企业官网建设流程全解析

简介：面向迁移学习与域适应方向的学习者和研究者，这份联合分布适配（JDA）代码包提供了一套可运行的MATLAB实现，用于在源域与目标域分布不一致时完成特征对齐与跨域分类实验。压缩包共28个文件、约53.52MB，主体为17个.mat格式的跨域数据集、5个.m脚本，另有1个rtf说明和1个txt文档，并含少量系统隐藏文件；数据覆盖Office、PIE、MNIST/USPS、COIL等常见实验场景，脚本则给出JDA主流程及不同数据集的运行入口。读者可据此复现Long等提出的联合分布适配方法，围绕PCA降维、第二阶统计特性对齐、类内紧凑性约束与优化变换矩阵求解逐步调试，也可替换自有源域、目标域数据开展迁移实验。目前已有1946人学习，适合具备一定机器学习基础、希望从代码和实验入口层面理解JDA实现细节的人群。

1. 从一次掉点 20 个点的翻车说起

去年在一个跨设备故障诊断的活儿里，模型在源设备上把测试集跑到 0.94，换到目标设备，同一套参数直接掉到 0.7 出头。目标设备没有标注，重新标注成本又太高，这就是联合分布适配 JDA 要处理的问题：源域有标签、目标域没标签，但两边的特征分布不一致，用一个线性或者核映射把两边同时拉到同一个子空间里，顺带把条件分布也往一块儿拽。这份代码就是一套纯 numpy + scipy 的 JDA 实现，不依赖深度学习框架，CPU 上几十行核心逻辑，适合做迁移学习入门复现、跨域小样本实验，也适合拿来做你自己的域自适应基线。下面按能跑、能读、能改的顺序拆。

2. 项目骨架：JDA 代码的模块划分与数据流

2.1 目录结构：算法本体和跑批入口是分开的

这类从论文复现出来的迁移学习代码，极少做成工程化的包，通常是一个算法文件加一个入口脚本，再挂一个数据目录。我见过的实现大同小异，源码包铺开来大致是下面这个形状：

jda_project/ ├── jda.py # 算法本体：核函数、MMD 矩阵构造、子空间求解、主循环 ├── demo.py # 单个域对的入口，读数据、调 jda、打印精度 ├── utils.py # 数据加载、标准化、结果落盘 ├── data/ │ ├── source.mat # 源域特征 + 标签 │ └── target.mat # 目标域特征 + 标签（标签只在评估时用） └── README.md

真正要读透的只有jda.py。它里面通常拆成六个函数，职责边界很清楚，改的时候不容易互相牵连：

这种「一个算法文件管到底」的组织方式，好处是阅读成本低，坏处是没有做参数校验、没有日志、没有中间结果缓存。二次开发时我一般先补一层 config，把超参从函数签名里挪出来，再谈改算法。

2.2 数据流：一个域对从进入到打分只走五步

把主循环摊平，数据流是这样的：

1. 源域特征Xs（ns×d）和目标域特征Xt（nt×d）竖直拼成一个X（n×d），n = ns + nt；
2. X过一次核映射得到K（n×n），线性核就是X @ X.T；
3. 用 ns、nt 算边缘分布矩阵M0，这是全程不变的常量；
4. 进入 T 次迭代：M = M0 + Mc，解一次广义特征值问题得到投影A，把核矩阵压到Z = A.T @ K；用源域那一段Zs训练一个 KNN，去预测目标域那一段Zt，得到伪标签，再用伪标签重算Mc；
5. 每一轮都拿伪标签和目标域真标签对一次，输出这一轮的 accuracy。

理解这条链路有个关键点：伪标签不是最终产物，它是迭代的输入。JDA 的初始假设是「源域和目标域的条件分布相同」，也就是分类器在两边行为一致，所以第一轮可以直接用源域分类器给目标域打标签；后面每轮用这份伪标签构造 Mc，把条件分布也拽过来。这是一个 EM 式的自举过程，跑偏了就会越跑越差，第五章会专门讲这个。

