从零开始搭建神经网络（二）数学公式及代码实现

本文以实现逻辑回归为例，逻辑回归如图所示，只有一个神经元结点。

1. 激活函数

logistic回归的激活函数一般使用sigmoid(x),其他情况可以使用tanh(x),ReLU(x)或者泄露ReLU(x),激活函数内容可以参考：从零开始搭建神经网络(一)基础知识。这里以sigmoid(x)为例表达式如下：

def sigmoid(z):
    """
    sigmoid激活函数
    :param z: 输入
    :return: sigmoid(z)
    """
    return 1/(1 + np.exp(-z))

2.初始化参数

神经网络中有两个参数需要初始化分别是权重w和偏置b，初始化的方式可以全部初始化为0，也可以随机初始化。需要注意到的是对于logistic回归，可以将权重初始化为零，但是对于神经网络的歌参数数组全部初始化为零，再使用梯度下降那么就会无效。原因是无论哪个初始输入与零权重相乘的到的结果也全是零，从而激活函数输出也是一样的，最终导致反向传播的结果也是一样。由于本文实现的是逻辑回归，故采用零值初始化。

def initializeParamWithZeros(dim):
    """
    初始化权重和偏置
    :param dim: 输入维度
    :return: 返回初始化的w和b
              w:(dim,1)的向量
              b:标量
    """
    w = np.zeros((dim,1))
    b = 0
    return w,b

3.BP算法

BP算法分为两个部分：前向传播与反向传播。详细内容可以参考：从零开始搭建神经网络(一)基础知识。逻辑回归中前向传播用公式表示为：

其中X是输入数据，A是输出数据。反向传播是采用梯度下降法使误差函数减小，误差函数表示为：

其中m为输入数据数目，是输入标签，是激活函数输出，即预测值。反向传播过程中使用梯度下降来实现损失函数的减小，需要先求得损失函数J对w和b的偏导分别为:

def BackPropagate(w,b,X,Y):
    """
    BP算法
    :param w: 权重
    :param b: 偏置
    :param X: 输入数据
    :param Y: 输入标签
    :return: 梯度和损失函数
    """
    #输入数据数目
    num = Y.shape[0]

    #前向传播
    A = sigmoid(np.dot(w.T,X) + b)
    cost = -1 / num * np.sum(Y * np.log(A) + (1 - Y) * np.log(1 - A))

    #反向传播
    dw = 1 / num * np.dot(X,(A - Y).T)
    db = 1 / num * np.sum(A - Y)

    #用字典存储dw和db
    gradients = {"dw": dw,
             "db": db}
    return gradients,cost

4. 梯度下降与优化

神经网络的目标是针对参数W和b来求其损失函数J(W,b)的最小值，为了求解最优的W和b,我们可以重复梯度下降法的迭代步骤来求解最优的W和b，W和b更新公式为:

其中为学习速率。

def Optimize(w,b,X,Y,iters,learning_rate):
    """
    :param w: 初始权值
    :param b: 初始偏置
    :param X: 输入数据
    :param Y: 输入数据标签
    :param iters: 训练迭代次数
    :param learning_rate: 学习速率
    :return: 权值w，偏置b，梯度gradients和损失函数cost
    """
    #存储损失函数的值
    costs = []
    for i in range(iters):
        #初始化梯度和损失函数的值
        gradients, cost = BackPropagate(w,b,X,Y)

        #获取偏导
        dw = gradients["dw"]
        db = gradients["db"]

        #更新参数
        w = w - learning_rate * dw
        b = b - learning_rate * db

        # 记录损失并输出函数
        costs.append(cost)
        print("The cost in the %d th iteration is %f" %(i,cost))

    gradients = {"dw": dw,
                 "db": db}
    return w,b,gradients,costs

 

5.预测

 

训练好后的参数就可以在实际应用中使用了。预测结果分为两部分，第一部分计算输出：

然后判断输出和0.5的大小，大于0.5则为1，反之则为0

def predict(w,b,X):
    """
    :param w: 训练后的权值
    :param b: 训练后偏置
    :param X: 输入数据
    :return: 预测概率大于0.5的
    """
    #获取输入数目m
    m = X.shape[0]
    #存储预测结果
    Y_prediction = np.zeros((1,m))
    w = w.reshape(X.shape[0], 1)
    #神经元输出
    A = sigmoid(np.dot(w.T,X) + b)

    #开始预测
    for i in range(A.shape[0]):
        if A[0,i] > 0.5:
            Y_prediction[0,i] = 1
        else:
            Y_prediction[0,i] = 0
    return Y_prediction

6. 完整实例

import numpy as np
import matplotlib.pyplot as plt

if __name__ == "__main__":
    #X为横坐标，Y为纵坐标
    X = [0, 1.5, 2, 2, 2.25, 2.8, 3.2, 4]
    Y = [1.5, 3, 4, 3, 0.5, 2.8, 1.35, 4]
    label = [1, 1, 1, 1, 0, 0, 0, 0]
    #第一类为蓝色，第二类为红色
    label_color = ['blue','red']
    color = []
    for i in label:
        if i == 1:
            color.append(label_color[0])
        else:
            color.append(label_color[1])
    for i in range(len(X)):
        plt.scatter(X[i], Y[i], c = color[i])
    plt.title('Raw Data')
    plt.show()

    #数据归一化
    X = np.array(X)
    Y = np.array(Y)
    X = (X - np.average(X))
    Y = (Y - np.average(Y))
    X = X / X.max()
    Y = Y / Y.max()
    for i in range(len(X)):
        plt.scatter(X[i], Y[i], c = color[i])
    plt.title('Normalization Data')
    plt.show()

    data_X = np.vstack((X, Y))
    data_label = np.array([label])
    #参数设置
    w = []
    b = []
    Y_prediction = []
    iters = 20
    learning_rate = 0.75
    #开始训练
    w,b = initializeParamWithZeros(data_X.shape[0])
    w, b, gradients, costs = Optimize(w,b,data_X,data_label,iters,learning_rate)
    Y_prediction = predict(w,b,data_X)

    #画图
    plt.plot(costs)
    plt.ylabel('cost')
    plt.xlabel('iterations')
    plt.title("Learning rate =" + str(learning_rate))
    plt.show()

    #测试输入数据
    point = input("Please enter a coordinates:\n")
    #获取坐标
    x = int(point.split(' ')[0])
    y = int(point.split(' ')[1])
    point_data = np.vstack((x,y))
    point_prediction = predict(w,b,point_data)
    print("The point is below to" ,end=" ")
    print(point_prediction[0,0])

初始数据:

归一化后的数据：

 

损失函数随迭代次数的变化：

                     

 

输入一个坐标，进行回归分类：