记6（人工神经网络

1、M-P神经元
2、感知机
3、Delta法则
4、前馈型神经网络（Feedforward Neural Networks）
5、鸢尾花数据集——单层前馈型神经网络：
6、多层神经网络：增加隐含层
7、实现异或运算（01、10为1,00、11为0）
8、线性不可分问题
9、万能近似定理
10、超参数与验证集
11、误差反向传播算法（Backpropagation, BP）

1、M-P神经元

M-P神经元：1943，McCulloch，Pitts
x1,x2,x3…模拟神经元的树突，接受信号，wi表示权重，对输入xi加权求和后与θ比较得到z，再传入阶跃函数得到输出y。但是不具备学习能力。

2、感知机

模型和上图一样，输入层xi不需要计算，只有输出层发生计算，层数只有一层。
具备学习能力，有多个解，受权值初始值和错误样本顺序影响。
线性二分类器，对非线性问题无法收敛。

在这里插入图片描述
单个感知机实现二分类问题，多个感知机（就是多个输出）能实现多分类问题（就是前面所说的softmax回归）：

3、Delta法则

就是前面的逻辑回归，用step()函数或sigmoid()函数，逻辑回归可以看做是单层神经网络

4、前馈型神经网络（Feedforward Neural Networks）

每层只与前一层神经元相连；同一层之间没有连接；各层间没有反馈，不存在跨层连接
全连接网络（Full Connnected Network）：前一层（左边）的节点都与后一层（右边）的节点连接，且后一层的节点都接受来自前一层的所有输入。

5、鸢尾花数据集——单层前馈型神经网络：

设计：

结构：单层前馈型神经网络
激活函数：softmax函数；
损失函数：交叉熵损失函数；

实现：如下图，输入是训练集的120条数据，含4条属性/数据，输出是3个标签（独热编码表示为1*3向量），将之前的模型参数W（Y=WX)的第一行参数分离出来，即Y=WX+B（以便实现多层神经网络时更加方便直观）。使用独热编码（见上一篇笔记）

softmax函数：tf.nn.softmax(tf.matmul(X_train,W)+b)
自然顺序码转化为独热编码（需要先转换为浮点数）：tf.one_hot(tf.constant(y_test,dtype=tf.int32),3)
交叉熵损失函数：tf.keras.losses.categorical_crossentropy(y_true,y_pred)
y_true：独热编码的标签值
y_pred：softmax函数的输出值
输出是一个一维张量，其中的每个元素是每个样品的交叉熵损失，因此需要用求平均值函数
设置运行时分配显存（如果出现错误：Blast GEMMlaunch failed:)：

gpus=tf.config.experimental.list_physical_devices('GPU')
for gpu in gpus:
    tf.config.experimental.set_memory_growth(gpu,True)

返回张量最大值的索引：tf.argmax(input_tensor,axis=0)（见TensorFlow笔记3）

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
#读取文件，详见Python笔记10
train_path=tf.keras.utils.get_file("iris.csv", origin=None)   #获取文件的绝对路径
df_iris=pd.read_csv(train_path,header=0)        #结果是panda的二维数据表
iris=np.array(df_iris)        #将二维数据表类型转化为二维数组类型，shape=(150,6)，与视频中不一样，索引号为0的是序号
x=iris[:,1:5]         #索引号1~4列属性：花瓣长度和宽度,x.shape=(150, 2)
y=iris[:,5]          #train_y.shape=(150,)

x_svv=np.concatenate((np.stack(x[y=='setosa']),  #选取2种花，以及其前2种属性
                     np.stack(x[y=='versicolor']),
                     np.stack(x[y=='virginica'])),axis=0)
y_svv=np.concatenate((np.zeros(np.where(y=='setosa')[0].size),   #元组只有一个元素（数组）
                     np.ones(np.where(y=='versicolor')[0].size),
                     2*np.ones(np.where(y=='virginica')[0].size),),axis=0)