2.3 依赖和环境：三件套，CPU 就能跑

依赖很轻，numpy做矩阵运算，scipy.linalg提供特征值分解，scikit-learn只用到 KNN 和评估函数。Python 3.8 以上的较新版本都能装：

pip install numpy scipy scikit-learn

不需要 GPU，也不需要深度学习框架。样本量在几千这个量级时，单次迭代在普通笔记本上是秒级；样本量上万之后，第 3.3 节讲的求逆开销会变成瓶颈，第五章会给出替代写法。

提示：这类代码对 numpy 版本比较敏感，特别是np.linalg.eig返回复数时的类型转换，老版本和较新版本对np.real的处理一致，但np.argsort对复数数组会直接报错，所以主循环里务必先取实部再排序。

3. 算法拆解：MMD 矩阵怎么变成一次广义特征值分解

3.1 边缘分布 M0：一行矩阵背后是两堆点的均值差

JDA 想最小化的东西，本质是「投影后源域和目标域的均值差」。设投影矩阵为 A，投影后的样本是A.T @ x，那么边缘分布的 MMD（最大均值差异）平方就是：

|| (1/ns) Σ_{i∈源域} A.T xi - (1/nt) Σ_{j∈目标域} A.T xj ||²

把这个式子展开成二次型，就得到tr(A.T @ X @ M0 @ X.T @ A)，其中M0是一个 n×n 的系数矩阵，四个块的取值分别是：

import numpy as np def mmd_marginal(ns, nt): """边缘分布矩阵 M0：源源块 1/ns²，域域块 1/nt²，交叉块 -1/(ns*nt)""" n = ns + nt M = np.zeros((n, n)) M[:ns, :ns] = 1.0 / (ns * ns) # 源域内部 M[ns:, ns:] = 1.0 / (nt * nt) # 目标域内部 M[:ns, ns:] = -1.0 / (ns * nt) # 源-目标交叉 M[ns:, :ns] = -1.0 / (ns * nt) # 目标-源交叉 return M

这段代码没有任何循环，因为二次型的交叉项正好对应着两个均值的内积。参数只有 ns 和 nt 两个样本数，调整空间很小，唯一容易错的是交叉项的符号：写成正号，最小化就变成「把两边均值拉到一起之外还要放大交叉项」，结果是直接发散。我见过有人把整块矩阵写成对称的正定形式，跑出来的精度比随机猜还低，就是这里翻了车。

M0只描述边缘分布，它假设两边的类别比例一致。如果你的目标域里某一类特别多、某一类特别少，光靠M0是纠不过来的，必须靠下一节的Mc。

3.2 条件分布 Mc：伪标签驱动的类内对齐

条件分布对齐的做法是：把源域和目标域按类别切开，对每一个类 c 单独算一次「类内均值差」，然后把所有类的 MMD 加起来。类别标签在源域是现成的，在目标域只能靠伪标签，这就是迭代的由来。

def mmd_conditional(ns, nt, ys, yt_pseudo, n_class): """按伪标签构造条件分布矩阵 Mc，结构与 M0 一致，只是限定在类内""" n = ns + nt M = np.zeros((n, n)) for c in range(n_class): idx_s = np.where(ys == c)[0] # 源域中属于类 c 的下标 idx_t = np.where(yt_pseudo == c)[0] # 目标域中被判为类 c 的下标 if len(idx_s) == 0 or len(idx_t) == 0: # 某一类在目标域一个都没分到 continue # 直接跳过，避免除零 M[np.ix_(idx_s, idx_s)] += 1.0 / (len(idx_s) ** 2) M[np.ix_(idx_t + ns, idx_t + ns)] += 1.0 / (len(idx_t) ** 2) M[np.ix_(idx_s, idx_t + ns)] += -1.0 / (len(idx_s) * len(idx_t)) M[np.ix_(idx_t + ns, idx_s)] += -1.0 / (len(idx_s) * len(idx_t)) return M

