tensorflow 实战Google 深度学习框架（1）

最新推荐文章于 2021-12-23 11:28:47 发布

东东就是我

最新推荐文章于 2021-12-23 11:28:47 发布

阅读量241

点赞数

分类专栏：工程能力文章标签： tensorflow

本文链接：https://blog.csdn.net/qq_33228039/article/details/99847641

版权

工程能力专栏收录该内容

48 篇文章 2 订阅

订阅专栏

tensorflow游乐场：

http://playground.tensorflow.org/#activation=tanh&batchSize=10&dataset=circle&regDataset=reg-plane&learningRate=0.03&regularizationRate=0&noise=0&networkShape=4,2&seed=0.39804&showTestData=false&discretize=false&percTrainData=50&x=true&y=true&xTimesY=false&xSquared=false&ySquared=false&cosX=false&sinX=false&cosY=false&sinY=false&collectStats=false&problem=classification&initZero=false&hideText=false

第三章：

训练神经网络的过程分为三步骤：

1.定义神经网络的结构和前向传播的输出结果

2.定义损失函数以及选择反向传播优化的算法

3.生成会话，并且在训练数据上反复运行反向传播优化算法。

import tensorflow as tf
from numpy.random import RandomState

#定义训练数据的batch大小
batce_size=8
#定义神经网络的参数
w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))
w2=tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))
#输如输出变量占位符
x=tf.placeholder(tf.float32,shape=(None,2),name='x-input')
y_=tf.placeholder(tf.float32,shape=(None,1),name='y-input')
#定义神经网络前向传播过程
a=tf.matmul(x,w1)
y=tf.matmul(a,w2)
#定义损失函数和反向传播算法
y=tf.sigmoid(y)

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

train_step=tf.train.AdadeltaOptimizer(0.1).minimize(cross_entropy)
#通过随机数产生模拟的数据集
rdm=RandomState(1)
dataset_size=128
X=rdm.rand(dataset_size,2)
Y=[[int (x1+x2<1)]for (x1,x2) in X]
#变量初始化
init=tf.global_variables_initializer()
#创建一个会话来运行程序
with tf.Session() as sess:
    #初始化变量
    sess.run(init)
    print(sess.run(w1))
    print(sess.run(w2))
    #设置训练的次数
    STEPS=50000
    
    for i in range(STEPS):
        #每次选取batch个样本训练
        start=(i*batce_size) %dataset_size
        end=min(start+batce_size,dataset_size)
        #通过选取的样本训练神经网络并跟新参数
        sess.run(train_step,feed_dict={x:X[start:end],y_:Y[start:end]})
        #每隔一段时间输出所有数据上的交叉熵
        if i%1000==0:
            total_cross_entropy=sess.run(cross_entropy,feed_dict={x:X,y_:Y})
            print(i,total_cross_entropy)
    print(sess.run(w1))
    print(sess.run(w2))

第四章

1.分类问题

交叉熵：是为了判断输出向量和期望向量有多接近，交叉熵刻画了两个概率分布之间的距离，是分类问题中使用比较广泛的一种损失函数。

$H(p,q)=-\sum p(x)log(q(x))$

神经网络的输出不一定是一个概率分布，通过softmax回顾把输出变换城一个概率分布。

$softmax(y)_{i}=y_{i}^{'}=\frac{e^{y_{i}}}{\sum_{j=1}^{n}e^{y_{i}} }$

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

2.回归问题

均方误差（MSE)

$MSE(y,y^{'})=\frac{\sum_{i=1}^{n}(y_{i}-y_{i}^{'})^{2})}{n}$

mse=tf.reduce_mean(tf.square(y_-y))

3.自定义损失函数

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_mean(tf.where(tf.greater(y,y_),(y-y_)*loss_more,(y_-y)*loss_less))

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

rdm=RandomState(1)
dataset_size=128

X=rdm.rand(dataset_size,2)
Y=[[x1+x2+rdm.rand()/10.0-0.05] for (x1,x2) in X]
init=tf.global_variables_initializer()

with tf.Session() as sess:
    sess.run(init)
    
    STEPS=5000
    
    for i in range(STEPS):
        start=(i*batce_size)%dataset_size
        end=min(start+batce_size,dataset_size)
        print(start,end)
        sess.run(train_step,feed_dict={x: X[start:end],y_:Y[start:end]})
        print(sess.run(w1))

4. 学习率设置

global_step=tf.Variable(0)

#生成学习率
learning_rate=tf.train.exponential_decay(0.1,global_step,100,0.96,staircase=True)
#使用学习率
learning_step=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss,global_step=global_step)

5.过拟合

1.正则化

L1: $R(w)=\left \| w \right \|_{1}=\Sigma |w_{i}|$ 让参数变得稀疏（更多的参数为0），计算不可导

L2: $R(w)=\left \| w \right \|_{2}^{2}=\Sigma |w_{i}^{2}|$

L2+L1: $R(w)=\Sigma \alpha |w_{i}|+(1-\alpha )w_{i}^{2}$

weight=tf.constant([[1.0,-2.0],[-3.0,4.0]])
with tf.Session() as sess:
    #5.0
    print(sess.run(tf.contrib.layers.l1_regularizer(.5)(weight)))
    #7.5
    print(sess.run(tf.contrib.layers.l2_regularizer(.5)(weight)))
    #20.0
    print(sess.run(tf.contrib.layers.l1_l2_regularizer(.5)(weight)))

import tensorflow as tf
#获取一层神经网络的权重，把这个权重的L2正则化添加入名为losses的集合
def get_weight(shape,lambda1):
    #生成一个变量
    var=tf.Variable(tf.random_normal(shape),dtype=tf.float32)
    #加入集合中
    tf.add_to_collection('losses',tf.contrib.layers.l2_regularizer(lambda1)(var))
    return var

x=tf.placeholder(tf.float32,shape=(None,2))
print(x)
y_=tf.placeholder(tf.float32,shape=(None,1))
print(y_)
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):
    #layer_dimension[i]为下一层的节点个数
    out_dimension=layer_dimension[i]
    weight=get_weight([in_dimension,out_dimension],0.001)
    bias=tf.Variable(tf.constant(0.1,shape=[out_dimension]))
    #使用RULE
    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'))
print(loss)

6.滑动平均模型

import tensorflow as tf

#定义一个变量用于计算滑动平均，这个变量的初始值为0
v1=tf.Variable(0,dtype=tf.float32)
#模拟神经网络中迭代的轮数，可以用于动态控制衰减率
step=tf.Variable(0,trainable=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 到5
    sess.run(tf.assign(v1,5))
    #更新v1的滑动平均值
    sess.run(maintain_averages_op)
    print(sess.run([v1,ema.average(v1)]))
    
    #更新step为10000
    sess.run(tf.assign(step,100))
    #更新v1为10
    sess.run(tf.assign(v1,10))
    
    sess.run(maintain_averages_op)
    
    print(sess.run([v1,ema.average(v1)]))
    
    sess.run(maintain_averages_op)
    
    print(sess.run([v1,ema.average(v1)]))