简单粗暴，上手修改原始神经网络模型的结构，以mobilenetv2为例

最新推荐文章于 2024-03-11 01:51:43 发布
最新推荐文章于 2024-03-11 01:51:43 发布
阅读量3.8k 收藏 28
点赞数 7
分类专栏： python pytorch 文章标签： 深度学习 python 神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/booklijian/article/details/107359243
版权

如题，想用mobilenetv2来训练自己的数据集，那肯定需要对原有的模型进细微的修改，至少需要把分类数给修改一下吧。

要想细微修改网络模型，则需要首先知道网络模型的结构，以mobilenetv2为例，简单使用如下代码：

from torchvision.models import mobilenet_v2
import torch.nn as nn

num_classes=100
net=mobilenet_v2().cuda()
print(net)

运行上述代码，显示mobilenetv2的网络结构，相关信息如下：

MobileNetV2(
  (features): Sequential(
    (0): ConvBNReLU(
      (0): Conv2d(3, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU6(inplace=True)
    )
    (1): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)
          (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): Conv2d(32, 16, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (2): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (2): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(16, 96, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(96, 96, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=96, bias=False)
          (1): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(96, 24, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (3): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(24, 144, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(144, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(144, 144, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=144, bias=False)
          (1): BatchNorm2d(144, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(144, 24, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (4): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(24, 144, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(144, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(144, 144, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=144, bias=False)
          (1): BatchNorm2d(144, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(144, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (5): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(32, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(192, 192, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=192, bias=False)
          (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(192, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (6): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(32, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(192, 192, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=192, bias=False)
          (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(192, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (7): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(32, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(192, 192, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=192, bias=False)
          (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(192, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (8): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(64, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384, bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(384, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (9): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(64, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384, bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(384, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (10): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(64, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384, bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(384, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (11): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(64, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384, bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(384, 96, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (12): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(96, 576, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(576, 576, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=576, bias=False)
          (1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(576, 96, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (13): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(96, 576, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(576, 576, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=576, bias=False)
          (1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(576, 96, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (14): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(96, 576, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(576, 576, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=576, bias=False)
          (1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(576, 160, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (15): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(160, 960, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(960, 960, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=960, bias=False)
          (1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(960, 160, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (16): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(160, 960, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(960, 960, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=960, bias=False)
          (1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(960, 160, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (17): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(160, 960, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(960, 960, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=960, bias=False)
          (1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(960, 320, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(320, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (18): ConvBNReLU(
      (0): Conv2d(320, 1280, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (1): BatchNorm2d(1280, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU6(inplace=True)
    )
  )
  (classifier): Sequential(
    (0): Dropout(p=0.2, inplace=False)
    (1): Linear(in_features=1280, out_features=1000, bias=True)
  )
)

 可以看到，网络结构比较长，内容太多，我们可以仅仅看最后一部分， classifier，使用代码如下：

from torchvision.models import mobilenet_v2
import torch.nn as nn

num_classes=100
net=mobilenet_v2().cuda()
print(net.classifier)

可以看到classifer层的具体情况：

Sequential(
  (0): Dropout(p=0.2, inplace=False)
  (1): Linear(in_features=1280, out_features=1000, bias=True)
)

而如果要对最后一层进行简单修改（例如将最后一层的out_features=1000修改为你自己数据集的种类数）：

from torchvision.models import mobilenet_v2
import torch.nn as nn

num_classes=100
net=mobilenet_v2().cuda()
net.classifier=nn.Sequential(
    nn.Dropout(0.2),
    nn.Linear(in_features=1280,out_features=num_classes,bias=True)
)
print("---------------------------After -----------------")
print(net.classifier)

 运行结果如下：

---------------------------After -----------------
Sequential(
  (0): Dropout(p=0.2, inplace=False)
  (1): Linear(in_features=1280, out_features=100, bias=True)
)

Process finished with exit code 0

要想了解mobilenetv2的具体实现情况，也可以详细阅读源代码，pytorch版本的可以在这里找到：https://github.com/pytorch/vision/blob/master/torchvision/models/mobilenet.py

-------------------- 正文到此结束------------------------

推荐一个公众号：健哥聊量化，会持续推出股票相关基础知识，以及python实现的一些基本的分析代码。欢迎大家关注，二维码如下：

相关文章列表如下：

dataat
关注
  • 7
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
轻量级CNN架构设计
lvlei19911108的博客
06-16 748
卷积神经网络架构设计，又指backbone设计，主要是根据具体任务的数据集特点以及相关的评价指标来确定一个网络结构的输入图像分辨率，深度，每一层宽度，拓扑结构等细节。公开发表的论文大多都是基于ImageNet这种大型的公开数据集来进行的通用结构设计，早期只以其分类精度来证明设计的优劣，后来也慢慢开始对比参数量(Params)和计算量(FLOPs)，由于ImageNet的数据量十分巨大且丰富，所以通...
简单粗暴理解与实现机器学习之神经网络NN（五）：神经网络案例DNN文本多分类——IMDB电影评论文本的神经网络分类
12-22
文章目录7.5 案例：DNN文本多分类学习目标7.5.1 IMDB电影评论文本的神经网络分类参数 7.5 案例：DNN文本多分类 学习目标 目标 无 应用 应用tf estimator完成文本分类 7.5.1 IMDB电影评论文本的神经网络分类 目的：对...
改神经网络模型的方法（1）
10-08 5181
《Bag of Tricks for Image Classification with Convolutional Neural Networks(2018)》，论文中以ResNet为例提出了一些简单的微调技巧，并且取得了一定的成果。且不说准确率如何，论文中除了分析准确率有着怎样怎样的提升之外，还关注了产生了额外开销，并且通过分析、实验量化了这些开销，这是值得肯定的（比那些不考虑开销，盲目微调，通过牺牲很多速度来提高那一点点准确率的论文，不知道要高到哪里去！） 以ResNet为例 原始的ResNet模
MobileNetV2轻量化网络结构（TensorFlow-2.6.0实现结构）
Keep_Trying_Go的博客
05-07 1793
文章目录1.论文地址2.关于MobileNetV1博客3.MobileNetV1的局限性4.模型之间的对比（1）MobileNetV1和MobileNetV2（2）ResNet和MobileNetV25.MobileNetV2采用了新的激活函数ReLU66.MobileNetV2网络结构7.为什么很多Depthwise convolutions之后训练出来的很多都是0呢？8.实验结果对比9.TensorFlow实现网络结构 1.论文地址 https://arxiv.org/abs/1801.04381 2
（深度学习，自监督、半监督、无监督！！！）神经网络修改网络结构如何下手？？？
weixin_45325693的博客
08-03 768
（深度学习，自监督、半监督、无监督！！！）神经网络修改网络结构如何下手？？？
神经网络优化: 提高性能与效率
禅与计算机程序设计艺术
01-08 1063
1.背景介绍 神经网络优化是一种针对神经网络模型的优化技术，旨在提高模型的性能和效率。随着神经网络在各个领域的广泛应用，如计算机视觉、自然语言处理、语音识别等，神经网络模型的规模越来越大，计算量也越来越大。因此，优化神经网络成为了一个重要的研究方向。 在本文中，我们将从以下几个方面进行阐述： 背景介绍 核心概念与联系 核心算法原理和具体操作步骤以及数学模型公式详细讲解 具体代码实例和详细解...
3 TensorFlow 模型建立与训练 — 简单粗暴 TensorFlow 2 0.4 beta 文档.pdf
10-30
在 TensorFlow 2.0.4 beta 版本中，模型建立与训练是核心部分，它涉及到使用 Keras API 创建和优化神经网络模型。Keras 是一个高级神经网络库，易于使用且灵活，已经被 TensorFlow 官方全面支持。在这个文档中，我们...
5 TensorFlow模型导出 — 简单粗暴 TensorFlow 2 0.4 beta 文档.pdf
10-30
SavedModel提供了这样的功能，它不仅包含模型的权重，还包含了模型的计算流程，使得模型可以脱离原始代码独立运行。了解和掌握如何正确地导出和加载SavedModel对于实现TensorFlow模型的高效部署至关重要。
简单粗暴学习数据结构与算法——JS版（一）
06-13
这篇教程"简单粗暴学习数据结构与算法——JS版（一）"显然旨在帮助初学者或有一定基础的开发者通过JavaScript来深入理解这些概念。 首先，数据结构是存储和组织数据的方式，它决定了数据的访问效率和操作便利性。在...
论文研究-BP神经网络模型的改进.pdf
09-20
论文研究-BP神经网络模型的改进.pdf,  本文在深入研究ＢＰ神经网络模型的基础上，提出了对该模型的若干改进技术处理方法，并通过仿真试验．实践表明，这些改进和技术处理方法是有效的．
简单粗暴学习数据结构与算法——JS版(二)
06-14
本教程"简单粗暴学习数据结构与算法——JS版(二)"显然是为那些希望通过JavaScript来学习数据结构与算法的初学者或开发者设计的。 首先，我们来讨论数据结构。数据结构是指在计算机中组织和存储数据的方式，它决定了...
10 使用TPU训练TensorFlow模型（Huan） — 简单粗暴 TensorFlow 2 0.4 beta 文档.pdf
10-30
【标题】和【描述】提到的是关于使用TPU（Tensor Processing Unit）训练TensorFlow模型的教程，源自“简单粗暴 TensorFlow 2.0.4 beta 文档”。本文将深入探讨TPU的基本概念、优势以及如何配置TPU环境，特别是通过...
一张图片收益2000＋，AI一键生成爆款原创作品简单粗暴，小白轻松上手
最新发布
03-27
AI 绘画的出现，为广大的绘画爱好者和创作者提供了一种全新的创作方式。 二、AI 绘画的优势 简单易用：即使没有绘画基础，也能通过 AI 绘画软件轻松创作出高质量的绘画作品。 高效快捷：AI 绘画能够自动完成一些重复...
简单粗暴 TensorFlow 2.0
10-12
简单粗暴 TensorFlow 2.0
pytorch中根据神经网络结构确定输入图片尺寸（根据图片尺寸修改神经网络结构）
Fighting Hua
06-21 3486
在学习pytorch的过程中，看到一些代码的解释中会说这个网络的期望输入大小为32x32（也可能是其他数字），请将输入图片调整为32x32。 开始的时候有一些不解，仔细看代码后明白，为代码条理清晰，一些神经网络结构事先被定义好，当卷积神经网络中包含有全连接层时，由于全连接层被设置为是固定尺寸的输入输出，全连接层的输入与输入图像尺寸息息相关，故定义好网络结构后，输入图像尺寸亦随之确定。 所以在用pytorch编写神经网络结构时，尤其是卷积神经网络，要特别注意输入图像的尺寸，如果想套用某个网络结构，需要先通过
迁移学习 修改预训练参数的网络模型
weixin_73101319的博客
03-11 392
在迁移学习中，要使用预训练权重。在训练好的网络权重中，使用的是1000类的分类任务。而我们自己的分类任务中没有1000类，需要修改网络。如果将MobileNetV2(num_classes=5)，我们的网络在最后输出是5类，与1训练好的1000类不符。这时候就要将训练参数中的最后输出1000类的那层删除掉。然后将参数冻结，只训练最后一层参数。
神经网络-网络模型的使用及修改、保存与读取
weixin_48139224的博客
08-14 700
太大太慢了，没办法使用imagenet数据集去验证VGG16模型中参数pretrain了，改变策略：把这个参数设置为TRUE/FALSE，去看看下载的网络模型差别。pretrained=TRUE时，才是从网络中进行下载，VGG16网络模型中的一些参数都是在数据集上训练好的。思路二：在线性层下面加一层，使in_features=1000,out_features=10。分类结果：输出为1000，即在imagenet上训练后的结果。（2）查看vgg16模型在imagenet数据集上训练的结果。
cannot import ConvBNReLU from torchision.models.mobilenet解析
weixin_44321389的博客
09-13 1974
这是因为torchvision版本是0.11，版本过高，代码中引用的ConvBNReLU模块已经不能直接从mobilenet引用，如果torchvision版本是0.7，是可以的。注意torch版本和torchvision版本有对应关系。
蓝牙5入门指南：CC2640R2F快速上手与常见问题解答
"《简单粗暴学蓝牙5（CC2640R2F篇）》是一本由作者甜甜的大香瓜编写的教程，专注于快速学习和理解蓝牙5技术，特别是针对CC2640R2F芯片。这本书的特点在于其及时更新性，作者根据读者反馈迅速修复错误并发布新版本，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值