L1和L2正则化python代码实现

L1和L2正则化是机器学习中的两个常用技术，用于防止过拟合。它们通过向模型的成本函数添加惩罚项，使得模型的权重变得更小，简单来说就是鼓励模型使用更少的特征。

**L1正则化 (Lasso Regression)**:
L1正则化也叫Lasso回归，它对权重施加的是绝对值的惩罚。Python中sklearn库中的`Lasso`实现了这个：

from sklearn.linear_model import Lasso

# 初始化模型
lasso = Lasso(alpha=0.1) # alpha控制正则化的强度

# 训练模型
lasso.fit(X_train, y_train)

# 预测
y_pred = lasso.predict(X_test)

其中，`alpha`是正则化系数，如果设为非零值，会使得某些权重变为0，这就是著名的“稀疏性”效果。

**L2正则化 (Ridge Regression)**:
L2正则化对权重施加的是平方的惩罚。sklearn的`Ridge`类可以实现：

from sklearn.linear_model import Ridge

# 初始化模型
ridge = Ridge(alpha=0.5) 

# 训练模型
ridge.fit(X_train, y_train)

# 预测
y_pred = ridge.predict(X_test)

同样，`alpha`决定了正则化的程度。

相关问题

用梯度下降算法实现Logistic回归的L1正则化和L2正则化python代码

下面是用梯度下降算法实现Logistic回归的L1正则化和L2正则化的Python代码：

import numpy as np

class LogisticRegression:
    def __init__(self, lr=0.1, num_iter=1000, fit_intercept=True, regularization=None, lambda_=0.1):
        self.lr = lr
        self.num_iter = num_iter
        self.fit_intercept = fit_intercept
        self.regularization = regularization
        self.lambda_ = lambda_
    
    def __add_intercept(self, X):
        intercept = np.ones((X.shape[0], 1))
        return np.concatenate((intercept, X), axis=1)
    
    def __sigmoid(self, z):
        return 1 / (1 + np.exp(-z))
    
    def __loss(self, h, y):
        return (-y * np.log(h) - (1 - y) * np.log(1 - h)).mean()
    
    def __l1_regularization(self, w):
        return self.lambda_ * np.abs(w[1:]).sum()
    
    def __l2_regularization(self, w):
        return self.lambda_ * np.sum(w[1:] ** 2)
    
    def fit(self, X, y):
        if self.fit_intercept:
            X = self.__add_intercept(X)
        
        self.theta = np.zeros(X.shape[1])
        
        for i in range(self.num_iter):
            z = np.dot(X, self.theta)
            h = self.__sigmoid(z)
            
            if self.regularization == 'l1':
                # L1正则化
                grad = np.dot(X.T, (h - y)) / y.size + self.lambda_ * np.sign(self.theta)
            elif self.regularization == 'l2':
                # L2正则化
                grad = np.dot(X.T, (h - y)) / y.size + self.lambda_ * self.theta
            else:
                grad = np.dot(X.T, (h - y)) / y.size
            
            self.theta -= self.lr * grad
    
    def predict_prob(self, X):
        if self.fit_intercept:
            X = self.__add_intercept(X)
    
        return self.__sigmoid(np.dot(X, self.theta))
    
    def predict(self, X, threshold=0.5):
        return self.predict_prob(X) >= threshold

其中，lr是学习率，num_iter是迭代次数，fit_intercept表示是否拟合截距，regularization表示正则化方法，lambda_是正则化系数。在fit方法中，通过判断regularization的取值，来实现L1正则化和L2正则化。在L1正则化中，使用np.sign函数计算符号函数，而在L2正则化中，直接对参数的平方和进行惩罚。在predict_prob方法中，对X进行截距拟合和sigmoid变换，返回预测概率。在predict方法中，对预测概率进行阈值处理，返回预测结果。

pytorch实现l1和l2正则化

要使用PyTorch实现L1和L2正则化，可以通过在损失函数中添加相应的正则化项来实现。下面是一个简单的示例：

import torch
import torch.nn as nn
import torch.optim as optim

# 定义模型
class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.linear = nn.Linear(10, 1)

    def forward(self, x):
        return self.linear(x)

model = MyModel()

# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 定义正则化权重
l1_lambda = 0.01
l2_lambda = 0.01

# 训练循环
for epoch in range(num_epochs):
    for inputs, targets in data_loader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, targets)

        # 添加L1正则化
        l1_reg = torch.tensor(0.)
        for param in model.parameters():
            l1_reg += torch.norm(param, 1)
        loss += l1_lambda * l1_reg

        # 添加L2正则化
        l2_reg = torch.tensor(0.)
        for param in model.parameters():
            l2_reg += torch.norm(param, 2)
        loss += l2_lambda * l2_reg

        loss.backward()
        optimizer.step()

在上述代码中，我们定义了一个`MyModel`类来表示我们的模型。然后，我们使用`nn.MSELoss()`作为损失函数，并使用`optim.SGD`作为优化器。在训练循环中，我们通过遍历模型的参数并计算其L1和L2范数来计算正则化项。然后将正则化项加到损失函数中，通过调整`l1_lambda`和`l2_lambda`参数来控制正则化的强度。最后，我们进行反向传播和参数更新以完成训练。

请注意，这只是一个简单的示例，实际应用中可能还会有其他细节需要考虑，如权重衰减（weight decay）等。