一、神经网络实现过程

1、筹备数据集，提取特色，作为输出喂给神经网络
2、搭建 NN（Neural Network）构造，从输出到输入（先搭建计算图，在用会话执行）（NN 前向流传算法→计算输入）
3、大量特色数据喂给 NN，迭代优化 NN 参数（NN 反向流传算法→优化参数训练模型）
4、应用训练好的模型预测和分类

二、前向流传

参数 W 的维数为：前行后列（即后面一层的个数为 W 的行数 前面一层的个数为 W 的列数）

前向流传代码示例：

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'  #暗藏输入正告
import tensorflow as tf

#定义输出和参数用 placeholder 定义输出（sess.run 喂入一组或多组数据）#tf.Variable 示意生成随机数 shape(a, b)示意数据类型为 a 行 b 列
x = tf.placeholder(tf.float32,shape=(None, 2)) #多组数据的话应用 none 示意
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 构造）实现）with tf.Session() as sess:
#变量初始化
init_op = tf.global_variables_initializer()
#计算图节点运算：在 sess.run 函数中写入带运算的节点
sess.run(init_op) 
#用 tf.placeholder 在后面占位，在 sess.run 函数中用 feed_dict 喂入数据
print("the result of 前向流传 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:", sess.run(w1))
print("w2:", sess.run(w2))

三、反向流传

1、反向流传的作用：训练模型参数，在所有参数上用梯度降落办法，使 NN 模型在训练数据上的损失函数最小
2、损失函数（loss）：用于预测值(y) 和已知标准答案（y_）的差距
3、均方误差 MSE：可用 TensorFlow 的函数示意：loss = tf.reduce_mean(tf,square(y_ – y))
4、反向流传训练方法有三种：都是以减小 loss 值为优化指标

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)

5、学习率：决定参数每次更新的幅度

反向流传代码示例：

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import tensorflow as tf
import numpy as np   #numpy 是 Python 的科学计算模块
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 则赋值 0
#作为输出数据集的标签（正确答案）Y = [[int(x0 + x1 < 1)] for (x0, x1) in X]
print("X:", X)
print("Y:", 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 = tf.reduce_mean(tf.square(y-y_)) #应用均方误差计算 loss
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss) #应用梯度降落实现训练过程，minimize 示意向减小的方向优化
# 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:",sess.run(w1))
    print("w2:",sess.run(w2))
    print("n")
    #训练模型
 STEP = 3000
 for i in range(STEP):
        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))

四、损失函数

神经元模型的降级

神经网络中罕用的激活函数

1、NN 的优化指标：loss 最小（有三种办法）
第一种：mse（Mean Squared Error）均方误差：示意预测值与标准值之间的间隔
第二种：自定义

第三种：ce（Cross Entropy）穿插熵：示意两个概率分布之间的间隔

五、学习率

1、参数的变动过程

2、学习率大了震荡不收敛，小了收敛速度慢（解决办法：应用指数衰减学习率）

3、指数衰减代码示例

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
#设损失函数 loss = (w1 + 1)^2 令 w 初值为常数 5 反向流传就是求最优 w 即求最小 loss 对应的 w 值
#应用指数衰减的学习率，在迭代初期失去较高的降落速度，能够在较小的训练轮数下获得更有收敛度
import tensorflow as tf
LEARNING_RATE_BASE = 0.1 #最后的学习率
LEARNING_RATE_DECAY = 0.99 #学习率衰减率
LEARNING_RATE_STEP = 1 #喂入多少轮 BATCH_SIZE 后，更新一次学习率，个别设为：总样本数 /BATCH_SIZE
#运行了几轮 BATCH_SIZE 的计数器，初值给 0，设为不被训练
global_step = tf.Variable(0, trainable=False)
#定义指数降落学习率
learning_rate = tf.train.exponential_decay(LEARNING_RATE_BASE, global_step, LEARNING_RATE_STEP, LEARNING_RATE_DECAY, staircase=True)
#定义待优化参数，初值给 10
w = tf.Variable(tf.constant(5, dtype=tf.float32))
#定义损失函数 loss
loss = tf.square(w+1)
#定义反向流传办法
train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)
#生成会话，训练 40 轮
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    for i in range(40):
        sess.run(train_step)
        learning_rate_val = sess.run(learning_rate)
        globals_step_val = sess.run(global_step)
        w_val = sess.run(w)
        loss_val = sess.run(loss)
        print("After %s steps: global_step is %f,w is %f, learning rate is %f, loss is %f" %(i, globals_step_val, w_val, learning_rate_val, loss_val))

