bp神经网络python代码

构建一个基本的BP神经网络需要使用Python和一些库来实现。

python
import numpy as np

class NeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        # 初始化权重和偏置
        self.weights_input_hidden = np.random.rand(input_size, hidden_size)
        self.bias_input_hidden = np.zeros((1, hidden_size))
        self.weights_hidden_output = np.random.rand(hidden_size, output_size)
        self.bias_hidden_output = np.zeros((1, output_size))

    def sigmoid(self, x):
        # Sigmoid激活函数
        return 1 / (1 + np.exp(-x))

    def sigmoid_derivative(self, x):
        # Sigmoid激活函数的导数
        return x * (1 - x)

    def forward(self, inputs):
        # 前向传播
        self.hidden_layer_input = np.dot(inputs, self.weights_input_hidden) + self.bias_input_hidden
        self.hidden_layer_output = self.sigmoid(self.hidden_layer_input)

        self.output_layer_input = np.dot(self.hidden_layer_output, self.weights_hidden_output) + self.bias_hidden_output
        self.predicted_output = self.sigmoid(self.output_layer_input)

        return self.predicted_output

    def backward(self, inputs, targets, learning_rate):
        # 反向传播
        error = targets - self.predicted_output
        output_delta = error * self.sigmoid_derivative(self.predicted_output)

        hidden_layer_error = output_delta.dot(self.weights_hidden_output.T)
        hidden_layer_delta = hidden_layer_error * self.sigmoid_derivative(self.hidden_layer_output)

        # 更新权重和偏置
        self.weights_hidden_output += self.hidden_layer_output.T.dot(output_delta) * learning_rate
        self.bias_hidden_output += np.sum(output_delta, axis=0, keepdims=True) * learning_rate
        self.weights_input_hidden += inputs.T.dot(hidden_layer_delta) * learning_rate
        self.bias_input_hidden += np.sum(hidden_layer_delta, axis=0, keepdims=True) * learning_rate

    def train(self, inputs, targets, epochs, learning_rate):
        # 训练神经网络
        for epoch in range(epochs):
            for i in range(len(inputs)):
                input_data = np.array([inputs[i]])
                target_data = np.array([targets[i]])
                
                # 前向传播
                self.forward(input_data)
                
                # 反向传播
                self.backward(input_data, target_data, learning_rate)

                # 打印每100次迭代的损失
                if (i + 1) % 100 == 0:
                    loss = np.mean(np.square(target_data - self.predicted_output))
                    print(f'Epoch {epoch + 1}/{epochs}, Iteration {i + 1}/{len(inputs)}, Loss: {loss}')

# 示例用法
# 定义输入、输出和隐藏层大小
input_size = 2
hidden_size = 3
output_size = 1

# 创建神经网络
nn = NeuralNetwork(input_size, hidden_size, output_size)

# 训练数据
inputs = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
targets = np.array([[0], [1], [1], [0]])

# 设置训练参数并开始训练
epochs = 10000
learning_rate = 0.1
nn.train(inputs, targets, epochs, learning_rate)

# 测试神经网络
test_input = np.array([[0, 0]])
predicted_output = nn.forward(test_input)
print(f'Test Input: {test_input}, Predicted Output: {predicted_output}')

在这个例子中，神经网络有一个输入层，一个隐藏层，和一个输出层。这个网络被训练以学习XOR逻辑门的行为。你可以根据自己的需求调整输入、隐藏和输出的大小，以及训练数据和超参数。

python
# 示例用法（

腾讯云最新优惠活动，点击查看