循环神经网络VGG
VGGnet
模型们在ImageNet竞赛上的top-5错误率概况：
目的：
探究在大规模图像识别任务中，卷积网络的深度与其性能之间的关系
做法：
VGG把 Alexnet 最开始的一个7*7的卷积核用 3个3*3的卷积核代替。
通过反复堆叠3*3的小型卷积核（stride：1，padding:1）和 2*2的最大池化层，不断加深网络结构来提升性能，成功地构筑了16~19层深的卷积神经网络。
为什么这么做？
（1）3x3是最小的能够捕获左、右、上、下和中心概念的尺寸；
（2）AlexNet最开始的7*7的卷积核的感受野是：7*7
……..VGG第一个卷积核的感受野：3*3
……..第二个卷积核的感受野：（3-1）*1+3=5
……..第三个卷积核的感受野：（5-1）*1+3=7
……..可见三个3*3卷积核和一个7*7卷积核的感受野是一样的，但是3*3卷积核可以把网络做的更深。
（3）多个3*3的卷积层比一个大尺寸的filter卷积层有更多的非线性，使得判决函数更加具有判断性。
（4）多个3*3的卷积层比一个大尺寸的filter具有更少的参数。
成就：
VGGNet 相比之前state-of-the-art的网络结构，错误率大幅下降， 获得ILSVRC 2014比赛分类项目的第2名和定位项目的第1名。
贡献：
证明了使用很小的卷积（3*3），增加网络深度可以有效提升模型的效果，而且VGGNet对其他数据集具有很好的泛化能力
VGG的结构
为了在公平的原则下探究网络深度对模型精确度的影响，所有卷积层有相同的配置：
卷积核大小为3*3，步长为1（stride：1），填充为1（padding:1）；
共有5个最大池化层，大小都为2*2，步长为2（stride：2）；
三个全连接层，前两层都有4096通道，第三层共1000路及代表1000个标签类别；最后一层为softmax层；
所有隐藏层后都带有ReLU非线性激活函数；
下图为VGG16的结构图：
配置对比：
这张图的意思是他们一共建了A, B, C, D, E, F 6个不同的网络。
结构A：和AlexNet类似，卷积层分为了5个stage，全连接层还是3层。只不过卷积层用的都是3x3大小的filter，具体的细节我会在下文接着阐述。
结构A-LRN：保留AlexNet里面LRN操作，其他与结构A无区别。
结构B：在A的 stage2 和 stage3 分别增加一个3*3的卷积层，共有10个卷积层，全连接层还是3层。
结构C：在B的基础上，stage3，stage4，stage5分别增加一个1*1的卷积层，有13个卷积层，全连接层还是3层，总计16层。
结构D：在C的基础上，stage3，stage4，stage5分别增加一个3*3的卷积层，有13个卷积层，全连接层还是3层，总计16层。
结构E：在D的基础上，stage3，stage4，stage5分别再增加一个3*3的卷积层，有16个卷积层，全连接层还是3层，总计19层。
参数（以VGG16为例）：
VGG结构需要注意的点：
1、卷积核都是3x3的
2、参数最多的层：第一个全卷积层，占用内存最多的层：前两个卷积层
3、卷积核个数从64到128到256的目的：stride：1，padding:1 的卷积，特征图大小不变，但是进经过2*2的pooling操作，每个特征图的w和h都变为1/2,特征图的大小变为1/4，将卷积核的个数翻倍，可以降低信息衰减
4、使用了1*1卷积核，1*1卷积核有什么作用？
（1）降维（ dimension reductionality ）。比如，一张500 * 500且厚度depth为100 的图片在20个filter上做1*1的卷积，那么结果的大小为500*500*20。
（2）加入非线性。卷积层之后经过激励层，1*1的卷积在前一层的学习表示上添加了非线性激励（ non-linear activation ），提升网络的表达能力；
代码实例：
读入文件
import tensorflow as tf
import os
import pickle
import numpy as np
CIFAR_DIR = "./cifar-10-batches-py"
print(os.listdir(CIFAR_DIR))运行效果
# "def load_data(filename):\n",
# " \"\"\"read data from data file.\"\"\"\n",
# " with open(filename, 'rb') as f:\n",
# " data = pickle.load(f, encoding='bytes')\n",
# " return data[b'data'], data[b'labels']\n",
def load_data(filename):
#读取文件
with open(filename,'rb') as f:
data = pickle.load(f,encoding='bytes')
return data[b'data'],data[b'labels']class CifarData:
def __init__(self,filenames,need_shuffle):
all_data = []
all_labels = []
for filename in filenames:
data,labels = load_data(filename)
all_data.append(data)
all_labels.append(labels)
#将data排成m行n列的矩阵,标签排成1行n列的矩阵
self._data = np.vstack(all_data)
self._data = self._data / 127.5-1
self._labels = np.hstack(all_labels)
self._num_examples = self._data.shape[0]
print(self._data.shape)
print(self._labels.shape)
self._need_shuffle = need_shuffle
self._indicator = 0
#如果需要打乱数据，则打乱数据
if self._need_shuffle:
self._shuffle_data()
def _shuffle_data(self):
p = np.random.permutation(self._num_examples)
self._data = self._data[p]
self._labels = self._labels[p]
def next_batch(self,batch_size):
end_indicator = self._indicator + batch_size
if end_indicator > self._num_examples:
if self._need_shuffle:
self._shuffle_data()
self._indicator = 0
end_indicator = batch_size
else:
raise Exception("erro")
if end_indicator >self._num_examples:
raise Exception("erro")
batch_data = self._data[self._indicator:end_indicator]
batch_labels = self._labels[self._indicator:end_indicator]
self._indicator = end_indicator
return batch_data,batch_labels
train_filenames = [os.path.join(CIFAR_DIR,'data_batch_%d' %i)for i in range(1,6)]
test_filenames = [os.path.join(CIFAR_DIR,'test_batch')]
train_data = CifarData(train_filenames,True)
test_data = CifarData(test_filenames,False)运行效果
占位符，每次放进计算图 None个样本，每个样本3072个特征
x = tf.placeholder(tf.float32,[None,3072])
#将x转化为图片模式，32*32的3张图片
x_image = tf.reshape(x,[-1,3,32,32])
x_image = tf.transpose(x_image,[0,2,3,1])
#输出的y表示图片属于第几类
y = tf.placeholder(tf.int64,[None])
#conv1:神经元图 32*32
conv1_1 = tf.layers.conv2d(x_image,
32,#输出大小
(3,3),#卷积核大小
padding='same',
activation=tf.nn.relu,
name='conv1')
conv1_2 = tf.layers.conv2d(conv1_1,
32,#输出大小
(3,3),#卷积核大小
padding='same',
activation=tf.nn.relu,
name='conv1_2')
conv1_3 = tf.layers.conv2d(conv1_2,
32,#输出大小
(3,3),#卷积核大小
padding='same',
activation=tf.nn.relu,
name='conv1_3')
#池化层：减少计算量 16*16
pooling1 = tf.layers.max_pooling2d(conv1_3,
(2,2),#核大小
(2,2),#步长
name = 'pool1')
#conv2:神经元图 16*16
conv2_1 = tf.layers.conv2d(pooling1,32,#输出大小
(3,3),#卷积核大小
padding='same',
activation=tf.nn.relu,
name='conv2_1')
conv2_2 = tf.layers.conv2d(conv2_1,32,#输出大小
(3,3),#卷积核大小
padding='same',
activation=tf.nn.relu,
name='conv2_2')
conv2_3 = tf.layers.conv2d(conv2_2,32,#输出大小
(3,3),#卷积核大小
padding='same',
activation=tf.nn.relu,
name='conv2_3')
#池化层：减少计算量 8*8
pooling2 = tf.layers.max_pooling2d(conv2_2,
(2,2),#核大小
(2,2),#步长
name = 'pool2')
# 8*8
conv3_1 = tf.layers.conv2d(pooling2,32,(3,3),padding='same',activation=tf.nn.relu,name='conv3_1')
conv3_2 = tf.layers.conv2d(conv3_1,32,(3,3),padding='same',activation=tf.nn.relu,name='conv3_2')
conv3_3 = tf.layers.conv2d(conv3_2,32,(3,3),padding='same',activation=tf.nn.relu,name='conv3_3')
#4*4
pooling3 = tf.layers.max_pooling2d(conv3_3,(2,2),(2,2),name='pool3')
#形成全连接层
flatten = tf.layers.flatten(pooling3)
#实现矩阵相乘的功能
y_ = tf.layers.dense(flatten,10)# #使用softmax：exp(x_i)/sum(exp(x_i)),转化为【1.。。0】之间的数
# p_y_1 = tf.nn.softmax(y_)
# #如5：转化为[0,0,0,0,1,0,0,0,0,0 ]
# y_one_hot = tf.one_hot(y,10,dtype=tf.float32)
# loss = tf.reduce_mean(tf.square(y_one_hot - p_y_1))
#交叉熵损失函数 实现了 y转化为概率，y的one_hot编码，loss = ylogy_
loss = tf.losses.sparse_softmax_cross_entropy(labels=y,logits=y_)#计算准确率
predict = tf.argmax(y_,1)
correct_prediction = tf.equal(predict,y)
accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))#定义如何去求最优解，使用梯度下降法
# "with tf.name_scope('train_op'):\n",
# " train_op = tf.train.AdamOptimizer(1e-3).minimize(loss)"
with tf.name_scope('train_op'):
train_op = tf.train.AdamOptimizer(1e-3).minimize(loss)def variable_summary(var,name):
with tf.name_scope(name):
mean = tf.reduce_mean(var)
with tf.name_scope('stddev'):
stddev = tf.sqrt(tf.reduce_mean(tf.square(var - mean)))
tf.summary.scalar('mean',mean)
tf.summary.scalar('stddev',stddev)
tf.summary.scalar('min',tf.reduce_mean(var))
tf.summary.scalar('max',tf.reduce_max(var))
tf.summary.histogram('histogram',var) #打印出数据的直方图
with tf.name_scope('scope'):
variable_summary(conv1_1,'conv1_1')
variable_summary(conv1_2,'conv1_2')
variable_summary(conv2_1,'conv2_1')
variable_summary(conv2_2,'conv2_2')
variable_summary(conv3_1,'conv3_1')
variable_summary(conv3_2,'conv3_2')
loss_summary = tf.summary.scalar('loss',loss)
accuracy_summary = tf.summary.scalar('accuracy',accuracy)
source_image = (x_image + 1) * 127.7 # 逆向归一化过程
inputs_summary = tf.summary.image('inputs_image',source_image)
#使得所有summary聚合计算
merged_summary = tf.summary.merge_all()
#merged_summary_test = tf.summary.merge([loss_summary,accuracy_summary]) 测试集的需要显示出的数据
#指定得到的结果存储的文件夹
LOG_DIR = '.' #指定路径
run_label = 'run_vgg_tensorboard' #指定文件夹名字
run_dir = os.path.join(LOG_DIR,run_label)##路径,文件夹名称
#如果文件夹不存在，就创建
if not os.path.exists(run_dir):
os.mkdir(run_dir)
train_log_dir = os.path.join(LOG_DIR,'train')
#test_log_dir = os.path.join(LOG_DIR,'test')
if not os.path.exists(train_log_dir):
os.mkdir(train_log_dir)
# if not os.path.exists(test_log_dir):
# os.mkdir(test_log_dir)#初始化变量
init = tf.global_variables_initializer()
batch_size = 20
train_step = 100
output_summary_every_step = 100#每100步输入计算出的图示
#建立会话
with tf.Session() as sess:
sess.run(init)
#完成文件的写入
train_writer = tf.summary.FileWriter(train_log_dir,#路径
sess.graph)#写入的计算图
#test_writer = tf.summary.FileWriter(test_log_dir,sess.graph)
for i in range(train_step):
batch_data,batch_labels = train_data.next_batch(batch_size)
eval_ops = [loss,accuracy,train_op]
should_output_summary = (i%output_summary_every_step == 0)
if should_output_summary:
eval_ops.append(merged_summary)
eval_ops_results = sess.run(eval_ops,
feed_dict={
x:batch_data,
y:batch_labels})
loss_val,acc_val = eval_ops_results[0:2]
if should_output_summary:
train_summary_str = eval_ops_ results[-1]
train_writer.add_summary(train_summary_str,i+1)
if (i+1)%50 == 0:
print('[train]step %d,loss:%4.5f,acc:%4.5f'%(i+1,loss_val,acc_val))运行最终效果
