77

有什么办法,我可以在 PyTorch 中添加简单的 L1/L2 正则化吗?我们可以通过简单地添加data_losswith来计算正则化损失,reg_loss但是有没有任何明确的方法,PyTorch 库的任何支持可以更轻松地完成它而无需手动执行?

4

7 回答 7

66

以下应该有助于 L2 正则化:

optimizer = torch.optim.Adam(model.parameters(), lr=1e-4, weight_decay=1e-5)
于 2017-10-06T02:47:25.017 回答
64

这在PyTorch的文档中有所介绍。您可以使用参数将 L2 损失添加weight_decay到优化函数中。

于 2017-03-10T16:46:28.077 回答
23

以前的答案虽然在技术上是正确的,但在性能方面效率低下,并且不是太模块化(很难在每层的基础上应用,例如由keras层提供)。

PyTorch L2 实现

为什么 PyTorchL2torch.optim.Optimizer实例内部实现?

我们看一下torch.optim.SGD源码(目前为功能优化程序),特别是这部分:

for i, param in enumerate(params):
    d_p = d_p_list[i]
    # L2 weight decay specified HERE!
    if weight_decay != 0:
        d_p = d_p.add(param, alpha=weight_decay)
  • 可以看到,d_p(参数的导数,梯度)被修改并重新分配以加快计算速度(不保存临时变量)
  • 它具有O(N)复杂性,没有任何复杂的数学,例如pow
  • 它不涉及autograd在没有任何需要的情况下扩展图形

将其与O(n) **2操作、加法以及参与反向传播进行比较。

数学

让我们看看L2带有正则化因子的方程alpha(L1 ofc 也可以这样做):

L2

如果我们使用L2正则化参数对任何损失求导w(它与损失无关),我们得到:

L2 衍生

所以它只是alpha * weight每个权重的梯度的加法!这正是 PyTorch 在上面所做的!

L1 正则化层

使用这个(和一些 PyTorch 魔法),我们可以提出非常通用的 L1 正则化层,但是让我们看一下 first 的一阶导数L1sgn是 signum 函数,返回1正输入和-1负输入,0对于0):

L1 导数

带有接口的完整代码WeightDecay位于torchlayers 第三方库中,提供诸如仅对权重/偏差/特定命名的参数进行正则化等内容(免责声明:我是作者),但下面概述的想法的本质(见评论):

class L1(torch.nn.Module):
    def __init__(self, module, weight_decay):
        super().__init__()
        self.module = module
        self.weight_decay = weight_decay

        # Backward hook is registered on the specified module
        self.hook = self.module.register_full_backward_hook(self._weight_decay_hook)

    # Not dependent on backprop incoming values, placeholder
    def _weight_decay_hook(self, *_):
        for param in self.module.parameters():
            # If there is no gradient or it was zeroed out
            # Zeroed out using optimizer.zero_grad() usually
            # Turn on if needed with grad accumulation/more safer way
            # if param.grad is None or torch.all(param.grad == 0.0):

            # Apply regularization on it
            param.grad = self.regularize(param)

    def regularize(self, parameter):
        # L1 regularization formula
        return self.weight_decay * torch.sign(parameter.data)

    def forward(self, *args, **kwargs):
        # Simply forward and args and kwargs to module
        return self.module(*args, **kwargs)

如果需要,请在此答案或相应的 PyTorch 文档中阅读有关钩子的更多信息。

而且用法也很简单(应该使用梯度累积和 PyTorch 层):

layer = L1(torch.nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3))

边注

另外,作为旁注,L1正则化没有实现,因为它实际上并没有引起稀疏性(丢失的引用,我认为这是 PyTorch repo 上的一些 GitHub 问题,如果有人有它,请编辑),正如权重等于 0 所理解的那样。

更常见的是,如果权重值达到某个小的预定义量级(0.001例如

于 2021-03-14T22:43:59.807 回答
21

对于 L2 正则化,

l2_lambda = 0.01
l2_reg = torch.tensor(0.)
for param in model.parameters():
    l2_reg += torch.norm(param)
loss += l2_lambda * l2_reg

参考:

于 2018-04-30T12:04:42.203 回答
16

对于 L1 正则化,weight仅包括:

L1_reg = torch.tensor(0., requires_grad=True)
for name, param in model.named_parameters():
    if 'weight' in name:
        L1_reg = L1_reg + torch.norm(param, 1)

total_loss = total_loss + 10e-4 * L1_reg
于 2019-10-24T02:41:51.477 回答
13

开箱即用的 L2 正则化

是的,pytorch优化器有一个名为的参数weight_decay,它对应于 L2 正则化因子:

sgd = torch.optim.SGD(model.parameters(), weight_decay=weight_decay)

L1 正则化实现

L1 没有类似的论点,但是这很容易手动实现:

loss = loss_fn(outputs, labels)
l1_lambda = 0.001
l1_norm = sum(p.abs().sum() for p in model.parameters())

loss = loss + l1_lambda * l1_norm

L2 的等效手动实现将是:

l2_norm = sum(p.pow(2.0).sum() for p in model.parameters())

资料来源:使用 PyTorch 进行深度学习(8.5.2)

于 2021-03-09T08:48:09.280 回答
5

有趣torch.norm的是在 CPU 上较慢,在 GPU 上较直接方法更快。

import torch
x = torch.randn(1024,100)
y = torch.randn(1024,100)

%timeit torch.sqrt((x - y).pow(2).sum(1))
%timeit torch.norm(x - y, 2, 1)

出去:

1000 loops, best of 3: 910 µs per loop
1000 loops, best of 3: 1.76 ms per loop

另一方面:

import torch
x = torch.randn(1024,100).cuda()
y = torch.randn(1024,100).cuda()

%timeit torch.sqrt((x - y).pow(2).sum(1))
%timeit torch.norm(x - y, 2, 1)

出去:

10000 loops, best of 3: 50 µs per loop
10000 loops, best of 3: 26 µs per loop
于 2019-05-02T11:36:45.420 回答