tensorflow KEras 之Lenet/Alexnet/VGG16 网络结构

最新推荐文章于 2022-05-30 14:48:54 发布
最新推荐文章于 2022-05-30 14:48:54 发布
阅读量424 收藏 4
点赞数 1
分类专栏： python 神经网络 tensorflow
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41485242/article/details/105657692
版权
python 同时被 3 个专栏收录
34 篇文章 1 订阅
订阅专栏
tensorflow
23 篇文章 0 订阅
订阅专栏
神经网络
20 篇文章 0 订阅
订阅专栏

目录

1. Lenet 

2. Alexnet

3.VGG16

1. Lenet 

from tensorflow.keras.layers import Dense, Flatten, Conv2D, MaxPool2D
from tensorflow.keras import Model

class LeNet5(Model):
    def __init__(self):
        super(LeNet5, self).__init__()
        self.c1 = Conv2D (filters =6, kernel_size = (5,5),
            activation = 'sigmoid')
        self.p1 = MaxPool2D (pool_size = (2,2), strides = 2)
        self.c2 = Conv2D (filters =16, kernel_size = (5,5),
            activation = 'sigmoid')
        self.p2 = MaxPool2D (pool_size = (2,2), strides = 2)
        self.flatten = Flatten()
        self.f1 = Dense(120, activation ='sigmoid')
        self.f2 = Dense(84, activation ='sigmoid')
        self.f3 = Dense(10, activation ='softmax')
    def call(self, x):
        x = self.c1(x)
        x = self.p1(x)
        x = self.c2(x)
        x = self.p2(x)
        x = self.flatten(x)
        x = self.f1(x)
        x = self.f2(x)
        y = self.f3(x)
        return y

2. Alexnet

from tensorflow.keras.layers import Dense, Flatten, Conv2D, MaxPool2D, BatchNormalization, Activation, Dropout
from tensorflow.keras import Model

class AlexNet8(Model):
    def __init__(self):
        super(AlexNet8, self).__init__()
        self.c1 = Conv2D(filters =96, kernel_size = (3,3) )
        self.b1 = BatchNormalization()
        self.a1 = Activation('relu')
        self.p1 = MaxPool2D(pool_size = (3,3), stride = 2)

        self.c2 = Conv2D(filters =256, kernel_size = (3,3) )
        self.b2 = BatchNormalization()
        self.a2 = Activation('relu')
        self.p2 = MaxPool2D(pool_size = (3,3), stride = 2)

        self.c3 = Conv2D(filters =384, kernel_size = (3,3), padding ='same',
            activation = 'relu' )

        self.c4 = Conv2D(filters =384, kernel_size = (3,3), padding ='same',
            activation = 'relu' )

        self.c5 = Conv2D(filters =256, kernel_size = (3,3), padding ='same',
            activation = 'relu' )
        self.p3 = MaxPool2D(pool_size = (3,3), stride = 2)

        self.flatten = Flatten()
        self.f1 = Dense(2048, activation = 'relu')
        self.d1 = Dropout(0.5)

        self.f2 = Dense(2048, activation = 'relu')
        self.d2 = Dropout(0.5)

        self.f3 = Dense(10, activation = 'softmax')

    def call(self, x):
        x = self.c1(x)
        x = self.b1(x)
        x = self.a1(x)
        x = self.p1(x)

        x = self.c2(x)
        x = self.b2(x)
        x = self.a2(x)
        x = self.p2(x)
       
        x = self.c3(x)
        x = self.c4(x)
        x = self.c5(x)
        x = self.p3(x)

        x = self.flatten(x)
        x = self.f1(x)
        x = self.d1(x)
        x = self.f2(x)
        x = self.d2(x)
        y = self.f3(x)

        return  y

3.VGG16

from tensorflow.keras.layers import Dense, Flatten, Conv2D, MaxPool2D, BatchNormalization, Activation, Dropout
from tensorflow.keras import Model

