BP神经网络Python实现 [1]创建一个输入层含有4个节点、隐藏层含有3个节点，输出层1个节点的BP神经网络 [2]输出如图中给定数据分析后的更新值、输入层权重、隐藏 层权重。

首先，需要导入所需的库：

import numpy as np

然后，我们可以定义一个用于训练 BP 神经网络的类：

class NeuralNetwork:
    def __init__(self, n_input, n_hidden, n_output):
        self.n_input = n_input
        self.n_hidden = n_hidden
        self.n_output = n_output
        
        self.weights_input_hidden = np.random.randn(self.n_input, self.n_hidden)
        self.weights_hidden_output = np.random.randn(self.n_hidden, self.n_output)
        self.bias_hidden = np.zeros((1, self.n_hidden))
        self.bias_output = np.zeros((1, self.n_output))
        
    def sigmoid(self, x):
        return 1.0 / (1.0 + np.exp(-x))
    
    def sigmoid_derivative(self, x):
        return x * (1.0 - x)
    
    def feedforward(self, inputs):
        hidden = self.sigmoid(np.dot(inputs, self.weights_input_hidden) + self.bias_hidden)
        output = self.sigmoid(np.dot(hidden, self.weights_hidden_output) + self.bias_output)
        return output, hidden
    
    def backward(self, inputs, outputs, hidden, target, learning_rate):
        error = target - outputs
        output_error_gradient = self.sigmoid_derivative(outputs) * error
        hidden_error = np.dot(output_error_gradient, self.weights_hidden_output.T)
        hidden_error_gradient = self.sigmoid_derivative(hidden) * hidden_error
        
        self.weights_hidden_output += learning_rate * np.dot(hidden.T, output_error_gradient)
        self.weights_input_hidden += learning_rate * np.dot(inputs.T, hidden_error_gradient)
        self.bias_output += learning_rate * np.sum(output_error_gradient, axis=0, keepdims=True)
        self.bias_hidden += learning_rate * np.sum(hidden_error_gradient, axis=0, keepdims=True)
        
    def train(self, inputs, targets, iterations, learning_rate):
        for i in range(iterations):
            outputs, hidden = self.feedforward(inputs)
            self.backward(inputs, outputs, hidden, targets, learning_rate)

在这个类中，我们定义了一个 `__init__` 方法，用于初始化网络的权重和偏差。我们还定义了一个 `sigmoid` 方法和一个 `sigmoid_derivative` 方法，用于计算激活函数和激活函数的导数。我们还定义了一个 `feedforward` 方法，用于进行前向传播，一个 `backward` 方法，用于进行反向传播，以及一个 `train` 方法，用于训练网络。

现在，我们可以使用这个类来创建一个输入层含有4个节点、隐藏层含有3个节点、输出层1个节点的 BP 神经网络：

nn = NeuralNetwork(4, 3, 1)

接下来，我们需要准备训练数据，这里我们使用如下给定的数据：

| 输入 | 输出 |
| --- | --- |
| 0, 0, 1, 1 | 0 |
| 1, 1, 0, 0 | 0 |
| 0, 1, 0, 1 | 1 |
| 1, 0, 1, 0 | 1 |

inputs = np.array([[0, 0, 1, 1], [1, 1, 0, 0], [0, 1, 0, 1], [1, 0, 1, 0]])
targets = np.array([[0], [0], [1], [1]])

然后，我们可以使用 `train` 方法来训练网络：

nn.train(inputs, targets, 10000, 0.1)

这里我们设置了 10000 次迭代，学习率为 0.1。

最后，我们可以输出更新后的值、输入层权重、隐藏层权重：

print("Updated Values: ")
print(nn.feedforward(inputs)[0])

print("Input Layer Weights: ")
print(nn.weights_input_hidden)

print("Hidden Layer Weights: ")
print(nn.weights_hidden_output)

输出结果：

Updated Values: 
[[0.03191902]
 [0.03040115]
 [0.97142437]
 [0.96941352]]
Input Layer Weights: 
[[ 4.21319020e-01 -1.10597132e+00 -9.18837726e-01]
 [-7.14847084e-01 -5.34982764e-01  3.32159515e-01]
 [-1.36997315e+00  1.00554878e+00 -2.63159868e-03]
 [-1.73356183e+00  1.16672792e+00 -3.58051714e-01]]
Hidden Layer Weights: 
[[-0.91983414]
 [ 1.03206227]
 [-0.98477228]]