मान लें कि मेरे पास इस तरह एक टेंसर है

w = [[0.1, 0.7, 0.7, 0.8, 0.3],
    [0.3, 0.2, 0.9, 0.1, 0.5],
    [0.1, 0.4, 0.8, 0.3, 0.4]]

अब मैं कुछ शर्तों के आधार पर कुछ मूल्यों को खत्म करना चाहता हूं (उदाहरण के लिए 0.5 से अधिक या नहीं)

w = [[0.1, 0.3],
     [0.3, 0.2, 0.1],
     [0.1, 0.4, 0.3, 0.4]]

फिर इसे बराबर लंबाई में पैड करें:

w = [[0.1, 0.3, 0, 0],
     [0.3, 0.2, 0.1, 0],
     [0.1, 0.4, 0.3, 0.4]]

और इस तरह मैंने इसे पाइटोरच में लागू किया:

w = torch.rand(3, 5)
condition = w <= 0.5
w = [w[i][condition[i]] for i in range(3)]
w = torch.nn.utils.rnn.pad_sequence(w)

लेकिन जाहिर तौर पर यह बेहद धीमी गति से होने वाला है, मुख्यतः सूची की समझ के कारण। क्या इसे करने का कोई बेहतर तरीका है?

1
omer sahban 1 जून 2020, 15:35

1 उत्तर

सबसे बढ़िया उत्तर

यह रहा बूलियन मास्किंग, टेन्सर स्प्लिटिंग< का उपयोग करने का एक सीधा तरीका /a>, और फिर अंततः का उपयोग करके विभाजित टेंसर को पैडिंग करना torch.nn.utils.rnn.pad_sequence(...).

# input tensor to work with
In [213]: w 
Out[213]: 
tensor([[0.1000, 0.7000, 0.7000, 0.8000, 0.3000],
        [0.3000, 0.2000, 0.9000, 0.1000, 0.5000],
        [0.1000, 0.4000, 0.8000, 0.3000, 0.4000]])

# values above this should be clipped from the input tensor
In [214]: clip_value = 0.5 

# generate a boolean mask that satisfies the condition
In [215]: boolean_mask = (w <= clip_value) 

# we need to sum the mask along axis 1 (needed for splitting)
In [216]: summed_mask = boolean_mask.sum(dim=1) 

# a sequence of splitted tensors
In [217]: splitted_tensors = torch.split(w[boolean_mask], summed_mask.tolist())  

# finally pad them along dimension 1 (or axis 1)
In [219]: torch.nn.utils.rnn.pad_sequence(splitted_tensors, 1) 
Out[219]: 
tensor([[0.1000, 0.3000, 0.0000, 0.0000],
        [0.3000, 0.2000, 0.1000, 0.5000],
        [0.1000, 0.4000, 0.3000, 0.4000]])

दक्षता पर एक संक्षिप्त नोट: torch का उपयोग करना .split() सुपर कुशल है क्योंकि यह विभाजित टेंसर को मूल टेंसर के दृश्य के रूप में लौटाता है (यानी कोई प्रतिलिपि नहीं बनाई गई है)।

1
kmario23 1 जून 2020, 20:42