使用numpy实现简单的误差逆传播算法模型

# -*- coding: utf-8 -*-
import numpy as np

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

# 定义激活函数的导数
def sigmoid_derivative(x):
    return x*(1-x)

# 输入数据
input_data = np.array([[0,0,1],
                       [0,1,1],
                       [1,0,1],
                       [1,1,1]])

# 期望输出
expected_output = np.array([[0,0,1,1]]).T

# 随机初始化权重
np.random.seed(1)
weight_0_1 = 2*np.random.random((3,256)) - 1
weight_1_2 = 2*np.random.random((256,256)) - 1
weight_2_3 = 2*np.random.random((256,10)) - 1

# 设置学习率
learning_rate = 0.1

# 开始训练
for j in range(10000):
    # 正向传播
    layer_0 = input_data
    layer_1 = sigmoid(np.dot(layer_0,weight_0_1))
    layer_2 = sigmoid(np.dot(layer_1,weight_1_2))
    layer_3 = sigmoid(np.dot(layer_2,weight_2_3))

    # 计算误差
    layer_3_error = expected_output - layer_3

    # 反向传播
    layer_3_delta = layer_3_error * sigmoid_derivative(layer_3)
    layer_2_error = layer_3_delta.dot(weight_2_3.T)
    layer_2_delta = layer_2_error * sigmoid_derivative(layer_2)
    layer_1_error = layer_2_delta.dot(weight_1_2.T)
    layer_1_delta = layer_1_error * sigmoid_derivative(layer_1)

    # 更新权重
    weight_2_3 += layer_2.T.dot(layer_3_delta)*learning_rate
    weight_1_2 += layer_1.T.dot(layer_2_delta)*learning_rate
    weight_0_1 += layer_0.T.dot(layer_1_delta)*learning_rate

# 输出最终预测结果
print(layer_3)