03.深层神经网络

一、深度学习与深层神经网络

1、线性模型有局限性

2、激活函数

常见的激活函数

tf.nn.relu

tf.nn.sigmoid

tf.nn.tanh

 

二、损失函数

交叉熵：用以表示两个分布之间的距离

由于损失函数用交叉熵表示所以输出应为不同分类之间的概率，SoftMax回归是一个非常常用的办法：

交叉熵代表用q来表示p的困难程度，q是预测值，p是正确值，交叉熵越小两个概率分布越接近。

 

实现交叉熵的代码：

cross_entropy=-tf.reduce_mean(y_*tf.log(tf.clip_by_value(y,1e-10,1.0)))

tf.clip_by_value(y,1e-10,1.0) 将张量中的数值限定在一个范围

y_*tf.log(tf.clip_by_value(y,1e-10,1.0))返回一个n*m的二维矩阵，n为batch中样例的数目，m为分类的类别数目

tf.reduce_mean()求矩阵平均

 

对于上述代码，tensorflow实现了封装：

cross_entropy=tf.nn.softmax_cross_entropy_with_logits(labels=y_,logits=y)

 

自定义损失函数

loss=tf.reduce_sum(tf.where(tf.greater(v1,v2),(vi-v2)*a,(v2-v1)*b))

 

反向传播：
train_step=tf.train.AdamOptimizer(0.001).minimize(loss)

 

训练过程：

STEPS=5000

for i in range(STEPS):

       start=(i*batch_size)%dataset_size;

       end=min(start+batch_size,dataset_size)

       sess.run(train_step,feed_dict={x:X[start,end],y_:Y[start,end]})

 

三、神经网络的优化算法

梯度下降法（不采用）：不一定达到全局最优解，只有当损失函数为凸函数是能够达到全局最优解。训练时间太长，每次要在全部数据上进行训练

 

随机梯度下降法（不采用）：每一次迭代随机优化某一条训练数据的损失函数，但可能无法达到全局最优，甚至无法达到局部最优

 

解决办法：每次计算一小部分数据的损失函数，这一小部分数据被称为一个batch，大大减小了迭代次数同时使收敛结果更加接近梯度下降的效果。

 

四、神经网络进一步优化

1、学习率的设置
指数衰减的方式设置梯度下降的学习率
learning_rate=tf.train.exponential_decay(0.1,global_step,100,0.96,staircase=True)
learn_step=tf.tain.CradientDescentOptimizer(learning_rate).minimize(...,global_step=global_step)

2、过拟合问题
常用方法：正则化

import tensorflow as tf

#获取一层神经网络边上的权重，并将这个权重的L2正则化损失加入名称为losses的集合中
def get_weight(shape,lambda):
	#生成一个变量
	var=tf.Variable(tf.random_normal(shape),dtype=tf.float32)
	tf.add_to_collection('losses',tf.contrib.layers.l1_regularizer(lambda)(var))
	return var

x=tf.placeholder(tf.float32,shape=(None,2))
y_=tf.placeholder(tf.float32,shape=(None,1))
batch_size=8
#定义每一层网络节点的个数
layer_dimension=[2,10,10,10,1]
#神经网络的层数
n_layers=len(layer_dimension)

#这个变量维护前向传播的最深层的节点，开始的时候就是输入层
cur_layer=x;
#当前层的节点数
in_dimension=layer_dimension[0]

#通过一个循环来生成5层全连接的神经网络结构
for i in range(1,n_layers):
	out_dimension=layer_dimension[i]
	weight=get_weight([in_dimension,out_dimension],0.001)
	bias=tf.Variable(tf.constant(0.1,shape=[out_dimension]))
	cur_layer=tf.nn.relu(tf.matmul(cur_layer,weight)+bias)
	in_dimension=layer_dimension[i]
	
mse_loss=tf.reduce_mean(tf.square(y_-cur_layer))

tf.add_to_collection('losses',mse_loss)
loss=tf.add_n(tf.get_collection('losses'))

3、滑动平均

import tensorflow as tf

#定义一个变量用于计算滑动平均
v1=tf.Variable(0,dtype=tf.float32)
step=tf.Variable(0,trainanle=False)

#------------定义一个滑动平均的类，初始化时给定衰减率和控制衰减的变量（step）
ema=tf.train.ExponentialMovingAverage(0.99,step)

maintain_averages_op=ema.apply([v1])#---------定义一个更新变量滑动平均的操作

with tf.Session() as sess:
	#初始化变量
	init_op=tf.global_variables_initializer()
	sess.run(init_op)
	
	print(sess.run([v1,ema.average(v1)]))#--------------------v1和滑动平均
	
	sess.run(tf.assign(v1,5))
	
	sess.run(maintain_averages_op)#-------------------------执行滑动平均操作
	print(sess.run([v1,ema.average(v1)]))#---------------输出v1和滑动平均值