【翻译】VGG16

最新推荐文章于 2024-05-14 11:07:26 发布
最新推荐文章于 2024-05-14 11:07:26 发布
阅读量3.9k 收藏 11
点赞数 4
分类专栏： tensorflow

原文地址：

http://www.cs.toronto.edu/~frossard/post/vgg16/


对应文件的下载链接：

  • Model weights - vgg16_weights.npz https://www.cs.toronto.edu/~frossard/vgg16/vgg16_weights.npz
  • TensorFlow model - vgg16.py https://www.cs.toronto.edu/~frossard/vgg16/vgg16.py
  • Class names - imagenet_classes.py https://www.cs.toronto.edu/~frossard/vgg16/imagenet_classes.py
  • Example input - laska.png https://www.cs.toronto.edu/~frossard/vgg16/laska.png


运行方式:

python vgg16.py

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

在这篇短文中，我们提供了VGG16的实现以及原始Caffe模型转换为TensorFlow的权重
结构

VGG16的宏观结构可以在图中看到。我们在文件vgg16.py中的TensorFlow中进行编码。 请注意，我们包含一个预处理图层，该图层将RGB图像的像素值范围为0-255，并减去平均图像值（在整个ImageNet训练集上计算）。

权重

我们使用专门的工具转换作者的GitHub配置文件中公开提供的Caffe权重。 一些后期处理是为了确保模型符合TensorFlow标准。 最后，我们得到vgg16_weights.npz中的权重。
类名称
为了将模型的输出与类名相关联，我们在imagenet_classes.py中提供了映射。
未来的内容

我们鼓励您熟悉这种模式，因为它被广泛使用，并且将成为未来关于卷积神经网络知识转移，反向传播和其他有趣话题的内容的基准。


代码实现：

########################################################################################
# Davi Frossard, 2016                                                                  #
# VGG16 implementation in TensorFlow                                                   #
# Details:                                                                             #
# http://www.cs.toronto.edu/~frossard/post/vgg16/                                      #
#                                                                                      #
# Model from https://gist.github.com/ksimonyan/211839e770f7b538e2d8#file-readme-md     #
# Weights from Caffe converted using https://github.com/ethereon/caffe-tensorflow      #
########################################################################################

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('laska.png', 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]


