对比学习笔记0

Supervised Contrastive Learning

创新

• 自监督对比方法扩展至全监督任务上。

区别

• 自监督对比损失$Eq.1$
  • 将一个正样本（即同一图片的增广版本）和有一组负样本（同一个batch里的其余样本）进行对比。
• 而监督对比损失$Eq.2$
  • 将正样本（同类别的所有样本）和负样本（同一个batch 内的其余的样本）进行对比。
    • 如图片中那条黑白狗所示，在 embedding 空间中我们考虑的是同类别的标签，相同类别的元素要比自监督情形下靠的更近。

3.2.1 self-supervised contrastive loss

$${\mathcal{L}}^{self}=\sum _{i\in 2N}{\mathcal{L}}_i^{self}=-\sum _{i\in 2N}log\frac{exp(z_i\cdot z_{j(i)}/\tau )}{\sum _{k\in 2N}{\mathbb{I}}_{i\ne k}exp(z_i\cdot z_k/\tau )}\text{\hspace{1em}(z1)}$$

---

$${\mathcal{L}}^{self}=\sum _{i\in I}{\mathcal{L}}_i^{self}=-\sum _{i\in I}log\frac{exp(z_i\cdot z_{j(i)}/\tau )}{\sum _{a\in A(i)}exp(z_i\cdot z_a/\tau )}\text{\hspace{1em}(1)}$$

符号表示

• $i\in I\equiv 1...2N$ 为任意增强样本的索引。
• $j(i)$
  • 是来自同一源样本的其他增强样本的索引。
  • 索引 $j(i)$ 称为正样本。
  • 其他$2(N-1)$个索引 ( { k ∈ A ( i ) / { j ( i ) } } ) (\lbrace k\in A(i)/\lbrace j(i)\rbrace\rbrace) ({k∈A(i)/{j(i)}}) 称为负样本。
• $z_{\ell }=Proj(Enc({\tilde{x}}_{\ell }))\in R^{D_P}$ 是使用图像数据增强手段，得到的数据。
  • $ Proj(\cdot)$ 将$r$映射为一个向量$ z=Proj®\in \mathbb{R}^{D_P}$
    • 多层感知机.
  • $Enc(\cdot )$ 将$x$映射为一个表征向量 $r=Enc(x)\in {\mathbb{R}}^{D_E}$
    • 增广后的两个样本会分别输入进该编码器$Enc(\cdot )$，得到一对表征向量。
• $\tau \in {\mathcal{R}}^{+}$ 是标量温度参数
  • 可以用来控制，$z_i\cdot z_{j(i)}$ (logits)的分布形状。
  • $\tau$ 变大，$z_i\cdot z_{j(i)}$ 会使原来logits分布里的数值都变小，经过指数运算之后更小，导致原来的logits分布变得更平滑。
    • 模型的对比损失会对所有的负样本一视同仁，导致模型学习没有轻重。
  • $\tau$ 变小，$z_i\cdot z_{j(i)}$ 会使原来logits分布里的数值都变大，经过指数运算之后更大，导致原来的logits分布变得更集中。
    • 模型会越关注特别困难的负样本，但其实那些负样本很可能是潜在的正样本，这样会导致模型很难收敛或者泛化能力差。
• A ( i ) ≡ I / { i } . A(i) ≡ I / \{i\}. A(i)≡I/{i}.是$I$中除了锚点$i$之外的其他锚点集。
• $i$ 是锚点
  • 每个$i$，有1个正样本对和 $2N-2$ 个负样本对。 分母共有 $2N-1$项（正样本和负样本）。

3.2.2 supervised contrastive Loss (key)

$$\begin{gathered} {\mathcal{L}}^{sup}=\sum _{i\in 2N}{\mathcal{L}}_i^{sup} \\ {\mathcal{L}}_i^{sup}=\frac{-1}{2N_{\widetilde{y_i}}-1}\sum _{j\in 2N}{\mathbb{I}}_{i\ne j}{\mathbb{I}}_{\widetilde{y_i}=\widetilde{y_j}}\cdot log\frac{exp(z_i\cdot z_{j(i)}/\tau )}{\sum _{k\in 2N}{\mathbb{I}}_{i\ne k}exp(z_i\cdot z_k/\tau )}\text{\hspace{1em}(z2)} \end{gathered}$$

---

$$
\mathcal{L}^{sup}{out} =
\underset {i \in I}{\sum} \mathcal{L}^{sup}{out,i}=
\underset {i \in I}{\sum} \frac{-1}{|P(i)|}\underset {p \in P(i)}{\sum}log \frac{exp(z_i\cdot z_p/ τ)}{\underset {a \in A{(i)}}{\sum}exp(z_i\cdot z_a/ τ)} \
\mathcal{L}^{sup}_{out,i}=\frac{-1}{|P(i)|}\underset {p \in P(i)}{\sum}log \frac{exp(z_i\cdot z_p/ τ)}{\underset {a \in A{(i)}}{\sum}exp(z_i\cdot z_a/ τ)}

\tag{3_key}
$$

---

$$\begin{gathered} {\mathcal{L}}_{in}^{sup}=\sum _{i\in I}{\mathcal{L}}_{in,i}^{sup}=\sum _{i\in I}-log\left\{\frac{1}{|P(i)|}\sum _{p\in P(i)}\frac{exp(z_i\cdot z_p/\tau )}{\sum _{a\in A(i)}exp(z_i\cdot z_a/\tau )}\right\} \\ {\mathcal{L}}_{in,i}^{sup}=-log\left\{\frac{1}{|P(i)|}\sum _{p\in P(i)}\frac{exp(z_i\cdot z_p/\tau )}{\sum _{a\in A(i)}exp(z_i\cdot z_a/\tau )}\right\}\text{\hspace{1em}(2)} \end{gathered}$$

