深度学习与TensorFlow实战（三）TensorFlow概述与神经网络

计算图：
Tensor表示张量，可以简单理解为多维数组，flow是张量之间通过计算相互转化的过程。TensorFlow每一个计算都是计算图上的一个节点，节点之间的边缘描述了计算之间的依赖关系。
张量：
多维数组，几阶张量就是几维数组，但是张量不像数组那样真正保存数字，它保存的是如何得到这些数字的计算过程。张量有三个属性：name（名字），shape（维度），type（类型）

add:0表示result这个张量是计算节点add输出的第一个结果（编号从0开始）
shape=（2,）表示一个一维数组，长度为2
dtype=float32表示浮点类型

会话session：
TensorFlow中使用会话来执行定义好的运算，使用时有两种模式：
1.需要明确调用会话生成函数和关闭会话函数

#创建一个会话
sess=tf.Session()
sess.run(...)
sess.close()

2.通过上下文管理器来使用会话

with tf.session() as sess:
     sess.run(...)

当默认的会话被指定后可以通过tf.Tensor.eval函数来计算一个张量的取值。

sess=tf.Seseeion()
with sess.as_default():
     print(result.eval())
#等同于下面
sess=tf.Session()
print(sess.run(result)
print(result.eval(session=sess))

神经网络参数：
指神经元线上的权重w，用变量表示，一般会先生成随机生成这些参数。
神经网络中常用的生成随机数/数组的函数有：
tf.random_normal() 生成正态分布随机数
tf.truncated_normal() 生成去掉过大偏离点的正态分布随机数
tf.random_uniform() 生成均匀分布随机数
tf.zeros 生成全0的数组
tf.ones 生成全1的数组
tf,fill 生成全定值数组
tf.constant 生成直接给定数组

举例:
1，w=tf.Variable(tf.randow_normal([2,3],stddev=2,mean=0,seed=1))，表示生成正态分布随机数，形成两行三列，标准差是2，均值是0，随机值种子是1.
2，w=random_uniform(shape=7,minval=0,maxval=1,dtype=tf.int32,seed=1)，表示从一个均值分布[minval maxval)中随机采样，定义域是左闭右开。
3，tf.zeros([3,2],int32)，tf.zeos([3,2],int32)，tf.fill([3,2],5)，tf.constan([3,2,1])
注意：如果随机种子去掉每次生成的随机数不一样
如果没有特殊要求，标准差、均值、随机种子是可以不写的

神经网络的搭建：
1、准备数据集，提取特征，作为输入喂给神经（NN）
2、搭建NN结构，从输入到输出（先搭建计算图，再用会话执行）
（NN前向传播算法——>计算输出）
3、大量特征数据喂给NN，迭代优化NN参数
（NN反向传播算法——>优化参数训练模型）
4，使用训练好的模型预测和分类

很多实际应用中，我们回先使用现有的成熟网络结构，喂人新数据，训练相应模型，判断是否能对喂人的新数据作出正确响应，再适当更改网络结构，反复迭代，让机器自动训练参数找出最优结构和参数。

前向传播：
就是搭建模型的计算过程，让模型具有推理能力，可以针对一组输入给出相应的输出。
举例：
假如生产一批零件，体积为x1，重量是x2，体积和体重就是我们选择的特征，把他们喂给神经网络，当体积和重量这组数组走过神经网络后会得到一个输出。

a11=x1*w11+x2*w21=0.29，同理得到a12=0.32，a13=0.38，Y=-0.015，这便实现了前向传播过程。

前向传播过程的TensorFlow描述：

#coding:utf-8
import tensorflow as tf
#定义输入和参数
x=tf.placeholder(tf.float32,shape(1,2)
w1=tf.Variable(tf.random_normal([2,3],stddve=1,seed=1))
w2=tf.Variable(tf.random_normal([3,1],stddve=1.seed=1))
#定义前向传播的过程
a=tf.matmul(x,w1)
y=tf.matmul(a,w2)
#用会话计算结果
with tf.Session() as sess:
     init_op=tf.global_variable_initializer()
     sess.run(init_op)
     print("喂给的数据"，sess.run(y,feed_dict={x:[[0.7,0.5],[0.1,0.3],[0.5,0.8]])

反向传播：
训练模型参数，在所有参数上用梯度下降，使NN模型在训练数据上的损失函数最小。
损失函数：计算得到的预测值y与已知答案y_的差距。
损失函数的计算有很多方法，均值误差MSE是比较常用的方法之一。
均方误差MSE：求前向传播计算结果与已知答案之差的平方再求平均。

用TensorFlow表示：
loss_mse=tf.reduce_mean(tf.square(y_-y))
反向传播训练方法：以减小loss值为优化目标，有梯度下降，momentum优化器，Adam优化器。
这三种优化方法用TensorFlow的函数表示：
train_step=tf.traim.GradientDescentOptimizer(learning.rate).minimize(loss)
train_step=tf.traim.MomentumOptimizer(learning.rate,momentum).minimize(loss)
train_step=tf.traim.AdaOptimizer(learning.rate).minimize(loss)
三种优化方法区别如下：
1，tf.traim.GradientDescentOptimizer()使用随机梯度下降算法，使参数沿着梯度的反方向，即总损失减小的方向移动，实现更新参数。

参数更新公式：

2，tf.traim.MomentumOptimizer()在更新参数时，利用了超参数，参数更新公式：

3，tf.traim.AdaOptimizer()是利用自适应学习率的优化算法，Adam算法和随机梯度下降算法不同。随机梯度下降算法保持单一的学习率更新所有的参数，学习率在训练过程并不会改变。而Adam算法通过计算梯度的一阶矩估计和二阶矩估计而为不同的参数设计独立的自适应性学习率。
学习率：决定每次参数更新的幅度。
优化器中都需要一个叫做学习率的参数，使用时，如果学习率过大会出现震荡不收敛的情况，如果学习率过下，会出现收敛速度慢的情况。我们可以选个较小的数值填入，0.01，0.001

进阶：反向传播参数推导过程

符号说明：

搭建神经网络的步骤：
1，导入模块，生成模拟数据集;
import
常量定义
生成数据集
2，前向传播：定义输入，输出，参数
x=
y_=
w1=
w2=
y=
3，反向传播：定义损失函数、反向传播方法
loss=
train_step=
4，生成会话，训练STEPS轮
with tf.session() as sess:
init_op=tf.global_variables_initialzier()
sess_run(init_op)
STEPS=3000
for i in range(STEPS):
start=
end=
sess.run(train_step,feed_dict:)

举例：代码展示
随机产生32组生产出的零件的体积和重量，训练3000轮，每500轮输出一次损失函数，

#coding:utf-8
#1导入模块,生成模拟数据集
import tensorflow as tf
import numpy as np

BATCH_SIZE=8
seed=23455

#基于seed产生随机数
rng=np.random.RandomState(seed)
#随机数返回32行2列的矩阵。表示32组体积和重量作为输入的数据集
X=rng.rand(32,2)
#从X这个矩阵中取出一行判断如果小于1给Y赋值1，如果不小于给Y赋值0
#作为输入数据集的标签（正确答案）
Y=[[int(x0+x1<1)] for (x0,x1) in X]
print("X:\n",X)
print("Y:\n",Y)
#2定义神经网络的输入，参数，和输出定义前向传播过程
x=tf.placeholder(tf.float32,shape=(None,2))
y_=tf.placeholder(tf.float32,shape=(None,1))

w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))
w2=tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))

a=tf.matmul(x,w1)
y=tf.matmul(a,w2)

#定义损失函数以及反向传播方法
loss=tf.reduce_mean(tf.square(y-y_))
train_step=tf.train.GradientDescentOptimizer(0.001).minimize(loss)
#train_step=tf.train.MomentumOptimizer(0.001,0.9).minimize(loss)
#train_step=tf.train.AdamOptimizer(0.001).minimize(loss)

#定义会话。训练STEPS轮
with tf.Session() as sess:
    init_op=tf.global_variables_initializer()
    sess.run(init_op)
    #输出目前未经训练的参数取值
    print("w1:\n",sess.run(w1))
    print("w2:\n",sess.run(w2))
    print("\n")

    #训练模型
    STEPS=10000
    for i in range(STEPS):
        start=(i*BATCH_SIZE)%32
        end=start+BATCH_SIZE
        sess.run(train_step,feed_dict={x:X[start:end],y_:Y[start:end]})
        if i%500==0:
            total_loss=sess.run(loss,feed_dict={x:X,y_:Y})
            print(("after%d train steps,loss on all data is %g"%(i,total_loss)))
    #输出训练后的参数值
    print("\n")
    print("w1\n",sess.run(w1))
    print("w2\n",sess.run(w2))

结果：