एक कृत्रिम न्यूरॉन नेटवर्क (एएनएन) जिसमें एक मनमाना संख्या में इनपुट और आउटपुट होते हैं

Question

मैं अपनी समस्या के लिए ANN का उपयोग करना चाहूंगा, लेकिन समस्या मेरे इनपुट की है और आउटपुट नोड संख्या निश्चित नहीं हैं।

मैंने अपना प्रश्न पूछने से पहले कुछ Google खोज की और पाया कि RNN मेरी समस्या में मदद कर सकता है। लेकिन, सभी उदाहरण जो मुझे मिले हैं वे किसी न किसी तरह से इनपुट और आउटपुट नोड्स को परिभाषित करते हैं।

इसलिए, मैं एक रणनीति की तलाश कर रहा हूं कि कैसे इसे वास्तविक या कम से कम कुछ उदाहरणों के रूप में देखा जाए, जो कि कैरस या पियरटेक में बेहतर हैं।

मेरे मुद्दे के बारे में अधिक जानकारी:

मेरे पास दो इनपुट सूचियाँ हैं, जहाँ पहले वाले की लंबाई तय है और दो बराबर हैं, fe:

in_1 = [2,2] 

लेकिन दूसरी सूची की लंबाई लचीली है, लंबाई तीन से inf तक हो सकती है, fe:

in_2 = [1,1,2,2]

या

in_2 = [1,1,1,2,2,2,3,3,3]

इसके अलावा, इनपुट सूची एक दूसरे पर निर्भर करती है। पहली सूची आउटपुट सूची के आयाम को दिखाती है। तो अगर in_1 = [2,2], का अर्थ है कि आउटपुट को [2,2] रूप में बदलने की संभावना होनी चाहिए।

वर्तमान में, मैं दो इनपुट सूची को एक में मिलाने की सोच रहा हूँ:

in = in_1 + in_2 = [2, 2, 1, 1, 2, 2]

इसके अलावा, आउटपुट में in_2 सूची, फाई जैसी ही लंबाई है :

यदि इनपुट सूचियाँ हैं:

in_1 = [2, 2]
in_2 = [1, 1, 2, 2]

आउटपुट होना चाहिए:

out = [1, 2, 1, 2]

किसी भी विचारों का स्वागत है!

Answer 1

उत्तर इनपुट वेक्टर की लंबाई या यह कैसे उत्पन्न होता है के महत्व पर निर्भर हो सकता है।

हालांकि, सबसे सरल समाधान आमतौर पर सबसे बड़े आकार के इनपुट को जानना और वैक्टर की संख्या के रूप में उपयोग करना है। यदि दिए गए इनपुट में लंबाई कम है, तो आप शून्य या उपयुक्त प्रतीकों के साथ पैडिंग कर सकते हैं। इसलिए वेक्टर [1, 2, 3] और [1, 2, 2, 3] रखने के बजाय आपके पास वैक्टर [1, 2, 3, 0] और [1, 2, 2, 3] हो सकते हैं।

वही आउटपुट के लिए आवेदन कर सकता है। यदि अपेक्षित आउटपुट [1, 2, 1] और [1, 3, 4, 1] है, तो आप पहले आउटपुट को [1, 2, 1, 0] के रूप में मान सकते हैं।

क्या यह सिर्फ हैक नहीं है?

आमतौर पर, न्यूरल नेटवर्क कार्य का अनुमान लगाते हैं। आदर्श रूप से, यह आउटपुट के रूप में वैक्टर (मेट्रिसेस) और आउटपुट के रूप में वैक्टर (मैट्रिसेस) का प्रतिनिधित्व करता है। यही कारण है कि यह हमेशा वांछनीय है कि आपके इनपुट वेक्टर का आकार तय किया जाए।

Comments

ठीक है, यह स्पष्ट है, मैं इनपुट के लिए पैडिंग कर सकता हूं। लेकिन, आउटपुट नोड्स के आकार को कैसे परिभाषित किया जाए?

— धान

Answer 2

मुझे लगता है कि आपने आरएनएन के लिए निश्चित संख्या में इनपुट को गलत समझा होगा। यह टाइमस्टेप प्रति इनपुट की संख्या है । आपके सभी उदाहरणों में प्रति टाइमस्टेप की निश्चित संख्या है: 1! आप उन्हें एक बार अपने तंत्रिका नेटवर्क में खिलाते हैं, एक विशेष "अंत" टोकन के साथ परिष्करण (आप हमेशा इस पर दूसरा इनपुट कर सकते हैं)। इसे तब तक कोई आउटपुट देने के लिए सिखाएं जब तक कि यह अंत टोकन को न देख ले, और फिर एक विशेष परिणाम आउटपुट टोकन के साथ समाप्त होने पर परिणाम के घटकों को एक बार में आउटपुट करना।

Comments

वाह धन्यवाद! क्या आप इसे बेहतर समझने के लिए कोई सभ्य ट्यूटोरियल / उदाहरण जानते हैं?

— धान

@ गोपी कुछ लिंक के लिए भयानक- rnn देखें उदाहरण के लिए char-rnn काफी मजेदार है।

— आर्थर टाका

Answer 3

यह जानते हुए कि पहली सूची बहुत अधिक अपरिवर्तनीय है (केवल एक निश्चित ज्यामिति का वर्णन करते हुए) आप हर अलग-अलग in_1 कॉन्फ़िगरेशन के लिए कई अलग-अलग, विशिष्ट NN बनाने की कोशिश कर सकते हैं और नेटवर्क को खिलाने के लिए केवल in_2 का उपयोग कर सकते हैं।

तो in_1 विभिन्न नेटवर्क को ड्राइव कर सकता है

in_1=[1,1]? --> NN #1 (n1) --> (o1)
in_1=[2,1]? --> NN #2 (n1,n2) --> (o1,o2)
in_1=[2,2]? --> NN #3 (n1,n2,n3,n4) -> (o1,o2,o3,o4)

पहले चरण में आप कॉन्फ़िगरेशन निर्धारित करते हैं (यानी एक तानाशाह बनाते हैं) और फिर उसके अनुसार विशेष नेटवर्क को प्रशिक्षित / फ़ीड करें।

Comments

वास्तव में, यह एक अच्छा विचार है, लेकिन आकार की संख्या काफी बड़ी है ... वैसे भी, इनपुट के लिए धन्यवाद!

— धान