पायटोरच में, सक्रियताओं के लिए एल 1 नियमितकर्ता को कैसे जोड़ना है?

Question

(यहां पिटोरच शुरुआती)

मैं एक आरएलयू से सक्रियण आउटपुट में एल 1 नियमितकर्ता जोड़ना चाहता हूं। अधिक आम तौर पर, नेटवर्क में किसी विशेष परत के लिए केवल एक नियमितकर्ता कैसे जोड़ता है?

इस पोस्ट से संबंधित हो सकता है: Adding L1/L2 regularization in PyTorch? हालांकि या तो इसे संबंधित नहीं है, वरना मैं इस सवाल का जवाब समझ में नहीं आता:

यह एक एल 2 regularizer अनुकूलन, जो एक अलग बात है में लागू को देखें। दूसरे शब्दों में, अगर समग्र वांछित नुकसान

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

मेरा मानना ​​है कि पैरामीटर torch.optim.Adagrad को आपूर्ति केवल क्रोस एंट्रोपी नुकसान के लिए लागू किया जाता है। या शायद यह नेटवर्क पर सभी पैरामीटर (भार) पर लागू होता है। लेकिन किसी भी मामले में यह सक्रियण की एक परत, पर एक नियमितकर्ता को लागू करने की अनुमति नहीं देता है और एल 1 हानि प्रदान नहीं करता है।

एक और प्रासंगिक विषय nn.modules.loss है, जिसमें L1Loss() शामिल है। प्रलेखन से, मुझे अभी तक यह समझ नहीं आया कि इसका उपयोग कैसे किया जाए।

आखिरकार, यह मॉड्यूल https://github.com/pytorch/pytorch/blob/master/torch/legacy/nn/L1Penalty.py है जो लक्ष्य के सबसे नज़दीक लगता है, लेकिन इसे "विरासत" कहा जाता है। ऐसा क्यों है?

Answer 1

यहाँ कैसे आप ऐसा करते हैं है:

• में अपने मॉड्यूल के आगे लौट अंतिम आउटपुट और परतें 'उत्पादन जिसके लिए आप एल 1 नियमितीकरण लागू करना चाहते हैं
• loss चर उत्पादन के पार एन्ट्रापी हानि का योग होगा wrt लक्ष्य और एल 1 दंड।

यहाँ एक उदाहरण कोड

import torch 
from torch.autograd import Variable 
from torch.nn import functional as F 


class MLP(torch.nn.Module): 
    def __init__(self): 
     super(MLP, self).__init__() 
     self.linear1 = torch.nn.Linear(128, 32) 
     self.linear2 = torch.nn.Linear(32, 16) 
     self.linear3 = torch.nn.Linear(16, 2) 

    def forward(self, x): 
     layer1_out = F.relu(self.linear1(x)) 
     layer2_out = F.relu(self.linear2(layer1_out)) 
     out = self.linear3(layer2_out) 
     return out, layer1_out, layer2_out 


def l1_penalty(var): 
    return torch.abs(var).sum() 


def l2_penalty(var): 
    return torch.sqrt(torch.pow(var, 2).sum()) 


batchsize = 4 
lambda1, lambda2 = 0.5, 0.01 

model = MLP() 
optimizer = torch.optim.SGD(model.parameters(), lr=1e-4) 

# usually following code is looped over all batches 
# but let's just do a dummy batch for brevity 

inputs = Variable(torch.rand(batchsize, 128)) 
targets = Variable(torch.ones(batchsize).long()) 

optimizer.zero_grad() 
outputs, layer1_out, layer2_out = model(inputs) 
cross_entropy_loss = F.cross_entropy(outputs, targets) 
l1_regularization = lambda1 * l1_penalty(layer1_out) 
l2_regularization = lambda2 * l2_penalty(layer2_out) 

loss = cross_entropy_loss + l1_regularization + l2_regularization 
loss.backward() 
optimizer.step()