PyTorch：VGG16网络模型

最新推荐文章于 2024-06-16 03:02:29 发布
最新推荐文章于 2024-06-16 03:02:29 发布
阅读量495 收藏 3
点赞数
分类专栏： PyTorch 文章标签： PyTorch Python VGG16
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cd_yourheart/article/details/113755220
版权

1、逐层定义网络

深度学习界的小学生一枚
从头开始，先了解一下VGG16，哈哈哈

VGG16的结构图随便百度一下就好
这里主要记录一下代码流程

import torch.nn as nn
from torchsummary import summary
import torch


class VGG16(nn.Module):
    def __init__(self):
        super(VGG16, self).__init__()
        self.maxpool1 = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )

        self.maxpool2 = nn.Sequential(
            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )

        self.maxpool3 = nn.Sequential(
            nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )

        self.maxpool4 = nn.Sequential(
            nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )

        self.maxpool5 = nn.Sequential(
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )

        self.dense = nn.Sequential(
            nn.Linear(512 * 5 * 5, 4096),
            nn.ReLU(),
            nn.Linear(4096, 4096),
            nn.ReLU(),
            nn.Linear(4096, 1000)
        )

    def forward(self, x):
        pool1 = self.maxpool1(x)
        pool2 = self.maxpool2(pool1)
        pool3 = self.maxpool3(pool2)
        pool4 = self.maxpool4(pool3)
        pool5 = self.maxpool5(pool4)

        flat = pool5.view(pool5.size(0), -1)
        class_ = self.dense(flat)
        return class_


if __name__ == "__main__":
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    vgg_model = VGG16().to(device)

    #给模型一个输入，查看输出size
    x = torch.rand(size=(8, 3, 160, 160))
    vgg_model(x)
    print(vgg_model(x).size())

    summary(vgg_model, (3, 160, 160))  # 打印网络结构

输出

D:\Anaconda3\envs\pytorch\python.exe E:/LearningCode/Torch/Torch-Learning/vgg16-learning-01.py
torch.Size([8, 1000])
----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1         [-1, 64, 160, 160]           1,792
              ReLU-2         [-1, 64, 160, 160]               0
            Conv2d-3         [-1, 64, 160, 160]          36,928
              ReLU-4         [-1, 64, 160, 160]               0
         MaxPool2d-5           [-1, 64, 80, 80]               0
            Conv2d-6          [-1, 128, 80, 80]          73,856
              ReLU-7          [-1, 128, 80, 80]               0
            Conv2d-8          [-1, 128, 80, 80]         147,584
              ReLU-9          [-1, 128, 80, 80]               0
        MaxPool2d-10          [-1, 128, 40, 40]               0
           Conv2d-11          [-1, 256, 40, 40]         295,168
             ReLU-12          [-1, 256, 40, 40]               0
           Conv2d-13          [-1, 256, 40, 40]         590,080
             ReLU-14          [-1, 256, 40, 40]               0
           Conv2d-15          [-1, 256, 40, 40]         590,080
             ReLU-16          [-1, 256, 40, 40]               0
        MaxPool2d-17          [-1, 256, 20, 20]               0
           Conv2d-18          [-1, 512, 20, 20]       1,180,160
             ReLU-19          [-1, 512, 20, 20]               0
           Conv2d-20          [-1, 512, 20, 20]       2,359,808
             ReLU-21          [-1, 512, 20, 20]               0
           Conv2d-22          [-1, 512, 20, 20]       2,359,808
             ReLU-23          [-1, 512, 20, 20]               0
        MaxPool2d-24          [-1, 512, 10, 10]               0
           Conv2d-25          [-1, 512, 10, 10]       2,359,808
             ReLU-26          [-1, 512, 10, 10]               0
           Conv2d-27          [-1, 512, 10, 10]       2,359,808
             ReLU-28          [-1, 512, 10, 10]               0
           Conv2d-29          [-1, 512, 10, 10]       2,359,808
             ReLU-30          [-1, 512, 10, 10]               0
        MaxPool2d-31            [-1, 512, 5, 5]               0
           Linear-32                 [-1, 4096]      52,432,896
             ReLU-33                 [-1, 4096]               0
           Linear-34                 [-1, 4096]      16,781,312
             ReLU-35                 [-1, 4096]               0
           Linear-36                 [-1, 1000]       4,097,000
