VGG-19架构 pytorch实现

最新推荐文章于 2024-04-29 16:12:40 发布
最新推荐文章于 2024-04-29 16:12:40 发布
阅读量1.6k 收藏 10
点赞数 5
分类专栏： 深度学习 文章标签： pytorch 深度学习 cv
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52295416/article/details/120926581
版权

在这里插入图片描述

import torch
import torch.nn as nn
from torchinfo import summary
class VGG19(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1=nn.Conv2d(3,64,kernel_size=3,padding=1)
        self.conv2=nn.Conv2d(64,64,kernel_size=3,padding=1)
        self.pool1 = nn.MaxPool2d(kernel_size=2,stride=2)
        self.conv3=nn.Conv2d(64,128,kernel_size=3,padding=1)
        self.conv4=nn.Conv2d(128,128,kernel_size=3,padding=1)
        self.pool2=nn.MaxPool2d(kernel_size=2,stride=2)
        self.conv5 = nn.Conv2d(128, 256, kernel_size=3,padding=1)
        self.conv6 = nn.Conv2d(256, 256, kernel_size=3,padding=1)
        self.conv7 = nn.Conv2d(256, 256, kernel_size=3,padding=1)
        self.conv8 = nn.Conv2d(256, 256, kernel_size=3,padding=1)
        self.pool3=nn.MaxPool2d(kernel_size=2,stride=2)
        self.conv9 = nn.Conv2d(256, 512, kernel_size=3,padding=1)
        self.conv10 = nn.Conv2d(512, 512, kernel_size=3,padding=1)
        self.conv11= nn.Conv2d(512, 512, kernel_size=3,padding=1)
        self.conv12= nn.Conv2d(512, 512, kernel_size=3,padding=1)
        self.pool4=nn.MaxPool2d(kernel_size=2,stride=2,padding=1)
        self.conv13 = nn.Conv2d(512, 512, kernel_size=3,padding=1)
        self.conv14 = nn.Conv2d(512, 512, kernel_size=3,padding=1)
        self.conv15 = nn.Conv2d(512, 512, kernel_size=3,padding=1)
        self.conv16 = nn.Conv2d(512, 512, kernel_size=3,padding=1)
        self.pool5=nn.MaxPool2d(kernel_size=2,stride=2)
        self.fc1=nn.Linear(7*7*512,4096)
        self.fc2=nn.Linear(4096,4096)
        self.fc3=nn.Linear(4096,10)

        self.relu=nn.ReLU()
        self.softmax=nn.Softmax(dim=1)
        print("success")
    def forward(self,x):
        x = self.relu(self.conv1(x))
        x = self.relu(self.conv2(x))
        x = self.pool1(x)
        x = self.relu(self.conv3(x))
        x = self.relu(self.conv4(x))
        x = self.pool2(x)
        x = self.relu(self.conv5(x))
        x = self.relu(self.conv6(x))
        x = self.relu(self.conv7(x))
        x = self.relu(self.conv8(x))
        x = self.pool3(x)
        x = self.relu(self.conv9(x))
        x = self.relu(self.conv10(x))
        x = self.relu(self.conv11(x))
        x = self.relu(self.conv12(x))
        x = self.pool4(x)
        x = self.relu(self.conv13(x))
        x = self.relu(self.conv14(x))
        x = self.relu(self.conv15(x))
        x = self.relu(self.conv16(x))
        x = self.pool5(x)
        # x = x.view(x.size()[0], -1)
        x = x.view(-1,7*7*512)
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        output = self.softmax(self.fc3(x))
        return output

net= VGG19()
# print(net)
data=torch.ones(size=(10,3,224,224))
net(data)
print(net(data).shape)
print(net(data))
# summary(net)

结果：

=================================================================
Layer (type:depth-idx)                   Param #
=================================================================
VGG19                                    --
├─Conv2d: 1-1                            1,792
├─Conv2d: 1-2                            36,928
├─MaxPool2d: 1-3                         --
├─Conv2d: 1-4                            73,856
├─Conv2d: 1-5                            147,584
├─MaxPool2d: 1-6                         --
├─Conv2d: 1-7                            295,168
├─Conv2d: 1-8                            590,080
├─Conv2d: 1-9                            590,080
├─Conv2d: 1-10                           590,080
├─MaxPool2d: 1-11                        --
├─Conv2d: 1-12                           1,180,160
├─Conv2d: 1-13                           2,359,808
├─Conv2d: 1-14                           2,359,808
├─Conv2d: 1-15                           2,359,808
├─MaxPool2d: 1-16                        --
├─Conv2d: 1-17                           2,359,808
├─Conv2d: 1-18                           2,359,808
├─Conv2d: 1-19                           2,359,808
├─Conv2d: 1-20                           2,359,808
├─MaxPool2d: 1-21                        --
├─Linear: 1-22                           102,764,544
├─Linear: 1-23                           16,781,312
├─Linear: 1-24                           40,970
├─ReLU: 1-25                             --
├─Softmax: 1-26                          --
聪明乖巧的小狮子
关注
  • 5
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
VGG-11、VGG-16、VGG-19 Pytorch算法复现
03-04
VGG是一种经典的卷积神经网络架构，由牛津大学的研究团队提出。它在2014年的ImageNet图像分类挑战中取得了很好的成绩，成为了当时最先进的模型之一。VGG的主要特点是使用了非常小的卷积核（3x3）和深层网络结构，通过堆叠多个卷积层和池化层来提取图像特征。 基于Pytorch实现的VGG资源提供了一个方便的工具，使得用户可以轻松地使用VGG模型进行图像分类任务。通过加载预训练的VGG模型，用户可以快速地进行图像特征提取和分类。同时，Pytorch作为一个流行的深度学习框架，提供了丰富的功能和灵活性，使得用户可以方便地进行模型的训练和调整。
基于PyTorch的VGG19神经网络的图像风格迁移学习
03-14
这个资源是用基于PyTorch的框架做的，用的是VGG19的神经网络模型，做的是一个图像风格迁移的案例。代码很详细，我做了非常多的注释，容易看懂。
【PyTorch】构造VGG19网络进行本地图片分类（超详细过程）——程序代码
See_Star的博客
06-10 8682
构造VGG19网络进行本地图片分类（超详细过程），包括如何自定义网络、自建数据集并加载、自定模型并训练
imagenet-vgg-verydeep-19.mat
12-18
该资源为imagenet-vgg-verydeep-19.mat，可以在迁移学习的时候使用。必须要补充字数，我就再补两句。
Grad-CAM的Pytorch实现-python
06-18
Grad-CAM的Pytorch实现。Pytorch implementation of Grad-CAM Pytorch 中的 Grad-CAM 实现是什么让网络认为图像标签是“哈巴狗，哈巴狗”和“虎斑猫，虎斑猫”：将 Grad-CAM 与引导反向传播结合用于“哈巴狗，哈巴狗”类：梯度类激活图是深度学习网络的一种可视化技术。 见论文：https://arxiv.org/pdf/1610.02391v1.pdf 论文作者火炬实现：https://github.com/ramprs/grad-cam 我的 Keras 实现：https://github.com/jacobgil /keras-grad-cam 这使用来自 torchvision 的 VGG19。 第一次使用时会下载。 可以修改代码以适用于任何模型。 然而，torchvision 中的 VGG 模型具有用于网络卷积部分和全连接部分的特征/分类器方法。 此代码假定传递的模型支持这两种方法。 用法：python gradcam.py --image-path 与 CUDA 一起使用： python gradcam
【PyTorch】构造VGG19网络进行本地图片分类（超详细过程）——项目介绍
See_Star的博客
06-10 6228
一、VGG介绍 二、数据集介绍 Animal Image Dataset(DOG, CAT and PANDA) Dataset for Image Classification Practice 下载地址：https://www.kaggle.com/ashishsaxena2209/animal-image-datasetdog-cat-and-panda 该数据集共包含3类目标：狗、猫和熊猫；每种图片各1000张；图片尺寸不固定；大部分图片为RGB图片，少部分图片为灰度图片，所以在处理数据的时候要注意
使用pytorch中预训练模型VGG19获取图像特征，得到图像embedding
热门推荐
me_yundou的博客
10-22 2万+
使用pytorch预训练模型VGG19提取图像特征, 得到图像embedding 前言 pytorch中的VGG19预训练模型, 最后一层输出是1000维的图像分类结果, 但是如果我们只想要模型中某一层的输出特征, 比如全连接层的4096维度的特征, 要如何提取呢? 本文解决这个问题. 本文内容参考: https://zhuanlan.zhihu.com/p/105703821 https://blog.csdn.net/Geek_of_CSDN/article/details/84343971
运用pytorch实现基于VGG19的风格迁移（绝对能跑）
U20215153的博客
09-10 1282
【代码】运用pytorch实现基于VGG19的风格迁移（绝对能跑）
Pytorch学习笔记（I）——预训练模型（六）：VGG19网络结构
lockonlxf的博客
05-21 7361
VGG( (features): Sequential( (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) (1): ReLU(inplace) (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1...
利用pytorch搭建VGG16、VGG19卷积神经网络对cifar10数据集进行训练（置顶有详细注释源码，免费下载，仅供学习参考，欢迎大家在评论区学习交流）
qq_55834618的博客
10-27 905
数据集大小：60000张彩色图片，其中训练集50000张，测试集10000张；图像大小：32*32*3，3通道RGB，32*32个像素点；
VGG网络--基于pytorch实现
07-21
卷积神经网络经典--VGG网络，基于pytorch实现 包括构建网络模型、训练模型、测试准确率，采用cifa-10数据集
pytorch_gradcam_vgg19.py
01-10
代码为Grad-CAM:Visual Explanations from Deep Networks via Gradient-based Localization的复现，并有代码注释，以便读者理解学习。
VGG-Face Pytorch版模型
04-02
博客地址：https://blog.csdn.net/wen_fei/article/details/80261047 VGG-Face模型Pytorch版本，使用Pytorch的torch.load(VGG_FACE_LOCATION)可直接读取，基于千万张人脸数据训练，
基于pytorch搭建VGGNet神经网络用于花类识别
秃头小苏的博客
04-21 1933
  🍊作者简介：秃头小苏，致力于用最通俗的语言描述问题 🍊往期回顾：卡尔曼滤波系列1——卡尔曼滤波    基于pytorch搭建AlexNet神经网络用于花类识别 🍊近期目标：拥有5000粉丝 🍊支持小苏：点赞👍🏼、收藏⭐、留言📩 文章目录基于pytorch搭建VGGNet神经网络用于花类识别写在前面VGGNet网络模型搭建训练结果展示小结   基于pytorch搭建VGGNet神经网络用于花类识别 写在前面   上一篇写过基于pytorch搭建AlexNet神经网络用
简单易懂的PyTorch版VGG19复现代码
hlld__的博客
02-10 6921
VGG19网络结构 VGG的创新点包括使用3x3小核替换传统的5x5或7x7大核卷积，其整个网络除全连接层外，均采用步长为 1 填充为 1 的 3x3 卷积 + ReLU 和步长为 2 填充为 0 的 2x2 最大池化，网络结构非常简洁。VGG网络的输入维度为 3x224x224，在全连接层之前没有使用全局平均值池化压缩特征图的空间维度，而是直接将特征图的后 3 维 Flatten 后输入到全连接层中，这样导致第一个全连接层有较多的参数，且VGG包括 3 个全连接层，在训练时需要使用Dropout等正则化方
使用pytorch实现基于VGG 19预训练模型的鲜花识别分类器，准确度达到97%
qq_41562735的博客
12-17 4986
项目说明 本文使用的数据集是网络开源的鲜花数据集，并且基于VGG19的预训练模型通过迁移学习重新训练鲜花数据由此构建一个鲜花识别分类器 数据集 可以在此处找到有关花朵数据集的信息。数据集为102个花类的每一个都包含一个单独的文件夹。每朵花都标记为一个数字，每个编号的目录都包含许多.jpg文件。 实验环境 prtorch库 PIL库 如果想使用GPU训练的话请使用英伟达的显卡并安装好CUDA 如果用...
深度学习12—VGG19实现
m0_55196097的博客
05-29 1444
state_dict = load_state_dict_from_url(model_urls['vgg19'],model_dir='./model' ,progress=progress)#预训练模型地址。accuracy=((out.argmax(1)==label).sum()).clone().detach().cpu().numpy()#正确预测的总和比测试集的长度，即预测正确的精度。image=torch.reshape(image,(1,3,224,224))#四维图形，RGB三个通。
pytorch预训练
zxmyoung的博客
09-02 796
参考： https://www.cnblogs.com/wmlj/p/9917827.html Pytorch预训练模型以及修改 pytorch中自带几种常用的深度学习网络预训练模型，torchvision.models包中包含alexnet、densenet、inception、resnet、squeezenet、vgg等常用网络结构，并且提供了预训练模型，可通过调用来读取网络结构和预训练模型（模型参数）。往往为了加快学习进度，训练的初期直接加载pretrain模型中预先训练好的参数。加载model
nn.TransformerEncoderLayer详细解释，使用方法！！
最新发布
qlkaicx的博客
04-29 718
模块中提供的一个类，用于实现 Transformer 编码器的一个单独的层。Transformer 编码器层通常包括一个自注意力机制和一个前馈神经网络，中间可能还包含层归一化（Layer Normalization）和残差连接（Residual Connection）。来创建一个包含一个编码器层的 Transformer 编码器。最后，我们创建了一个随机的输入张量，并将其传递给编码器，以得到输出张量。在这个例子中，我们首先创建了一个。是 PyTorch 的。实例，然后将其传递给。
vgg-16 pytorch实现+注释
06-05
VGG-16是一种卷积神经网络模型，已被证明是一种有效的图像识别和分类工具。VGG-16主要由卷积层和全连接层组成，整个网络被分成13个卷积层和3个全连接层。这些层是根据其宽度和深度来命名的。在PyTorch中实现VGG-16，我们可以使用torchvision中提供的预训练模型。以下是一些实现中的注释： ``` import torch.nn as nn import torchvision.models as models # 使用VGG-16预训练模型 vgg16 = models.vgg16(pretrained=True) # 原始VGG-16模型已经训练好了，我们需要冻结其权重， # 这样它的权重在训练新任务时就不会被更新了 for param in vgg16.parameters(): param.requires_grad = False # 替换最后一层的全连接层 num_features = vgg16.classifier[6].in_features features = list(vgg16.classifier.children())[:-1] # 去掉最后一个全连接层 features.extend([nn.Linear(num_features, 10)]) # 添加一个新的全连接层，输出10个类别 vgg16.classifier = nn.Sequential(*features) # 在PyTorch中定义反向传播优化器和损失函数 criterion = nn.CrossEntropyLoss() optimizer = torch.optim.SGD(vgg16.parameters(), lr=0.001, momentum=0.9) # 训练模型 for epoch in range(10): # 训练10个epoch for i, (inputs, labels) in enumerate(trainloader, 0): # 输入数据 inputs, labels = inputs.to(device), labels.to(device) # 前向传播 outputs = vgg16(inputs) loss = criterion(outputs, labels) # 反向传播和优化 optimizer.zero_grad() loss.backward() optimizer.step() # 每1000批输出一次状态 if i % 1000 == 999: print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, loss.item() / 1000.0)) running_loss = 0.0 ``` 注释中解释了如何在PyTorch中实现VGG-16模型、如何替换最后一层的全连接层、如何定义反向传播优化器和损失函数，以及如何进行训练。其中，loss.backward()用于计算梯度，optimizer.step()用于更新权重。通过这些操作，我们可以训练一个新的神经网络模型，用于分类具有10个类别的图像。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值