VGG一维、二维复现pytorch

已于 2024-05-20 09:23:58 修改
阅读量2.6k 收藏 36
点赞数 8
分类专栏： Pytorch深度学习一维网络 文章标签： pytorch 深度学习 人工智能
于 2022-06-17 15:49:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chrnhao/article/details/125334357
版权

VGG网络可以说是深度学习中最著名的网络之一，因为VGG网络模型只是纵向的延申，网络结构比较简单，就竖着堆就行了又能适应大部分任务，准确率还有保障。比起GoogLeNet，ResNet和DenseNet来简直就是小学生难度。

文章目录


LeNet-AlexNet-ZFNet: LeNet-AlexNet-ZFNet一二维复现pytorch
VGG: VGG一二维复现pytorch
GoogLeNet: GoogLeNet一二维复现pytorch
ResNet: ResNet残差网络一二维复现pytorch-含残差块复现思路分析
DenseNet: DenseNet一二维复现pytorch
Squeeze: SqueezeNet一二维复现pytorch
MobileNet: |从零搭建网络| MobileNet系列网络详解及搭建(学弟提供)
Mnasnet: |从零搭建网络| Mnasnet网络详解及pytorch搭建(学弟提供)
ShuffleNet: |从零搭建网络| ShuffleNet系列网络详解及搭建(学弟提供)
EfficientNet: |从零搭建网络| EfficientNet网络详解及搭建(学弟提供)

下面的是我复现了所有一维卷积神经网络经典模型的链接地址
链接: https://github.com/StChenHaoGitHub/1D-deeplearning-model-pytorch.git

一维模型训练模板代码自己编写已开源
https://github.com/StChenHaoGitHub/1D_Pytorch_Train_demo.git
训练代码讲解博客地址
在这里插入图片描述

VGG

原文链接: VERY DEEP CONVOLUTIONAL NETWORKS FOR LARGE-SCALE IMAGE RECOGNITION
在这里插入图片描述
这几乎没什么好说的直接上干货

一维VGG19代码复现

import torch
from torchsummary import summary

class VGG19(torch.nn.Module):
    def __init__(self,In_channel=1,classes=5):
        super(VGG19, self).__init__()
        self.feature = torch.nn.Sequential(

            torch.nn.Conv1d(In_channel, 64, kernel_size=3, padding=1),
            torch.nn.BatchNorm1d(64),
            torch.nn.ReLU(),
            torch.nn.Conv1d(64, 64, kernel_size=3, padding=1),
            torch.nn.BatchNorm1d(64),
            torch.nn.ReLU(),
            torch.nn.MaxPool1d(2),

            torch.nn.Conv1d(64, 128, kernel_size=3, padding=1),
            torch.nn.BatchNorm1d(128),
            torch.nn.ReLU(),
            torch.nn.Conv1d(128, 128, kernel_size=3, padding=1),
            torch.nn.BatchNorm1d(128),
            torch.nn.ReLU(),
            torch.nn.MaxPool1d(2),

            torch.nn.Conv1d(128, 256, kernel_size=3, padding=1),
            torch.nn.BatchNorm1d(256),
            torch.nn.ReLU(),
            torch.nn.Conv1d(256, 256, kernel_size=3, padding=1),
            torch.nn.BatchNorm1d(256),
            torch.nn.ReLU(),
            torch.nn.Conv1d(256, 256, kernel_size=3, padding=1),
            torch.nn.BatchNorm1d(256),
            torch.nn.ReLU(),
            torch.nn.Conv1d(256, 256, kernel_size=3, padding=1),
            torch.nn.BatchNorm1d(256),
            torch.nn.ReLU(),
            torch.nn.MaxPool1d(2),

            torch.nn.Conv1d(256, 512, kernel_size=3, padding=1),
            torch.nn.BatchNorm1d(512),
            torch.nn.ReLU(),
            torch.nn.Conv1d(512, 512, kernel_size=3, padding=1),
            torch.nn.BatchNorm1d(512),
            torch.nn.ReLU(),
            torch.nn.Conv1d(512, 512, kernel_size=3, padding=1),
            torch.nn.BatchNorm1d(512),
            torch.nn.ReLU(),
            torch.nn.Conv1d(512, 512, kernel_size=3, padding=1),
            torch.nn.BatchNorm1d(512),
            torch.nn.ReLU(),
            torch.nn.MaxPool1d(2),

            torch.nn.Conv1d(512, 512, kernel_size=3, padding=1),
            torch.nn.BatchNorm1d(512),
            torch.nn.ReLU(),
            torch.nn.Conv1d(512, 512, kernel_size=3, padding=1),
            torch.nn.BatchNorm1d(512),
            torch.nn.ReLU(),
            torch.nn.Conv1d(512, 512, kernel_size=3, padding=1),
            torch.nn.BatchNorm1d(512),
            torch.nn.ReLU(),
            torch.nn.Conv1d(512, 512, kernel_size=3, padding=1),
            torch.nn.BatchNorm1d(512),
            torch.nn.ReLU(),
            torch.nn.MaxPool1d(2),

            torch.nn.AdaptiveAvgPool1d(7)
        )
        self.classifer = torch.nn.Sequential(
            torch.nn.Linear(3584,1024),
            torch.nn.ReLU(),
            torch.nn.Dropout(0.5),
            torch.nn.Linear(1024,1024),
            torch.nn.ReLU(),
            torch.nn.Dropout(0.5),
            torch.nn.Linear(1024, 512),
            torch.nn.ReLU(),
            torch.nn.Linear(512, classes),
        )

    def forward(self, x):
        x = self.feature(x)
        x = x.view(-1, 3584)
        x = self.classifer(x)
        return x


if __name__ == '__main__':
    model = VGG19(In_channel=1,classes=5)
    input = torch.randn(size=(1,1,224))
    output = model(input)
    print(f"输出大小{output.shape}")
    print(model)
    summary(model=model, input_size=(1, 224), device='cpu')

运行结果

输出大小torch.Size([1, 5])
VGG19(
  (feature): Sequential(
    (0): Conv1d(1, 64, kernel_size=(3,), stride=(1,), padding=(1,))
    (1): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
    (3): Conv1d(64, 64, kernel_size=(3,), stride=(1,), padding=(1,))
    (4): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (5): ReLU()
    (6): MaxPool1d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (7): Conv1d(64, 128, kernel_size=(3,), stride=(1,), padding=(1,))
    (8): BatchNorm1d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (9): ReLU()
    (10): Conv1d(128, 128, kernel_size=(3,), stride=(1,), padding=(1,))
    (11): BatchNorm1d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (12): ReLU()
    (13): MaxPool1d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (14): Conv1d(128, 256, kernel_size=(3,), stride=(1,), padding=(1,))
    (15): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (16): ReLU()
    (17): Conv1d(256, 256, kernel_size=(3,), stride=(1,), padding=(1,))
    (18): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (19): ReLU()
    (20): Conv1d(256, 256, kernel_size=(3,), stride=(1,), padding=(1,))
    (21): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (22): ReLU()
    (23): Conv1d(256, 256, kernel_size=(3,), stride=(1,), padding=(1,))
    (24): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (25): ReLU()
    (26): MaxPool1d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (27): Conv1d(256, 512, kernel_size=(3,), stride=(1,), padding=(1,))
    (28): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (29): ReLU()
    (30): Conv1d(512, 512, kernel_size=(3,), stride=(1,), padding=(1,))
    (31): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (32): ReLU()
    (33): Conv1d(512, 512, kernel_size=(3,), stride=(1,), padding=(1,))
    (34): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (35): ReLU()
    (36): Conv1d(512, 512, kernel_size=(3,), stride=(1,), padding=(1,))
    (37): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (38): ReLU()
    (39): MaxPool1d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (40): Conv1d(512, 512, kernel_size=(3,), stride=(1,), padding=(1,))
    (41): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (42): ReLU()
    (43): Conv1d(512, 512, kernel_size=(3,), stride=(1,), padding=(1,))
    (44): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (45): ReLU()
    (46): Conv1d(512, 512, kernel_size=(3,), stride=(1,), padding=(1,))
    (47): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (48): ReLU()
    (49): Conv1d(512, 512, kernel_size=(3,), stride=(1,), padding=(1,))
    (50): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (51): ReLU()
    (52): MaxPool1d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (53): AdaptiveAvgPool1d(output_size=7)
  )
  (classifer): Sequential(
    (0): Linear(in_features=3584, out_features=1024, bias=True)
    (1): ReLU()
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=1024, out_features=1024, bias=True)
    (4): ReLU()
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=1024, out_features=512, bias=True)
    (7): ReLU()
    (8): Linear(in_features=512, out_features=5, bias=True)
  )
)
----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv1d-1              [-1, 64, 224]             256
       BatchNorm1d-2              [-1, 64, 224]             128
              ReLU-3              [-1, 64, 224]               0
            Conv1d-4              [-1, 64, 224]          12,352
       BatchNorm1d-5              [-1, 64, 224]             128
              ReLU-6              [-1, 64, 224]               0
         MaxPool1d-7              [-1, 64, 112]               0
            Conv1d-8             [-1, 128, 112]          24,704
       BatchNorm1d-9             [-1, 128, 112]             256
             ReLU-10             [-1, 128, 112]               0
           Conv1d-11             [-1, 128, 112]          49,280
      BatchNorm1d-12             [-1, 128, 112]             256
             ReLU-13             [-1, 128, 112]               0
        MaxPool1d-14              [-1, 128, 56]               0
           Conv1d-15              [-1, 256, 56]          98,560
      BatchNorm1d-16              [-1, 256, 56]             512
             ReLU-17              [-1, 256, 56]               0
           Conv1d-18              [-1, 256, 56]         196,864
      BatchNorm1d-19              [-1, 256, 56]             512
             ReLU-20              [-1, 256, 56]               0
           Conv1d-21              [-1, 256, 56]         196,864
      BatchNorm1d-22              [-1, 256, 56]             512
             ReLU-23              [-1, 256, 56]               0
           Conv1d-24              [-1, 256, 56]         196,864
      BatchNorm1d-25              [-1, 256, 56]             512
             ReLU-26              [-1, 256, 56]               0
        MaxPool1d-27              [-1, 256, 28]               0
           Conv1d-28              [-1, 512, 28]         393,728
      BatchNorm1d-29              [-1, 512, 28]           1,024
             ReLU-30              [-1, 512, 28]               0
           Conv1d-31              [-1, 512, 28]         786,944
      BatchNorm1d-32              [-1, 512, 28]           1,024
             ReLU-33              [-1, 512, 28]               0
           Conv1d-34              [-1, 512, 28]         786,944
      BatchNorm1d-35              [-1, 512, 28]           1,024
             ReLU-36              [-1, 512, 28]               0
           Conv1d-37              [-1, 512, 28]         786,944
      BatchNorm1d-38              [-1, 512, 28]           1,024
             ReLU-39              [-1, 512, 28]               0
        MaxPool1d-40              [-1, 512, 14]               0
           Conv1d-41              [-1, 512, 14]         786,944
      BatchNorm1d-42              [-1, 512, 14]           1,024
             ReLU-43              [-1, 512, 14]               0
           Conv1d-44              [-1, 512, 14]         786,944
      BatchNorm1d-45              [-1, 512, 14]           1,024
             ReLU-46              [-1, 512, 14]               0
           Conv1d-47              [-1, 512, 14]         786,944
      BatchNorm1d-48              [-1, 512, 14]           1,024
             ReLU-49              [-1, 512, 14]               0
           Conv1d-50              [-1, 512, 14]         786,944
      BatchNorm1d-51              [-1, 512, 14]           1,024
             ReLU-52              [-1, 512, 14]               0
        MaxPool1d-53               [-1, 512, 7]               0
AdaptiveAvgPool1d-54               [-1, 512, 7]               0
           Linear-55                 [-1, 1024]       3,671,040
             ReLU-56                 [-1, 1024]               0
          Dropout-57                 [-1, 1024]               0
           Linear-58                 [-1, 1024]       1,049,600
             ReLU-59                 [-1, 1024]               0
          Dropout-60                 [-1, 1024]               0
           Linear-61                  [-1, 512]         524,800
             ReLU-62                  [-1, 512]               0
           Linear-63                    [-1, 5]           2,565
================================================================
Total params: 11,937,093
Trainable params: 11,937,093
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.00
Forward/backward pass size (MB): 4.92
Params size (MB): 45.54
Estimated Total Size (MB): 50.46
----------------------------------------------------------------

Process finished with exit code 0

二维VGG19代码复现

import torch
from torchsummary import summary

class VGG19(torch.nn.Module):
    def __init__(self,In_channel=3,classes=5):
        super(VGG19, self).__init__()
        self.feature = torch.nn.Sequential(

            torch.nn.Conv2d(In_channel, 64, kernel_size=3, padding=1),
            torch.nn.BatchNorm2d(64),
            torch.nn.ReLU(),
            torch.nn.Conv2d(64, 64, kernel_size=3, padding=1),
            torch.nn.BatchNorm2d(64),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(2),

            torch.nn.Conv2d(64, 128, kernel_size=3, padding=1),
            torch.nn.BatchNorm2d(128),
            torch.nn.ReLU(),
            torch.nn.Conv2d(128, 128, kernel_size=3, padding=1),
            torch.nn.BatchNorm2d(128),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(2),

            torch.nn.Conv2d(128, 256, kernel_size=3, padding=1),
            torch.nn.BatchNorm2d(256),
            torch.nn.ReLU(),
            torch.nn.Conv2d(256, 256, kernel_size=3, padding=1),
            torch.nn.BatchNorm2d(256),
            torch.nn.ReLU(),
            torch.nn.Conv2d(256, 256, kernel_size=3, padding=1),
            torch.nn.BatchNorm2d(256),
            torch.nn.ReLU(),
            torch.nn.Conv2d(256, 256, kernel_size=3, padding=1),
            torch.nn.BatchNorm2d(256),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(2),

            torch.nn.Conv2d(256, 512, kernel_size=3, padding=1),
            torch.nn.BatchNorm2d(512),
            torch.nn.ReLU(),
            torch.nn.Conv2d(512, 512, kernel_size=3, padding=1),
            torch.nn.BatchNorm2d(512),
            torch.nn.ReLU(),
            torch.nn.Conv2d(512, 512, kernel_size=3, padding=1),
            torch.nn.BatchNorm2d(512),
            torch.nn.ReLU(),
            torch.nn.Conv2d(512, 512, kernel_size=3, padding=1),
            torch.nn.BatchNorm2d(512),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(2),

            torch.nn.Conv2d(512, 512, kernel_size=3, padding=1),
            torch.nn.BatchNorm2d(512),
            torch.nn.ReLU(),
            torch.nn.Conv2d(512, 512, kernel_size=3, padding=1),
            torch.nn.BatchNorm2d(512),
            torch.nn.ReLU(),
            torch.nn.Conv2d(512, 512, kernel_size=3, padding=1),
            torch.nn.BatchNorm2d(512),
            torch.nn.ReLU(),
            torch.nn.Conv2d(512, 512, kernel_size=3, padding=1),
            torch.nn.BatchNorm2d(512),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(2),

            torch.nn.AdaptiveAvgPool2d(7)
        )
        self.classifer = torch.nn.Sequential(
            torch.nn.Linear(25088,1024),
            torch.nn.ReLU(),
            torch.nn.Dropout(0.5),
            torch.nn.Linear(1024,1024),
            torch.nn.ReLU(),
            torch.nn.Dropout(0.5),
            torch.nn.Linear(1024, 512),
            torch.nn.ReLU(),
            torch.nn.Linear(512, classes),
        )

    def forward(self, x):
        x = self.feature(x)
        x = x.view(-1, 25088)
        x = self.classifer(x)
        return x


