AdapFair：基于最优传输与归一化流的黑盒模型公平性数据预处理框架

1. 项目概述与核心价值

在机器学习模型日益渗透到信贷审批、招聘筛选、司法风险评估等关键决策领域的今天，一个无法回避的挑战是：模型预测是否会因为个体的种族、性别、年龄等敏感属性而产生系统性偏差？这就是公平机器学习要解决的核心问题。传统的公平性干预手段，无论是修改模型内部结构（In-processing）、还是对模型输出进行后处理（Post-processing），都存在明显的局限性。前者需要访问并重训练模型，成本高昂且不适用于预训练的黑盒模型；后者则往往以牺牲模型在原始任务上的性能为代价。

我最近在复现和优化一个名为AdapFair的框架时，深感其设计思路的巧妙。它本质上是一个数据预处理框架，其核心思想是：与其费力地修改一个已经训练好的、可能非常复杂的分类器（比如一个百亿参数的大模型），不如在数据“喂”给分类器之前，先对它做一次“公平化整形”。这个框架将最优传输理论与归一化流这两种强大的数学工具结合了起来。最优传输负责精确地度量并最小化不同群体（例如男性和女性）预测结果分布之间的差异，而归一化流则充当了一个“可编程的数据变形器”，它能以一种可逆、可微的方式对输入数据进行变换，从而引导分类器输出更公平的结果。

最吸引我的地方在于它的“非侵入性”。你可以把它想象成一个适配器，一端连接着你的原始数据，另一端连接着那个你既不想也不能动的黑盒分类器（比如一个云服务提供的API，或者一个内部遗留的复杂系统）。通过训练这个适配器，你可以在不触碰分类器内部任何参数的情况下，显著提升其预测的公平性。这对于处理数据漂移（例如，模型训练在加州数据上，却要部署在纽约）或应对动态变化的公平性法规（今天要求满足“机会均等”，明天可能要求“统计平等”）的场景，价值巨大。接下来，我将深入拆解这个框架的每一个技术环节，并分享在复现过程中积累的实操经验和避坑指南。

2. 技术原理深度拆解：为什么是“最优传输”+“归一化流”？

要理解AdapFair，必须吃透它背后的两大支柱：最优传输用于定义和优化“公平”，归一化流用于实现可微的数据变换。我们分开来看。

2.1 最优传输：公平性的“度量衡”与“优化器”

在公平机器学习中，我们常说的“不同群体间预测结果应该相似”，本质上是在要求两个概率分布（比如群体A的预测分数分布和群体B的预测分数分布）尽可能接近。那么，如何量化两个分布的“距离”或“差异”呢？

常见的选择有KL散度、JS散度等，但它们对于分布形态的细微变化可能不敏感。而Wasserstein距离（又称推土机距离）来自最优传输理论，它衡量的是将一个分布“搬运”成另一个分布所需的最小“工作量”。这个“工作量”由我们定义的“成本矩阵”决定。在公平性语境下，这个“成本”可以理解为将一个群体的某个预测分数“调整”到另一个群体的某个预测分数所需的代价。

Wasserstein距离的数学形式化：假设我们有敏感属性为0的群体，其分类器输出（如正类概率）的分布为 ( p_{R_0} )，敏感属性为1的群体对应分布为 ( p_{R_1} )。它们被离散化为概率向量a和b。两个分布中样本点之间的“搬运成本”由成本矩阵M定义（例如，( M_{ij} ) 可以是两个输出分数 ( r_0^i ) 和 ( r_1^j ) 之差的平方）。那么，Wasserstein距离 ( W(p_{R_0}, p_{R_1}) ) 就是求解一个最优传输计划P（一个非负矩阵，其行和等于a，列和等于b），使得总成本 ( \langle P, M \rangle ) 最小。

然而，直接求解Wasserstein距离在计算上是昂贵的。AdapFair采用了Sharp Sinkhorn近似。Sinkhorn算法通过引入一个熵正则项，将问题转化为一个可以通过迭代矩阵缩放快速求解的平滑问题。而“Sharp”版本通过一个技巧（固定最后一个对偶变量）确保了近似解在正则化系数 ( \epsilon ) 很大时，依然能快速、精确地收敛到真实的Wasserstein距离。在代码中，这通常对应一个几十行的高效迭代过程。

