基本概念
基于TensorFlow的神经网络：用张量表示数据，用计算图搭建神经网络，用会话执行计算图，优化线上的权重（参数），得到模型。
张量(tensor)：多维数组（列表）
阶：张量的维数
维数 阶 名字 例子
0-D 0 标量 scalar s=123
1-D 1 向量 vector v=[1,2,3]
2-D 2 矩阵 matrix m=[[1,2,3],[4,5,6],[7,8,9]]
n-D 3 张量 tensor t=[[[.........n个
张量可以表示0阶到n阶数组（列表）
数据类型：tf.float32 tf.int32 …
张量加法：
import tensorflow as tf
a = tf.constant([1.0 , 2.0]) #constant()代表定义常数
b = tf.constant([3.0 , 4.0])
result = a + b
print(result)
#结果显示：
Tensor("add:0", shape=(2,), dtype=float32)
| | | | |
节点名 第0个 维 一维 数据类型
输出 度 数组
长度2
计算图只描述了运算过程，不计算运算结果
计算图（Graph）:搭建神经网络的计算过程，只搭建，不运算。
会话（Senssion）：执行计算图中的节点运算。
with tf.Session() as sess:
print(sess.run(y))
TensorFlow不会自动生成默认的会话，需要手动指定
当默认的会话被指定之后可以通过tf.Tensor.eval函数来计算一个张量的取值
node1 = tf.constant(3.0, tf.float32, name="node1")
node2 = tf.constant(4.0, tf.float32, name="node2")
result = tf.add(node1, node2)
sess = tf.Session()
with sess.as_default():
print(result.eval())
下面代码也可以完成相同功能
node1 = tf.constant(3.0, tf.float32, name="node1")
node2 = tf.constant(4.0, tf.float32, name="node2")
result = tf.add(node1, node2)
sess = tf.Session()
#下面两个命令有相同的功能
print(sess.run(result))
print(result.eval(session=sess))
参数：即神经元线上的权重W，用变量表示，随机给初值。
w = tf.Variable(tf.random_normal([2,3] , stddev=2 , mean=0 , seed=1)) #tf.Variable() 生成随机数
| | | | |
正态分布 产生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]) #生成[3,2,1]
神经网络的实现过程：
1、准备数据集，提取特征，作为输入喂给神经网络
2、搭建NN结构，从输入到输出（先搭建计算图，再用会话执行）
（NN前向传播算法 --> 计算输出）
3、大量特征数据喂给NN，迭代优化NN参数
（NN反向传播算法 --> 优化参数训练模型）
4、使用训练好的模型预测和分类
一、前向传播 --> 搭建模型，实现推理（以全连接网络为例）
eg. 生产一批零件将体积X1和重量X2为特征输入NN，通过NN后输出一个数值。
变量初始化、计算图节点运算都要用会话（with结构）实现：
with tf.Session() as sess:
sess.run()
变量初始化：在sess.run函数中用tf.global_variables_initializer()
init_op = tf.global_variabes_initializer() #对所有变量初始化（赋初值）
sess.run(init_op)
计算图节点运算：在sess.run函数中写入待运算的节点
sess.run(y)
用tf.placeholder占位，在sess.run函数中用feed_dict喂数据
喂一组数据：
x = tf.placeholder(tf.float32 , shape=(1,2)) #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.1,0.2],[0.2,0.3],[0.3,0.4],[0.4,0.5]]})
二、反向传播 --> 训练模型参数，在所有参数上用梯度下降，使NN模型在训练数据上的损失函数最小
损失函数（loss）：预测值（y）与已知答案（y_）的差距
定义损失函数：
L1损失： 基于模型预测的值与标签的实际值之差的绝对值
L2损失： 又称 平方损失，一种常见的损失函数
均方误差MSE： 指的是每个样本的平均平方损失
loss = tf.reduce_mean(tf.square(y_-y))
反向传播训练方法：以减小loss值为优化目标
train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss) #梯度下降
train_step = tf.train.MomentumOptimize(learning_rate).minimize(loss) #Momentum优化器
train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss) #Adam优化器
训练模型的迭代方法
模型训练要点
1、首先要对权重w和偏置b进行初始猜测
2、然后反复调整这些猜测
3、直到获得损失可能最低的权重和偏置为止
梯度： 一个向量（矢量），表示某一函数在该点处的方向导数沿着该方向取得的最大值，即函数在该点处沿着该方向（此梯度的方向）变化最快，变化率最大。
梯度下降法： 沿着负梯度方向进行下一步探索
随机梯度下降： 在梯度下降法中，批量指的是用于在单次迭代中计算梯度的样本总数
定义优化器： 定义优化器Optimizer，初始化一个GradienDescentOptimizer
设置学习率和优化目标：最小化损失
train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss) #梯度下降
train_step = tf.train.MomentumOptimize(learning_rate).minimize(loss) #Momentum优化器
train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss) #Adam优化器
学习率：决定参数每次更新的幅度，梯度下降前进的步长
搭建神经网络：准备、前传、后传、迭代
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_initallzer()
sess_run(init_op)
STEPS=3000
for i in range(STEPS):
start=
end=
sess.run(train_step, feed_dict:)
神经网络搭建实例:
#coding：utf-8
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作为输入数据集的标签（正确答案） 人为给出零件的合格与否 1合格 0不合格
Y = [[int(x0 + x1 < 1)] for (x0,x1) in X]
#上面一行代码类似于下面
#for (x0,x1) in X:
# if x0+x1<1:
# Y=1
# else:
# Y=0
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)) #[2,3]中 2对应x 3表示隐藏层用3个神经元
w2 = tf.Variable(tf.random_normal([3,1], stddev=1, seed=1)) #[3,1]中 1对应y 3表示隐藏层用3个神经元
#前向传播过程描述
a = tf.matmul(x, w1)
y = tf.matmul(a, w2)
#2定义损失函数及反向传播方法。
loss = tf.reduce_mean(tf.square(y-y_)) #均方误差
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss) #梯度下降 学习率0.001
#train_step = tf.train.MomentumOptimize(0.001，0.9).minimize(loss) #Momentum优化器
#train_step = tf.train.AdamOptimizer(0.001).minimize(loss) #Adam优化器
#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 #训练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 step(s),loss on all data is %g" % (i, total_loss))
#输出训练后的参数取值
print("\n")
print("w1:\n",sess.run(w1))
print("w2:\n",sess.run(w2))
同时欢迎关注我的简书:https://www.jianshu.com/u/3dbb0292f6a4