【代码】SupConLoss

已于 2022-07-21 21:52:51 修改
阅读量2.3k 收藏 5
点赞数 2
分类专栏： 小菜鸡加油 文章标签： 深度学习 python pytorch
于 2022-07-17 16:27:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nyist_yangguang/article/details/125833322
版权

eg1: 相等的元素为True

torch.eq(torch.arange(5).view(5,1),torch.arange(5).view(5,1))
Out[28]: 
tensor([[True],
        [True],
        [True],
        [True],
        [True]])
torch.eq(torch.arange(5).view(5,1),torch.arange(5).view(5,1).T)
Out[29]: 
tensor([[ True, False, False, False, False],
        [False,  True, False, False, False],
        [False, False,  True, False, False],
        [False, False, False,  True, False],
        [False, False, False, False,  True]])
torch.eq(torch.arange(5).view(5,1).T,torch.arange(5).view(5,1))
Out[30]: 
tensor([[ True, False, False, False, False],
        [False,  True, False, False, False],
        [False, False,  True, False, False],
        [False, False, False,  True, False],
        [False, False, False, False,  True]])

eg2: 解开指定的维度

torch.unbind(torch.tensor([[1],[2],[3]]),1)
Out[36]: (tensor([1, 2, 3]),)
torch.unbind(torch.tensor([[1],[2],[3]]),0)
Out[37]: (tensor([1]), tensor([2]), tensor([3]))

eg3:

torch.unbind(features,dim=1)
Out[44]: 
(tensor([[ 0.0165, -0.1257,  0.0335,  ...,  0.0430,  0.0588,  0.0256],
         [ 0.0581, -0.0996, -0.0443,  ..., -0.0111,  0.1081, -0.0078],
         [ 0.0172, -0.1306, -0.0858,  ..., -0.0411,  0.0833,  0.0013],
         ...,
         [ 0.0601, -0.1264, -0.0413,  ...,  0.0127,  0.1198, -0.0309],
         [-0.0102, -0.1497,  0.0010,  ..., -0.0122,  0.1112, -0.0583],
         [ 0.0758, -0.1189, -0.0197,  ...,  0.0220,  0.0872, -0.0166]],
        device='cuda:0', grad_fn=<UnbindBackward>),
 tensor([[ 0.0165, -0.1257,  0.0335,  ...,  0.0430,  0.0588,  0.0256],
         [ 0.0581, -0.0996, -0.0443,  ..., -0.0111,  0.1081, -0.0078],
         [ 0.0172, -0.1306, -0.0858,  ..., -0.0411,  0.0833,  0.0013],
         ...,
         [ 0.0601, -0.1264, -0.0413,  ...,  0.0127,  0.1198, -0.0309],
         [-0.0102, -0.1497,  0.0010,  ..., -0.0122,  0.1112, -0.0583],
         [ 0.0758, -0.1189, -0.0197,  ...,  0.0220,  0.0872, -0.0166]],
        device='cuda:0', grad_fn=<UnbindBackward>))

eg4: t.repeat()

eg5: torch.div（）

eq6:

# tile mask
mask = mask.repeat(anchor_count, contrast_count)
# mask-out self-contrast cases
logits_mask = torch.scatter(
    torch.ones_like(mask),
    1,
    torch.arange(batch_size * anchor_count).view(-1, 1).to(device),
    0
)

logits_mask

tensor([[0., 1., 1.,  ..., 1., 1., 1.],
        [1., 0., 1.,  ..., 1., 1., 1.],
        [1., 1., 0.,  ..., 1., 1., 1.],
        ...,
        [1., 1., 1.,  ..., 0., 1., 1.],
        [1., 1., 1.,  ..., 1., 0., 1.],
        [1., 1., 1.,  ..., 1., 1., 0.]], device='cuda:0')

----

torch.scatter(
            torch.ones_like(mask),
            0,
            torch.arange(batch_size * anchor_count).view(-1, 1).to(device),
            0)

tensor([[0., 1., 1.,  ..., 1., 1., 1.],
        [0., 1., 1.,  ..., 1., 1., 1.],
        [0., 1., 1.,  ..., 1., 1., 1.],
        ...,
        [0., 1., 1.,  ..., 1., 1., 1.],
        [0., 1., 1.,  ..., 1., 1., 1.],
        [0., 1., 1.,  ..., 1., 1., 1.]], device='cuda:0')

【笔记】scatter_函数：用法如 torch.zeros(target.size(0), 2).scatter_(1,target,1).to(self.device)_程序猿的探索之路的博客-CSDN博客

eg7: 消除对角元素

mask = mask.repeat(anchor_count, contrast_count)
# mask-out self-contrast cases
logits_mask = torch.scatter(
    torch.ones_like(mask),
    1,
    torch.arange(batch_size * anchor_count).view(-1, 1).to(device),
    0
)
mask = mask * logits_mask

mask
Out[20]: 
tensor([[1., 0., 1.,  ..., 1., 0., 0.],
        [0., 1., 0.,  ..., 0., 0., 0.],
        [1., 0., 1.,  ..., 1., 0., 0.],
        ...,
        [1., 0., 1.,  ..., 1., 0., 0.],
        [0., 0., 0.,  ..., 0., 1., 0.],
        [0., 0., 0.,  ..., 0., 0., 1.]], device='cuda:0')
mask*logits_mask
Out[21]: 
tensor([[0., 0., 1.,  ..., 1., 0., 0.],
        [0., 0., 0.,  ..., 0., 0., 0.],
        [1., 0., 0.,  ..., 1., 0., 0.],
        ...,
        [1., 0., 1.,  ..., 0., 0., 0.],
        [0., 0., 0.,  ..., 0., 0., 0.],
        [0., 0., 0.,  ..., 0., 0., 0.]], device='cuda:0')

eg8:

                      2           64
loss = loss.view(anchor_count, batch_size)

tensor([[4.7642, 4.7700, 4.9274, 4.8298, 5.0163, 4.8054, 4.9344, 4.6297, 5.0533,
         4.8786, 4.8808, 4.8946, 4.5965, 4.9085, 4.6794, 4.9939, 4.8648, 4.8382,
         4.5422, 4.7529, 4.6383, 4.7940, 4.7202, 4.9732, 4.5696, 4.7187, 4.8346,
         4.8804, 4.5355, 4.7395, 4.8884, 4.7580, 5.0020, 4.9140, 5.2952, 4.7402,
         4.8660, 4.9400, 4.9015, 4.8370, 5.0518, 4.8339, 5.0241, 4.8498, 5.0187,
         4.6112, 4.6124, 4.7228, 4.8453, 4.6810, 4.7281, 4.7040, 4.8005, 5.0514,
         5.0573, 4.2868, 4.9171, 4.5031, 4.7733, 4.8827, 4.7193, 4.9463, 4.8855,
         4.9188],
        [4.7642, 4.7700, 4.9274, 4.8298, 5.0163, 4.8054, 4.9344, 4.6297, 5.0533,
         4.8786, 4.8808, 4.8946, 4.5965, 4.9085, 4.6794, 4.9939, 4.8648, 4.8382,
         4.5422, 4.7529, 4.6383, 4.7940, 4.7202, 4.9732, 4.5696, 4.7187, 4.8346,
         4.8804, 4.5355, 4.7395, 4.8884, 4.7580, 5.0020, 4.9140, 5.2952, 4.7402,
         4.8660, 4.9400, 4.9015, 4.8370, 5.0518, 4.8339, 5.0241, 4.8498, 5.0187,
         4.6112, 4.6124, 4.7228, 4.8453, 4.6810, 4.7281, 4.7040, 4.8005, 5.0514,
         5.0573, 4.2868, 4.9171, 4.5031, 4.7733, 4.8827, 4.7193, 4.9463, 4.8855,
         4.9188]], device='cuda:0', grad_fn=<ViewBackward>)