实操心得：成本矩阵M的设计成本矩阵M的定义直接影响公平性的优化方向。最直接的方式是使用预测分数差的平方：( M_{ij} = (r_0^i - r_1^j)^2 )。但在实际编码中，需要确保r0和r1是经过分类器f和预处理变换T0,T1后的输出，并且计算图是可微的，这样才能将梯度从公平性损失项回传到预处理器的参数。我通常会先实现一个不依赖梯度的验证版本，确保Wasserstein距离计算正确，再将其嵌入到自动微分框架中。

2.2 归一化流：可逆、可微的“数据整形器”

有了衡量公平性的“尺子”（Wasserstein距离），我们还需要一个能改变数据分布、且能被这把“尺子”度量的“工具”。这就是归一化流。

归一化流是一类特殊的神经网络，它学习一个从简单先验分布（如标准正态分布）到复杂数据分布之间的可逆、可微的双射变换。这意味着，给定一个输入x，流网络T(x; θ)可以将其映射到一个潜变量z，并且这个映射的逆变换T^{-1}(z; θ)和雅可比行列式（用于概率密度计算）都可以高效求得。

在AdapFair中，我们为每个敏感属性群体s配备一个独立的归一化流预处理器 ( T_s )。它的作用不是改变数据标签，而是对输入特征空间进行一个保测度的扭曲。想象一下，分类器f是一个固定的函数（地形），不同群体的数据点原本落在这个地形上不同位置，导致了不公平的输出分布。归一化流 ( T_s ) 的作用，就是分别对每个群体的数据点进行“平移”和“拉伸”，使得它们经过f映射后，在输出空间（预测分数）上的分布变得一致。

为什么必须是可逆的？可逆性保证了变换是保测度的，即变换前后数据的概率密度变化是明确且可计算的。这对于稳定训练和理论分析至关重要。常用的流结构包括RealNVP、Glow等，它们通过耦合层（Coupling Layer）等设计来保证可逆性和高效计算。

工程上的关键点：我们需要训练的是 ( T_s ) 的参数 ( θ_s )，而分类器f的参数是冻结的。损失函数是分类准确率损失（如交叉熵）和公平性损失（Sharp Sinkhorn近似）的加权和： [ L = \lambda L_{clf}(Y, f(T_s(X_s))) + (1-\lambda) S_\epsilon(M, a, b) ] 通过链式法则，梯度可以穿过固定的分类器f，传递到预处理器的参数 ( θ_s ) 上。论文中的定理1给出了这个梯度 ( \nabla_{\theta_s} L ) 的解析形式，这是实现高效训练的核心。

3. 框架实现与核心环节实操

理解了原理，我们来看如何将其实现。AdapFair的实现可以分为几个核心模块：数据与预处理流定义、损失函数构建（含Sharp Sinkhorn计算）、梯度计算与反向传播、以及最终的训练循环。

3.1 环境准备与依赖

首先，你需要一个支持自动微分和GPU计算的深度学习框架。PyTorch是首选，因为其对自定义梯度操作和动态图的支持非常灵活。

# 核心依赖 pip install torch torchvision pip install numpy pandas scikit-learn # 可选，用于更复杂的流结构或可视化 pip install nflows matplotlib seaborn

对于数据集，论文中使用了Communities & Crime、Law School等。你需要从UCI等仓库下载并完成预处理，包括处理缺失值、数值化分类变量、标准化特征，以及明确指定敏感属性（如‘race’）和预测目标。

3.2 构建归一化流预处理器

我们以RealNVP为例，构建一个简单的流网络。关键在于实现耦合层，它将输入x分割为两部分x1, x2，然后以可逆的方式对x2进行变换，其参数由x1通过一个神经网络（尺度网络s和平移网络t）生成。

