相关疑难解决方法(0)

(pytorch初学者在这里)

我想将L1正则化器添加到ReLU的激活输出中.更一般地说,如何仅将规则化器添加到网络中的特定层？

这篇文章可能有关: 在PyTorch中添加L1/L2正则化？ 但无论是否相关,或者我不明白答案:

它指的是在优化中应用的L2正则化器,这是另一回事.换句话说,如果总的期望损失是

crossentropy + lambda1*L1(layer1) + lambda2*L1(layer2) + ...

我相信提供给torch.optim.Adagrad的参数仅适用于交叉熵损失.或者它可能适用于整个网络的所有参数(权重).但无论如何,它似乎不允许将单一的正则化应用于单层激活,并且不会提供L1损失.

另一个相关主题是nn.modules.loss,其中包含L1Loss().从文档中,我还不知道如何使用它.

最后,有一个模块https://github.com/pytorch/pytorch/blob/master/torch/legacy/nn/L1Penalty.py似乎最接近目标,但它被称为"遗产".这是为什么？

我在下面编写了这段代码，以尝试了解这些钩子发生了什么。

class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.fc1 = nn.Linear(10,5)
        self.fc2 = nn.Linear(5,1)
        self.fc1.register_forward_hook(self._forward_hook)
        self.fc1.register_backward_hook(self._backward_hook)
    
    def forward(self, inp):
        return self.fc2(self.fc1(inp))

    def _forward_hook(self, module, input, output):
        print(type(input))
        print(len(input))
        print(type(output))
        print(input[0].shape)
        print(output.shape)
        print()

    def _backward_hook(self, module, grad_input, grad_output):
        print(type(grad_input))
        print(len(grad_input))
        print(type(grad_output))
        print(len(grad_output))
        print(grad_input[0].shape)
        print(grad_input[1].shape)
        print(grad_output[0].shape)
        print()

model = Model()
out = model(torch.tensor(np.arange(10).reshape(1,1,10), dtype=torch.float32))
out.backward()

产生输出

<class 'tuple'>
1
<class 'torch.Tensor'>
torch.Size([1, 1, 10])
torch.Size([1, 1, 5])

<class 'tuple'>
2
<class 'tuple'>
1
torch.Size([1, 1, 5])
torch.Size([5])
torch.Size([1, 1, 5])

您还可以按照此处的CNN 示例进行操作。事实上，需要理解我的问题的其余部分。 …

我正在尝试在简单神经网络的第一层（1 个隐藏层）上实现 L1 正则化。我查看了 StackOverflow 上的一些其他帖子，这些帖子使用 Pytorch 应用 l1 正则化来弄清楚它应该如何完成（参考：在 PyTorch 中添加 L1/L2 正则化？，在 Pytorch 中，如何将 L1 正则化添加到激活中？）。无论我将 lambda（l1 正则化强度参数）增加多高，我都不会在第一个权重矩阵中得到真正的零。为什么会这样？（代码如下）

import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np

class Network(nn.Module):
    def __init__(self,nf,nh,nc):
        super(Network,self).__init__()
        self.lin1=nn.Linear(nf,nh)
        self.lin2=nn.Linear(nh,nc)

    def forward(self,x):
        l1out=F.relu(self.lin1(x))
        out=F.softmax(self.lin2(l1out))
        return out, l1out

def l1loss(layer):
    return torch.norm(layer.weight.data, p=1)

nf=10
nc=2
nh=6
learningrate=0.02
lmbda=10.
batchsize=50

net=Network(nf,nh,nc)

crit=nn.MSELoss()
optimizer=torch.optim.Adagrad(net.parameters(),lr=learningrate)


xtr=torch.Tensor(xtr)
ytr=torch.Tensor(ytr)
#ytr=torch.LongTensor(ytr)
xte=torch.Tensor(xte)
yte=torch.LongTensor(yte)
#cyte=torch.Tensor(yte)

it=200
for epoch in range(it):
    per=torch.randperm(len(xtr))
    for i …