np.random.seed(612)
iris_rand=np.concatenate((x_svv,np.expand_dims(y_svv,axis=1)),axis=1)
np.random.shuffle(iris_rand)        #打乱数组，并选前面120条数据为训练集，后面30条做测试集
x_train=tf.constant(iris_rand[:120,0:4],dtype=tf.float32)       #转化为float32张量
y_train=tf.constant(iris_rand[:120,4],dtype=tf.int64)           #转化为int32张量
x_test=tf.constant(iris_rand[120:,0:4],dtype=np.float32)
y_test=tf.constant(iris_rand[120:,4],dtype=tf.int64)

X_train=x_train-tf.reduce_mean(x_train,axis=0)      #中心化, x_train.dtype=dtype('O')，是object
X_test=x_test-tf.reduce_mean(x_test,axis=0)
Y_train=tf.one_hot(y_train,3)                       #转化为独热编码Y_train.shape=TensorShape([120, 3])
Y_test=tf.one_hot(y_test,3)

learn_rate=0.5                                  #超参数——学习率
iter=50                                         #迭代次数
display_step=10                                 #设置每迭代10次输出结果，方便查看
np.random.seed(612)
W=tf.Variable(np.random.randn(4,3),dtype=tf.float32)    #W列向量，4行3列
B=tf.Variable(np.zeros([3]),dtype=tf.float32)           #B列向量，长度为3的一维张量

cce_train=[]       #保存交叉熵损失
cce_test=[]
acc_train=[]      #保存准确率
acc_test=[]

#训练模型
for i in range(0,iter+1):
    with tf.GradientTape() as tape:
        #softmax函数,PRED_train是120*3的张量，每行3个元素表属于某个样品的预测概率
        PRED_train=tf.nn.softmax(tf.matmul(X_train,W)+B)    #shape=TensorShape([120, 3])
        Loss_train=tf.reduce_mean(tf.keras.losses.categorical_crossentropy(y_true=Y_train, y_pred=PRED_train))

    PRED_test=tf.nn.softmax(tf.matmul(X_test,W)+B)
    Loss_test=tf.reduce_mean(tf.keras.losses.categorical_crossentropy(y_true=Y_test, y_pred=PRED_test))

    #准确率,求PRED_train的每一行3个元素的max，即属于对应标签的概率最大，再与真实值y_train比较，求得准确率
    Accuracy_train=tf.reduce_mean(tf.cast(tf.equal(tf.argmax(PRED_train,axis=1),y_train),tf.float32))
    Accuracy_test=tf.reduce_mean(tf.cast(tf.equal(tf.argmax(PRED_test,axis=1),y_test),tf.float32))   
    cce_train.append(Loss_train)
    cce_test.append(Loss_test)
    acc_train.append(Accuracy_train)
    acc_test.append(Accuracy_test)
    
    grads=tape.gradient(Loss_train,[W,B])
    W.assign_sub(learn_rate*grads[0])       #dL_dW
    B.assign_sub(learn_rate*grads[1])       #dL_dB
    
    if i%display_step==0:
        print("i:%i,\tTrainAcc:%f,TrainLoss:%f\tTestAcc:%f,TestLoss:%f" 
              %(i,Accuracy_train,Loss_train,Accuracy_test,Loss_test))

#可视化,图1准确率，图2损失函数
plt.figure(figsize=(10,3))
plt.subplot(121)
plt.plot(cce_train,color="blue",label="train")
plt.plot(cce_test,color="red",label="test")
plt.xlabel("Iteration")
plt.ylabel("Loss")
plt.subplot(122)
plt.plot(acc_train,color="blue",label="train")
plt.plot(acc_test,color="red",label="test")
plt.xlabel("Iteration")
plt.ylabel("Accuracy")
plt.tight_layout()      #自动调整子图
plt.show()
        输出：训练集和测试集损失都在下降，可以继续训练