import torch import torch.nn as nn class CouplingLayer(nn.Module): def __init__(self, dim, hidden_dim): super().__init__() self.scale_net = nn.Sequential( nn.Linear(dim // 2, hidden_dim), nn.ReLU(), nn.Linear(hidden_dim, dim // 2), nn.Tanh() # 使用Tanh限制尺度变化范围，增强稳定性 ) self.translate_net = nn.Sequential( nn.Linear(dim // 2, hidden_dim), nn.ReLU(), nn.Linear(hidden_dim, dim // 2) ) def forward(self, x, reverse=False): x1, x2 = x.chunk(2, dim=1) if not reverse: s = self.scale_net(x1) t = self.translate_net(x1) y2 = x2 * torch.exp(s) + t y1 = x1 log_det_jacobian = s.sum(dim=1) # 对数雅可比行列式 return torch.cat([y1, y2], dim=1), log_det_jacobian else: s = self.scale_net(x1) t = self.translate_net(x1) x2 = (x2 - t) * torch.exp(-s) return torch.cat([x1, x2], dim=1) class RealNVPPreprocessor(nn.Module): def __init__(self, dim, num_layers, hidden_dim): super().__init__() self.layers = nn.ModuleList([ CouplingLayer(dim, hidden_dim) for _ in range(num_layers) ]) # 添加随机排列层，增强表达能力 self.permute = nn.ModuleList([ nn.Linear(dim, dim) for _ in range(num_layers - 1) ]) def forward(self, x, reverse=False): log_det = 0 if not reverse: for i, layer in enumerate(self.layers): x, ldj = layer(x) log_det += ldj if i < len(self.layers) - 1: x = self.permute[i](x) # 简单的线性排列，实践中可用固定排列 return x, log_det else: for i, layer in enumerate(reversed(self.layers)): if i > 0: x = self.permute[len(self.layers)-1-i](x) x = layer(x, reverse=True) return x

注意事项：流网络的初始化与稳定性流网络的初始化至关重要。如果尺度网络s的初始输出过大，torch.exp(s)会导致数值溢出。因此，通常将最后一个激活函数设为Tanh，并将权重初始化得较小。在训练初期，建议监控雅可比行列式的值，确保其不会爆炸或消失。一个稳定的流，其对数雅可比行列式的值应该在零附近小幅波动。

3.3 实现Sharp Sinkhorn近似与损失函数

这是框架中最数学密集的部分。我们需要实现公式(6)-(8)中的前向计算，以及定理1中的梯度计算。为了清晰，我们分步实现。

def compute_sinkhorn(M, a, b, epsilon=1.0, max_iter=1000, stop_thresh=1e-9): """ 计算Sharp Sinkhorn近似。 M: 成本矩阵，形状 (n0, n1) a, b: 概率向量，形状 (n0,) 和 (n1,)，且和为1 epsilon: 正则化系数 返回: P_star (最优传输计划), alpha_star, beta_star """ n0, n1 = M.shape # 初始化对偶变量beta，固定最后一个为0 (Sharp技巧) beta = torch.zeros(n1, device=M.device) # beta的最后一个元素固定为0，因此我们优化前n1-1个 beta_active = beta[:-1] # 形状 (n1-1,) # 使用L-BFGS优化关于beta的损失 L_beta(beta) # 这里为简化，展示核心迭代逻辑，实际需用torch.optim.LBFGS K = torch.exp(-M / epsilon) # Gibbs核 u = torch.ones(n0, device=M.device) / n0 # 辅助变量 for it in range(max_iter): # 固定beta，更新alpha (公式6) # 注意：为了数值稳定性，实际计算使用log-sum-exp # alpha_star_i = (1/epsilon) * log(a_i) - (1/epsilon) * log(sum_j exp(epsilon*(beta_j - M_ij))) log_alpha = torch.log(a) - torch.logsumexp(epsilon * (beta.unsqueeze(0) - M), dim=1) alpha = log_alpha / epsilon # 固定alpha，更新传输计划P (公式中的P(beta)) # P = exp(epsilon * (alpha.unsqueeze(1) + beta.unsqueeze(0) - M)) log_P = epsilon * (alpha.unsqueeze(1) + beta.unsqueeze(0) - M) P = torch.exp(log_P) # 检查边际约束收敛性 margin_a = P.sum(dim=1) margin_b = P.sum(dim=0) err = torch.norm(margin_a - a, p=1) + torch.norm(margin_b - b, p=1) if err < stop_thresh: break # 更新beta (通过梯度下降，实际使用公式8的梯度) # 这里简化，实际应按照论文用L-BFGS优化L_beta # grad_beta = P[:, :-1].sum(dim=0) - b[:-1] (公式8) grad_beta_active = P[:, :-1].sum(dim=0) - b[:-1] # ... L-BFGS更新步骤 ... P_star = P.detach() alpha_star = alpha.detach() beta_star = beta.detach() return P_star, alpha_star, beta_star def fairness_loss(r0, r1, a, b, epsilon=0.1): """ 计算基于Sharp Sinkhorn近似的公平性损失。 r0, r1: 群体0和1的模型输出（如logits或概率），形状分别为 (n0, 1) 和 (n1, 1) a, b: 经验分布权重，通常设为均匀分布 1/n0 和 1/n1 """ # 1. 计算成本矩阵 M = (r0_i - r1_j)^2 M = (r0.unsqueeze(1) - r1.unsqueeze(0)).pow(2) # 形状 (n0, n1) # 2. 计算Sharp Sinkhorn近似 P_star, alpha_star, beta_star = compute_sinkhorn(M, a, b, epsilon) # 3. 计算损失 S_epsilon (公式7的负值，见论文) # L_beta(beta) = -alpha*^T a - beta*^T b + <P*, M> loss_s = -torch.dot(alpha_star, a) - torch.dot(beta_star, b) + torch.sum(P_star * M) # 注意：论文中L_beta是负的损失，所以这里S_epsilon可能就是loss_s，具体符号需对照论文公式 # 我们最终需要最小化这个损失 return loss_s

避坑指南：数值稳定性计算logsumexp和torch.exp(log_P)时极易出现数值溢出（得到inf）或下溢（得到0）。务必使用torch.logsumexp函数，并在计算log_P时考虑减去最大值进行归一化。例如：log_P = epsilon * (alpha.unsqueeze(1) + beta.unsqueeze(0) - M)max_log_P = log_P.max(dim=1, keepdim=True).values.max(dim=0, keepdim=True).values# 全局最大值log_P_stable = log_P - max_log_PP = torch.exp(log_P_stable)同时，epsilon的选择很重要，太大会导致exp爆炸，太小则近似误差大。从1.0开始调试是常见的做法。

3.4 整合训练循环与梯度回传

现在，我们将分类器损失和公平性损失结合起来，并按照定理1计算梯度来更新预处理器的参数。这里的关键是，分类器f被视为一个黑盒，我们只需要它的前向输出r和关于其输入的梯度∂r/∂x（这可以通过PyTorch的自动微分获得，即使f不可训练）。

def train_adapfair(preprocessor0, preprocessor1, classifier, dataloader0, dataloader1, optimizer, lambda_clf=0.7, epsilon_fair=0.1, epochs=100): """ 训练AdapFair预处理器的简化训练循环。 classifier: 预训练好的黑盒分类器，其参数被冻结。 """ classifier.eval() # 分类器始终处于评估模式 for epoch in range(epochs): # 假设dataloader0/1每次提供一个批次的全部数据（用于计算分布） # 在实际中，可能需要累积一个epoch的数据或使用整个训练集计算公平性损失 data0, labels0, sens0 = next(iter(dataloader0)) data1, labels1, sens1 = next(iter(dataloader1)) # 1. 前向传播：通过预处理器和分类器 trans_data0, _ = preprocessor0(data0) # 忽略log_det，因为我们不优化似然 trans_data1, _ = preprocessor1(data1) # 黑盒分类器前向传播。确保requires_grad=True以计算梯度。 r0 = classifier(trans_data0) # 形状 (batch0, 1) 或 (batch0, n_classes) r1 = classifier(trans_data1) # 形状 (batch1, 1) # 2. 计算损失 # 分类损失（例如二分类交叉熵） loss_clf = F.binary_cross_entropy_with_logits(r0, labels0) + F.binary_cross_entropy_with_logits(r1, labels1) loss_clf = loss_clf / 2 # 平均 # 公平性损失 # 构造经验分布权重a和b（均匀分布） a = torch.ones(data0.size(0), device=data0.device) / data0.size(0) b = torch.ones(data1.size(0), device=data1.device) / data1.size(0) loss_fair = fairness_loss(r0, r1, a, b, epsilon_fair) # 总损失 total_loss = lambda_clf * loss_clf + (1 - lambda_clf) * loss_fair # 3. 反向传播与优化 optimizer.zero_grad() total_loss.backward() # 梯度将通过r0, r1回传到trans_data0/1，再回到preprocessor0/1的参数 optimizer.step() if epoch % 10 == 0: print(f"Epoch {epoch}, LossClf: {loss_clf.item():.4f}, LossFair: {loss_fair.item():.4f}, Total: {total_loss.item():.4f}")

核心技巧：处理黑盒分类器的梯度虽然分类器参数被冻结，但为了计算∂r/∂x（即r0和r1关于预处理后数据trans_data的梯度），我们必须让trans_data的requires_grad=True，并且在对classifier进行前向传播时，确保其处于torch.no_grad()上下文之外。PyTorch的自动微分会计算从total_loss到trans_data的梯度，然后继续反向传播到预处理器的参数。这就是“通过”黑盒分类器进行梯度传递。

4. 关键问题排查与调优经验

在实际复现和应用AdapFair框架时，我遇到了几个典型问题，以下是排查思路和解决方案。

4.1 训练不稳定或梯度爆炸/消失

这是最常见的问题，根源往往在于归一化流或Sinkhorn计算中的数值问题。

• 症状：损失函数变成NaN，或者梯度范数极大。
• 排查步骤：
  1. 隔离测试流网络：单独测试流网络的前向和反向传播，输入随机数据，检查输出和雅可比行列式是否在合理范围。确保耦合层中的exp(s)不会爆炸（s的值最好在[-2, 2]区间内）。
  2. 检查Sinkhorn迭代：在compute_sinkhorn函数中，每一步都打印P矩阵的最小值、最大值和总和。确保没有NaN或inf。使用双精度（torch.double）进行调试有时能暴露单精度下的问题。
  3. 梯度裁剪：在优化器步骤之前，对预处理器的梯度进行裁剪torch.nn.utils.clip_grad_norm_(preprocessor.parameters(), max_norm=1.0)。这是一个简单有效的稳定化技巧。
  4. 调整损失权重λ和正则化系数ε：λ控制准确率和公平性的权衡。如果训练初期公平性损失loss_fair远大于loss_clf，会导致优化方向被公平性主导，可能破坏已有的分类性能。可以从较大的λ（如0.9）开始，逐渐减小。ε是Sinkhorn的正则化系数，增大ε会使计算更稳定但近似误差增大，反之亦然。从ε=1.0开始调试。

4.2 公平性提升不明显，或准确率下降过多

这涉及到公平性与准确性的根本权衡，以及模型是否学到了有效的变换。

• 症状：∆DP或∆EOpp下降有限，但准确率（Accuracy）大幅下跌。
• 排查与调优：
  1. 验证预处理器的表达能力：你的流网络是否足够深、足够宽？尝试增加耦合层的数量或隐藏层维度。同时，检查流网络是否真的改变了数据分布。可以可视化预处理前后，两个群体数据在某个特征维度或PCA降维后的二维空间中的分布变化。
  2. 审视成本矩阵M：你使用的是平方差(r0 - r1)^2吗？对于概率输出，也可以考虑使用基于排序的损失（如Wasserstein距离本身就更关注分布形态）。有时，对r进行适当的变换（如sigmoid）后再计算成本，效果可能更好。
  3. 分类器是否过于“顽固”？如果黑盒分类器f是一个非常复杂、高度非线性的函数（例如一个深度过参数化的神经网络），那么通过微调输入分布来改变其输出分布可能会非常困难。此时，预处理器的容量需要足够大。论文中处理DenseNet-201和图像数据的实验表明，即使对于大模型，该框架也有效，但这可能需要更精细的调参和更长的训练时间。
  4. 尝试“敏感属性盲”模式：在部署时没有敏感属性信息怎么办？论文提出了一个变体，即训练一个统一的预处理器T用于所有群体。这相当于让模型学习一个对所有人都“公平”的变换。实现时，只需将T0和T1设为同一个网络实例，在计算公平性损失时，依然根据训练数据中的敏感属性将数据分为两组计算r0和r1。这种模式下的公平性提升通常会比“敏感属性感知”模式弱一些，但更实用。

4.3 扩展到多分类与其它公平性准则

论文主要聚焦二分类和 Demographic Parity（统计平等）。如何扩展到多分类和 Equalized Odds（机会均等）？

• 多分类：对于多分类，分类器输出是一个分数向量（logits）。公平性损失可以定义为不同群体在每个类别上的输出分布之间的Wasserstein距离之和。具体地，假设有K类，我们需要计算K个成本矩阵 ( M^{(k)} )，其中 ( M^{(k)}{ij} = (r{0,i}^{(k)} - r_{1,j}^{(k)})^2 )，( r_{s,i}^{(k)} ) 是群体s中第i个样本属于第k类的分数。总公平性损失是这K个Sinkhorn损失的和。梯度计算会变得更复杂，但原理相通。
• Equalized Odds（EO）：EO要求在不同群体间，给定真实标签的条件下，预测结果的分布相同。这意味着我们需要为每个（敏感属性，真实标签）组合（如“男性且还款”、“女性且还款”）分别计算条件分布，并最小化同类标签下的分布距离。在AdapFair框架下，这需要引入两个公平性损失项：一个针对真实标签为1的组（True Positive Rate平等），一个针对真实标签为0的组（True Negative Rate平等）。在计算损失时，需要根据样本的真实标签对数据进行分组。这要求训练数据中必须有真实标签信息，且会使得小群体-小标签组合的数据量可能很少，需要小心处理。

5. 实验结果复现与工程实践要点

根据论文中的实验部分，AdapFair在多个数据集上相比基线方法（如后处理、Fair PCA、Fair NF等）展现出优势，尤其是在数据漂移和适配预训练大模型的场景下。在复现时，有几个工程要点需要特别注意。

5.1 基线方法的公平实现

为了进行公平比较，你需要复现或找到可靠的基线方法实现。例如：

• 后处理（Post-processing）：如 [53] 的方法，通常需要访问分类器的输出分数和敏感属性，然后学习一个阈值或变换来调整决策，以实现公平。这是一个强基线。
• 公平表示学习（如Fair PCA, CFair）：这些是“处理中”方法，需要与分类器联合训练。复现时需严格按照原论文的描述，并确保使用相同的数据划分和评估协议。
• Fair NF：这是与AdapFair最相关的方法，它也使用归一化流，但是与分类器联合训练。这意味着在数据漂移场景下，如果分类器固定，Fair NF的预处理器无法单独调整，这是AdapFair的主要优势之一。

5.2 评估指标的计算

除了准确率，公平性指标必须精确计算。

• ∆DP（Demographic Parity Gap）：abs(P(Ŷ=1|S=0) - P(Ŷ=1|S=1))。在测试集上，分别统计两个群体中被预测为正类的样本比例，然后计算绝对差。
• ∆EOpp（Equal Opportunity Gap）：abs(P(Ŷ=1|S=0, Y=1) - P(Ŷ=1|S=1, Y=1))。在测试集上，分别统计两个群体中真实标签为正的样本里，被预测为正类的比例，然后计算绝对差。
• 重要提示：这些指标应在同一个分类器上计算。对于AdapFair，就是用训练好的预处理器变换测试数据后，输入到固定的黑盒分类器中得到预测，再计算指标。所有对比方法也必须使用同一个分类器，以确保比较的公平性。

5.3 与大型预训练模型集成

这是AdapFair的一大亮点。以DenseNet-201和ISIC皮肤癌数据集为例，操作流程如下：

1. 加载预训练模型：使用torchvision.models.densenet201(pretrained=True)，并替换最后的全连接层以适应你的分类任务（如二分类：恶性 vs 良性）。
2. 冻结分类器：将DenseNet的所有参数设置为requires_grad=False。
3. 设计图像预处理器：归一化流通常用于连续数据。对于图像，一种方法是将图像展平为向量，但这会破坏空间结构。更好的方法是使用卷积归一化流（如Glow的变种）或使用一个轻量的卷积网络作为“特征变换器”，但要确保其变换在某种程度上是可逆或至少是保真的。论文中可能使用了更简化的处理，或者将图像通过一个编码器映射到潜空间，在潜空间应用流变换。这部分是工程上的难点，需要仔细设计。
4. 训练：损失计算和梯度回传的逻辑与表格数据完全相同。梯度会从DenseNet的输入层（即预处理后的图像）反向传播到图像预处理器的参数。由于DenseNet很大，一次前向传播成本高，因此批量大小（batch size）可能受限，需要更小的学习率和更长的训练时间。
5. 资源管理：训练会占用大量显存。建议使用梯度累积（gradient accumulation）来模拟更大的批量大小，并开启混合精度训练（torch.cuda.amp）来加速并节省显存。

我个人在尝试复现与大型模型集成的实验时发现，直接在高维像素空间应用流变换计算代价巨大且效果不佳。一个更可行的策略是，先使用预训练模型（如DenseNet）的倒数第二层特征提取器（即去掉最后的分类层），将图像映射到一个高维特征向量（例如，DenseNet-201最后是1920维的特征图全局平均池化后的向量）。然后，在这个特征向量空间（而非原始像素空间）上应用AdapFair的归一化流预处理器。这样，预处理器学习的是对高级语义特征的分布进行调整，计算效率更高，且更符合“公平性作用于模型决策逻辑层面”的直觉。训练完成后，部署时只需将“特征提取器+预处理器”串联在原始分类器之前即可。这种设计在保持框架核心思想的同时，大大提升了工程可行性。