TensorFlow中的VGG16 介绍以及 代码

最新推荐文章于 2024-06-14 21:57:21 发布
最新推荐文章于 2024-06-14 21:57:21 发布
阅读量3k 收藏 20
点赞数 4
分类专栏： VGG
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40979622/article/details/88784331
版权

VGG是由牛津大学的K. Simonyan和A. Zisserman在“用于大规模图像识别的超深度卷积网络”一文中提出的卷积神经网络模型。  。该模型在ImageNet中实现了92.7％的前5个测试精度  ，这是属于1000个类的超过1400万张图像的数据集。

 

VGG16 之前一直没找到代码，今天找到了。

关于原理，之前看过，这里就不写了。一以后有hi时间再写。

这段代码是测试代码，人家已经把模型训练好了。我们直接下载它的模型用就可以了。

关于训练，以及换数据集，我明天再试试。

我是在这里找到的。https://www.cs.toronto.edu/~frossard/post/vgg16/

代码：

import tensorflow as tf
import numpy as np
from scipy.misc import imread, imresize
from imagenet_classes import class_names


class vgg16:
    def __init__(self, imgs, weights=None, sess=None):
        self.imgs = imgs
        self.convlayers()
        self.fc_layers()
        self.probs = tf.nn.softmax(self.fc3l)
        if weights is not None and sess is not None:
            self.load_weights(weights, sess)


    def convlayers(self):
        self.parameters = []

        # zero-mean input
        with tf.name_scope('preprocess') as scope:
            mean = tf.constant([123.68, 116.779, 103.939], dtype=tf.float32, shape=[1, 1, 1, 3], name='img_mean')
            images = self.imgs-mean

        # conv1_1
        with tf.name_scope('conv1_1') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 3, 64], dtype=tf.float32,
                                                     stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(images, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[64], dtype=tf.float32),
                                 trainable=True, name='biases')
            out = tf.nn.bias_add(conv, biases)
            self.conv1_1 = tf.nn.relu(out, name=scope)
            self.parameters += [kernel, biases]

        # conv1_2
        with tf.name_scope('conv1_2') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 64, 64], dtype=tf.float32,
                                                     stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(self.conv1_1, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[64], dtype=tf.float32),
                                 trainable=True, name='biases')
            out = tf.nn.bias_add(conv, biases)
            self.conv1_2 = tf.nn.relu(out, name=scope)
            self.parameters += [kernel, biases]

        # pool1
        self.pool1 = tf.nn.max_pool(self.conv1_2,
                               ksize=[1, 2, 2, 1],
                               strides=[1, 2, 2, 1],
                               padding='SAME',
                               name='pool1')

        # conv2_1
        with tf.name_scope('conv2_1') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 64, 128], dtype=tf.float32,
                                                     stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(self.pool1, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[128], dtype=tf.float32),
                                 trainable=True, name='biases')
            out = tf.nn.bias_add(conv, biases)
            self.conv2_1 = tf.nn.relu(out, name=scope)
            self.parameters += [kernel, biases]

        # conv2_2
        with tf.name_scope('conv2_2') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 128, 128], dtype=tf.float32,
                                                     stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(self.conv2_1, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[128], dtype=tf.float32),
                                 trainable=True, name='biases')
            out = tf.nn.bias_add(conv, biases)
            self.conv2_2 = tf.nn.relu(out, name=scope)
            self.parameters += [kernel, biases]

        # pool2
        self.pool2 = tf.nn.max_pool(self.conv2_2,
                               ksize=[1, 2, 2, 1],
                               strides=[1, 2, 2, 1],
                               padding='SAME',
                               name='pool2')

        # conv3_1
        with tf.name_scope('conv3_1') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 128, 256], dtype=tf.float32,
                                                     stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(self.pool2, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[256], dtype=tf.float32),
                                 trainable=True, name='biases')
            out = tf.nn.bias_add(conv, biases)
            self.conv3_1 = tf.nn.relu(out, name=scope)
            self.parameters += [kernel, biases]

        # conv3_2
        with tf.name_scope('conv3_2') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 256, 256], dtype=tf.float32,
                                                     stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(self.conv3_1, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[256], dtype=tf.float32),
                                 trainable=True, name='biases')
            out = tf.nn.bias_add(conv, biases)
            self.conv3_2 = tf.nn.relu(out, name=scope)
            self.parameters += [kernel, biases]

        # conv3_3
        with tf.name_scope('conv3_3') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 256, 256], dtype=tf.float32,
                                                     stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(self.conv3_2, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[256], dtype=tf.float32),
                                 trainable=True, name='biases')
            out = tf.nn.bias_add(conv, biases)
            self.conv3_3 = tf.nn.relu(out, name=scope)
            self.parameters += [kernel, biases]

        # pool3
        self.pool3 = tf.nn.max_pool(self.conv3_3,
                               ksize=[1, 2, 2, 1],
                               strides=[1, 2, 2, 1],
                               padding='SAME',
                               name='pool3')

        # conv4_1
        with tf.name_scope('conv4_1') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 256, 512], dtype=tf.float32,
                                                     stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(self.pool3, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[512], dtype=tf.float32),
                                 trainable=True, name='biases')
            out = tf.nn.bias_add(conv, biases)
            self.conv4_1 = tf.nn.relu(out, name=scope)
            self.parameters += [kernel, biases]

        # conv4_2
        with tf.name_scope('conv4_2') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 512, 512], dtype=tf.float32,
                                                     stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(self.conv4_1, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[512], dtype=tf.float32),
                                 trainable=True, name='biases')
            out = tf.nn.bias_add(conv, biases)
            self.conv4_2 = tf.nn.relu(out, name=scope)
            self.parameters += [kernel, biases]

        # conv4_3
        with tf.name_scope('conv4_3') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 512, 512], dtype=tf.float32,
                                                     stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(self.conv4_2, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[512], dtype=tf.float32),
                                 trainable=True, name='biases')
            out = tf.nn.bias_add(conv, biases)
            self.conv4_3 = tf.nn.relu(out, name=scope)
            self.parameters += [kernel, biases]

        # pool4
        self.pool4 = tf.nn.max_pool(self.conv4_3,
                               ksize=[1, 2, 2, 1],
                               strides=[1, 2, 2, 1],
                               padding='SAME',
                               name='pool4')

        # conv5_1
        with tf.name_scope('conv5_1') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 512, 512], dtype=tf.float32,
                                                     stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(self.pool4, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[512], dtype=tf.float32),
                                 trainable=True, name='biases')
            out = tf.nn.bias_add(conv, biases)
            self.conv5_1 = tf.nn.relu(out, name=scope)
            self.parameters += [kernel, biases]

        # conv5_2
        with tf.name_scope('conv5_2') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 512, 512], dtype=tf.float32,
                                                     stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(self.conv5_1, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[512], dtype=tf.float32),
                                 trainable=True, name='biases')
            out = tf.nn.bias_add(conv, biases)
            self.conv5_2 = tf.nn.relu(out, name=scope)
            self.parameters += [kernel, biases]

        # conv5_3
        with tf.name_scope('conv5_3') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 512, 512], dtype=tf.float32,
                                                     stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(self.conv5_2, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[512], dtype=tf.float32),
                                 trainable=True, name='biases')
            out = tf.nn.bias_add(conv, biases)
            self.conv5_3 = tf.nn.relu(out, name=scope)
            self.parameters += [kernel, biases]

        # pool5
        self.pool5 = tf.nn.max_pool(self.conv5_3,
                               ksize=[1, 2, 2, 1],
                               strides=[1, 2, 2, 1],
                               padding='SAME',
                               name='pool4')

    def fc_layers(self):
        # fc1
        with tf.name_scope('fc1') as scope:
            shape = int(np.prod(self.pool5.get_shape()[1:]))
            fc1w = tf.Variable(tf.truncated_normal([shape, 4096],
                                                         dtype=tf.float32,
                                                         stddev=1e-1), name='weights')
            fc1b = tf.Variable(tf.constant(1.0, shape=[4096], dtype=tf.float32),
                                 trainable=True, name='biases')
            pool5_flat = tf.reshape(self.pool5, [-1, shape])
            fc1l = tf.nn.bias_add(tf.matmul(pool5_flat, fc1w), fc1b)
            self.fc1 = tf.nn.relu(fc1l)
            self.parameters += [fc1w, fc1b]

        # fc2
        with tf.name_scope('fc2') as scope:
            fc2w = tf.Variable(tf.truncated_normal([4096, 4096],
                                                         dtype=tf.float32,
                                                         stddev=1e-1), name='weights')
            fc2b = tf.Variable(tf.constant(1.0, shape=[4096], dtype=tf.float32),
                                 trainable=True, name='biases')
            fc2l = tf.nn.bias_add(tf.matmul(self.fc1, fc2w), fc2b)
            self.fc2 = tf.nn.relu(fc2l)
            self.parameters += [fc2w, fc2b]

        # fc3
        with tf.name_scope('fc3') as scope:
            fc3w = tf.Variable(tf.truncated_normal([4096, 1000],
                                                         dtype=tf.float32,
                                                         stddev=1e-1), name='weights')
            fc3b = tf.Variable(tf.constant(1.0, shape=[1000], dtype=tf.float32),
                                 trainable=True, name='biases')
            self.fc3l = tf.nn.bias_add(tf.matmul(self.fc2, fc3w), fc3b)
            self.parameters += [fc3w, fc3b]

    def load_weights(self, weight_file, sess):
        weights = np.load(weight_file)
        keys = sorted(weights.keys())
        for i, k in enumerate(keys):
            print (i, k, np.shape(weights[k]))
            sess.run(self.parameters[i].assign(weights[k]))

