vgg-16代码实现

最新推荐文章于 2024-03-15 21:08:16 发布
最新推荐文章于 2024-03-15 21:08:16 发布
阅读量2.9k 收藏 12
点赞数 3
分类专栏： 深度学习 
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]
            print(self.parameters[1])

        # 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:
            print(self.pool5.get_shape())
            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]
            print(self.parameters)

    def load_weights(self, weight_file, sess):
        weights = np.load(weight_file)#权重载入

        keys = sorted(weights.keys())#对获得的字典值进行排序
        for i, k in enumerate(keys):#之后使用一个enumerate方法将数据迭代出，这里迭代的结果是序号以及key值，
            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]#（1，1000）[0]=>(1000,)
    print("prob")
    print(prob)
    print(np.shape(prob)) #(1000,)
    preds = (np.argsort(prob)[::-1])[0:5]#升序输出前5个
    for p in preds:
        print(class_names[p], prob[p])

 具体vgg的权重vgg16_weights.npz和imagenet_classes.py文件地址在https://www.cs.toronto.edu/~frossard/post/vgg16/

 

chenxi0910
关注
  • 3
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
VGGNet16完整测试代码
03-26
vggnet完整测试代码，需要自己下载vgg16_weights.npz，测试时候输入png格式图片即可。
深度学习pytorch实战三：VGG16图像分类篇自建数据集图像分类三类
qq_55433305的博客
03-06 4746
VGG16图像分类篇自建数据集图像分类三类1.自建数据集与划分训练集与测试集 2.模型相关知识 3.model.py——定义AlexNet网络模型 4.train.py——加载数据集并训练，训练集计算损失值loss，测试集计算accuracy，保存训练好的网络参数 5.predict.py——利用训练好的网络参数后，用自己找的图像进行分类测试
VGG网络的代码实现
xfsong2012的博客
03-15 421
VGG网络的程序实现完全根据配置表来实现。全连接层之前的部分属于特征提取部分，后三部分全连接层用来分类。
vgg16代码实现
tang330023555的博客
07-15 1934
class deeplabv1(nn.Module): def __init__(self): super(deeplabv1, self).__init__() self.block1 = nn.Sequential( nn.Conv2d(3, 64, kernel_size=3, padding=1), nn.ReLU(), nn.Conv2d(64, 64, kernel_size=3, .
VGG16模型代码实现
m0_59161923的博客
06-11 1306
nn.Conv2d(in_channel,64,3,1,1),#输入通道数为in_channel，输出通道数为64，卷积核大小为3x3，步长为1，填充为1。nn.Linear(num_hidden,4096),#输入大小为num_hidden，输出大小为4096，表示第一个全连接层。#self.avgpool是自适应平均池化层，可以根据输入数据的大小自动调整池化核的大小，并在不改变特征图大小的情况下进行下采样操作。#output_size=(7,7)表示得到的池化结果大小为7x7。
tensorflow-vgg16代码
11-24
忘了是哪本外国书的源代码了，只是当时看书的时候顺便Copy了作者给的代码，
VGG16层经典源代码
09-23
最经典的VGG代码，是深度学习的基础，适合配合VGG代码一起阅读使用，非常适合深度学习初学者阅读学习深度学习框架构建规则。
vgg-cifar100:在CIFAR-100上训练的VGG-16的Tensorflow实现
05-17
CIFAR-100上的VGG-16 在CIFAR-100上训练的VGG网（具有batchnorm和dropout）。 您可以通过更改数据加载器类中的一行来轻松修改此代码以在CIFAR-10上进行训练。 在不增加数据的情况下达到约64％的准确性。 该数据集上...
VGG16-Tensorflow:VGG16的Tensorflow实现
05-02
VGG16的实施除了代码本身的注释外，我还写了一篇文章，您可以在找到有关VGGNet的进一步说明。... VGG16 Train.ipynb ：笔记本，用于培训和测试VGG16的实现。 如果您在查看笔记本文件时遇到问题，请单击。
VGG16_TF:简单实现VGG16
04-28
利用Tensorflow简单实现VGGNet，从数据集制作到训练完成测试 参考：《Tensorflow实战》《Tensorflow 实战Google深度学习框架》 学习Tensorflow，拿VGG16练练手，没有其他骚操作，只有数据集制作，训练及测试。 训练...
基于Python+VGG-16的图像检索系统源码+数据集+详细文档（高分毕业设计）.zip
最新发布
04-17
基于Python+VGG-16的图像检索系统源码+数据集+详细文档（高分毕业设计）.zip基于Python+VGG-16的图像检索系统源码+数据集+详细文档（高分毕业设计）.zip 【备注】 1、该资源内项目代码都经过测试运行成功，功能ok的...
VGG16_vgg16代码_VGG16_vgg16代码详解_
09-29
vgg16代码，最简单版本，容易看懂，易上手，按照论文敲的
VGG16模型tensorflow实现
05-05
包括数据集预处理以及生成tfrecord文件，用自己数据集训练VGG16，亲测可用
vgg16网络代码，可直接使用
04-29
vgg16网络，直接训练预测，方便有效
Vgg16 model
03-25
vgg16 模型 用于初始训练，准确率非常高，可以直接将其封装到云平台中！
基于VGG-16的图像检索系统（python源码+项目说明）.zip
03-19
【资源说明】 1、该资源包括项目的全部源码，下载可以直接使用！ 2、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设项目，作为参考...基于VGG-16的图像检索系统（python源码+项目说明）.zip
卷积神经网络模型之——VGG-16网络结构与代码实现
1+1=王的博客
07-18 9579
VGG原文：Very deep convolutional networks for large-scale image recognition：https://arxiv.org/pdf/1409.1556.pdf VGG在2014年由牛津大学Visual GeometryGroup提出，获得该年lmageNet竞赛中Localization Task(定位任务)第一名和 Classification Task (分类任务)第二名。VGG与AlexNet相比，它采用几个连续的3x3的卷积核代替AlexNe
VGG16网络结构与代码
m0_56247038的博客
05-30 9098
VGG16总共有16层（不包括池化层），13个卷积层和3个全连接层，第一次经过64个卷积核的两次卷积后，采用一次pooling，第二次经过两次128个卷积核卷积后，采用pooling；再经过3次256个卷积核卷积后，采用pooling；再经过3次512个卷积核卷积，采用pooling；再经过3次512个卷积核卷积，采用pooling，最后经过三次全连接。 模块 各模块的涉及的层次 ..................
VGG16全卷积网络 以VGG代码为例
路人的博客
06-09 1958
VGG之所以经典，是因为VGG第一次将深度学习做得非常“深”，达到了16-19层。同时，它用了非常“小”的卷积核（3X3）。 VGG与AlexNet差不多，不同之处就在于网络层数变深了。下图VGG对原始VGG16做了一点变化，把后面三层FC层改为了conv层。可以将其称之为全卷积VGG16。实现特征通道的升维和降维通过控制卷积核的数量达到通道数大小的放缩。而池化层只能改变高度和宽度，无法改变通道数。...
VGG16网络代码实现
05-20
以下是VGG16网络的代码实现： ```python import tensorflow as tf def VGG16(input_shape=(224, 224, 3), num_classes=1000): model = tf.keras.Sequential([ # Block 1 tf.keras.layers.Conv2D(64, (3, 3), ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值