python人工智能神经网络学习代码

以下是使用Python实现神经网络学习的代码示例：

首先，我们需要导入必要的Python模块：

import numpy as np
import matplotlib.pyplot as plt

接下来，我们定义一个神经网络的类：

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.weights_ih = np.random.randn(self.hidden_size, self.input_size)
        self.weights_ho = np.random.randn(self.output_size, self.hidden_size)
        
        # 初始化偏置
        self.bias_h = np.zeros((self.hidden_size, 1))
        self.bias_o = np.zeros((self.output_size, 1))
        
        # 设置学习率
        self.learning_rate = 0.1

在神经网络的初始化方法中，我们定义了神经网络的输入层大小、隐藏层大小和输出层大小，并初始化了权重和偏置。我们还设置了学习率。

接下来，我们定义神经网络的前向传播方法：

    def forward(self, x):
        # 计算隐藏层的值
        hidden = np.dot(self.weights_ih, x) + self.bias_h
        hidden = 1 / (1 + np.exp(-hidden))
        
        # 计算输出层的值
        output = np.dot(self.weights_ho, hidden) + self.bias_o
        output = 1 / (1 + np.exp(-output))
        
        return output

在前向传播方法中，我们首先计算隐藏层的值，然后使用Sigmoid函数进行激活。接着，我们计算输出层的值，并使用Sigmoid函数进行激活。最后，我们返回输出层的值。

接下来，我们定义神经网络的反向传播方法：

    def backward(self, x, y, output):
        # 计算输出层的误差
        error_output = output - y
        # 计算输出层的梯度
        gradient_output = output * (1 - output)
        # 计算输出层的权重更新
        delta_weights_ho = np.dot(error_output * gradient_output, self.hidden.T)
        # 计算输出层的偏置更新
        delta_bias_o = np.sum(error_output * gradient_output, axis=1, keepdims=True)
        
        # 计算隐藏层的误差
        error_hidden = np.dot(self.weights_ho.T, error_output)
        # 计算隐藏层的梯度
        gradient_hidden = self.hidden * (1 - self.hidden)
        # 计算隐藏层的权重更新
        delta_weights_ih = np.dot(error_hidden * gradient_hidden, x.T)
        # 计算隐藏层的偏置更新
        delta_bias_h = np.sum(error_hidden * gradient_hidden, axis=1, keepdims=True)
        
        # 更新权重和偏置
        self.weights_ho -= self.learning_rate * delta_weights_ho
        self.bias_o -= self.learning_rate * delta_bias_o
        self.weights_ih -= self.learning_rate * delta_weights_ih
        self.bias_h -= self.learning_rate * delta_bias_h

在反向传播方法中，我们首先计算输出层的误差，然后计算输出层的梯度和权重更新。接着，我们计算隐藏层的误差，然后计算隐藏层的梯度和权重更新。最后，我们使用更新的权重和偏置来更新神经网络。

最后，我们定义一个训练方法来训练神经网络：

    def train(self, x_train, y_train, epochs):
        for epoch in range(epochs):
            for i in range(len(x_train)):
                x = x_train[i].reshape(self.input_size, 1)
                y = y_train[i].reshape(self.output_size, 1)
                
                # 前向传播
                self.hidden = np.dot(self.weights_ih, x) + self.bias_h
                self.hidden = 1 / (1 + np.exp(-self.hidden))
                output = np.dot(self.weights_ho, self.hidden) + self.bias_o
                output = 1 / (1 + np.exp(-output))
                
                # 反向传播
                self.backward(x, y, output)
                
            # 计算损失
            loss = self.loss(x_train, y_train)
            print('Epoch %d/%d - Loss: %f' % (epoch+1, epochs, loss))

在训练方法中，我们首先对每个训练样本进行前向传播和反向传播。然后，我们计算损失并输出日志。

最后，我们定义一个计算损失的方法：

    def loss(self, x, y):
        loss = 0
        for i in range(len(x)):
            x_i = x[i].reshape(self.input_size, 1)
            y_i = y[i].reshape(self.output_size, 1)
            output = self.forward(x_i)
            loss += np.sum(np.square(output - y_i))
        return loss / len(x)

在计算损失方法中，我们对每个训练样本计算预测值和真实值之间的平方误差，并将其加起来。最后，我们将总误差除以训练样本的数量来得到平均损失。

现在，我们可以使用上面定义的神经网络类来训练一个二分类模型。以下是一个示例：

# 定义训练集
x_train = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y_train = np.array([[0], [1], [1], [0]])

# 创建神经网络实例
nn = NeuralNetwork(input_size=2, hidden_size=4, output_size=1)

# 训练神经网络
nn.train(x_train, y_train, epochs=1000)

# 在测试集上进行预测
x_test = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y_test = np.array([[0], [1], [1], [0]])
for i in range(len(x_test)):
    x = x_test[i].reshape(2, 1)
    y = y_test[i].reshape(1, 1)
    output = nn.forward(x)
    print('Input: %s, Output: %s, Target: %s' % (x.T, output.T, y.T))

在这个示例中，我们使用XOR逻辑运算符的训练数据来训练一个二分类模型。我们使用一个包含4个隐藏单元的隐藏层，并在训练过程中进行了1000个迭代。最后，我们在测试集上进行了预测，并打印了每个样本的输入、输出和目标值。