class VGG(Model):
    def __init__(self):
        self.c1 = Conv2D(filters =64, kernel_size = (3,3),padding = 'same' )
        self.b1 = BatchNormalization()
        self.a1 = Activation('relu')

        self.c2 = Conv2D(filters = 64, kernel_size =(3,3), padding = 'same')
        self.b2 = BatchNormalization()
        self.a2 = Activation('relu')
        self.p2 = MaxPool2D(kernel_size = (2,2),strides = 2)
        self.d2 = Dropout(0.2)

        self.c3 = Conv2D(filters =128, kernel_size = (3,3),padding = 'same' )
        self.b3 = BatchNormalization()
        self.a3 = Activation('relu')

        self.c4 = Conv2D(filters = 128, kernel_size =(3,3), padding = 'same')
        self.b4 = BatchNormalization()
        self.a4 = Activation('relu')
        self.p4 = MaxPool2D(kernel_size = (2,2),strides = 2)
        self.d4 = Dropout(0.2)

        self.c5 = Conv2D(filters =256, kernel_size = (3,3),padding = 'same' )
        self.b5 = BatchNormalization()
        self.a5 = Activation('relu')

        self.c6 = Conv2D(filters = 256, kernel_size = (3,3),padding = 'same' )
        self.b6 = BatchNormalization()
        self.a6 = Activation('relu')

        self.c7 = Conv2D(filters = 256, kernel_size =(3,3), padding = 'same')
        self.b7 = BatchNormalization()
        self.a7 = Activation('relu')
        self.p7 = MaxPool2D(kernel_size = (2,2),strides = 2)
        self.d7 = Dropout(0.2)

        self.c8 = Conv2D(filters =512, kernel_size = (3,3),padding = 'same' )
        self.b8 = BatchNormalization()
        self.a8 = Activation('relu')

        self.c9 = Conv2D(filters = 512, kernel_size = (3,3),padding = 'same' )
        self.b9 = BatchNormalization()
        self.a9 = Activation('relu')

        self.c10 = Conv2D(filters = 256, kernel_size =(3,3), padding = 'same')
        self.b10 = BatchNormalization()
        self.a10 = Activation('relu')
        self.p10 = MaxPool2D(kernel_size = (2,2),strides = 2)
        self.d10 = Dropout(0.2)

        self.c11 = Conv2D(filters = 512, kernel_size = (3,3),padding = 'same' )
        self.b11 = BatchNormalization()
        self.a11 = Activation('relu')

        self.c12 = Conv2D(filters = 512, kernel_size = (3,3),padding = 'same' )
        self.b12 = BatchNormalization()
        self.a12 = Activation('relu')

        self.c13 = Conv2D(filters = 512, kernel_size =(3,3), padding = 'same')
        self.b13 = BatchNormalization()
        self.a13 = Activation('relu')
        self.p13 = MaxPool2D(kernel_size = (2,2),strides = 2)
        self.d13 = Dropout(0.2)

        self.f14 = Dense(512, activation = 'relu')
        self.d14 = Dropout(0.2)

        self.f15 = Dense(512, activation = 'relu')
        self.d15 = Dropout(0.2)

        self.f16 = 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.p2(x)
        x = self.d2(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.p4(x)
        x = self.d4(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.p7(x)
        x = self.d7(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.p10(x)
        x = self.d10(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.p13(x)
        x = self.d13(x)

        x = self.f14(x)
        x = self.d14(x)

        x = self.f15(x)
        x = self.d15(x)

        y = self.f16(x)

 

吃不胖的粥
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
VGG-16网络结构详解
qq_45998041的博客
03-10 3万+
VGG，又叫VGG-16，顾名思义就是有16层，包括13个卷积层和3个全连接层，是由Simonyan 和Zisserman在文献**《Very Deep Convolutional Networks for Large Scale Image Recognition》**中提出卷积神经网络模型，其名称来源于作者所在的牛津大学视觉几何组(Visual Geometry Group)的缩写。 该模型参加2014年的 ImageNet图像分类与定位挑战赛，取得了优异成绩：在分类任务上排名第二，在定位任务上排名第一
【深度学习】全面理解VGG16模型
florrie
06-18 3万+
全面理解VGG16模型VGG16的结构层次介绍结构图VGG16模型所需要的内存容量介绍卷积中的基本概念1.从input到conv1：2.从conv1到conv2之间的过渡：3.conv2到conv3：4.进入conv3：5.从conv3到conv4之间的过渡：6.最后到三层全连接FC层结论 VGG16的结构层次 vgg16总共有16层，13个卷积层和3个全连接层，第一次经过64个卷积核的两次卷积后...
PyTorch之VGG16网络结构详解以及源码解读
qq_34600424的博客
01-15 1万+
论文：Very Deep Convolutional Networks for Large-Scale Image Recognition 简单介绍 **意义：**证明了增加小卷积核的个数以及网络深度可以提高分类结果的正确率。 **预处理：**各通道减去RGB在训练集上的均值。 特点： 1）使用小的卷积核（3 × 3）叠加的形式代替大的卷积核（5 × 5 or 7 × 7） 2）卷积层不会改变layer大小，而是通过max pooling减小layer大小 3）网络层数比较深 优点： 1）网络结构简洁：
深度学习卷积神经网络——经典网络VGG-16网络的搭建与实现
loveliuzz的博客
01-23 4万+
一、VGG-16网络框架介绍 VGGNet是牛津大学计算机视觉组（Visual Geometry Group）和Google DeepMind公司的研究员一起研发的深度卷积神经网络。 VGGNet探索了卷积神经网络的深度与其性能之间的关系，通过反复堆叠3*3的小型卷积核和2*2的最大池化层， VGGNet成功地构筑了16~19层深的卷积神经网络。VGGNet相比之前state-of-
VGG-16网络结构
qq_38162944的博客
03-03 1192
在这里插入代码片 模型 import torch.nn as nn import torch class VGG(nn.Module):#继承自nn.Module的父类 def __init__(self, features, num_classes=1000, init_weights=False): #features--通过make_features（）得到的提取特征网络结构，num_classes--想要得到的分类种类，init_weights--初始化权重
TensorFlow总结
最新发布
01-08
TensorFlow提供了多种卷积神经网络模型，例如LeNet、AlexNet、VGGNet等。这些模型都可以使用TensorFlow中的API来实现。在TensorFlow中，可以使用tf.keras.layers.Conv2D来实现卷积层，tf.keras.layers.MaxPooling2D...
LeNet-5_keras_深度学习_LeNet5_pand88_CNN_
10-02
Keras是一个高级神经网络API，它构建在TensorFlow、Theano和CNTK等后端之上，以Python语言编写，提供了简洁、高效的接口，使得模型构建、训练和评估过程变得简单易懂。对于初学者，Keras是理解深度学习概念和实践的...
Keras对CIFAR10的图像分类全套代码（包含多个模型）
05-17
模型有LeNet，AlexNet，VGG，GoogLeNet，ResNet，DenseNet等等 也可以通过进行可视化输出结果，也含有数据增强等方法提高准确率 在资源中有全部代码的学习资料，并且包括所有的权重，代码所有都可运行，可执行，可...
卷积神经网络二1
08-04
随后，卷积神经网络的研究逐渐深入，出现了更多的模型，如AlexNet、VGGNet、GoogLeNet等。 深度学习的历史也与卷积神经网络息息相关。深度学习的提出可以追溯到20世纪50年代，来自于人工智能的研究。随后，深度学习...
卷积神经网络的发展及其应用.docx
03-17
随着Tensorflow和Keras等深度学习框架的发展，LeNet的应用变得更加简便，不仅限于MINIST，还能应用于更复杂的图像识别任务。 3.2 AlexNet 2012年，Alex Krizhevsky等人提出了AlexNet，它具有更深的网络结构，包括8...
tensorflow.keras实现AlexNet模型
qq_37499519的博客
11-27 2788
AlexNet网络结构： 创新点： 1.使用GPU加速 2.使用了ReLU激活函数 代码如下 from tensorflow.keras import Sequential,layers model=Sequential() model.add(layers.Conv2D(filters=96,input_shape=(224,224,3),kernel_size=(11,11),activation='relu',strides=(4,4),paddin...
深度学习-VGG16原理详解
weixin_43496706的博客
09-23 5万+
1.网络结构 根据卷积核大小和卷积层数，VGG共有6中配置，分别为A,A-LRN,B,C,D,E，其中D和E两种最为常用，即i我们所说的VGG16和VGG19。看下图红色框所示。具体为： 1. 卷积-卷积-池化-卷积-卷积-池化-卷积-卷积-卷积-池化-卷积-卷积-卷积-池化-卷积-卷积-卷积-池化-全连接-全连接-全连接 。 2. 通道数分别为64，1258，512，512，512，4096，4...
pytorch实现VGG16 (2)
m0_50127633的博客
05-19 1384
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
windows+TensorFlow/keras+vgg16训练自己的数据集
花生米
06-07 6105
前提 要想在TensorFlow训练vgg16，首先要配置TensorFlow环境，这篇博客介绍如何配置python2.7版本的TensorFlow，在这里就不在叙述了。 TensorFlow版本 下载代码：VGG16 下载数据集17flowers，密码：3nc4 如果是训练自己的数据集，可以模仿17flowers数据集格式，将同一类的图片放在同一个文件夹中，如下图所示。 下载vgg16.npy...
【题目】VGG-16网络详细分析（Keras代码）
小C的博客
09-23 1万+
【时间】2018.09.23 【题目】VGG-16网络分析（Keras代码） 目录   一、VGG-16的基本架构 二、Keras代码 三、代码详解 1、ZeroPadding2D层 2、Conv2D层 3、MaxPooling2D层 4、Flatten层 5、Dense层 6.Dropout层 一、VGG-16的基本架构 【VGG-16的架构】： 【架构说明】：...
经典卷积神经网络---VGG16详解
热门推荐
笼中鸟
04-21 5万+
一.VGG概述 VGGNet是牛津大学视觉几何组(Visual Geometry Group)提出的模型，该模型在2014ImageNet图像分类与定位挑战赛 ILSVRC-2014中取得在分类任务第二，定位任务第一的优异成绩。VGGNet突出的贡献是证明了很小的卷积，通过增加网络深度可以有效提高性能。VGG很好的继承了Alexnet的衣钵同时拥有着鲜明的特点。即网络层次较深。 VGGNet结构 VGGNet模型有A-E五种结构网络，深度分别为11,11,13,16,19。其中较为典型的网络结构主要有
VGG16网络结构与代码
m0_56247038的博客
05-30 9328
VGG16总共有16层（不包括池化层），13个卷积层和3个全连接层，第一次经过64个卷积核的两次卷积后，采用一次pooling，第二次经过两次128个卷积核卷积后，采用pooling；再经过3次256个卷积核卷积后，采用pooling；再经过3次512个卷积核卷积，采用pooling；再经过3次512个卷积核卷积，采用pooling，最后经过三次全连接。 模块 各模块的涉及的层次 ..................
关于VGGNet网络结构浅谈（主要是VGG16结构）
Keep_Trying_Go的博客
04-03 5889
文章目录1.首先看一下论文中一张表：2.VGG16网络结构解释：3.网络构成详解： 1.首先看一下论文中一张表： 注解： （1）可以看到表中从左->右网络结构逐渐变得更深和复杂；层数从11->11->13->16->16->19； （2）所有的激活函数使用的都是ReLU函数； （3）层与层之间的间隔使用Max Pool（最大池化）； （4）使用的卷积核大小都是3*3的卷积，通道数逐渐增加（因为宽和高在变小，所以通道数增加对特征的保留更好）； （5）根据卷积层来设计其中子
VGG16 (Tensorflow/keras)网络
qq_34619572的博客
07-09 376
****感谢万门 vgg网络要求输入不低于224像素。大小不一需要resize（） from keras.layers import Input,Conv2D, MaxPool2D, Flatten, Dropout, Dense from keras.utils import to_categorical from keras.optimizers import Adam from keras.losses import categorical_crossentropy import matpl..
对飞行员脑电数据进行CNN-LSTM模型进行如LeNet、AlexNet、VGG、ResNet等模型结构选择有什么原因，附上相关代码和视频
06-11
针对飞行员脑电数据进行CNN-LSTM模型进行分类时，选择模型结构的原因是为了提高分类的准确率和泛化能力。这些经典的模型结构都是在不同的数据集上进行了大量的实验和优化，具有较高的分类性能和较强的泛化能力，可以作为参考模型用于该任务。 LeNet、AlexNet、VGG、ResNet等模型结构选择的具体原因如下： - LeNet：LeNet是一个较早的卷积神经网络模型，适用于对小图像进行分类。在飞行员脑电数据分类任务中，LeNet可以用于提取输入数据的局部特征，从而提高分类准确率。 - AlexNet：AlexNet是一个较早的深度卷积神经网络模型，具有较好的分类性能。在飞行员脑电数据分类任务中，AlexNet可以通过多层卷积和池化层提取输入数据的特征，从而提高分类准确率。 - VGG：VGG是一个非常深的卷积神经网络模型，具有较强的泛化能力。在飞行员脑电数据分类任务中，VGG可以通过多层卷积和池化层提取输入数据的特征，从而提高分类准确率。 - ResNet：ResNet是一个残差神经网络模型，具有较强的泛化能力和防止梯度消失的能力。在飞行员脑电数据分类任务中，ResNet可以通过残差模块提取输入数据的特征，从而提高分类准确率。 以下是一个使用TensorFlow实现VGG模型的代码示例： ```python # 导入相关库 import tensorflow as tf # 定义VGG模型 model = tf.keras.Sequential([ # 第一段卷积层 tf.keras.layers.Conv2D(filters=64, kernel_size=(3,3), padding='same', activation='relu', input_shape=input_shape), tf.keras.layers.Conv2D(filters=64, kernel_size=(3,3), padding='same', activation='relu'), tf.keras.layers.MaxPooling2D(pool_size=(2,2), strides=(2,2)), # 第二段卷积层 tf.keras.layers.Conv2D(filters=128, kernel_size=(3,3), padding='same', activation='relu'), tf.keras.layers.Conv2D(filters=128, kernel_size=(3,3), padding='same', activation='relu'), tf.keras.layers.MaxPooling2D(pool_size=(2,2), strides=(2,2)), # 第三段卷积层 tf.keras.layers.Conv2D(filters=256, kernel_size=(3,3), padding='same', activation='relu'), tf.keras.layers.Conv2D(filters=256, kernel_size=(3,3), padding='same', activation='relu'), tf.keras.layers.Conv2D(filters=256, kernel_size=(3,3), padding='same', activation='relu'), tf.keras.layers.MaxPooling2D(pool_size=(2,2), strides=(2,2)), # 第四段卷积层 tf.keras.layers.Conv2D(filters=512, kernel_size=(3,3), padding='same', activation='relu'), tf.keras.layers.Conv2D(filters=512, kernel_size=(3,3), padding='same', activation='relu'), tf.keras.layers.Conv2D(filters=512, kernel_size=(3,3), padding='same', activation='relu'), tf.keras.layers.MaxPooling2D(pool_size=(2,2), strides=(2,2)), # 第五段卷积层 tf.keras.layers.Conv2D(filters=512, kernel_size=(3,3), padding='same', activation='relu'), tf.keras.layers.Conv2D(filters=512, kernel_size=(3,3), padding='same', activation='relu'), tf.keras.layers.Conv2D(filters=512, kernel_size=(3,3), padding='same', activation='relu'), tf.keras.layers.MaxPooling2D(pool_size=(2,2), strides=(2,2)), # 全连接层 tf.keras.layers.Flatten(), tf.keras.layers.Dense(units=4096, activation='relu'), tf.keras.layers.Dense(units=4096, activation='relu'), tf.keras.layers.Dense(units=num_classes, activation='softmax') ]) # 编译模型 model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) # 训练模型 model.fit(x_train, y_train, epochs=10, validation_data=(x_test, y_test)) # 评估模型 score = model.evaluate(x_test, y_test, verbose=0) print('Test loss:', score[0]) print('Test accuracy:', score[1]) ``` 此外，我还找到一个相应的视频，其中讲解了如何使用TensorFlow和Keras构建LeNet、AlexNet、VGG、ResNet等模型进行图像分类。您可以在以下链接中查看该视频：https://www.youtube.com/watch?v=mQGwjrStQgg。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值