neural network - पाइटोरेक, क्रमिक तर्क क्या हैं




neural-network gradient (2)

व्याख्या

तंत्रिका नेटवर्क के लिए, हम आम तौर पर यह आकलन करने के लिए loss का उपयोग करते हैं कि नेटवर्क ने इनपुट छवि (या अन्य कार्यों) को वर्गीकृत करने के लिए कितना अच्छा सीखा है। loss शब्द आमतौर पर एक अदिश मान होता है। नेटवर्क के मापदंडों को अद्यतन करने के लिए, हमें मापदंडों को loss wrt के ग्रेडिएंट की गणना करने की आवश्यकता है, जो वास्तव में गणना ग्राफ में leaf node है (वैसे, ये पैरामीटर ज्यादातर विभिन्न परतों के वजन और पूर्वाग्रह हैं जैसे कि रूपांतरण , रैखिक और इतने पर)।

श्रृंखला नियम के अनुसार, एक पत्ती नोड के लिए loss wrt के ग्रेडिएंट की गणना करने के लिए, हम कुछ मध्यवर्ती संस्करण के loss wrt के व्युत्पन्न की गणना कर सकते हैं, और पत्ती चर के लिए मध्यवर्ती चर wrt के ढाल, एक डॉट उत्पाद करते हैं और इन्हें योग करते हैं।

एक Variable के backward() विधि के gradient तर्कों का उपयोग एक Variable के प्रत्येक तत्व के भारित राशि की गणना करने के लिए किया जाता है ये वजन केवल मध्यवर्ती चर के प्रत्येक तत्व को अंतिम loss wrt की व्युत्पत्ति है।

एक ठोस उदाहरण

आइए इसे समझने के लिए एक ठोस और सरल उदाहरण लें।

from torch.autograd import Variable
import torch
x = Variable(torch.FloatTensor([[1, 2, 3, 4]]), requires_grad=True)
z = 2*x
loss = z.sum(dim=1)

# do backward for first element of z
z.backward(torch.FloatTensor([[1, 0, 0, 0]]), retain_graph=True)
print(x.grad.data)
x.grad.data.zero_() #remove gradient in x.grad, or it will be accumulated

# do backward for second element of z
z.backward(torch.FloatTensor([[0, 1, 0, 0]]), retain_graph=True)
print(x.grad.data)
x.grad.data.zero_()

# do backward for all elements of z, with weight equal to the derivative of
# loss w.r.t z_1, z_2, z_3 and z_4
z.backward(torch.FloatTensor([[1, 1, 1, 1]]), retain_graph=True)
print(x.grad.data)
x.grad.data.zero_()

# or we can directly backprop using loss
loss.backward() # equivalent to loss.backward(torch.FloatTensor([1.0]))
print(x.grad.data)    

उपरोक्त उदाहरण में, पहले print का परिणाम है

२ ० ० ०
[torch.FloatTensor का आकार 1x4]

जो कि बिल्कुल x से z_1 wrt का व्युत्पन्न है।

दूसरे print का परिणाम है:

० २ ० ०
[torch.FloatTensor का आकार 1x4]

जो x से z_2 wrt का व्युत्पन्न है।

अब अगर z wrt की व्युत्पत्ति की गणना करने के लिए [1, 1, 1, 1] के वजन का उपयोग किया जाता है, तो परिणाम 1*dz_1/dx + 1*dz_2/dx + 1*dz_3/dx + 1*dz_4/dx । तो कोई आश्चर्य नहीं, 3 print का आउटपुट है:

२ २ २ २
[torch.FloatTensor का आकार 1x4]

यह ध्यान दिया जाना चाहिए कि वजन वेक्टर [1, 1, 1, 1] zt, z_2, z_3 और z_4 के loss wrt से बिल्कुल व्युत्पन्न है। x को loss wrt के व्युत्पन्न की गणना इस प्रकार की जाती है:

d(loss)/dx = d(loss)/dz_1 * dz_1/dx + d(loss)/dz_2 * dz_2/dx + d(loss)/dz_3 * dz_3/dx + d(loss)/dz_4 * dz_4/dx

तो 4th print का आउटपुट 3rd print के समान है:

२ २ २ २
[torch.FloatTensor का आकार 1x4]

मैं PyTorch के प्रलेखन के माध्यम से पढ़ रहा हूं और एक उदाहरण मिला जहां वे लिखते हैं

gradients = torch.FloatTensor([0.1, 1.0, 0.0001])
y.backward(gradients)
print(x.grad)

जहाँ x एक प्रारंभिक चर था, जहाँ से y (3-वेक्टर) का निर्माण किया गया था। सवाल यह है कि ग्रेडिएंट टेंसर के 0.1, 1.0 और 0.0001 तर्क क्या हैं? उस पर प्रलेखन बहुत स्पष्ट नहीं है।


आमतौर पर, आपके कम्प्यूटेशनल ग्राफ में एक स्केलर आउटपुट के loss । तो फिर तुम loss.backward() द्वारा वजन wrt वजन (ढाल) की ढाल की गणना कर सकते हैं। जहां backward() का डिफ़ॉल्ट तर्क backward() 1.0

यदि आपके आउटपुट में कई मान हैं (जैसे loss=[loss1, loss2, loss3] ), तो आप लॉस के नुकसान को कम करने वाले ग्रैडिएंट्स की गणना loss.backward(torch.FloatTensor([1.0, 1.0, 1.0]))

इसके अलावा, यदि आप अलग-अलग नुकसान के लिए वजन या loss.backward(torch.FloatTensor([-0.1, 1.0, 0.0001])) जोड़ना चाहते हैं, तो आप loss.backward(torch.FloatTensor([-0.1, 1.0, 0.0001])) उपयोग कर सकते हैं।

इसका अर्थ है -0.1*d(loss1)/dw, d(loss2)/dw, 0.0001*d(loss3)/dw एक साथ -0.1*d(loss1)/dw, d(loss2)/dw, 0.0001*d(loss3)/dw