用python实现bp神经网络

好的，让我们来实现一个简单的BP神经网络：

import numpy as np

class NeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        
        self.W1 = np.random.randn(self.input_size, self.hidden_size) 
        self.W2 = np.random.randn(self.hidden_size, self.output_size)
        
    def sigmoid(self, x):
        return 1 / (1 + np.exp(-x))
    
    def sigmoid_derivative(self, x):
        return x * (1 - x)
    
    def forward(self, X):
        self.z = np.dot(X, self.W1)
        self.z2 = self.sigmoid(self.z)
        self.z3 = np.dot(self.z2, self.W2)
        o = self.sigmoid(self.z3)
        return o
    
    def backward(self, X, y, o):
        self.o_error = y - o
        self.o_delta = self.o_error * self.sigmoid_derivative(o)
        
        self.z2_error = self.o_delta.dot(self.W2.T)
        self.z2_delta = self.z2_error * self.sigmoid_derivative(self.z2)
        
        self.W1 += X.T.dot(self.z2_delta)
        self.W2 += self.z2.T.dot(self.o_delta)
        
    def train(self, X, y, epochs):
        for epoch in range(epochs):
            o = self.forward(X)
            self.backward(X, y, o)
            
    def predict(self, X):
        return self.forward(X)

这个神经网络包含一个输入层，一个隐藏层和一个输出层。我们使用sigmoid函数作为激活函数，使用反向传播算法进行训练。

在构造函数中，我们使用随机权重初始化网络的权重。

在forward方法中，我们首先计算输入层到隐藏层的加权和，然后使用sigmoid函数作为激活函数。接下来，我们计算隐藏层到输出层的加权和，并再次使用sigmoid函数作为激活函数。最后，我们返回输出层的输出。

在backward方法中，我们计算输出层的误差和delta值。然后，我们计算隐藏层的误差和delta值。最后，我们根据误差和delta值更新权重。

在train方法中，我们迭代训练神经网络。在每次迭代中，我们计算输出并更新权重。

在predict方法中，我们使用训练得到的权重来预测输出。

下面是一个使用该神经网络解决XOR问题的例子：

X = np.array([[0,0],[0,1],[1,0],[1,1]])
y = np.array([[0],[1],[1],[0]])

nn = NeuralNetwork(2, 3, 1)
nn.train(X, y, 10000)

print(nn.predict(np.array([0,1])))

输出：

[[ 0.9859321]]

可以看到，我们的神经网络成功地学习了XOR问题。