i:0,	TrainAcc:0.291667,TrainLoss:2.102095	TestAcc:0.366667,TestLoss:1.757901
i:10,	TrainAcc:0.891667,TrainLoss:0.338472	TestAcc:0.933333,TestLoss:0.447548
i:20,	TrainAcc:0.933333,TrainLoss:0.271075	TestAcc:0.900000,TestLoss:0.405325
i:30,	TrainAcc:0.958333,TrainLoss:0.234893	TestAcc:0.833333,TestLoss:0.384106
i:40,	TrainAcc:0.958333,TrainLoss:0.210969	TestAcc:0.766667,TestLoss:0.370561
i:50,	TrainAcc:0.966667,TrainLoss:0.193312	TestAcc:0.766667,TestLoss:0.360828

在这里插入图片描述

6、多层神经网络：增加隐含层

在这里插入图片描述

7、实现异或运算（01、10为1,00、11为0）

采用2个感知机：一个感知机相当于一根直线，下图第1个感知机实现与运算（11–>1，其他–>0），第2个感知机实现或非运算（见下图红色横线处）
在这里插入图片描述
再进行叠加（对h1、h2进行或非运算），得到异或运算的模型（每个神经元，即感知机，有3个参数）：

也可以使用以下运算（先进行或运算OR、或非运算NAND，再进行与运算AND)：

8、线性不可分问题

可以转化为多个线性问题，每个线性问题用一个感知机（一个神经元下图第3图的橙色圈）表示一条直线，再用一个神经元将其组合起来（下图第3图绿色圈）：
在这里插入图片描述
下图中1个四边形，1个六变形。需要用2个隐含层（下图红色框），用4个神经元（黄色圈）区分4边形，用6个神经元（橙色圈）区分6边形，再将2个图形组合起来（绿色圈）

9、万能近似定理

在前馈型神经网络中，只要有一个隐含层，并且这个隐含层中有足够多的神经元，就可以逼近任意一个连续的函数或空间分布

多隐含层神经网络：能够表示非连续的函数或空间区域、减少泛化误差、减少每层神经元的数量

10、超参数与验证集

例如：有2个超参数a、b，a∈{1,2,3}，b∈{4,5,6,7}，那么就有3*4种组合。使用同一个训练集训练每一种组合得到各种组合的模型，使用同一个验证集测试其误差（防止模型的过拟合），去除误差较大的模型，确定模型超参数，再在测试集评估模型的泛化能力。

11、误差反向传播算法（Backpropagation, BP）

误差反向传播算法（Backpropagation, BP）：利用链式法则，反向传播损失函数的梯度信息，计算出损失函数对网络中所有模型参数的梯度（它计算的只是梯度，其本身不是学习算法，将梯度传递给其他算法，如梯度下降法，来学习更新模型的参数）

举个栗子：下面神经网络，输入值x=1时，真实值y=0.8，4个模型参数wh、bh、w0、b0，重复下面4个步骤：
在这里插入图片描述

step1：设置模型参数初始值：wh=0.2, bh=0.1, w0=0.3, b0=0.2
step2：正向计算预测值（即是计算预测值y0）：
$y_h=\dfrac{1}{1+e^{-(0.2*1+0.1)}}=0.57$
$y_0=\dfrac{1}{1+e^{-(0.3*0.57+0.2)}}=0.59$
step3：计算误差：Loss=0.5*(y-y0)²=0.02205
step4：误差反向传播：

可以用TensorFlow自带求导自动求偏导，也可手动求，下面手动对w求偏导数的过程（用求导的链式求导即可）：（图中有问题的：dLoss/dw0少了一个负号！！！）

同理，更新参数b0（和上面对w0求偏导比较，只有dz0/db0不同）：

同理，更新隐含层模型参数wh、bh：

如果隐含层有多个神经元，那么误差反向传播，则按照权值wi按比例反向传播：

如果输出层有多个神经元，和上面同理：