三个参数要留意。ys是源域真标签，顺序必须和Xs的行严格对应，一旦中间做过排序或者 shuffle 没同步，整块矩阵就全错位了。yt_pseudo是目标域伪标签，长度是 nt，而矩阵里的下标要加上ns偏移，因为整个 M 是按拼接后的 n 个样本索引的，这个偏移写漏是最常见的 bug。n_class是类别总数，一般取len(np.unique(ys))，如果目标域实际类别比源域多，多出来的类在这一轮里是拿不到对齐的，这属于方法本身的限制，不是你代码写错了。

np.ix_是这里的性能关键，它做的是笛卡尔积索引，等价于两块 for 循环但走的是 C 层。换成双重 for 循环，n 到几千的时候光构造矩阵就能卡好几秒。

3.3 子空间求解：为什么是 (KMKᵀ + λI)⁻¹ KHKᵀ

目标函数凑齐了：最小化tr(A.T @ K @ M @ K.T @ A)。但这里有个坑——如果只写这一个目标，最优解是 A = 0，把所有点映射到原点，MMD 当然是 0。所以必须加一个约束：投影后样本的方差要保住。

约束写成A.T @ K @ H @ K.T @ A = I，其中H = I - (1/n) 11ᵀ是中心化矩阵，KHKᵀ乘完就是投影后特征的协方差（差一个 n 倍）。用拉格朗日乘子法推一下，问题转成广义特征值问题：

(K M Kᵀ + λI) a = θ (K H Kᵀ) a

取最小的 dim 个特征值对应的特征向量，就是我们要的 A。代码里通常换个等价写法：先求逆再乘，取最大特征值。

def subspace(K, M, H, dim, lamb=1.0): """解 (KMK'+λI)^-1 KHK' 的前 dim 个特征向量""" n = K.shape[0] LHS = K @ M @ K.T + lamb * np.eye(n) # 正则项，防止 K M K' 奇异 RHS = K @ H @ K.T # 保方差约束 A = np.linalg.inv(LHS) @ RHS w, V = np.linalg.eig(A) # 可能返回复数 idx = np.argsort(np.real(w))[::-1][:dim] return np.real(V[:, idx]) # 只取实部，虚部是数值误差

lamb是正则系数，原实现里一般取 1.0。它的作用是把KMKᵀ从可能的奇异状态拉回来：如果某一类目标域样本特别少，Mc里那个类对应的块会非常大，矩阵条件数爆炸，求逆出来的 A 全是噪声。dim是子空间维度，常见取值 30 到 100，取太大等于不降维，取太小信息丢太多。np.real那一步必须留，eig对非对称矩阵返回复数，忘了取实部，后面 KNN 直接报类型错。

3.4 核化：把 X 换成 K 之后，A 的含义变了

前面所有的推导里，X是原始特征矩阵。核化之后换成K，A 从 d×dim 变成 n×dim，投影结果成了Z = A.T @ K，形状是 dim×n。这一步的意义是允许非线性映射——RBF 核把样本隐式映射到无穷维空间，在原始特征线性不可分的时候，核空间里可能就分开了。

def kernel(ker, X, gamma=1.0): """线性核 / RBF 核，X 为空时算自核矩阵""" if ker == 'linear': return X @ X.T if ker == 'rbf': # ||x-y||² = ||x||² + ||y||² - 2xy，避免显式广播 sq = (X ** 2).sum(1) d2 = sq[:, None] + sq[None, :] - 2 * X @ X.T return np.exp(-gamma * np.maximum(d2, 0)) # 截断负值，防数值误差 raise ValueError('kernel 只支持 linear / rbf')

gamma只对 RBF 生效，经验值是1/d（d 是特征维度）附近，跨域任务里偏小一点往往更稳，因为核太尖会把目标域样本全推成「与源域无关」。np.maximum(d2, 0)这一步看着多余，其实必要：浮点误差会让本该为 0 的对角线出现-1e-16，exp一下就成了 1.0000000002，虽然影响极小，但在特征值分解里会被放大。有些实现还支持primal模式，不做核映射、直接把K取成原始特征矩阵，等价于线性核但省一次矩阵乘，样本量大的时候可以切过去。

