SimMatch: Semi-supervised Learning with Similarity Matching

现有的半监督学习策略：

1. 在一个大规模数据集上进行预训练，并用少量标签数据微调
   （缺点在于，完全未利用到标签信息）
2. 使用有标签数据训练一个语义分类器，并通过这个分类器为无标签数据生成伪标签（pseudo label）。伪标签通常由弱视图或多个增强视图的平均预测产生。最后目标通过多个强增强视图和伪标签之间的交叉熵来构建
   （缺点在于，当标签数据十分有限时，所训练的语义分类器并不可靠，由此生成的伪标签将会出现“overconfidence”问题，即模型会去拟合那些置信度很好但是错误的伪标签，由此导致性能下降）

本文方法

1. 首先，希望强增强视图和弱增强视图具有相同的语义相似性（预测的标签）
2. 强增强视图与弱增强视图具有相同的实例特征（即实例之间的相似性），以便于进行更多的内在特征匹配

方法

语义相似性

对于有标签样本，

1. 对batch中所有样本随机应用一种弱增强$T_w(\cdot )$（例如旋转或裁剪）
2. 用一个encoder $F(\cdot )$提取特征信息，即$h=\mathcal{F}(T(x))$
3. 采用一个全连接类别预测头$\varphi (\cdot )$将${\mathbf{h}}_b$映射为语义相似度 ，即$p=\varphi (\mathbf{h})$

其中，有标签样本直接使用交叉熵损失进行优化：
$${\mathcal{L}}_s=\frac{1}{B}\sum \mathrm{H}(y,p)$$
对于无标签样本，

1. 随机应用弱增强或强增强的一种，并使用和有标签样本相同的处理方式，得到语义相似度$p^w$和$p^s$

2. 计算两种标签之间的无监督损失：
   $${\mathcal{L}}_u=\frac{1}{\mu B}\sum 1\left(\max DA\left(p^w\right)>\tau \right)\mathrm{H}\left(DA\left(p^w\right),p^s\right)$$
   这里$\tau$作为置信度阈值，且仅保留在伪标签中最大类别概率大于$\tau$的无标签样本。$DA(\cdot )$表示分布对齐策略，用于平衡伪标签的分布。

实例相似性

目的是希望强增强视图与弱增强视图具有类似的相似性分布。

1. 这里引入一个非线性映射头$g(\cdot )$，能将特征表示$\mathbf{h}$映射为一个低维嵌入，即${\mathbf{z}}_b=g({\mathbf{h}}_b)$

2. 遵循基于anchoring的方法，这里将${\mathbf{z}}_b^w$和${\mathbf{z}}_b^s$分别表示为来自弱增强和强增强的嵌入

3. 现在，假设对于一簇不同的样本${\mathbf{z}}_k:k\in (1,\dots ,K)$，具有K个弱增强嵌入，使用相似度函数$sim(\cdot )$计算${\mathbf{z}}^w$和第i个实例${\mathbf{z}}_i$之间的相似度：
   $$\mathrm{sim}(\mathbf{u},\mathbf{v})=\frac{{\mathbf{u}}^{\hat{T}}\mathbf{v}}{\Vert \mathbf{u}\Vert \Vert \mathbf{v}\Vert }$$
   使用softmax函数处理相似度计算结果，得到相似度分布：
   $$q_i^w=\frac{\exp \left(\mathrm{sim}\left({\mathbf{z}}_b^w,{\mathbf{z}}_i\right)/t\right)}{{\sum }_{k=1}^K\exp \left(\mathrm{sim}\left({\mathbf{z}}_b^w,{\mathbf{z}}_k\right)/t\right)}$$
   其中$t$为温度系数，用于控制分布的平滑程度。

4. 同样计算${\mathbf{z}}^s$和${\mathbf{z}}_i$之间的相似度分布：
   $$q_i^s=\frac{\exp \left(\mathrm{sim}\left({\mathbf{z}}_b^s,{\mathbf{z}}_i\right)/t\right)}{{\sum }_{k=1}^K\exp \left(\mathrm{sim}\left({\mathbf{z}}_b^s,{\mathbf{z}}_k\right)/t\right)}$$

5. 最后，可以通过最小化$q^s$和$q^w$之间的差异实现一致性正则化（consistency regularization），这里采用交叉熵损失实现：
   $${\mathcal{L}}_{in}=\frac{1}{\mu B}\sum \mathrm{H}\left(q^w,q^s\right)$$
   这里需要注意的是，这种实例的一致性正则化只应用于无标签样本。

