1 简介

VGGNet是2015年在ICLR会议中，公开的神经网络模型，这个模型在2014年imagenet比赛中获得了定位的第一名和分类的第二名的好成绩。

2 基本方法

Google官方文档介绍
（1）tf.placeholder用于传入真实训练样本/测试、真实特征、待处理特征，仅占位，不必给初值，用sess.run的feed_dict参数以字典形式喂给x:

images = tf.placeholder(tf.float32, shape =[BATCH_SIZE, IMAGE_PIXELS])

截屏2020-12-22 上午9.46.58.png
（2）np.load /np.save将数组以二进制格式读出或写入磁盘，扩展名为.npy

np.save(“名.npy”,某数组) 某变量 = np.load(“名.npy”,encoding =””).item()# encoding可不写，有三个选项latin1 ASCII bytes 默认是ASCII

（3）.item()遍历（键值对）

data_dict = np.load(vgg16.npy,encoding=’latin1’).item()#读取vgg16.npy文件，遍历其内键值对，导出模型参数赋给data_dict

（4）tf.shape(a)返回a的维度，a可以为tensor,list ,array
截屏2020-12-22 上午10.01.19.png
（5）tf.nn.bias_add(乘加和,bias)#把bias加到乘加和上
（6）tf.reshape(tensor,[n行，m列])或tf.reshape(tensor,[-1，m列])-1表示行随着m列自动计算
（7）np.argsort(列表)#对列表从小到大排序，返回索引值
（8）os.getcwd() # 返回当前工作目录
（9）os.path.join( , ,…) # 拼出整个路径，可引导到特定文件

vv16_path = os.path.join(os.getcwd(),”vgg16.npy”)

（10）tf.split(切谁，怎么切，在哪个维度切)

  1. #value 是一个【5 30】的张量
  2. split0,split1,split2 = tf.split(value,[4,15,11],1)
  3. 把value在第一个维度分为4 15 11三份
  4. tf.shape(split0) ==>[5,4]
  5. tf.shape(split1) ==>[5,15]
  6. tf.shape(split2) ==>[5,11]
  7. #把value平均切为三份
  8. split0,split1,split2 = tf.split(value, num_or_size_splits = 3,axis = 1)


（11）tf.conda(值，在哪个维)，实现粘贴

  1. t1 = [[1,2,3],[4,5,6]]
  2. t2 = [[7,8,9],[10,11,12]]
  3. #按照第0个维度粘
  4. tf.concat([t1,t2],0) ==>[[1,2,3],[4,5,6][7,8,9],[10,11,12]]
  5. #按照第1个维度粘贴
  6. tf.concat([t1,t2],1) ==>[[1,2,3,7,8,9],[4,5,6,10,11,12]]
  7. ...

（12）fig = plt.figure(‘图名字’)可视化图片

  1. img = io.imread(图片路径)
  2. ax = fig.add_subplot(数 数 数)#分别是包含几行，包含∏列，当前是第几个
  3. ax.bar(bar的个数，bar的值，每个bar的名字，bar宽,bard色)
  4. ax.set_ylabel("")
  5. ax.set_title("")
  6. ax.text(文字x坐标，文字y坐标，文字内容，ha ='center',va ='bottom',fontsize = 7)

（13）ax = imshow(图)画子图

3 实现

app.py文件

