卷积，池化，全连接

TensorFlow的constant与Varialbe

tf.constant

• 常量

tf.zeros(shape, dtype, name)
tf.zeros_like(tensor, dtype, name)
tf.ones(shape, dtype, name)
tf.ones_like(tensor, dtype, name)
tf.constant(value, dtype, shape, name)
tf.fill(dims, value, name)

• 序列

tf.range(start, limit, delta=1, name='range')
tf.linspace(start, stop, num, name=None)

• 随机数

tf.random_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)
tf.truncated_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)
tf.random_uniform(shape, minval=0.0, maxval=1.0, dtype=tf.float32, seed=None, name=None)
tf.random_shuffle(value, seed=None, name=None)
tf.random_crop(value, size, seed=None, name=None)
tf.multinomial(logits, num_samples, seed=None, name=None) 
tf.random_gamma(shape, alpha, beta=None, dtype=tf.float32, seed=None, name=None)

tf.Varialbe

x = tf.Variable()
x.initializer()        # 初始化单个变量
x.value()              # 读取op
x.assign()             # 写入op
x.assign_add()         # 更多op
x.eval()               # 输出变量内容

CNN卷积神经网络原理

机器识别一张图像的原理简单可以理解是十字绣的逆向操作。是先将图像分割，然后提取分割后的小图的特征，再将特征汇总后与标签对比完成识别。

1. 卷积层初步提取特征
2. 池化层提取主要特征
3. 全连接层将各部分特征汇总
4. loss函数和优化算法

卷积（核心）

卷积实质上是对信号进行滤波，提取有效信息。
卷积的物理意义：一个函数（如：单位响应）在另一个函数（如：输入信号）上的加权叠加。

卷积层的作用其实就是通过不断的改变卷积核，来确定能初步表征图片特征的有用的卷积核是哪些，再得到与相应的卷积核相乘后的输出矩阵

卷积运算就是一个加权求和的过程

卷积核：卷积运算使用的加权矩阵

常用卷积模板

• 低通滤波器
  边缘平滑，边缘区域将被平滑过渡。

[[1, 1, 1], [1, 1, 1], [1, 1, 1]]
[[1, 1, 1], [1, 2, 1], [1, 1, 1]]
[[1, 2, 1], [2, 4, 2], [1, 2, 1]]

• 高通滤波器
  边缘提取与增强。边缘区域的灰度变换加大，也就是频率较高。所以，对于高通滤波，边缘部分将被保留，非边缘部分将被过滤；

[[0, -1, 0], [-1, 5, -1], [0, -1, 0]]
[[-1, -1, -1], [-1, 9, -1], [-1, -1, -1]]
[[1, -2, 1], [-2, 4, -2], [1, -2, 1]]

• 平移和差分边缘检测

[[0, 0, 0], [-1, 1, 0], [0, 0, 0]]
[[0, -1, 0], [0, 1, 0], [0, 0, 0]]
[[-1, 0, 0], [0, 1, 0], [0, 0, 0]]

• 匹配滤波边缘检测

[[-1, -1, -1, -1, -1], [0, 0, 0, 0, 0], [1, 1, 1, 1, 1]]
[[-1, 0, 1], [-1, 0, 1], [-1, 0, 1], [-1, 0, 1], [-1, 0, 1]]

• 边缘检测

[[-1, 0, -1], [0, 4, 0], [-1, 0, -1]]
[[-1, -1, -1], [-1, 8, -1], [-1, -1, -1]]
[[1, -2, 1], [-2, 4, -2], [1, -2, 1]]

• 梯度方向边缘检测

[[1, 1, 1], [1, -2, 1], [-1, -1, -1]]
[[1, 1, 1], [-1, -2, 1], [-1, -1, 1]]
[[-1, 1, 1], [-1, -2, 1], [-1, 1, 1]]
[[-1, -1, 1], [-1, -2, 1], [1, 1, 1]]

矩阵的卷积运算

1. 卷积核旋转180度
   实现方法一：卷积核中心旋转180度
   实现方法二：沿两条对角线分别翻转两次
   实现方法三：同时翻转行和列
2. 翻转后的卷积核中心对准待处理矩阵第一个元素，对应位置相乘后相加，没有元素的地方补0
3. 得到输出矩阵，即卷积结果

卷积层输出值越高，就说明匹配程度越高，越能表现该图片的特征。

扩展：
图像卷积————实现图像处理的数学运算方法
图像卷积的意义，处理图像色值通道产生特征图谱。减少无用噪声数据的影响，卷积神经网络训练过程中，根据数据的特征会反馈更新卷积核的值，使其在特征图谱的滤波工作越来越好。

图像滤波————抽出对象的特征作为图像识别的特征模式，消除图像数字化时所混入的噪声
在尽量保留图像细节特征的条件下对目标图像的噪声进行抑制，可能是低频，也可能是高频

