你好我想要一个python的简易神经网络

好的，以下是一个简单的 Python 神经网络的代码示例：

import numpy as np

# 定义神经网络类
class NeuralNetwork:
    def __init__(self, input_neurons, hidden_neurons, output_neurons):
        # 定义神经网络的输入、隐藏和输出层的神经元数量
        self.input_neurons = input_neurons
        self.hidden_neurons = hidden_neurons
        self.output_neurons = output_neurons
        
        # 初始化权重矩阵
        self.weight_ih = np.random.rand(self.hidden_neurons, self.input_neurons)
        self.weight_ho = np.random.rand(self.output_neurons, self.hidden_neurons)
        
        # 初始化偏置向量
        self.bias_h = np.random.rand(self.hidden_neurons, 1)
        self.bias_o = np.random.rand(self.output_neurons, 1)
        
    # 定义 sigmoid 激活函数
    def sigmoid(self, x):
        return 1 / (1 + np.exp(-x))
    
    # 定义神经网络的前向传播函数
    def forward(self, input_data):
        # 计算隐藏层的输入
        hidden_input = np.dot(self.weight_ih, input_data) + self.bias_h
        # 计算隐藏层的输出
        hidden_output = self.sigmoid(hidden_input)
        
        # 计算输出层的输入
        output_input = np.dot(self.weight_ho, hidden_output) + self.bias_o
        # 计算输出层的输出
        output_output = self.sigmoid(output_input)
        
        return output_output
    
    # 定义神经网络的训练函数
    def train(self, input_data, target_data, learning_rate):
        # 进行前向传播，得到输出层的输出
        output = self.forward(input_data)
        
        # 计算输出层的误差
        output_error = target_data - output
        # 计算输出层的梯度
        output_gradient = output * (1 - output) * output_error
        
        # 计算隐藏层的误差
        hidden_error = np.dot(self.weight_ho.T, output_gradient)
        # 计算隐藏层的梯度
        hidden_gradient = self.sigmoid(np.array(hidden_error)) * (1 - self.sigmoid(np.array(hidden_error)))
        
        # 更新权重矩阵和偏置向量
        self.weight_ho += learning_rate * np.dot(output_gradient, np.transpose(np.array([self.sigmoid(np.array(hidden_error))])))
        self.weight_ih += learning_rate * np.dot(hidden_gradient, np.transpose(np.array([input_data])))
        self.bias_o += learning_rate * output_gradient
        self.bias_h += learning_rate * hidden_gradient
        
# 测试神经网络
input_data = np.array([0, 1, 1]) # 输入数据
target_data = np.array([1]) # 目标输出
learning_rate = 0.1 # 学习率

# 创建一个 3-2-1 的神经网络
nn = NeuralNetwork(3, 2, 1)

# 进行 1000 次训练
for i in range(1000):
    nn.train(input_data, target_data, learning_rate)

# 输出测试结果
print(nn.forward(input_data))

这是一个简单的 3-2-1 神经网络，可以通过修改初始化参数来定义其他神经网络。在训练过程中，输入数据和目标输出都是 numpy 数组。可以进行多次训练来逐渐优化神经网络的性能