[总结] 半监督学习方法: 协同训练&类协同训练(Co-training)

Co-training 最早在 1998 年提出, 是基于分歧的方法, 其假设每个数据可以由不同的视图(View)表示, 不同视图可以训练出不同的分类器, 利用这些分类器对无标签样本进行分类, 再挑选最自信的无标签样本加入训练集中. 这种多视图的方法需要满足两个假设:

• 每个视图都包含足够产生最优学习器的信息, 此时对其中任一视图来说, 另一个视图则是冗余的, 即冗余性.
• 两个数据 $x_1$ 和 $x_2$ 在给定标签的情况下是条件独立的. 即给定标记时每个属性集都条件独立于另一个属性集.

不过该假设非常强, 大多现实数据无法满足此假设, 或很难划分出冗余的视图. 于是便有了其他协同训练的变种: 由多视图转变为多学习器. 例如 Co-forest 等, 核心思想为在一个视图上训练多个不同的学习器, 这些学习器之间存在一定的差异. 另外也有方法通过去构建多个充分独立的视图模型来近似 Co-training 假设, 如 Deep Co-training 等.

blog 文章传送门:

• Co-training
• COREG
• Democratic Co-Learning
• CoBCReg
• Deep Co-training
• Tri-training
• Disagreement Tri-training
• Tri-net
• Tri-TS

1. Co-training

定义一个实例空间 $X=X_1\times X_2$, 其中 $X_1$, $X_2$ 对应于同一实例的两个不同"视图". Co-training 算法流程如下:

• 步骤1: 定义带标签的训练集 $\mathbf{L}$ 和无标签数据集 $\mathbf{U}$.
• 步骤2: 从 $\mathbf{U}$ 中随机选择 $u$ 个实例来创建样本缓冲池 ${\mathbf{U}}^{\prime }$. $\mathbf{U}=\mathbf{U}\backslash {\mathbf{U}}^{\prime }$.
• 步骤3: 分别考虑两个视图 $x_1$ 和 $x_2$, 使用 $\mathbf{L}$ 训练出分类器 $h_1$ 和 $h_2$.
• 步骤4: 用 $h_1$ 对 ${\mathbf{U}}^{\prime }$ 中所有元素进行标记, 从中选出置信度高的 $p$ 个正标记和 $n$ 个负标记, $h_2$ 同理. U ′ = U ′ \ { U p ′ ∪ U n ′ } \mathbf{U}'=\mathbf{U}' \backslash \{\mathbf{U_p}' \cup \mathbf{U_n}'\} U′=U′\{Up​′∪Un​′}.
• 步骤5: 将这些标记实例加入到 $L$ 中, 即 $h_1$ 选出的 $p+n$ 个标记实例加入到 $x_2$ 中, $h_2$ 选出的 $p+n$ 个标记实例加入到 $x_1$ 中. 再随机从 $\mathbf{U}$ 中选择 $2p+2n$ 个样本到 ${\mathbf{U}}^{\prime }$ 中.
• 步骤3到步骤5迭代 $k$ 次.

2. COREG

COREG 既不假设有两个视图, 也不假设使用不同的学习算法. 在这里, 回归器 $h_1$ 和 $h_2$ 都采用 $k$-NN 算法. 不过这两个 $k$-NN 回归器通过用不同的距离度量或不同的 $k$ 值来实例化, 借此来实现多样性. 在学习过程中, 每个回归器都为另一个回归器标记未标记示例.

选择 $k$-NN 回归器理由如下:

• $k$-NN 算法是一种惰性学习方法, 不需要单独的训练阶段.
• 为了选择合适的未标记示例进行标记, 应估计标记置信度, 在 COREG 中, 置信度估计使用了训练示例的邻近属性, 可以很容易地与 $k$-NN 回归器耦合.

COREG 算法流程如下:

• 首先通过不同的参数设置初始化两个 $k$-NN 回归器 $h_1$, $h_2$, 两个回归器的训练集分别为 $L_1$, $L_2$. 注意这两个初始训练集为原始训练集 $L$ 的副本.
• 对于每个未标记数据集 $U^{\prime }$ 中的 ${\mathbf{x}}_u$, 计算其邻居示例得到集合 ${\Omega }_u$.
• 利用回归器 $h_j$, j ∈ { 1 , 2 } j \in \{1,2\} j∈{1,2} 对 ${\mathbf{x}}_u$ 进行预测, 得到预测结果 ${\hat{\mathbf{y}}}_u$. 并将其添加到训练集 $L_j$ 中, 然后重新训练一个 $k$-NN 回归器 $h_j^{\prime }$.
• 接着计算 MSE: ${\delta }_{x_u}={\sum }_{x_i\in {\Omega }_u}((y_i-h({\mathbf{x}}_i){)}^2-(y_i-h^{\prime }({\mathbf{x}}_i){)}^2)$.
• 完成上述工作后, 如果存在 ${\delta }_{{\mathbf{x}}_u}>0$, 则最大化 ${\delta }_{{\mathbf{x}}_u}$ 得到 ${\tilde{\mathbf{x}}}_j$, 利用 $h_j$ 对其预测得到 ${\tilde{\mathbf{y}}}_j$, 将 { ( x ~ j , y ~ j ) } \{(\tilde{\mathbf{x}}_j,\tilde{\mathbf{y}}_j)\} {(x~j​,y~​j​)} 添加到 ${\pi }_j$ 中, 并将 ${\tilde{\mathbf{x}}}_j$ 从 $U^{\prime }$ 中去除.
• 经过一些列迭代, 最终得到 ${\pi }_1$, ${\pi }_2$, 并将 ${\pi }_1$ 添加到 $L_2$ 中, ${\pi }_2$ 添加到 $L_1$ 中. 利用最新的数据集 $L_1$, $L_2$ 重新训练回归器得到 $f_1$, $f_2$. 最终的预测结果为两个回归器和的平均值.

3. Democratic Co-Learning

Democratic Co-Learning 也是采用单视图多学习器的策略, 像是民主投票, 以多数票的形式进行数据挑选.

定义 $\mathbf{L}$ 为标记数据集, $\mathbf{U}$ 为无标记数据集, $A_1,\dots ,A_n$ 为分类器, 每个分类器对 $\mathbf{U}$ 中的未标记数据 $x$ 预测一个类别 c i ∈ C = { c 1 , … , c r } c_i \in \mathcal{C}=\{c_1,\dots,c_r\} ci​∈C={c1​,…,cr​}, 并令 $c_k$ 表示多数分类器预测一致的结果(将这些分类器的集合称为多数团体(Majoritty Group)). 将这些结果加入到 $\mathbf{L}$ 中, 然后继续进行训练, 直到满足没有可挑选的未标记数据为止. Democratic Co-Learning 算法如下图所示:

初始阶段, 初始化模型:

• 使用不同学习算法 $A_i$ 在 ${\mathbf{L}}_{\mathbf{i}}$ 上训练分类器 $H_i$.
• 使用 $H_i$ 为 $\mathbf{U}$ 上的每个示例 $x$ 预测一个标签值 $c_j$, 令 $c_k$ 为 majority prediction.

民主优先采样阶段, 选择未标记示例给专家标记, 并加入对应训练集:

• 计算 $H_i$ 在 $\mathbf{L}$ 上的 95% 置信区间 $[l_i,h_i]$ 和平均置信度 $(l_i+h_i)/2$.
• 初始化 $n$ 个 ${\mathbf{L}}^{\prime }$, 如果多数团体的平均置信值之和大于少数团体的平均置信值之和, 则将 $(x,c_k)$ 加入到 ${{\mathbf{L}}_{\mathbf{i}}}^{\prime }$ 中.

评估阶段, 评估将 ${{\mathbf{L}}_{\mathbf{i}}}^{\prime }$ 添加到 ${\mathbf{L}}_{\mathbf{i}}$ 中是否提升准确率:

• 计算 $H_i$ 在 ${\mathbf{L}}_i$ 上的 95% 置信区间 $[l_i,h_i]$, 然后分别计算在 ${\mathbf{L}}_i$, ${\mathbf{L}}_i^{\prime }$ 和 ${\mathbf{L}}_i\cup {\mathbf{L}}_i^{\prime }$ 上的错误率 $q_i$, $e_i^{\prime }$ 和 $q_i^{\prime }$.
• 如果 $q_i^{\prime }>q_i$ 则将 ${{\mathbf{L}}_{\mathbf{i}}}^{\prime }$ 添加到 ${\mathbf{L}}_{\mathbf{i}}$ 中

重复以上操作直到 ${\mathbf{L}}_1,\cdots {\mathbf{L}}_n$ 不再变化为止. 最终通过 Combine 函数返回一组分类器.

4. CoBCReg

CoBCReg 的思想与 Democratic Co-Learning 非常类似, CoBCReg 中使用了一个预测器委员会来预测未标记的示例.

CoBCReg 算法如下所示:

• 步骤1. 遍历委员会中的每一个回归器, 对标记数据集使用随机采样获得 { L i , V i } \{L_i,V_i\} {Li​,Vi​}, 其中 $L_i$ 为包内数据, 即选择的用于训练的数据, $V_i$ 为包外数据(用于测试集). 利用 RBFNN 训练得到回归器 $h_i$.
• 步骤2. 对于每次迭代 $i$, 从 $U$ 中随机抽取 $u$ 个示例到缓冲池 $U^{\prime }$. 应用 SelectRelevantExamples 方法使同伴委员会 $H_i$ (除 $h_i$ 之外的所有成员组成)估计 $U^{\prime }$ 中每个未标记示例的输出, 并返回最有意义的未标记示例 ${\pi }_i$.
• 步骤3. 对于每次迭代 $i$, 如果 ${\pi }_i$ 不为空, 则将其加入到 $L_i$, 然后利用更新后的 $L_i$ 通过 RBFNN 重新训练回归器 $h_i$.
• 重复步骤2, 3, 直到达 $t$ 到最大迭代次数 $T$ 或 $U$ 变为空.
• 最终返回回归器 $H(x)$, 即委员会所有回归器的加权和.

其中 SelectRelevantExamples 算法如下:

• 首先计算 $h_j$ 在验证集 $V_j$ 上的 RMSE ${ϵ}_j$.
• 对于 $U^{\prime }$ 中每个未标记示例 $x_u$, 对委员会中的所有回归器(除去 $h_j$)的预测结果取均值, 得到 { x u , H j ( x u ) } \{x_u,H_j(x_u)\} {xu​,Hj​(xu​)}, 并将其加入到 $L_j$ 中.
• 利用更新后的 $L_j$ 通过 RBFNN 重新训练回归器 $h_j^{\prime }$. 然后 $h_j^{\prime }$ 计算在验证集 $V_j$ 上的 RMSE ${ϵ}_j^{\prime }$.
• 接着计算 ${\Delta }_{x_u}\leftarrow ({ϵ}_j-{ϵ}_j^{\prime })/{ϵ}_j$.
• 对 $U^{\prime }$ 迭代完成后, 定义空集合 $\pi$.
• 通过 $gr$ 次迭代, 选择 $gr$ 个使 ${\Delta }_{x_u}$ 最大的结果对应的未标记示例 $x_u$, 将其加入到 ${\pi }_j$ 中.
• 最后返回 ${\pi }_j$.

5. Deep Co-training

Co-Training 假设 $\mathcal{D}=\mathcal{S}\cup \mathcal{U}$ 中的每个数据 $x$ 有两个视图, 即 $x=(v_1,v_2)$, 每个视图 $v_i$ 都足以学习一个有效的模型. 其中 $\mathcal{S}$, $\mathcal{U}$ 分别表示标记数据集和未标记数据集. 给定 $\mathcal{D}$ 的分布 $\mathcal{X}$, Co-Training 假设表示如下:
$$f(x)=f_1(v_1)=f_2(v_2),\forall x=(v_1,v_2)\sim \mathcal{X}$$

• 在 Deep Co-training 中, $v_1(x)$ 和 $v_2(x)$ 是 $x$ 在最终全连接层 $f_i(\cdot )$ 之前的卷积表示. 在标记数据集 $\mathcal{S}$ 上的标准交叉熵损失函数定义为:
  $${\mathcal{L}}_{\mathrm{s}\mathrm{u}\mathrm{p}}(x,y)=H(y,f_1(v_1(x)))+H(y,f_2(v_2(x)))$$
  其中 $H(p,q)$ 表示交叉熵. 而对于未标记数据集 $\mathcal{U}$, 基于 Co-Training 假设, 期望 $f_1(v_1(x))$ 和 $f_2(v_2(x))$ 有相似的预测, 使用 JS 散度来进行 $f_1(v_1(x))$ 和 $f_2(v_2(x))$ 之间的相似性度量, 损失函数定义如下:
  $${\mathcal{L}}_{\mathrm{c}\mathrm{o}\mathrm{t}}(x)=H(\frac{1}{2}(f_1(v_1(x))+f_2(v_2(x))))-\frac{1}{2}(H(f_1(v_1(x)))+H(f_2(v_2(x))))$$
  其中 $H(p)$ 表示 $p$ 的熵.