if __name__ == '__main__':
    model = VGG19(In_channel=3,classes=5)
    input = torch.randn(size=(1,3,224,224))
    output = model(input)
    print(f"输出大小{output.shape}")
    print(model)
    summary(model=model, input_size=(3,224,224), device='cpu')

模型输出结果如下：

VGG19(
  (feature): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
    (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (5): ReLU()
    (6): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (7): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (9): ReLU()
    (10): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (12): ReLU()
    (13): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (14): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (16): ReLU()
    (17): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (18): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (19): ReLU()
    (20): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (21): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (22): ReLU()
    (23): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (24): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (25): ReLU()
    (26): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (27): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (28): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (29): ReLU()
    (30): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (31): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (32): ReLU()
    (33): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (34): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (35): ReLU()
    (36): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (37): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (38): ReLU()
    (39): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (40): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (41): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (42): ReLU()
    (43): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (44): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (45): ReLU()
    (46): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (47): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (48): ReLU()
    (49): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (50): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (51): ReLU()
    (52): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (53): AdaptiveAvgPool2d(output_size=7)
  )
  (classifer): Sequential(
    (0): Linear(in_features=3584, out_features=1024, bias=True)
    (1): ReLU()
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=1024, out_features=1024, bias=True)
    (4): ReLU()
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=1024, out_features=512, bias=True)
    (7): ReLU()
    (8): Linear(in_features=512, out_features=5, bias=True)
  )
)
----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1         [-1, 64, 224, 224]           1,792
       BatchNorm2d-2         [-1, 64, 224, 224]             128
              ReLU-3         [-1, 64, 224, 224]               0
            Conv2d-4         [-1, 64, 224, 224]          36,928
       BatchNorm2d-5         [-1, 64, 224, 224]             128
              ReLU-6         [-1, 64, 224, 224]               0
         MaxPool2d-7         [-1, 64, 112, 112]               0
            Conv2d-8        [-1, 128, 112, 112]          73,856
       BatchNorm2d-9        [-1, 128, 112, 112]             256
             ReLU-10        [-1, 128, 112, 112]               0
           Conv2d-11        [-1, 128, 112, 112]         147,584
      BatchNorm2d-12        [-1, 128, 112, 112]             256
             ReLU-13        [-1, 128, 112, 112]               0
        MaxPool2d-14          [-1, 128, 56, 56]               0
           Conv2d-15          [-1, 256, 56, 56]         295,168
      BatchNorm2d-16          [-1, 256, 56, 56]             512
             ReLU-17          [-1, 256, 56, 56]               0
           Conv2d-18          [-1, 256, 56, 56]         590,080
      BatchNorm2d-19          [-1, 256, 56, 56]             512
             ReLU-20          [-1, 256, 56, 56]               0
           Conv2d-21          [-1, 256, 56, 56]         590,080
      BatchNorm2d-22          [-1, 256, 56, 56]             512
             ReLU-23          [-1, 256, 56, 56]               0
           Conv2d-24          [-1, 256, 56, 56]         590,080
      BatchNorm2d-25          [-1, 256, 56, 56]             512
             ReLU-26          [-1, 256, 56, 56]               0
        MaxPool2d-27          [-1, 256, 28, 28]               0
           Conv2d-28          [-1, 512, 28, 28]       1,180,160
      BatchNorm2d-29          [-1, 512, 28, 28]           1,024
             ReLU-30          [-1, 512, 28, 28]               0
           Conv2d-31          [-1, 512, 28, 28]       2,359,808
      BatchNorm2d-32          [-1, 512, 28, 28]           1,024
             ReLU-33          [-1, 512, 28, 28]               0
           Conv2d-34          [-1, 512, 28, 28]       2,359,808
      BatchNorm2d-35          [-1, 512, 28, 28]           1,024
             ReLU-36          [-1, 512, 28, 28]               0
           Conv2d-37          [-1, 512, 28, 28]       2,359,808
      BatchNorm2d-38          [-1, 512, 28, 28]           1,024
             ReLU-39          [-1, 512, 28, 28]               0
        MaxPool2d-40          [-1, 512, 14, 14]               0
           Conv2d-41          [-1, 512, 14, 14]       2,359,808
      BatchNorm2d-42          [-1, 512, 14, 14]           1,024
             ReLU-43          [-1, 512, 14, 14]               0
           Conv2d-44          [-1, 512, 14, 14]       2,359,808
      BatchNorm2d-45          [-1, 512, 14, 14]           1,024
             ReLU-46          [-1, 512, 14, 14]               0
           Conv2d-47          [-1, 512, 14, 14]       2,359,808
      BatchNorm2d-48          [-1, 512, 14, 14]           1,024
             ReLU-49          [-1, 512, 14, 14]               0
           Conv2d-50          [-1, 512, 14, 14]       2,359,808
      BatchNorm2d-51          [-1, 512, 14, 14]           1,024
             ReLU-52          [-1, 512, 14, 14]               0
        MaxPool2d-53            [-1, 512, 7, 7]               0
AdaptiveAvgPool2d-54            [-1, 512, 7, 7]               0
           Linear-55                 [-1, 1024]       3,671,040
             ReLU-56                 [-1, 1024]               0
          Dropout-57                 [-1, 1024]               0
           Linear-58                 [-1, 1024]       1,049,600
             ReLU-59                 [-1, 1024]               0
          Dropout-60                 [-1, 1024]               0
           Linear-61                  [-1, 512]         524,800
             ReLU-62                  [-1, 512]               0
           Linear-63                    [-1, 5]           2,565
================================================================
Total params: 25,283,397
Trainable params: 25,283,397
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.57
Forward/backward pass size (MB): 351.86
Params size (MB): 96.45
Estimated Total Size (MB): 448.88
----------------------------------------------------------------

Process finished with exit code 0

如果需要训练模板，可以在下面的浩浩的科研笔记中的付费资料购买，赠送所有一维神经网络模型的经典代码，可以在模板中随意切换。

浩浩的科研笔记
关注
专栏目录
用Pytorch实现一个一维残差网络
weixin_42607969的博客
02-11 579
实现一个一维残差网络在PyTorch中非常简单。你可以定义一个继承自nn.Module类的自定义模型类，并在其中定义一维残差块，然后将多个残差块通过堆叠在一起来构建整个模型。 下面是一个示例代码： ``` import torch import torch.nn as nn class ResidualBlock(nn.Module): def init(self, in_features...
Pytorch_复现DHSNet过程、问题记录
t3321
03-26 1025
Salient object detection 显著性目标检测 2019.3.11～3.22 期间复现DHSNet 由于是第一次复现显著性目标检测算法，有很多东西需要边学边写，且中间尝试了Encoder_Decoder模型并且进行了训练，所以用了将近两周，时间比较长，过程、工作、问题记录如下。 一、论文 论文标题：DHSNet: Deep Hierarchical Saliency Networ...
VGG模型
qq_44294745的博客
05-25 3138
VGGNet的结构非常简洁，整个网络都使用了同样大小的卷积核尺寸（3x3）和最大池化尺寸（2x2）。 通过增加深度能有效地提升性能； VGG16是最佳的模型，从头到尾只有3x3卷积与2x2池化，简洁优美； 卷积可代替全连接，可适应各种尺寸的图片。
卷积神经网络之VGG模型
思维特二的博客
07-20 2296
卷积神经网络CNN是我们深度学习过程中 的入门网络模型。它在视觉识别任务上的表现很好奇。一个复杂的CNN网络是带有上百万参数和许多隐含层的。AlexNet，VGG，Inception和ResNet是一些流行的CNN网络。那就接下来我们就从VGG说起吧。 对于CNN模型，开始训练时我们可以使用一个很大的数据集如ImageNet（。CNN模型的两个特点：神经元间的权重共享和卷积层之间的稀疏连接。大部分的CNN模型都需要很大的内存和计算量，特别是在训练过程。要想尽可能的训练精度高，就要在计算量上增加。 VGG模
动手学深度学习之经典的卷积神经网络之VGG
Trony的博客
08-19 561
VGG VGG块 深 vs 宽 5 * 5卷积 3 * 3卷积 深但窄效果更好 VGG块 3 * 3卷积(填充1)(n层，m通道)。也就是说一个VGG块中可以有n个卷积层，每个卷积层的通道数都是一样的 2 * 2最大池化层(步幅2)。每个VGG块的最后一层 VGG架构 其实就是替换掉AlexNet的整个卷积的部分 在多个VGG块之后连接全连接层 不同次数的重复块得到不同的架构VGG-16,VGG-19… 进度 总结 VGG有两个思想影响了后来的研究：1、使用可重复的块来构建
VGG详解
热门推荐
disguise666的博客
04-02 3万+
VGG 一、背景介绍 VGG全称是Visual Geometry Group，因为是由Oxford的Visual Geometry Group提出的。AlexNet问世之后，很多学者通过改进AlexNet的网络结构来提高自己的准确率，主要有两个方向：小卷积核和多尺度。而VGG的作者们则选择了另外一个方向，即加深网络深度。 二、网络架构 卷积网络的输入是224 * 224的RGB图像，整个网络的组成...
在pytorch基础上复现FCN
m0_53926478的博客
04-21 926
FCN复现 数据读取代码 ###BagData.py import os import torch import torch.nn as nn from torch.utils.data import DataLoader, Dataset, random_split from torchvision import transforms import numpy as np import cv2 # from onehot import onehot transform = transforms.Com
【深度学习】基于PyTorch架构神经网络学习总结（基础概念&基本网络搭建）
weixin_62100318的博客
02-02 1207
利用PyTorch架构使用神经网络模型时，一般是利用torch.nn函数自定义神经网络框架 | 官方示例： 对于forward函数相对于是用来说明神经网络中的处理过程，如进行卷积运算的次数与类型等，也可以进行简单的数据处理，如下： 卷积层（convolution） stride参数用于设置卷积核在图像中的运行步数，如果为单个整数则说明横向纵向都是一样的，也可以设置为元组，（H,W）（横向、纵向）默认为1padding：进行填充使用示例： 输出效果：dilation:设置卷积核的间隔，一般设置为
浅谈 Mlp-Mixer（pytorch and keras）
__不想写代码__的博客
07-11 3808
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码
Pytorch学习
咬树羊的博客
03-17 958
pytorch
keras: 用预训练的模型提取特征
wzg2016的博客
03-12 4655
keras提供了VGG19在ImageNet上的预训练权重模型文件，其他可用的模型还有VGG16、Xception、ResNet50、InceptionV3 4个。 VGG19在keras中的定义： def VGG19(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, ...
torchsummary 中input size 异常的问题
爪爪熊的博客
09-25 7081
爪爪熊原创文章----谢绝转载 本文解决问题： torchsummary针对多个输入模型的时候，其输出信息中input size等存在着错误，这里提供方案解决这个错误。 当我们使用pytorch搭建好我们自己的深度学习模型的的时候，我们总想看看具体的网络信息以及参数量大小，这时候就要请出我们的神器 torchsummary了，torchsummary的简单使用如下所示： # pip install torchsummary from torchsummary import summary model
torchsummary和torchstat使用方法和结果分析
m0_56192771的博客
05-09 1万+
1 torchstat：查看模型的大小和浮动运算量 安装工具 pip install torchstat 使用例子 import torch import torch.nn as nn from torchstat import stat class Net(nn.Module): def __init__(self): super(Net, self).__init__() self.layer1 = nn.Sequential( nn
pytorch打印模型参数_Pytorch获取模型参数情况的方法
weixin_39725594的博客
12-07 4528
分享人工智能技术干货，专注深度学习与计算机视觉领域！相较于Tensorflow，Pytorch一开始就是以动态图构建神经网络图的，其获取模型参数的方法也比较容易，既可以根据其内建接口自己写代码获取模型参数情况，也可以借助第三方库来获取模型参数情况，下面，就让我们一起来了解Pytorch获取模型参数情况的这两种方法！Pytorch依据其内建接口自己写代码获取模型参数情况，我们主要是借助该框架提供的模...
基础分类网络VGG
weixin_30371875的博客
09-12 514
vgg16是牛津大学视觉几何组(Oxford Visual Geometry Group)2014年提出的一个模型. vgg模型也得名于此. 2014年，vgg16拿了Imagenet Large Scale Visual Recognition Challenge 2014 (ILSVRC2014) 比赛的冠军. 论文连接：https://arxiv.org/abs/1409.1556...
VGGNet结构分析
Coding
01-06 1万+
VGG是Visual Geometry Group, Department of Engineering Science, University of Oxford的缩写。他们组参加ILSVRC 2014时候组名叫VGG，所以提交的那种网络结构也叫VGG，或者叫VGGNet。VGG和GoogleNet同在2014年参赛，图像分类任务中GoogLeNet第一，VGG第二，它们都是重要的网络结构。 ...
一维卷积积分学习实例
越野者的博客
02-16 3973
本文主要参考内容为奥本海姆《信号与系统》2.2节连续时间线性时不变系统卷积积分，若有不正确的地方，敬请指正。
vs2017\vs2019 VGG19处理cifar-10数据集的TensorFlow实现
黄笳倞的博客
12-17 8690
这是针对于博客vs2017安装和使用教程（详细）和vs2019安装和使用教程（详细）的VGG19-CIFAR10项目新建示例 目录 一、代码(附有重要的注释) 二、项目结构 三、VGG简介 四、程序执行关键部分解析 五、训练过程和结果 六、参考博客和文献 一、代码(附有重要的注释) 1.博主提供的代码包含了很多重要的注释，都是博主精心查阅资料和debug的结果，对于新手了解ten...
卷积神经网络（含LeNet-5、AlexNet、BN、VGG、GoogleNet、ResNet实战）
qq_23334761的博客
03-21 4833
含LeNet-5、AlexNet、BN、VGG、GoogleNet、ResNet实战
resnet VGG
最新发布
09-06
ResNet (_residual network) 和 VGG (Visual Geometry Group) 都是深度学习领域非常知名的卷积神经网络架构。 ResNet是由Microsoft Research团队于2015年提出的，它解决了深度神经网络训练过程中存在的梯度消失和过拟合问题。ResNet的核心思想是引入了残差块（residual block），通过跳跃连接直接将输入传递到深层，使得网络能够更容易地学习到更深的特征表示，从而提高了模型的性能。ResNet因其深度和有效性，在ImageNet图像分类等任务上取得了显著成就，并且对后来的许多深度学习架构产生了深远影响。 VGG, 由牛津大学的Visual Geometry Group在2014年发布，其特点是网络结构简单、层次清晰，包含大量密集相连的小卷积层（通常3x3的滤波器）。这种设计让VGG特别适合于细节识别，如物体边界检测。VGG网络的特点是深度大，总共有16-19层，但每一层的卷积核数目相对较少，这导致计算资源需求较高。 尽管VGG不如ResNet深，但它在一些任务上的准确率非常高，特别是在小规模数据集上。然而，由于其计算复杂度，对于实时应用来说，ResNet的轻量级设计更为实用。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

浩浩的科研笔记

这我为您答疑发送资源的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值