अजगर: Vectorize गणना का उपयोग कर कार्यान्वित किया चलने का दृष्टिकोण

के बाद से आप काम कर रहे हैं के साथ तीन आयामों n, mहै , और c (लोअरकेस में अस्पष्टता से बचने के लिए), यह कर सकते हैं उपयोगी हो करने के लिए का आकार बदलने सभी अपने tensors के लिए (n, m, c), नकल करके अपने मूल्यों से अधिक लापता आयाम (उदा. M(m, c) हो जाता है M(n, m, c)).

हालांकि, अगर आप को छोड़ कर सकते हैं स्पष्ट प्रतिकृति का उपयोग करें और प्रसारण, तो यह करने के लिए पर्याप्त है unsqueeze लापता आयाम (उदा. M(m, c) हो जाता है M(1, m, c).

इन बातों को देखते हुए, के vectorization के अपने कोड हो जाता है के रूप में इस प्रकार है

cond = y.unsqueeze(2) == torch.arange(M.size(dim=1)).unsqueeze(0)
pos = ds.unsqueeze(2) * M.unsqueeze(1) * cond
neg = ds.unsqueeze(2) * M.unsqueeze(1).sum(dim=0, keepdim=True) * ~cond
grad += (pos - neg).sum(dim=0)

यहाँ है एक छोटे से परीक्षण करने के लिए वैधता की जांच के लिए समाधान

import torch

n, m, c = 11, 5, 7

y = torch.randint(c, size=(n, 1))
ds = torch.rand(n, m)
M = torch.randint(2, size=(n, c))
grad = torch.rand(m, c)


def slow_grad(y, ds, M, grad):
    for i in range(M.size(dim=1)):
        for j in range(ds.size(dim=0)):
            if y[j] == i:
                grad[:,i] = grad[:,i] - (ds[j,:].T * sum(M[j,:]))
            else:
                if M[j,i] > 0:
                    grad[:,i] = grad[:,i] + ds[j,:].T
    return grad


def fast_grad(y, ds, M, grad):
    cond = y.unsqueeze(2) == torch.arange(M.size(dim=1)).unsqueeze(0)
    pos = ds.unsqueeze(2) * M.unsqueeze(1) * cond
    neg = ds.unsqueeze(2) * M.unsqueeze(1).sum(dim=0, keepdim=True) * ~cond
    grad += (pos - neg).sum(dim=0)
    return grad
  
# Assert equality of all elements function outputs, throws an exception if false
assert torch.all(slow_grad(y, ds, M, grad) == fast_grad(y, ds, M, grad))

महसूस नि: शुल्क परीक्षण के लिए पर अन्य मामलों में के रूप में अच्छी तरह से!