神经网络算法：神经网络反向传播法代码

下面是一个使用Python实现的神经网络反向传播算法的代码示例：

import numpy as np

class NeuralNetwork:
    def __init__(self, num_inputs, num_hidden, num_outputs):
        self.num_inputs = num_inputs
        self.num_hidden = num_hidden
        self.num_outputs = num_outputs
        
        self.weights_h = np.random.randn(self.num_inputs, self.num_hidden)
        self.weights_o = np.random.randn(self.num_hidden, self.num_outputs)
        
    def forward(self, inputs):
        self.hidden = np.dot(inputs, self.weights_h)
        self.hidden_activated = self.sigmoid(self.hidden)
        
        self.output = np.dot(self.hidden_activated, self.weights_o)
        self.output_activated = self.sigmoid(self.output)
        
        return self.output_activated
    
    def backward(self, inputs, outputs, learning_rate):
        error = outputs - self.output_activated
        output_delta = error * self.sigmoid_derivative(self.output)
        
        error_hidden = np.dot(output_delta, self.weights_o.T)
        hidden_delta = error_hidden * self.sigmoid_derivative(self.hidden)
        
        self.weights_o += learning_rate * np.dot(self.hidden_activated.T, output_delta)
        self.weights_h += learning_rate * np.dot(inputs.T, hidden_delta)
        
    def train(self, inputs, outputs, learning_rate, num_epochs):
        for epoch in range(num_epochs):
            predicted_outputs = self.forward(inputs)
            self.backward(inputs, outputs, learning_rate)
            
            if (epoch+1) % 100 == 0:
                error = np.mean(np.abs(outputs - predicted_outputs))
                print(f"Epoch {epoch+1}/{num_epochs}, Error: {error:.4f}")
        
    def sigmoid(self, x):
        return 1 / (1 + np.exp(-x))
    
    def sigmoid_derivative(self, x):
        return x * (1 - x)

# 示例用法
# 创建一个具有2个输入、2个隐藏层节点和1个输出的神经网络
nn = NeuralNetwork(2, 2, 1)

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

# 使用反向传播算法进行训练
nn.train(inputs, outputs, learning_rate=0.1, num_epochs=1000)

# 对新的输入进行预测
new_inputs = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
predicted_outputs = nn.forward(new_inputs)

print("Predictions:")
print(predicted_outputs)

注：

• num_inputs, num_hidden, 和 num_outputs 分别表示输入层节点数、隐藏层节点数和输出层节点数。
• 在示例中，使用了sigmoid作为激活函数，可以根据需要修改激活函数的实现。
• 反向传播算法通过调用 train方法来训练神经网络，其中 learning_rate 是学习率，控制每次权重更新的幅度， num_epochs 是训练的轮数。
• 训练过程中，每隔100个epoch，打印出当前的训练误差。
• 预测过程中，使用 forward方法对新的输入进行前向传播，并打印出预测结果。