来由

• $Eq.1$ 中的对比损失函数无法处理，多个一个样本属于同一类。
• $Eq.2$和$Eq.3$ 提出了两种最直接的方法来概括 $Eq.1$。
• 使用标准数据增广的交叉熵损失。

特性

• 泛化到任意数量的正样本。
• 负样本越多，对比效果越好。
• 执行困难的正/负样本挖掘的能力。

区别

• ${\mathcal{L}}_{out}^{sup}>{\mathcal{L}}_{in}^{sup}$
  • 因为 $log$ 是一个凹函数
  • ${\mathcal{L}}_{in}^{sup}$包含相同的归一化因子$\frac{1}{|P(i)|}$ ，它位于$log$中。 $\frac{1}{|P(i)|}$对整体损失贡献一个附加常数，而不会影响梯度。
  • 在没有任何归一化效果的情况下，${\mathcal{L}}_{in}^{sup}$的梯度$\frac{\partial {\mathcal{L}}_i^{sup}}{\partial z_I}$更容易受到正样本偏差的影响，从而导致次优训练。

符号表示

• $\tau \in {\mathcal{R}}^{+}$ 是标量温度参数

• $z_{\ell }=Proj(Enc({\tilde{x}}_{\ell }))\in R^{D_P}$ 是使用图像数据增强手段，得到的数据。

  • $Aug(\cdot )$对于每个输入样本$x$，我们生成两个随机增广样本。
    • $\tilde x=Aug(x) $ 每个都代表了该数据的不同角度，包含原数据的一些子信。
  • $ Proj(\cdot)$ 将$r$映射为一个向量$ z=Proj®\in \mathbb{R}^{D_P}$
    • 多层感知机.。
    • $x$表示样本。
  • $Enc(\cdot )$ 将$x$映射为一个表征向量 $r=Enc(x)\in {\mathbb{R}}^{D_E}$
    • 增广后的两个样本会分别输入进该编码器$Enc(\cdot )$，得到一对表征向量。

• A ( i ) ≡ I / { i } . A(i) ≡ I / \{i\}. A(i)≡I/{i}.是$I$中除了锚点$i$之外的其他锚点集（正样本和负样本）。

• $P(i)\equiv p\in A(i):{\tilde{y}}_p={\tilde{y}}_i$ 是与 $i$ 不同的多视图批次中所有正样本锚点集。

• $|P(i)|$是与 $i$ 不同的多视图批次中所有正样本锚点集的数量。

• $\frac{1}{|P(i)|}$

  • 是正样本归一化因子。
  • 用于消除导致损失的多视图批次中正样本中存在的偏差。

• $i$是锚点

  • 每个$i$，有1个正样本对和 $2N-2$ 个负样本对。 分母共有 $2N-1$项（正样本和负样本）。

• $p=j(i)$ 是一对正样本。

• k , k ∈ A ( i ) / { j ( i ) } k,k\in A(i)/ \{j(i)\} k,k∈A(i)/{j(i)} 是 $2N-2$ 个负样本对。

结论

论文给出的推倒仅能说明，
	严格的正负样本 在他们的loss下会产生更大的梯度，
	而这正是之前的对比学习方法要找  严格的样本 的原因，
	就是因为 严格的样本 可以更好的帮助模型更新。

code-Eq.3 (key)

注意

• loss.py 中的损失函数 $SupConLoss$ 将特征（$L2$ 归一化）和标签作为输入，并返回损失。
• 如果标签是 None 或没有传递给它，它会退化为 $SimCLR$。

# url:https://github.com/HobbitLong/SupContrast/blob/master/losses.py
"""
Author: Yonglong Tian (yonglong@mit.edu)
Date: May 07, 2020
"""
from __future__ import print_function

import torch
import torch.nn as nn