• 利用 $g(x)$ 从 $\mathcal{D}$ 中生成对抗样本数据集 ${\mathcal{D}}^{\prime }$, 在 ${\mathcal{D}}^{\prime }$ 中 $f_1(v_1(g(x)))\ne f_2(v_2(g(x)))$. 希望 $g(x)$ 与 $x$ 之间足够小, 以便于对抗样本还能保持自然的图像特征. 不过当 $g(x)-x$ 很小时, 有很大概率会出现 $f_1(v_1(g(x))=f_1(v_1(x))$ 和 $f_2(v_2(g(x))=f_2(v_2(x))$, 这就与我们的想法违背. 即希望当 $f_1(v_1(g(x))=f_1(v_1(x))$ 出现时, 需满足 $f_2(v_2(g(x))\ne f_2(v_2(x))$. 通过交叉熵来训练网络 $f_1$, $f_2$, 使得可以抵抗相互的对抗示例:
  $${\mathcal{L}}_{\mathrm{d}\mathrm{i}\mathrm{f}}(x)=H(f_1(v_1(x)),f_2(v_2(g_1(x))))+H(f_1(v_1(g_2(x))),f_2(v_2(x)))$$
  最终的损失函数定义为:
  $$\mathcal{L}={\mathbb{E}}_{(x,y)\in \mathcal{S}}{\mathcal{L}}_{\mathrm{s}\mathrm{u}\mathrm{p}}(x,y)+{\lambda }_{\mathrm{c}\mathrm{o}\mathrm{t}}{\mathbb{E}}_{x\in \mathcal{U}}{\mathcal{L}}_{\mathrm{c}\mathrm{o}\mathrm{t}}(x)+{\lambda }_{\mathrm{d}\mathrm{i}\mathrm{f}}{\mathbb{E}}_{x\in \mathcal{D}}{\mathcal{L}}_{\mathrm{d}\mathrm{i}\mathrm{f}}(x)$$

6. Tri-training

Tri-training 核心思想简述如下: 假设除了分类器 $h_1$ 和 $h_2$ 之外, 利用标记数据再训练了一个分类器 $h_3$. 那么, 对于任何分类器, 只要其他两个分类器同意这个示例的标签, 则可以将其标记起来, 而分类器标记的置信度不需要明确测量. 例如, 如果 $h_2$ 和 $h_3$ 同意示例 $x$ 的标记结果, 则可以将标记 $x$ 加入到 $h_1$ 中. 其具体算法如下:

首先利用 Bootstrap 重采样, 从有标签数据集 $L$ 里采样三个子数据集 $S_i$, $S_j$, $S_k$. 利用三个子数据集训练三个基分类器 $h_i$, $h_j$, $h_k$. 并初始化 $e_i^{\prime }=0.5$, $l_i^{\prime }=0$. 这里 $e_i^{\prime }$ 表示 $h_j\&h_k$ 的分类错误率的上界, 即 $h_j$ 和 $h_k$ 组合得出的假设的错误率. $l_i^{\prime }$ 用作与挑选的未标记示例集 $L_i$ 的大小做比较.

接着迭代每个分类器, 首先, 初始化挑选数据集 $L_i=\varnothing$; 使用 MeasureError 函数计算 $e_i$; 初始化分类器 $h_i$ 的更新标志 $updat{e}_i=FALSE$.

当满足 $e_i<e_i^{\prime }$ 时, 对于分类器 $h_i$, 使用另外两个分类器预测所有未标注数据集, 挑选出其中预测结果相同的样本, 作为新的有标签数据 $(x,h_j(x))$, 并加入到分类器 $h_i$ 的训练集 $L_i$ 中. 当 $l_i^{\prime }=0$ 时(即刚初始化, $h_i$ 还没经过训练进行更新), 通过下式计算 $l_i^{\prime }$:
$$l_i^{\prime }=\lfloor \frac{e_i}{e_i^{\prime }-e_i}+1\rfloor$$
当 $l_i^{\prime }<|L_i|$ 时, 如果 $e_i|L_i|<e_i^{\prime }{l}_i^{\prime }$, 则表示分类器 $h_i$ 已更新: $updat{e}_i=True$, 如果 $l_i^{\prime }>\frac{e_i}{e_i^{\prime }-e_i}$, 则通过函数 Subsample 从 $L_i$ 中随机选择 $|L_i|-\lceil \frac{e_i}{e_i^{\prime }-e_i}+1\rceil$ 个示例删除, 同时更新 $updat{e}_i=True$.

迭代完成后, 检查每个分类器的更新状态, 如果分类器 $i$ 已更新, 则将与之对应的 $L_i$ 加入到 $L$ 中, 利用扩增的数据集 $L$ 更新分类器 $i$, 同时用 $e_i$ 更新 $e_i^{\prime }$, $|L|$ 更新 $l_i^{\prime }$.

重复上述分类器迭代过程, 直到每个分类器不在变化为止. 最终得到三个训练完成的分类器, 通过 $\underset{y\in label}{\mathrm{argmax}}{\sum }_{h_i(x)=y}1$ 来预测结果, 即投票原则.

7. Disagreement Tri-training

带分歧的 Tri-training 只对 Tri-training 进行简单改动, 如下所示:

非常容易理解, 如果分类器 $c_j$ 和 $c_k$ 都同意对数据 $x$ 的预测, 但 $c_i$ 不同意, 就可以自然的认为 $x$ 是 $c_i$ 的弱点. 并希望通过 $x$ 来加强 $c_i$.

8. Tri-net

Tri-net 的训练过程如下图:

阶段1: 初始化

Tri-net 的第一步是生成三个多样的模型. Tri-net 由一个共享模型 $M_S$ 和另外三个不同的模型 $M_1$, $M_2$ 和 $M_3$ 组成. 为了得到三个准确多样的模型, 使用 Output Smearing 来生成三个不同的标记数据集: ${\mathcal{L}}_{os}^1$, ${\mathcal{L}}_{os}^2$ 和 ${\mathcal{L}}_{os}^3$. 在三个数据集上同时训练 $M_S$, $M_1$, $M_2$ 和 $M_3$. 网络结构如下:

阶段2: 训练

和 tri-training 思想一样, 如果两个模型对未标记示例的预测达成一致, 并且预测可靠且稳定, 则将这个具有伪标签示例加入到第三个模型的训练集中. 然后用增强的训练集细化第三个模型. 由于模型之间相互挑选增加了训练集, 所以三个模型会越来越相似. 为了解决这个问题, 对标记数据上的模型进行微调, 以在某些特定轮次中增加它们之间的多样性. 整个训练过程如下所示:

• 步骤1. 在 $\mathcal{L}$ 上使用 Output Smearing 生成三个不同的标记数据集: ${\mathcal{L}}_{os}^1$, ${\mathcal{L}}_{os}^2$ 和 ${\mathcal{L}}_{os}^3$.
• 步骤2. 在 ${\mathcal{L}}_{os}^1$, ${\mathcal{L}}_{os}^2$ 和 ${\mathcal{L}}_{os}^3$ 上训练 $M_S$, $M_1$, $M_2$, $M_3$.
• 步骤3. 训练 $M_v,v=1,2,3$. 初始化挑选样本集 ${\mathcal{P}\mathcal{L}}_v$, 首先通过 Labeling 函数让另外两个模型挑选出置信示例, 并添加到 ${\mathcal{P}\mathcal{L}}_v$ 中, 接着, 利用 DES 方法对 ${\mathcal{P}\mathcal{L}}_v$ 进行更新, 最后得到 $M_v$ 的训练样本 ${\hat{\mathcal{L}}}_v=\mathcal{L}\cup {\mathcal{P}\mathcal{L}}_v$. 注意, 如果刚开始训练 $M_1$ 时, 模型 $M_S$ 和 $M_1$ 一同通过 ${\hat{\mathcal{L}}}_v$ 训练, 其他两个模型进行训练时则不需要再对 $M_S$ 进行训练.
• 重复步骤3 $T$ 次, 最终返回训练完成的 $M_S$, $M_1$, $M_2$, $M_3$.

9. Tri-TS

同 Tri-Training, 首先从标记数据集 $L$ 中用 bootstrap 采样获得三个不同的数据集 $S_i$, $S_j$, $S_k$, 这样做的目的是增加多样性, 然后分别训练三个分类器 $m_i$, $m_j$, $m_k$. 对于未标记数据集 $U$ 中的示例 $x$, 每个分类器对其的预测结果分别为 $c_i$, $c_j$, $c_k$, 以及对应的概率 $p_i(c_i|x)$, $p_j(c_j|x)$, $p_k(c_k|x)$.

与原始 Tri-Training 中为 $x$ 分配多数投票标签的策略不同, 在 Teacher-Student 中, 从师生的角度对学习任务进行建模. 在迭代过程中, 如果 $p_j(c_j|x)$, $p_k(c_k|x)$ 同时大于 teacher 的阈值 ${\tau }_t$, 则将 $m_j$, $m_k$ 视作 teacher, 如果另一个分类器 $m_i$ 的预测概率小于 student 的阈值 ${\tau }_s$, 则将其视为 student. 未标记样本 $x$ 只有在被判别为可被教导(Teachable)后才会被分配一个标签. 选择 Teachable 样本的算法如下所示:

其标准如下:

• 分类器 $m_j$, $m_k$ 互相认同对方的分类结果 $c_k$, $c_j$.
• 两个 teacher 的预测置信度 $p_j$, $p_k$ 必须同时大于 ${\tau }_t$, 同时 student 的预测置信度 $p_i$ 必须小于 ${\tau }_s$.

完整的 Teacher Student Tri-training 算法如下所示: