Python机器学习笔记：卷积神经网络最终笔记

1981 年的诺贝尔医学奖，颁发给了 David Hubel、TorstenWiesel，以及
Roger Sperry。他们的主要贡献，是发现了人的视觉系统的信息处理是分级的。 从低级的V1区提取边缘特征，再到V2区的形状或者目标的部分等，再到更高层，
整个目标、目标的行为等。也就是说高层的特征是低层特征的组合，从低层到高层
的特征表示越来越抽象，越来越能表现语义或者意图。而抽象层面越高，存在的可
能猜测就越少，就越利于分类。

# _*_coding:utf-8_*_
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_datamnist = input_data.read_data_sets('MNIST_data/', one_hot=True)
sess = tf.InteractiveSession()# 权重和偏置需要创建，我们这里定义好初始化函数以便重复使用
# 这里我们使用截断的正态分布噪声，标准差设为0.1
def weight_varibale(shape):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)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')# 定义输入的： x 特征，y_ 真实的label
x = tf.placeholder(tf.float32, [None, 784])
y_ = tf.placeholder(tf.float32, [None, 10])
# 因为需要将1D 的输入向量转为2D的图片结构，而且颜色只有一个通道
# 所以最终尺寸如下，当然-1代表样本数量不固定，不用担心
x_image = tf.reshape(x, [-1, 28, 28, 1])# 第一个卷积层
W_conv1 = weight_varibale([5, 5, 1, 32])
b_conv1 = bias_variable([32])
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)# 第二个卷积层（区别第一个卷积，卷积核变为64，也就是说这一层会提取64个特征）
W_conv2 = weight_varibale([5, 5, 32, 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)# 当经历了两次步长为2*2的最大池化，所以边长已经只有1/4
# 所以图片尺寸由28*28边长7*7
W_fc1 = weight_varibale([7 * 7 * 64, 1024])
b_fc1 = bias_variable([1024])
h_pool2_flat = tf.reshape(h_pool2, [-1, 7 * 7 * 64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)# 为了防止过拟合，下面使用一个Dropout层
# Dropout层是通过一个placeholder传入 keep_prob比率来控制的
# 在训练时候，我们随机丢掉一部分节点的数据来减轻过拟合
# 在预测时候，我们则保留全部数据来追求最好的预测性能
keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)# 将Dropout层的输出连接一个Softmax层，得到最后的概率输出
W_fc2 = weight_varibale([1024, 10])
b_fc2 = bias_variable([10])
y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)# 定义损失函数cross_entropy，但是优化器使用Adam 并给予学习率1e-4
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y_conv),
reduction_indices=[1]))
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, tf.float32))tf.global_variables_initializer().run()
for i in range(20000):
batch = mnist.train.next_batch(50)
if i % 100 == 0:
train_accuracy = accuracy.eval(feed_dict={
x: batch[0], y_: batch[1], keep_prob: 1.0
})
print("step %d, training accuracy %g" % (i, train_accuracy))
train_step.run(feed_dict={x: batch[0], y_: batch[1],
keep_prob: 0.5})print("test accuracy %g" % accuracy.eval(feed_dict={
x: mnist.test.images,
y_: mnist.test.labels,
keep_prob: 1.0
}))

step 0, training accuracy 0.1
step 100, training accuracy 0.9
step 200, training accuracy 0.86
step 300, training accuracy 0.92
step 400, training accuracy 0.92
step 500, training accuracy 0.94
step 600, training accuracy 0.98
step 700, training accuracy 0.96
......
step 7500, training accuracy 1
step 7600, training accuracy 0.98
... ...
step 19700, training accuracy 1
step 19800, training accuracy 1
step 19900, training accuracy 1
test accuracy 0.9929

飞机， 汽车， 鸟， 猫， 鹿， 狗， 青蛙， 马， 船以及卡车。

#_*_coding:utf-8_*_
# import cifar10
import cifar10_input
import tensorflow as tf
import numpy as np
import timemax_steps = 3000
batch_size = 128
data_dir = 'cifar10\CIFAR-10\cifar-10-batches-bin'def variable_with_weight_loss(shape, stddev, w1):
'''
权重初始化函数
:param shape: 卷积核参数，格式类似于[5, 5, 3, 32]，代表卷积核尺寸（前两个数字通道数和卷积核个数）
:param stddev: 标准差
:param w1: L2正则化的权重参数
:return: 返回带有L2正则的初始化的权重参数
'''
# 截断产生正态分布，即产生正态分布的值与均值的差值大于两倍的标准差，那就重新写
var = tf.Variable(tf.truncated_normal(shape, stddev=stddev))
if w1 is not None:
# 给权重W加上L2 正则，并用W1 参数控制L2 Loss大小
weight_loss = tf.multiply(tf.nn.l2_loss(var), w1, name='weight_loss')
# 将weight_loss 存在一个名为 “losses” 的collection里，后面会用到
tf.add_to_collection('losses', weight_loss)
return var# 我们对图像进行数据增强的操作需要耗费大量CPU时间，因此distorted_inputs使用了16个
# 独立的线程来加速任务，函数内部会产生线程池，在需要使用时会通过queue进行调度。
images_train, labels_train = cifar10_input.distorted_inputs(
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)# 数据中图片的尺寸为24*24，即裁剪后的大小，而颜色的通道数则为3，代表RGB
image_holder = tf.placeholder(tf.float32, [batch_size, 24, 24, 3])
label_holder = tf.placeholder(tf.int32, [batch_size])# 第一个卷积层
weight1 = variable_with_weight_loss(shape=[5, 5, 3, 64], stddev=5e-2,
w1=0.0)
kernel1 = tf.nn.conv2d(image_holder, weight1, [1, 1, 1, 1],
padding='SAME')
bias1 = tf.Variable(tf.constant(0.0, shape=[64]))
conv1 = tf.nn.relu(tf.nn.bias_add(kernel1, bias1))
pool1 = tf.nn.max_pool(conv1, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],
padding='SAME')
norm1 = tf.nn.lrn(pool1, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75)# 第二个卷积层，上一层卷积核数量为64，所以本层卷积核尺寸的第三个维度也需调整64
# 这里bias值全部初始化为0.1，而不是0，最后调整了最大池化层和LRN层的顺序，先LRN层处理
weight2 = variable_with_weight_loss(shape=[5, 5, 64, 64], stddev=5e-2, w1=0.0)
kernel2 = tf.nn.conv2d(norm1, weight2, [1, 1, 1, 1], padding='SAME')
bias2 = tf.Variable(tf.constant(0.1, shape=[64]))
conv2 = tf.nn.relu(tf.nn.bias_add(kernel2, bias2))
norm2 = tf.nn.lrn(conv2, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75)
pool2 = tf.nn.max_pool(norm2, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],
padding='SAME')# 全连接层
reshape = tf.reshape(pool2, [batch_size, -1])
dim = reshape.get_shape()[1].value
weight3 = variable_with_weight_loss(shape=[dim, 384], stddev=0.04, w1=0.004)
bias3 = tf.Variable(tf.constant(0.1, shape=[384]))
local3 = tf.nn.relu(tf.matmul(reshape, weight3) + bias3)# 全连接层2，和之前很像，只不过其隐含节点数下降了一半，只有192个，其他超参数不变
weight4 = variable_with_weight_loss(shape=[384, 192], stddev=0.04, w1=0.004)
bias4 = tf.Variable(tf.constant(0.1, shape=[192]))
local4 = tf.nn.relu(tf.matmul(local3, weight4) + bias4)# 最后一层，先建立weight，其正态分布标准差为上一个隐含层的节点数的倒数，并且不计入L2正则
weight5 = variable_with_weight_loss(shape=[192, 10], stddev=1/192.0, w1=0.0)
bias5 = tf.Variable(tf.constant(0.0, shape=[10]))
logits = tf.add(tf.matmul(local4, weight5), bias5)

#_*_coding:utf-8_*_
# import cifar10
import cifar10_input
import tensorflow as tf
import numpy as np
import timemax_steps = 3000 #训练轮数（每一轮一个batch参与训练）
batch_size = 128 # batch 大小
data_dir = 'cifar10\CIFAR-10\cifar-10-batches-bin' # 数据目录def variable_with_weight_loss(shape, stddev, w1):
'''
权重初始化函数
:param shape: 卷积核参数，格式类似于[5, 5, 3, 32]，代表卷积核尺寸（前两个数字通道数和卷积核个数）
:param stddev: 标准差
:param w1: L2正则化的权重参数
:return: 返回带有L2正则的初始化的权重参数
'''
# 截断产生正态分布，即产生正态分布的值与均值的差值大于两倍的标准差，那就重新写
var = tf.Variable(tf.truncated_normal(shape, stddev=stddev))
if w1 is not None:
# 给权重W加上L2 正则，并用W1 参数控制L2 Loss大小
weight_loss = tf.multiply(tf.nn.l2_loss(var), w1, name='weight_loss')
# 将weight_loss 存在一个名为 “losses” 的collection里，后面会用到
tf.add_to_collection('losses', weight_loss)
return vardef loss(logits, labels):
# 类型转换为 tf.int64
labels = tf.cast(labels, tf.int64)
cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
logits=logits, labels=labels,
name='cross_entropy_per_example'
)
# 计算一个batch中交叉熵的均值
cross_entropy_mean = tf.reduce_mean(cross_entropy,
name='cross_entropy')
# 将交叉熵存在 losses的collection
tf.add_to_collection('losses', cross_entropy_mean)
return tf.add_n(tf.get_collection('losses'), name='total_loss')# 我们对图像进行数据增强的操作需要耗费大量CPU时间，因此distorted_inputs使用了16个
# 独立的线程来加速任务，函数内部会产生线程池，在需要使用时会通过queue进行调度。
# images_train, labels_train = cifar10_input.distorted_inputs(
# data_dir=data_dir, batch_size=batch_size
# )
images_train, labels_train = cifar10_input.distorted_inputs(
batch_size=batch_size
)# 生成测试数据，每次执行都会生成一个 batch_size 的数量的测试样本
# images_test, labels_test = cifar10_input.inputs(eval_data=True,
# data_dir=data_dir,
# batch_size=batch_size)images_test, labels_test = cifar10_input.inputs(eval_data=True,
batch_size=batch_size)
# 数据中图片的尺寸为24*24，即裁剪后的大小，而颜色的通道数则为3，代表RGB
image_holder = tf.placeholder(tf.float32, [batch_size, 24, 24, 3])
label_holder = tf.placeholder(tf.int32, [batch_size])# 第一个卷积层
# 第一层权重初始化，产生64个三通道（RGB图片），尺寸为5*5的卷积核，不带L2正则（w1=0）
weight1 = variable_with_weight_loss(shape=[5, 5, 3, 64], stddev=5e-2,
w1=0.0)
# 对输出原始图像进行卷积操作，步长为[1, 1, 1, 1]即将每一个像素点都计算到
kernel1 = tf.nn.conv2d(image_holder, weight1, [1, 1, 1, 1],
padding='SAME')
# 定义第一层的偏置参数，由于有64个卷积核，这里有偏置尺寸为64
bias1 = tf.Variable(tf.constant(0.0, shape=[64]))
# 卷积结果加偏置后采用relu激活
conv1 = tf.nn.relu(tf.nn.bias_add(kernel1, bias1))
# 第一层的池化操作，使用尺寸为3*3，步长为2*2 的池化层进行操作
# 这里的ksize和strides 第一个和第四个数字一般都是1
pool1 = tf.nn.max_pool(conv1, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],
padding='SAME')
# 用LRN对结果进行处理，使用比较大的值变得更大，比较小的值变得更小，模仿神经系统的侧抑制机制
norm1 = tf.nn.lrn(pool1, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75)# 第二个卷积层，上一层卷积核数量为64，所以本层卷积核尺寸的第三个维度也需调整64
# 这里bias值全部初始化为0.1，而不是0，最后调整了最大池化层和LRN层的顺序，先LRN层处理
weight2 = variable_with_weight_loss(shape=[5, 5, 64, 64], stddev=5e-2, w1=0.0)
kernel2 = tf.nn.conv2d(norm1, weight2, [1, 1, 1, 1], padding='SAME')
bias2 = tf.Variable(tf.constant(0.1, shape=[64]))
conv2 = tf.nn.relu(tf.nn.bias_add(kernel2, bias2))
norm2 = tf.nn.lrn(conv2, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75)
pool2 = tf.nn.max_pool(norm2, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],
padding='SAME')# 全连接层
# 将上面的输出结果展平，-1代表不确定多大
reshape = tf.reshape(pool2, [batch_size, -1])
# 得到数据扁平化后的长度
dim = reshape.get_shape()[1].value
# 建立一个隐含节点数为384的全连接层
weight3 = variable_with_weight_loss(shape=[dim, 384], stddev=0.04, w1=0.004)
bias3 = tf.Variable(tf.constant(0.1, shape=[384]))
local3 = tf.nn.relu(tf.matmul(reshape, weight3) + bias3)# 全连接层2，和之前很像，只不过其隐含节点数下降了一半，只有192个，其他超参数不变
weight4 = variable_with_weight_loss(shape=[384, 192], stddev=0.04, w1=0.004)
bias4 = tf.Variable(tf.constant(0.1, shape=[192]))
local4 = tf.nn.relu(tf.matmul(local3, weight4) + bias4)# 最后一层，先建立weight，其正态分布标准差为上一个隐含层的节点数的倒数，并且不计入L2正则
weight5 = variable_with_weight_loss(shape=[192, 10], stddev=1/192.0, w1=0.0)
bias5 = tf.Variable(tf.constant(0.0, shape=[10]))
# 注意这里，直接是网络的原始输出（即wx+b 的形式），没有加softmax激活
logits = tf.add(tf.matmul(local4, weight5), bias5)# 将logits节点和label_holder传入loss函数获得最终的loss
loss = loss(logits, label_holder)
#优化器依然选择 adam Optimizer 学习速率设置为1e-3
train_op = tf.train.AdamOptimizer(1e-3).minimize(loss)
# 关于tf.nn.in_top_k函数的用法见http://blog.csdn.net/uestc_c2_403/article/details/73187915
# tf.nn.in_top_k会返回一个[batch_size, classes(类别数)]大小的布尔型张量，记录是否判断正确
top_k_op = tf.nn.in_top_k(logits, label_holder, 1)# 创建默认的session，接着初始化全部模型参数
sess = tf.InteractiveSession()
tf.global_variables_initializer().run()# 启动图片数据增强的线程队列，这里一共使用了16个线程来进行加速
# 注意：如果不启动线程，后续的inference及训练的操作都是无法开始的
tf.train.start_queue_runners()for step in range(max_steps):
start_time = time.time()
# 获得一个batch的训练数据
image_batch, label_batch = sess.run([images_train, labels_train])
# 运行训练过程并获得一个batch的total_loss
_, loss_value = sess.run([train_op, loss],
feed_dict={image_holder: image_batch,
label_holder: label_batch})
# 记录跑一个batch所耗费的时间
duration = time.time() - start_time # 每10个batch输出信息
if step % 10 == 0:
# 计算每秒能跑多少个样本
examples_per_sec = batch_size / duration
# 计算每个batch需要耗费的时间
sec_per_batch = float(duration) format_str = ('step %d, loss=%.2f(%.1f examples/sec; %.3f sec/batch)')
print(format_str%(step, loss_value, examples_per_sec, sec_per_batch))num_examples = 10000
import math
num_iter = int(math.ceil(num_examples / batch_size))
true_count = 0
total_sample_count = num_iter * batch_size
step = 0
while step < num_iter:
image_batch, label_batch = sess.run([images_test, labels_test])
predictions = sess.run([top_k_op], feed_dict={
image_holder: image_batch, label_holder: label_batch
})
true_count += np.sum(predictions)
step += 1precision = true_count / total_sample_count
print('precsion @ 1 = %.3f' %precision)