================================================================
Total params: 88,025,896
Trainable params: 88,025,896
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.29
Forward/backward pass size (MB): 111.56
Params size (MB): 335.79
Estimated Total Size (MB): 447.64
----------------------------------------------------------------

Process finished with exit code 0

2、for循环定义网络

import torch
from torch import nn
from torchsummary import summary

class VGG(nn.Module):
    def __init__(self, num_classes=1000):
        super(VGG, self).__init__()
        layers = []
        in_dim = 3
        out_dim = 64
        for i in range(13):
            layers += [nn.Conv2d(in_dim, out_dim, 3, 1, 1), nn.ReLU(inplace=True)]
            in_dim = out_dim
            if i==1 or i==3 or i==6 or i==9 or i==12:
                layers += [nn.MaxPool2d(2, 2)]
                if i!=9:
                    out_dim*=2
        self.features = nn.Sequential(*layers)
        self.classifier = nn.Sequential(
            nn.Linear(512 * 7 * 7, 4096),
            nn.ReLU(True),
            nn.Dropout(),
            nn.Linear(4096, 4096),
            nn.ReLU(True),
            nn.Dropout(),
            nn.Linear(4096, num_classes),
        )
    def forward(self, x):
        x = self.features(x)
        x = x.view(x.size(0), -1)
        x = self.classifier(x)
        return x
    
vgg = VGG(21)
print(vgg.features)
print(vgg.classifier)
input = torch.randn(1, 3, 224, 224)
output = vgg(input)
summary(vgg, (3, 224, 224))
Sequential(
  (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (1): ReLU(inplace=True)
  (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (3): ReLU(inplace=True)
  (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (6): ReLU(inplace=True)
  (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (8): ReLU(inplace=True)
  (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (11): ReLU(inplace=True)
  (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (13): ReLU(inplace=True)
  (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (15): ReLU(inplace=True)
  (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (18): ReLU(inplace=True)
  (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (20): ReLU(inplace=True)
  (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (22): ReLU(inplace=True)
  (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (25): ReLU(inplace=True)
  (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (27): ReLU(inplace=True)
  (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (29): ReLU(inplace=True)
  (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
)
Sequential(
  (0): Linear(in_features=25088, out_features=4096, bias=True)
  (1): ReLU(inplace=True)
  (2): Dropout(p=0.5, inplace=False)
  (3): Linear(in_features=4096, out_features=4096, bias=True)
  (4): ReLU(inplace=True)
  (5): Dropout(p=0.5, inplace=False)
  (6): Linear(in_features=4096, out_features=21, bias=True)
)
----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1         [-1, 64, 224, 224]           1,792
              ReLU-2         [-1, 64, 224, 224]               0
            Conv2d-3         [-1, 64, 224, 224]          36,928
              ReLU-4         [-1, 64, 224, 224]               0
         MaxPool2d-5         [-1, 64, 112, 112]               0
            Conv2d-6        [-1, 128, 112, 112]          73,856
              ReLU-7        [-1, 128, 112, 112]               0
            Conv2d-8        [-1, 128, 112, 112]         147,584
              ReLU-9        [-1, 128, 112, 112]               0
        MaxPool2d-10          [-1, 128, 56, 56]               0
           Conv2d-11          [-1, 256, 56, 56]         295,168
             ReLU-12          [-1, 256, 56, 56]               0
           Conv2d-13          [-1, 256, 56, 56]         590,080
             ReLU-14          [-1, 256, 56, 56]               0
           Conv2d-15          [-1, 256, 56, 56]         590,080
             ReLU-16          [-1, 256, 56, 56]               0
        MaxPool2d-17          [-1, 256, 28, 28]               0
           Conv2d-18          [-1, 512, 28, 28]       1,180,160
             ReLU-19          [-1, 512, 28, 28]               0
           Conv2d-20          [-1, 512, 28, 28]       2,359,808
             ReLU-21          [-1, 512, 28, 28]               0
           Conv2d-22          [-1, 512, 28, 28]       2,359,808
             ReLU-23          [-1, 512, 28, 28]               0
        MaxPool2d-24          [-1, 512, 14, 14]               0
           Conv2d-25          [-1, 512, 14, 14]       2,359,808
             ReLU-26          [-1, 512, 14, 14]               0
           Conv2d-27          [-1, 512, 14, 14]       2,359,808
             ReLU-28          [-1, 512, 14, 14]               0
           Conv2d-29          [-1, 512, 14, 14]       2,359,808
             ReLU-30          [-1, 512, 14, 14]               0
        MaxPool2d-31            [-1, 512, 7, 7]               0
           Linear-32                 [-1, 4096]     102,764,544
             ReLU-33                 [-1, 4096]               0
          Dropout-34                 [-1, 4096]               0
           Linear-35                 [-1, 4096]      16,781,312
             ReLU-36                 [-1, 4096]               0
          Dropout-37                 [-1, 4096]               0
           Linear-38                   [-1, 21]          86,037
================================================================
Total params: 134,346,581
Trainable params: 134,346,581
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.57
Forward/backward pass size (MB): 218.58
Params size (MB): 512.49
Estimated Total Size (MB): 731.65
----------------------------------------------------------------

3、参数定义多种网络

import torch.nn as nn
import math


class VGG(nn.Module):

    def __init__(self, features, num_classes=1000, init_weights=True):
        super(VGG, self).__init__()
        self.features = features
        self.classifier = nn.Sequential(
            nn.Linear(512 * 7 * 7, 4096),
            nn.ReLU(True),
            nn.Dropout(),
            nn.Linear(4096, 4096),
            nn.ReLU(True),
            nn.Dropout(),
            nn.Linear(4096, num_classes),
        )
        if init_weights:
            self._initialize_weights()

    def forward(self, x):
        x = self.features(x)
        x = x.view(x.size(0), -1)
        x = self.classifier(x)
        return x

    def _initialize_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
                m.weight.data.normal_(0, math.sqrt(2. / n))
                if m.bias is not None:
                    m.bias.data.zero_()
            elif isinstance(m, nn.BatchNorm2d):
                m.weight.data.fill_(1)
                m.bias.data.zero_()
            elif isinstance(m, nn.Linear):
                m.weight.data.normal_(0, 0.01)
                m.bias.data.zero_()


def make_layers(cfg, batch_norm=False):
    layers = []
    in_channels = 3
    for v in cfg:
        if v == 'M':
            layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
        else:
            conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
            if batch_norm:
                layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
            else:
                layers += [conv2d, nn.ReLU(inplace=True)]
            in_channels = v
    return nn.Sequential(*layers)


cfg = {
    'A': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
    'B': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
    'D': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],
    'E': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],
}


def vgg11(**kwargs):
    model = VGG(make_layers(cfg['A']), **kwargs)
    return model


def vgg11_bn(**kwargs):
    model = VGG(make_layers(cfg['A'], batch_norm=True), **kwargs)
    return model


def vgg13(**kwargs):
    model = VGG(make_layers(cfg['B']), **kwargs)
    return model


def vgg13_bn(**kwargs):
    model = VGG(make_layers(cfg['B'], batch_norm=True), **kwargs)
    return model


def vgg16(**kwargs):
    model = VGG(make_layers(cfg['D']), **kwargs)
    return model


def vgg16_bn(**kwargs):
    model = VGG(make_layers(cfg['D'], batch_norm=True), **kwargs)
    return model


def vgg19(**kwargs):
    model = VGG(make_layers(cfg['E']), **kwargs)
    return model


def vgg19_bn(**kwargs):
    model = VGG(make_layers(cfg['E'], batch_norm=True), **kwargs)
    return model


if __name__ == '__main__':
    # 'VGG', 'vgg11', 'vgg11_bn', 'vgg13', 'vgg13_bn', 'vgg16', 'vgg16_bn', 'vgg19_bn', 'vgg19'
    # Example
    net11 = vgg11()
    print(net11)

六月的翅膀
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【使用Pytorch实现VGG16网络模型】
vcsir的专栏
07-30 7364
VGG-Network是K.Simonyan和A.Zisserman在论文“VeryDeepConvolutionalNetworksforLarge-ScaleImageRecognition”中提出的卷积神经网络模型。该架构在ImageNet中实现了92.7%的top-5测试准确率，该网络拥有超过1400万张属于1000个类别的图像。•模型的输入是固定大小的224×224224×224RGB图像•预处理是从每个像素中减去训练集RGB值的平均值。......
pytorch实现VGG16网络
方悔读书迟
07-27 7017
import torch import torch.nn as nn class VGG16(nn.Module): def __init__(self, nums): super(VGG16, self).__init__() self.nums = nums vgg = [] # 第一个卷积部分 # 112, 112, 64 vgg.append(nn.Conv2d(in_channels=3,.
VGG16-PyTorch-master.zip
08-20
Vgg16分类源码
Pytorch使用VGG16模型进行预测猫狗二分类
qq_43649937的博客
07-31 3680
pytorch python
【猫狗分类】Pytorch VGG16 实现猫狗分类2-模型构建
最新发布
zw_van的博客
06-16 1197
搭架子，搭建网络架子，就是先把这个VGG16网络,里面的算子层，按照VGG16那个结构，搭建起来，从开始知道，它一共是16层，按照顺序，搭建起来。但是这一块和自己搭建不一样，他不是先一层一层搭建的，它先把分类器给搭建了。把官方源代码复制过来，删除一些不必要的，用删除线表示，新增用斜线表示。这里分为两块，网络搭建+权重初始化先看看网络搭建部分，传特征，建池化层，按照顺序搭建: int: bool-> Noneself.features = features # 传特征self.
pytorch实现VGG16 (2)
m0_50127633的博客
05-19 1388
VGG16Net.py from torch import nn class Vgg16_net(nn.Module): def __init__(self): super(Vgg16_net, self).__init__() self.layer1=nn.Sequential( nn.Conv2d(in_channels=3,out_channels=64,kernel_size=3,stride=1,padding=1), #(32
使用pytorch实现VGG16模型(小白学习,详细注释)
热门推荐
m0_50127633的博客
05-19 3万+
VGG16的模型 首先我们可以看到VGG一共有六个模型,每个模型根据卷积层和全连接层的层数进行分类,第二张图就是VGG16的基本模型. 代码实现 Vgg16Net.py from torch import nn class Vgg16_net(nn.Module): def __init__(self): super(Vgg16_net, self).__init__() self.layer1=nn.Sequential( nn.C
Pytorch：VGG16
weixin_42782833的博客
07-08 1928
import torch import torch.nn as nn import torch.nn.functional as F class VGG16(nn.Module): def __init__(self): super(VGG16, self).__init__() #输入图片大小为：3 * 224 * 224 self.conv1_1 = nn.Conv2d(3, 64, 3) #
VGG-PyTorch-master_vgg16模型_VGG16pytorch_vgg16pytorchcode_
10-01
4. **批量归一化**（Batch Normalization）：虽然原始的VGG16模型没有使用批量归一化，但在PyTorch实现中，人们可能添加此层来加速训练过程和提高模型的泛化能力。 5. **ReLU激活函数**：VGG16模型广泛使用ReLU...
pytorch实现VGG网络
01-06
使用重复元素的网络（VGG） AlexNet在LeNet的基础上...VGG提出了可以通过重复使用简单的基础块来构建深度模型的思路。 VGG块 VGG块的组成规律是：连续使用数个相同的填充为1、窗口形状为的卷积层后接上一个步幅为2、窗
VGG扫盲帖：利用pytorch实现VGG16网络架构
l love CV
04-27 2264
调用pytorch已经封装好的包，来洞察VGG16的网络架构是如何搭建的
利用PyTorch实现VGG16教程
12-17
我就废话不多说了，大家还是直接看代码吧~ import torch import torch.nn as nn import torch.nn.functional as F class VGG16(nn.Module): def __init__(self): super(VGG16, self).__init__() # 3 * 224 * 224 self.conv1_1 = nn.Conv2d(3, 64, 3) # 64 * 222 * 222 self.conv1_2 = nn.Conv2d(64, 64, 3, padding=(1, 1)) # 64 * 2
pytorch_vgg16_classify.py
09-07
pytorch1.5实现的vgg16分类。在真实数据集测试成功 pytorch1.5实现的vgg16分类。在真实数据集测试成功 pytorch1.5实现的vgg16分类。在真实数据集测试成功
pytorch迁移学习训练VGG16和模型测试代码
05-13
Pytorch迁移学习训练VGG16和模型测试代码（采用华为云modelarts训练），训练猫狗分类模型
GestureRecognition-PyTorch:动作识别网络-CNN + LSTM
05-13
微调预训练的CNN模型（AlexNet，VGG，ResNet），然后微调LSTM。 该网络应用于手势控制无人机。 训练： 下载直升机编组数据集： : usp 将数据集放在/data文件夹下 运行培训代码并指定数据文件夹的路径 python basic...
深度学习之基于Tensorflow2.0实现VGG16网络
starlet_kiss的博客
10-01 3952
VGG系列的网络，在网络深度上相比于其之前的网络有了提升，VGG16与VGG19是VGG系列的代表，本次基于Tensorflow2.0实现VGG16网络。 1.VGG16 网络简介 VGG16网络模型在2014年ImageNet比赛上脱颖而出，取得了在分类任务上排名第二，在定位任务上排名第一的好成绩。VGG16网络相比于之前的LexNet以及LeNet网络，在当时的网络层数上达到了空前的程度。 2.网络结构 3.创新点 ① 使用3x3的卷积核代替7x7的卷积核。 3x3 卷积核是能够感受到上下、左右重点的
VGG-16网络模型pytorch实现
Hawley的博客
11-20 735
VGG-16网络模型pytorch实现 今天把VGG-16的网络模型过了一遍，来记录一下，我是根据别人的博客改的代码，并没有完全的自己敲一遍。 下面是吴恩达老师第四课——第二周——2.2经典网络里的VGG-16网络结构图 这张图里很清晰的讲解了各个层图像的尺度和深度，以及卷积层和池化层的位置。 AlexNet只有八层网络，使用1111的卷积核（滤波器），而VGG-16有16层网络，使用的是33的卷积核（滤波器）。VGG的优势在于使用3*3的卷积核代替AlexNet中大的卷积核，在具有相同的感受野的同
vgg16的网络结构
xiaobumi123的博客
04-16 4127
vgg16名字的由来是其结构卷积块共有5个，一共有2+2+3+3+3=13个卷积层，全连接层3个，共16个，所以称为16，还有vgg11，13，16，19的结构。
用pytorch搭建vgg16模型
08-25
我可以提供一些关于如何使用PyTorch搭建VGG16模型的指导。首先，你需要创建一个VGG16模型，可以使用PyTorch实现。其次，你需要定义模型的架构，如层数，激活函数，池化层等。紧接着，你需要使用PyTorch定义一个优化...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值