【翻译】VGG16

最新推荐文章于 2024-06-06 21:01:50 发布
最新推荐文章于 2024-06-06 21:01:50 发布
阅读量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.zip
04-10
这是VGG16网络，vgg16_weights在多伦多大学的开源镜像，因直接在该原网站下载较慢且费时间，大家需要请自取
Tensorflow【实战Google深度学习框架】基于tensorflow + Vgg16进行图像分类识别
李响
02-26 1273
文章目录1.VGG-16介绍2. 文件组成- vgg16.py文件代码：运行，测试参考 1.VGG-16介绍 vgg是在Very Deep Convolutional Networks for Large-Scale Image Recognition期刊上提出的。模型可以达到92.7%的测试准确度,在ImageNet的前5位。它的数据集包括1400万张图像，1000个类别。 vgg-16是一种深...
神经网络----现有网络的下载和使用（vgg16）
最新发布
qq_45452617的博客
06-06 497
以下两种方法已经用不了。
vgg16.npy与vgg16_weights.npz百度云下载
m0_46413170的博客
08-06 1848
vgg16.npy链接：https://pan.baidu.com/s/1lgTxud8cTn1zkfCs1ZUEyA 提取码：xiao vgg_weights.npz链接：https://pan.baidu.com/s/1NSBhOjRSlMqZnVPZBUMqyg 提取码：xiao
vgg16动物识别
AtYeXTolearn的博客
07-19 183
VGG是5个group的卷积、2层全连接层用于提取图像特征、1层全连接层用于分类特征。根据前5个卷积层组每个组中的不同配置，卷积层数从8到16递增，网络结构如下图所示。
Tensorflow学习笔记：VGG16训练——Finetuning，猫狗大战，VGGNet的重新针对训练
luckyboy101的专栏
10-26 3098
前面我们介绍了猫狗大战的数据集的整理已经转换成Tensorflow专用格式https://blog.csdn.net/nvidiacuda/article/details/83413837 以及介绍了vgg16模型https://blog.csdn.net/nvidiacuda/article/details/83414293 这篇介绍如何用数据对vgg16进行训练 Finetuning最重...
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. 准确率：随机选择了属于不同类型、不同大小的图片进行测试，通过模型的激活、调用和识别的其他过程之后...
vgg16_weights.npz
05-17
vgg16_weights.npz是vgg16权重，网上资源下载的话速度会很慢，内附网盘地址，下载很快，如果链接失效给我留言哦
vgg16_weight_and_xception_weights
01-14
这有两个文件，分别是VGG16_weights_tf和xception_weights_tf,都是No_top的，有top太大没法传，其他inception_v3的两个文件和resnet50的两个文件分别压缩在一块，刚好小于200M，也上传上来了
vgg16_weights 权重下载百度云下载链接.docx
05-02
vgg16_weights 权重百度云下载链接
VGG16经典神经网络总结
ZDA_fight的博客
06-03 1388
2014_VGG16_牛津** 图： 网络描述： VGG16总共有16层，13个卷积层和3个全连接层，第一次经过64个卷积核的两次卷积后，采用一次pooling，第二次经过两次128个卷积核卷积后，再采用pooling，再重复两次三个512个卷积核卷积后，再pooling，最后经过三次全连接。 输入图像尺寸224×224×3，进行第一个卷积之后得到224×224×64的特征图，接着还有一层224×224×64，得到这样2个厚度为64的卷积层，意味着我们用64个过滤器进行了两次卷积。这里采用的都是大小为3×
VGG（论文翻译）
SF_ORION的博客
06-10 1883
VGG（论文翻译） Very Deep Convolutional Networks for Large-Scale Image Recognition 用于大规模图像识别的超深度卷积网络 ABSTRACT 摘要 In this work we investigate the effect of the convolutional network depth on its accuracy in the large-scale image recognition setting. Our main cont
vgg16的权重更新
weixin_67957872的博客
10-05 1683
获取vgg16网络模型参数出错时的解决办法
keras 自带VGG16 net 参数分析
vola的专栏
04-13 4391
对VGG16 这类keras自带的网络分析有感,写在这里. 查看VGG16在keras中的说明文档,可以这样: from keras.applications.vgg16 import VGG16 然后(在jupyter notebook, jupyter lab或Ipython中) ? VGG16 可查看VGG16的使用帮助. Signature: VGG16(inclu...
VGG论文：3x3卷积深度提升大规模图像识别性能
本文档是一篇关于卷积神经网络（Convolutional Neural Networks, CNN）深度对大规模图像识别性能影响的研究论文翻译。该工作由SnailTyan在2017年进行，主要关注的是VGG（Visual Geometry Group）系列模型的深度设计...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值