图像平滑————实际上就是低通滤波
压制、弱化或消除图像中的细节、突变、边缘和噪声,就是图像平滑化。图像平滑是对图像作低通滤波,可在空间域或频率域实现。空间域图像平滑方法主要用低通卷积滤波、中值滤波等；频率域图像平滑常用的低通滤波器有低通梯形滤波器、低通高斯滤波器、低通指数滤波器、巴特沃思低通滤波器等。

池化

池化层的输入就是卷积层输出的原数据与相应的卷积核相乘后的输出矩阵
池化层的目的：

1. 减少训练参数的数量，降低卷积层输出的特征想了
2. 减小过拟合现象，减少噪声传递，最大化保留图片有效信息

常见的池化形式

1. 最大池化
   取池化窗口矩阵内的最大值作为池化输出
2. 均值池化
   取池化窗口矩阵内的平均值作为池化输出

全连接

卷积层和池化层的工作就是提取特征，并减少原始图像带来的参数。为了生成最终的输出，我们需要应用全连接层来生成一个分类器。

全连接层的工作原理是把池化层输出的张量重新切割成一些向量，乘上权重矩阵，加上偏置值，然后对其使用ReLU激活函数，再用梯度下降法优化参数。

#!/usr/bin/env python3
# -*- encoding:utf-8 -*-

from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf


def weight_variable(shape):
    # 产生随机变量
    # truncated_normal：选取位于正态分布均值=0.1附近的随机值，如果随机数偏离均值超过2个标准差，就重新随机
    # random_normal：正态分布
    # random_uniform：平均分布
    # random_gamma：gamma分布
    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):
    # stride = [1,水平移动步长,竖直移动步长,1]
    # 输入x是图片信息矩阵，W是卷积核的值
    # padding的可选参数为“VALID”和“SAME”
    # VALID不用0来填充边界，新图像尺寸大小 = 原数据尺寸大小-卷积核尺寸大小+1
    # SAME边界补0，新图像尺寸大小 = 原数据尺寸大小
    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')


def max_pool_2x2(x):
    # stride = [1,水平移动步长,竖直移动步长,1]
    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
                          strides=[1, 2, 2, 1], padding='SAME')


# 读取MNIST数据集
mnist = input_data.read_data_sets('./input_data', one_hot=True)
sess = tf.InteractiveSession()

# 预定义输入值X、输出真实值Y    placeholder为占位符
# 748 = 28*28
x = tf.placeholder(tf.float32, shape=[None, 784])
y_ = tf.placeholder(tf.float32, shape=[None, 10])
# keep_prob 是为了减小过拟合现象。每次只让部分神经元参与工作使权重得到调整。只有当keep_prob = 1时，才是所有的神经元都参与工作
keep_prob = tf.placeholder(tf.float32)
x_image = tf.reshape(x, [-1, 28, 28, 1])
# print(x_image.shape)  #[n_samples,28,28,1]

# 卷积层1网络结构定义
# 卷积核1：patch=5×5;in size 1;out size 32;激活函数reLU非线性处理
W_conv1 = weight_variable([5, 5, 1, 32])
b_conv1 = bias_variable([32])
# output size 28*28*32
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
# output size 14*14*32
h_pool1 = max_pool_2x2(h_conv1)

# 卷积层2网络结构定义
# 卷积核2：patch=5×5;in size 32;out size 64;激活函数reLU非线性处理
W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)  # output size 14*14*64
h_pool2 = max_pool_2x2(h_conv2)  # output size 7 *7 *64

# 全连接层1
W_fc1 = weight_variable([7 * 7 * 64, 1024])
b_fc1 = bias_variable([1024])
h_pool2_flat = tf.reshape(h_pool2, [-1, 7 * 7 * 64])  # [n_samples,7,7,64]->>[n_samples,7*7*64]
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)  # 减少计算量dropout

# 全连接层2
# 全连接层2有10个神经元，相当于生成的分类器，预测值存入prediction中
W_fc2 = weight_variable([1024, 10])
b_fc2 = bias_variable([10])
prediction = tf.matmul(h_fc1_drop, W_fc2) + b_fc2
# prediction = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)

# 二次代价函数:预测值与真实值的误差
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(labels=y_, logits=prediction))
# 梯度下降法:数据太庞大,选用AdamOptimizer优化器
train_step = tf.train.AdamOptimizer(1e-4).minimize(loss)
# 结果存放在一个布尔型列表中
correct_prediction = tf.equal(tf.argmax(prediction, 1), tf.argmax(y_, 1))
# 求准确率
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

saver = tf.train.Saver()  # defaults to saving all variables
sess.run(tf.global_variables_initializer())

for i in range(1000):
    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", i, "training accuracy", train_accuracy)
    train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})


# 保存模型参数
saver.save(sess, './model.ckpt')
print("test accuracy %g"%accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))