हम हमेशा स्वर्णिम अनुपात क्यों देखना चाहते हैं? C ++ तंत्रिका नेटवर्क का उपयोग करते हुए प्रयास (असफल) विकासवादी विश्लेषण

हाल ही में, मैंने अपने आप से पूछा: क्या हमारी इच्छा है कि हर जगह स्वर्ण अनुपात को हर जगह किसी न किसी तरह से सांस्कृतिक चीजों से जोड़ा जाए, या हमारे मस्तिष्क की संरचना में किसी प्रकार का गहरा पैटर्न छिपा है? इसका पता लगाने के लिए, मैंने कुछ चीजें करने का फैसला किया:

  1. इस पैटर्न के बारे में एक विशिष्ट परिकल्पना तैयार करें। मैंने तय किया कि यह धारणा सबसे उपयुक्त है कि हमारा मस्तिष्क संख्याओं के अपघटन के आधार पर एक संख्या प्रणाली का उपयोग करता है जो सुनहरे अनुपात की डिग्री में है, क्योंकि इसकी कुछ विशेषताएं आदिम तंत्रिका नेटवर्क के काम के समान हैं: तथ्य यह है कि एक उच्चतर क्रम के सुनहरे खंड की डिग्री को अंतहीन रूप से विस्तारित किया जा सकता है निचले क्रम की डिग्री और ऋणात्मक डिग्री के योग में तरीकों की संख्या। इस प्रकार, एक उच्च डिग्री कुछ निचले डिग्री से "उत्साहित" है, जिससे तंत्रिका नेटवर्क के साथ समान समानता प्रकट होती है।
  2. इसका परीक्षण करने के लिए एक विशिष्ट तरीका बताएं: मैंने चटाई को चुना। सबसे सरल संभव तंत्रिका नेटवर्क में यादृच्छिक परिवर्तनों के माध्यम से मस्तिष्क के विकास का अनुकरण - एक रेखीय ऑपरेटर का मैट्रिक्स।
  3. परिकल्पना की पुष्टि के लिए मानदंड बनाएं। मेरी कसौटी यह थी कि सुनहरे अनुपात पर आधारित संख्या प्रणाली एक तंत्रिका नेटवर्क इंजन पर लागू होती है जिसमें बाइनरी की तुलना में कम त्रुटियों के साथ समान जानकारी होती है।

चूंकि हम प्रोग्रामिंग के बारे में बात कर रहे हैं, मैं दूसरे और तीसरे बिंदुओं के बारे में अधिक विस्तार से वर्णन करूंगा।

विकास के दौरान मस्तिष्क में यादृच्छिक परिवर्तनों का अनुकरण करने के लिए, मैंने rand_s () फ़ंक्शन का उपयोग किया, क्योंकि यह क्रिप्टोग्राफिक रूप से स्थिर है और तदनुसार, "अधिक यादृच्छिक" परिणाम देगा। मैंने यह भी एक मानदंड के रूप में उपयोग किया कि तंत्रिका नेटवर्क ने सीखने के दौरान सबसे छोटी संख्या में त्रुटियां प्राप्त कीं, जब मैट्रिक्स छोटे मूल्यों द्वारा यादृच्छिक दिशाओं में विचलन करता है, वेक्टर द्वारा इसका उत्पाद लगभग एक ही मॉड्यूल द्वारा बदलता है।

वेक्टर में डेटा के एन्कोडिंग के लिए, मैंने दो 14-अंकीय बाइनरी संख्याओं के लिए 28-आयामी वेक्टर का उपयोग किया और उनकी राशि (पहले 14 वर्णों के बाद, इसमें भरने के लिए सिर्फ 14 शून्य हैं) और सिस्टम में दो संख्याओं के लिए 40-आयामी वेक्टर। सुनहरे अनुपात के साथ।

इनपुट फ़ाइल में निम्न प्रारूप है।

पहली पंक्ति दो पूर्णांकों को एक स्थान से अलग करती है, वेक्टर का आयाम और प्रशिक्षण सेट में तत्वों की संख्या।

सभी बाद की लाइनें: पहली पंक्ति तंत्रिका नेटवर्क का इनपुट है, दूसरी सही प्रसंस्करण परिणाम है।

यहां तंत्रिका नेटवर्क कोड का एक स्निपेट है जो इनपुट डेटा के नमूने पर उन्हें प्रशिक्षित करने और उनके अनुरूप सही परिणामों के लिए जिम्मेदार है:

while (((d-mu)*(d-mu)>0.01)||(q<10)) // ,        ""    { s=0; //           for (k=0;k<m;k++) { for (i=0;i<n;i++) { (*(z+k*n+i))=0; } for (i=0;i<n;i++) { for (j=0;j<n;j++) { (*(z+k*n+i))=(*(z+k*n+i))+(*(a+i*n+j))*(*(x+k*n+j)); } } //        for (i=0;i<n;i++) { s=s+((*(z+k*n+i))-(*(y+k*n+i)))*((*(z+k*n+i))-(*(y+k*n+i))); } //         s1=s+1; } while (s<s1) //      ,      ,    { s1=0; //      for (k=0;k<m;k++) { for (i=0;i<n;i++) { (*(z+k*n+i))=0; } }//  ()      rand_s(&p); k1 = (int) (p/((int) (UINT_MAX/n))); rand_s(&p); k2 = (int) (p/((int) (UINT_MAX/n))); //   ""  ,     rand_s(&p); h=((double) p/UINT_MAX)-0.5; //  h1=1; rand_s(&p); l=((int) ((double) p/UINT_MAX)*20); for (i=0;i<l;i++) { h1=h1/10; } h=h*h1; //,        for (k=0;k<m;k++) { for (i=0;i<n;i++) { for (j=0;j<n;j++) { if ((i==k1)&&(j==k2)) (*(z+k*n+i))=(*(z+k*n+i))+(*(a+i*n+j))*(*(x+k*n+j))+h*(*(x+k*n+j)); else (*(z+k*n+i))=(*(z+k*n+i))+(*(a+i*n+j))*(*(x+k*n+j)); } } //       for (i=0;i<n;i++) { s1=s1+((*(z+k*n+i))-(*(y+k*n+i)))*((*(z+k*n+i))-(*(y+k*n+i))); }//           } } (*(a+k1*n+k2))=(*(a+k1*n+k2))+h; //           s1=0; d=0; for (k1=0;k1<n;k1++) { for (k2=0;k2<n;k2++) { for (k=0;k<m;k++) { for (i=0;i<n;i++) { (*(z+k*n+i))=0; } } for (k=0;k<m;k++) { for (i=0;i<n;i++) { for (j=0;j<n;j++) { if ((i==k1)&&(j==k2)) (*(z+k*n+i))=(*(z+k*n+i))+((*(a+i*n+j))+0.1)*(*(x+k*n+j)); else (*(z+k*n+i))=(*(z+k*n+i))+(*(a+i*n+j))*(*(x+k*n+j)); } } } s1=0; for (k=0;k<m;k++) { for (i=0;i<n;i++) { s1=s1+((*(z+k*n+i))-(*(y+k*n+i)))*((*(z+k*n+i))-(*(y+k*n+i))); } } d=d+(s1-s)*(s1-s)/(n*m);//          } } mu=mu*((double) q/(q+1))+((double) d/(q+1));//         q=q+1; printf("%lf \n",mu);//         } 

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

मैंने युग्मित टी-परीक्षणों के साथ विभिन्न संख्या प्रणालियों में त्रुटियों की तुलना की और मुझे यही मिला।

तुलना: गोल्डन अनुपात - बाइनरी सिस्टम
परिकल्पना: स्वर्णिम अनुपात में त्रुटि औसतन कम है।
परिणाम:
t = -22.033
df = 999
p <0.001
कोहेन का d = -0.697 (सुनहरे अनुपात के साथ, त्रुटि कम है)
कोहेन के डी के लिए 99% विश्वास अंतराल:
से लेकर -0.615 तक
शापिरो-विल्क वितरण सामान्यता परीक्षण:
W = 0.998 p = 0.382 (वितरण सामान्य के अनुरूप है)
वर्णनात्मक आँकड़े:
सुनहरा अनुपात:
अंकगणित का अर्थ है: 0.365
मानक विचलन: 0.044
बाइनरी सिस्टम:
अंकगणितीय माध्य: 0.414
मानक विचलन: 0.055

मैंने इस छोटे से हस्तकला अध्ययन में उपयोग किए गए सभी डेटा को अभी तक सबूत के रूप में रखने का फैसला किया कि मैंने छत से संख्याएं नहीं खींचीं। जो कोई मांगता है, मैं उसे भेज सकता हूं।

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

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

Source: https://habr.com/ru/post/hi478998/


All Articles