class SupConLoss(nn.Module):
    """Supervised Contrastive Learning: https://arxiv.org/pdf/2004.11362.pdf.
    It also supports the unsupervised contrastive loss in SimCLR"""
    def __init__(self, temperature=0.07, contrast_mode='all',
                 base_temperature=0.07):
        super(SupConLoss, self).__init__()

        self.temperature = temperature  # Eq.3: τ
        self.base_temperature = base_temperature
        self.contrast_mode = contrast_mode


    def forward(self, features, labels=None, mask=None):
        """Compute loss for model. If both `labels` and `mask` are None,
        it degenerates to SimCLR unsupervised loss:
        https://arxiv.org/pdf/2002.05709.pdf

        Args:
            features: hidden vector of shape [bsz, n_views, ...].
            labels: ground truth of shape [bsz].
            mask: contrastive mask of shape [bsz, bsz],
                mask_{i,j}=1 if sample j has the same class as sample i.
                Can be asymmetric.
                正样本邻接矩阵
        Returns:
            A loss scalar.
        """
        # 1。选择计算loss的设备
        device = (torch.device('cuda')
                  if features.is_cuda
                  else torch.device('cpu'))

        # 2. 判断图片特征规模是否满足需求
        if len(features.shape) < 3:
            raise ValueError('`features` needs to be [bsz, n_views, ...],'
                             'at least 3 dimensions are required')
        if len(features.shape) > 3:
            features = features.view(features.shape[0], features.shape[1], -1)

        # 3. 初始化 mask 和 labels，
        # 3. 查看mask 和 labels 是否满足要求
        batch_size = features.shape[0]
        if labels is not None and mask is not None:
            raise ValueError('Cannot define both `labels` and `mask`')
        elif labels is None and mask is None:
            # labels=mask=None，
            # mask 初始化为batch_size的对角矩阵
            mask = torch.eye(batch_size, dtype=torch.float32).to(device)
        elif labels is not None:
            # mask=None
            # 对 label 进行复制和重新排列
            labels = labels.contiguous().view(-1, 1)
            if labels.shape[0] != batch_size:
                raise ValueError('Num of labels does not match num of features')
            # 根据 label 生成 mask
            # mask.shape=[256]
            mask = torch.eq(labels, labels.T).float().to(device)
        else:
            # labels=None
            mask = mask.float().to(device)

        # 4. 选择对比学习的模式
        # contrast_count = 对比锚点数
        contrast_count = features.shape[1]
        # contrast_feature 对features按列切片，按行拼接
        contrast_feature = torch.cat(torch.unbind(features, dim=1), dim=0)
        if self.contrast_mode == 'one':
            anchor_feature = features[:, 0]
            anchor_count = 1
        elif self.contrast_mode == 'all':
            # default
            anchor_feature = contrast_feature
            anchor_count = contrast_count
        else:
            raise ValueError('Unknown mode: {}'.format(self.contrast_mode))

        # 5. compute logits: 锚点和其他锚点的内积 除以 温度系数
        # Eq.3: logits = z_I \cdot z_I  /  τ
        # Eq.3: z_I=anchor_feature, z_I=contrast_feature, τ=self.temperature
        anchor_dot_contrast = torch.div(
            torch.matmul(anchor_feature, contrast_feature.T),
            self.temperature)

        # for numerical stability
        logits_max, _ = torch.max(anchor_dot_contrast, dim=1, keepdim=True)
        logits = anchor_dot_contrast - logits_max.detach()

        # 扩大mask
        # mask.shape=[256,256^2]
        mask = mask.repeat(anchor_count, contrast_count)
        # mask-out self-contrast cases
        # 屏蔽锚点和锚点自身进行对比
        logits_mask = torch.scatter(
            torch.ones_like(mask), # 一个形状和mask一样，元素为 1 的矩阵
            1,
            torch.arange(batch_size * anchor_count).view(-1, 1).to(device),
            0
        )

        # Eq.3: P(i) = mask
        mask = mask * logits_mask

        # 6. compute log_prob
        # 图片特征表示 和 其他图片特征 计算得到的logits, 进行exp()
        exp_logits = torch.exp(logits) * logits_mask
        log_prob = logits - torch.log(exp_logits.sum(1, keepdim=True))

        # 7. compute mean of log-likelihood over positive
        # Eq3: \frac{-1}{|P(i)|} = -1 / mask.sum(1)
        # Eq3: \sum log(分式) = (mask * log_prob).sum(1)
        #       mask 屏蔽不存在的 图片之间的对比
        mean_log_prob_pos = (mask * log_prob).sum(1) / mask.sum(1)

        # 8.loss
        # - (self.temperature / self.base_temperature) = 1
        loss = - (self.temperature / self.base_temperature) * mean_log_prob_pos
        # 9.求loss均值，而不是求和
        loss = loss.view(anchor_count, batch_size).mean()

        return loss

Contrastive Graph Poisson Networks: Semi-Supervised Learning with Extremely Limited Labels

重点

• 在极少样本下进行半监督学习。
• GNN，例如图卷积网络（GCN）和图注意网络（GAT）
  • 需要足够的标注数据，才能获得令人满意的泛化能力。
  • 标签数量的减少，大多数当前GNN的性能严重下降。

原理

• 变分推理（variational inference）

  • 优化目标函数ELBO（Evidence Lower Bound Objectiv）*

• 对近似后验概率进行建模。

• 替代分布（surrogate distribution）替代后验分布（intractable posterior）

创新

• 新的GNN框架CGPN
  • 来解决标签极为有限的半监督节点分类问题
• 图泊松网络（Graph Poisson Network，GPN）。
  • 有效地将有限的标签传播到整个图
  • 使用正常的GNN来灵活地引导GPN的传播。
  • 基于注意机制来构建出泊松标签传播模型。
• 将对比学习整合到变分推理框架中，
  • 从大量未标记数据中探索额外的监督信息，帮助训练我们的CGPN框架。
• 应用对比目标（contrastive objective）
  • 进一步利用GPN和GNN模型学习过程中的监督信息（supervision information）

4.3 Contrastive label inference(key)

$${\mathcal{L}}_{PC}(z_i,{\tilde{z}}_i)=-log\frac{exp(⟨z_i,{\tilde{z}}_i⟩/\tau )}{exp(⟨z_i,{\tilde{z}}_i⟩/\tau )+\stackrel{n}{\sum _{j=1}}{\mathbb{I}}_{[j\ne i]}exp(⟨z_i,{\tilde{z}}_j⟩/\tau )+\stackrel{n}{\sum _{j=1}}{\mathbb{I}}_{[j\ne i]}exp(⟨z_i,z_j⟩/\tau )},\text{\hspace{1em}(9)}$$

---

基于$Eq.9$，要最小化的整体loss。
KaTeX parse error: Expected '}', got '_' at position 154: …,z_i)). \tag{10_̲key}

---

$${\mathcal{L}}_{ELBO}(\theta ,\varphi )=\mathrm{l}\mathrm{o}\mathrm{g}{\mathrm{p}}_{\theta }({\mathbf{Y}}_{\mathrm{L}}\mid \mathbf{A},\mathbf{X})-{\mathrm{D}}_{\mathrm{K}\mathrm{L}}({\mathrm{q}}_{\varphi }({\mathbf{Y}}_{\mathrm{U}}\mid \mathbf{A},\mathbf{X},{\mathbf{Y}}_{\mathrm{L}})\mid \mid {\mathrm{p}}_{\theta }({\mathbf{Y}}_{\mathrm{U}}\mid \mathbf{A},\mathbf{X})).\text{\hspace{1em}(4)}$$