loss = loss.view(anchor_count, batch_size).mean()

tensor(4.8208, device='cuda:0', grad_fn=<MeanBackward0>)
 

loss.view(anchor_count, batch_size).mean(0)

tensor([4.7642, 4.7700, 4.9274, 4.8298, 5.0163, 4.8054, 4.9344, 4.6297, 5.0533,
        4.8786, 4.8808, 4.8946, 4.5965, 4.9085, 4.6794, 4.9939, 4.8648, 4.8382,
        4.5422, 4.7529, 4.6383, 4.7940, 4.7202, 4.9732, 4.5696, 4.7187, 4.8346,
        4.8804, 4.5355, 4.7395, 4.8884, 4.7580, 5.0020, 4.9140, 5.2952, 4.7402,
        4.8660, 4.9400, 4.9015, 4.8370, 5.0518, 4.8339, 5.0241, 4.8498, 5.0187,
        4.6112, 4.6124, 4.7228, 4.8453, 4.6810, 4.7281, 4.7040, 4.8005, 5.0514,
        5.0573, 4.2868, 4.9171, 4.5031, 4.7733, 4.8827, 4.7193, 4.9463, 4.8855,
        4.9188], device='cuda:0', grad_fn=<MeanBackward1>)

loss.view(anchor_count, batch_size).mean(1)

tensor([4.8208, 4.8208], device='cuda:0', grad_fn=<MeanBackward1>)
 

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
        self.contrast_mode = contrast_mode
        self.base_temperature = base_temperature

    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.
        """
        device = (torch.device('cuda')
                  if features.is_cuda
                  else torch.device('cpu'))

        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)

        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:
            mask = torch.eye(batch_size, dtype=torch.float32).to(device)
        elif labels is not None:
            labels = labels.contiguous().view(-1, 1)
            if labels.shape[0] != batch_size:
                raise ValueError('Num of labels does not match num of features')
            mask = torch.eq(labels, labels.T).float().to(device)
        else:
            mask = mask.float().to(device)

        contrast_count = features.shape[1]
        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':
            anchor_feature = contrast_feature
            anchor_count = contrast_count
        else:
            raise ValueError('Unknown mode: {}'.format(self.contrast_mode))

        # compute logits
        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()

        # tile mask
        mask = mask.repeat(anchor_count, contrast_count)
        # mask-out self-contrast cases
        logits_mask = torch.scatter(
            torch.ones_like(mask),
            1,
            torch.arange(batch_size * anchor_count).view(-1, 1).to(device),
            0
        )
        mask = mask * logits_mask

        # compute log_prob
        exp_logits = torch.exp(logits) * logits_mask
        log_prob = logits - torch.log(exp_logits.sum(1, keepdim=True))

        # compute mean of log-likelihood over positive
        mean_log_prob_pos = (mask * log_prob).sum(1) / mask.sum(1)

        # loss
        loss = - (self.temperature / self.base_temperature) * mean_log_prob_pos
        loss = loss.view(anchor_count, batch_size).mean()

        return loss

程序猿的探索之路
关注
专栏目录
对比学习(Contrastive Learning) (2)
weixin_47062807的博客
02-09 2398
《Supervised Contrastive Learning》 该工作将原来自监督学习(self-supervised)的对比学习思想扩展到全监督学习(full-supervised)，相比于上一篇SimCLR，SupCon在数据增强，encoder，投影网络的设计上没什么区别，在正样本与负样本的定义上稍有不同：在一个batch中，对于每一个选择的锚样本，与其属于同一类的都认为是正样本，不属于同一类的都认为是负样本。 监督学习的损失函数 Loutsup=∑i∈ILout,isup=∑i∈I−1∣P(i)
SupConLoss&(CE/NCE/info NCE)
记录/交流，加油啊呀...
02-09 864
参考。
ClipReID的监督对比损失SupConLoss
SisterRu的博客
07-31 387
SupConLoss继承自nn.Module，这是 PyTorch 中所有神经网络模块的基类。在初始化方法__init__中，它接受一个device参数，用来指定运算应该在哪个设备上进行（如CPU或GPU）。是一个标量，用于控制损失计算中的温度参数，影响特征向量之间相似度的缩放。
SupContrast 开源项目教程
gitblog_01185的博客
08-09 648
SupContrast 开源项目教程 SupContrastPyTorch implementation of "Supervised Contrastive Learning" (and SimCLR incidentally)项目地址:https://gitcode.com/gh_mirrors/su/SupContrast 项目介绍 SupContrast 是一个实现监督对比学习（Sup...
SupContrast: 监督对比学习的PyTorch实现
最新发布
gitblog_09622的博客
09-13 352
SupContrast: 监督对比学习的PyTorch实现 SupContrast PyTorch implementation of "Supervised Contrastive Learning" (and SimCLR incidentally) ...
SupContrast:PyTorch实施“监督式对比学习”（顺带SimCLR）
03-19
SupContrast：监督式对比学习 此库使用CIFAR作为说明性示例，涵盖了PyTorch中以下论文的参考实现： （1）监督式对比学习。（2）视觉表示对比学习的简单框架。 损失函数 损耗函数在losses.py花费features （L2归一化）和labels作为输入，并返回损耗。如果labels为None或未传递给它，则它会退化为SimCLR。 用法： from losses import SupConLoss # define loss with a temperature `temp` criterion = SupConLoss ( temperature = temp ) # features: [bsz, n_views, f_dim] # `n_views` is the number of crops from each image # better be L2 no
对比学习 LOSS
HelloWorld的博客
02-12 531
对比学习属于无监督学习的一种，即给一堆数据，没有标签，自己学习出一种特征表示。
S5CL：通过分层对比学习统一全监督、自监督和半监督学习
qq_45745941的博客
05-02 905
通过引入S5CL将这两个阶段的训练压缩为一个阶段，S5CL是一个用于全监督、自监督和半监督学习的统一框架为标记图像、未标记图像和伪标记图像定义了三个对比损失的情况下，S5CL可以学习反映距离关系层次的特征表示：相似的图像和增强嵌入得最近，其次是同一类的不同外观的图像，而来自不同类的图像具有最大的距离S5CL允许灵活地组合这些损失，以适应不同的场景代码地址。
对比学习 Contrast Learning
银晗的学习博客
08-27 594
监督对比学习的目标是最大化正样本对（同一类别的样本）的一致性，并最小化负样本对（不同类别的样本）的一致性。监督对比损失通过鼓励正样本对的表示在嵌入空间中更加接近，同时将负样本对的表示推开来实现这一目标。对比损失：Supervised Contrastive Loss（监督对比损失）是一种在监督对比学习中使用的损失函数。它旨在学习既具有区分性又具有对同一类别内变化具有不变性的表示。
PyTorch实施“监督式对比学习”（顺带SimCLR）-Python开发
05-25
SupContrast：有监督的对比学习本文档以CIFAR为例说明了PyTorch中...纸张损失功能loss.py中的损失函数SupConLoss以要素（L2标准化）和标签为输入，并返回损失。 如果标签为None或未传递给它，则它会退化为SimCLR。 用法
「视觉表示对比学习简单框架」（Geoffrey Hinton新论文）.zip
02-16
近日，深度学习先驱Geoffrey Hinton领衔的Google大脑团队发布了他们在视觉表示对比学习的最新研究成果-SimLCR，建立了新的SOTA视觉ImageNet识别模型，76.5%的top-1准确度，比以前的水平提高了7%，与监督的ResNet-50的性能相当。并有一系列重要的发现。
Pytorch十九种损失函数的使用详解
12-20
损失函数通过torch.nn包实现， 1 基本用法 criterion = LossCriterion() #构造函数有自己的参数 loss = criterion(x, y) #调用标准时也有参数 2 损失函数 2-1 L1范数损失 L1Loss 计算 output 和 target 之差的绝对值。 torch.nn.L1Loss(reduction='mean') 参数： reduction-三个值，none: 不使用约简；mean:返回loss和的平均值； sum:返回loss的和。默认：mean。 2-2 均方误差损失 MSELoss 计算 output 和 target 之差的均
[FSCE]FSCE: Few-Shot Object Detection via Contrastive Proposal Encoding(CVPR. 2021)
Ah丶Weii
08-25 2266
1. Motivation 本文是基于fine-tuning based方法 In this work, we observe and address the essential weakness of the fine- tuning based approach – constantly mislabeling novel in- stances as confusable categories, and improve the few-shot detection performance to t.
win10+jupyter+闪退+出现ImportError: cannot import name ‘secure_write‘ from ‘jupyter_core.paths‘错误
Catcher
11-09 1631
问题描述 jupyter打开后闪退，什么都没提示。然后使用Anaconda prompt 运行指令jupyter notebook，可以发现出现如下错误： (base) C:\Users\XuHR>jupyter notebook Traceback (most recent call last): File "C:\Users\XuHR\Anaconda3\Scripts\jupyter-notebook-script.py", line 6, in <module> fro
MATLAB算法实战应用案例精讲-【人工智能】对比学习（概念篇）
qq_36130719的博客
05-03 9028
对比学习」属于无监督学习的一种，即给一堆数据，没有标签，自己学习出一种特征表示。我们知道的无监督方法有聚类(迭代地更新聚类中心，让属于同一类的样本更近，不同类的样本更远)，自编码器(输入x->特征隐层编码->解码恢复出x'，让x'和x接近)，那对比学习又是怎么个操作，怎么构建loss反向传播呢？对比学习，关键是「对比」，根据聚类和自编码器的思想，对比应该也是有A和B更近，A和C更远这种比较性的思想的。所以关键在于如何拿到B和C。（其实聚类也算是一种对比）
【论文笔记_对比学习_2021】Supervised Contrastive Learning
qq_45128278的博客
07-25 1763
近年来，应用于自我监督表示学习的对比学习再次兴起，导致了深度图像模型的无监督训练中的艺术表现。现代批量对比方法包含或明显优于传统的对比损失，如三元组、最大余量和N对损失。在这项工作中，我们将自我监督的批量对比方法扩展到完全监督的设置，使我们能够有效地利用标签信息。属于同一类的点的聚类在嵌入空间中被拉在一起，同时推开来自不同类的样本的聚类。我们分析了监督对比(SupCon)损失的两种可能版本，确定了损失的最佳表现形式。交叉熵损失是深度分类模型的监督学习中最广泛使用的损失函数。我们的主要贡献总结如下。.....
ECCV2022 论文 Contrastive Deep Supervision
chen_znn的博客
09-28 2718
传统的训练方法只对神经网络的最后一层进行监督，并将误差逐层反向传播，由于梯度在传播过程中可能会消失，这将导致中间层优化起来比较困难。最近，有的方法提出使用深度监督把辅助分类器添加到深度神经网络的中间层，通过使用有监督的任务损失来优化这些辅助分类器。然而，底层的低级特征并不适合分类。为了解决这个问题，这篇文章提出了一种新的训练框架，称为对比深度监督，它通过基于增强的对比学习来监督中间层训练。
MindSpore的tile算子性能问题
weixin_45666880的博客
11-09 270
***************************************************解答*****************************************************经过这边复现 目前确实存在tile算子速度过慢的问题。mindspore模型在训练过程中的速度明显低于pytorch模型。具体到代码而言，在损失函数中，使用到了一次该算子。我根据API映射将该算子迁移过来。
torch.Tensor.grad属性的使用说明
敲代码的小风
01-20 6909
参考链接: torch.Tensor.grad
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序猿的探索之路

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值