【人工智能概论】 Python标准库——dalib（领域自适应）

---

一. 领域鉴别器（DomainDiscriminator）

dalib.modules.domain_discriminator.DomainDiscriminator(in_feature: int, hidden_size: int)

• 功能： 区分输入的特征是来自源域还是目标域，源域标签为1，目标域标签为0。
• 参数：

• in_feature（int）： 输入特征的维度；
• hidden_size（int）： 隐层特征的维度。

• 形状：

• inputs：（minibatch， in_feature）；
• outputs： （minibatch， 1）。

• 举例：

• 见 领域对抗损失（DomainAdversarialLoss） 的举例。

二. 领域对抗损失（DomainAdversarialLoss）

dalib.adaptation.dann.DomainAdversarialLoss(domain_discriminator: torch.nn.modules.module.Module, reduction: Optional[str]= 'mean')

• 定义： $$Loss(D_s,D_t)=E_{x_i^s⌢D_s}log[D(f_i^s)]+E_{x_j^t⌢D_t}log[1-D(f_j^t)]$$其中，D是领域鉴别器，f是领域的特征。
• 参数：

• domain_discriminator（nn.Module） ： 域鉴别器对象，用于预测特征的域；
• reduction（string，Optional） ： 指定输出损失的方式，‘none’， ‘sum’，‘mean’，其中’none’指不使用任何降维直接输出，‘sum’、'mean’分别是对损失求和、求均值，默认为求均值。

• 输入：

• f_s （tensor）：源域的特征$f^s$；
• f_t （tensor） ：目标域的特征$f^t$。

• 形状：

• f_s， f_t ： （N, F）F是输入特征的维度；
• outputs ： 默认是标量，但如果reduction是’none’输出的形状是（N，）。

• 举例：

from dalib.modules.domain_discriminator import DomainDiscriminator
from dalib.adaptation.dann import DomainAdversarialLoss

discriminator = DomainDiscriminator(in_feature= 1024, hidden_size= 2048)
loss = DomainAdversarialLoss(discriminator, reduction= 'mean')

f_s, f_t = torch.rand(20, 1024), torch.rand(20, 1024)
output = loss(f_s, f_t)

print(output)

三. 高斯核（GaussianKernel）

dalib.modules.kernels.GaussianKernel(sigma: Optional[float] = None, track_running_stats: Optional[bool] = True, alpha: Optional[float] = 1.0)

• 定义：

• 高斯核$k$的定义：$$k(x_1,x_2)=exp(-\frac{{\Vert x_1-x_2\Vert }^2}{2{\sigma }^2})$$ 其中$x_1,x_2\in R^d$是一维张量。
• 高斯核矩阵$K$被定义在$X=(x_1,x_2,...x_m)$上：$$K(x{)}_{i,j}=k(x_i,x_j)$$
• 在运算中${\sigma }^2$有两种确认方法：
  第一种通过下式计算动态获得：$${\sigma }^2=\frac{\alpha }{n^2}\sum _{i,j}{\Vert x_i-x_j\Vert }^2$$
  第二种是直接给定数值。

• 参数：

• sigma(float, optional)： 即$\sigma$，默认为None；
• track_running_stats(bool, optional)：如果是’True’则用前面的公式计算${\sigma }^2$，若为’False’则使用固定的${\sigma }^2$，默认为’True’；
• alpha(float, optional)：当track_running_stats为’True’时为计算${\sigma }^2$提供$\alpha$。

• 输入：

• X(tensor)：输入组X。

• 形状：

• inputs：(minibatch, F) ， F是输入特征的维数；
• outputs：(minibatch, minibatch) 。

四. 多核最大均值差异（MK-MMD）

dalib.adaptation.dan.MultipleKernelMaximumMeanDiscrepancy（kernels: Sequence[torch.nn.modules.module.Module], Linear: Optional[bool]= False, quadratic_program: Optional[bool]= False）

• MK-MMD：

• 源域为： D s = { ( x i s , y i s ) } i = 1 n s D_{s}= \left \{ (x_{i}^{s},y_{i}^{s}) \right \}_{i=1}^{n_{s}} Ds​={(xis​,yis​)}i=1ns​​
• 目标域：$$D_t={\left\{x_j^t\right\}}_{j=1}^{n_t}$$
• 它们各自的样本间都符合独立同分布；

• 则MK-MMD的计算公式为：$$d_{MK-MMD}(D_s,D_t)={\Vert E_s[g(D_s)]-E_t[g(D_t)]\Vert }_{H_k}^2$$
• $H_k$表示具有特定内核$k$的$RKHS$，$g(\ast )$是与核函数相关的连续映射，$E[\ast ]$是给定分布的期望；

• 应当注意的是，核函数$k$是被定义为$r$个不同的半正定核的凸组合，如下形式：$$k(x^s,x^t)={\sum }_{i=1}^r{\beta }_i{k}_i(x^s,x^t)$$
• 其中：$${\sum }_i^r{\beta }_i=1,{\beta }_i\ge 0$$
• 所谓半正定性是核函数的常见的性质（可以联系SVM中的相关概念学习），凸组合是一种线性组合，若满足$${\lambda }_i\ge 0，{\sum }_i^r{\lambda }_i=1$$则${\sum }_i^r{\lambda }_i{x}_i$即为凸组合；

• 使用内核技巧，MK-MMD可以简化计算为：$${\hat{D}}_k(D_s,D_t)=\frac{1}{n_s^2}{\sum }_{i=1}^{n_s}{\sum }_{j=1}^{n_s}k(D_s^i,D_s^j)+\frac{1}{n_t^2}{\sum }_{i=1}^{n_t}{\sum }_{j=1}^{n_t}k(D_t^i,D_t^j)-\frac{2}{n_s{n}_t}{\sum }_{i=1}^{n_s}{\sum }_{j=1}^{n_t}k(D_s^i,D_t^j)$$

• 参数：

• Kernel(tuple(nn.Module))： 核方程；
• Linear(bool)：是否使用DAN的线性版本，默认不用；
• quadratic_program(bool)： 是否使用二次规划求解$\beta$，默认不用。

• 输入：

• d_s(tensor)：源域通过映射所得的特征$D_s$；
• d_t(tensor)： 目标域通过映射所得的特征$D_t$。
• 注意它俩必须相同的形状。

• 形状：

• inputs： (minibatch, *) *代表任意数，实际上就是传入的特征维度；
• outputs： 标量。

• 举例：

from dalib.modules.kernels import GaussianKernel
from dalib.adaptation.dan import MultipleKernelMaximumMeanDiscrepancy

feature_dim = 1024
batch_size = 10

kernels = (GaussianKernel(alpha=0.5), GaussianKernel(alpha=1.), GaussianKernel(alpha=2.))
loss = MultipleKernelMaximumMeanDiscrepancy(kernels)

# features from source domain and target domain
z_s, z_t = torch.randn(batch_size, feature_dim), torch.randn(batch_size,feature_dim)
output = loss(z_s, z_t)

print(output)