step 0, loss=4.68(136.3 examples/sec; 0.939 sec/batch)
step 10, loss=3.66(187.9 examples/sec; 0.681 sec/batch)
step 20, loss=3.13(175.1 examples/sec; 0.731 sec/batch)
step 30, loss=2.83(181.5 examples/sec; 0.705 sec/batch)
step 40, loss=2.47(177.5 examples/sec; 0.721 sec/batch)
step 50, loss=2.25(185.2 examples/sec; 0.691 sec/batch)
step 60, loss=2.18(196.3 examples/sec; 0.652 sec/batch)
step 70, loss=2.12(191.3 examples/sec; 0.669 sec/batch)
step 80, loss=1.94(187.4 examples/sec; 0.683 sec/batch)
... ...
step 160, loss=1.86(206.4 examples/sec; 0.620 sec/batch)
step 170, loss=1.94(207.4 examples/sec; 0.617 sec/batch)
step 180, loss=1.85(209.8 examples/sec; 0.610 sec/batch)
... ...
step 310, loss=1.60(183.1 examples/sec; 0.699 sec/batch)
step 320, loss=1.57(193.3 examples/sec; 0.662 sec/batch)

import tensorflow as tfx = tf.constant([[1.,2.,3.],[4.,5.,6.]])
print(x) #Tensor("Const:0", shape=(2, 3), dtype=float32)
x = tf.reshape(x,[1,2,3,1])
print(x) #Tensor("Reshape:0", shape=(1, 2, 3, 1), dtype=float32)valid_pad = tf.nn.max_pool(x,[1,2,2,1],[1,2,2,1],padding='VALID')
same_pad = tf.nn.max_pool(x,[1,2,2,1],[1,2,2,1],padding='SAME')print(valid_pad) #Tensor("MaxPool:0", shape=(1, 1, 1, 1), dtype=float32)
print(same_pad) #Tensor("MaxPool_1:0", shape=(1, 1, 2, 1), dtype=float32)