👈🏼 ⛏️ 🖕 निर्णय लेने में संतुलन। कांटा "यादृच्छिक अनुभव" 🏩 ⏹️ 🌋

वास्तविक जीवन लिखने के लिए, आपको पूरी तरह से और पूरी तरह से हारने के अलावा और किसी चीज की आवश्यकता नहीं है। मैं इसे बनाना जारी रखता हूं और बाद में मैं इस विषय पर एक विशाल लेख लिखूंगा, लेकिन, मेरे, यह अपने आप में क्या चीज है और 7 बार मापना कितना मुश्किल है, एक को काट लें, फिर दूसरे को 77 बार मापें और अंत में काटें नहीं। नाप, फिर से नाप! - यह किसी के लिए आदर्श वाक्य है जो वास्तव में कुछ असामान्य बनाना चाहता है। कोडिंग सोचने की तुलना में बहुत आसान है। लेकिन सोचने के लिए सामान्य रूप से दर्दनाक और असामान्य है।

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

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

याद है कि सबसे अधिक संभावना तथाकथित पृथ्वी पर "जीवन" रासायनिक तत्वों की अराजक बातचीत के परिणामस्वरूप उत्पन्न हुआ। ऐसा जीवन कभी नहीं होता अगर एक अणु दूसरे से इलेक्ट्रॉनों को खींचने में सक्षम नहीं होता, या इसके विपरीत, अपने स्वयं के साथ साझेदारी करता है। यह OPPORTUNITY ही हैयह केवल इस तथ्य के कारण था कि यौगिक तत्वों से प्रकट हुए थे, और यौगिकों से पहले प्रतिकृति और जीव भी। इसलिए, यदि हम एक डिजिटल जीवन बनाना चाहते हैं, तो हमें सहभागिता की अवसर प्रदान करना चाहिए ।

यदि हम ब्रह्मांड के महान आर्किटेक्ट थे और प्राथमिक से शुरू होने वाले इसके सभी कानूनों को ठीक से जानते थे, तो उन्हें डिजिटल बनाने की समस्याएं गंभीर समस्याएं नहीं बनेंगी। लेकिन क्योंकि चूंकि हम नहीं हैं (दुर्भाग्य से), हम केवल इस तथ्य पर भरोसा कर सकते हैं कि हम उन स्थितियों का अनुमान लगा सकते हैं और बना सकते हैं जो जैविक जीवन के आगमन के साथ थे, जिससे डिजिटल जीवन संभव हो सके।

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

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

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

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

मान लीजिए कि हमने एक यादृच्छिक इनपुट संख्यात्मक सेट के जवाब में कोड की एक निष्पादन योग्य पंक्ति को यादृच्छिक रूप से उत्पन्न किया है। यह माना जा सकता है कि प्रतिक्रिया पीढ़ी, या प्रतिक्रिया, अनुभव है। यदि कुछ समान आवक संकेतों के लिए समान रूप से प्रतिक्रिया करता है, तो हम कह सकते हैं कि यह अनुभव का उपयोग करता है। इसलिए, मैं उत्पन्न स्ट्रिंग को याद रखना चाहूंगा। लेकिन यह सीधे नहीं किया जा सकता है! आप बस इस लाइन को नहीं ले सकते हैं और इसे कक्षा के उदाहरण के सरणी चर में कहीं दूर भेज सकते हैं और इस तरह से एक तरह की प्रतिक्रिया पुस्तकालय बनाना शुरू कर सकते हैं, जैसे कि IF [input.set in memory_ array] THEN [स्मृति ।-> प्रतिक्रिया]। यह असंभव है! क्योंकि यह एक तथ्य नहीं है कि यह "जैविक मेमोरी सिस्टम" कैसे काम करता है। और इस तथ्य से नहीं कि उनका निर्माण मूल रूप से वैसा ही था जैसा कि अब हम देखते हैं।

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

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

समस्या को समझने के लिए, कल्पना करें कि हमारे पास कोड में 2 संभावित क्रियाएं हैं। आप सीधे संकेत नहीं दे सकते कि किसे चुनना है, इसके लिए एक दृढ़ संकल्प होगा। और अगर आप सब कुछ यादृच्छिक करते हैं, तो आपको संभावनाओं का उपयोग करने की आवश्यकता है। सिर्फ क्या? 50/50? 30/70? 80/20? मान लीजिए, अन्य चीजें समान हैं, 50/50 वास्तव में सबसे अनिश्चित संबंध है। फिर कोड कुछ इस तरह दिखाई देगा:

if random.random() >= 0.5:
      1
else:
     2

इस कोड के साथ क्या समस्या है? और तथ्य यह है कि लूप के प्रत्येक पुनरावृत्ति पर, यह कोड हमेशा या तो पहले एक्शन या दूसरे को चुन लेगा । दूसरे शब्दों में, इस तरह की अराजकता कभी संरचित नहीं होती है, क्योंकि इसमें ऐसी सैद्धांतिक संभावना भी नहीं होती है। द्वारा और बड़े, यहाँ हम एक ही दृढ़ संकल्प के साथ काम कर रहे हैं। इस स्थिति से निकलने का एक रास्ता है। यह इस तथ्य में शामिल है कि कार्रवाई 1 और एक्शन 2 को उन परिस्थितियों को बदलना होगा जिनके तहत उन्हें लागू किया जाता है। वहाँ, मुझे लगता है, विभिन्न विकल्प हैं, लेकिन मैं निम्नलिखित की पेशकश करना चाहूंगा।

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

