BP神经网络正则化代码

BP神经网络正则化是为了避免过拟合现象而进行的一种处理方法，主要有L1正则化和L2正则化两种方式。其中L1正则化的处理方法是将权重矩阵中的每个元素都乘以一个小于1的缩小因子，而L2正则化的处理方法是将权重矩阵中的每个元素都乘以一个小于1的缩小因子的平方。

以下是一个使用L2正则化的BP神经网络代码示例：

import numpy as np

class NeuralNetwork:
    
    def __init__(self, input_dim, hidden_dim, output_dim, lambda_val):
        self.input_dim = input_dim
        self.hidden_dim = hidden_dim
        self.output_dim = output_dim
        self.lambda_val = lambda_val
        
        self.W1 = np.random.randn(self.input_dim, self.hidden_dim) / np.sqrt(self.input_dim)
        self.b1 = np.zeros((1, self.hidden_dim))
        self.W2 = np.random.randn(self.hidden_dim, self.output_dim) / np.sqrt(self.hidden_dim)
        self.b2 = np.zeros((1, self.output_dim))
        
    def sigmoid(self, x):
        return 1.0 / (1.0 + np.exp(-x))
    
    def sigmoid_prime(self, x):
        return self.sigmoid(x) * (1 - self.sigmoid(x))
    
    def feedforward(self, X):
        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
        exp_scores = np.exp(self.z2)
        probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)
        return probs
    
    def calculate_loss(self, X, y):
        num_examples = len(X)
        probs = self.feedforward(X)
        logprobs = -np.log(probs[range(num_examples), y])
        data_loss = np.sum(logprobs)
        data_loss += self.lambda_val/2 * (np.sum(np.square(self.W1)) + np.sum(np.square(self.W2)))
        return 1./num_examples * data_loss
    
    def predict(self, X):
        probs = self.feedforward(X)
        return np.argmax(probs, axis=1)
    
    def backpropagation(self, X, y):
        num_examples = len(X)
        
        delta3 = self.feedforward(X)
        delta3[range(num_examples), y] -= 1
        dW2 = (self.a1.T).dot(delta3)
        db2 = np.sum(delta3, axis=0, keepdims=True)
        
        delta2 = delta3.dot(self.W2.T) * self.sigmoid_prime(self.z1)
        dW1 = np.dot(X.T, delta2)
        db1 = np.sum(delta2, axis=0)
        
        dW2 += self.lambda_val * self.W2
        dW1 += self.lambda_val * self.W1
        
        return dW1, db1, dW2, db2
    
    def train(self, X, y, num_passes=20000, learning_rate=0.01):
        
        for i in range(num_passes):
            dW1, db1, dW2, db2 = self.backpropagation(X,y)
            
            self.W1 -= learning_rate * dW1
            self.b1 -= learning_rate * db1
            self.W2 -= learning_rate * dW2
            self.b2 -= learning_rate * db2
            
            if i % 1000 == 0:
                print("Loss after iteration %i: %f" %(i, self.calculate_loss(X,y)))

以上代码中，NeuralNetwork类的构造函数中输入参数依次为输入层维度、隐藏层维度、输出层维度和正则化因子。其中，初始化权重矩阵时使用的是随机高斯分布，并且通过除以根号下输入层或隐藏层维度来缩放权重矩阵。在feedforward方法中，首先计算z值和激活函数值，然后通过softmax函数计算输出概率。在calculate_loss方法中，计算交叉熵损失和L2正则化损失之和。在backpropagation方法中，首先计算输出层误差，然后反向传播计算隐藏层误差，最后计算梯度并添加L2正则化项。在train方法中，迭代训练神经网络并打印出每一次迭代后的损失值。