一、神经网络实现过程

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()