直接使用训练好的VGG16测试

最新推荐文章于 2024-08-04 18:20:47 发布
最新推荐文章于 2024-08-04 18:20:47 发布
阅读量2.8k 收藏 16
点赞数 1
分类专栏： 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32002253/article/details/89762412
版权

实验环境：

1、下载用VGG16在ImageNet数据集上训练好的权重数据 vgg16.npy  链接:https://pan.baidu.com/s/1gg9jLw3  密码:umce

2、下载imagenet_classes.py （1000个类别，tf.argmax 返回值就是imagenet_classes中行号对应的类别），下载地址：http://www.cs.toronto.edu/~frossard/post/vgg16/

3、创建 vgg16_v1.py

4、将一张猫图片（或其他图片），vgg16_v1.py，imagenet_classes.py，vgg16.npy放在同一个文件夹在

5、运行，ok....

vgg16_v1.py如下：

import tensorflow as tf
import numpy as np
import cv2
import imagenet_classes 


class vgg16:
    def __init__(self, imgs, weights=None, sess=None):
        self.imgs = imgs
        self.convlayers()
        self.fc_layers()
        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')
            biases = tf.Variable(tf.constant(0.0, shape=[64], dtype=tf.float32),trainable=True, name='biases')
            conv = tf.nn.conv2d(images, kernel, [1, 1, 1, 1], padding='SAME')
            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')
            biases = tf.Variable(tf.constant(0.0, shape=[64], dtype=tf.float32),trainable=True, name='biases')                                         
            conv = tf.nn.conv2d(self.conv1_1, kernel, [1, 1, 1, 1], padding='SAME')
            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')
            biases = tf.Variable(tf.constant(0.0, shape=[128], dtype=tf.float32),trainable=True, name='biases')                                         
            conv = tf.nn.conv2d(self.pool1, kernel, [1, 1, 1, 1], padding='SAME')
            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')
            biases = tf.Variable(tf.constant(0.0, shape=[128], dtype=tf.float32),trainable=True, name='biases')                                        
            conv = tf.nn.conv2d(self.conv2_1, kernel, [1, 1, 1, 1], padding='SAME')
            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')
            biases = tf.Variable(tf.constant(0.0, shape=[256], dtype=tf.float32),trainable=True, name='biases')                                         
            conv = tf.nn.conv2d(self.pool2, kernel, [1, 1, 1, 1], padding='SAME')
            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')
            biases = tf.Variable(tf.constant(0.0, shape=[256], dtype=tf.float32), trainable=True, name='biases')                                          
            conv = tf.nn.conv2d(self.conv3_1, kernel, [1, 1, 1, 1], padding='SAME')
            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')
            biases = tf.Variable(tf.constant(0.0, shape=[256], dtype=tf.float32),trainable=True, name='biases')                                         
            conv = tf.nn.conv2d(self.conv3_2, kernel, [1, 1, 1, 1], padding='SAME')
            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')
            biases = tf.Variable(tf.constant(0.0, shape=[512], dtype=tf.float32),trainable=True, name='biases')                                          
            conv = tf.nn.conv2d(self.pool3, kernel, [1, 1, 1, 1], padding='SAME')
            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')
            biases = tf.Variable(tf.constant(0.0, shape=[512], dtype=tf.float32),trainable=True, name='biases')                                      
            conv = tf.nn.conv2d(self.conv4_1, kernel, [1, 1, 1, 1], padding='SAME')
            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')
            biases = tf.Variable(tf.constant(0.0, shape=[512], dtype=tf.float32), trainable=True, name='biases')                                         
            conv = tf.nn.conv2d(self.conv4_2, kernel, [1, 1, 1, 1], padding='SAME')
            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')
            biases = tf.Variable(tf.constant(0.0, shape=[512], dtype=tf.float32), trainable=True, name='biases')                                         
            conv = tf.nn.conv2d(self.pool4, kernel, [1, 1, 1, 1], padding='SAME')
            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')
            biases = tf.Variable(tf.constant(0.0, shape=[512], dtype=tf.float32),trainable=True, name='biases')                                      
            conv = tf.nn.conv2d(self.conv5_2, kernel, [1, 1, 1, 1], padding='SAME')
            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('fc6') 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('fc7') 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('fc8') 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):
        data_dict = np.load(weight_file, encoding='latin1').item()
        keys = sorted(data_dict.keys())
