AutoRubric-T2I: Robust Rule-Based Reward Model for Text-to-Image Alignment

Paper: arXiv:2605.17602 Code: johnsonkao0213/AutoRubric-T2I Code reference: main @ 4c0598ec (2026-05-21)

1. Motivation (研究动机)

当前 Text-to-Image (T2I) 对齐越来越依赖 image reward model：给定 prompt 和生成图像，reward model 输出标量分数或 pairwise preference，然后用于 best-of-N、数据过滤、自动评测或 RL fine-tuning。论文指出现有路线有两个核心问题。

第一类是 Bradley-Terry (BT) preference model，例如 ImageReward、PickScore、HPSv2/HPSv3、UnifiedReward。这类模型能吸收大规模人类偏好，但训练和更新成本高，而且把“对象数量是否正确、属性是否缺失、空间关系是否满足、文字是否可读、审美是否自然”等多个维度压成一个 scalar。这个 scalar 在下游优化时很容易变成黑盒目标：模型知道怎样把分数刷高，却不一定真的满足 prompt。

第二类是 VLM-as-a-judge 或 QA-style evaluator。它们可以在文本层面解释图像是否满足某个条件，天然更适合 fine-grained alignment；但如果 rubric 是人工写的或启发式生成的，rubric 本身未必和真实人类偏好一致。论文在 Table 1 中给了一个直接动机：raw pointwise Qwen3-VL-8B 在 MMRB2 overall 只有 26.5%，即使用 tie-adjusted 也只有 58.0；同一个模型改成 pairwise judge 是 59.4%。这说明“让 VLM 看图打分”本身不是充分条件，关键是要有能约束 VLM 判断的高质量规则。

本文要解决的问题是：能否不用重新训练一个 dense scalar reward model，而是从少量 preference pairs 中自动学习一组显式、可解释、可复用的 visual rubrics，并用它们指导 off-the-shelf VLM judge 形成稳定 reward。这个问题值得研究，因为它同时影响两件事：一是 reward benchmark 上的 preference prediction，二是 RL fine-tuning 里的 reward hacking。若 reward 可以拆成明确规则，研究者不只得到一个分数，还能知道图像为什么被奖励或惩罚。

Figure 1 解读：图中对比了 scalar HPSv3 reward 和 AutoRubric-T2I 的优化结果。HPSv3 可以把 scalar reward 推高，但生成图可能违反 prompt 的具体约束；AutoRubric-T2I 因为把 reward 分解成多条 rubric，能更明确地惩罚“高分但错约束”的样本。这是本文把 reward model 从黑盒标量改成显式规则集合的直接动机。

2. Idea (核心思想)

核心思想是：不要把人类偏好直接压缩成一个不可解释的 reward network，而是把偏好拆成一组自然语言 rubrics，再学习每条 rubric 对偏好判断的权重。AutoRubric-T2I 把 rubric 视为一个无限维特征空间中的 coordinate；每条 rubric 经 VLM judge 产生一个 yes-token probability，所有 rubric score 的加权和就是最终 reward。

关键创新有三点：第一，用少量 preference pairs 生成初始 rubric pool，而不是手工写规则；第二，用 ${\ell }_1$-regularized logistic regression 在候选规则中做 sparse selection，只保留 Top-$N$ 正权重规则；第三，通过 curriculum-bucketed hard-pair mining 找到当前规则集误判的样本，再让 VLM 根据失败案例补充新规则。

它和 HPSv3 / PickScore 的根本差异是 reward 形态不同：HPSv3 / PickScore 是训练好的 scalar reward model，优化时很难知道哪个维度出了问题；AutoRubric-T2I 是 weighted rubric set，reward 的每一项都对应一条可读规则。它和 AutoRule / AutoRubric 这类 rubric baseline 的差异是 rubric 不只是生成出来，而是经过偏好数据驱动的 sparse refiner、正权重约束、多轮 hard-pair evolution 和 cluster initialization 筛选。

3. Method (方法)

3.1 Overall framework：从 seed rubrics 到 weighted rubric reward

