模型优化系列1：分类器CenterLoss使用Pytorch实现MNIST、CIFAR10、CIFAR100分类图示

最新推荐文章于 2024-05-24 20:38:21 发布
最新推荐文章于 2024-05-24 20:38:21 发布
阅读量1.1k 收藏 7
点赞数 10
分类专栏： 模型优化 PyTorch 文章标签： pytorch 分类 人工智能 计算机视觉 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44240478/article/details/137228567
版权

CentLoss实现

前言

参考文章：史上最全MNIST系列（三）——Centerloss在MNIST上的Pytorch实现（可视化）
源码：Gitee或Github都有上传，保留了最优版，对最优版调整了一些参数看效果
Gitee传送门：点击这里跳转Gitee源码库
Github传送门：点击这里跳转Github源码库
--------------------无---------------情---------------分---------------割---------------线--------------------
贴心省流：最优效果见文末的v5版

v1

一开始实现的效果还行，但！是！
我忘记参数了（0.0！！）
于是，开始了漫长的尝试。。。

效果

image.png

v2

网络结构

self.hidden_layer = nn.Sequential(
    ConvLayer(1, 32, 3, 1, 1),
    ConvLayer(32, 32, 3, 1, 1),
    nn.MaxPool2d(2),
    ConvLayer(32, 64, 3, 1, 1),
    ConvLayer(64, 64, 3, 1, 1),
    nn.MaxPool2d(2),
    ConvLayer(64, 128, 3, 1, 1),
    ConvLayer(128, 128, 3, 1, 1),
    nn.MaxPool2d(2)
)

self.fc = nn.Sequential(
    nn.Linear(128 * 3 * 3, 12)
)

批次和学习率

data_loader = data.DataLoader(dataset=train_data, shuffle=True, batch_size=512)
# ...
net_opt = torch.optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
scheduler = torch.optim.lr_scheduler.StepLR(net_opt, 30, gamma=0.9)
c_l_opt = torch.optim.SGD(center_loss_fn.parameters(), lr=0.01, momentum=0.9)

效果

image.png

结论

分类效果不明显

v2_2

v2基础上仅修改了网络结构

网络结构

self.hidden_layer = nn.Sequential(
    ConvLayer(1, 32, 3, 1, 1),
    ConvLayer(32, 32, 3, 1, 1),
    nn.MaxPool2d(2),
    ConvLayer(32, 64, 3, 1, 1),
    ConvLayer(64, 64, 3, 1, 1),
    nn.MaxPool2d(2),
    ConvLayer(64, 128, 3, 1, 1),
    ConvLayer(128, 128, 3, 1, 1),
    nn.MaxPool2d(2)
)

self.fc = nn.Sequential(
    nn.Linear(128 * 3 * 3, 2)
)

self.output_layer = nn.Sequential(
    nn.Linear(2, 10)
)

批次和学习率

data_loader = data.DataLoader(dataset=train_data, shuffle=True, batch_size=512)
# ...
net_opt = torch.optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
scheduler = torch.optim.lr_scheduler.StepLR(net_opt, 30, gamma=0.9)
c_l_opt = torch.optim.SGD(center_loss_fn.parameters(), lr=0.01, momentum=0.9)

效果

image.png

结论

输出12–>2+10，分类效果明确，但未完全分开

v2_3

v2_2基础上仅修改了学习率

网络结构

self.hidden_layer = nn.Sequential(
    ConvLayer(1, 32, 3, 1, 1),
    ConvLayer(32, 32, 3, 1, 1),
    nn.MaxPool2d(2),
    ConvLayer(32, 64, 3, 1, 1),
    ConvLayer(64, 64, 3, 1, 1),
    nn.MaxPool2d(2),
    ConvLayer(64, 128, 3, 1, 1),
    ConvLayer(128, 128, 3, 1, 1),
    nn.MaxPool2d(2)
)

self.fc = nn.Sequential(
    nn.Linear(128 * 3 * 3, 2)
)