是应用程序，实现图像识别
截屏2020-12-22 上午10.30.15.png

  1. #coding:utf-8
  2. import numpy as np
  3. import tensorflow as tf
  4. #引入绘图模块
  5. import matplotlib.pyplot as plt
  6. #引用自定义模块
  7. import vgg16
  8. import utils
  9. from Nclasses import labels
  11. testNum = input("input the number of test pictures:")
  12. for i in range(testNum):
  13.     img_path = raw_input('Input the path and image name:')
  14.     #对待测试图像出预处理操作
  15.     img_ready = utils.load_image(img_path) 
  17.     #定义画图窗口，并指定窗口名称
  18.     fig=plt.figure(u"Top-5 预测结果") 
  20.     with tf.Session() as sess:
  21.         #定义一个维度为[1, 224, 224, 3]的占位符
  22.         images = tf.placeholder(tf.float32, [1, 224, 224, 3])
  23.         #实例化出vgg
  24.         vgg = vgg16.Vgg16() 
  25.         #前向传播过程，调用成员函数，并传入待测试图像
  26.         vgg.forward(images) 
  27.         #将一个batch数据喂入网络，得到网络的预测输出
  28.         probability = sess.run(vgg.prob, feed_dict={images:img_ready})
  29.         #得到预测概率最大的五个索引值
  30.         top5 = np.argsort(probability[0])[-1:-6:-1]
  31.         print "top5:",top5
  32.         #定义两个list-对应概率值和实际标签
  33.         values = []
  34.         bar_label = []
  35.         #枚举上面取出的五个索引值
  36.         for n, i in enumerate(top5): 
  37.             print "n:",n
  38.             print "i:",i
  39.             #将索引值对应的预测概率值取出并放入value
  40.             values.append(probability[0][i]) 
  41.             #将索引值对应的际标签取出并放入bar_label
  42.             bar_label.append(labels[i]) 
  43.             print i, ":", labels[i], "----", utils.percent(probability[0][i]) 
  45.         #将画布分为一行一列，并把下图放入其中
  46.         ax = fig.add_subplot(111) 
  47.         #绘制柱状图
  48.         ax.bar(range(len(values)), values, tick_label=bar_label, width=0.5, fc='g')
  49.         #设置横轴标签
  50.         ax.set_ylabel(u'probabilityit') 
  51.         #添加标题
  52.         ax.set_title(u'Top-5') 
  53.         for a,b in zip(range(len(values)), values):
  54.             #显示预测概率值
  55.             ax.text(a, b+0.0005, utils.percent(b), ha='center', va = 'bottom', fontsize=7)   
  56.         #显示图像
  57.         plt.show()

vgg16.py文件

