本文共 6295 字，大约阅读时间需要 20 分钟。

深度学习有四个步骤：

准备数据  搭建模型   迭代训练   使用模型 

import tensorflow as tfimport numpy as np  #数组import matplotlib.pyplot as plt # matplotlib.pyplot 2D绘图库 类似MATLAB的一种绘图框架plotdata = { "batchsize":[], "loss":[] }    #存放批次值和损失值def moving_average(a, w=10):               if len(a) < w:         return a[:]        return [val if idx < w else sum(a[(idx-w):idx])/w for idx, val in enumerate(a)]#生成模拟数据train_X = np.linspace(-1, 1, 100) #train_X = np.linspace(-1, 1, 100) #生成-1~1之间的100个数作为x。train_Y = 2 * train_X + np.random.randn(*train_X.shape) * 0.3    #（a属于[-1,1]之间的随机数）train_Y = 2 * train_X + np.random.randn(*train_X.shape) * 0.3 # y=2x，但是加入了噪声#显示模拟数据点plt.plot(train_X, train_Y, 'ro', label='Original data')   #‘ro’代表红色实心圈标记plt.legend()  #显示图例label='Original data'plt.show()# 创建模型# 占位符X = tf.placeholder("float")Y = tf.placeholder("float")  #X代表输入,Y代表对应的真实值，都是占位符（占住一个固定的位置等着再往里面添加内容的符号）# 模型参数W = tf.Variable(tf.random_normal([1]), name="weight")b = tf.Variable(tf.zeros([1]), name="bias")  #W和b是参数，W被初始化为[-1,1]的随机数，形状为一维的数字，b的初始化为0，形状也是一维。# 前向结构z = tf.multiply(X, W)+ b#反向优化cost =tf.reduce_mean( tf.square(Y - z))learning_rate = 0.01  #学习率代表调整参数的速度。这个值一般小于1。值越大，代表调整的速度越大，但不精确。optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost) #GradientDescentOptimizer是封装好的梯度下降算法。# 初始化变量init = tf.global_variables_initializer()# 训练参数training_epochs = 20  #迭代次数display_step = 2# 启动sessionwith tf.Session() as sess:    sess.run(init)    # Fit all training data    for epoch in range(training_epochs):        for (x, y) in zip(train_X, train_Y):            sess.run(optimizer, feed_dict={X: x, Y: y})   #外层放循环次数通过sess.run来进行网络节点的运算，通过feed机制将真实数据灌到占位符对应的位置（feed_dict={X: train_X, Y:train_Y})同时没执行一次都会将网络结构中的节点打印出来        #显示训练中的详细信息        if epoch % display_step == 0:            loss = sess.run(cost, feed_dict={X: train_X, Y:train_Y})            print ("Epoch:", epoch+1, "cost=", loss,"W=", sess.run(W), "b=", sess.run(b))            if not (loss == "NA" ):   #是个安全检查，保证loss值有效才会将其用图示显示出来                plotdata["batchsize"].append(epoch)                plotdata["loss"].append(loss)    print (" Finished!")    print ("cost=", sess.run(cost, feed_dict={X: train_X, Y: train_Y}), "W=", sess.run(W), "b=", sess.run(b))    #print ("cost:",cost.eval({X: train_X, Y: train_Y}))    #图形显示    plt.plot(train_X, train_Y, 'ro', label='Original data')    plt.plot(train_X, sess.run(W) * train_X + sess.run(b), label='Fitted line')    plt.legend()    plt.show()        plotdata["avgloss"] = moving_average(plotdata["loss"])    plt.figure(1)  #plt.figure(1)是新建一个名叫 Figure1的画图窗口    plt.subplot(211)   #第一个画板的第一个子图    plt.plot(plotdata["batchsize"], plotdata["avgloss"], 'b--')  #plt.plot(x,c)是在画图窗口里具体绘制横轴为x 纵轴为c的曲线     ‘b--’为蓝色破折线    plt.xlabel('Minibatch number')    plt.ylabel('Loss')    plt.title('Minibatch run vs. Training loss')         plt.show()    print ("x=0.2，z=", sess.run(z, feed_dict={X: 0.2}))

学习速率对于梯度下降算法，这应该是一个最重要的超参数。如图所示，如果学习速率设置得非常大，那么训练可能不会收敛，就直接发散了；如果设置的比较小，虽然可以收敛，但是训练时间可能无法接受；如果设置的稍微高一些，训练速度会很快，但是当接近最优点会发生震荡，甚至无法稳定。不同学习速率的选择影响可能非常大。 理想的学习速率是：刚开始设置较大，有很快的收敛速度，然后慢慢衰减，保证稳定到达最优点。

下面记录一下各种函数的作用，有助于学习记忆python库和函数：

1.首先是linspace函数：numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None) 

返回（start，stop）间的num个数，endpoint为真sample必然有终点，为否必然没有终点，retstep表示一定步长，最后返回（sample，step）

2.np.random.randn : numpy.random.rand(d0, d1, ..., dn)

随机产生维度为（d0,d1...，dn）的随机数，从标准正态分布中产生。