हमारे मामले में, प्राथमिकता सिद्धांत हमें कर्नेल पर निष्पादन के लिए थ्रेड्स को बदलने की अनुमति नहीं देगा, लेकिन कोड के कुछ हिस्सों को जहां नियंत्रण स्थानांतरित किया जाएगा। और अगर हम कोड का एक हिस्सा "यादृच्छिक" के रूप में बनाते हैं, और दूसरा "अनुभवी" के रूप में, तो उनका वैकल्पिक परिवर्तन बहुत ही समाधान होगा जिसे हम खोज रहे हैं।

दूसरे शब्दों में, कोड, अनुभव को लागू करने, प्रत्येक बार इस संभावना को बढ़ाएगा कि अगली बार कार्रवाई यादृच्छिक होगी, और यादृच्छिक रूप से कार्य करेगा, चक्र के बाद के पुनरावृत्तियों पर अनुभव को लागू करने की संभावना को बढ़ाएगा। इस प्रकार, हम अव्यवस्था के वांछित प्रवाह को अनुभव में लेते हैं और इसके विपरीत - वास्तव में हमें जो चाहिए।

इस डिजाइन का एक अविश्वसनीय लाभ यह है कि सिस्टम के ossification के साथ पूरी तरह से कोई समस्या नहीं है, जिसे ज्ञात है, उदाहरण के लिए, एक ही तंत्रिका नेटवर्क में। दूसरी ओर, हम स्थिरता का त्याग करते हैं, लेकिन हमें यहां इसकी आवश्यकता नहीं है।

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

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

import random

deter_numb = 69
p_deter = 0.01
p_random = 0.99
iteration = 1

while True:
        print('iter = ',iteration)
        print('p_rand =  ', p_random)         
        print('p_deter = ', p_deter)
        input()
        if p_random > random.random():
            p_random-=0.01                     #  
            p_deter+=0.01
            print(random.random())    #  
        if p_deter > random.random():       
            p_deter-=0.01                      #  
            p_random+=0.01
            print(deter_numb)            #  
        iteration+=1

मेरा आपसे आग्रह है कि आप इस स्क्रिप्ट को अपने दम पर चलाने की कोशिश करें और देखें कि यह कैसे काम करता है। यह एक सेल्फ-बैलेंसिंग कोड है। कार्रवाई के रूप में 1 खड़ा है

print(random.random())

- अर्थात। बस एक यादृच्छिक संख्या उत्पादन, और क्रियाएँ 2 -

print(deter_numb)

- एक निर्धारित संख्या का आउटपुट। कोड में, उनके स्थान पर क्रियाएं होंगी, मैंने यहां सिर्फ़ सिद्धांत प्रदर्शित करने के लिए प्रिंट बनाए।

जब नियंत्रण पहली स्थिति (कोड का यादृच्छिक भाग) से गुजरता है, तो कोड स्वयं पुनरावृत्ति की संभावना कम कर देता है (p_random- = 0.01 - खुद को घटाता है) और उसी समय कोड के उस हिस्से के निष्पादन की संभावना बढ़ जाती है जहां अनुभव लागू होता है (p_deter + = 0.01 - दूसरे की संभाव्यता का वृद्धि)। दूसरी स्थिति पर नियंत्रण स्थानांतरित करते समय एक ही बात होती है। इस प्रकार, कोड के इन दोनों टुकड़ों को, जब निष्पादित किया जाता है, तो स्वयं "धीमा" होता है और साथ ही साथ कोड के अन्य "प्रतिस्पर्धा" भाग को "फैलाना" होता है।

कृपया ध्यान दें कि नियंत्रण की प्रारंभिक संभावना कोड के यादृच्छिक भाग में 99% और प्रायोगिक एक - 1% में स्थानांतरित हो जाएगी। यह दिखाना है कि इस तरह की मौलिक संभावनाओं के साथ भी सिस्टम संतुलित है। कोड निष्पादित करते समय, यह देखा जाएगा कि यह अनुपात सिर्फ सौ पुनरावृत्तियों में 50/50 पर कैसे आएगा, 0.5 के एक स्पष्ट शिखर और लगभग 6% के कामकाजी पड़ोस (अगले 3-5 सौ पुनरावृत्तियों में) के साथ सामान्य वितरण का गठन होगा।

कोड को निष्पादित करते समय, यह स्पष्ट है कि संभावनाएं संतुलन में आती हैं और 0.5 के आसपास बस जाती हैं, इस बिंदु को संतुलित करते हुए ठीक इसके बिंदु के आसपास के क्षेत्र में एक पेंडुलम संतुलन की तरह।

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

अगले लेख में, हम यादृच्छिक क्रियाओं और अनुभव के गठन पर विचार करेंगे। खैर, या कुछ अलग से, आइए देखें कि यह कैसे होता है।

निर्णय लेने में संतुलन। कांटा "यादृच्छिक अनुभव"

More articles: