Tensor flow 实战Google深度学习框架 笔记Code Part 深层神经网络

深层神经网络

线性模型的局限性

激活函数实现去线性化

a=tf.nn.relu(tf.matmul(x,w1)+biases1)
y=tf.nn.relu(tf.matmul(a,w2)+biases2)

经典损失函数

#计算交叉熵
cross_entropy=-tf.reduce_mean(
                  y_*tf.log(tf.clip_by_value(y,le-10,1.0)))

#tf.clip_by_value 样例
v=tf.constant（[1.0,2.0,3.0],[4.0,5.0,6.0]）
print tf.clip_by_value(v,2.5,4.5).eval()
#输出 [[2.5,2.5,3],[4.0,4.5,4.5]]

如果你有一个Tensor t，在使用t.eval()时，等价于：tf.get_default_session().run(t).

#tf.log()样例 对数计算
v = tf.constant([1.0,2.0,3.0])
print tf.log(v).eval()
#输出。。。。 

#将两个矩阵直接进行"*"操作 不是矩阵乘法 而是让矩阵的元素直接对应相乘
v1 = tf.constant([[1.0,2.0],[3.0,4.0]])
v2 = tf.constant([[5.0,6.0],[7.0,8.0]])

print (v1*v2).eval()
#输出[[5. 12.] [21. 32.]]

#矩阵乘法
print tf.matmul(v1，v2).eval()

#tf.reduce_mean函数样例  平均计算
v= tf.constant([[1.0,2.0,3.0],[4.0,5.0,6.0]])
print tf.reduce.mean(v).eval()
#输出3.5

#使用softmax回归之后的交叉熵损失函数
cross_entropy =tf.nn.softmax_cross_entropy_with_logits(y,y_)

#实现均方误差损失函数
mse = tf.reduce_mean(tf.square(y_-y))

自定义损失函数

#demo
loss=tf.reduce_sum(tf.select(tf.greater(v1,v2),(v1-v2)*a,(v2-v1)*b))

#tf.select 函数 tf.greater函数
v1 = tf.constant([1.0,2.0.3.0,4.0])
v2 = tf.constant([4.0,3.0,2.0,1.0])

sess = tf.InteractiveSession()
print tf.greater(v1,v2).eval()
#输出[False False True True]

print tf.select(tf.greater(v1,v2),v1,v2).eval()
#输出[4. 3. 3. 4. ]
sess.close()

#使用自己定义的损失函数
import tensorflow as tf

from numpy.random import RandomState
batch_size=8

x=tf.placeholder(tf.float32,shape=(None,2),name='x-input')
y_=tf.placeholder(tf.float32,shape=(None,1),name='y-input')

w1 =tf.Variable(tf.random_normal([2,1],stddev=1,seed=1))
y=tf.matmul(x,w1)

#定义预测多了和预测少了的成本

loss_less=10
loss_more=1
loss = tf.reduce_sum(tf.select(tf.greater(y,y_),(y-y_)*loss_
more,(y_-y)*loss_less))

train_step =tf.train.AdamOptimizer(0.001).minimize(loss)

rdm=RandomState(1)
dataset_size=128
X=rdm.rand(dataset_size,2)
#设置回归的正确值为两个输入的和加上一个随机量。之所以要加上一个随机量是为了加入#不可预测的噪音，否则不同的损失函数就意义不大了，因为不同损失函数都会在完全预测#正确的时候最低。一般来说噪音为一个均值维0的小量，所以这里的噪音设置
#维-0.05~0.05的随机数
Y=[[x1+x2+rdm.rand()/10-0.05]for(x1,x2) in  X]
#训练神经网络
with tf.Session() as sess:
      init_op=tf.initialize_all_variables()
      sess.run(init_op)
      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]})
                         print sess.run(w1)

神经网络优化算法(学习率的设置)

batch_size = n
#每次读取一小部分数据作为当前的训练数据来执行反向传播算法
x=tf.placeholder(tf.float32,shape=(batch_size,2),name='x-input')
y_=tf.placeholder(tf.float32,shape=(batch_size,1),name='y-input')

#定义神经网络结构和优化算法
loss...
train_step = tf.train.AdamOptimizer(0.001)minimize(loss)

#训练神经网络
with  tf.Session() as sess:
    #参数初始化
    ...
    #迭代的更新参数
     for i in range(STEPS):
            #准备batch_size个训练数据。一般将所有训练数据随机打乱之后再选可以得到
            #更好的优化效果
            current_x,current_y=...
            sess.run(train_step,feed_dict={x:current_x,y_:current_y})

#exponential_decay指数级的减小学习率
decayed_learning_rate=\
     learning_rate*decay_rate^(global_step/decay_steps)

global_step=tf.Variable(0)

#通过exponential_decay函数生成学习率
learning_rate=tf.train.exponential_decay(
    0.1,global_step,100,0.96,staircase=True)

#使用指数衰减学习率。在minimize
#函数中传入global_step将自动更新global_step参数，从而使得学习率也得到相应的更新
learning_step=tf.train.GradientDescentOptimizer(learning_rate)\
                        .minimize(...my loss...,global_step=global_step)

过拟合问题（正则化损失函数）

#带有L2正则化的损失函数定义
w=tf.Variable（tf.random_normal([2,1],stddev=1,seed=1))
y=tf.matmul(x,w)

loss=tf.reduce_mean(tf.square(y_-y)+
    tf.contrib.layers.l2_regularizer(lambda)(w)
        

weights =tf.constant([1.0,-2.0],[-3.0,4.0])
with tf.Session() as sess:
    #输出为（|1|+|-2|+|-3|+|4|）*0.5=5 其中0.5为正则化项的权重
    print sess.run(tf.contrib.layers.L1_regularizer(.5)(weights))
    #输出为（|1方|+|-2方|+|-3方|+|4方）/2*0.5=7.5
    #TensorFlow会将L2的正则化损失函数除以2使得求导得到的结果更加简洁
    print sess.run(tf.contrib.layers.l2_regularizer(.6)(weights))

通过集合计算一个5层神经网络带L2正则化的损失函数的计算方法

import tensorflow as tf

#获取一个神经网络边上的权重 并将这个权重的L2正则化损失加入名称为'losses'的集合中

def get_weight(shape,lamda):
        #生成一个变量
        var =tf.Variable(tf.random_normal(shape),dtype=tf.float32)
        #add_to_collection函数将这个新生成的变量的L2正则化损失项加入集合。
        #这个函数的第一个参数'losses'是集合的名字，第二个参数是要加入这个集合的内容
        tf.add_to_collection(
                'losses',tf.contrib.layers.l2_regularizer(lambda0)(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_dimonsion[0]

#通过一个循环来生成5层全连接的神经网络结构
for i in range（1,n_layers）
        #layer_dimonsion[i]为下一层的节点个数
        out_dimonsion=layer_dimonsion[i]
        #生成当前层中的权重的变量 ，并将这个变量的l2 正则化损失加入计算图上的集合
        weight =get_weight([in_dimonsion,out_dimonsion],0.001)
        bias=tf.Vriable(tf.constant(0.1,shape=[out_dimonsinon]))
        #使用Relu激活函数
        cur_layer=tf.nn.relu(tf.matmul(cur_layer,weight)+bias)
        #进入下一层之前将下一层节点数更新为当前层节点个数
        in_dimonsion =layer_dimonsion[i]

#在定义神经网络前向传播的同时已经将所有的l2正则化损失加入了图上的集合
#这里只需要计算刻画模型在训练数据上表现的损失函数
mse_loss =tf.recuce_mean(tf.square(y_-cur_layer))

#将均方误差函数加入损失集合
tf.add_to_collection('losses',mse_loss)

#get_collection返回一个列表 这个列表是所有这个集合中的元素 。 在这个样例中
#这些元素就是损失函数的不同部分 将它们加起来就可以得到最终的损失函数
loss=tf.add_n(tf.get_collection('losses'))

  滑动平均模型 使模型在测试数据上面更健壮

tensoflow中提供了tf.train.ExponentialMovingAverage来实现滑动平均模型