直接使用训练好的VGG16测试

最新推荐文章于 2025-05-20 15:23:13 发布
原创 最新推荐文章于 2025-05-20 15:23:13 发布 · 2.9k 阅读 · 16 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

该博客介绍了VGG16实验环境搭建过程。需下载用VGG16在ImageNet数据集训练好的权重数据vgg16.npy、imagenet_classes.py，创建vgg16_v1.py，将一张图片与相关文件放于同一文件夹，运行即可。还给出了vgg16.npy的百度网盘链接及imagenet_classes.py的下载地址。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

实验环境：

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 3531
对于一个复杂的卷积神经网络来说，通常网络的层数非常大，网络的深度非常深、网络的参数非常多，单单设计一个卷积网络就需要颇费心思，何况网络还需要大量的数据集进行漫长时间的训练，若没有一个好的算力平台也很难迅速训练出模型。可见，从头到尾搭建一个中等规模的卷积神经网络对于我们来说绝非易事。幸运的是PyTorch已经许多预训练好的模型，比如内置了使用ImageNet数据集预训练好的、流行的VGG、AlexNet等深度学习网络，我们可以针对自己的需求，对预训练好的网络进行微调，从而快速完成自己的任务。
vgg16网络代码，可直接使用
04-29
vgg16网络，直接训练预测，方便有效
Tensorflow如何直接使用预训练模型(vgg16为例)
weixin_44633882的博客
04-06 1万+
Tensorflow如何直接使用预训练模型(vgg16为例) 本文链接： 主流的CNN模型基本都会使用VGG16或者ResNet等网络作为预训练模型，正好有个朋友和我说发给他一个VGG16的预训练模型和代码，我就整理了一下。在这里也分享一下，方便大家直接使用。 系统环境 Tensorflow-gpu 1.12.0 Python 3.5.2 资料来源 官方slim说明 https://gith...
（一）VGG网络实战：VGG16网络构建及训练
最新发布
dzy0619的博客
05-20 314
本文详细介绍了基于VGG16网络的搭建、训练和预测过程。首先，通过定义VGG16类搭建网络结构，包含13个卷积层和3个全连接层，并使用Kaiming初始化方法对权重进行初始化。接着，使用自定义数据集进行训练，数据通过CustomDataset类加载，并进行数据增强。训练过程中，使用交叉熵损失函数和Adam优化器，并通过StepLR调整学习率。最后，通过加载训练好的模型对图像进行预测，输出类别和置信度。此外，还提供了一个简化版的VGG6网络，适用于资源有限的情况。整个过程涵盖了从网络搭建到实际应用的完整流程。
跟我学算法- tensorflow VGG模型进行测试
weixin_34283445的博客
09-01 169
我们使用的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模型已经训练好的notop文件
04-02
该文件虽然是在github上可以找到的， 把该文件下载后保存到/root/.keras/models目录下即可
在使用一个已经训练好的模型测试时出现的问题总结
xuexue3729的博客
09-23 1375
最近在做超分辨率相关的实验，想找一个现成的简单测试一下，就用了这个博主的： SRGAN的简单实现 但是由于环境等都不一样，所以也是改了很久，基本都是环境问题，总结一下： python环境 在博主的readme中没看见有python版本，我自己是3.7的，也没改，只写了keras是2.2.4的，所以我配了1.12版的tensorflow，但还是有很多问题，报HDF5版本不对，也改不过来，后来还说是protobuf的问题。照网上的教程卸了重装好多次也没效果，后来发现keras和tensorflow版本都是对
pytorch预训练模型vgg16-397923af.pth
01-17
- 使用`torchvision.models`模块中的`vgg16(pretrained=True)`直接获取官方提供的预训练模型； - 自定义网络结构并通过`torch.load()`函数加载本地文件中的权重参数。 示例代码如下所示： ```python import ...
基于tensorflow框架，用训练好的Vgg16模型，实现猫狗图像分类的代码.zip
03-28
在本项目中，我们将探讨如何使用预训练的VGG16模型在TensorFlow框架下进行猫狗图像分类。VGG16是深度学习领域中一个经典的卷积神经网络（CNN）模型，最初由牛津大学视觉几何组（VGG）在2014年的ImageNet竞赛中提出。...
vgg16特征提取_成功_利用vGG16_VGG16_vgg16特征提取_vgg16图像分类_图像分类_
10-03
2. **加载预训练模型**：使用`applications.VGG16()`函数加载预训练的VGG16模型，并且可以选择是否包括顶部的全连接层。通常，为了进行特征提取，我们会不包含顶部的分类层。 3. **特征提取**：通过`model.layers[-...
pytorch迁移学习训练VGG16和模型测试代码
05-13
Pytorch迁移学习训练VGG16和模型测试代码（采用华为云modelarts训练），训练猫狗分类模型
使用别人已经训练好的模型1
08-08
VGG19模型图# 枚举模型中的所有层for i in vgg.layers: print(i.name)得到的结果input1，block1conv1，blo
vgg16.npy下载
07-14
支持vgg16网络的权重初始化。
训练产生的npy数据集
10-23
这个是我们用上面的算法调整之后生成的npy数据集合，需要的同学可以自行下载！
VGGNet16完整测试代码
03-26
vggnet完整测试代码，需要自己下载vgg16_weights.npz，测试时候输入png格式图片即可。
[VGG16模型]现有网络模型的使用与修改的学习 及ImageNet 数据集的下载
m0_51816252的博客
06-05 2156
本文以vgg16为例，来学习现有网络模型的使用与修改。除此之外还提及到了ImageNet 数据集的学习，和ImageNet 数据集的下载方面的一些问题。
vgg16网络搭建可运行代码
m0_53291740的博客
08-06 284
summary是打印网络结构信息。
基于 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对
调用训练好的vgg去测试cifar
01-19
### 使用预训练的 VGG 模型测试 CIFAR 数据集 为了使用预训练的 VGG 模型对 CIFAR-10 数据集进行测试，可以按照如下方法操作： #### 准备工作 确保安装必要的 Python 库，如 TensorFlow 和 Keras。可以通过 pip 安装这些库。 ```bash pip install tensorflow keras numpy matplotlib ``` #### 加载并准备数据集 CIFAR-10 是一个标准的数据集，在 Keras 中可以直接调用。需要注意的是，原始 CIFAR-10 图像大小为 32×32 像素，而大多数预训练模型期望输入更大的图片尺寸（通常是 224×224 或更高），因此需要调整图像大小以匹配预训练模型的要求[^2]。 ```python from keras.datasets import cifar10 import numpy as np from PIL import Image from keras.applications.vgg16 import preprocess_input (x_train, y_train), (x_test, y_test) = cifar10.load_data() def resize_images(images): resized_images = [] for img in images: pil_image = Image.fromarray(img.astype('uint8')) resized_img = pil_image.resize((224, 224)) resized_images.append(np.array(resized_img)) return np.array(resized_images) x_test_resized = resize_images(x_test) x_test_preprocessed = preprocess_input(x_test_resized) ``` #### 调整类别标签 因为 CIFAR-10 的标签是从 0 到 9 编号，但是某些情况下可能需要将其转换成 one-hot 编码形式以便于后续处理。 ```python from keras.utils import to_categorical y_test_one_hot = to_categorical(y_test, num_classes=10) ``` #### 导入预训练模型 Keras 提供了一个简单的接口来导入带有 ImageNet 权重初始化的 VGG16 模型。这里去掉顶部全连接层，并冻结所有卷积基底参数不参与反向传播更新过程。 ```python from keras.applications import VGG16 base_model = VGG16(weights='imagenet', include_top=False, input_shape=(224, 224, 3)) for layer in base_model.layers: layer.trainable = False ``` #### 构建顶层分类器 构建一个新的顶层分类器附加到已有的特征提取部分之上。这一步骤通常涉及添加全局平均池化层和平滑线性单元激活函数后的密集层作为输出节点数等于目标类别的数量。 ```python from keras.models import Model from keras.layers import Dense, GlobalAveragePooling2D x = base_model.output x = GlobalAveragePooling2D()(x) predictions = Dense(10, activation='softmax')(x) model = Model(inputs=base_model.input, outputs=predictions) ``` #### 测试模型性能 编译模型之后就可以利用测试集中的一部分样本验证模型的表现了。注意设置合适的损失函数和优化算法。 ```python model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) scores = model.evaluate(x_test_preprocessed, y_test_one_hot, verbose=1) print(f'Test accuracy: {scores[1]*100:.2f}%') ``` 通过上述步骤，能够成功地应用预训练好的 VGG 模型对 CIFAR-10 进行预测分析。值得注意的是，由于两者之间存在差异——比如图像分辨率的不同以及源域与目标域之间的差距——实际效果可能会有所折扣。不过这种方法仍然提供了一种快速有效的迁移学习途径[^4]。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值