基本概念

基于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