मैं अपने नेटवर्क को समान रूप से इनपुट के घुमाव का इलाज कैसे कर सकता हूं?

Question

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

मेरा नेटवर्क हर वर्ग और उसके आस-पास के चौराहों को एक ग्रिड में देखकर और उस वर्ग के लिए आउटपुट देकर कॉनवे के गेम ऑफ़ लाइफ को सीखना और भविष्यवाणी करना है। इसका इनपुट 9 बिट्स का एक स्ट्रिंग है:

उपरोक्त को 010 001 111 के रूप में दर्शाया गया है।

हालांकि इस आकार के तीन अन्य घुमाव हैं, और वे सभी एक ही आउटपुट का उत्पादन करते हैं:

मेरा नेटवर्क टोपोलॉजी इनपुट में केंद्र वर्ग के अगले राज्य के लिए 9 इनपुट नोड और 1 आउटपुट नोड है। मैं छिपी हुई परत (ओं) का निर्माण कैसे कर सकता हूं ताकि वे इनमें से प्रत्येक घुमाव को समान रूप से ले सकें, मूल इनपुट के एक चौथाई तक संभव इनपुट की संख्या में कटौती?

संपादित करें:

प्रत्येक घुमाव का एक फ्लिप भी है जो एक समान परिणाम पैदा करता है। इन्हें शामिल करने से मेरे इनपुट में 1/8 वीं कटौती होगी। ग्लाइडर के साथ, मेरा उद्देश्य इन सभी इनपुटों के लिए बिल्कुल समान व्यवहार करना है। क्या इसे पूर्व-प्रसंस्करण के साथ करना होगा, या क्या मैं इसे नेटवर्क में शामिल कर सकता हूं?

Comments

बकाया सवाल! मेरे पास अपनी परियोजना के साथ एक समान, थकाऊ मुद्दा है और समरूपता के लिए कम करने के लिए सबसे कुशल तकनीकों के बारे में जानने के लिए बहुत दिलचस्पी होगी।

— DukeZhou

@ ड्यूकझोउ को मुझे यह आभास हो जाता है कि इसका उत्तर पाने में थोड़ा समय लगेगा। यदि आवश्यक हो तो एक इनाम स्थापित करने के लिए मैं अपने प्रतिनिधि की आपूर्ति की आपूर्ति का उपयोग करने के लिए तैयार हूं ...

— एरिक

एक अन्य समाधान इनपुट को पूर्व-संसाधित करना है, जैसे कि सभी 4 घुमाव नेटवर्क में खिलाए जाने से पहले एक ही छवि में परिवर्तित हो जाते हैं।

— BlueMoon93

Answer 1

यदि मैं अच्छी तरह से समझता हूं कि आपका एकल आउटपुट नोड मध्य में वर्ग की अगली स्थिति होगी। मॉडल को प्रशिक्षित करने के लिए पर्याप्त संसाधन होने पर आपको छिपी हुई परतों में नोड्स की संख्या के बारे में चिंता करने की आवश्यकता नहीं है। यह समस्या एक तंत्रिका नेटवर्क के लिए सीखना बहुत आसान है इसलिए कोई आकार की चिंता नहीं है।

आपको पर्यवेक्षित प्रशिक्षण करने की आवश्यकता है जिसका अर्थ है कि आपको इनपुट डेटा और मिलान अपेक्षित आउटपुट में खिलाने की आवश्यकता है। आपको यह सुनिश्चित करने की आवश्यकता है कि आपके प्रशिक्षण डेटा में सभी 4 घुमाव एक ही आउटपुट को सौंपे गए हैं। इस तरह से आपके नेटवर्क को इन सभी के साथ उसी तरह व्यवहार करना सीखना चाहिए।

आपने मुझे जिज्ञासु बनाया इसलिए मैंने स्वयं प्रयास किया। मेरा समाधान मेरे पुराने लैपटॉप पर कुछ सेकंड के भीतर चलने वाले लगभग 20 युगों में 100% सही सीख सकता है। मैंने केवल [0,1] या [1,0] श्रेणीगत होने के लिए आउटपुट को थोड़ा बदल दिया है, लेकिन यह वही परिणाम देता है जिसकी आपको तलाश है। यहाँ केवल संदर्भ के लिए अजगर में लिखा गया कोड है:

from keras.models import Sequential
from keras.layers import Input, Dense
from keras.models import Model
from keras import optimizers
from keras.utils.np_utils import to_categorical
import helper

x_,y_ = helper.fnn_csv_toXY("conway.csv","output",False)
y_binary = to_categorical(y_)

model = Sequential()
model.add(Dense(100, activation='relu', kernel_initializer='glorot_uniform',input_shape =(9,)))
model.add(Dense(20, activation='relu', kernel_initializer='glorot_uniform'))
model.add(Dense(2, activation='softmax'))
adam=optimizers.Adam()
model.compile(optimizer=adam,
              loss='categorical_crossentropy',
              metrics=['acc'])
model.fit(x_, y_binary, epochs=100)

Comments

मैं जिस नेटवर्क का उपयोग कर रहा हूं, वह स्वयं द्वारा लिखी गई कक्षा द्वारा सिम्युलेटेड होगा, इसलिए मेमोरी चिंता का विषय है।

— एरिक

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

— मन्ंजो

यदि मेमोरी चिंता का विषय नहीं है, तो मैं कहूंगा कि नेटवर्क आपके द्वारा बताए गए कारणों के लिए यह ऑपरेशन करता है। प्री-प्रोसेसिंग नेटवर्क से कुछ कार्य को सरल करता है, इसे सरल करता है।

— अरिक

सही करें, फिर पूर्व-प्रसंस्करण के लिए जाएं। मुझे लगता है कि इस सवाल का जवाब है। यदि आप स्मृति के साथ समस्याओं में भाग लेते हैं तो आप इसे लागू कर सकते हैं। टिप: वजन के लिए फ्लोट का उपयोग करें जो कि 64 के बजाय डबल 32 बिट्स लेता है। यह कम मेमोरी का उपयोग करेगा।

— मानगो

Answer 2

आपने अपने समस्या स्थान में एक अनुकूलन की पहचान की है और इसे अपने तंत्रिका जाल में सेंकना करने की इच्छा की है। मेरा सुझाव है कि प्रीप्रोसेसिंग करें: अपने अनुकूलन को एक तंत्रिका जाल के साथ लिखें जो कि आप जो चाहते हैं उसका सबसेट करता है।

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

यादृच्छिक इनपुट उत्पन्न करके अपने सामान्यक का परीक्षण करें, इसे सभी चार संभावित परिवर्तनों के लिए घुमाएं, प्रत्येक पर सामान्यक को चलाएं, फिर जांचें कि वे सभी समान हैं।

Answer 3

इसके बारे में शुद्ध होने के लिए, इनपुट को अलग से विचार करने के साथ शुरू करें, आकार चार के एक गोल सरणी के रूप में, प्रत्येक आइटम जिसमें बिट्स की एक जोड़ी होती है, और इसके अलावा एक केंद्र बिट:

... 01, 01, 11, 10 ...

0

नेटवर्क के डिजाइन के दौरान, इस परिपत्र संरचना और केंद्र बिंदु प्रतिमान को जारी रखें।