---

$$\mathcal{L}(\theta ,\varphi )=-{\mathcal{L}}_{ELBO}(\theta ,\varphi )+{\lambda }_1{\mathcal{L}}_{CE}\left({\mathbf{Z}}_L,{\mathbf{Y}}_L\right)+{\lambda }_2{\mathcal{L}}_{\text{Cont }}\text{\hspace{1em}(11)}$$

符号表示

• $z_i$ 是$q_{\Phi }(Y|A,X,Y_L)$

  • 由$GPN$图泊松网络模型训练得到的数据。
  • $q_{\Phi }(Y|A,X,Y_L)$是根据可伸缩变分推理（$scalablevariationalinference$），
  • 引入了由参数 $\varphi$参数化的分布 。$q_{\Phi }(Y|A,X,Y_L)$
  • 来近似真正的后验分布。

• ${\tilde{z}}_i$是$p_{\theta }(A,X)$

  • 由$GCN$图泊松网络模型训练得到的数据。
  • $p_{\theta }(A,X)$ 以$A,X$ 为输入，输出$Y $的概率。

• $⟨\cdot ,\cdot ⟩$ 表示内积。

  • $$similar(\vec{a},\vec{b})=cos⟨\vec{a},\vec{b}⟩=\frac{\vec{a}\cdot \vec{b}}{||\vec{a}||\cdot ||\vec{b}||}\text{\hspace{1em}(内积)}$$

• $τ $ 是标量温度参数

• $Z_L$ 由$q_{\Phi }(Y|A,X,Y_L)$生成,，是$X_L$的预测结果。

• ${\mathcal{L}}_{PC}$ 表示 泊松对比损失。

• ${\mathcal{L}}_{CE}$ 表示 多类softmax交叉熵损失 。

• ${\mathcal{L}}_{Cont}$ 表示 对比损失。

• $D_{KL}(\cdot ||\cdot )$Kullback-Leibler散度。

• ${\lambda }_2,{\lambda }_1$ 是权重系数。

特性

• 使用对比损失 从未标记数据中挖掘额外的监督信息用于模型训练，提高标签推理的性能。
• 去最大化来自$q_{\Phi }(Y|A,X,Y_L)$和$p_{\theta }(A,X)$结点的一致性（$agreement$）。
  • $A$ 邻接矩阵
  • $X$ 结点特征表示。
  • $Y_L$ 结点真正的标签
  • $p_{\theta }(A,X)$
• 除了使用对比损失外，使用多类softmax交叉熵损失${\mathcal{L}}_{CE}$去惩罚 $q_{\Phi }(Y|A,X,Y_L)$的输出$Z_L$和真实标签$Y_L$ 之间的差异。
• $GPN$和$GNN$模型之间的对比，可以利用互信息来提高标签推理能力.
• $Z_L$ 由模型 $q_{\Phi }(Y|A,X,Y_L)$ 生成，表示$X_L$的预测。

code-Eq.10 (key)

# cosine simlar(z1,z2)
# Eq.9: 计算内积 ⟨z_i,\widetilde{z}_i⟩
def sim(z1: torch.Tensor, z2: torch.Tensor):
    # 正则化
    z1 = F.normalize(z1)
    z2 = F.normalize(z2)
    return torch.mm(z1, z2.t())

# Eq.10: \mathcal{L}_{PC}(z_i,\widetilde{z}_i)
# Eq.9: τ = tau
def semi_loss(z1: torch.Tensor, z2: torch.Tensor, tau):
    # 定义函数 f(X) = e^{x/tau}
    f = lambda x: torch.exp(x / tau)

    refl_sim = f(sim(z1, z1))
    between_sim = f(sim(z1, z2))

    # Eq.9: 分子 exp(⟨z_i,\widetilde{z}_i⟩/τ) = between_sim.diag()
    # Eq.9: 分母 (refl_sim.sum(1) + between_sim.sum(1) - refl_sim.diag())
    #   分母_between_sim.sum(1) =
    #       exp(⟨z_i,\widetilde{z}_i⟩/τ)+
    #       \overset{n}{\underset{j=1}{\sum}} \mathbb{I}_{[j\neq i]} exp(⟨z_i,\widetilde{z}_j⟩/τ)
    #   分母_refl_sim.sum(1) - refl_sim.diag() =
    #       \overset{n}{\underset{j=1}{\sum}}\mathbb{I}_{[j\neq i]}exp(⟨z_i,z_j⟩/τ)
    return -torch.log(
        between_sim.diag()
        / (refl_sim.sum(1) + between_sim.sum(1) - refl_sim.diag()))

def contrastive_loss(z1: torch.Tensor, z2: torch.Tensor,
         mean: bool = True):
    # Eq.10: z_i = z1
    h1 = z1
    # Eq.10: \widetilde{z}_i = z2
    h2 = z2

    # Eq.10: \mathcal{L}_{PC}(z_i,\widetilde{z}_i)
    l1 = semi_loss(h1, h2, 0.5)
    # Eq.10: \mathcal{L}_{PC}(\widetilde{z}_i,z_i)
    l2 = semi_loss(h2, h1, 0.5)

    ret = (l1 + l2) * 0.5
    # 获取平均的loss
    ret = ret.mean() if mean else ret.sum()

    return ret

Q&A - 关于理论

encoder

作用

• 将图片转换成向量表示。

泊松学习

动机

• 标签信息非常有限时，如何解决拉普拉斯SSL的简并性。

传统的拉普拉斯学习算法
$$\{\begin{array}{rl}\mathcal{L}u\left({\mathbf{x}}_i\right)=0,& \text{ if }l+1\le i\le n\\ u\left({\mathbf{x}}_i\right)=y_i,& \text{ if }1\le i\le l\end{array},$$

符号表示

• X ∈ { x 1 , x 2 , . . . , x l , x l + 1 , . . . , x l + u } X \in \{x_1,x_2,...,x_l,x_{l+1},...,x_{l+u}\} X∈{x1​,x2​,...,xl​,xl+1​,...,xl+u​} 数据集合。
  • u ( x i ) = { x 1 , x 2 , . . . , x l } u\left(x_{i}\right) = \{x_1,x_2,...,x_l\} u(xi​)={x1​,x2​,...,xl​} 有标签的数据集。
  • $ {x_{l+1},…,x_{l+u}}$ 没有标签的数据集。
• $\mathcal{L}u({\mathbf{x}}_i)$ 表示非归一化的拉普拉斯图。
• 果第 $j$ 个元素$u_j(x_i)$ 是$u(x_i)$中最大的值，那么节点$x_i$属于第$j$个类别。

泊松学习算法
$$\mathcal{L}u\left({\mathbf{x}}_i\right)=\sum _{j=1}^l\left(y_j-\bar{y}\right){\delta }_{ij}fori=1,\dots ,n$$
符号表示

• ${\sum }_{i=1}^n{d}_{i}u({\mathbf{x}}_i)=0$
  • $d_i={\sum }_{j=1}^n{\mathbf{A}}_{ij}$
• ${\delta }_{ij}$
  • $i=j,{\delta }_{ij}=1$
  • $i\ne j,{\delta }_{ij}=0$
• $\bar{y}=\frac{1}{l}\mathbf{F}1,\mathbf{F}\in {\mathbb{R}}^{c\times l}$
  • 表示 $l$个标注节点的标签矩阵。

特点

• 标签作为源项（source term）。

泊松方程第$t+1$次迭代
$$U^{(t+1)}\leftarrow U^{(t)}+D^{-1}\left(B^{\top }-L{U}^{(t)}\right),$$
符号表示

• $D$ 是对角矩阵。
  • $D_{ii}=d_i$
• $L$ 是拉普拉斯矩阵。
  • $A-D$
• $B=[F-\overline{y},O]$ 是源项。
  • $O\in {\mathbb{R}}^{c\times (n-l)}$ 是一个零矩阵。

---

结论

• 在非常低的标签率，泊松学习优于传统拉普拉斯学习。
• 缺点
  • 在泊松学习中，图结构并没有被充分利用来指导标签的传播。
  • 泊松学习依赖于一个固定的图，而该图在现实中可能会有噪声，因此无法很好地探索图节点之间的内在关系。
  • 由于泊松学习主要强调输入标签信息的传播，相邻节点特征构成的结构信息没有被利用。
    • 不准确的标签预测可能会随着迭代传播而累积，这不可避免地导致性能下降。
• 解决
  • 图泊松网络（GPN）。

$q_{\Phi }(Y|A,X,Y_L)$ 和 $p_{\theta }(Y|A,X)$的差异？

$q_{\Phi }(Y|A,X,Y_L)$

• GPN的思想。

$p_{\theta }(Y|A,X)$

• GNN的思想。

$q_{\Phi }(Y|A,X,Y_L)$

后验分布 $p_{\theta }({\mathbf{Y}}_U\mid \mathbf{A},\mathbf{X},{\mathbf{Y}}_L)$ 和它的参数$\theta$ .这种后验概率的计算通常难以分析，因此我们采用近似的后验概率推断方法。

使用参数$\varphi$参数化的分布
$$q_{\varphi }({\mathbf{Y}}_U\mid \mathbf{A},\mathbf{X},{\mathbf{Y}}_L)$$
问题

• $Y_L$中的标签信息极其稀缺，大多数现有的方法在这里是无效的。
  • 解决方法： 泊松学习算法。
    • 图结构并没有被充分利用来指导标签的传播。

证据下限（Evidence Lower BOund，ELBO）

$${\mathcal{L}}_{ELBO}(\theta ,\varphi )=\mathrm{l}\mathrm{o}\mathrm{g}{\mathrm{p}}_{\theta }({\mathbf{Y}}_{\mathrm{L}}\mid \mathbf{A},\mathbf{X})-{\mathrm{D}}_{\mathrm{K}\mathrm{L}}({\mathrm{q}}_{\varphi }({\mathbf{Y}}_{\mathrm{U}}\mid \mathbf{A},\mathbf{X},{\mathbf{Y}}_{\mathrm{L}})\mid \mid {\mathrm{p}}_{\theta }({\mathbf{Y}}_{\mathrm{U}}\mid \mathbf{A},\mathbf{X})).\text{\hspace{1em}(4)}$$

符号表示

• $p_{\theta }({\mathbf{Y}}_U\mid \mathbf{A},\mathbf{X})$ 以$ \mathbf{A},\mathbf{X}$ 为输入，输出$\mathbf{Y}_{U} $的概率。

特性

• 可以灵活地用GNN模型实例化$p_{\theta }({\mathbf{Y}}_L\mid \mathbf{A},\mathbf{X})$。
• 使用中需要指定$q_{\varphi }({\mathbf{Y}}_U\mid \mathbf{A},\mathbf{X},{\mathbf{Y}}_L)$ 和 $p_{\theta }({\mathbf{Y}}_U\mid \mathbf{A},\mathbf{X})$ GNN下的参数形式。

​

view 和 对比目标？

view

• 数据增强（裁箭、模糊）用于生成同一图像的多个视图。
• 用于对比学习。
• 不同模型的输出。
  • GPN模型的输出。
  • GCN模型的输出。

对比目标

• 两个视图的对比。

self-supervised contrastive loss detail

$${\mathcal{L}}^{self}=\sum _{i\in 2N}{\mathcal{L}}_i^{self}=-\sum _{i\in 2N}log\frac{exp(z_i\cdot z_{j(i)}/\tau )}{\sum _{k\in 2N}{\mathbb{I}}_{i\ne k}exp(z_i\cdot z_k/\tau )}$$

作用

• 完全通过对比一个个无label的data，从而对data学习出一个有效的representation。

流程

对于一个data sample:x，
通过data augmentation，得到两个x_i（anchor），x_j（positive sample）。

拉近x_i和x_j的representation的距离，拉远x_i和其他数据（negative sample）的representation的距离

分子即是x_i和x_j的representation距离，
分母即是x_i和所有数据（negative sample和positive sample）的representation的距离。
最小化这个loss。目的也就达成了。

实验

上图片经过了两个network才变成了做inner product操作的128维的projection vector。

首先图片通过一个 encoder network（图片通常用resnet的final pooling layer）变成2048维的vector，

然后再通过一个projection network （基本大家都用的是一个全联接网络）变成128维的vector。

contrastive learning结束之后，只保留encoder network，projection network就丢掉不要了。

这篇论文拿到训练好的encoder network之后，把这个encoder 固定住，用cross-entropy loss训练了一个全联接的linear classifier。

再和单纯的resnet+cross-entropy loss做比较。supervised contrastive 优于了cross entropy baselines。

supervised contrastive Loss

$$\begin{gathered} {\mathcal{L}}^{sup}=\sum _{i\in 2N}{\mathcal{L}}_i^{sup} \\ {\mathcal{L}}_i^{sup}=\frac{-1}{2N_{\widetilde{y_i}}-1}\sum _{j\in 2N}{\mathbb{I}}_{i\ne j}{\mathbb{I}}_{\widetilde{y_i}=\widetilde{y_j}}\cdot log\frac{exp(z_i\cdot z_{j(i)}/\tau )}{\sum _{k\in 2N}{\mathbb{I}}_{i\ne k}exp(z_i\cdot z_k/\tau )}\text{\hspace{1em}(z2)} \end{gathered}$$

$N_{\widetilde{y_i}}$是这个$minibatch$中是同一个$label$的图片的数量。*

• $minibatch$是$[A_1,A_2,A_3,B_1,B_2,C_1]$，那么$N_{\widetilde{y_i}}$就等于5。*

区别

是在有$label$的$setting$下，一个$minibatch$可以有多个$anchor$，多个$positivesample$的适应性版本。

正负样本定义

作用

• 在训练过程中计算损失。

产生

• 负样本（即噪声样本）负样本采样。
• 正样本（即数据样本）数据增强手段（例如，随机裁剪、随机颜色失真、随机高斯模糊）来产生对比学习正样本对。

例子

• 人脸检测：正样本-人脸，负样本-非人脸。

$SimCLR$

	Arch	Setting	Loss	Accuracy(%)
$SimCLR$	ResNet50	Unsupervised	Contrastive	93.6

url:
	ResNet50
	https://blog.csdn.net/Cheungleilei/article/details/103610799

NCE loss : Noise Contrastive Estimation

KaTeX parse error: Expected '}', got '_' at position 330: …\ \tag{NCE loss_̲NLP}

---

$${\mathcal{L}}_{NCE}=-log\frac{exp(q\cdot k_{+})/\tau }{exp(q\cdot k_{+}/\tau )+exp(q\cdot k_{-}/\tau )}$$

$${\mathcal{L}}_q=-log\frac{exp(q\cdot k_{+}/\tau )}{\stackrel{k}{\sum _{i=0}}exp(q\cdot k_i/\tau )}\text{\hspace{1em}(InfoNCE loss)}$$

---

$$\begin{gathered} \mathcal{L}(\hat{y})=-\stackrel{k}{\sum _{i=0}}{y}_{i}log(\hat{y}) \\ \text{\hspace{1em}(cross entropy loss)} \end{gathered}$$

$${\hat{y}}_{+}=softmax(z_{+})=\frac{exp(z_{+})}{\stackrel{k}{\sum _{i=0}}exp(z_i)}\text{\hspace{1em}(softmax)}$$

---

符号表示

• $k$ 类别数。
• $q\cdot k$ 是模型计算出来的logit（矫正值）。
• $\tau$ 温度超参数，是个标量，控制了模型对负样本的区分度。
  • $\tau$ 可以用来控制，$q\cdot k$ (logits)的分布形状。
  • $\tau$ 变大，$q\cdot k$ 会使原来logits分布里的数值都变小，经过指数运算之后更小，导致原来的logits分布变得更平滑。
    • 模型的对比损失会对所有的负样本一视同仁，导致模型学习没有轻重。
  • $\tau$ 变小，$q\cdot k$ 会使原来logits分布里的数值都变大，经过指数运算之后更大，导致原来的logits分布变得更集中。
    • 模型会越关注特别困难的负样本，但其实那些负样本很可能是潜在的正样本，这样会导致模型很难收敛或者泛化能力差。
• $InfoNCEloss$ 中的 $\sum$ 操作，是再正样本和负样本上做的 。共$k+1$个样本数量。

联系

• $InfoNCEloss$其实就是一个$crossentropyloss$，
  • 做的是一个$ k+1$类的分类任务，目的就是想把$q$这个图片分到$k_+$这个类.
  • 忽略 $\tau$, $InfoNCEloss$其实就是$crossentropyloss$.
  • 在$crossentropyloss$里，$k$指代的是数据集里类别的数量，
  • 在$InfoNCEloss$里，$k$指的是负样本的数量。

思想

• 将多分类问题转换为二分类问题。
  • 数据类别 data sample
  • 噪声类别 noisy sample

解决的问题

• 模型训练中，当类别总数非常大的时候，$softmax$需要对每一个类别预测出概率，计算量很大。
  • CV领域的ImageNet数据集来举例，该数据集一共有128万张图片。
  • 使用数据增强手段（例如，随机裁剪、随机颜色失真、随机高斯模糊）来产生对比学习正样本对，每张图片就是单独一类，那k就是128万类。
  • 使用交叉熵损失函数是不合理的。

作用

• 不计算所有class的probability，但同时给我们一个合理的loss。
• 噪声对比（noise contrastive）
  • 通过学习数据样本和噪声样本之间的区别，将数据样本和噪声样本做对比。
  • 从而得到数据集中的特性。

应用

• 模型训练。
  • training的时候，使用nce loss，可以减少计算量。
  • testing的时候，使用sigmoid cross entropy。
  • 因为还是要衡量所有可能class的probability，在所有可能结果中做选择。
• 负样本（即噪声样本）负样本采样。
• 正样本（即数据样本）数据增强手段（例如，随机裁剪、随机颜色失真、随机高斯模糊）来产生对比学习正样本对。

对比学习

定义

• 对比学习是一种判别方法。
  • 将相似的样本彼此靠近，而相异的样本彼此远离。
• 对比学习可以用来学习数据的特征表示。

例子

• 对比学习（Contrastive Learning）对输入的图片之间的关系进行判断。

  • similar
  • dissimilar

• 原始图片和样本经过encoder，转换成为向量。

• 计算cosine similar（内积），得到一个标量similar metric，可以用来判断原始图片和样本之间的相识度。

• 图片对应的向量映射到球面上的点。

  • 点之间的距离越小，图片之间越相似。
  • 映射$Proje()$ 过程存在信息损失。

• 生成样本。

• 根据样本设计损失函数。

self-supervised 流程

• pretrained

  • pretext
    • 对数据进行标注。
      • 比如将图片转90度，得到的图片为input， label=90度。
  • 对标注好的数据信息训练。

• fine-tuning

  • 对pretrained训练好的Nerual Net进行训练。
  • 在以标注的数据集上。

• Batch张图片进行$Aug(\cdot )$ 后得到2*Batch张图片样本。

• encoder$Enter(\cdot )$将2*Batch张图片样本转换成向量。

  • 当作图片特征表示。

• 向量经过$Proj(\cdot )$映射成对应的点，该过程有信息丢失。

  • 也可以说是经过GCN、GPN模型的输出。

• cosine similar的计算。

• 降低损失。

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ViTKLiWH-1655469334180)(C:\Users\sherlock\AppData\Roaming\Typora\typora-user-images\image-20220612192738855.png)]

• 总体

Q&A - 关于代码

tensor.detach()

url: https://blog.csdn.net/qq_31244453/article/details/112473947

作用

• 返回一个新的tensor，从当前计算图中分离下来。但是仍指向原变量的存放位置，不同之处只是requirse_grad为false.得到的这个tensir永远不需要计算器梯度，不具有grad.

• 即使之后重新将它的requires_grad置为true，它也不会具有梯度grad。这样我们就会继续使用这个新的tensor进行计算，后面当我们进行反向传播时，到该调用detach()的tensor就会停止，不能再继续向前进行传播.

注意

• 使用detach返回的tensor和原始的tensor共同一个内存，即一个修改另一个也会跟着改变。

lambda

例子

输入
   import torch
    
    tau = 0.5
    a = torch.randn(3)  # 生成一个一维的矩阵
    b = torch.randn(2, 3)  # 生成一个二维的矩阵
    print("a before")
    print(a)

    f = lambda x: torch.exp(x / tau)
    a = f(a)
    print("a after")
    print(a)
    
输出
    a before
    tensor([-0.6016,  2.2668, -0.3400])
    a after
    tensor([ 0.3002, 93.0994,  0.5066])

mean()

例子

输入
    import torch

    a=torch.randn(3) #生成一个一维的矩阵
    b=torch.randn(2,3) #生成一个二维的矩阵

    print(a)
    print(b)

    print("mean(a)")
    print(torch.mean(a))
    print("mean(b)")
    print(torch.mean(b))