4、滑动均匀代码示例

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import tensorflow as tf
#1. 定义变量及滑动均匀类
#定义一个 32 位浮点变量，初值为 0.0 这个代码就是不断更新 w1 参数，优化 w1 参数，滑动均匀做了个 w1 的影子
w1 = tf.Variable(0, dtype=tf.float32)
#定义 num_updates(NN 的迭代轮次)，初始值为 0 时示意不可被优化（训练），这个参数不训练
global_step = tf.Variable(0, trainable=False)
# 实例化滑动均匀类，给衰减率为 0.99，以后轮数 global_step
MOVING_AVERAGE_DECAY = 0.99
ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
#apply 后的括号里是更行列表，每次运行 sess.run(ema_op)时，对更新列表中的元素求滑动平均值
#在理论利用中会应用 tf.trainable_variables()主动将多有待训练的参数汇总为列表
#ema_op = ema.apply([w21])
ema_op = ema.apply(tf.trainable_variables())
#查看不同迭代中变量取值的变动
with tf.Session() as sess:
    # 初始化
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    #用 ema.average(w1)获取 w1 滑动平均值（要运行多个节点，作为列表中的元素列出，写在 sess,run 中）#打印出以后参数 w1 和 w1 的滑动平均值
    print(sess.run([w1, ema.average(w1)]))
    #参数 w1 赋值为 1
    sess.run(tf.assign(w1, 1))
    sess.run(ema_op)
    print(sess.run([w1, ema.average(w1)]))
    #更新 step 和 w1 的值，模拟出 100 轮迭代后，参数 w1 变为 10
    sess.run(tf.assign(global_step, 100))
    sess.run(tf.assign(w1, 10))
    sess.run(ema_op)
    print(sess.run([w1, ema.average(w1)]))
    #每次 sess,run 会更新一次 w1 的滑动平均值
    sess.run(ema_op)
    print(sess.run([w1, ema.average(w1)]))
    sess.run(ema_op)
    print(sess.run([w1, ema.average(w1)]))
    sess.run(ema_op)
    print(sess.run([w1, ema.average(w1)]))
    sess.run(ema_op)
    print(sess.run([w1, ema.average(w1)]))
    sess.run(ema_op)
    print(sess.run([w1, ema.average(w1)]))
    sess.run(ema_op)
    print(sess.run([w1, ema.average(w1)]))

六、正则化

1、作用：避免模型过拟合，导致训练是正确率高，预测时正确率小的问题 蕴含正则化的模型曲线会比没有正则化的更加平滑

2、正则化示例代码

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
BATCH_SIZE = 30
seed = 2
# 基于 seed 产生随机数、rdm = np.random.RandomState(seed)
# 随机数返回 300 行 2 列的矩阵，示意 300 组坐标点（x0，x1）作为输出数据集
X = rdm.randn(300, 2)
# 从 x 这个 300 行 2 列的矩阵中取出一行，判断如果两个坐标的平方和小于 2，给 Y 赋值 1 相同则赋值 0
# 作为输出数据集的标签（正确答案）Y_ = [int(x0*x0 + x1*x1 < 2) for (x0, x1) in X]
# 遍历 Y 中的每个元素，1 赋值 red 其余赋值 blue，这样可视化显示时人能够直观辨别
Y_c = [['red' if y else 'blue'] for y in Y_]
# 对数据集 X 和标签 Y 进行 shape 整顿，第一个元素为 - 1 示意，随第二个参数计算失去，第二个元素示意多少列，吧 X 整顿为 n 行 2 列，把 Y 整顿为 n 行 1 列
X = np.vstack(X).reshape(-1, 2)
Y_ = np.vstack(Y_).reshape(-1, 1)
print(X)
print(Y_)
print(Y_c)
# 用 plt.scatter 画出数据集 X 各行中第 0 列元素和第 1 列元素的点即各行的（x0，x1），用各行 Y_c 对应的值示意色彩（c 是 color 的缩写）plt.scatter(X[:, 0], X[:, 1], c = np.squeeze(Y_c))
plt.show()
# 定义神经网络的输出、参数和输入，定义前向流传过程
# 生成 w 的函数
def get_weight(shape, reularizer):
    w = tf.Variable(tf.random_normal(shape), dtype=tf.float32)
    tf.add_to_collection('losses', tf.keras.regularizers.l2(reularizer)(w)) # TensorFlow 高版本中 contrib.l2 没有了，故应用 Keras 来进行正则化
 return w