Figure 2 解读：AutoRubric-T2I 的流程分成三层。左侧先从少量偏好对中选 seed pairs，并用 VLM 生成初始 rubrics；中间每轮对候选 rubrics 做 VLM scoring，再用 sparse logistic regression 选出 Top-$N$；右侧对当前规则集误判的 hard pairs 做失败诊断，生成新 rubrics 并加入下一轮 working set。最终输出的是一组 (rubric, weight)，而不是一个新训练的 reward network。

直觉上，AutoRubric-T2I 的关键不是“让 VLM 多说几条规则”，而是把规则当成可学习的 reward feature。单条自然语言规则可能很噪：有的只关注审美，有的只关注空间关系，有的在某些 prompt 上有效、在另一些 prompt 上无效。${\ell }_1$ refiner 的作用是让偏好数据决定哪些规则有判别力；hard-pair mining 的作用是让下一轮规则专门补当前 reward 的盲点。这样得到的 reward 既比手写 rubric 更贴近偏好数据，又比 dense scalar RM 更可解释。

3.2 Rubric reward formulation

给定一条自然语言 rubric $r_j$、文本 prompt $x$ 和图像 $y$，VLM judge 输出图像是否满足规则的 yes-token probability： $s(r_j,x,y):=P_{\theta }(\mathrm{yes}\mid r_j,x,y),s(r_j,x,y)\in [0,1].$ 若选出的 rubric set 是 $\mathcal{R}=\{r_1,\dots ,r_N\}$，权重为 $w\in {\mathbb{R}}^N$，最终 prompt-image reward 是： $s_{\mathcal{R},w}(x,y):={\sum }_{j=1}^N{w}_{j}s(r_j,x,y).$ 训练数据为少量 preference pairs： ${\mathcal{D}}_{\mathrm{train}}=\{(x^{(i)},y_a^{(i)},y_b^{(i)},z^{(i)}){\}}_{i=1}^M,$ 其中 $z^{(i)}\in \{1,-1\}$ 表示人类偏好方向，默认 $M=256$。对每条 rubric 计算 pairwise score difference： $\Delta s_j^{(i)}=s(r_j,x^{(i)},y_a^{(i)})-s(r_j,x^{(i)},y_b^{(i)}).$ 论文将 rubric learning 写成 ${\ell }_1$-regularized logistic regression： ${\min }_w{\sum }_{i=1}^M\log \left(1+\exp \left(-z^{(i)}{\sum }_{j\in \mathcal{J}}{w}_j\Delta s_j^{(i)}\right)\right)+\lambda \Vert w{\Vert }_1.$ 这里 $\mathcal{J}$ 可以理解为所有可能自然语言 rubrics 的巨大空间。实际实现不能枚举这个空间，所以采用 working-set / coordinate-selection 思路：先有一个有限候选集合，拟合稀疏权重，再从 failure cases 生成新候选。

3.3 Seed data selection and initial rubric generation

默认训练只用 256 个 preference pairs。论文强调 seed pairs 不是随机抽样，而是 diversity-aware selection：同时考虑 prompt semantic diversity 和 proxy reward margin，避免初始 rubrics 只覆盖少数常见视觉问题。这个设计和 FiFA 类似：高 margin pairs 提供清晰偏好信号，prompt clustering 保证规则覆盖对象、属性、关系、文字、风格等多种 prompt 类型。

初始 rubric 生成采用 Gemini-3-Flash。流程分成两步：先让 vision reasoner 对每个 preference pair 产生 step-by-step rationale，解释 preferred image 为什么更符合 prompt；再从 rationale 中抽取客观、可复用、视觉可验证的 rubric。抽取出的规则不是针对单个 prompt 的一句评价，而应能迁移到其他 prompt-image pair。

Figure 7 解读：这个 prompt 模板让 VLM 先比较两张图和文本 prompt 的一致性，产生偏好理由。它对应“从偏好对中提取规则”的第一阶段：先有解释，再从解释中抽象规则。

