原文链接: TensorFlow cifar 卷积网络

上一篇: one hot 编码 转化

下一篇: TensorFlow 梯度计算

卷积操作使用同卷积操作，步长为1，SAME

池化层有两个函数，一个放在卷子后面，取最大值，步长为2，SAME，即将原图长宽各除以2

另一个放在最后一层，取均值，步长为最终生成的特征尺寸6X6，（24X24经过两次池化变为6X6），filter也为6X6

倒数第二层是没有最大池化的卷积层，因为有10类，所以卷积输出的是10个通道，并使其全局平均池化为10个节点

结果

step 14400, training accuracy 0.5625
step 14600, training accuracy 0.703125
step 14800, training accuracy 0.609375
finished！ test accuracy 0.625

参考代码

import cifar10_input
import tensorflow as tf
import numpy as np# 数据准备，每次训练128张
batch_size = 128
data_dir = '/tmp/cifar10_data/cifar-10-batches-bin'
print("begin")
images_train, labels_train = cifar10_input.inputs(eval_data=False, data_dir=data_dir, batch_size=batch_size)
images_test, labels_test = cifar10_input.inputs(eval_data=True, data_dir=data_dir, batch_size=batch_size)
print("begin data")# 生成标准差为0.1 的随机数
def weight_variable(shape):initial = tf.truncated_normal(shape, stddev=0.1)return tf.Variable(initial)# 生成初始化为0.1的权重
def bias_variable(shape):initial = tf.constant(0.1, shape=shape)return tf.Variable(initial)def conv2d(x, W):return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')def max_pool_2x2(x):return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],strides=[1, 2, 2, 1], padding='SAME')def avg_pool_6x6(x):return tf.nn.avg_pool(x, ksize=[1, 6, 6, 1],strides=[1, 6, 6, 1], padding='SAME')# tf Graph Input
x = tf.placeholder(tf.float32, [None, 24, 24, 3])  # cifar data image of shape 24*24*3
y = tf.placeholder(tf.float32, [None, 10])  # 0-9 数字=> 10 classesW_conv1 = weight_variable([5, 5, 3, 64])
b_conv1 = bias_variable([64])x_image = tf.reshape(x, [-1, 24, 24, 3])h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)W_conv2 = weight_variable([5, 5, 64, 64])
b_conv2 = bias_variable([64])h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)W_conv3 = weight_variable([5, 5, 64, 10])
b_conv3 = bias_variable([10])
h_conv3 = tf.nn.relu(conv2d(h_pool2, W_conv3) + b_conv3)nt_hpool3 = avg_pool_6x6(h_conv3)  # 10
nt_hpool3_flat = tf.reshape(nt_hpool3, [-1, 10])
y_conv = tf.nn.softmax(nt_hpool3_flat)cross_entropy = -tf.reduce_sum(y * tf.log(y_conv))train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))sess = tf.Session()
sess.run(tf.global_variables_initializer())
tf.train.start_queue_runners(sess=sess)
for i in range(15000):  # 20000image_batch, label_batch = sess.run([images_train, labels_train])label_b = np.eye(10, dtype=float)[label_batch]  # one hottrain_step.run(feed_dict={x: image_batch, y: label_b}, session=sess)if i % 200 == 0:train_accuracy = accuracy.eval(feed_dict={x: image_batch, y: label_b}, session=sess)print("step %d, training accuracy %g" % (i, train_accuracy))image_batch, label_batch = sess.run([images_test, labels_test])
label_b = np.eye(10, dtype=float)[label_batch]  # one hot
print("finished！ test accuracy %g" % accuracy.eval(feed_dict={x: image_batch, y: label_b}, session=sess))

优化卷积核

将5X5 的滤波器转化为5X1和1X5两个，减少计算量

#########################################################new########
W_conv21 = weight_variable([5, 1, 64, 64])
b_conv21 = bias_variable([64])
h_conv21 = tf.nn.relu(conv2d(h_pool1, W_conv21) + b_conv21)W_conv2 = weight_variable([1, 5, 64, 64])
b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(h_conv21, W_conv2) + b_conv2)
###########################################################old#########
# W_conv2 = weight_variable([5, 5, 64, 64])
# b_conv2 = bias_variable([64])
# h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
###################################################################