if __name__ == '__main__':
    sess = tf.Session()
    imgs = tf.placeholder(tf.float32, [None, 224, 224, 3])
    vgg = vgg16(imgs, 'vgg16_weights.npz', sess)

    img1 = imread('gou.jpg', mode='RGB')
    img1 = imresize(img1, (224, 224))

    prob = sess.run(vgg.probs, feed_dict={vgg.imgs: [img1]})[0]
    preds = (np.argsort(prob)[::-1])[0:5]
    for p in preds:
        print (class_names[p], prob[p])

以上代码在在VGG16.py文件中。这段代码还不够，需要两个文件 文件地址在上面写着。

imagenet_classes.py     https://www.cs.toronto.edu/~frossard/vgg16/imagenet_classes.py

vgg16_weights.npz        https://www.cs.toronto.edu/~frossard/vgg16/vgg16_weights.npz

把这两个和上面的代码放在一个文件中。

再找一个图片引入测试就可以看识别的情况了。

我的运行结果

个人感觉识别率不高。不过识别的范围还是挺广的。 

希望后期能够改进（改进是不可能的，这辈子都不可能）

 

爱吃西瓜的小松鼠
关注
  • 4
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
VGG16源代码详解
qq_38293067的博客
06-07 1万+
VGG16源代码详解 小白第一篇源码阅读笔记，若有错误请多多指教。 本文除了对源码的顺序和注释进行了一点删改外，其他与源码一致 首先看入口，也就是当我要去创建一个VGG模型时，我会调用的那个函数： def vgg11(pretrained=False, progress=True, **kwargs): return _vgg('vgg11', 'A', False, pretrained, progress, **kwargs) def vgg11_bn(pretrained=False, pro
深度学习与TensorFlow实战（十）卷积神经网络—VGG（16）神经网络
法兰西流浪者博客
08-27 9771
架构： 训练输入：固定尺寸224x224的RGB图像。 预处理：每个像素减去训练集上的RGB均值。 卷积核：一系列3X3卷积核堆叠，步长为1，采用padding保持卷积后图像空间分辨率不变。 空间池化：紧随卷积堆的最大池化，为2x2滑动窗口，步长2. 全连接层：特征提取后，接三个全连接层，前两个为4096，第三个为1000通道，最后是一个softmax层，输出概率。 所有隐藏层都用非线...
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）网络结构简洁：
week6：VGG-16算法-Pytorch实现人脸识别实验
最新发布
weixin_43690449的博客
06-14 322
使用多个3x3的小卷积核而不是大卷积核，这样可以增加网络的深度，提高模型的表达能力，同时减少参数量。第2段：两个3x3卷积层（128个过滤器），后接一个2x2最大池化层（stride为2）。第3段：三个3x3卷积层（256个过滤器），后接一个2x2最大池化层（stride为2）。第4段：三个3x3卷积层（512个过滤器），后接一个2x2最大池化层（stride为2）。第5段：三个3x3卷积层（512个过滤器），后接一个2x2最大池化层（stride为2）。
利用Tensorflow实现VGG16及训练自己的数据
热门推荐
weixin_31200719的博客
07-26 3万+
 参考：《Tensorflow实战》《Tensorflow 实战Google深度学习框架》 https://blog.csdn.net/sinat_16823063/article/details/53946549 https://blog.csdn.net/yaoqi_isee/article/details/77526497 https://blog.csdn.net/u0127591...
VGG16详细原理（含tensorflow版源码）
Code_and516的博客
03-28 4631
VGG16详细原理（含tensorflow版源码）
VGG16-Tensorflow:VGG16的Tensorflow实现
05-02
VGG16的实施除了代码本身的注释外，我还写了一篇文章，您可以在找到有关VGGNet的进一步说明。内容vgg16.py ：带有vgg16.py的图形定义的类。 VGG16 Train.ipynb ：笔记本，用于培训和测试VGG16的实现。 如果您在查看...
tensorflow-vgg16
10-09
TensorFlow VGG16是一个深度学习框架TensorFlow中的预训练模型，它基于VGG16网络架构。VGG16是由牛津大学视觉几何组（Visual Geometry Group）在2014年的ImageNet Large Scale Visual Recognition Challenge (ILSVRC...
tensorflow-vgg16代码
11-24
通过阅读和理解这段代码，你可以深入了解如何在TensorFlow中利用VGG16进行人脸识别，并掌握迁移学习的基本应用。 总之，TensorFlow VGG16代码示例展示了如何结合预训练的深度学习模型解决人脸识别问题。通过这个...
VGG16_vgg16代码_VGG16_vgg16代码详解_
09-29
在VGG16_vgg16代码详解中，作者提供了简单易懂的实现方式，使得初学者能够快速理解和上手。通过阅读和理解代码，你可以了解到深度学习模型如何从原始图像中提取特征，以及深度学习模型训练的基本流程。此外，了解VGG...
VGG16_TF:简单实现VGG16
04-28
学习Tensorflow，拿VGG16练练手，没有其他骚操作，只有数据集制作，训练及测试。 训练数据-17flowers，百度网盘链接: : 3nc4 VGG16.npy，百度网盘链接: : 4wvq create_tfrecords.py为生成tfrecords数据脚本 VGG16....
TF中建立vgg16并实现七分类
weixin_41707744的博客
03-21 906
实验综述 1.基于vgg16模型进行迁移学习；因为总体数据集偏小，所以只训练了最后一层的参数，而冻结所有其他层；当然当数据集增大时，可以向前多结冻几层网络进行训练。 2.总体的实施步骤为： （1）处理数据 （2）建立vgg16网络模型类 （3）利用网络模型类实现模型复用、载入数据、训练模型与权重保存 ...
经典卷积神经网络——VGG16
Lightismore的博客
04-30 2万+
VGG16前言一、VGG发展历程二、VGG网络模型三、VGG16代码详解1.VGG网络架构2.VGG16网络验证2.读取数据，进行数据增强3.训练模型，测试准确率四、VGG缺点 前言 我们都知道Alexnet是卷积神经网络的开山之作，但是由于卷积核太大，移动步长大，无填充，所以14年提出的VGG网络解决了这一问题 一、VGG发展历程 VGG网络由牛津大学在2014年ImageNet挑战赛本地和分类追踪分别获得了第一名和第二名。研究卷积网络深度对其影响在大规模图像识别设置中的准确性，主要贡献是全面评估网络
掌握Tensorflow之VGG-16网络搭建与讲解
litt1e的博客
03-05 2376
VGGNet探索了卷积神经网络的深度与性嫩之间的关系，通过反复堆叠3×3的卷积核和2×2的池化层构建了16层的卷积神经网络。 由上图所知，VGG一共有五段卷积，每段卷积之后紧接着最大池化层，作者一共实验了6种网络结构。分别是VGG-11，VGG-13,VGG-16,VGG-19，网络的输入是224*224大小的图像，输出是图像分类结果。 下面我们主要针对tensorflow如何实现vgg做出讲解...
用tensorflow手动实现VGG16
weixin_43193071的博客
06-25 1951
用tensorflow手动实现VGG16 1简介 VGG卷积神经网络是牛津大学在2014年提出来的模型。当这个模型被提出时，由于它的简洁性和实用性，马上成为了当时最流行的卷积神经网络模型。它在图像分类和目标检测任务中都表现出非常好的结果。在2014年的ILSVRC比赛中，VGG 在Top-5中取得了92.3%的正确率。 2结构图 我们将其结构拆解开：具体每步过程如下 ​ 表4.5...
利用TensorFlow实现VGG16
Cheese的博客
09-08 2万+
本篇文章实现了一个 TensorFlow版本的Vgg16,完成了数据从制作，到输入，训练的整个过程。
基于TensorFlow的VGG16模型源码
qq_37116150的博客
03-07 2236
我看了网上的一些源码程序，自己下载跑一哈，发现有很多的错误，不知道是我电脑原因，还是tensorflow版本问题，我自己基于别人的源码修改了一些细节，使程序可以顺利运行 imagenet_classes.py # -*- coding: utf-8 -*- class_names = '''tench, Tinca tinca goldfish, Carassius auratus grea...
如何使用Tensorflow的VGG16预置模型
qq_42635142的博客
06-29 1865
使用的是矩池云+Pycharm进行Tensorflow 预置的VGG16进行测试
1、FCN_TensorFlow——VGG16_FCN8s构造代码分析
u013303599的博客
02-01 1万+
首先，感谢Marvin Teichmann分享的KittiSeg代码，源码见其GitHub主页 先贴一张全连接的VGG16模型，如图1：                                 图 1 1、全卷积神经网络(FCN)是在图1的基础上，将全连接层改为卷积替代并将其用于语义分割上，详情见论文《Fully Convolutional Networks for Semanti
tensorflow中vgg16在哪一部分
05-22
在Tensorflow中，VGG16被定义在tensorflow.keras.applications.vgg16模块中。可以使用以下代码导入VGG16模型： ```python from tensorflow.keras.applications.vgg16 import VGG16 # 加载预训练的VGG16模型 model ...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值