# 生成偏执值 b 的函数
def get_bias(shape):
    b = tf.Variable(tf.constant(0.01, shape = shape))
    return b
x = tf.placeholder(tf.float32, shape=(None, 2))
y_ = tf.placeholder(tf.float32, shape=(None, 1))
# 第一层
w1 = get_weight([2, 11], 0.01) # ([行数，列数], 权重)
b1 = get_bias([11])
y1 = tf.nn.relu(tf.matmul(x, w1)+b1)
# 第二层
w2 = get_weight([11, 1], 0.01)
b2 = get_bias([1])
y = tf.matmul(y1, w2)+b2 # 输入层不过激活
# 定义损失函数
loss_mse = tf.reduce_mean(tf.square(y - y_)) # 均方误差的损失函数
loss_total = loss_mse + tf.add_n(tf.get_collection('losses'))# 均方误差的损失 + 正则化 w 的损失
# 定义反向流传办法：不含正则化
train_step = tf.train.AdamOptimizer(0.0001).minimize(loss_mse) # 应用 AdamOptimizer 优化器进行优化
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    STEP = 20000
 for i in range(STEP):
        start = (i*BATCH_SIZE) % 300
 end = start + BATCH_SIZE
        sess.run(train_step, feed_dict={x:X[start:end], y_:Y_[start:end]})
        if i % 2000 == 0:
            loss_mse_v = sess.run(loss_mse, feed_dict={x:X, y_:Y_})
            print("After %d steps, loss is :%f" %(i, loss_mse_v))
    # xx 在 - 3 到 3 之间以步长为 0.01，yy 在 - 3 到 3 之间以步长 0.01，生成二位网格坐标点
 xx, yy = np.mgrid[-3:3:0.1, -3:3:0.1]
    # 将 xx, yy 拉直，并合并成一个 2 列的矩阵，失去一个网格坐标点的汇合
 grid = np.c_[xx.ravel(), yy.ravel()]
    # 件网格坐标点喂入神经网络，probs 输入
 probs = sess.run(y, feed_dict={x:grid})
    # probs 的 shape 调整成 xx 的样子
 probs = probs.reshape(xx.shape)
    print("w1 :n",sess.run(w1))
    print("b1 :n", sess.run(b1))
    print("w2 :n", sess.run(w2))
    print("b2 :n", sess.run(b2))
plt.scatter(X[:, 0], X[:, 1], c = np.squeeze(Y_c))
plt.contour(xx, yy, probs, levels=[.5])
plt.show()
# 定义反向流传办法：蕴含正则化
train_step = tf.train.AdamOptimizer(0.0001).minimize(loss_total) # 应用 AdamOptimizer 优化器进行优化
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    STEP = 20000
 for i in range(STEP):
        start = (i*BATCH_SIZE) % 300
 end = start + BATCH_SIZE
        sess.run(train_step, feed_dict={x:X[start:end], y_:Y_[start:end]})
        if i % 2000 == 0:
            loss_mse_v = sess.run(loss_mse, feed_dict={x:X, y_:Y_})
            print("After %d steps, loss is :%f" %(i, loss_mse_v))
    # xx 在 - 3 到 3 之间以步长为 0.01，yy 在 - 3 到 3 之间以步长 0.01，生成二位网格坐标点
 xx, yy = np.mgrid[-3:3:0.1, -3:3:0.1]
    # 将 xx, yy 拉直，并合并成一个 2 列的矩阵，失去一个网格坐标点的汇合
 grid = np.c_[xx.ravel(), yy.ravel()]
    # 件网格坐标点喂入神经网络，probs 输入
 probs = sess.run(y, feed_dict={x:grid})
    # probs 的 shape 调整成 xx 的样子
 probs = probs.reshape(xx.shape)
    print("w1 :n",sess.run(w1))
    print("b1 :n", sess.run(b1))
    print("w2 :n", sess.run(w2))
    print("b2 :n", sess.run(b2))
plt.scatter(X[:, 0], X[:, 1], c = np.squeeze(Y_c))
plt.contour(xx, yy, probs, levels=[.5])
plt.show()