使用tf卷积函数简化代码

def convolution(inputs,num_outputs,kernel_size,stride=1,padding='SAME',data_format=None,rate=1,activation_fn=nn.relu,normalizer_fn=None,normalizer_params=None,weights_initializer=initializers.xavier_initializer(),weights_regularizer=None,biases_initializer=init_ops.zeros_initializer(),biases_regularizer=None,reuse=None,variables_collections=None,outputs_collections=None,trainable=True,scope=None):

常用的参数说明如下：

• inputs:形状为[batch_size, height, width, channels]的输入。
• num_outputs：代表输出几个channel。这里不需要再指定输入的channel了，因为函数会自动根据inpus的shpe去判断。
• kernel_size：卷积核大小，不需要带上batch和channel，只需要输入尺寸即可。[5,5]就代表5x5的卷积核，如果长和宽都一样，也可以只写一个数5.
• stride：步长，默认是长宽都相等的步长。卷积时，一般都用1，所以默认值也是1.如果长和宽都不相等，也可以用一个数组[1,2]。
• padding：填充方式，'SAME'或者'VALID'。
• activation_fn：激活函数。默认是ReLU。也可以设置为None
• weights_initializer：权重的初始化，默认为initializers.xavier_initializer()函数。
• weights_regularizer：权重正则化项，可以加入正则函数。biases_initializer：偏置的初始化，默认为init_ops.zeros_initializer()函数。
• biases_regularizer：偏置正则化项，可以加入正则函数。
• trainable： 是否可训练，如作为训练节点，必须设置为True，默认即可。如果我们是微调网络，有时候需要冻结某一层的参数，则设置为False。

import cifar10_input
import tensorflow as tf
import numpy as npbatch_size = 128
data_dir = '/tmp/cifar10_data/cifar-10-batches-bin'
print("begin")
images_train, labels_train = cifar10_input.inputs(eval_data=False, data_dir=data_dir, batch_size=batch_size)
images_test, labels_test = cifar10_input.inputs(eval_data=True, data_dir=data_dir, batch_size=batch_size)
print("begin data")# tf Graph Input
x = tf.placeholder(tf.float32, [None, 24, 24, 3])  # cifar data image of shape 24*24*3
y = tf.placeholder(tf.float32, [None, 10])  # 0-9 数字=> 10 classesx_image = tf.reshape(x, [-1, 24, 24, 3])h_conv1 = tf.contrib.layers.conv2d(x_image, 64, [5, 5], 1, 'SAME', activation_fn=tf.nn.relu)
h_pool1 = tf.contrib.layers.max_pool2d(h_conv1, [2, 2], stride=2, padding='SAME')h_conv2 = tf.contrib.layers.conv2d(h_pool1, 64, [5, 5], 1, 'SAME', activation_fn=tf.nn.relu)
h_pool2 = tf.contrib.layers.max_pool2d(h_conv2, [2, 2], stride=2, padding='SAME')nt_hpool2 = tf.contrib.layers.avg_pool2d(h_pool2, [6, 6], stride=6, padding='SAME')nt_hpool2_flat = tf.reshape(nt_hpool2, [-1, 64])y_conv = tf.contrib.layers.fully_connected(nt_hpool2_flat, 10, activation_fn=tf.nn.softmax)cross_entropy = -tf.reduce_sum(y * tf.log(y_conv))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))sess = tf.Session()
sess.run(tf.global_variables_initializer())
tf.train.start_queue_runners(sess=sess)
for i in range(15000):  # 20000image_batch, label_batch = sess.run([images_train, labels_train])label_b = np.eye(10, dtype=float)[label_batch]  # one hottrain_step.run(feed_dict={x: image_batch, y: label_b}, session=sess)if i % 200 == 0:train_accuracy = accuracy.eval(feed_dict={x: image_batch, y: label_b}, session=sess)print("step %d, training accuracy %g" % (i, train_accuracy))image_batch, label_batch = sess.run([images_test, labels_test])
label_b = np.eye(10, dtype=float)[label_batch]  # one hot
print("finished！ test accuracy %g" % accuracy.eval(feed_dict={x: image_batch, y: label_b}, session=sess))