self.output_layer = nn.Sequential(
    nn.Linear(2, 10)
)

批次和学习率

data_loader = data.DataLoader(dataset=train_data, shuffle=True, batch_size=512)
# ...
net_opt = torch.optim.SGD(net.parameters(), lr=0.001, momentum=0.8)
scheduler = torch.optim.lr_scheduler.StepLR(net_opt, 30, gamma=0.8)
c_l_opt = torch.optim.SGD(center_loss_fn.parameters(), lr=0.01, momentum=0.8)

效果

image.png

结论

动量0.9–>0.8，分类效果不明显

v2_4

v2_2基础上仅修改了学习率

网络输出：2+10

self.hidden_layer = nn.Sequential(
    ConvLayer(1, 32, 3, 1, 1),
    ConvLayer(32, 32, 3, 1, 1),
    nn.MaxPool2d(2),
    ConvLayer(32, 64, 3, 1, 1),
    ConvLayer(64, 64, 3, 1, 1),
    nn.MaxPool2d(2),
    ConvLayer(64, 128, 3, 1, 1),
    ConvLayer(128, 128, 3, 1, 1),
    nn.MaxPool2d(2)
)

self.fc = nn.Sequential(
    nn.Linear(128 * 3 * 3, 2)
)

self.output_layer = nn.Sequential(
    nn.Linear(2, 10)
)

批次和学习率

data_loader = data.DataLoader(dataset=train_data, shuffle=True, batch_size=512)
# ...
net_opt = torch.optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
scheduler = torch.optim.lr_scheduler.StepLR(net_opt, 30, gamma=0.9)
c_l_opt = torch.optim.SGD(center_loss_fn.parameters(), lr=0.5, momentum=0.9)

效果

image.png

结论

center_loss学习率0.01–>0.5，分类效果不明显

v3

网络结构

self.hidden_layer = nn.Sequential(
    ConvLayer(1, 32, 5, 1, 1),
    ConvLayer(32, 32, 5, 1, 2),
    nn.MaxPool2d(2, 2),
    ConvLayer(32, 64, 5, 1, 1),
    ConvLayer(64, 64, 5, 1, 2),
    nn.MaxPool2d(2, 2),
    ConvLayer(64, 128, 5, 1, 1),
    ConvLayer(128, 128, 5, 1, 2),
    nn.MaxPool2d(2, 2)
)

self.fc = nn.Sequential(
    nn.Linear(128, 12)
)

批次和学习率

data_loader = data.DataLoader(dataset=train_data, shuffle=True, batch_size=1024)
# ...
net_opt = torch.optim.SGD(net.parameters(), lr=0.002, momentum=0.8)
scheduler = torch.optim.lr_scheduler.StepLR(net_opt, 20, gamma=0.8)
c_l_opt = torch.optim.SGD(center_loss_fn.parameters(), lr=0.7)

效果

image.png

v3_2

v3基础上修改学习率

网络结构

class MainNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.hidden_layer = nn.Sequential(
            ConvLayer(1, 32, 5, 1, 1),
            ConvLayer(32, 32, 5, 1, 2),
            nn.MaxPool2d(2, 2),
            ConvLayer(32, 64, 5, 1, 1),
            ConvLayer(64, 64, 5, 1, 2),
            nn.MaxPool2d(2, 2),
            ConvLayer(64, 128, 5, 1, 1),
            ConvLayer(128, 128, 5, 1, 2),
            nn.MaxPool2d(2, 2)
        )

        self.fc = nn.Sequential(
            nn.Linear(128, 12)
        )

    # self.output_layer = nn.Sequential(
    #     nn.Linear(2, 10)
    # )

    def forward(self, _x):
        h_out = self.hidden_layer(_x)
        h_out = h_out.reshape(-1, 128)
        # feature = self.fc(h_out)
        # outs = self.output_layer(feature)
        outs = self.fc(h_out)
        return outs

批次和学习率

