编写python代码，实验时建立三层BP神经网络，输入节点2个，隐含层节点2个，输出节点1个，输入训练样本如下表： 输入值0.0 0.1 0.0 1.0 1.0 0.0 1.0 1.0 0.1 1.0 输出值 0.0 1.0 1.0 0.0 1.0学习率分别为0.8, 最大允许误差0.001。求出迭代次数和训练耗时。 2、在原来网络的基础上，改变学习因子为0.5，求出迭代次数和训练耗时并进行对比。 3、改变输入层、隐含层、输出层的单元数。在原来网络的基础上，当隐含层节点个数为3时，求出迭代次数和训练耗时并进行对比。 4、在原来网络的基础上，取误差为0.0001，求出迭代次数和训练耗时并进行对比。

以下是实现上述任务的Python代码：

import numpy as np
import time

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

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

# 设置训练数据
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [1], [1], [0]])

# 设置超参数
learning_rate = 0.8
max_error = 0.001
max_iterations = 10000

# 初始化权重和偏置
np.random.seed(1)
w1 = 2 * np.random.random((2, 2)) - 1
b1 = 2 * np.random.random((1, 2)) - 1
w2 = 2 * np.random.random((2, 1)) - 1
b2 = 2 * np.random.random((1, 1)) - 1

# 训练模型
start_time = time.time()
for i in range(max_iterations):
    # 前向传播
    layer1 = sigmoid(np.dot(X, w1) + b1)
    layer2 = sigmoid(np.dot(layer1, w2) + b2)

    # 计算误差
    error = y - layer2
    if np.mean(np.abs(error)) < max_error:
        print(f"Reached max accuracy at iteration {i+1}")
        break

    # 反向传播
    layer2_delta = error * sigmoid_derivative(layer2)
    layer1_delta = layer2_delta.dot(w2.T) * sigmoid_derivative(layer1)

    # 更新权重和偏置
    w2 += layer1.T.dot(layer2_delta) * learning_rate
    b2 += np.sum(layer2_delta, axis=0, keepdims=True) * learning_rate
    w1 += X.T.dot(layer1_delta) * learning_rate
    b1 += np.sum(layer1_delta, axis=0, keepdims=True) * learning_rate

end_time = time.time()
print(f"Training time: {end_time - start_time:.2f} seconds")

# 测试模型
print(layer2)

# 改变学习因子为 0.5
learning_rate = 0.5
max_iterations = 10000

# 重新训练模型
np.random.seed(1)
w1 = 2 * np.random.random((2, 2)) - 1
b1 = 2 * np.random.random((1, 2)) - 1
w2 = 2 * np.random.random((2, 1)) - 1
b2 = 2 * np.random.random((1, 1)) - 1

start_time = time.time()
for i in range(max_iterations):
    # 前向传播
    layer1 = sigmoid(np.dot(X, w1) + b1)
    layer2 = sigmoid(np.dot(layer1, w2) + b2)

    # 计算误差
    error = y - layer2
    if np.mean(np.abs(error)) < max_error:
        print(f"Reached max accuracy at iteration {i+1}")
        break

    # 反向传播
    layer2_delta = error * sigmoid_derivative(layer2)
    layer1_delta = layer2_delta.dot(w2.T) * sigmoid_derivative(layer1)

    # 更新权重和偏置
    w2 += layer1.T.dot(layer2_delta) * learning_rate
    b2 += np.sum(layer2_delta, axis=0, keepdims=True) * learning_rate
    w1 += X.T.dot(layer1_delta) * learning_rate
    b1 += np.sum(layer1_delta, axis=0, keepdims=True) * learning_rate

end_time = time.time()
print(f"Training time: {end_time - start_time:.2f} seconds")

# 测试模型
print(layer2)

# 改变隐含层节点数为 3
learning_rate = 0.8
num_hidden_units = 3
max_iterations = 10000

# 重新训练模型
np.random.seed(1)
w1 = 2 * np.random.random((2, num_hidden_units)) - 1
b1 = 2 * np.random.random((1, num_hidden_units)) - 1
w2 = 2 * np.random.random((num_hidden_units, 1)) - 1
b2 = 2 * np.random.random((1, 1)) - 1

start_time = time.time()
for i in range(max_iterations):
    # 前向传播
    layer1 = sigmoid(np.dot(X, w1) + b1)
    layer2 = sigmoid(np.dot(layer1, w2) + b2)

    # 计算误差
    error = y - layer2
    if np.mean(np.abs(error)) < max_error:
        print(f"Reached max accuracy at iteration {i+1}")
        break

    # 反向传播
    layer2_delta = error * sigmoid_derivative(layer2)
    layer1_delta = layer2_delta.dot(w2.T) * sigmoid_derivative(layer1)

    # 更新权重和偏置
    w2 += layer1.T.dot(layer2_delta) * learning_rate
    b2 += np.sum(layer2_delta, axis=0, keepdims=True) * learning_rate
    w1 += X.T.dot(layer1_delta) * learning_rate
    b1 += np.sum(layer1_delta, axis=0, keepdims=True) * learning_rate

end_time = time.time()
print(f"Training time: {end_time - start_time:.2f} seconds")

# 测试模型
print(layer2)

# 将误差阈值改为 0.0001
learning_rate = 0.8
max_error = 0.0001
max_iterations = 100000

# 重新训练模型
np.random.seed(1)
w1 = 2 * np.random.random((2, 2)) - 1
b1 = 2 * np.random.random((1, 2)) - 1
w2 = 2 * np.random.random((2, 1)) - 1
b2 = 2 * np.random.random((1, 1)) - 1

start_time = time.time()
for i in range(max_iterations):
    # 前向传播
    layer1 = sigmoid(np.dot(X, w1) + b1)
    layer2 = sigmoid(np.dot(layer1, w2) + b2)

    # 计算误差
    error = y - layer2
    if np.mean(np.abs(error)) < max_error:
        print(f"Reached max accuracy at iteration {i+1}")
        break

    # 反向传播
    layer2_delta = error * sigmoid_derivative(layer2)
    layer1_delta = layer2_delta.dot(w2.T) * sigmoid_derivative(layer1)

    # 更新权重和偏置
    w2 += layer1.T.dot(layer2_delta) * learning_rate
    b2 += np.sum(layer2_delta, axis=0, keepdims=True) * learning_rate
    w1 += X.T.dot(layer1_delta) * learning_rate
    b1 += np.sum(layer1_delta, axis=0, keepdims=True) * learning_rate

end_time = time.time()
print(f"Training time: {end_time - start_time:.2f} seconds")

# 测试模型
print(layer2)

第一段代码将建立一个三层BP神经网络，并使用给定的训练数据进行训练。在训练过程中，我们将监控误差是否小于给定的阈值，并在达到该阈值或达到最大迭代次数时停止训练。训练完成后，我们将输出网络的输出结果并计算训练耗时。

第二段代码将使用与第一段代码相同的训练数据和网络结构，但将学习率设置为0.5，并重新进行训练。我们将输出网络的输出结果并计算训练耗时。

第三段代码将使用与第一段代码相同的训练数据和学习率，但将隐含层节点数改为3，并重新进行训练。我们将输出网络的输出结果并计算训练耗时。

第四段代码将使用与第一段代码相同的训练数据和网络结构，但将误差阈值设置为0.0001，并重新进行训练。我们将输出网络的输出结果并计算训练耗时。