读取模型参数，搭建模型
截屏2020-12-22 上午10.31.38.png

  1. #tensorflow学习笔记(北京大学) vgg16.py 完全解析 
  2. #QQ群：476842922（欢迎加群讨论学习
  3. #!/usr/bin/python
  4. #coding:utf-8
  6. import inspect
  7. import os
  8. import numpy as np
  9. import tensorflow as tf
  10. import time
  11. import matplotlib.pyplot as plt
  13. #样本RGB的平均值
  14. VGG_MEAN = [103.939, 116.779, 123.68] 
  16. class Vgg16():
  17.     def __init__(self, vgg16_path=None):
  18.         if vgg16_path is None:
  19.             #返回当前工作目录
  20.             vgg16_path = os.path.join(os.getcwd(), "vgg16.npy") 
  21.             #遍历其内键值对，导入模型参数
  22.             self.data_dict = np.load(vgg16_path, encoding='latin1').item() 
  24.     def forward(self, images):
  26.         print("build model started")
  27.         #获取前向传播开始时间
  28.         start_time = time.time() 
  29.         #逐个像素乘以255
  30.         rgb_scaled = images * 255.0 
  31.         #从GRB转换彩色通道到BRG
  32.         red, green, blue = tf.split(rgb_scaled,3,3) 
  33.         #减去每个通道的像素平均值，这种操作可以移除图像的平均亮度值
  34.         #该方法常用在灰度图像上
  35.         bgr = tf.concat([     
  36.             blue - VGG_MEAN[0],
  37.             green - VGG_MEAN[1],
  38.             red - VGG_MEAN[2]],3)
  39.         #构建VGG的16层网络（包含5段卷积，3层全连接），并逐层根据命名空间读取网络参数
  40.         #第一段卷积，含有两个卷积层，后面接最大池化层，用来缩小图片尺寸
  41.         self.conv1_1 = self.conv_layer(bgr, "conv1_1") 
  42.         #传入命名空间的name，来获取该层的卷积核和偏置，并做卷积运算，最后返回经过激活函数后的值
  43.         self.conv1_2 = self.conv_layer(self.conv1_1, "conv1_2")
  44.         #根据传入的pooling名字对该层做相应的池化操作
  45.         self.pool1 = self.max_pool_2x2(self.conv1_2, "pool1")
  47.         #第二段卷积，包含两个卷积层，一个最大池化层
  48.         self.conv2_1 = self.conv_layer(self.pool1, "conv2_1")
  49.         self.conv2_2 = self.conv_layer(self.conv2_1, "conv2_2")
  50.         self.pool2 = self.max_pool_2x2(self.conv2_2, "pool2")
  52.         #第三段卷积，包含三个卷积层，一个最大池化层
  53.         self.conv3_1 = self.conv_layer(self.pool2, "conv3_1")
  54.         self.conv3_2 = self.conv_layer(self.conv3_1, "conv3_2")
  55.         self.conv3_3 = self.conv_layer(self.conv3_2, "conv3_3")
  56.         self.pool3 = self.max_pool_2x2(self.conv3_3, "pool3")
  58.         #第四段卷积，包含三个卷积层，一个最大池化层
  59.         self.conv4_1 = self.conv_layer(self.pool3, "conv4_1")
  60.         self.conv4_2 = self.conv_layer(self.conv4_1, "conv4_2")
  61.         self.conv4_3 = self.conv_layer(self.conv4_2, "conv4_3")
  62.         self.pool4 = self.max_pool_2x2(self.conv4_3, "pool4")
  64.         #第五段卷积，包含三个卷积层，一个最大池化层
  65.         self.conv5_1 = self.conv_layer(self.pool4, "conv5_1")
  66.         self.conv5_2 = self.conv_layer(self.conv5_1, "conv5_2")
  67.         self.conv5_3 = self.conv_layer(self.conv5_2, "conv5_3")
  68.         self.pool5 = self.max_pool_2x2(self.conv5_3, "pool5")
  70.         #第六层全连接
  71.         #根据命名空间name做加权求和运算
  72.         self.fc6 = self.fc_layer(self.pool5, "fc6")
  73.         #经过relu激活函数
  74.         self.relu6 = tf.nn.relu(self.fc6) 
  76.         #第七层全连接
  77.         self.fc7 = self.fc_layer(self.relu6, "fc7")
  78.         self.relu7 = tf.nn.relu(self.fc7)
  80.         #第八层全连接
  81.         self.fc8 = self.fc_layer(self.relu7, "fc8")
  82.         self.prob = tf.nn.softmax(self.fc8, name="prob")
  84.         #得到全向传播时间
  85.         end_time = time.time() 
  86.         print(("time consuming: %f" % (end_time-start_time)))
  88.         #清空本次读取到的模型参数字典
  89.         self.data_dict = None 
  91.     #定义卷积运算    
  92.     def conv_layer(self, x, name):
  93.         #根据命名空间name找到对应卷积层的网络参数
  94.         with tf.variable_scope(name): 
  95.             #读到该层的卷积核
  96.             w = self.get_conv_filter(name) 
  97.             #卷积运算
  98.             conv = tf.nn.conv2d(x, w, [1, 1, 1, 1], padding='SAME') 
  99.             #读到偏置项
  100.             conv_biases = self.get_bias(name) 
  101.             #加上偏置，并做激活计算
  102.             result = tf.nn.relu(tf.nn.bias_add(conv, conv_biases)) 
  103.             return result
  105.     #定义获取卷积核的参数
  106.     def get_conv_filter(self, name):
  107.         #根据命名空间从参数字典中获取对应的卷积核
  108.         return tf.constant(self.data_dict[name][0], name="filter") 
  110.     #定义获取偏置项的参数
  111.     def get_bias(self, name):
  112.         #根据命名空间从参数字典中获取对应的偏置项
  113.         return tf.constant(self.data_dict[name][1], name="biases")
  115.     #定义最大池化操作
  116.     def max_pool_2x2(self, x, name):
  117.         return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME', name=name)
  119.     #定义全连接层的全向传播操作
  120.     def fc_layer(self, x, name):
  121.         #根据命名空间name做全连接层的计算
  122.         with tf.variable_scope(name): 
  123.             #获取该层的维度信息列表
  124.             shape = x.get_shape().as_list() 
  125.             dim = 1
  126.             for i in shape[1:]:
  127.                 #将每层的维度相乘
  128.                 dim *= i 
  129.             #改变特征图的形状，也就是将得到的多维特征做拉伸操作，只在进入第六层全连接层做该操作
  130.             x = tf.reshape(x, [-1, dim])
  131.             #读到权重值
  132.             w = self.get_fc_weight(name) 
  133.             #读到偏置项值
  134.             b = self.get_bias(name) 
  135.             #对该层输入做加权求和，再加上偏置
  136.             result = tf.nn.bias_add(tf.matmul(x, w), b) 
  137.             return result
  139.     #定义获取权重的函数
  140.     def get_fc_weight(self, name): 
  141.         #根据命名空间name从参数字典中获取对应1的权重
  142.         return tf.constant(self.data_dict[name][0], name="weights")

