BP防止过拟合正则化代码Jupyter

以下是一个简单的使用L2正则化防止过拟合的BP神经网络的代码示例，可以在Jupyter Notebook中运行：

import numpy as np
import matplotlib.pyplot as plt

# 定义激活函数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# 定义L2正则化损失函数
def compute_cost(AL, Y, parameters, lambd):
    m = Y.shape[1]
    L = len(parameters) // 2
    cross_entropy_cost = -np.sum(Y*np.log(AL) + (1-Y)*np.log(1-AL)) / m
    L2_regularization_cost = 0
    for l in range(1, L+1):
        L2_regularization_cost += np.sum(np.square(parameters['W'+str(l)]))
    L2_regularization_cost *= lambd / (2*m)
    cost = cross_entropy_cost + L2_regularization_cost
    return cost

# 定义反向传播函数
def backward_propagation(parameters, cache, X, Y, lambd):
    m = X.shape[1]
    L = len(parameters) // 2
    dZ = cache['A'+str(L)] - Y
    grads = {}
    for l in reversed(range(1, L+1)):
        grads['dW'+str(l)] = np.dot(dZ, cache['A'+str(l-1)].T) / m + lambd/m*parameters['W'+str(l)]
        grads['db'+str(l)] = np.sum(dZ, axis=1, keepdims=True) / m
        if l > 1:
            dA_prev = np.dot(parameters['W'+str(l)].T, dZ)
            dZ = dA_prev * cache['A'+str(l-1)] * (1 - cache['A'+str(l-1)])
    return grads

# 定义训练函数
def train(X, Y, layer_dims, learning_rate, num_iterations, lambd):
    np.random.seed(1)
    costs = []
    parameters = {}
    L = len(layer_dims) - 1
    for l in range(1, L+1):
        parameters['W'+str(l)] = np.random.randn(layer_dims[l], layer_dims[l-1]) / np.sqrt(layer_dims[l-1])
        parameters['b'+str(l)] = np.zeros((layer_dims[l], 1))
    for i in range(num_iterations):
        AL, cache = forward_propagation(X, parameters)
        cost = compute_cost(AL, Y, parameters, lambd)
        grads = backward_propagation(parameters, cache, X, Y, lambd)
        for l in range(1, L+1):
            parameters['W'+str(l)] -= learning_rate * grads['dW'+str(l)]
            parameters['b'+str(l)] -= learning_rate * grads['db'+str(l)]
        if i % 100 == 0:
            print("Cost after iteration {}: {:.6f}".format(i, cost))
        if i % 10 == 0:
            costs.append(cost)
    plt.plot(np.squeeze(costs))
    plt.ylabel('cost')
    plt.xlabel('iterations (per tens)')
    plt.title("Learning rate =" + str(learning_rate))
    plt.show()
    return parameters

# 定义预测函数
def predict(X, parameters):
    AL, cache = forward_propagation(X, parameters)
    predictions = (AL > 0.5)
    return predictions

# 定义前向传播函数
def forward_propagation(X, parameters):
    cache = {}
    A = X
    L = len(parameters) // 2
    for l in range(1, L):
        Z = np.dot(parameters['W'+str(l)], A) + parameters['b'+str(l)]
        A = sigmoid(Z)
        cache['Z'+str(l)] = Z
        cache['A'+str(l)] = A
    ZL = np.dot(parameters['W'+str(L)], A) + parameters['b'+str(L)]
    AL = sigmoid(ZL)
    cache['Z'+str(L)] = ZL
    cache['A'+str(L)] = AL
    return AL, cache

使用示例：

# 生成随机训练数据
m = 1000
X = np.random.randn(2, m)
Y = np.zeros((1, m))
Y[(X[0,:]**2 + X[1,:]**2) < 1] = 1

# 训练模型
parameters = train(X, Y, [2, 10, 5, 1], 0.05, 2000, 0.01)

# 预测结果
predictions = predict(X, parameters)

# 绘制决策边界
x_min, x_max = X[0,:].min() - 0.1, X[0,:].max() + 0.1
y_min, y_max = X[1,:].min() - 0.1, X[1,:].max() + 0.1
xx, yy = np.meshgrid(np.linspace(x_min, x_max, 500), np.linspace(y_min, y_max, 500))
Z = predict(np.c_[xx.ravel(), yy.ravel()].T, parameters)
Z = Z.reshape(xx.shape)
plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)
plt.scatter(X[0,:], X[1,:], c=Y, cmap=plt.cm.Spectral)
plt.show()

这里使用了一个简单的二分类问题进行演示，你可以根据自己的需求修改数据和神经网络结构。在训练函数中，我们将L2正则化系数作为一个额外的参数传递。在反向传播函数中，我们在计算权重梯度时加入了正则化项。在计算损失函数时，我们首先计算交叉熵损失，然后再加上L2正则化损失。