1、知识点
"""
基础知识：
1、神经网络(neural networks)的基本组成包括输入层、隐藏层、输出层。而卷积神经网络的特点在于隐藏层分为卷积层和池化层(pooling layer，又叫下采样层)
2、卷积层：通过在原始图像上平移来提取特征，每一个特征就是一个特征映射
a)提取特征：定义一个过滤器(也称观察窗口，奇数大小，值为权重)大小，步长
b)移动越过图片：
1、VALID：不越过，直接停止观察(一般不用)
2、SAME：直接越过，则对图像零填充(padding过程)
影响因素：窗口大小，步长，零填充，窗口数目 矩阵大小公式计算:
输入体积大小：H1*W1*D1
四个超参数：Filter数量K、Filter大小F、步长S、零填充大小P
输出体积大小 H2*W2*D2
H2=(H1-F+2P)/S+1 #如果有小数，要注意
W2=(W1-F+2P)/S+1
D2=K 卷积API:tf.nn.conv2d(input, filter, strides=, padding=, name=None)计算给定4-D input和filter张量的2维卷积
input：给定的输入张量，具有[batch,heigth,width,channel]，类型为float32,64 ，channel为图片的通道数，batch为图片的数量
filter：指定过滤器的大小，[filter_height, filter_width, in_channels, out_channels] ，其中，in_channels=channel ，out_channels为过滤器的数量
strides：strides = [1, stride, stride, 1],步长
padding：“SAME”, “VALID”，使用的填充算法的类型，使用“SAME”。其中”VALID”表示滑动超出部分舍弃，“SAME”表示填充，使得变化后height,width一样大 3、激活函数(Relu)，增加激活函数相当于增加了网络的非线性分割能力
1、机器学习使用：sigmoid ，公式：f(x) = 1/1+e^(-x)
2、深度学习使用：Relu ,公式为：f(x) = max(0,x)
3、API:tf.nn.relu(features, name=None)
features:卷积后加上偏置的结果
return:结果 4、池化层：通过特征后稀疏参数来减少学习的参数，降低网络的复杂度，（最大池化和平均池化）
1、池化计算矩阵大小公式和卷积一样
2、API:tf.nn.max_pool(value, ksize=, strides=, padding=,name=None)输入上执行最大池数
value:4-D Tensor形状[batch, height, width, channels]
ksize:池化窗口大小，[1, ksize, ksize, 1]
strides:步长大小，[1,strides,strides,1]
padding:“SAME”, “VALID”，使用的填充算法的类型，使用“SAME” 5、dropout:防止过拟合，直接使一些数据失效，小型网络用不到 6、不采用sigmoid函数作为激活函数的原因？
第一、采用sigmoid等函数，反向传播求取误差梯度时，计算量相对大，而采用Relu激活函数，震哥哥过程的计算节省很多
第二、对于深层网络，sigmoid函数反向传播时，很容易就会出现梯度消失等情况
7、tf.one_hot(indices,depth)
indices:数据集标签
depth:类别数 卷积神经网络实现流程：
1、准备数据
2、建立模型
a)准备数据占位符
b)卷积、激活、池化操作
c)全连接层，建立矩阵表达式
3、计算交叉熵损失
4、梯度下降求出损失
5、计算准确率
6、初始化变量
7、开始训练 手写字网络结构设计：
输入数据：[None，784] [None.10]
一卷积层：
卷积:32个filer,5*5 ,strides=1,padding="SAME" ,输入：[None,28,28,1] 输出：[None,28,28,32]
激活：输出 [None,28,28,32]
池化：2*2,strides=2,padding="SAME" 输出 [None,14,14,32]
二卷积层：
卷积：64个filer,5*5 ,strides=1,padding="SAME" ,输入：[None,14,14,32] 输出：[None,14,14,64]
激活:输出 [None,14,14,64]
池化: 2*2，strides=2 ,输出：[None,7,7,64]
全连接层：
形状改变：[None,7,7,64] -->[None,7*7*64]
权重：[7*7*10]
偏置：[10]
输出：[None,10]
输出：[3,5,7] -->softmax转为概率[0.04,0.16,0.8] ---> 交叉熵计算损失值 (目标值和预测值的对数)
"""
2、代码
# coding = utf-8
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data #定义一个初始化权重的函数
def weight_variables(shape):
w = tf.Variable(tf.random_normal(shape=shape,mean=0.0,stddev=1.0))
return w #定义一个初始化偏置的函数
def bais_variables(shape):
b = tf.Variable(tf.constant(0.0,shape=shape))
return b def model():
"""
自定义卷积模型
:return:
"""
#1、准备数据的占位符 x[None,784] y_true[None,10]
with tf.variable_scope("data"):
x = tf.placeholder(tf.float32,[None,784])
y_true = tf.placeholder(tf.int32,[None,10]) #2、一卷积层 卷积: 5*5*1，32个，strides=1 激活: tf.nn.relu 池化
with tf.variable_scope("conv1"):
#随机初始化权重，[5,5,1,32]--->5,5为过滤器大小，1为输入的图像通道数，32为过滤器的数量
w_conv1 = weight_variables([5,5,1,32])
b_conv1 =bais_variables([32])
#对x进行形状的改变[None,784] --->[None,28,28,1]
# 改变形状，不知道的参数填写-1
x_reshape= tf.reshape(x,[-1,28,28,1]) #strides=[1,1,1,1],表示上下左右移动步长都为1 [None, 28, 28, 1]-----> [None, 28, 28, 32]
x_relu1 = tf.nn.relu(tf.nn.conv2d(x_reshape,w_conv1,strides=[1,1,1,1],padding="SAME")+b_conv1) #池化 2*2 ,strides2 [None, 28, 28, 32]---->[None, 14, 14, 32]
x_pool1 = tf.nn.max_pool(x_relu1,ksize=[1,2,2,1],strides=[1,2,2,1],padding="SAME") #3、二卷积层
with tf.variable_scope("conv2"):
# 随机初始化权重, 权重：[5, 5, 32, 64] 偏置[64]
w_conv2 = weight_variables([5, 5, 32, 64])
b_conv2 = bais_variables([64]) # 卷积，激活，池化计算
# [None, 14, 14, 32]-----> [None, 14, 14, 64]
x_relu2 = tf.nn.relu(tf.nn.conv2d(x_pool1,w_conv2,strides=[1,1,1,1],padding="SAME")+b_conv2) # 池化 2*2, strides 2, [None, 14, 14, 64]---->[None, 7, 7, 64]
x_pool2 =tf.nn.max_pool(x_relu2,ksize=[1,2,2,1],strides=[1,2,2,1],padding="SAME") #4、全连接层 [None, 7, 7, 64]--->[None, 7*7*64]*[7*7*64, 10]+ [10] =[None, 10]
with tf.variable_scope("conv2"):
# 随机初始化权重,
w_fc = weight_variables([7*7*64, 10])
b_fc = bais_variables([10]) #修改形状[None, 7, 7, 64] --->None, 7*7*64]
x_fc_reshape = tf.reshape(x_pool2,[-1,7*7*64])
#进行矩阵运算，得出每个样本的10个结果
y_predict = tf.matmul(x_fc_reshape,w_fc)+b_fc ######收集和合并变量####
tf.summary.histogram("w1",w_conv1)
tf.summary.histogram("b1",b_conv1)
tf.summary.histogram("w2",w_conv2)
tf.summary.histogram("b2",b_conv2)
tf.summary.histogram("wfc",w_conv1)
tf.summary.histogram("bfc",b_conv1) merged =tf.summary.merge_all() return x,y_true,y_predict,merged def conv_fc():
# 获取数据
minist = input_data.read_data_sets("./data/mnist/input_data/", one_hot=True)
x,y_true,y_predict,merged = model() # 3、计算交叉熵损失
with tf.variable_scope("cross_entropy"):
# 求取平均交叉熵损失
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_true, logits=y_predict)) # 4、梯度下降求出损失
with tf.variable_scope("optimizer"):
train_op = tf.train.GradientDescentOptimizer(0.0001).minimize(loss) # 5、计算准确率
with tf.variable_scope("accuracy"):
equal_list = tf.equal(tf.argmax(y_true, 1), tf.argmax(y_predict, 1))
# equal_list None个样本 [1,0,1,1,0,0,0......]
accuracy = tf.reduce_mean(tf.cast(equal_list, tf.float32)) # 7、初始化变量
init_op = tf.global_variables_initializer() ##########收集变量#############
tf.summary.scalar("losses",loss)
tf.summary.scalar("accuracy",accuracy)
merged1 = tf.summary.merge_all()
with tf.Session() as sess:
sess.run(init_op)
fileWriter = tf.summary.FileWriter("./event/",graph=sess.graph)
for i in range(1000):
# 取出数据的特征自和目标值
mnist_x, mnist_y = minist.train.next_batch(50)
# 训练
sess.run(train_op, feed_dict={x: mnist_x, y_true: mnist_y}) summary = sess.run(merged,feed_dict={x: mnist_x, y_true:mnist_y})
summary1 = sess.run(merged1, feed_dict={x: mnist_x, y_true: mnist_y})
fileWriter.add_summary(summary,i)
fileWriter.add_summary(summary1, i) print("训练第%d步，准确率为：%f" % (i, sess.run(accuracy, feed_dict={x: mnist_x, y_true: mnist_y}))) return None if __name__ == "__main__":
conv_fc()
3、发展历程
4、卷积与池化输出矩阵维度计算公式
5、损失计算-交叉熵损失公式
6、SoftMax回归计算公式
7、激活函数-Relu