Figure 8 解读：第二阶段把 preference rationale 转成 rule candidates，并通过 merger 去除重复或过细的规则。这样做是为了让后续 sparse refiner 面对的是相对干净的 rubric pool，而不是大量同义、冗余、只对单例有效的文本片段。

3.4 Working-set scoring and sparse selection

每一轮 refinement 中，对当前 working set ${\mathcal{R}}^t$ 的每条 rubric，VLM judge 都会在训练 preference pairs 上打分，形成 feature matrix。released code 中 autorubric_t2i/features.py 的 build_feature_matrix 明确实现为：每行一个 preference pair，每列一条 rule，特征是 score(image_a)-score(image_b)；label 是 pair 的偏好方向。

随后 autorubric_t2i/refiner.py 中 _fit_l1 调用 sklearn.linear_model.LogisticRegression(penalty='l1', solver='liblinear', C=1.0, fit_intercept=False, random_state=42)。_retain_top_n 只保留 weight > 1e-4 的正权重，并按权重降序取 Top-$N$；代码默认 TOP_N=25、NUM_ROUNDS=10、HARD_PAIRS_PER_ROUND=16。这和论文的“positive-only weights”一致：满足一条 rubric 应该单调增加 reward，否则负权重会让解释变得反直觉。

论文公式与 released code 实现差异：论文把 label 写成 $z\in \{1,-1\}$ 的 logistic loss；released code 用 sklearn.LogisticRegression 的二分类 label 表示，并通过 fit_intercept=False、penalty='l1'、C=1.0 实现稀疏线性分类。两者目标等价于用 rubric-score differences 做 preference classification，但正则强度在代码里表现为 C=1.0 而不是显式 $\lambda$。

Figure 12 解读：这是 Qwen3-VL-8B 在 HPSv3 source preferences 上学到的优化后 rubric set。可以看到规则集中既有 prompt alignment 维度，也有视觉质量、对象完整性、空间/属性一致性等维度；这些规则就是 sparse refiner 保留下来的 reward coordinates。

Figure 13 解读：PickScore source preferences 学到的规则与 HPSv3 有重叠，但权重和侧重点不同。这说明 AutoRubric-T2I 不是固定模板，而是能随 source preference corpus 迁移：不同偏好数据会选择不同 visual criteria。

Figure 14 解读：更大的 VLM judge 也会得到类似但不完全相同的规则组合。它说明 rubric learning 同时依赖偏好数据和 judge 能力；同一套 learning pipeline 可以套在不同 VLM 上。

Figure 15 解读：Qwen3-VL-32B + PickScore 的规则集中，许多规则更强调综合质量和 text-image correspondence。与 Figure 12/13 对比可以看出，AutoRubric-T2I 的输出是“模型能力 × source preference corpus”的结果，而不是单一固定 rubric taxonomy。

3.5 Curriculum-bucketed hard-pair mining

仅靠初始 rules 做一次 sparse selection 仍可能漏掉困难错误。AutoRubric-T2I 因此在每轮验证后挖掘当前规则集 misrank 的 hard pairs。released code autorubric_t2i/hard_pairs.py 将错误样本分成三类：

• wrong_small：当前 reward 排错但 margin 小，代表边界附近的细粒度错误；
• wrong_large：排错且 margin 大，代表规则集明显缺失某个关键维度；
• high_reward_wrong：当前 reward 对错误样本也给高分，代表最危险的 reward hacking 形态。

curriculum 随轮次变化：前两轮采样比例是 (0.6, 0.4, 0.0)，中间轮次是 (0.5, 0.3, 0.2)，最后阶段是 (0.3, 0.3, 0.4)。也就是说，早期先修正大方向和边界错误，后期增加 high-reward wrong，专门攻击“看起来高分但人类不喜欢”的漏洞。

Figure 10 解读：hard-pair prompt 会把当前 retained rules 和误判图像对一起交给 VLM，让它诊断“为什么当前规则不能解释人类偏好”。这一步不是重新生成所有规则，而是只针对失败模式补规则，因此比盲目扩大 rule pool 更高效。

3.6 VLM-driven rule generation from failures