4. 跑通流程：数据准备、参数配置和一次完整训练

4.1 数据准备：标准化只能在源域上 fit

这是全流程里最容易埋雷的一步。跨域场景下，目标域的统计量在训练时是不可见的，所以标准化的均值方差必须只用源域算，再套到两边：

import numpy as np from sklearn.preprocessing import StandardScaler def load_pair(Xs, ys, Xt, yt): """统一标准化 + 行归一化，模拟真实场景：目标域统计量不可见""" scaler = StandardScaler().fit(Xs) # 只在源域上 fit Xs = scaler.transform(Xs) Xt = scaler.transform(Xt) # 行归一化到单位球，让线性核等价于余弦相似度 Xs = Xs / np.linalg.norm(Xs, axis=1, keepdims=True) Xt = Xt / np.linalg.norm(Xt, axis=1, keepdims=True) return Xs, ys, Xt, yt

用fit(Xs)而不是fit(np.vstack([Xs, Xt]))，代价是目标域数据没被完美归一化，收益是实验设置和真实部署一致。如果你在做论文复现、追求和原文对齐的数字，很多实现其实是拼接后统一 fit 的，这时候精度会好看一点，但那部分收益在真实场景里是拿不到的。两条路都行，关键是知道自己站在哪条上。

行归一化那一步也不是标配。它的好处是让线性核的数值范围收敛到 [-1, 1]，矩阵条件数好很多；坏处是对幅值敏感的模态（比如振动信号的频谱幅值）会丢掉一部分信息。我一般会做一组消融，两种都跑一下看哪边稳。

4.2 参数怎么定：五个旋钮的作用和取值范围

dim和lamb是最值得花时间的两维，我一般先固定lamb=1.0、T=10，扫dim ∈ {30, 50, 100}，找到拐点之后再回去微调lamb。n_neighbors建议就用 1，JDA 原文也是 1NN，改成 3 或 5 之后伪标签会变平滑，但前几轮的错误会被摊到更多样本上，反而更难纠回来。

4.3 完整训练脚本：把上面几块拼起来

import numpy as np from sklearn.neighbors import KNeighborsClassifier from sklearn.metrics import accuracy_score def jda(Xs, ys, Xt, yt, dim=30, lamb=1.0, T=10, ker='linear', gamma=1.0, n_neighbors=1, n_class=None): ns, nt = Xs.shape[0], Xt.shape[0] n = ns + nt # 1) 拼接 + 核映射 X = np.vstack([Xs, Xt]) K = kernel(ker, X, gamma) # 2) 中心化矩阵 H 与边缘分布矩阵 M0 H = np.eye(n) - np.ones((n, n)) / n M0 = mmd_marginal(ns, nt) Mc = np.zeros((n, n)) accs, yt_pseudo = [], np.zeros(nt, dtype=ys.dtype) # 3) 伪标签自举 for it in range(T): M = M0 + Mc A = subspace(K, M, H, dim, lamb) Z = A.T @ K # (dim, n) Zs, Zt = Z[:, :ns].T, Z[:, ns:].T clf = KNeighborsClassifier(n_neighbors=n_neighbors).fit(Zs, ys) yt_pseudo = clf.predict(Zt) # 用源域分类器给目标域打伪标签 accs.append(accuracy_score(yt, yt_pseudo)) # 4) 用伪标签重算条件分布矩阵，进入下一轮 Mc = mmd_conditional(ns, nt, ys, yt_pseudo, n_class) return accs, yt_pseudo, Zs, Zt if __name__ == '__main__': Xs, ys, Xt, yt = load_pair(*read_mat('data/source.mat', 'data/target.mat')) accs, pred, Zs, Zt = jda(Xs, ys, Xt, yt, dim=30, lamb=1.0, T=10, ker='linear', n_class=len(np.unique(ys))) print('每轮目标域准确率:', [round(a, 4) for a in accs])

