VGGNet网络搭建（tensorflow，keras）

已于 2022-04-09 18:30:48 修改
阅读量806 收藏 1
点赞数
文章标签： python tensorflow 神经网络 卷积神经网络 机器学习
于 2022-04-08 17:56:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57780419/article/details/124047603
版权

VGGNet网络搭建

网络结构：

在这里插入图片描述

自定义VGGNet网络类：

class VGG16(Model):
    def __init__(self):
        super(VGG16, self).__init__()
        self.c1 = Conv2D(filters=64, kernel_size=(3, 3), padding='same')  # 卷积层1
        self.b1 = BatchNormalization()  # BN层1
        self.a1 = Activation('relu')  # 激活层1
        self.c2 = Conv2D(filters=64, kernel_size=(3, 3), padding='same', )
        self.b2 = BatchNormalization()  # BN层1
        self.a2 = Activation('relu')  # 激活层1
        self.p1 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
        self.d1 = Dropout(0.2)  # dropout层

        self.c3 = Conv2D(filters=128, kernel_size=(3, 3), padding='same')
        self.b3 = BatchNormalization()  # BN层1
        self.a3 = Activation('relu')  # 激活层1
        self.c4 = Conv2D(filters=128, kernel_size=(3, 3), padding='same')
        self.b4 = BatchNormalization()  # BN层1
        self.a4 = Activation('relu')  # 激活层1
        self.p2 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
        self.d2 = Dropout(0.2)  # dropout层

        self.c5 = Conv2D(filters=256, kernel_size=(3, 3), padding='same')
        self.b5 = BatchNormalization()  # BN层1
        self.a5 = Activation('relu')  # 激活层1
        self.c6 = Conv2D(filters=256, kernel_size=(3, 3), padding='same')
        self.b6 = BatchNormalization()  # BN层1
        self.a6 = Activation('relu')  # 激活层1
        self.c7 = Conv2D(filters=256, kernel_size=(3, 3), padding='same')
        self.b7 = BatchNormalization()
        self.a7 = Activation('relu')
        self.p3 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
        self.d3 = Dropout(0.2)

        self.c8 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        self.b8 = BatchNormalization()  # BN层1
        self.a8 = Activation('relu')  # 激活层1
        self.c9 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        self.b9 = BatchNormalization()  # BN层1
        self.a9 = Activation('relu')  # 激活层1
        self.c10 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        self.b10 = BatchNormalization()
        self.a10 = Activation('relu')
        self.p4 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
        self.d4 = Dropout(0.2)

        self.c11 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        self.b11 = BatchNormalization()  # BN层1
        self.a11 = Activation('relu')  # 激活层1
        self.c12 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        self.b12 = BatchNormalization()  # BN层1
        self.a12 = Activation('relu')  # 激活层1
        self.c13 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        self.b13 = BatchNormalization()
        self.a13 = Activation('relu')
        self.p5 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
        self.d5 = Dropout(0.2)

        self.flatten = Flatten()
        self.f1 = Dense(512, activation='relu')
        self.d6 = Dropout(0.2)
        self.f2 = Dense(512, activation='relu')
        self.d7 = Dropout(0.2)
        self.f3 = Dense(10, activation='softmax')

    def call(self, x):
        x = self.c1(x)
        x = self.b1(x)
        x = self.a1(x)
        x = self.c2(x)
        x = self.b2(x)
        x = self.a2(x)
        x = self.p1(x)
        x = self.d1(x)

        x = self.c3(x)
        x = self.b3(x)
        x = self.a3(x)
        x = self.c4(x)
        x = self.b4(x)
        x = self.a4(x)
        x = self.p2(x)
        x = self.d2(x)

        x = self.c5(x)
        x = self.b5(x)
        x = self.a5(x)
        x = self.c6(x)
        x = self.b6(x)
        x = self.a6(x)
        x = self.c7(x)
        x = self.b7(x)
        x = self.a7(x)
        x = self.p3(x)
        x = self.d3(x)

        x = self.c8(x)
        x = self.b8(x)
        x = self.a8(x)
        x = self.c9(x)
        x = self.b9(x)
        x = self.a9(x)
        x = self.c10(x)
        x = self.b10(x)
        x = self.a10(x)
        x = self.p4(x)
        x = self.d4(x)

        x = self.c11(x)
        x = self.b11(x)
        x = self.a11(x)
        x = self.c12(x)
        x = self.b12(x)
        x = self.a12(x)
        x = self.c13(x)
        x = self.b13(x)
        x = self.a13(x)
        x = self.p5(x)
        x = self.d5(x)

        x = self.flatten(x)
        x = self.f1(x)
        x = self.d6(x)
        x = self.f2(x)
        x = self.d7(x)
        y = self.f3(x)
        return y