data_loader = data.DataLoader(dataset=train_data, shuffle=True, batch_size=1024)
# ...
net_opt = torch.optim.SGD(net.parameters(), lr=0.001, momentum=0.8)
scheduler = torch.optim.lr_scheduler.StepLR(net_opt, 30, gamma=0.8)
c_l_opt = torch.optim.SGD(center_loss_fn.parameters(), lr=0.01, momentum=0.8)

效果

image.png

v4

网络结构

class MainNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.hidden_layer = nn.Sequential(
            ConvLayer(1, 32, 5, 1, 1),
            ConvLayer(32, 32, 5, 1, 2),
            nn.MaxPool2d(2, 2),
            ConvLayer(32, 64, 5, 1, 1),
            ConvLayer(64, 64, 5, 1, 2),
            nn.MaxPool2d(2, 2),
            ConvLayer(64, 128, 5, 1, 1),
            ConvLayer(128, 128, 5, 1, 2),
            nn.MaxPool2d(2, 2)
        )

        self.fc = nn.Sequential(
            nn.Linear(128, 2)
        )

        self.output_layer = nn.Sequential(
            nn.Linear(2, 10)
        )

    def forward(self, _x):
        h_out = self.hidden_layer(_x)
        h_out = h_out.reshape(-1, 128)
        feature = self.fc(h_out)
        outs = self.output_layer(feature)
        return torch.cat((feature, outs), dim=1)

批次和学习率

data_loader = data.DataLoader(dataset=train_data, shuffle=True, batch_size=1024)
# ...
net_opt = torch.optim.SGD(net.parameters(), lr=0.001, momentum=0.8)
scheduler = torch.optim.lr_scheduler.StepLR(net_opt, 30, gamma=0.8)
c_l_opt = torch.optim.SGD(center_loss_fn.parameters(), lr=0.1, momentum=0.8)

效果

image.png

v4_2

v4基础上修改了学习率

网络结构

class MainNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.hidden_layer = nn.Sequential(
            ConvLayer(1, 32, 5, 1, 1),
            ConvLayer(32, 32, 5, 1, 2),
            nn.MaxPool2d(2, 2),
            ConvLayer(32, 64, 5, 1, 1),
            ConvLayer(64, 64, 5, 1, 2),
            nn.MaxPool2d(2, 2),
            ConvLayer(64, 128, 5, 1, 1),
            ConvLayer(128, 128, 5, 1, 2),
            nn.MaxPool2d(2, 2)
        )

        self.fc = nn.Sequential(
            nn.Linear(128, 2)
        )

        self.output_layer = nn.Sequential(
            nn.Linear(2, 10)
        )

    def forward(self, _x):
        h_out = self.hidden_layer(_x)
        h_out = h_out.reshape(-1, 128)
        feature = self.fc(h_out)
        outs = self.output_layer(feature)
        return torch.cat((feature, outs), dim=1)

批次和学习率

data_loader = data.DataLoader(dataset=train_data, shuffle=True, batch_size=1024)
# ...
net_opt = torch.optim.SGD(net.parameters(), lr=0.001, momentum=0.8)
scheduler = torch.optim.lr_scheduler.StepLR(net_opt, 30, gamma=0.8)
c_l_opt = torch.optim.SGD(center_loss_fn.parameters(), lr=0.01, momentum=0.8)

效果

image.png

结论

centerloss优化器学习率0.1–>0.01，分类效果明显

更换批次

data_loader = data.DataLoader(dataset=train_data, shuffle=True, batch_size=256)
# ...
net_opt = torch.optim.SGD(net.parameters(), lr=0.001, momentum=0.8)
scheduler = torch.optim.lr_scheduler.StepLR(net_opt, 30, gamma=0.8)
c_l_opt = torch.optim.SGD(center_loss_fn.parameters(), lr=0.01, momentum=0.8)

效果

image.png

结论

批次1024–>256，计算速度加快，分类速度减慢

v4_3

v4基础上修改了学习率

网络结构

class MainNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.hidden_layer = nn.Sequential(
            ConvLayer(1, 32, 5, 1, 1),
            ConvLayer(32, 32, 5, 1, 2),
            nn.MaxPool2d(2, 2),
            ConvLayer(32, 64, 5, 1, 1),
            ConvLayer(64, 64, 5, 1, 2),
            nn.MaxPool2d(2, 2),
            ConvLayer(64, 128, 5, 1, 1),
            ConvLayer(128, 128, 5, 1, 2),
            nn.MaxPool2d(2, 2)
        )

        self.fc = nn.Sequential(
            nn.Linear(128, 2)
        )

        self.output_layer = nn.Sequential(
            nn.Linear(2, 10)
        )

    def forward(self, _x):
        h_out = self.hidden_layer(_x)
        h_out = h_out.reshape(-1, 128)
        feature = self.fc(h_out)
        outs = self.output_layer(feature)
        return torch.cat((feature, outs), dim=1)

批次和学习率

data_loader = data.DataLoader(dataset=train_data, shuffle=True, batch_size=1024)
# ...
net_opt = torch.optim.SGD(net.parameters(), lr=0.001, momentum=0.8)
scheduler = torch.optim.lr_scheduler.StepLR(net_opt, 30, gamma=0.8)
c_l_opt = torch.optim.SGD(center_loss_fn.parameters(), lr=0.5, momentum=0.8)

效果

image.png

结论

centerloss优化器学习率0.1–>0.5，分类效果明显

v5

加深网络，修改centerloss计算（取消平方根），修改学习率

centerloss计算

# return lamda / 2 * torch.mean(torch.div(torch.sqrt(torch.sum(torch.pow(_x - center_exp, 2), dim=1)), count_exp))
return lamda / 2 * torch.mean(torch.div(torch.sum(torch.pow((_x - center_exp), 2), dim=1), count_exp))

网络结构

self.hidden_layer = nn.Sequential(
    # ConvLayer(1, 32, 5, 1, 2),
    ConvLayer(3, 32, 5, 1, 2),
    ConvLayer(32, 64, 5, 1, 2),
    nn.MaxPool2d(2, 2),
    ConvLayer(64, 128, 5, 1, 2),
    ConvLayer(128, 256, 5, 1, 2),
    nn.MaxPool2d(2, 2),
    ConvLayer(256, 512, 5, 1, 2),
    ConvLayer(512, 512, 5, 1, 2),
    nn.MaxPool2d(2, 2),
    ConvLayer(512, 256, 5, 1, 2),
    ConvLayer(256, 128, 5, 1, 2),
    ConvLayer(128, 64, 5, 1, 2),
    nn.MaxPool2d(2, 2)
)

self.fc = nn.Sequential(
    # nn.Linear(64, 2)
    nn.Linear(64 * 2 * 2, 2)
)

self.output_layer = nn.Sequential(
    nn.Linear(2, 10)
)

批次和学习率

data_loader = data.DataLoader(dataset=train_data, shuffle=True, batch_size=256)
# ...
net_opt = torch.optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
scheduler = torch.optim.lr_scheduler.StepLR(net_opt, 20, gamma=0.8)
c_l_opt = torch.optim.SGD(center_loss_fn.parameters(), lr=0.5)

效果

MNIST
image.png
output.gif
image.png
CIFAR10
image.png
output_cifar10.gif
image.png
CIFAR100
image.png

饭碗、碗碗香
关注
  • 10
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
模型优化系列2：分类器ArcLoss使用Pytorch实现MNIST分类图示
一只努力学习的小碗~
04-24 419
分类器ArcLoss使用Pytorch实现MNIST分类
pytorch-center-loss：Pytorch实现中心损失
02-05
火炬中心损失 Pytorch实现中心损失的方法： （ ）也使用此损失函数。 开始吧 克隆此仓库并运行代码 $ git clone https://github.com/KaiyangZhou/pytorch-center-loss $ cd pytorch-center-loss $ python main.py --eval-freq 1 --gpu 0 --save-dir log/ --plot 您将在终端中看到以下信息 Currently using GPU: 0 Creating dataset: mnist Creating model: cnn == > Epoch
Pytorch训练分类器进行图像分类
最新发布
2301_76259531的博客
05-24 866
​​​return x​​torch.nntorch.nn是Pytorch的核心模块，专门用于构建和训练神经网络。它提供了许多预定义的神经网络层、激活函数、损失函数和其他相关工具。神经网络层线性层：如，实现全连接层（也称为密集层）。卷积层：如，实现二维卷积层，常用于图像处理任务。循环层：如和，用于处理序列数据。激活函数常见的激活函数如等。损失函数提供了多种损失函数，如等，用于评估模型的性能。容器：按顺序将多个层组合在一起，形成一个神经网络。和：用于存储和管理层的列表和字典。
Pytorch实现CenterLoss（实战）
liu1073811240的博客
11-24 4048
下面完整代码在github仓库：传送门 文章目录一、定义Center loss函数二、搭建网络模型三、开始训练数据 一、定义Center loss函数 import torch import torch.nn as nn def center_loss(feature, label, lambdas): center = nn.Parameter(torch.randn(int(max(label).item() + 1), feature.shape[1]), requires_grad=T
center loss pytorch实现总结
qq_45759229的博客
09-18 957
center loss pytorch实现总结
Center loss-pytorch代码详解
m0_37579232的博客
08-24 3655
首先上github代码：https://github.com/KaiyangZhou/pytorch-center-loss 主要代码如下： class CenterLoss(nn.Module): """Center loss. Reference: Wen et al. A Discriminative Feature Learning Approach for Deep Face Recognition. ECCV 2016. Args:.
Center Loss的Pytorch实现
gukedream的专栏
01-13 1万+
Center Loss的Pytorch实现开始结果在自己的项目中使用中心损失函数 Center Loss的Pytorch实现: Wen et al. A Discriminative Feature Learning Approach for Deep Face Recognition. ECCV 2016. 这个损失函数也被使用在： deep-person-reid github项目：https...
PyTorch - 数据集介绍（mnist、CIFAR10、CIFAR100）
Micheal 超 的博客
01-01 6692
参考自官网：torchvision.datasets 总介绍 torchvision.datasets中包含了以下数据集 MNIST COCO（用于图像标注和目标检测）(Captioning and Detection) LSUN Classification ImageFolder Imagenet-12 CIFAR10 and CIFAR100 STL10 详细介绍(以mnist手写数字集...
【Loss】Center loss代码详解（pytorch）
m0_51358406的博客
01-04 2656
**注：**全部代码在最后，此代码不知来自哪位大神。 m:batch size n:class size d:feat dim x=(x0x1...xm−1)=(x00x01...x0(d−1)x10x11...x1(d−1).............x(m−1)0x(m−1)1...x(m−1)(d−1))∈Rm×dx=\begin{pmatrix}x_0 \\ x_1\\ ...\\x_{m-1}\end{pmatrix} =\begin{pmatrix}x_{00}&x_{01}&am
Triplet Loss 和 Center Loss详解和pytorch实现
热门推荐
weixin_40671425的博客
08-01 2万+
最近在学习ReID相关的算法，为了提高ReID的性能通常会采用softmax loss 联合 Triplet Loss和Center Loss来提高算法的性能。 本文对Triplet Loss和Cnetr Loss做一个总结，以简洁的方式帮助理解。 Triplet Loss和Center Loss都是从人脸识别领域里面提出来的，后面在各种图像检索任务中被广泛应用。 想要了解Triplet L...
pytorchOCR之CRNN+centerloss
BADBADBADBOY的博客
03-13 2402
pytorchOCR之CRNN+centerloss 这是阿里团队提出来用来解决softmax对于形近字表征不足的问题，之前一直想写来着，写了一半被拉去做项目了，偶然逛GitHub，看见一位大佬也做了这个工作，原代码在此，本着我辈不嫖白不嫖的思想，花了一个周末嫖过来了。 思路 ...
Pytorch中accuracy和loss的计算知识点总结
09-18
在本片文章里小编给大家整理的是关于Pytorch中accuracy和loss的计算相关知识点内容，有需要的朋友们可以学习下。
基于多任务卷积网络(MTCNN)和Center-Loss的多人实时人脸检测和人脸识别系统
05-15
**DFace** 是个开源的深度学习人脸检测和人脸识别系统。所有功能都采用　**[pytorch](https://github.com/pytorch/pytorch)**　框架开发。pytorch是一个由facebook开发的深度学习框架，它包含了一些比较有趣的高级特性，例如自动求导，动态构图等。DFace天然的继承了这些优点，使得它的训练过程可以更加简单方便，并且实现的代码可以更加清晰易懂。 DFace可以利用CUDA来支持GPU加速模式。我们建议尝试linux GPU这种模式，它几乎可以实现实时的效果。
pytorch loss function 详解 带公式
心之所向
04-04 3903
链接
人脸识别 损失函数 centerloss arcfaceloss pytorch实现
不佛的博客
10-16 3265
Softmax loss
pytorch CenterLoss
jacke121的专栏
05-23 3592
原文：https://github.com/jxgu1016/MNIST_center_loss_pytorch c++不知道什么框架的： https://github.com/BOBrown/SSD-Centerloss # coding: utf8 import torch from torch.autograd import Variable class Center...
PyTorch学习系列(五)——自定义loss
CodeTutor
05-26 1万+
在PyTorch中可以自定义loss，并且只要输入到输出的过程中一直使用的都是Variable（没有用tensor或者numpy），那么loss可以自动求梯度。
center loss 实现MNIST数据集（pytorch）
center-loss实现MNIST数据集
07-30 1735
center loss import torch as t import torch.nn as nn import torch.nn.functional as F class CenterLoss(nn.Module): def __init__(self,cls_num,featur_num): super().__init__() sel...
pytorch 损失函数总结
jacke121的专栏
09-22 2万+
PyTorch深度学习实战 4　损失函数 损失函数，又叫目标函数，是编译一个神经网络模型必须的两个参数之一。另一个必不可少的参数是优化器。 损失函数是指用于计算标签值和预测值之间差异的函数，在机器学习过程中，有多种损失函数可供选择，典型的有距离向量，绝对值向量等。 上图是一个用来模拟线性方程自动学习的示意图。粗线是真实的线性方程，虚线是迭代过程的示意，w1 是第一次迭代的权重，w2 是...
帮我写一个使用pytorch实现cifar10分类的结论与展望
03-27
结论： 本文使用PyTorch实现了CIFAR-10分类任务，通过构建一个卷积神经网络模型，在测试集上取得了较高的准确率。具体来说，本文使用了6层卷积层和3层全连接层的神经网络模型，在训练集上进行了100个epoch的训练，最终在测试集上取得了80%的准确率。 此外，本文对比了不同的优化器和学习率下的训练效果，发现使用Adam优化器和较小的学习率可以取得更好的结果。同时，本文还对模型进行了可视化分析，发现模型对于一些类别的分类效果较差，可能需要进一步的优化。 展望： 虽然本文在CIFAR-10分类任务上取得了较好的结果，但是还有一些可以进一步优化的方向。首先是模型的结构，可以尝试更深层次、更复杂的网络结构，来提升模型的性能。其次是数据增强的方法，可以通过更多的数据增强技巧来增加训练数据的多样性，提升模型的泛化性能。最后是模型的解释性，可以通过可视化技术来深入探究模型的工作原理，进一步理解模型的优缺点，指导模型的优化。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

饭碗、碗碗香

感谢壮士的慷概解囊！

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

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

打赏作者

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

抵扣说明：

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

余额充值