PyTorch में बैच-इनपुट एलएसटीएम नेटवर्क को सही तरीके से कार्यान्वित कैसे करें?

Question

यह release PyTorch के पुनरावर्ती तंत्रिका नेटवर्क के लिए इनपुट की चर लंबाई के लिए PackedSequence प्रदान करता है। हालांकि, मैंने पाया कि इसे सही तरीके से उपयोग करना थोड़ा मुश्किल है।

एक RNN परत जो pack_padded_sequence से तंग आ चुके थे का उत्पादन ठीक करने के लिए pad_packed_sequence का उपयोग करना, हम एक T x B x N टेन्सर outputs जहां T अधिकतम समय कदम दूर है मिला है, B बैच आकार और N छिपा आकार है। मैंने पाया कि बैच में छोटे अनुक्रमों के लिए, बाद का आउटपुट सभी शून्य होगा।

यहां मेरे प्रश्न हैं।

1. एक भी उत्पादन कार्य जहां एक सभी दृश्यों के अंतिम उत्पादन की आवश्यकता होगी के लिए, सरल outputs[-1] एक गलत परिणाम दे देंगे के बाद से इस टेन्सर कम दृश्यों के लिए शून्य के बहुत सारे हैं। सभी अनुक्रमों के लिए अंतिम अंतिम आउटपुट लाने के लिए अनुक्रम लंबाई से सूचकांक बनाने की आवश्यकता होगी। क्या ऐसा करने का कोई आसान तरीका है?
2. एक बहु उत्पादन कार्य के लिए (जैसे seq2seq), आम तौर पर एक एक रेखीय परत N x O जोड़ सकते हैं और TB x O में T x B x O नयी आकृति प्रदान बैच आउटपुट और गणना सही लक्ष्य TB (आमतौर पर भाषा मॉडल में पूर्णांक) के साथ पार एन्ट्रापी नुकसान होगा। इस स्थिति में, बैच आउटपुट मामलों में इन शून्यों को करते हैं?

Answer 1

प्रश्न 1 - अंतिम timestep

इस कोड है कि मैं पिछले timestep के उत्पादन प्राप्त करने के लिए इस्तेमाल करते हैं। मुझे नहीं पता कि एक आसान समाधान है या नहीं। यदि यह है, तो मैं इसे जानना चाहता हूं। मैंने इस discussion का पालन किया और मेरे last_timestep विधि के लिए सापेक्ष कोड स्निपेट पकड़ा। यह मेरा आगे है।

class BaselineRNN(nn.Module): 
    def __init__(self, **kwargs): 
     ... 

    def last_timestep(self, unpacked, lengths): 
     # Index of the last output for each sequence. 
     idx = (lengths - 1).view(-1, 1).expand(unpacked.size(0), 
               unpacked.size(2)).unsqueeze(1) 
     return unpacked.gather(1, idx).squeeze() 

    def forward(self, x, lengths): 
     embs = self.embedding(x) 

     # pack the batch 
     packed = pack_padded_sequence(embs, list(lengths.data), 
             batch_first=True) 

     out_packed, (h, c) = self.rnn(packed) 

     out_unpacked, _ = pad_packed_sequence(out_packed, batch_first=True) 

     # get the outputs from the last *non-masked* timestep for each sentence 
     last_outputs = self.last_timestep(out_unpacked, lengths) 

     # project to the classes using a linear layer 
     logits = self.linear(last_outputs) 

     return logits 

प्रश्न 2 - नकाबपोश क्रॉस Entropy घटाने

हाँ, डिफ़ॉल्ट रूप से शून्य गद्देदार timesteps (लक्ष्य) बात। हालांकि, उन्हें मुखौटा करना बहुत आसान है। आपके द्वारा उपयोग किए जाने वाले PyTorch के संस्करण के आधार पर आपके पास दो विकल्प हैं।

1. PyTorch 0.2.0: अब pytorch, CrossEntropyLoss में सीधे मास्किंग ignore_index तर्क के साथ समर्थन करता है। उदाहरण के लिए, मॉडलिंग या seq2seq, जहां मैं शून्य गद्दी जोड़ने भाषा में, मैं मुखौटा शून्य गद्देदार शब्द (लक्ष्य) बस इस तरह:

   loss_function = nn.CrossEntropyLoss (ignore_index = 0)

2. PyTorch 0.1.12 और पुराना: PyTorch के पुराने संस्करणों में, मास्किंग समर्थित नहीं था, इसलिए आपको अपना खुद का कामकाज लागू करना पड़ा। मैं जिस समाधान का उपयोग करता था, masked_cross_entropy.py था, jihunchoi द्वारा। आपको इस discussion में भी रुचि हो सकती है।