算法强化 —— 前向神经网络

网络图和激活函数

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_circles

准备数据

def load_data():
    # 训练样本有300个 测试样本有100个
    train_X,train_Y = make_circles(n_samples=300,noise=.05)
    test_X,test_Y = make_circles(n_samples=100,noise=.05)
    # 可视化数据
    plt.scatter(train_X[:,0],train_X[:,1],c = train_Y,s = 40,cmap=plt.cm.Spectral)
    train_X = train_X.T
    train_Y = train_Y.reshape((1,train_Y.shape[0]))
    test_X = test_X.T
    test_Y = test_Y.reshape((1,test_Y.shape[0]))
    return train_X,train_Y,test_X,test_Y

train_X,train_Y,test_X,test_Y = load_data()

print(train_X,train_Y,test_X,test_Y)

几个激活函数

$sigmoid(z)=\frac{1}{1+e^{-z}}$
$tanh(z)=\frac{e^z-e^{-z}}{e^z+e^{-z}}$
$relu(z)=max(z,0)$

def sigmoid(z):
    return 1./(1+np.exp(-z))

def tanh(z):
    return (np.exp(z)-np.exp(-z)) / (np.exp(z)+np.exp(-z))

def relu(z):
    return (np.abs(z)+z)/2

x = np.linspace(-5,5,100)
y = sigmoid(x)
plt.plot(x,y)
plt.show()


y = tanh(x)
plt.plot(x,y)
plt.show()

y = relu(x)
plt.plot(x,y)
plt.show()

sigmoid函数的导函数：$z^{\prime }(x)=s(x)\ast (1-s(x))$
RELU函数的导数：
$$rel{u}^{\prime }(z)=\{\begin{array}{ll}1,& relu(x)>0\\ 0,& relu(z)=0\end{array}$$

前向传播的过程

首先对于每一组数据来说都有一个输入${\left[\begin{array}{l}{x}_1\\ x_2\end{array}\right]}_{(2,1)}$
然后第一个隐藏层我们称之为$H_1$,其hidden_size为20，将还没有经过激活函数的RELU的，称之为$Z_1$,那么我们马上有：
$$Z_1=W_{1}X+b_1$$
$$H_1=RELU(Z_1)$$
其中$W_1$是从输入层到第一个隐藏层的参数，$b_1$是其bias项。

在这里面我们要十分注意维度的变换，W1的维度是(20,2),$b_1$为(20,1),自然$Z_1$是(20,1),同样的$H_1$也是(20,1),他的过程大致是
$$Z^{[1]}=WX+b^{[1]}={\left[\begin{array}{cc}{w}_{1,1}^{[1]}& w_{1,2}^{[1]}\\ w_{2,1}^{[1]}& w_{2,2}^{[1]}\\ ⋮& ⋮\\ w_{20,1}^{[1]}& w_{20,2}^{[1]}\end{array}\right]}_{(20,2)}\times {\left[\begin{array}{c}{x}_1\\ x_2\end{array}\right]}_{(2,1)}+{\left[\begin{array}{c}{b}_1^{[1]}\\ b_2^{[1]}\\ ⋮\\ b_{20}^{[1]}\end{array}\right]}_{(20,1)}$$
当然对于第二个隐藏层，它的hidden_size是5，那么它的前向传播的一系列东西如下
$$Z_2=W_2{H}_1+b_2$$
$$H_2=RELU(Z_2)$$
其各个维度对应如下$H_1:(20,1),W_2:(5,20),b_2:(5,1),Z_2:(5,1),H_2:(5,1)$
到了我们的最后一层
$$Z_3=W_3{H}_2+b_3$$
$$\hat{y}=sigmoid(Z_3)$$
其各个维度对应如下$H_2:(5,1),W_3:(5,1),b_3:(1),H_3:(1)$
然后我们得出一个标量值，这个值根据我们设定的阈值，比如如果大于0.5，我们把它归为1，反之为0，就完成了我们的分类，也代表我们整个前向传播的过程结束了

def initialize_parameters(layer_dims):
    # 初始化权重和偏置项
    Weight = {}
    bias = {}
    for d in range(1,len(layer_dims)):
        Weight['W'+str(d)] = np.random.randn(layer_dims[d],layer_dims[d-1]) / np.sqrt(layer_dims[d-1])
        bias['b'+str(d)] = np.zeros((layer_dims[d],1))

    return Weight,bias

# 设定每一层的 hidden_size
layer_dims = [2,20,5,1]  # 两个隐藏层的大小 20 5
W,b = initialize_parameters(layer_dims)
W["W3"].shape
# 输出w3的维度 (1,5)

def forward_propagation(X,Weight,bias,activation):
    # 前向传播函数
    Z = {}
    H = {}
    # 一般吧输入X看做第0层的输出 H0
    H['HO'] = X
    L = len(Weight)
    for l in range(1,L=1):
        Z['Z'+str(l)] = np.dot(Weight['W'+str(l)],H['H'+str(l-1)] + bias['b'+str(l)])
        exec("H['H'+str(l)] = "+activation[l-1]+"(Z['Z'+str(l)])")

    return H,Z

损失函数选用

选用的是交叉熵损失函数(cross entropy ,CE)
$$L\left({\hat{y}}^{(i)},y^{(i)}\right)=-\left(y^{(i)}\log \left({\hat{y}}^{(i)}\right)+\left(1-y^{(i)}\right)\log \left(1-{\hat{y}}^{(i)}\right)\right)$$
对整个样本来说，我们的损失函数可以这么定义：
$$J(w,b)=\frac{1}{m}\sum _{i=1}^{m}L\left({\hat{y}}^{(i)},y^{(i)}\right)=-\frac{1}{m}\sum _{i=1}^m\left[y^{(i)}\log \left({\hat{y}}^{(i)}\right)+\left(1-y^{(i)}\right)\log \left(1-{\hat{y}}^{(i)}\right)\right]+\frac{\lambda }{2m}\Vert w{\Vert }_F^2$$
我们在损失函数的最后加了一个L2正则式，进行一个权重的衰减，防止过拟合

import numpy as np
def compute_cost(H,Y,Weight,lambd = 0.7):
    m = Y.shape[1]
    L2_term = 0
    for key in Weight.keys():
        L2_term += (np.sum(np.square(Weight[key])))

    logprobs = np.multiarray(-np.log(H['H'+str(len(H)-1)]),Y)+np.multiarray(-np.log(1-H['H'+str(len(H)-1)]),1-Y)
    # 在训练的时候我们是一批数据进行迭代，最后取其总和的平均值
    cost = 1./m*np.nansum(logprobs)
    cost += L2_term * lambd / (2*m)
    return cost