几个参数的作用串起来看：n_class必须显式传，不能靠yt推，因为yt在真实场景里根本拿不到；Z[:, :ns].T这个转置是为了让 KNN 拿到(样本数, 特征数)的标准形状，写反了 sklearn 会报维度不匹配；yt_pseudo初值给全零不影响结果，因为第一轮一定会在循环里被覆盖。

4.4 结果怎么读：不是最后一轮的精度最高

跑完打印出来的accs是一个长度 T 的列表，通常会看到这么个形态：第 1 轮 0.55，第 2 轮 0.71，第 3 轮 0.78，第 5 轮 0.81，然后第 7 轮 0.80，第 10 轮 0.79。前几轮的涨幅是条件分布对齐带来的，后面的回落是伪标签把错误固化了。

所以工程上真正该用的不是最后一轮的模型，而是峰值那一轮的伪标签和投影矩阵。原实现里很多时候直接打最后一轮，导致复现出来的数字比原文低两三个点，原因就在这儿。我现在的做法是在循环里记一个 best，按目标域的置信度或者按源域验证集上的表现来选轮次，别用目标域标签选，那是作弊。

注意：如果你在调试阶段用目标域真标签来挑最优轮次，务必在正式汇报里标明这是 oracle 设置，否则和别人对比时数字不可比。

5. 避坑与排查：精度对不上论文的五个具体原因

5.1 现象：整体精度比参考值低十几个点，但每一轮都在涨

原因基本落在数据预处理上。跨域任务的精度对特征尺度极其敏感，源域单独标准化和目标域单独标准化，结果能差 5 到 10 个点。另一种情况是特征本身不对：拿原始像素跑和拿深度特征跑，JDA 的增益完全不同，原始像素上往往只有几个点提升，深度特征上能到十几个点。

解决思路是先做一次 sanity check：只在源域训练、直接在目标域测试，如果这个「不迁移」的基线就已经很低（比如 0.4），那 JDA 再怎么对齐也救不回来，问题在特征不在算法。确认基线合理之后，再固定随机种子跑三次，看方差有多大，方差超过 2 个点就先解决数据划分问题。

5.2 现象：某一轮之后精度突然掉到接近随机，或者矩阵出现 NaN

这是Mc里出现除零导致的。mmd_conditional里如果某一类在目标域的伪标签数量为 0，1.0 / (len(idx_t) ** 2)就是除零，numpy 会给inf再变nan，一路污染到特征值分解。

解决办法是加那个if len(idx_s) == 0 or len(idx_t) == 0: continue的跳过分支。更稳的做法是给每个类设一个最小样本数阈值，低于阈值就不参与条件对齐，只用边缘分布：

if len(idx_t) < 3: # 目标域这一类样本太少，对齐不可靠 continue

这个阈值没有理论依据，纯粹是工程保护。样本量小的域对，条件分布本来也估不准，强行对齐反而引入噪声。

5.3 现象：样本量上万之后，单轮迭代要跑几分钟甚至内存爆掉

np.linalg.inv(LHS)是 O(n³)，n = ns + nt。n 到两万，一个 n×n 的 float64 矩阵就是 3.2 GB，加上K、H、M三份，内存直接见底。

替代写法是绕开显式求逆，直接解广义特征值问题，用scipy.linalg.eigh只取需要的特征对：

from scipy.linalg import eigh def subspace_fast(K, M, H, dim, lamb=1.0): """大样本版本：不显式求逆，只解前 dim 个广义特征值""" n = K.shape[0] LHS = K @ M @ K.T + lamb * np.eye(n) RHS = K @ H @ K.T vals, vecs = eigh(LHS, RHS) # 解 LHS a = θ RHS a idx = np.argsort(vals)[:dim] # 取最小 dim 个 return vecs[:, idx]

注意特征值方向反过来了：原写法取最大，这里取最小，因为eigh(A, B)解的是A a = θ B a，而我们的目标是最小化二次型。两种写法在数学上等价，数值稳定性上前者差一些，但胜在直观。样本量再大就得上scipy.sparse.linalg.eigsh，配合稀疏核矩阵，不过那就不是单文件脚本能解决的事了。

