1. 初识POT:你的Python最优传输工具箱
如果你在机器学习和数据分析领域摸爬滚打过一阵子,肯定遇到过这样的问题:怎么衡量两个“长得不一样”的分布之间的距离?比如,一个分布是城市里咖啡馆的位置,另一个是写字楼的位置,它们在地图上的点根本对不上号。用传统的欧氏距离或者KL散度?前者要求点对点严格对应,后者对分布的支撑集(简单理解就是分布有值的区域)敏感,经常给你一个无穷大的尴尬结果。
这时候,最优传输(Optimal Transport, OT) 就该登场了。你可以把它想象成一个最有效率的“搬家公司”:它要把一堆沙土(一个概率分布)从一个地方搬到另一个地方,形成新的沙堆(另一个概率分布),目标是找到总“搬运成本”最低的方案。这个最低成本,就是著名的 Wasserstein距离,也叫“推土机距离”。它厉害的地方在于,能自然地处理分布支撑集不重叠的情况,并且考虑了数据内在的几何结构。
理论虽美,但上手实现那些复杂的线性规划或熵正则化算法,足以让大多数人望而却步。好在,我们有 POT(Python Optimal Transport)库。这个由法国学者Rémi Flamary和Nicolas Courty等人发起的开源项目,几乎把最优传输领域几十年来的核心算法都打包进了Python。无论你是想计算两个分布的距离,做图像的颜色迁移,还是进行复杂的域适应(Domain Adaptation)任务,POT都提供了现成的、高效的函数。我用了好几年,从研究到工程落地,它都是我最信赖的OT工具包。今天,我就带你从零开始,玩转这个强大的库。
首先,安装它非常简单,一条pip命令搞定:
pip install pot
注意,导入库的时候用的是 ot,而不是 pot,这是一个历史遗留的小约定。
import ot # 注意是ot,不是pot
import numpy as np
2. 核心实战:从计算Wasserstein距离开始
一切的故事,都从计算两个分布的距离开始。我们先用最简单的例子感受一下。
2.1 理解“代价矩阵”与分布
假设我们有两个一维的分布,比如两个班级学生的身高分布。在POT中,我们通常用直方图(histogram)来表示离散分布。也就是说,我们有两个向量 a 和 b,它们所有元素的和为1(概率归一化),且每个元素非负。
但光有两个分布还不行,OT需要知道把 a 中每“一撮土”运到 b 中每个位置的“运费”是多少。这就需要代价矩阵(Cost Matrix) M。如果 a 的长度是 n,b 的长度是 m,那么 M 就是一个 n x m 的矩阵,其中 M[i, j] 表示将 a[i] 的质量运送到 b[j] 的成本。最常用的成本就是两点之间的欧氏距离的平方。
我们来生成一些模拟数据,亲手算一下:
# 生成模拟数据:两个一维分布
n = 30 # 第一个分布的支撑点数量
m = 30 # 第二个分布的支撑点数量
# 生成支撑点的位置。这里我们简单地在[0,1]区间和[0.5, 1.5]区间生成点,让它们有部分重叠。
np.random.seed(42)
xs = np.random.rand(n, 1) # 形状 (n, 1)
xt = np.random.rand(m, 1) + 0.5 # 形状 (m, 1)
# 为每个点分配概率质量(权重),这里我们用均匀分布
a = ot.unif(n) # 相当于 np.ones(n) / n
b = ot.unif(m) # 相当于 np.ones(m) / m
# 计算代价矩阵:使用平方欧氏距离
M = ot.dist(xs, xt, metric='sqeuclidean') # 形状 (n, m)
print(f"代价矩阵 M 的形状: {M.shape}")
print(f"M 的前3行,前3列:\n{M[:3, :3]}")
运行这段代码,你会看到一个30x30的矩阵。M[i,j] 就是 xs[i] 到 xt[j] 的平方距离。这就是我们“搬家公司”的价目表。
2.2 精确解法:地球移动距离(EMD)
有了分布 a, b 和价目表 M,我们就可以求解最优传输问题了。最经典的方法是求解一个线性规划问题,得到的结果叫做地球移动距离(Earth Mover‘s Distance, EMD)。在POT中,使用 ot.emd 函数来求解最优传输矩阵 T,使用 ot.emd2 直接计算Wasserstein距离。
# 计算最优传输矩阵 T
T = ot.emd(a, b, M) # T[i,j] 表示从 a[i] 运送到 b[j] 的质量
print(f"传输矩阵 T 的形状: {T.shape}")
print(f"检查 T 的行和是否等于 a: {np.allclose(T.sum(axis=1), a)}")
print(f"检查 T 的列和是否等于 b: {np.allclose(T.sum(axis=0), b)}")
# 直接计算 Wasserstein 距离(p=2时的平方距离)
W_dist_squared = ot.emd2(a, b, M)
print(f"Wasserstein 距离(平方): {W_dist_squared}")
# 注意:因为我们用的代价是平方欧氏距离,所以这里 ot.emd2 的结果是 W_2^2。
# 要得到 W_2,需要开方。
W_dist = np.sqrt(W_dist_squared)
print(f"Wasserstein 距离 W_2: {W_dist}")
T 矩阵非常有意思,它是一个稀疏矩阵(如果你用 print(T) 看,很多地方是0)。它精确地指明了如何以最小的成本重新分配质量。而 W_dist 就是这个最小成本的总和。你可以尝试改变 xs 和 xt 的生成范围,比如让它们完全分开,你会发现Wasserstein距离依然能算出一个合理的值,而KL散度可能就爆炸了。
2.3 更快的熵正则化解法:Sinkhorn算法
精确的 ot.emd 求解线性规划,当数据点很多时(比如n, m > 1000),计算会变得非常慢。这时,熵正则化最优传输 和 Sinkhorn算法 就派上用场了。它通过给传输矩阵 T 加上一个熵约束,将问题变成一个可以通过迭代矩阵缩放快速求解的问题。虽然结果是近似解,但速度极快,而且特别适合与深度学习框架(如PyTorch)结合,因为它是可微的。
# 设置正则化系数 reg。reg越大,熵约束越强,解越平滑,计算越快,但近似误差越大。
reg = 0.1 # 这是一个常用的起始值
# 使用 Sinkhorn 算法计算正则化后的传输矩阵和距离
T_reg = ot.sinkhorn(a, b, M, reg)
W_dist_reg = ot.sinkhorn2(a, b, M, reg)
print(f"正则化传输矩阵 T_reg 的形状: {T_reg.shape}")
print(f"正则化 Wasserstein 距离: {W_dist_reg}")
print(f"注意:Sinkhorn2 返回的已经是 W_2^2,无需再开方(当M是平方距离时)。")
# 比较一下 T 和 T_reg 的区别
print(f"\n精确解 T 的稀疏性(非零元素比例): {(T > 1e-10).sum() / (n*m):.2%}")
print(f"正则化解 T_reg 的稀疏性(非零元素比例): {(T_reg > 1e-10).sum() / (n*m):.2%}")
你会看到 T_reg 比 T 稠密得多,几乎每个位置都有值,这就是熵正则化的效果——它不允许传输路径“太极端”,从而让计算变得稳定快速。在实际应用中,尤其是深度学习里,reg 通常设置得像0.01、0.1这样的小数,在速度和精度之间取得平衡。
3. 进阶应用:图像颜色迁移与分布对齐
理解了基础,我们来看看POT能做的酷炫事情。最优传输在图像处理领域有一个经典应用:颜色迁移(Color Transfer)。目标是把一张图片(源图片)的颜色风格,迁移到另一张图片(目标图片)上,而不改变目标图片的内容。
3.1 颜色迁移的原理
为什么OT能用来做颜色迁移?我们可以把一张图片在颜色空间(比如RGB空间)中所有像素点的颜色值,看作一个三维的概率分布。颜色迁移的任务,就是找到一个“颜色映射”,把目标图片的颜色分布,变换成源图片的颜色分布。这正是最优传输的拿手好戏——它找到了两个颜色分布之间代价最小的传输方案。
POT的示例库中就有完整的颜色迁移代码。其核心步骤是:
- 将源图和目标图的像素从RGB空间转换到Lab空间(Lab空间对颜色感知更均匀)。
- 对两图的像素颜色值进行聚类(例如用K-Means),得到两个颜色分布(用聚类中心代表颜色,聚类大小为权重)。
- 计算两个聚类分布之间的最优传输矩阵
T。 - 利用
T将目标图的每个像素颜色,按照传输计划“搬运”到源图的颜色风格上。
这里我给出一个简化版的代码框架,帮你理解这个过程:
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import MiniBatchKMeans
import ot
# 假设我们已经有了源图像素 lab_s (形状: N_s x 3) 和目标图像素 lab_t (形状: N_t x 3)
# 步骤1: 聚类,简化分布
n_clusters = 100 # 聚类数量,越大效果越精细,计算越慢
kmeans_s = MiniBatchKMeans(n_clusters=n_clusters, random_state=42).fit(lab_s)
kmeans_t = MiniBatchKMeans(n_clusters=n_clusters, random_state=42).fit(lab_t)
# 得到聚类中心和权重(每个簇的像素比例)
centers_s = kmeans_s.cluster_centers_ # (n_clusters, 3)
centers_t = kmeans_t.cluster_centers_ # (n_clusters, 3)
weights_s = np.bincount(kmeans_s.labels_, minlength=n_clusters) / len(lab_s)
weights_t = np.bincount(kmeans_t.labels_, minlength=n_clusters) / len(lab_t)
# 步骤2: 计算代价矩阵(Lab空间中的欧氏距离)
M_color = ot.dist(centers_s, centers_t, metric='euclidean')
# 步骤3: 计算最优传输(使用Sinkhorn加速)
reg = 0.1
T_color = ot.sinkhorn(weights_s, weights_t, M_color, reg)
# 步骤4: 将传输矩阵应用于目标图的每个像素
# 对于目标图的每个像素(属于聚类j),我们需要找到它应该映射到源图的哪个颜色。
# 一种简单的方法是:对于目标图聚类j,根据 T_color[:, j] 的比例,将其像素随机分配到源图的各个聚类i。
# 更平滑的方法是:计算一个 barycentric mapping。
# 这里展示 barycentric mapping 的思路:
transported_colors = np.zeros_like(lab_t)
for j in range(n_clusters):
# 找到属于目标聚类j的所有像素
indices_j = np.where(kmeans_t.labels_ == j)[0]
if len(indices_j) == 0:
continue
# 计算从源图所有聚类到目标聚类j的传输质量归一化后的比例
proportion = T_color[:, j] / (T_color[:, j].sum() + 1e-10)
# 目标聚类j的新颜色,是源图所有聚类颜色的加权平均,权重就是传输比例
new_color_j = np.dot(proportion, centers_s)
# 应用这个新颜色
transported_colors[indices_j] = new_color_j
# 步骤5: 将结果转换回RGB空间并显示
通过这个流程,目标图片就“染”上了源图片的色调。POT官方示例的效果非常惊艳,比如把一张黄昏风景照的颜色风格迁移到一张白天风景照上。
3.2 域适应(Domain Adaptation)
另一个重量级应用是域适应。在机器学习中,我们经常遇到训练数据(源域)和测试数据(目标域)分布不同的问题,比如用模拟数据训练的模型,在真实数据上效果变差。OT可以用来对齐这两个域的特征分布,从而提升模型在目标域上的性能。
POT提供了 ot.da 子模块来处理这类问题。其核心思想是:寻找一个变换,使得变换后源域样本的分布,与目标域样本的分布之间的Wasserstein距离最小。同时,这个变换还要能保持样本的重要判别结构(比如类别信息)。
import ot
from ot.datasets import make_data_classif
from ot.da import SinkhornTransport
# 生成模拟的源域和目标域数据
Xs, ys = make_data_classif('3gauss', 100) # 源域,100个样本
Xt, yt = make_data_classif('3gauss2', 150) # 目标域,150个样本,分布略有不同
# 初始化 SinkhornTransport 求解器
ot_sinkhorn = SinkhornTransport(reg_e=1.0, # 熵正则化参数
max_iter=1000,
verbose=True)
# 拟合(学习)传输计划
ot_sinkhorn.fit(Xs=Xs, Xt=Xt)
# 将源域数据变换到目标域分布上
Xs_transformed = ot_sinkhorn.transform(Xs=Xs)
# 现在,你可以用 Xs_transformed 和 ys 训练一个分类器,
# 这个分类器在 Xt 上的表现通常会比直接用 Xs 训练更好。
SinkhornTransport 类封装了完整的流程。在实际项目中,你可以将深度学习模型的特征提取层的输出,作为 Xs 和 Xt,然后利用OT学习到的变换来调整源域特征,实现特征级别的域适应。
4. 高级功能与性能调优
当你熟悉了基本操作后,POT库更强大的高级功能会让你如虎添翼。
4.1 处理不平衡与部分传输
现实中的数据分布常常是不平衡的,或者我们只关心一部分数据的对齐。POT提供了 Unbalanced OT(不平衡OT) 和 Partial OT(部分OT)。
-
Unbalanced OT:不再严格要求传输矩阵的行和、列和必须完全等于
a和b,而是允许有“质量创造”或“质量销毁”,但会施加一个惩罚。这适用于两个分布总质量不同的情况。from ot.unbalanced import sinkhorn_unbalanced2 # a和b的总和可以不一样 a_ub = np.random.rand(n) a_ub /= a_ub.sum() * 0.8 # 总质量为 0.8 b_ub = np.random.rand(m) b_ub /= b_ub.sum() * 1.2 # 总质量为 1.2 reg = 0.1 # 传输矩阵的熵正则化 reg_m = 1.0 # 边际约束(mass violation)的正则化强度 W_ub = sinkhorn_unbalanced2(a_ub, b_ub, M, reg, reg_m) print(f"不平衡OT距离: {W_ub}") -
Partial OT:只要求传输总质量为
m(m小于两个分布的总质量)。这在你只想匹配两个分布中最相似的那部分时非常有用,比如在匹配只有部分重叠的单词嵌入时。from ot.partial import partial_wasserstein # 只传输总质量为 0.5 的部分 m = 0.5 T_partial, log = partial_wasserstein(a, b, M, m=m, log=True) print(f"实际传输的质量: {log['partial_w_dist']}")
4.2 计算重心(Barycenter)
Wasserstein重心 可以理解为多个分布的“平均”分布。它在风格平均、聚类中心计算等方面有广泛应用。POT计算重心非常方便。
# 假设我们有3个一维分布,用直方图表示,存储在矩阵 A 的每一列中
k = 3 # 分布个数
d = 50 # 每个分布的支撑点数量(直方图bin数)
A = np.random.rand(d, k)
A = A / A.sum(axis=0) # 归一化每一列为一个分布
# 创建一个简单的代价矩阵(这里假设支撑点是1D的均匀网格)
x = np.arange(d).reshape(-1, 1).astype(float)
M_bary = ot.dist(x, x) # 支撑点之间的绝对距离矩阵
# 设置每个分布的权重
weights = np.array([0.2, 0.5, 0.3]) # 三个分布的权重,和为1
# 计算熵正则化的 Wasserstein 重心
reg = 0.001 # 很小的正则化,接近精确解
barycenter = ot.barycenter(A, M_bary, reg, weights=weights)
print(f"重心分布的形状: {barycenter.shape}")
print(f"重心分布的和(应为1): {barycenter.sum()}")
这个计算出的 barycenter 就是一个新的直方图,它在Wasserstein意义下是输入分布的加权平均。
4.3 后端加速与大规模计算
对于超大规模问题,POT也提供了解决方案。
-
1D特例加速:如果你的数据是一维的,一定要使用
ot.wasserstein_1d或ot.emd_1d等函数,它们有基于排序的算法,复杂度几乎是线性的,比通用解法快几个数量级。# 生成一维数据 u = np.random.randn(10000) v = np.random.randn(12000) + 2.0 a_1d, b_1d = ot.unif(len(u)), ot.unif(len(v)) # 快速计算1D Wasserstein距离 W1d = ot.wasserstein_1d(u, v, a_1d, b_1d, p=2) print(f"1D Wasserstein距离: {W1d}") -
GPU与自动微分后端:POT支持 PyTorch, JAX, TensorFlow 作为后端。这意味着你可以将OT计算无缝嵌入到深度学习模型中,利用GPU加速,并且OT损失函数可以参与反向传播。这是POT库近年来一个巨大的优势。
# 示例:使用PyTorch后端(需要安装torch) import torch import ot # 将numpy数组转换为torch张量 a_torch = torch.from_numpy(a).requires_grad_(False) b_torch = torch.from_numpy(b).requires_grad_(False) M_torch = torch.from_numpy(M).requires_grad_(False) # 使用 ot.sinkhorn2 计算距离(POT会自动检测张量类型并使用对应后端) W_torch = ot.sinkhorn2(a_torch, b_torch, M_torch, reg=0.1) print(f"PyTorch后端计算的W距离: {W_torch.item()}")当你需要训练一个包含OT损失的GAN(生成对抗网络)或进行可微分的图匹配时,这个功能至关重要。
5. 避坑指南与最佳实践
在我多年的使用中,也踩过不少坑,这里分享几个关键点,能帮你节省大量时间。
1. 正则化参数 reg 的选择:这是使用Sinkhorn算法时最重要的超参数。reg 越小,解越接近精确的线性规划解,但算法收敛越慢,数值稳定性也越差(可能需要用到对数域的稳定化实现 ot.sinkhorn 的 method=’sinkhorn_stabilized’)。reg 越大,解越平滑,计算越快,但近似误差越大。我的经验是,先从 0.1 或 0.01 开始尝试,根据结果的质量和速度进行调整。在深度学习训练中,reg 可以作为一个可学习的参数,或者使用一个较小的固定值(如 1e-3)。
2. 代价矩阵的构造:代价矩阵 M 定义了问题的本质。除了欧氏距离,POT的 ot.dist 函数支持很多度量,如 cityblock(曼哈顿距离)、cosine(余弦距离)等。对于非欧氏空间的数据(如文本、图),你可能需要自定义代价矩阵。确保你的代价函数符合你的问题直觉,比如在颜色迁移中,使用Lab空间的欧氏距离就比RGB空间更合理。
3. 内存问题:传输矩阵 T 的大小是 n x m。当 n 和 m 达到上万时,存储一个稠密的 T 矩阵会消耗数GB内存。此时,你有几个选择:
* 使用 ot.sinkhorn2 只计算距离,不返回 T。
* 使用 ot.bregman.empirical_sinkhorn 等面向样本的函数,它们的内存效率更高。
* 考虑使用 geomloss 库(与POT兼容),它提供了高度优化的、支持批处理和GPU的OT求解器,特别适合大规模深度学习。
4. 理解“免费午餐”的局限:Wasserstein距离虽然强大,但计算成本也高。对于非常高维的数据,“维度诅咒”会使OT计算变得极其困难且结果可能缺乏意义(因为在高维空间中,所有点对之间的距离都差不多)。这时,可以考虑降维技术,或者使用 Sliced Wasserstein Distance,它通过随机投影将高维OT转化为一系列一维OT,大大降低了计算量。POT也提供了 ot.sliced_wasserstein_distance 函数。
最后,POT拥有极其丰富的官方示例库(Gallery),涵盖了从基础到前沿的几乎所有应用场景。当你不知道如何下手时,去那里找找灵感,复制代码跑一跑,是最高效的学习方式。这个库的社区也很活跃,遇到问题在GitHub上提Issue,通常能得到及时的回复。
2771



被折叠的 条评论
为什么被折叠?



