反向传播算法的简单实现（不包括梯度检测，随机初始化）

一、参数
1. 输入层：X = 【x₁,x₂,x₃,…x_n】
输入层表示特征的个数
2. 输出层：Y = 【y₁,y₂,y₃,…y_n】
对于分类问题，输出层的个数为类别个数
3. 隐藏层
规则： 默认一层，隐藏层的单元数要比输入层的单元数多
若为多层，每层的单元数要相同，理论上每层的单元数越多越好，但单元数过多会导致计算量增大
4.学习率： θ，用于更新权重
5.迭代次数： numIter
6.图示

二、前向传播算法
1. 目的: 用于计算除了输入层的每层的激励a_num^layer
其中：
layer为从隐藏层开始的每一层，如：第一层隐藏层为a_num⁽¹⁾
num为该层的激励的序号，如：第一层隐藏层的第一个单元的激励为a₁⁽¹⁾，第一层隐藏层的第二个单元的激励为a₂⁽¹⁾，以此类推。
2. 计算每一层的激励
a₁⁽¹⁾ = g(w₁₀⁽¹⁾x₀ + w₁₁⁽¹⁾x₁ + w₁₂⁽¹⁾x₂) = g(z₁⁽¹⁾)
a₂⁽¹⁾ = g(w₂₀⁽¹⁾x₀ + w₂₁⁽¹⁾x₁ + w₂₂⁽¹⁾x₂) = g(z₂⁽¹⁾)
其中，
x₀为偏置单元，是一个常量
w₂₁⁽¹⁾为权重，其下标表示第一层对第二层的权重
g()为激励函数，这里使用sigmoid函数作为激励函数
z₁⁽¹⁾ = w₁₀⁽¹⁾x₀ + w₁₁⁽¹⁾x₁ + w₁₂⁽¹⁾x₂)

三、反向传播算法
1. 目的： 计算误差项
2. 计算每一层的误差项
对于输出层： δ⁽²⁾ = a⁽²⁾ - Y
对于隐藏层： δ⁽¹⁾ = (w⁽¹⁾)^Tδ⁽²⁾ .* g^‘(z⁽¹⁾) - Y
其中：.表示点乘，即矩阵对应元素相乘(python中使用np.dot),其余为正常乘法(python中使用np.multipy)
g‘(z(1)) = a⁽¹⁾ .* (1 - a⁽¹⁾)

四、权值更新
w <- w + θδ该层的输入

五、代码实现

import numpy as np
#定义激活函数
def sigmoid(x):
    return 1 / (1+np.exp(-x))
    
if __name__ == "__main__":
    x = [0.05,0.10]
    y = [0.01,0.99]
    b1 = 0.35
    b2 = 0.60
    w1 = [[0.15,0.20],[0.25,0.30]]
    w2 = [[0.40,0.45],[0.50,0.55]]

    theta = 0.5
    numIter = 10000

    #前向传播
    z1 = np.dot(w1,x) + b1
    a1 = sigmoid(z1)

    z2 = np.dot(w2,x) + b2
    a2 = sigmoid(z2)
    
    for n in range(numIter):
        #反向传播
        delta2 = a2 - y
        delta1 = np.multiply(np.dot(np.array(w2).T,delta2),np.multiply(a1,1-a1))

        #更新权重
        for i in range(len(w2)):
            w2[i] = w2[i] - theta * delta2[i] * a1

        for i in range(len(w1)):
            w1[i] = w1[i] - theta * delta1[i] * np.array(x)

        #继续向前传播输出结果
        z1 = np.dot(w1, x) + b1
        a1 = sigmoid(z1)

        z2 = np.dot(w2, x) + b2
        a2 = sigmoid(z2)

        print(str(n) + " result:" + str(a2[0]) + ", result:" + str(a2[1]))