#         print(len(keys),len(self.parameters))
        for i,key in enumerate(keys):
            weights = data_dict[key][0]
            biases = data_dict[key][1]
#             print(i,key,'w=',data_dict[key][0].shape,'b=',data_dict[key][1].shape)
            sess.run(self.parameters[2*i].assign(data_dict[key][0]))
            sess.run(self.parameters[2*i+1].assign(data_dict[key][1]))
           
    def predict(self):
        return tf.argmax(tf.nn.softmax(self.fc3l),1)        

if __name__ == '__main__':
    weigth='E:/deepLearningModel/vgg16.npy' #我把vgg16.npy放在E:/deepLearningModel/
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        imgs = tf.placeholder(tf.float32, [None, 224, 224, 3])
        vgg = vgg16(imgs, weigth, sess)
        preData = cv2.imread('cat.1.jpg')
        img1 =cv2.resize(preData,(224, 224))
        prob = sess.run(vgg.predict(), feed_dict={vgg.imgs: [img1]})
        print(imagenet_classes.class_names[prob[0]])

结果

 

海鸥-号
关注
专栏目录
Pytorch快速入门系列---（九）Pytorch对预训练好的VGG16模型进行微调
qq_42681787的博客
03-21 2967
对于一个复杂的卷积神经网络来说，通常网络的层数非常大，网络的深度非常深、网络的参数非常多，单单设计一个卷积网络就需要颇费心思，何况网络还需要大量的数据集进行漫长时间的训练，若没有一个好的算力平台也很难迅速训练出模型。可见，从头到尾搭建一个中等规模的卷积神经网络对于我们来说绝非易事。幸运的是PyTorch已经许多预训练好的模型，比如内置了使用ImageNet数据集预训练好的、流行的VGG、AlexNet等深度学习网络，我们可以针对自己的需求，对预训练好的网络进行微调，从而快速完成自己的任务。
vgg16网络代码，可直接使用
04-29
vgg16网络，直接训练预测，方便有效
跟我学算法- tensorflow VGG模型进行测试
weixin_34283445的博客
09-01 135
我们使用的VGG模型是别人已经训练好的一个19层的参数所做的一个模型 第一步：定义卷积分部操作函数 mport scipy.io import numpy as np import os import scipy.misc import matplotlib.pyplot as plt import tensorflow as tf # 进行卷积操作 def _conv_...
使用vgg16 ————对乳腺超声图像进行分类（两种方法）
最新发布
2401_84095018的博客
08-04 1232
通过两种不同的算法模型，对乳腺超声图像经行分类。
VGG16模型已经训练好的notop文件
04-02
该文件虽然是在github上可以找到的， 把该文件下载后保存到/root/.keras/models目录下即可
在使用一个已经训练好的模型测试时出现的问题总结
xuexue3729的博客
09-23 1272
最近在做超分辨率相关的实验，想找一个现成的简单测试一下，就用了这个博主的： SRGAN的简单实现 但是由于环境等都不一样，所以也是改了很久，基本都是环境问题，总结一下： python环境 在博主的readme中没看见有python版本，我自己是3.7的，也没改，只写了keras是2.2.4的，所以我配了1.12版的tensorflow，但还是有很多问题，报HDF5版本不对，也改不过来，后来还说是protobuf的问题。照网上的教程卸了重装好多次也没效果，后来发现keras和tensorflow版本都是对
pytorch迁移学习训练VGG16和模型测试代码
05-13
Pytorch迁移学习训练VGG16和模型测试代码（采用华为云modelarts训练），训练猫狗分类模型
VGG16模型训练+测试
王小波的博客
03-21 3567
tf.keras.applications 中有一些预定义好的经典卷积神经网络结构，如 VGG16 、 VGG19 、 ResNet 、 MobileNet、InceptionV3 等。我们可以直接调用这些经典的卷积神经网络结构（甚至载入预训练的参数），而无需手动定义网络结构。 导入需要的包 from keras.models import Model from keras.layers i...
VGG16、VGG19网络架构及模型训练 tricks ：训练技巧、测试技巧
l love CV
04-23 2335
在Vgg文章的基础之上，总结一下论文中提出的训练技巧和测试技巧，以及相关实验结果的分析。
pytorch预训练模型vgg16-397923af.pth
01-17
- 使用`torchvision.models`模块中的`vgg16(pretrained=True)`直接获取官方提供的预训练模型； - 自定义网络结构并通过`torch.load()`函数加载本地文件中的权重参数。 示例代码如下所示： ```python import ...
vgg16特征提取_成功_利用vGG16_VGG16_vgg16特征提取_vgg16图像分类_图像分类_
10-03
2. **加载预训练模型**：使用`applications.VGG16()`函数加载预训练的VGG16模型，并且可以选择是否包括顶部的全连接层。通常，为了进行特征提取，我们会不包含顶部的分类层。 3. **特征提取**：通过`model.layers[-...
使用别人已经训练好的模型1
08-08
VGG19模型图# 枚举模型中的所有层for i in vgg.layers: print(i.name)得到的结果input1，block1conv1，blo
vgg16.npy下载
07-14
支持vgg16网络的权重初始化。
训练产生的npy数据集
10-23
这个是我们用上面的算法调整之后生成的npy数据集合，需要的同学可以自行下载！
基于tensorflow框架，用训练好的Vgg16模型，实现猫狗图像分类的代码.zip
03-28
在本项目中，我们将探讨如何使用预训练的VGG16模型在TensorFlow框架下进行猫狗图像分类。VGG16是深度学习领域中一个经典的卷积神经网络（CNN）模型，最初由牛津大学视觉几何组（VGG）在2014年的ImageNet竞赛中提出。...
【入门教程】使用预训练模型进行训练、预测（以VGG16为例）
qq_36335611的博客
11-17 1万+
【新手教程】使用预训练模型进行训练、预测（以VGG16为例） 本文参考[csdn博文]( Pytorch学习笔记（I）——预训练模型（一）：加载与使用_lockonlxf的博客-CSDN博客_pytorch使用预训练模型)，修改了一些小问题 本文环境：win10、torch>=1.6 本文所有相关代码：阿里云盘 1、基础知识 VGG16是一个简单的深度学习模型，可以实现图像的分类。PyTorch的库中有VGG16的模型构架，在torchvision.models中： VGG( (features)
[VGG16模型]现有网络模型的使用与修改的学习 及ImageNet 数据集的下载
m0_51816252的博客
06-05 1861
本文以vgg16为例，来学习现有网络模型的使用与修改。除此之外还提及到了ImageNet 数据集的学习，和ImageNet 数据集的下载方面的一些问题。
基于 VGG16 深度学习预训练权重的图像分类预测实验
徐海蛟
02-19 1万+
徐海蛟教学 一直以来，计算科学家在为建立世界上最精确的计算机视觉系统孜孜不倦地努力着，但取得进展的过程却一直如马拉松竞赛般漫长而艰辛。斯坦福大学每年都会举行一个比赛 ILSVR ，邀请谷歌、微软、百度等IT企业使用ImageNet —— 全球最大的图像识别数据库，测试他们的系统运行情况。每年一度的比赛也牵动着各大巨头公司的心弦，过去几年中，系统的图像识别功能大大提高，ImageNet 2
使用VGG训练Imagenet
热门推荐
kesonyk的专栏
12-22 2万+
使用VGG训练Imagenet准备数据具体官网地址，请点击这里ImageNet官网训练数据集：ILSVRC2012_img_train.tar验证数据集：ILSVRC2012_img_val.tar数据解压sudo tar –xvf ILSVRC2012_img_train.tar -C ./train sudo tar –xvf ILSVRC2012_img_val.tar -C ./val对
用pytorch实现vgg网络包括数据集训练和测试
05-26
好的，下面是用PyTorch实现VGG网络的步骤，包括数据集的训练和测试。 ## 1. 数据集准备 我们使用的是CIFAR10数据集，可以在PyTorch中直接加载。如果你还没有下载，可以使用以下代码下载： ```python import ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值