最终的损失函数为：
$${\mathcal{L}}_{\text{overall }}={\mathcal{L}}_s+{\lambda }_u{\mathcal{L}}_u+{\lambda }_{in}{\mathcal{L}}_{in}$$
其中，${\lambda }_u$和${\lambda }_{in}$是控制两种损失权重的平衡因子。

通过SimMatch 进行标签传播

由于上述过程完全未利用到标签信息，这里进一步介绍一种能利用到标签信息的方法，并允许语义相似性和实例相似性相互交互。

具体做法：

1. 实例化一个带标签的内存缓冲区，用于存放所有标注的样本（$q_i^w$和$q_i^s$），这样使得每个用到的样本都被指定一个特定的类别。

   如果我们将$\varphi (\cdot )$中的向量（由有标签样本生成）解释为"中心化"的类引用，那么我们标记的内存缓冲区中的embedding（由无标签样本生成）可以看作是实例个体引用的集合。

2. 给定一个弱增强样本，文中首先计算它的语义相似度（可以认为是类别标签）$p^w\in {\mathbb{R}}^{1\times L}$和实例相似度$q^w\in {\mathbb{R}}^{1\times K}$（这里L一定是远小于K的，因为文中希望每个类别至少具有一个样本（L即为类别数））

   使用语义相似度来校准实例相似度

3. 为了使用$p^w$ 校准$q^w$，我们需要将$p^w$展开到$K$维空间，文中将其表示为$p^{unfold}$。文中通过为每个已标记的嵌入匹配相应的语义相似性来实现这一点，即：
   $$p_i^{unfold}=p_j^w,\text{ where }\mathrm{class}\left(q_j^w\right)=\mathrm{class}\left(p_i^w\right)$$
   其中，$class(\cdot )$是返回ground truth类别的函数。

   具体来说，$class(q_j^w)$表示内存缓冲区中第j个元素的标签，$class(p_i^w)$表示第i个类。

4. 接下来，通过使用$p^{unfold}$对$q^w$进行缩放来重新生成校准后的实例的伪标签，可以表示为如下形式：
   $${\hat{q}}_i=\frac{q_i^w{p}_i^{unfold}}{{\sum }_{k=1}^K{q}_k^w{p}_k^{\text{unfold }}}$$

5. 将校准后的伪标签$\hat{q}$作为新的目标并替代之前计算损失${\mathcal{L}}_{in}$中的$q^w$

   使用实例相似度调整语义相似度

6. 首先将$q$汇聚到$L$维空间，记为$q^{agg}$，通过对具有相同ground-truth的实例求和进行实现：
   $$q_i^{agg}=\sum _{j=0}^{K}1\left(\mathrm{class}\left(p_i^w\right)=\mathrm{class}\left(q_j^w\right)\right)q_j^w$$

7. 通过使用$q^{agg}$平滑$p^w$重新生成调整过的语义伪标签，：
   $${\hat{p}}_i=\alpha p_i^w+(1-\alpha )q_i^{agg}$$
   其中$\alpha$作为超参数控制语义信息和实例信息的权重

8. 同样地，将校准后的伪标签$\hat{p}$作为新的目标并替代之前计算损失${\mathcal{L}}_u$中的$p_i^w$

9. 此时，伪标签$\hat{p}$和$\hat{q}$便都具有语义和实例级别的信息

其意义在于：当语义相似度和实力相似度接近时，意味着两个分布与彼此的预测一致，由此生成的伪标签将具有更高的置信度，从而更加可靠

整个训练过程如图所示。

细节实现

unfold操作

batch_u = 1
num_class = 10
K = 256 

prob_ku_orig = torch.zeros((batch_u, num_class)) #(1, 10)
labels = torch.zeros(K, dtype=torch.long) #(256, )
index = labels.expand([batch_u, -1]) #(1, 256)

factor = prob_ku_orig.gather(1, index) # p^{unfold}
print(prob_ku_orig.shape, factor.shape)
# torch.Size([1, 10]) torch.Size([1, 256])

# e.g.
prob = torch.tensor([[0.15, 0.8, 0.05]])
print(prob)
labels = torch.tensor([1,0,0,2,1])
index = labels.expand([1, -1])
prob.gather(1, index)
# tensor([[0.8000, 0.1500, 0.1500, 0.0500, 0.8000]])

aggregate操作

bs = teacher_prob_orig.size(0) # batch_u
aggregated_prob = torch.zeros([bs, self.num_classes], device=teacher_prob_orig.device)
aggregated_prob = aggregated_prob.scatter_add(1, self.labels.expand([bs,-1]), teacher_prob_orig) #q^{agg}