神经网络算法多层感知机代码实现

以下是一个使用Python实现多层感知机的示例代码：

import numpy as np

class MLP(object):
    def __init__(self, input_dim, hidden_dim, output_dim):
        """
        input_dim: 输入层维度
        hidden_dim: 隐藏层维度
        output_dim: 输出层维度
        """
        self.input_dim = input_dim
        self.hidden_dim = hidden_dim
        self.output_dim = output_dim
        self.W1 = np.random.randn(input_dim, hidden_dim)
        self.b1 = np.zeros((1, hidden_dim))
        self.W2 = np.random.randn(hidden_dim, output_dim)
        self.b2 = np.zeros((1, output_dim))

    def sigmoid(self, x):
        return 1 / (1 + np.exp(-x))

    def sigmoid_derivative(self, x):
        return x * (1 - x)

    def forward(self, X):
        """
        前向传播
        X: 输入数据，形状为(N, input_dim)
        """
        self.z1 = np.dot(X, self.W1) + self.b1
        self.a1 = self.sigmoid(self.z1)
        self.z2 = np.dot(self.a1, self.W2) + self.b2
        self.y_hat = self.sigmoid(self.z2)
        return self.y_hat

    def backward(self, X, y, y_hat, learning_rate):
        """
        反向传播
        X: 输入数据，形状为(N, input_dim)
        y: 标签，形状为(N, output_dim)
        y_hat: 预测值，形状为(N, output_dim)
        learning_rate: 学习率
        """
        delta2 = (y - y_hat) * self.sigmoid_derivative(y_hat)
        dW2 = np.dot(self.a1.T, delta2)
        db2 = np.sum(delta2, axis=0, keepdims=True)
        delta1 = np.dot(delta2, self.W2.T) * self.sigmoid_derivative(self.a1)
        dW1 = np.dot(X.T, delta1)
        db1 = np.sum(delta1, axis=0)
        self.W2 += learning_rate * dW2
        self.b2 += learning_rate * db2
        self.W1 += learning_rate * dW1
        self.b1 += learning_rate * db1

    def train(self, X, y, epochs, learning_rate):
        """
        训练模型
        X: 输入数据，形状为(N, input_dim)
        y: 标签，形状为(N, output_dim)
        epochs: 训练轮数
        learning_rate: 学习率
        """
        for i in range(epochs):
            y_hat = self.forward(X)
            self.backward(X, y, y_hat, learning_rate)

    def predict(self, X):
        """
        预测
        X: 输入数据，形状为(N, input_dim)
        """
        y_hat = self.forward(X)
        return np.round(y_hat)

这里实现了一个简单的二分类多层感知机，其中使用sigmoid函数作为激活函数，使用交叉熵作为损失函数。训练过程使用批量梯度下降算法。可以根据需要修改参数和激活函数等。