输出
    tensor([0.1390, 1.7866, 0.7340])
    tensor([[-0.2442,  0.3046, -0.6403],
            [ 1.1096,  0.9852, -0.1313]])
    mean(a)
    tensor(0.8865)
    mean(b)
    tensor(0.2306)

sum()

例子

>>> import numpy as np

>>> x = np.array([[0, 1], [1, 1], [2, 2]])
>>> x.sum(1)
array([1, 2, 4])
>>> x.sum(-1)
array([1, 2, 4])
>>> x.sum(axis=1)
array([1, 2, 4])
>>> print(x,axis=1)

torch.unbind()

输入
    import torch

    t = torch.rand(3, 3)  # 随机生成一个tensor
    print(t)
    print(t.shape)

    r = torch.unbind(t, dim=0)  # dim = 0 指定切片的维度
    print("r")
    print(r)
    s = torch.unbind(t, dim=1)  # dim = 1指定切片的维度
    print("s")
    print(s)

输出
    tensor([[0.5254, 0.6354, 0.6671],
            [0.7242, 0.5994, 0.4613],
            [0.0423, 0.7953, 0.0694]])
    torch.Size([3, 3])
    r
    (tensor([0.5254, 0.6354, 0.6671]), tensor([0.7242, 0.5994, 0.4613]), tensor([0.0423, 0.7953, 0.0694]))
    s
    (tensor([0.5254, 0.7242, 0.0423]), tensor([0.6354, 0.5994, 0.7953]), tensor([0.6671, 0.4613, 0.0694]))