model = VGG16()

整体代码：

以下以cifar10数据集为例进行演示
（cifar10数据集有5万张32*32像素点的彩色图片，用于训练
有1万张32*32像素点的彩色图片，用于测试）

cifar10 = tf.keras.datasets.cifar10
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0


class VGG16(Model):
    def __init__(self):
        super(VGG16, self).__init__()
        self.c1 = Conv2D(filters=64, kernel_size=(3, 3), padding='same')  # 卷积层1
        self.b1 = BatchNormalization()  # BN层1
        self.a1 = Activation('relu')  # 激活层1
        self.c2 = Conv2D(filters=64, kernel_size=(3, 3), padding='same', )
        self.b2 = BatchNormalization()  # BN层1
        self.a2 = Activation('relu')  # 激活层1
        self.p1 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
        self.d1 = Dropout(0.2)  # dropout层

        self.c3 = Conv2D(filters=128, kernel_size=(3, 3), padding='same')
        self.b3 = BatchNormalization()  # BN层1
        self.a3 = Activation('relu')  # 激活层1
        self.c4 = Conv2D(filters=128, kernel_size=(3, 3), padding='same')
        self.b4 = BatchNormalization()  # BN层1
        self.a4 = Activation('relu')  # 激活层1
        self.p2 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
        self.d2 = Dropout(0.2)  # dropout层

        self.c5 = Conv2D(filters=256, kernel_size=(3, 3), padding='same')
        self.b5 = BatchNormalization()  # BN层1
        self.a5 = Activation('relu')  # 激活层1
        self.c6 = Conv2D(filters=256, kernel_size=(3, 3), padding='same')
        self.b6 = BatchNormalization()  # BN层1
        self.a6 = Activation('relu')  # 激活层1
        self.c7 = Conv2D(filters=256, kernel_size=(3, 3), padding='same')
        self.b7 = BatchNormalization()
        self.a7 = Activation('relu')
        self.p3 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
        self.d3 = Dropout(0.2)

        self.c8 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        self.b8 = BatchNormalization()  # BN层1
        self.a8 = Activation('relu')  # 激活层1
        self.c9 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        self.b9 = BatchNormalization()  # BN层1
        self.a9 = Activation('relu')  # 激活层1
        self.c10 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        self.b10 = BatchNormalization()
        self.a10 = Activation('relu')
        self.p4 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
        self.d4 = Dropout(0.2)

        self.c11 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        self.b11 = BatchNormalization()  # BN层1
        self.a11 = Activation('relu')  # 激活层1
        self.c12 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        self.b12 = BatchNormalization()  # BN层1
        self.a12 = Activation('relu')  # 激活层1
        self.c13 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        self.b13 = BatchNormalization()
        self.a13 = Activation('relu')
        self.p5 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
        self.d5 = Dropout(0.2)

        self.flatten = Flatten()
        self.f1 = Dense(512, activation='relu')
        self.d6 = Dropout(0.2)
        self.f2 = Dense(512, activation='relu')
        self.d7 = Dropout(0.2)
        self.f3 = Dense(10, activation='softmax')

    def call(self, x):
        x = self.c1(x)
        x = self.b1(x)
        x = self.a1(x)
        x = self.c2(x)
        x = self.b2(x)
        x = self.a2(x)
        x = self.p1(x)
        x = self.d1(x)

        x = self.c3(x)
        x = self.b3(x)
        x = self.a3(x)
        x = self.c4(x)
        x = self.b4(x)
        x = self.a4(x)
        x = self.p2(x)
        x = self.d2(x)

        x = self.c5(x)
        x = self.b5(x)
        x = self.a5(x)
        x = self.c6(x)
        x = self.b6(x)
        x = self.a6(x)
        x = self.c7(x)
        x = self.b7(x)
        x = self.a7(x)
        x = self.p3(x)
        x = self.d3(x)

        x = self.c8(x)
        x = self.b8(x)
        x = self.a8(x)
        x = self.c9(x)
        x = self.b9(x)
        x = self.a9(x)
        x = self.c10(x)
        x = self.b10(x)
        x = self.a10(x)
        x = self.p4(x)
        x = self.d4(x)

        x = self.c11(x)
        x = self.b11(x)
        x = self.a11(x)
        x = self.c12(x)
        x = self.b12(x)
        x = self.a12(x)
        x = self.c13(x)
        x = self.b13(x)
        x = self.a13(x)
        x = self.p5(x)
        x = self.d5(x)

        x = self.flatten(x)
        x = self.f1(x)
        x = self.d6(x)
        x = self.f2(x)
        x = self.d7(x)
        y = self.f3(x)
        return y


