基于TensorFlow的NN： 用张量表示数据，用计算图搭建神经网络，用会话执行计算图，优化线上的权重（参数），得到模型。
张量（Tensor）：多维数组（列表）
阶： 张量的维数

n阶 张量	名字及例子
0	标量，s=123
1	向量，v=[1,2,3]
2	矩阵，m=[[1,2,3],[4,5,6],[7,8,9]]
n	张量 ，t=[[[…n个

张量可以表示0阶到n阶数组（列表）

未来会常用vim编辑器，为了方便，我们先修改vim的配置文件：

vim ~/.vimrc写入：
set ts=4 使tab键等效为4个空格
set nu  使vim显示行号

TensorFlow的数据类型：tf.float32、tf.int32…

import tensorflow as tf  导入tensorflow模块
a = tf.constant([1.0,2.0])      定义常数
b=tf.constant([3.0,4.0])
result = a+b
print result

显示：

Tensor("add:0",shape=(2,),dtype=float32)
 表示：“节点名：第0个输出”，维度=一维数组长度为2，数据类型

结果截图：

计算图：（Graph）搭建神经网络的计算，只搭建，不运算（只描述运算过程）

y=XW=x1w1+x2w2

import tensorflow as tf
x = tf.constant([[1.0,2.0]])    两行一列
w=tf.constant([[3.0],[4.0]])    一行两列

y=tf.matmul(x,w)
print y

显示：

Tensor("matmul:0",shape(1,1),dtype=float32)  结果shape一行一列

结果截图：

以上得到的只是图，不是结果，如果想得到结果就要用到会话了。
会话：（Session）执行计算图中的节点运算。

with tf.Sessiion() as sess:
    print sess.run(y)     
   注：print前是四个空格

例如：

import tensorflow as tf
x = tf.constant([[1.0,2.0]])    两行一列
w=tf.constant([[3.0],[4.0]])    一行两列
y=tf.matmul(x,w)
print y
with tf.Session() as sess:
    print sess.run(y)   

结果截图：

若提示非程序的错误，可屏蔽，将TensorFlow的提示等级降低：

vim ~/.bashrc
进去后在尾部加上：   export TF_CPP_LOG_LEVEL=2
保存退出后：source ~/.bashrc   刚才的配置文件生效

**

前向传播

**
参数：线上权重，一般会先随机生成。

w=tf.Variable(tf.random_normal([2,3],stddev=2,mean=0,seed=1))
              正态分布 产生2 * 3矩阵   标准差为2   均值为0  随机种子

随机种子如果去掉，每次生成的随机数就不一致。
后三项如果没有特殊要求可以省略。

tf.truncated_normal()   去掉过大偏离值的正态分布（如果随机出来的数据偏离平均值超过两个标准差将会被重新生成）
tf.random_uniform()   平均分布
也可生成常数：
tf.zeros 全0数组   tf.zeros([3,2],int32)生成[[0,0],[0,0],[0,0]]
tf.ones 全1数组   tf.ones([3,2],int32)生成[[1,1],1,1],1,1]]
tf.fill 全定值数组  tf.fill([3,2],6)生成[6,6],[6,6].[6,6]
tf.constant 直接给值      tf.constant([3,2,1])

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

前向传播 ：输入进网络得到输出。
X是输入为1 * 2 的矩阵

a是第一层计算结果。
变量初始化、计算图节点运算都要用会话（with结构）实现

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

变量初始化：在sess.run函数中用tf.global_variables_initializer()

init_op = tf.gloabal_variables_initializer()
sess.run(init_op)

计算图节点运算：在sess.run函数中写入带运算的节点

sess.run(y)

用tf.placeholder占位，在sess.run函数中用feed_dict喂数据

喂一组数据
x = tf.placeholder(tf.float32,shape=(1,2))   两个输入特征
sess.run(y,feed_dict={x:[[0.5,0.6]]})

喂多组数据：
x = tf.placeholder(tf.float32,shape=(None,2))
sess.run(y,feed_dict={x:[[0.5,0.6]，[0.2,0.3],[0.3,0.4],[0.4,0.5]]})

举例
例1：

#coding:utf-8
#两层简单神经网络（全连接）
import tensorflow as tf

#定义输入和输出参数
x = tf.constant([[0.7,0.5]])
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)

#用会话计算结果
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    print"y in tf is:\n",sess.run(y)

结果截图：

例2：向神经网络喂入一组数据

#coding:utf-8
#两层简单神经网络（全连接）
import tensorflow as tf

#定义输入和输出参数
#用placeholder实现输入定义（sess.run中喂一组数据）
x = tf.placeholder(tf.float32,shape=(1,2))
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)

#用会话计算结果
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
       print"y in tf is:\n",sess.run(y,feed_dict={x:[[0.7,0.5]]})

结果截图：

例3：向神经网络喂入n组数据

#coding:utf-8
#两层简单神经网络（全连接）
import tensorflow as tf

#定义输入和输出参数
#用placeholder实现输入定义（sess.run中喂多组数据）
x = tf.placeholder(tf.float32，shape=(None,2))
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)

#用会话计算结果
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    print"result is:\n",sess.run(y,feed_dict={x:[[0.7,0.5],[0.2,0.3],[0.3,0.4],[0.4,0.5]]})
    print"w1:\n",sess.run(w1)
    print"w2:\n",sess.run(w2)

结果截图：

反向传播

反向传播 ：训练模型参数，在所有参数上梯度下降，使NN模型在训练数据上的损失函数最小。
损失函数：（loss）预测值y与已知答案y_的差距

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

反向传播训练方法：以减小loss值为优化目标

train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)
train_step = tf.train.MomentumOptimizer(learning_rate,momentum).minimize(loss)
train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss)

学习率：决定每次更新的幅度，先选比较小的值
举例：

#coding:utf-8
#0导入模块，生成模拟数据集
#numpy模块是python的科学计算模块
#BATCH是一次喂入神经网络多少数据，不宜过大
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这个32行2列的矩阵中取出一行，判断如果和小于1，给Y赋值1，如果和不小于1，给Y赋值0
#作为输入数据集的标签（正确答案）
Y = [[int(x0 + x1 < 1)] for (x0,x1) in X]
print "X:\n",X
print "Y:\n",Y

#1定义神经网络的输入、参数和输出，定义前向传播过程
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)

#2定义损失函数及反向传播方法
#均方误差计算loss
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)

#3生成会话，训练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 = 3000
     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 training steps,loss on all data is %g" % (i,total_loss))
     #输出训练后的权重
     print "\n"
     print "w1:\n",sess.run(w1)
     print "w2:\n",sess.run(w2)

结果截图：

搭建神经网络八股：准备、前传、反传、迭代
0、准备：import
常量定义
生成数据集
1、前向传播：定义输入、参数和输出

x=
y_=
w1=
w2=
a=
y=

2、反向传播：定义损失函数、反向传播方法

loss=
train_step=

3、生成会话，训练STEPS轮

with tf.Session() as sess:
     init_op = tf.global_variables_initializer()
     sess.run(init_op)
     STEPS = 3000
     for i in range(STEPS):
         start = 
         end = 
         sess.run(train_step,feed_dict：)