torch.arange()

作用

-返回一个一维向量，其大小为$\lceil \frac{\text{end}-\text{start}}{\text{step}}\rceil$，取值区间为[start, end) ，从start开始，以step为步长增加，直到end结束（不包括end）
$${\text{out}}_{i+1}={\text{out}}_i+\text{step}$$
例子

>>> torch.arange(5)
tensor([ 0,  1,  2,  3,  4])
>>> torch.arange(1, 4)
tensor([ 1,  2,  3])
>>> torch.arange(1, 2.5, 0.5)
tensor([ 1.0000,  1.5000,  2.0000])

torch.ones_like()

例子

>>> input = torch.empty(2, 3)
>>> torch.ones_like(input)
tensor([[ 1., 1., 1.],
		[ 1., 1., 1.]])

torch.scatter()

url: https://blog.csdn.net/leo0308/article/details/125056119

例子

>>> x = torch.rand(2, 5)
>>> x
tensor([[ 0.3992,  0.2908,  0.9044,  0.4850,  0.6004],
        [ 0.5735,  0.9006,  0.6797,  0.4152,  0.1732]])
        
>>> torch.zeros(3, 5).scatter_(0, torch.tensor([[0, 1, 2, 0, 0], [2, 0, 0, 1, 2]]), x)
tensor([[ 0.3992,  0.9006,  0.6797,  0.4850,  0.6004],
        [ 0.0000,  0.2908,  0.0000,  0.4152,  0.0000],
        [ 0.5735,  0.0000,  0.9044,  0.0000,  0.1732]])

repeat()函数

例子

输入
    import torch

    A = torch.tensor([[[0, 0],
                       [1, 1],
                       [2, 2]]])
    X1 = A.repeat(2,1,1)
    print(X1)
    X2 = A.repeat(2,2,1)
    print(X2)
    X3 = A.repeat(1,2,1)
    print(X3)
    print(A.shape)

输入
    tensor([[[0, 0],
             [1, 1],
             [2, 2]],

            [[0, 0],
             [1, 1],
             [2, 2]]])
    tensor([[[0, 0],
             [1, 1],
             [2, 2],
             [0, 0],
             [1, 1],
             [2, 2]],

            [[0, 0],
             [1, 1],
             [2, 2],
             [0, 0],
             [1, 1],
             [2, 2]]])
    tensor([[[0, 0],
             [1, 1],
             [2, 2],
             [0, 0],
             [1, 1],
             [2, 2]]])
    torch.Size([1, 3, 2])

torch.div()

torch.div(input, other, out=None)

$${\text{out}}_i=\frac{{\text{input}}_i}{\text{other}}$$

view()

作用

• 通过参数改变矩阵的形状。

torch.eq()

作用

• 对两个张量进行逐元素的比较，若相同位置的两个元素相同，则返回True；若不同，返回False。

contiguous()函数

url:https://blog.csdn.net/kdongyi/article/details/108180250

作用

• 不改变tensor的内容本身，而只是重新定义下标与元素的对应关系的。

例子

输入
    x = torch.randn(3, 2)
    y = torch.transpose(x, 0, 1).contiguous()
    print("修改前：")
    print("x-", x)
    print("y-", y)

    print("\n修改后：")
    y[0, 0] = 11
    print("x-", x)
    print("y-", y)

输出
    修改前：
    x- tensor([[ 0.9730,  0.8559],
               [ 1.6064,  1.4375],
               [-1.0905,  1.0690]])
    y- tensor([[ 0.9730,  1.6064, -1.0905],
               [ 0.8559,  1.4375,  1.0690]])

    修改后：
    x- tensor([[ 0.9730,  0.8559],
               [ 1.6064,  1.4375],
               [-1.0905,  1.0690]])
    y- tensor([[11.0000,  1.6064, -1.0905],
               [ 0.8559,  1.4375,  1.0690]])

参考资料

paper
	Supervised Contrastive Learning
	https://arxiv.org/pdf/2004.11362.pdf
	Contrastive Graph Poisson Networks: Semi-Supervised Learning with Extremely Limited Labels
	https://proceedings.neurips.cc/paper/2021/file/31c0b36aef265d9221af80872ceb62f9-Paper.pdf
	https://arxiv.org/pdf/2011.00362.pdf
	https://arxiv.org/pdf/2002.05709.pdf
blog
	NCE loss
	https://blog.csdn.net/yimingsilence/article/details/105920987
	https://blog.csdn.net/weixin_40539952/article/details/115007202?utm_medium=distribute.pc_relevant.none-task-blog-2~default~baidujs_baidulandingword~default-0-115007202-blog-105920987.pc_relevant_antiscanv3&spm=1001.2101.3001.4242.1&utm_relevant_index=2
	
	https://blog.csdn.net/kdongyi/article/details/108180250

note
	Supervised Contrastive Learning
	https://zhuanlan.zhihu.com/p/265529937
	NCE loss
	https://zhuanlan.zhihu.com/p/506544456
	
video
	https://www.bilibili.com/video/BV1Qr4y1Q7ea