released code autorubric_t2i/rule_gen.py 中 RuleGenerator 使用 Gemini API：_diagnose 先上传 image A/B，并构造 failure diagnosis prompt；_extract 再把 diagnosis 转成 rule list；generate 对 hard pairs 并行运行两步 pipeline，最后去重。默认 generation 配置是 temperature=0.1、thinking_budget=1024、concurrency=8，config.py 中 GEMINI_MODEL='gemini-3-flash-preview'。

这个设计的工程含义是：AutoRubric-T2I 不是一次性 prompt engineering，而是一个闭环。当前规则集在哪些 pair 上失败，下一轮就把这些失败转成新的候选规则；${\ell }_1$ refiner 再决定这些新规则是否真的有判别力。

Figure 9 解读：VLM judge 模板将每条 rubric 转成 Yes/No 问题，再读取 yes-token probability。这样每条 rule 都变成一个数值 feature，既能用于 logistic regression，也能在 RL 中作为 weighted reward term。

3.7 Downstream RL reward integration

在下游 T2I RL 中，论文不改变 Flow-GRPO 的主体算法，只替换 reward。给定最终规则集 ${\mathcal{R}}^{\mathrm{final}}=\{({\rho }_j,w_j){\}}_{j=1}^N$，对每个 rollout 图像 $x$ 和 prompt $p$，VLM judge 计算： $p_j(x,p)=P_{\mathrm{VLM}}(\mathrm{YES}\mid x,p,{\rho }_j),$ 送入 Flow-GRPO 的 reward 是： $r_{\mathrm{AutoRubric}}(x,p)={\sum }_{j=1}^N{w}_j{p}_j(x,p).$ 论文强调这些 $w_j$ 就是 256 个 preference pairs 上拟合出的 ${\ell }_1$ logistic regression coefficients，RL 阶段不再重调。因为 $p_j\in [0,1]$ 且权重为正，reward 保持可解释：每个维度都能追溯到一条自然语言规则。

论文公式与 released code 实现差异：released GitHub repo 主要包含 rubric refinement / evaluation 代码，没有包含论文中 SD-3.5-Medium + Flow-GRPO 的完整训练 launcher；因此 RL 训练超参来自论文 Appendix Table 5，而不是 repo 中的可执行训练配置。repo 中 run_evaluation.py 对 weighted scores 做了除以 weight_sum 的归一化；论文 Eq. (4) 写成未归一化 weighted sum。两者在 pairwise ranking 上通常只差一个正比例缩放，但在 RL reward scale 上可能影响 KL / advantage 标度，复现时需要确认使用哪一版。

3.8 Pseudocode（基于 released code）

import numpy as np
from sklearn.linear_model import LogisticRegression
 
WEIGHT_THRESHOLD = 1e-4
TOP_N = 25
 
def fit_l1_refiner(vlm_results, train_pairs, rules):
    X = np.empty((len(train_pairs), len(rules)), dtype=np.float64)
    y = np.empty(len(train_pairs), dtype=np.int64)
    for i, pair in enumerate(train_pairs):
        for j, rule in enumerate(rules):
            score_a = vlm_results[(rule, pair.img_a, pair.prompt)] or 0.0
            score_b = vlm_results[(rule, pair.img_b, pair.prompt)] or 0.0
            X[i, j] = score_a - score_b
        y[i] = pair.label
 
    model = LogisticRegression(
        penalty="l1", solver="liblinear", C=1.0,
        fit_intercept=False, random_state=42,
    )
    model.fit(X, y)
    weights = model.coef_[0]
    retained = [(rules[j], float(weights[j])) for j in range(len(rules))
                if weights[j] > WEIGHT_THRESHOLD]
    retained.sort(key=lambda item: -item[1])
    return retained[:TOP_N]