utils.py文件

读入图片，概率显示

  1. #!/usr/bin/python
  2. #coding:utf-8
  3. from skimage import io, transform
  4. import numpy as np
  5. import matplotlib.pyplot as plt
  6. import tensorflow as tf
  7. from pylab import mpl
  9. mpl.rcParams['font.sans-serif']=['SimHei'] # 正常显示中文标签
  10. mpl.rcParams['axes.unicode_minus']=False # 正常显示正负号
  12. def load_image(path):
  13.     fig = plt.figure("Centre and Resize")
  14.     #传入读入图片的参数路径
  15.     img = io.imread(path) 
  16.     #将像素归一化处理到[0,1]
  17.     img = img / 255.0 
  19.     #将该画布分为一行三列，把下面的图像放在画布的第一个位置
  20.     ax0 = fig.add_subplot(131)  
  21.     #添加子标签
  22.     ax0.set_xlabel(u'Original Picture') 
  23.     #添加展示该图像
  24.     ax0.imshow(img) 
  26.     #找到该图像的最短边
  27.     short_edge = min(img.shape[:2]) 
  28.     #把图像的w和h分别减去最短边，并求平均
  29.     y = (img.shape[0] - short_edge) / 2  
  30.     x = (img.shape[1] - short_edge) / 2 
  31.     #取出切分过的中心图像
  32.     crop_img = img[y:y+short_edge, x:x+short_edge] 
  34.     #把下面的图像放在画布的第二个位置
  35.     ax1 = fig.add_subplot(132) 
  36.     #添加子标签
  37.     ax1.set_xlabel(u"Centre Picture") 
  38.     #添加展示该图像
  39.     ax1.imshow(crop_img)
  41.     #resize成固定的imagesize
  42.     re_img = transform.resize(crop_img, (224, 224)) 
  44.     #把下面的图像放在画布的第三个位置
  45.     ax2 = fig.add_subplot(133) 
  46.     ax2.set_xlabel(u"Resize Picture") 
  47.     ax2.imshow(re_img)
  48.     #转换为需要的输入形状
  49.     img_ready = re_img.reshape((1, 224, 224, 3))
  51.     return img_ready
  53. #定义百分比转换函数
  54. def percent(value):
  55.     return '%.2f%%' % (value * 100)

Nclasses.py文件

含label字典
源码下载

vgg16.npy文件

包含了神经网络的全部参数
源码下载