Qin_xian_shen
关注
  • 4
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
vgg16_weights.npz
05-17
vgg16_weights.npz是vgg16权重，网上资源下载的话速度会很慢，内附网盘地址，下载很快，如果链接失效给我留言哦
VGG16
m0_49423899的博客
01-28 715
入门-VGG16模型的学习以及源码分析
深度学习之基于Vgg16卷积神经网络的皮肤疾病识别系统
Q1744828575的博客
05-14 321
一、项目背景与意义皮肤疾病是一类常见的健康问题，其种类繁多，症状各异。传统的皮肤疾病诊断主要依赖于医生的专业知识和经验，但这种方法存在主观性强、诊断效率不高等问题。随着深度学习技术的快速发展，特别是卷积神经网络（CNN）在图像识别领域的成功应用，为皮肤疾病的自动识别和诊断提供了新的解决方案。本项目旨在利用VGG16卷积神经网络开发一个高效、准确的皮肤疾病识别系统，以提高皮肤疾病的诊断效率和准确性。二、项目目标本项目的核心目标是构建一个基于VGG16卷积神经网络的皮肤疾病识别系统。
2014-VGG-《Very deep convolutional networks for large-scale image recognition》翻译
爱吃土豆
01-10 1万+
原文：http://xueshu.baidu.com/s?wd=paperuri%3A%282801f41808e377a1897a3887b6758c59%29&filter=sc_long_sign&tn=SE_xueshusource_2kduw22v&sc_vurl=http%3A%2F%2Farxiv.org%2Fabs%2F1409.1556&ie=utf-8&sc_us=4549459
论文翻译—VGGNet
FlyDremever
03-13 410
vgg 论文翻译
VGG16论文解读
MinevaG的博客
04-11 711
对于给定的感受野（与输出有关的输入图片的局部大小），采用堆积的小卷积核是优于采用大的卷积核，因为多层非线性层可以增加网络深度来保证学习更复杂的模式，而且代价还比较小（参数更少）。注：很多pretrained的方法就是使用VGG的model（主要是16和19），VGG相对其他的方法，参数空间很大，最终的model有500多m，AlexNet只有200m，GoogLeNet更少，所以train一个vgg模型通常要花费更长的时间，所幸有公开的pretrained model让我们很方便的使用。
VGGNet中文翻译1
08-03
【VGGNet中文翻译1】这篇论文探讨了卷积神经网络（Convolutional Neural Networks，简称ConvNets或CNNs）在大规模图像识别任务中的深度对其准确性的关键影响。作者Karen Simonyan和Andrew Zisserman来自牛津大学的...
基于VGG16+LSTM的二分类暴力行为检测.zip
05-22
LSTM (Long Short-Term Memory) 是一种特殊的循环神经网络（RNN）架构，用于处理...由于LSTM能够有效地处理长期依赖关系，它在许多序列建模任务中都取得了很好的效果，如语音识别、文本生成、机器翻译、时序预测等。
图像字幕生成器：LSTM模型从预先训练的VGG-16模型中提取特征后，会为输入图像生成字幕。 （计算机视觉，自然语言处理，深度学习，Python）
02-04
这个项目是基于Python实现的，利用了预训练的VGG-16模型来提取图像特征，并通过LSTM（长短期记忆网络）模型生成相应的图像字幕。下面我们将详细探讨这些关键知识点。 1. **计算机视觉（Computer Vision）**： ...
东南大学本科毕业设计，采用VGG16-LSTM进行基于关键帧的视频场景识别.zip
最新发布
05-22
LSTM (Long Short-Term Memory) 是一种特殊的循环神经网络（RNN）架构，用于处理...由于LSTM能够有效地处理长期依赖关系，它在许多序列建模任务中都取得了很好的效果，如语音识别、文本生成、机器翻译、时序预测等。
基于Tensorflow+VGG+DBN本地化批量图像识别系统（深度学习+Python）含全部工程源码+视频演示+图片数据集
06-05
模型选择简化VGG16模型，简化之后的模型具有 13 个卷积池化层以及后续的全连接层，参数总量约为 500Mb。 5. 准确率：随机选择了属于不同类型、不同大小的图片进行测试，通过模型的激活、调用和识别的其他过程之后...
vggnet 代码（带注释）以及vgg16 npy资源
05-03
自己学习vgg的部分代码以及vgg16 npy文件
vgg16_weights_th_dim_ordering_th_kernels_notop.h5
08-05
vgg16 cnn theano
vgg16_weights.zip
07-07
vgg16权重，网上资源下载速度很慢，资源地址：https://github.com/fchollet/deep-learning-models/releases/
VGGNet16完整测试代码
03-26
vggnet完整测试代码，需要自己下载vgg16_weights.npz，测试时候输入png格式图片即可。
深度学习主干网络-VGG16论文网络实现，参数介绍，数据处理，单通道，多通道数据，最大池化可视化。带源码。
weixin_43005832的博客
03-10 3967
深度学习主干网络-VGG16论文网络实现，参数介绍，数据处理，单通道，多通道数据，最大池化可视化。带源码。
vgg16
qq_40146935的博客
10-10 318
vgg16网络结构 import os import numpy as np import tensorflow as tf class vgg16(): def __init__(self,imgs): # 在类里边想要复用已经训练权重参数的时候，在模型中作为参数作为输入，类里边输入的参数，将参数在整个类中共享 self.paramerters = [] #在类的初始化时加入全局列表，将所需共享的参数加载进来 self.imgs =
基于卷积神经网络VGG16的皮革瑕疵识别与检测的研究（论文部分）
北天的博客
06-07 1363
基于卷积神经网络VGG16的皮革瑕疵识别与检测的研究（论文部分）
VGG-16、VGG-19(论文阅读《Very Deep Convolutional NetWorks for Large-Scale Image Recognition》)
热门推荐
周周的专栏
08-31 2万+
论文阅读《Very Deep Convolutional NetWorks for Large-Scale Image Recognition》介绍这是卷积神经网络发展的一些主要网络 LeNet（3个卷积层+2个降采样层+1个全连接层）CNN雏形 AlexNet （5个卷积层+3个全连接层+1个softmax层 本文所讨论的VGG就是基于LeNet、AlexNet提出的更深的卷积神经网络
vgg16和vgg16bn
10-19
vgg16和vgg16_bn都是深度学习中的卷积神经网络模型，其中vgg16_bn是在vgg16的基础上添加了batch normalization层。batch normalization是一种用于加速深度神经网络训练的技术，它可以使得网络更加稳定，加快收敛速度...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值