5.4 现象：换个随机种子重跑，精度波动 5 个点以上

波动来源有三个，按影响从大到小排：KNN 的 k 值、初始伪标签的生成方式、迭代轮数 T。k=1 的时候，目标域边界上那几个样本判错，下一轮Mc就会把整块类内对齐拉偏，属于典型的正反馈失控。

压制波动的办法是给伪标签加一个置信度过滤：KNN 的predict_proba拿到概率，低于 0.7 的目标域样本这一轮不参与条件对齐。另一个办法是固定 T 为一个较小的值（5 到 8），别指望它收敛，这类自举过程本来就不收敛，跑到后面只会越来越偏。

5.5 现象：精度高得不正常，接近甚至超过源域上的表现

先别高兴，八成是标签泄漏了。最常见的三种：把yt传进了训练流程、标准化的时候用两边数据一起 fit、伪标签初始化直接用了目标域真标签。

排查方法很简单，把yt全部改成一个常数（比如全 0）再跑一遍，如果精度还是高，那说明标签从别的路径漏进去了。第二种更隐蔽，代码里写StandardScaler().fit_transform(np.vstack([Xs, Xt]))，看起来人畜无害，实际上目标域的均值方差信息已经混进特征里了。我踩过这个坑，当时实验数字比参考值高了 8 个点，高兴了一下午，后来改成只在源域 fit，数字掉回正常区间。

6. 二次开发：把 JDA 改成能挂进你自己项目的样子

改这套代码，我一般从三处下手，按投入产出比排。

第一处是换距离度量。JDA 用 MMD 对齐边缘和条件分布，但 MMD 只对齐一阶和二阶以外的统计量很弱，协方差漂移明显的数据集上，换成 CORAL（对齐二阶协方差）往往更直接。改法是把mmd_marginal换成一个直接算协方差差的矩阵，主循环结构完全不用动：

def coral_matrix(Xs, Xt): """用协方差差替代 MMD，返回等价的二次型系数矩阵""" ns, nt = Xs.shape[0], Xt.shape[0] Cs = np.cov(Xs, rowvar=False) + np.eye(Xs.shape[1]) * 1e-3 Ct = np.cov(Xt, rowvar=False) + np.eye(Xt.shape[1]) * 1e-3 # 白化源域后再对齐，等价于最小化 ||Cs - Ct||_F² return Cs, Ct # 后续用 Cs^-1/2 @ Ct^1/2 做线性变换

这条路适合特征维度不高（几百以内）的场景，维度上千协方差估计就不准了。

第二处是给边缘和条件分布加权重。原版是M0 + Mc直接相加，但很多跨域任务里边缘分布差异远大于条件分布差异，等权相加会让条件对齐变成噪声。改成M = M0 + beta * Mc，beta 从 0.1 扫到 1.0，通常能捡回一到两个点。进一步可以做成自适应的：每轮根据伪标签的置信度动态调整 beta，置信度低就把 beta 往下压。

第三处是接深度特征。这是收益最大的一处。把 JDA 当成一个后处理模块，前面挂一个预训练骨干，取倒数第二层的输出（常见是 256 或 512 维）作为输入，再做标准化和 JDA。深度特征本身的跨域性比手工特征好得多，JDA 在其上的增益也更明显。要注意的是特征维度上去之后，样本量相对变小，dim不能按 30 取，得往 100 以上走，否则信息丢太多。

验证改造效果有个硬规矩：别只看目标域精度。每次改完，我都要同时打三个数——源域精度、目标域精度、目标域上的伪标签置信度均值。只有目标域涨、源域不跌、置信度不塌，才算真涨了；目标域涨了但置信度崩了，大概率是运气。

从那以后我每次动这类迁移学习代码，都强制先跑一遍「不迁移基线 + 源域单独 fit 标准化」这两件事，用这两条数把天花板和地板都框出来，再谈改算法。不然改了半天，涨的那几个点根本不知道是算法起作用还是数据泄漏在帮忙。希望帮到你。

本文还有配套的精品资源，点击获取