以人事招聘为例的误差反向传播算法 （第一小问）

import numpy as np
import matplotlib.pyplot as plt

# 输入数据1行4列，这里只有张三的数据
X = np.array([[1.0, 0.1, 1.0, 1.0]])
# 标签，也叫真值，1行1列，张三的真值：一定录用
T = np.array([1])

# 定义一个2-2的神经网络：4个输入神经元 -> 2个隐藏神经元 -> 2个隐藏神经元
# 输入层到隐藏层1的权值初始化，4行2列
W1 = np.array([[0.8, 0.2],
               [0.2, 0.8],
               [0.5, 0.5],
               [0.5, 0.5]])
# 隐藏层1到隐藏层2的权值初始化，2行2列
W2 = np.array([[0.5, 0.0],
               [0.5, 1.0]])

# 初始化偏置值
# 隐藏层1的2个神经元偏置
b1 = np.array([-1, 0.3])
# 隐藏层2的2个神经元偏置
b2 = np.array([0.1, -0.1])

# 学习率设置
lr = 0.1
# 定义训练周期数10000
epochs = 10000
# 每训练1000次计算一次loss值
report = 1000
# 将所有样本分组，每组大小为
batch_size = 1


# 定义sigmoid函数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))


# 定义sigmoid函数导数
def dsigmoid(x):
    return x * (1 - x)


# 更新权值和偏置值
def update():
    global batch_X, batch_T, W1, W2, lr, b1, b2

    # 隐藏层1输出
    Z1 = np.dot(batch_X, W1) + b1
    A1 = sigmoid(Z1)

    # 隐藏层2输出
    Z2 = np.dot(A1, W2) + b2
    A2 = sigmoid(Z2)

    # 计算loss值（假设直接使用隐藏层2的输出作为最终输出）
    delta_A2 = (batch_T - A2)
    delta_Z2 = delta_A2 * dsigmoid(A2)

    # 利用隐藏层2的误差，求出三个偏导（即隐藏层1到隐藏层2的权值改变）
    delta_W2 = A1.T.dot(delta_Z2) / batch_X.shape[0]
    delta_B2 = np.sum(delta_Z2, axis=0) / batch_X.shape[0]

    # 求隐藏层1的误差
    delta_A1 = delta_Z2.dot(W2.T)
    delta_Z1 = delta_A1 * dsigmoid(A1)

    # 利用隐藏层1的误差，求出三个偏导（即输入层到隐藏层1的权值改变）
    delta_W1 = batch_X.T.dot(delta_Z1) / batch_X.shape[0]
    delta_B1 = np.sum(delta_Z1, axis=0) / batch_X.shape[0]

    # 更新权值
    W2 = W2 + lr * delta_W2
    W1 = W1 + lr * delta_W1

    # 改变偏置值
    b2 = b2 + lr * delta_B2
    b1 = b1 + lr * delta_B1


# 定义空list用于保存loss
loss = []
batch_X = []
batch_T = []
max_batch = X.shape[0] // batch_size

# 训练模型
for idx_epoch in range(epochs):
    for idx_batch in range(max_batch):
        # 更新权值
        batch_X = X[idx_batch * batch_size:(idx_batch + 1) * batch_size, :]
        batch_T = T[idx_batch * batch_size:(idx_batch + 1) * batch_size]
        update()

    # 每训练1000次计算一次loss值
    if idx_epoch % report == 0:
        # 隐藏层1输出
        A1 = sigmoid(np.dot(X, W1) + b1)
        # 隐藏层2输出
        A2 = sigmoid(np.dot(A1, W2) + b2)
        # 计算loss值
        print('A2:', A2)
        print('epochs:', idx_epoch, 'loss:', np.mean(np.square(T - A2) / 2))
        # 保存loss值
        loss.append(np.mean(np.square(T - A2) / 2))

# 画图训练周期数与loss的关系图
plt.plot(range(0, epochs, report), loss)
plt.xlabel('epochs')
plt.ylabel('loss')
plt.show()

# 最终的输出
A1 = sigmoid(np.dot(X, W1) + b1)
A2 = sigmoid(np.dot(A1, W2) + b2)
print('output:')
print(A2)


# 因为最终的分类只有0和1，所以我们可以把
# 大于等于0.5的值归为1类，小于0.5的值归为0类
def predict(x):
    if x >= 0.5:
        return 1
    else:
        return 0


# map会根据提供的函数对指定序列做映射
# 相当于依次把A2中的值放到predict函数中计算
# 然后打印出结果
print('predict:')
#for i in map(predict, A2.flatten()):
for i in map(predict, A2.flatten()):
    print(i)