def select_hard_pairs(pair_stats, round_id, total_rounds, k=16):
    margin_threshold = np.quantile([s.margin for s in pair_stats], 0.3)
    reward_threshold = np.quantile([s.min_score for s in pair_stats], 0.7)
    wrong = [s for s in pair_stats if s.misrank == 1]
    high_reward_wrong = [s for s in wrong if s.min_score >= reward_threshold]
    rest = [s for s in wrong if s not in high_reward_wrong]
    wrong_small = [s for s in rest if s.margin <= margin_threshold]
    wrong_large = [s for s in rest if s.margin > margin_threshold]
 
    if round_id < 3:
        weights = (0.6, 0.4, 0.0)
    elif round_id < total_rounds - 1:
        weights = (0.5, 0.3, 0.2)
    else:
        weights = (0.3, 0.3, 0.4)
 
    selected = []
    selected += sorted(wrong_small, key=lambda s: s.margin)[:int(k * weights[0])]
    selected += sorted(wrong_large, key=lambda s: -s.margin)[:int(k * weights[1])]
    selected += sorted(high_reward_wrong, key=lambda s: s.margin)[:int(k * weights[2])]
    remaining = sorted(pair_stats, key=lambda s: (-s.misrank, s.margin))
    return (selected + [s for s in remaining if s not in selected])[:k]

async def refine_autorubric(provider, train_pairs, val_pairs, seed_rules, rule_generator,
                            num_rounds=10, top_n=25, hard_pairs_per_round=16):
    all_rules = list(seed_rules)
    best_rules, best_acc = [], -1.0
    for round_id in range(1, num_rounds + 1):
        train_results = await score_with_vlm(provider, train_pairs, all_rules)
        top_rules = fit_l1_refiner(train_results, train_pairs, all_rules)[:top_n]
        retained_rules = [r for r, w in top_rules]
        retained_weights = [w for r, w in top_rules]
 
        val_results = await score_with_vlm(provider, val_pairs, retained_rules)
        acc = validate_pairwise_accuracy(val_results, val_pairs, retained_rules, retained_weights)
        if acc > best_acc:
            best_acc, best_rules = acc, top_rules
 
        if round_id == num_rounds:
            break
        stats = compute_pair_stats(train_results, train_pairs, retained_rules, retained_weights)
        hard_pairs = select_hard_pairs(stats, round_id, num_rounds, hard_pairs_per_round)
        new_rules = await rule_generator.generate(hard_pairs, retained_rules)
        all_rules = retained_rules + [r for r in new_rules if r not in retained_rules]
    return best_rules

Code reference: main @ 4c0598ec (2026-05-21) — pseudocode and mapping based on this commit

Paper Concept	Source File	Key Class/Function
VLM yes-token rubric score	config.py; judge/; autorubric_t2i/features.py	VLLM_MODEL='Qwen3-VL-8B-Instruct'; build_feature_matrix; _score
${\ell }_1$ sparse refiner	autorubric_t2i/refiner.py	_fit_l1; _retain_top_n; TOP_N=25; NUM_ROUNDS=10
Pairwise feature construction	autorubric_t2i/features.py	build_feature_matrix; weighted_scores
Curriculum hard-pair mining	autorubric_t2i/hard_pairs.py	_curriculum_weights; select_hard_pairs; MARGIN_PERCENTILE=0.3
Failure-case rule generation	autorubric_t2i/rule_gen.py	RuleGenerator._diagnose; RuleGenerator._extract; RuleGenerator.generate
End-to-end refinement CLI	run_refiner.py	--rounds; --top-n; --hard-pairs; output top_rules.csv
Preference benchmark evaluation	run_evaluation.py	load_rules; weighted scoring; accuracy reporting
Downstream Flow-GRPO RL	论文 Appendix B / Table 5	released repo 未包含完整 RL launcher；需按论文超参接入 Flow-GRPO

4. Experimental Setup (实验设置)

4.1 Models and baselines

VLM judges 包括 Qwen3-VL-8B、Qwen3-VL-32B 和 Gemini-3-Flash。baseline 覆盖四类：CLIP-based / scalar reward models（CLIPScore、ImageReward、PickScore、HPSv2）、fine-tuned VLM reward models（HPSv3、UnifiedReward on Qwen2.5-VL-7B）、zero-shot VLM judges（pairwise 和 pointwise 两种模式）、rubric-based baselines（AutoRule、AutoRubric）。rubric generation 统一使用 Gemini-3-Flash 生成 reasoning chains。