model = VGG16()

model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

###############################################    show   ###############################################

# 显示训练集和验证集的acc和loss曲线
plt.subplot(1, 2, 1)
plt.plot(acc, label='Training Accuracy')
plt.plot(val_acc, label='Validation Accuracy')
plt.title('Training and Validation Accuracy')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(loss, label='Training Loss')
plt.plot(val_loss, label='Validation Loss')
plt.title('Training and Validation Loss')
plt.legend()
plt.show()

注：本文来自于中国大学mooc中北京大学的人工智能实践：Tensorflow笔记，在此感谢北大的曹健老师

牛+马=我
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
TensorFlow 实现 VGGNet
lemontree232的博客
09-29 188
TensorFlow 实现 VGGNet TensorFlow 实现 VGGNet VGGNet 是牛津大学计算机视觉组 （ Visual Geomety Group ） 和 Google DeepMind 公司的研究员一起研发的的深度卷积神经网络 。VGGNet 探索了卷积神经网络的深度与其 性能之间的关系，通过反复堆叠3×3 的小型卷积核和 2×2 的最大地化层 ，VGGNet 成功地 构筑了...
VGG-13 16 19网络的tensorflow.keras实现
认真努力，做一只会飞的毛毛虫。
11-29 3874
注意几个点： 1.所用的数据集是从ImageNet上下载的，但数据量比较小，VGG网络是非常庞大的，因此肯定是不够去训练的，当然想要训练网络可以通过迁移学习的方法。 2.所有的知识点和难点都会在注释中详细说明。 3.整个代码一共有三个模块，基本上除了模型定义，剩下的部分和之前的AlexNet网络代码大体类似。 模型脚本： from tensorflow.keras import layers, models, Model, Sequential #定义分类网络结构 即最后的全连接层 def VGG(f
tensorflow2.1 构建Vgg16、GoogLeNet-v1、resNet18
qq_39197555的博客
09-01 496
一、Vgg16 from tensorflow.keras.layers import Conv2D, Dense, BatchNormalization, ReLU, MaxPool2D, Flatten, Dropout, InputLayer from tensorflow.keras.models import Sequential def make_block(conv_num, filters): """ :param conv_num: 卷积层数量 :para
VGG16详细原理（含tensorflow版源码）
Code_and516的博客
03-28 4631
VGG16详细原理（含tensorflow版源码）
Keras实现vgg16网络和迁移学习
skycol的博客
10-03 1823
1.VGG-Net介绍，2.keras定义vgg16，3.keras实现vgg16迁移学习 ，4.预测新图-识别猫咪
Keras实现经典的卷积神经网络
09-11
本篇将详细讲解Keras如何实现四种经典的卷积神经网络模型：NIN（Network In Network）、VGG（Visual Geometry Group）、ResNet（Residual Network）以及DenseNet（Densely Connected Convolutional Networks）。...
基于tensorflow的深度学习论文复现(包括经典的AlexNet, VGGNet).zip
最新发布
02-19
在这个项目实践中，你将学习如何使用TensorFlow搭建这些模型，理解它们的网络结构，以及如何训练和优化模型。Python作为深度学习的主要编程语言，将在整个过程中发挥关键作用，包括数据预处理、模型构建、损失函数...
tensorflow笔记.zip
07-28
在TensorFlow中，可以通过tf.layers或tf.keras.layers模块实现VGG-Net的搭建。 **VGG16模型** VGG16是VGG-Net的一个具体实现，包含16个层，13个卷积层和3个全连接层。它引入了更深的网络结构，通过小的3x3卷积核堆...
基于keras的卷积神经网络的图像分类算法研究.pdf
09-25
VGGNet 模型对卷积神经网络的深度与其性能之间的关系进行了探索，网络的结构非常简洁，它的整个网络中全部使用了大小相同的卷积核（3×3）和最大池化核（2×2）。通过重复堆叠的方式，使用这些卷积层和最大池化层...
AlexNet_kerasalexnet_keras_深度学习_alexnet_CNN_
10-01
Keras是一个高级神经网络API，用于Python编程语言，可运行在TensorFlow、Theano和CNTK后端之上。Keras设计简洁，易于使用，适合快速原型设计、实验和部署深度学习模型。在本项目中，AlexNet的实现利用了Keras的强大...
【深度学习原理第6篇】深入解析VGGNet网络+keras实现
小样yx的博客
11-23 1110
目录前言一、VGG网络模型结构二、VGG16和VGG19网络结构分析2.1 VGG16解析2.2 VGG-19解析代码实现（VGG-16为例）三、VGG相较AlexNet改进详解3.1 小卷积核3.2 小池化核3.3 层数更深特征图更宽3.4 全连接转卷积 前言 这是入门必备经典网络学习的第二篇，VGGNet由牛津大学的视觉几何组（Visual Geometry Group）和Google DeepMind公司的研究员共同提出，是以解决ImageNet比赛中的1000类图像分类和定位问题而展开的，该网络斩获
keras实现简略版的VGGNet并加入可调整的学习率fine tuning
OliverkingLi的博客
07-25 2591
VGGNet的原理部分就不细说了，具体可以看原作者paper：Very Deep Learning Convolutional Neural Networks for Large-Scale Image Recognition。 这里使用小数据集去训练，因此就是用简略版的VGGNet去实现VGG思想，使用3x3的卷积核去迭代组合形成更深的网络结构。 这个实现：CONV => RELU =...
DL(3) - 卷积神经网络AlexNet/VGGNet/InceptionNet之keras实作 (上)
英俊强健的博客
02-06 525
卷积神经网络keras实作VGGNetResNetInceptionNetMobileNetDenseNetEffectionNet -数据 CIFAR10 ，使用keras实作VggNet，ResNet，InceptionNet，MobileNet，DenseNet，EffectionNet VGGNet ResNet InceptionNet MobileNet DenseNet Effec...
使用Keras来搭建VGG网络
Peter清风
12-13 8775
上述VGG网络结构图 VGG网络是在Very Deep Convolutional Network For Large-Scale Image Recognition这篇论文中提出,VGG是2014年被提出的，与之前的state-of-the-art的网络结构，错误率大幅下降，并取得了ILSVRC2014比赛分类项目的第二名和定位项目的第一名。同时，VGG的拓展性很强，迁移到其他图片数据上的泛化...
一篇图像识别的科普文
weixin_33910137的博客
02-02 394
引自：http://www.sohu.com/a/151663692_697750 图像识别是当今深度学习的主流应用，而Keras是入门最容易、使用最便捷的深度学习框架，所以搞图像识别，你也得强调速度，不能磨叽。本文让你在最短时间内突破五个流行网络结构，迅速达到图像识别技术前沿。 作者| Adrian Rosebrock 几个月前，我写了一篇关于如何使用已经训练好的卷积（预训练）神经网络模型...
Keras大法（8）——实现VGGNet19模型
Friedrich Yuan的博客
02-11 1万+
Keras大法（8）——实现VGGNet19模型（1）模型结构（2）模型代码（3）总 结 （1）模型结构 模型结构如下： （2）模型代码 import tensorflow as tf from tensorflow import keras # 使用tf.data进行数据馈送，此为参考示例 def parse_function(example_proto): features =...
tensorflow.keras实现VGGNet-16模型
qq_37499519的博客
11-27 337
网络结构： 代码实现 from tensorflow.keras import Sequential,layers model=Sequential() model.add(layers.Conv2D(input_shape=(224,224,3),filters=64,kernel_size=(3,3),activation='relu',padding='same')) model.add(layers.Conv2D(filters=64,kernel_size=(3,3),...
深度学习分类任务(3):TF2.0基于fashion数据集的VGG16神经网络搭建
青鸠的博客
08-11 930
TF2.0基于fashion数据集的VGG16神经网络搭建 1、VGG16简介 VGG是由Simonyan 和Zisserman在文献《Very Deep Convolutional Networks for Large Scale Image Recognition》中提出卷积神经网络模型，其名称来源于作者所在的牛津大学视觉几何组(Visual Geometry Group)的缩写。 该模型参加2014年的 ImageNet图像分类与定位挑战赛，取得了优异成绩：在分类任务上排名第二，在定位任务上排名第一。
pytorch一步一步在VGG16上训练自己的数据集
热门推荐
hnu_zzt的博客
12-19 3万+
准备数据集及加载，ImageFolder 在很多机器学习或者深度学习的任务中，往往我们要提供自己的图片。也就是说我们的数据集不是预先处理好的，像mnist，cifar10等它已经给你处理好了，更多的是原始的图片。比如我们以猫狗分类为例。在data文件下，有两个分别为train和val的文件夹。然后train下是cat和dog两个文件夹，里面存的是自己的图片数据，val文件夹同train。这样我们的...
基于tensorflow keras搭建模块化神经网络示例
06-12
好的，以下是一个基于TensorFlow Keras搭建模块化神经网络的示例代码： ```python from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Activation # 定义模型 def build...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值