　　但random.rand（d0,d1...，dn）产生数值取值范围是[0,1)

3.tf.placeholder : tf.placeholder(dtype,shape = None , name = None)

占位数，可以理解为变量，在需要的时候才去赋值

dtype 表示数据类型，例如tf.float32,tf.float64，shape表示数组形状,shape = None 表示一维数，还可以shape  =[3,4]，shape = [None,4]表示行未定。返回Tensor类型。

4.tf.Variable.int()

tf.Variable.init(initial_value, trainable=True, collections=None, validate_shape=True, name=None)

　　参数表引用相关资料：

5.tf.random_normal() : tf.random_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)

代码中仅用到shape=[1],表示一维数

6.tf.reduce_mean(input_tensor, reduction_indices=None, keep_dims=False, name=None) 求平均值

input_tensor:待求值的tensor。

reduction_indices:在哪一维上求解。

7.tf.train.GrandientDescentOptimizer(learning_rate)

产生一个规定学习率的优化器：optmizier = tf.train.GrandientDescentOptimizer(learning_rate = 0.01)

　　计算梯度并且直接作用于变量上：optimizer.minimize(cost , var_list = <list of variables>)

optimizer.run()

　　计算出梯度：gradients = optimizer.compute_gradients(loss , <list of variables>)

　　然后就可以根据自己的需要处理梯度了。

8.tf.global_variables_initializer()初始化所有Tensor变量的状态

init = tf.global_variables_initializer()

with tf.Session() as sess:

sess.run(init)

9.def moving_average(a, w=10):    

if len(a) < w:      

  return a[:]        

return [val if idx < w else sum(a[(idx-w):idx])/w for idx, val in enumerate(a)]

滑动平均模型 用途：用于控制变量的更新幅度，使得模型在训练初期参数更新较快，在接近最优值处参数更新较慢，幅度较小

方式：主要通过不断更新衰减率来控制变量的更新幅度.

在训练神经网络时，不断保持和更新每个参数的滑动平均值，在验证和测试时，参数的值使用其滑动平均值能有效提高神经网络的准确率。

第一个返回值是如果a向量的长度小于w的值，就输出向量a中的所有值。

第二个返回值是如果向量a的长度大于w值，将索引小于长度w的值直接输出，将索引大于w值的按照sum(a[(idx-w):idx])/w的方式进行计算输出。

在python中enumerate的用法多用于在for循环中得到计数，

enumerate参数为可遍历的变量，如 字符串，列表等； 返回值为enumerate类。

举个例子a=[a,b,c,d]

For idx,val in enumerate(a)   #idx为向量a的索引即下标

[0 a]    [1 b]    [2 c]    [3 d]

在python中enumerate的用法多用于在for循环中得到计数，

enumerate参数为可遍历的变量，如 字符串，列表等； 返回值为enumerate类。

tensorflow开发的基本步骤

1.定义输入节点的方法 2.定义学习参数的变量 3.定义运算 4.优化函数，优化目标 5.初始化所有变量 6.迭代更新参数到最优解 7.测试模型8. 使用模型

模型内部的数据流向

1 正向 ：数据从输入开始，依次进行各节点定义的运算，一直运算到输出，是模型最基本的数据流向。它直观地表现了网络模型的结构，在模型的训练、测试、使用场景中都会用到。这部分是必须要掌握的。

2 反向 ：只有在训练场景下会用到。这里使用了一个叫做反向链式求导的方法，即先从正向的最后一个节点开始，计算此时结果值与真实值的误差，这样会形成一个用学习参数表示误差的方程，然后对方程中的每个参数求导，得到其梯度修正值，同时反推出上一层的误差，这样就将该层节点的误差按照正向的相反方向传到上一层，并接着计算上一层的修正值，如此反复下去一步一步地进行转播，直到传到正向的第一个节点。 这部分原理TensorFlow已经实现好了，简单理解即可，应该把重点放在使用什么方法来计算误差，使用哪些梯度下降的优化方法，如何调节梯度下降中的参数（如学习率）问题上。

一个标准的模型结构分为输入、中间节点、输出三大部分，而如何让这三部分连通起来学习规则并可进行计算，则是框架TensorFlow所做的事情。

TensorFlow将中间节点及节点间的运算关系（OPS）定义在自己内部的一个“图”上，全通过一个“会话（session）”进行图中OPS的具体运算。

可以这样理解： “图”是静态的，无论做任何加、减、乘、除，它们只是将关系搭建在一起，不会有任何计算。 “会话”是动态的，只有启动会话后才会将数据流向图中，并按照图中的关系运算。并将最终的结果从图中流出。

TensorFlow用这种方式分离了计算的定义和执行，“图”类似施工图（blueprint），而会话更像施工地点。

构建一个完整的图一般需要定义3种变量。 输入节点：即网络的入口。 用于训练的模型参数（也叫学习参数）：是连接各个节点的路径。 模型中的节点（OP）：最复杂的就是OP。OP可以用来代表模型中的中间节点，也可以代表最终的输出节点，是网络中的真正结构。