4.2 Datasets and benchmark scale

• Preference source corpora：HPSv3 / HPDv3 和 PickScore，用于学习 rubrics；默认只选 256 个 seed preference pairs。
• Preference evaluation：PickScore official test 12,864 pairs；HPDv3 official test 34,344 pairs；MMRB2 T2I subtask 1,000 expert-annotated preference pairs。
• Out-of-domain reward benchmark：MMRB2，包括 EvalMuse、OneIG-Bench、R2I-Bench、RealUnify、WISE 等来源。
• Downstream T2I RL evaluation：TIIF 和 UniGenBench++，都报告 short / long prompt variants。

4.3 Metrics

Preference benchmark 使用 accuracy；Table 1 同时报告 raw win accuracy 和括号中的 tie-adjusted score，后者定义为 $(\#\mathrm{wins}+0.5\times \#\mathrm{ties})/\#\mathrm{total}$。下游 TIIF / UniGenBench++ 报告各类别 percentage score 和 Overall。

4.4 Training and implementation config

AutoRubric-T2I pipeline 的关键超参来自论文 Appendix F 和 released code：VLM judge 是 Qwen3-VL-8B-Instruct via vLLM；rule generator 是 Gemini-3-Flash；默认 TOP_N=25、NUM_ROUNDS=10、HARD_PAIRS_PER_ROUND=16、MAX_HARD_PAIR_REPEAT=4、MARGIN_PERCENTILE=0.3、REWARD_QUANTILE=0.7、VLLM_MAX_CONCURRENT=128、VLLM_TOP_LOGPROBS=5。

下游 RL 使用 SD-3.5-Medium + Flow-GRPO。论文 Table 5 报告：LoRA rank/alpha、optimizer、learning rate、group size $K=24$、effective prompt batch、EMA 和 eval cadence 采用 Flow-GRPO defaults；训练运行在 $1\times 8$ H200 GPUs；reported steps 为 100–500；每 25 steps 保存并评估；PPO mask timestep fraction 为 0.99；KL $\beta =0.01$；inner epochs 为 1；EMA on policy weights 为 yes。由于 released repo 没有完整 RL launcher，这些 RL 训练数字应以论文 Appendix / Table 5 为准。

5. Experimental Results (实验结果)

5.1 Preference benchmark：rubric 让 pointwise VLM 更可靠

Table 1 的关键结论是：raw pointwise VLM judge 很弱，但学到的 rubrics 能显著改善它。Qwen3-VL-8B pointwise 在 MMRB2 overall 只有 26.5%（tie-adjusted 58.0），pairwise Qwen3-VL-8B 是 59.4%。AutoRubric-T2I 加到 Qwen3-VL-8B pointwise 后，HPSv3-source rubrics 达到 MMRB2 overall 62.5%、PickScore 61.7%、HPSv3 63.9；PickScore-source rubrics 达到 MMRB2 overall 62.4%、PickScore 63.2%、HPSv3 61.5。

更强 judge 上收益继续存在：Qwen3-VL-32B + AutoRubric-T2I (PickScore) 达到 MMRB2 overall 67.7、PickScore 64.9、HPSv3 62.5；Gemini-3-Flash + AutoRubric-T2I (PickScore) 达到 MMRB2 overall 71.4、PickScore 70.3、HPSv3 66.8。作为对比，fine-tuned scalar RM 中 HPSv3 的 MMRB2 overall 是 59.4，UnifiedReward 是 59.8。说明 AutoRubric-T2I 在 OOD preference benchmark 上不仅超过手写/启发式 rubric baseline，也能超过强 scalar RM baseline。

5.2 Downstream RL：AutoRubric reward 改善 TIIF / UniGenBench++

在 TIIF 上，AutoRubric-T2I (HPSv3) 将 SD-3.5-Medium short prompt overall 从 65.3 提升到 71.6，long prompt overall 从 62.7 提升到 67.9。PickScore-source rubrics 下，AutoRubric-T2I short / long overall 分别达到 70.8 / 69.0，均优于 PickScore scalar reward 和 AutoRule。

在 UniGenBench++ 上，AutoRubric-T2I (HPSv3) 将 base model short overall 从 61.0 提升到 62.7，long overall 从 64.0 提升到 66.9；AutoRubric-T2I (PickScore) short / long overall 分别达到 62.4 / 67.7。论文强调提升尤其集中在 relation、compound reasoning、layout、text rendering 等细粒度类别，这些正是 scalar reward 容易混在一个分数里忽略的维度。

Figure 3 解读：训练曲线展示了 scalar reward 与 rubric reward 的优化动态差异。scalar reward 可能随着 RL 上升，但这不保证真实 prompt alignment 同步提升；AutoRubric-T2I 把 reward 拆成多个规则维度，使训练信号更稳定，也更容易发现哪个维度在退化。

Figure 4 解读：图中展示 RL 过程中生成质量演化。scalar reward 优化会出现视觉质量下降或 prompt-specific constraint 被破坏的情况；AutoRubric-T2I 因为对对象、关系、属性、文本等维度分别打分，能降低单一 reward 被“刷分”的风险。

5.3 Ablation：每个 refinement 组件都有贡献

Table 4 从 AutoRule 出发逐步加组件。Qwen3-VL-8B on HPSv3：AutoRule 的 MMRB2 是 59.1；加 negative weights 的 L1 refiner 几乎不变（59.2）；改成 positive-only weights 到 60.1；multi-round random pairs 到 60.3；hard-pair evolution 到 61.3；cluster initialization 最终到 62.5。Qwen3-VL-8B on PickScore：AutoRule 的 MMRB2 是 56.4；最终 cluster initialization 到 62.4。

这组 ablation 支持两个结论。第一，${\ell }_1$ 选择本身不够，负权重会让规则解释反直觉；positive-only 是必要约束。第二，multi-round refinement 必须配合 hard-pair mining，随机 pair 的收益有限；真正有用的是让当前规则集的失败样本驱动下一轮规则发现。

5.4 Qualitative and human evaluation

Figure 5 解读：case study 对比 base model、scalar reward optimization、AutoRule 和 AutoRubric-T2I。AutoRubric-T2I 更能保留 prompt 中要求的对象、关系和场景结构；scalar reward 或 generic rubric reward 则可能出现画面看似漂亮但约束不满足的问题。

Figure 6 解读：human evaluation 用人类偏好验证 RL 后 policy 的输出质量。图中的比较说明 AutoRubric-T2I 优化后的图像更常被人类选择，尤其是在需要多约束组合、空间/属性一致性和文本生成的 prompt 上。

Figure S 解读：附录案例补充了更多 prompt 和生成图像对比。它的意义不是展示单个 cherry-pick，而是说明 learned rubrics 在多类 prompt 上提供一致约束：对象数量、属性、布局、风格、文本细节都能被拆成可检查条件。

5.5 Limitations and caveats（limitations）

论文没有把 AutoRubric-T2I 描述成完全替代 reward model 的方案。主要限制有三点：第一，rubric quality 依赖 VLM judge 和 rule generator 的能力，若 VLM 对某类视觉错误本身看不出来，规则学习也会受限。第二，VLM scoring 在 RL 中会被频繁调用，计算成本比一个轻量 scalar reward head 更高。第三，released code 当前覆盖 rubric refinement / evaluation，但未公开完整 SD-3.5-Medium + Flow-GRPO 训练 launcher；复现下游 RL 时需要自行接入 reward function 并确认 reward scaling。

总体结论是：AutoRubric-T2I 证明了 T2I alignment reward 可以从“训练一个黑盒标量模型”转向“学习一组可解释规则及其权重”。在偏好评测上，它把 pointwise VLM judge 变成更可靠的 reward model；在 RL 上，它降低 scalar reward hacking，并在 TIIF / UniGenBench++ 上带来更稳定的 prompt alignment 提升。