🚲 ✋🏿 🤢 पायथन में रैंडम ब्रांच बनाना 👌🏼 👨‍🔬 😚

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

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

ऑपरेटिंग सिस्टम में बड़ी संख्या में कार्रवाई की स्वतंत्रता के साथ कोड को लागू करने के लिए, जो एक ही समय में निष्पादन योग्य निर्देशों का सिर्फ एक अराजक सेट नहीं होगा, एक मॉडल दिखाई दिया जिसमें 3 मॉड्यूल शामिल हैं।

मुख्य निष्पादन योग्य कोड के यादृच्छिक पीढ़ी का मॉड्यूल
रैंडम शिक्षा मॉड्यूल
ओएस ऑब्जेक्ट्स का "कंप्यूटर विज़न" मॉड्यूल

इस लेख में, हम पहले मॉड्यूल के बारे में बात करेंगे, जो अब तक केवल यादृच्छिक शाखा की पीढ़ी है, अर्थात। "अगर-एलिफ-और" जैसे निर्माण। शाखायें क्यों? क्योंकि, बड़े और किसी भी जीवित जीव के जीवन में वातानुकूलित प्रतिक्रियाएं होती हैं: हम जो कुछ भी करते हैं वह कथित सूचनाओं की प्रतिक्रिया है। कोशिकाएं विभाजित होती हैं यदि कुछ स्थितियां होती हैं, तो पीड़ित एक मजबूत शिकारी को देखने से बचने की कोशिश करता है, और अगर वह कमजोर है, तो वह उस पर हमला करने की कोशिश कर सकता है, अगर प्रकाश चालू होता है, तो एक व्यक्ति खाने के लिए तिलचट्टे बिखेरता है, अगर वह भूखा है, आदि। आदि। - यह पंक्ति अंतहीन है। कोई भी स्वतंत्र, अलग क्रिया नहीं है जो किसी भी चीज से वातानुकूलित न हो। नतीजतन, विशेष रूप से जीवित जीवों के व्यवहार को स्थिति की प्रतिक्रिया के रूप में वर्णित किया जाता है: IF [कुछ] THEN [कुछ]। हम इस व्यवहार को उत्पन्न करने की कोशिश कर रहे हैं।

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

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

वर्तमान में, उल्लिखित फ़ंक्शन थोड़ा रूपांतरित हो गया है:

def make_solution(p_random, p_deter):                       
    deter_flag = 0
    random_flag = 0
    if p_random >= random.random():
            p_random-=0.01                                  #  
            p_deter+=0.01
            random_flag = 1
    if p_deter >= random.random():
            p_deter-=0.01                                   #  
            p_random+=0.01
            deter_flag = 1
    if random_flag == 1 and deter_flag == 0:
        return(p_random, p_deter, 1)
    elif deter_flag == 1 and random_flag == 0:
        return(p_random, p_deter, -1)
    else:
        return (p_random, p_deter,0)

इनपुट पर, यह 2 संभावनाएं लेता है (शुरू में डिफ़ॉल्ट रूप से वे दोनों 0.5 के बराबर हैं), जिसके बाद यह एक-एक करके उनके ऑपरेशन की जांच करता है। ट्रिगर होने की संभावना 1% तक कम हो जाती है और उसी समय अन्य 1% बढ़ जाती है। इसलिए, हर बार संभावना काम करती है, यह घट जाती है, और दूसरी बढ़ जाती है। नतीजतन, किसी भी संभावना पर बहुत अधिक लाभ नहीं मिलता है, और वे आत्म-संतुलन, 0.5 पर केंद्रित एक सामान्य वितरण का निर्माण करते हैं और +10% से अधिक नहीं के कामकाजी पड़ोस के साथ, जो इस फ़ंक्शन को मानक यादृच्छिक से अलग करता है, जहां हमारे मामले में संभावना है। यह हमेशा 0.5 के बराबर होगा और पिछले गणना पर निर्भर नहीं करेगा।

व्यावहारिक रूप से, यह एक छोटे आयाम के साथ एक संभावना पेंडुलम है। यदि पहली संभावना काम करती है और दूसरा काम नहीं करती है, तो यह 1 लौटती है, अन्यथा -1 वापस आ जाती है, और यदि दोनों ने काम किया है या नहीं किया है, तो 0., इस प्रकार, 2 आवक संभावनाओं के लिए मेकओलेशन फ़ंक्शन 3 संभावित क्रियाओं में से एक देता है, एक संतुलित देता है। 3 संभावित निरंतरता विकल्पों के साथ कांटा समाधान। भविष्य में, यह फ़ंक्शन सार्वभौमिक होने की संभावना है, और अनिश्चितताओं की अनिश्चित संख्या लेने में सक्षम होगा, क्योंकि कांटे में भिन्नता 3 से अधिक हो सकती है, लेकिन इफ-एलीफ-अन्यथा जनरेटर के मामले में, निरंतरता के लिए तीन विकल्प काफी पर्याप्त हैं।

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

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

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

शाखा जनरेटर को लिखते समय, न केवल काम करने योग्य कोड बनाना आवश्यक था जो त्रुटि-मुक्त पीढ़ियों का उत्पादन करता है, बल्कि ऐसा कोड भी हो सकता हैif-elif-अन्यथा के अधिकतम संभव निर्माण उत्पन्न करते हैं, लेकिन इस तरह के संभावित विकल्पों में से 2 या 3 नहीं हैं। उदाहरण के लिए, निम्नलिखित संभव योजनाओं पर विचार करें।

आइकनों द्वारा [..] योजनाओं में मेरा मतलब है एक शर्त के लिए भावों का एक समूह या यादृच्छिक क्रियाओं का एक ब्लॉक। सबसे प्राथमिक योजना 1 है, जहां स्थिति बस जाती है, और इसके बाद कार्रवाई ब्लॉक होती है। 2 ए और 2 बी अगर एक एलीफ या एक और के साथ भिन्नताएं हैं। विकल्प 2 सी में, यदि पहले से ही बिना किसी और के कई एलिफ के साथ आता है। और अंत में, विकल्प 2 डी में, सबसे सामान्य योजना प्रस्तुत की जाती है, जहां यदि कई एलिफ और 1 अन्य शामिल हैं।

सब कुछ सरल होगा यदि यह असीमित शाखाओं के निर्माण की आवश्यकता के लिए नहीं था। प्रत्येक के बाद, यदि एलिफ या अन्य, पुनरावृत्ति कहा जा सकता है, जो बदले में आगे फिर से उठ सकता है और "सही" करने के लिए नए एलिफ-और ब्लॉकों का उत्पादन कर सकता है। आइए संभावित विकल्पों की योजना देखें।

अवतार 2e और 2f ऐसे पुनरावर्ती शाखाओं के सरल विशेष मामलों को दिखाते हैं जब पुनरावृत्ति को एकल एलिफ के बाद या किसी अन्य के बाद भी बुलाया जाता है। विकल्प 2 जी ऐसी पुनरावृत्ति के सबसे जटिल और सामान्य मामले का वर्णन करता है, जब प्रत्येक एलिफ के बाद एक एक्शन ब्लॉक + रिकर्सन (या तुरंत पुनरावर्तन) हो सकता है, और यही बात किसी और के बाद भी हो सकती है।

अभी भी वैरिएशन हैं जब या अगर और एक्शन ब्लॉक के तुरंत बाद या बाद में पुनरावृत्ति होती है।

यह विकल्प 3 ए और 3 बी में देखा जाता है। विकल्प 3c ऐसी योजना को सबसे सामान्य रूप में दिखाता है।

यह कहना नहीं है कि उपरोक्त योजनाएं शाखाओं के निर्माण के लिए सभी संभावित विकल्पों को कवर करती हैं, लेकिन इस रूप में भी, अंतिम कोड आसानी से 150 लाइनों की शाखाओं को जन्म देता है, जो 10-15 चरणों के लिए "सही" जा रहा है। किसी भी मामले में, यदि आवश्यक हो तो योजना को जटिल करना मुश्किल नहीं है।

आप यह सुनिश्चित करने के लिए एक ऐसी पीढ़ी का उदाहरण देख सकते हैं कि शाखाएँ बहुत विविध हो सकती हैं।

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

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

निम्नलिखित चित्र दिखाता है कि विस्थापन कैसे स्थानांतरित किया जाता है।

यहां सबसे महत्वपूर्ण बात यह है कि शाखा को गहरा करने के साथ विस्थापन हमेशा दाईं ओर स्थानांतरित किया जाता है। हालांकि, यदि हमारे पास उदाहरण के लिए, एक एलीफ-और ब्लॉक है जिसमें कई एलिफ या एक एकल एलिफ-अन्य जोड़ी है, तो गाड़ी को "वापसी" करने की आवश्यकता है जो दाईं ओर तैरती है, ताकि अगले एलिफ (या फिर) के साथ शुरू हो। ब्लॉक में पिछले एक के रूप में एक ही ऑफसेट। ऐसा करने के लिए, आपको मूल ऑफ़सेट ( wall_offset) को सहेजना होगा) और शाखा पीढ़ी के अंत के बाद (उदाहरण के लिए, एक एलिफ की पूर्ण शाखा), इसे पुनर्स्थापित करें। यह सुनिश्चित करता है कि एलिफ, ब्लॉक में अन्य तत्व समान रूप से "एक दूसरे के ऊपर" हैं। इसके अलावा, प्रत्येक नए ब्लॉक का अपना विस्थापन है। एक ही चाल कुल मिलाकर अगर एलिफ-अन्यथा निर्माण (पुनरावर्ती सहित) में सद्भाव प्रदान करती है।

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

var_list = ['a','b']
exp_list = ['a+b','b-a', 'b//a']
sign = ['+','-','/','*','//']
sign2 = ['>','<','==','>=','<=','!=']
a = 3
b = 2

जैसा कि आप देख सकते हैं, दो चर का उपयोग किया जाता है: a और b ( var_list ), जो कि आरंभीकृत, 3 अंकगणितीय अभिव्यक्तियाँ ( exp_list ), साथ ही संकेत ( साइन, साइन 2 ) के साथ दो शीट हैं । जैसा कि पहले उल्लेख किया गया है, परिणामस्वरूप अभिव्यक्तियों की संरचना अब मायने नहीं रखती है और इस लेख में विचार नहीं किया गया है - कोड की व्याख्या करने के लिए उन्हें मुख्य रूप से आवश्यक है। एक और ख़ासियत को नोट किया जाना चाहिए: एलीफ-और ब्लॉक की पीढ़ी में, आपको दूसरे की उपस्थिति को ट्रैक करने और पीढ़ी को रोकने की आवश्यकता है, अन्यथा अन्य एलीफ के सामने आ सकते हैं, जो स्वाभाविक रूप से एक त्रुटि का कारण होगा। इस उद्देश्य के लिए fin_else_flag ध्वज का उपयोग किया जाता है ।

हम मुख्य पीढ़ी समारोह के साथ अपने विचार शुरू करते हैं।

def if_gen(exp_list, var_list, if_str, offset_koeff, fin_else_flag, prob_list):             
    choice_list = [exp_list, var_list]
    base_offset = ' '
    #   
    prob_list[0],prob_list[1],sol = make_solution(prob_list[0],prob_list[1])       
    # if +   (1   )        
    if sol == 0: 
        #     +3                                                                   
        action_str = action_str_gen(choice_list, offset_koeff+3, prob_list)                 
        return(base_offset*offset_koeff+'if '+ if_sub(exp_list,var_list, sign, prob_list) +':\n' + action_str, offset_koeff, fin_else_flag, prob_list) 
    # if + elif/else (2   )           
    elif sol == -1:                                                                         
        if_str= base_offset*offset_koeff+'if '+ if_sub(exp_list,var_list, sign, prob_list) +':\n' + action_str_gen(choice_list, offset_koeff+3, prob_list) # if [..]:
        #  elif/else
        prob_list[2],prob_list[3],sol2=make_solution(prob_list[2],prob_list[3])             
        if sol2!=0:
            ee_string='elif'
        else:
             ee_string='else'
        #   elif/else
        if_str, offset_koeff, fin_else_flag, prob_list = elif_else_block(ee_string, offset_koeff, exp_list, var_list, sign, if_str, choice_list, fin_else_flag, prob_list)
        return(if_str, offset_koeff, fin_else_flag, prob_list)
    # if + if() (3   )
    else:                                                                                   
            if_str= base_offset*offset_koeff+'if '+ if_sub(exp_list,var_list, sign, prob_list) +':\n' # if [..]:
            #  if/if+ 
            prob_list[4],prob_list[5],sol = make_solution(prob_list[4],prob_list[5])        
            if sol==0:
                #     +3
                if_str+=action_str_gen(choice_list, offset_koeff+3, prob_list)      
            #          
            wall_offset = offset_koeff                                                      
            if_rek, offset_koeff, fin_else_flag, prob_list = if_gen(exp_list, var_list, if_str, offset_koeff+3, fin_else_flag, prob_list) #  if+if
            #    
            if_str+=if_rek   
            #   elif-else/                                                                
            prob_list[4],prob_list[5],sol2=make_solution(prob_list[4],prob_list[5])         
            if sol2!=0:
                prob_list[2],prob_list[3],sol3=make_solution(prob_list[2],prob_list[3])
                if sol3!=0:
                    ee_string='elif'
                else:
                    ee_string='else'
                if_str, offset_koeff, fin_else_flag, prob_list = elif_else_block(ee_string, wall_offset, exp_list, var_list, sign, if_str, choice_list, fin_else_flag, prob_list)  
            else:
                #     +3
                if_str+=action_str_gen(choice_list, offset_koeff+3, prob_list)              
            return(if_str, offset_koeff,fin_else_flag, prob_list)

पीढ़ी (exp_list, var_list) के लिए "मांस" के साथ सूचियों के अलावा, फ़ंक्शन if_str को भी स्वीकार करता है - यह वह रेखा है जहां उत्पन्न कोड बदले में एकत्र किया जाता है। इसे यहाँ स्वीकार किया जाता है क्योंकि if_gen फ़ंक्शन को ही पुनरावर्ती कहा जा सकता है, और यह पहले से उत्पन्न कोड के टुकड़े को न खोना उचित होगा। ऑफ़सेट_कोएफ़

पैरामीटर ऑफसेट गुणांक है, जो एक स्थान ( बेस_ऑफ़सेट ) के साथ एक पंक्ति के लिए एक कारक है और, तदनुसार, यह कोड ब्लॉकों के क्षैतिज विस्थापन के लिए जिम्मेदार है। हमने ऊपर fin_else_flag के बारे में बात की, यहाँ यह केवल एक फ़ंक्शन को दिया गया है जो कि अगर + elif / else (नीचे देखें) उत्पन्न करने के लिए जिम्मेदार है। खैर, एक और पैरामीटर है -

प्रोब_लिस्ट , जो 10 संभावनाओं वाला एक पत्रक है (संभावनाओं के 5 जोड़े)

prob_list = [0.5 for y in range(0,10)]

और जैसा कि हमने ऊपर चर्चा की: मेक सॉल्यूशन फ़ंक्शन द्वारा उपयोग किया जाता है : कांटे के प्रकार के अनुरूप यह या उस से संभावनाओं की जोड़ी इसे पास कर दी जाती है (उदाहरण के लिए, मुख्य संरचनात्मक कांटा शीट में पहले 2 संभावनाओं का उपयोग करता है: प्रोबीलिस्ट [0] और prob_list [1] )। इस शीट में संभाव्यता के परिणाम, उदाहरण के रूप में, निम्न आकृति में देखे जा सकते हैं।

इस सूची में संभावनाएं पीढ़ी-दर-पीढ़ी बदलती रहती हैं, अगर अगली पीढ़ी के दौरान कोड का संबंधित टुकड़ा निष्पादित हो जाता है।

फ़ंक्शन में ही, नेस्टेड लिस्ट चॉइस_लिस्ट को शुरुआत में शुरू किया जाता है - यह "मीट" से अभिव्यक्ति के सुविधाजनक यादृच्छिक पीढ़ी के लिए आवश्यक है, और बेस ऑफसेट__सेटसेट = '' एक स्थान पर।

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

पहला विकल्प सबसे सरल विकल्प को लागू करता है अगर + [..]। उत्तर को वर्तमान ऑफसेट के साथ एक स्ट्रिंग के रूप में बनाया जाता है (यह आवश्यक रूप से 0 के बराबर नहीं है!), एक "यदि" स्ट्रिंग, एक यादृच्छिक स्थिति जो if_sub फ़ंक्शन (जो बाद में चर्चा की जाएगी), गाड़ी वापसी, और एक्शन ब्लॉक की पीढ़ी का उपयोग कर एक्शन_स्ट्रस्ट फ़ंक्शन (नीचे देखें) द्वारा उत्पन्न होती है। । परिणामस्वरूप, हमें कुछ ऐसा मिलता है:

if ((a+b)==(b)):
   b=b
   a=b-a
   a=a

दूसरा विकल्प इस प्रकार को उत्पन्न करने के लिए जिम्मेदार है: यदि [..] + एलिफ / और-ब्लॉक (योजनाओं में विकल्प २)। सबसे पहले, अगर + [..] लाइन वहां बनती है, तो एलिफ़ / वरना कांटा होता है, जो यह तय करता है कि एलिफ-अन्य ब्लॉक उत्पन्न होगा या नहीं, अगर एलिफ या आई- ईई (ई lif_else_block फ़ंक्शन ( नीचे देखें)। परिणाम अलग-अलग हो सकते हैं। उदाहरण के लिए:

if ((a+b)==(a)):
   b=a+b
elif ((b//a)==(a)):
   None
elif ((a+b)<=(a)):
   a=b//a
else:
   if ((b)<=(a)):
      a=b-a
      b=a

if ((a)==(b-a)):
   b=b-a
   b=b
   a=b
   a=b-a
elif ((b)>(b-a))and((a)<(b-a)):
   if ((b//a)<(a)):
      b=b-a
   elif ((a+b)<(b-a))and((b)<(a+b))or((a+b)==(a+b)):
      b=b
      a=b-a
   elif ((a)>(b-a)):
      None

if ((b)<=(b-a))or((a+b)>=(b)):
   a=a
   b=b
elif ((b)<=(b)):
   if ((a)>=(b)):
      a=a+b
      a=b
elif ((b)>=(a)):
   a=b-a
   a=a
   if ((a)>=(b))and((b//a)==(a))and((b//a)!=(b)):
      b=b-a
else:
   a=b//a
   if ((b//a)<(b-a)):
      a=b
      a=b-a
   else:
      if ((a)==(b)):
         a=a
         a=b//a
         b=b
         b=a+b
         b=a
      else:
         None

तीसरा विकल्प बहुत शुरुआत से पुनरावृत्ति लागू करता है (योजनाओं में विकल्प 3), अर्थात। फार्म की एक शाखा को जन्म देता है:

if ((a)==(a)):
   if ((a+b)<(b)):

या

if ((b-a)<=(a)):
   a=a
   if ((b-a)==(b)):
      a=a
      a=a

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

if ((b-a)==(b)):

   if ((a)>(a+b)):
      if ((b)==(b-a)):
         b=b
         a=a
      elif ((b)>(b)):
         None
      else:
         None
         b=a
         b=b

इसके बाद एलीफ-और-ब्लॉक / एक्शन ब्लॉक में एक कांटा आता है, जो यह तय करता है कि पुनरावृत्ति के बाद एक्शन ब्लॉक या एलिफ-ब्लॉक ब्लॉक को जोड़ना है या नहीं। यदि आप एक एलीफ-और ब्लॉक को जोड़ने का निर्णय लेते हैं, तो वहां, जैसा कि ऊपर वर्णित मामले में है, स्कीम 2 में, एलिफ या किसी अन्य का चयन किया गया है।

यहां इस तथ्य पर ध्यान देना आवश्यक है कि उत्पन्न कोड को एक कदम से दाईं ओर स्थानांतरित करने के लिए + 3 की ऑफसेट के साथ कॉल किया जाता है, और एलिफ-अन्यथा ब्लॉक को वॉल_ऑफसेट की ऑफसेट के साथ कहा जाता है ताकि यह ब्लॉक पुनरावृत्ति के बाद दाईं ओर न जाए, लेकिन मूल के साथ रहता है मूल की भरपाई अगर।

परिणाम काफी भिन्न हो सकते हैं: सरल से जटिल तक, लेकिन पुनरावृत्ति की उपस्थिति तुरंत सबसे अलंकृत शाखाओं का उत्पादन करती है।

if ((b-a)>(a+b))and((b)<(a+b)):
   if ((b-a)<=(a+b)):
      b=b//a
   elif ((b)!=(a)):
      a=b-a
else:
   if ((a+b)!=(b-a)):
      a=a

if ((b)<(b-a)):
   if ((a+b)==(b-a))and((b-a)<(a+b))and((b-a)==(a))and((a)>(b//a))or((a+b)>(b//a)):
      if ((b)>=(b-a)):
         a=b
         b=b
         if ((b)>(b)):
            a=a+b
            b=a+b
            a=a
            b=a+b
            b=b//a
            b=a
      else:
         b=a+b
         a=b
         a=b
   elif ((a)<(b-a)):
      a=b//a
      a=b-a

if ((a)>=(b-a))or((a)>=(a))or((b)<=(b)):
   a=a
   a=a
elif ((a)==(a))and((b)>(b-a)):
   a=b//a
   if ((a)<(b)):
      if ((a+b)==(b-a)):
         a=a
         if ((a)!=(b//a)):
            if ((b//a)!=(a))and((b-a)>=(b)):
               a=b
            else:
               None
               a=b//a
      else:
         b=b
         b=a+b
         if ((b-a)<=(b//a)):
            a=b
            a=b
            a=a+b
else:
   a=a+b
   if ((b-a)>=(a)):
      a=b
      if ((b-a)==(a))or((b)!=(b//a)):
         a=b-a
         a=a
         a=a
         a=b//a
         a=a+b
         b=a

अब आइए elif_else_block फ़ंक्शन को देखें , जो elif-else ब्लॉक बनाने के लिए ज़िम्मेदार है और इसे मुख्य if_gen फ़ंक्शन से बुलाया जाता है ।

def elif_else_block(ee_string, offset_koeff, exp_list, var_list, sign, if_str, choice_list,  fin_else_flag, prob_list):
    if ee_string=='elif':
        sol3 = 9
        #  
        wall_offset = offset_koeff
        #  elif  
        while sol3!=0 and fin_else_flag!=1:
            temp_str, offset_koeff, fin_else_flag, prob_list=elif_else('elif', wall_offset, exp_list, var_list, sign, if_str, choice_list, fin_else_flag, prob_list)
            if_str+=temp_str
            prob_list[6],prob_list[7],sol3 = make_solution(prob_list[6],prob_list[7])
        #  -   else   elif?
        prob_list[2],prob_list[3],sol = make_solution(prob_list[2],prob_list[3])
        if sol!=0:
            #  else,   
            fin_else_flag=1
            temp_str,offset_koeff, fin_else_flag, prob_list=elif_else('else', wall_offset, exp_list, var_list, sign, if_str, choice_list, fin_else_flag, prob_list)
            if_str+=temp_str
        return(if_str,offset_koeff, fin_else_flag, prob_list)
    #  else
    else: 
          temp_str,offset_koeff, fin_else_flag, prob_list=elif_else('else', offset_koeff, exp_list, var_list, sign, if_str, choice_list, fin_else_flag, prob_list)
          if_str+=temp_str
          return(if_str, offset_koeff, fin_else_flag, prob_list)

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

यह निर्णय कि क्या और किसी अन्य को एलिफ ब्लॉक में संलग्न करना है, एक ही मेक_ सॉल्यूशन फ़ंक्शन का उपयोग करके एक कांटा द्वारा तय किया जाता है , और यदि अन्य संलग्न है, तो तुरंत fin_else_flag ध्वज चालू हो जाता हैजो ब्लॉक जनरेशन को रोकता है। Elif

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

अब elif_else फ़ंक्शन पर विचार करें ।

<b>def elif_else(ee_string, offset_koeff, exp_list, var_list, sign, if_str, choice_list, fin_else_flag, prob_list):
    ee_str = ''
    #   else:  elif [..]:
    if ee_string=='else':
        ee_str += ' '*offset_koeff+ee_string + ':\n'
    elif ee_string=='elif':
        ee_str += ' '*offset_koeff+ee_string+' '+if_sub(exp_list, var_list, sign, prob_list) + ':\n'
    #   -None /  +
    prob_list[2],prob_list[3],sol = make_solution(prob_list[2],prob_list[3])
    if sol!=0:
        prob_list[6],prob_list[7],sol2 = make_solution(prob_list[6],prob_list[7])
        if sol2!=0:
            #  
            ee_str+=action_str_gen(choice_list,offset_koeff+3, prob_list)
        else:
            # None
            ee_str+=' '*(offset_koeff+3)+'None\n'
        return(ee_str, offset_koeff, fin_else_flag, prob_list)
    else:
        #   
        prob_list[6],prob_list[7],sol2 = make_solution(prob_list[6],prob_list[7])
        if sol2==0:
            #  
            ee_str+=action_str_gen(choice_list,offset_koeff+3, prob_list)
        #  if_gen
        if_str, offset_koeff,  fin_else_flag, prob_list = if_gen(exp_list, var_list, if_str, offset_koeff+3, fin_else_flag, prob_list)                 
        ee_str+=if_str
        return(ee_str, offset_koeff, fin_else_flag, prob_list)

यह फ़ंक्शन एलीफ़ के गठन के लिए ज़िम्मेदार है या फिर स्वयं लाइन, साथ ही बाद की पीढ़ी के लिए या इन लाइनों के बाद पुनरावृत्ति ब्लॉक के लिए जिम्मेदार है। यह ee_string वैरिएबल भी लेता है , जिसमें या तो एलिफ होता है या फिर अन्य, और संबंधित स्ट्रिंग बनाता है। फिर एक कांटा है, जहां यह निर्धारित किया जाता है कि आगे क्या होगा: (एक्शन ब्लॉक या कोई नहीं), या (एक्शन ब्लॉक या एक्शन ब्लॉक + रिकर्सन)। इस कांटे के अंदर, दो उप-कांटा में क्रमशः एक विभाजन होता है, और प्रत्येक मामले में निर्णय लेने के लिए उपयुक्त मापदंडों के साथ मेक_सुलेशन फ़ंक्शन को कहा जाता है ।

यह ध्यान दिया जाना चाहिए कि जब यह कोड में होता हैif sol!=0, इसका मतलब है कि हम जानबूझकर कोड के एक हिस्से को दूसरे पर एक फायदा देते हैं, क्योंकि अगर सोल! = 0, तो यह -1 या 1 के बराबर होता है, और इसलिए कोड का एक और टुकड़ा कम बार निष्पादित किया जाएगा (केवल जब सोल == 0)। इसका उपयोग, विशेष रूप से, elif_else_block फ़ंक्शन में किया जाता है , जहां हमें elif और अन्य के लिए समान संभावना देने के बजाय ब्लॉक में और अधिक एलिफ्स बनाने के लिए अधिक लाभदायक है। या, उदाहरण के लिए, elif_else फ़ंक्शन में , हम विकल्प को एक लाभ देते हैं जब एक एक्शन ब्लॉक या कोई नहीं बनता है बजाय इसके कि रिकर्सियन क्या हो रहा है - अन्यथा शाखाएं बहुत ही अशोभनीय आकार तक बढ़ सकती हैं।

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

एक्शन ब्लॉक उत्पन्न करने के लिए जिम्मेदार फ़ंक्शन ।

def action_str_gen(choice_list, offset_koeff, prob_list):
    sol = 9
    curr_offset = ' '*offset_koeff
    act_str = ''
    while sol!=0:
        act_str+= curr_offset+rand(rand(choice_list[1]))+'='+rand(rand(choice_list))+'\n'
        prob_list[6],prob_list[7],sol = make_solution(prob_list[6],prob_list[7])
    return(act_str)

यहां सब कुछ काफी सरल है: नेस्टेड लिस्ट choise_list से, जो, जैसा कि हम याद करते हैं, में v ar_list (चरों की सूची) और exp_list (अभिव्यक्तियों की सूची) शामिल हैं, इस फ़ंक्शन में इस फॉर्म की एक या एक से अधिक लाइनें शामिल हैं: a = a + b या b = b । उन। या तो एक अभिव्यक्ति को चर या किसी अन्य चर (स्वयं सहित) को सौंपा गया है। रैंड फ़ंक्शन बेतरतीब ढंग से सूची से एक तत्व का चयन करता है और राक्षसी तारों का उत्पादन न करने के लिए पूरी तरह से यहां की आवश्यकता होती है।

def rand(t_list):
    return(t_list[random.randint(0,len(t_list)-1)])

शर्तों के लिए if_sub अभिव्यक्ति पीढ़ी फ़ंक्शन बड़ा दिखता है।

def if_sub(exp_list, var_list, sign, prob_list):
    sub_str = ''
    sol = 9
    choice_list = [exp_list, var_list]
    flag = 0
    while sol!=0:
        prob_list[6],prob_list[7],sol = make_solution(prob_list[6],prob_list[7])
        sub_str+='(('+rand(rand(choice_list))+')'+rand(sign2)+'('+rand(rand(choice_list))+'))'
        if flag == 1 and sol==1:
            sub_str+=')'
            flag=0
        or_and_exp = or_and(prob_list)
        if len(or_and_exp):
            sub_str+=or_and_exp
        else:
            break
        prob_list[6],prob_list[7],sol2 = make_solution(prob_list[6],prob_list[7])
        if sol2 == 1 and (sub_str[-1]=='D' or sub_str[-1]=='R') and flag == 0:
            sub_str+='('
            flag = 1
    
    if sub_str[-1] == '(':
        if sub_str[-2]=='d':
           sub_str=sub_str[0:-4]
        elif sub_str[-2]=='r':
             sub_str=sub_str[0:-3]
        else:
            sub_str=sub_str[0:-1]
    elif sub_str[-1]=='d':
         sub_str=sub_str[0:-3]
    elif sub_str[-1]=='r':
         sub_str=sub_str[0:-2]
    else:
         None
    if flag == 1:
        sub_str+=')'
        return(sub_str)
    else:
        return(sub_str)

यह प्रकार से भाव उत्पन्न करता है: ((ए)> = (बीए)) या (ए)> = (ए)) या ((बी) <= (बी)) । एक ही समय में, बाएं और दाएं दोनों तरफ विभिन्न विकल्प हो सकते हैं और अलग-अलग चर, साथ ही साथ भाव या समूह के रूप में खड़े हो सकते हैं। तार्किक ऑपरेटरों या और और भी यहाँ उपयोग किया जाता है , जो का उपयोग कर सुविधा के लिए चुने गए हैं or_and_exp समारोह ।

def or_and(prob_list):
    prob_list[8],prob_list[9],sol = make_solution(prob_list[8],prob_list[9])
    if sol==-1:
        return('and')
    elif sol==1:
        return('or')
    else:
        return('')

बाकी if_sub फ़ंक्शन एक्सप्रेशन से अतिरिक्त पूंछों को काट देता है, और जब आवश्यक हो, कोष्ठक को बंद करके, इन नृत्यों के साथ इन नृत्यों पर विचार करने के लिए, मुझे लगता है, यह अक्षम है।

अच्छा यही सब है। आप जनरेटर शुरू कर सकते हैं, उदाहरण के लिए, इस तरह:

var_list = ['a','b']
exp_list = ['a+b','b-a', 'b//a']
sign = ['+','-','/','*','//']
sign2 = ['>','<','==','>=','<=','!=']
a = 3
b = 2       
prob_list = [0.5 for y in range(0,10)]      
while True:
     if_str = ''
     if_str, offset_koeff, fin_else_flag, prob_list = if_gen(exp_list, var_list, if_str, 0,0, prob_list)
     try:
         exec(compile(if_str,'gen','exec'))
         print(if_str)
         input()
         
     except ZeroDivisionError:
         None
     except:
         print('error')
         print(if_str)
         input()

सबसे पहले, इनपुट, जिसमें प्रोब्लेबिलिटीज के साथ एक प्रोबाइटल शामिल है , फिर एक अनंत लूप में, मुख्य कार्य को if_gen कहते हैं और निष्पादन के लिए उत्पन्न जनरेट स्ट्रिंग शुरू करते हैं। यह अलग से ZeroDivisionError प्रसंस्करण के लायक है, क्योंकि इस तरह के यादृच्छिक निर्माण के साथ शून्य से विभाजन बहुत आम है। लॉन्च के बाद, अगली पीढ़ी को दिखने के लिए Enter दबाएं। ज्यादातर अक्सर वे काफी सरल होंगे, लेकिन अक्सर शाखाओं वाले और यहां तक कि बहुत शाखित होते हैं। खैर, आयात यादृच्छिक शुरुआत में भी सम्मिलित करने के लिए अच्छा होगा, जो उन लोगों के हाथ से सब कुछ इकट्ठा देखना चाहता हूँ नहीं है के लिए), से फ़ाइल डाउनलोड कर सकते हैं Github (फ़ाइल if_gen.py)।

अंत में, मैं कहना चाहता हूं कि मैंने जो कोड प्रस्तुत किया था, उसमें सैकड़ों हजारों पीढ़ियों पर त्रुटियों के बिना परीक्षण किया गया था, जबकि इसने इफ-इलीफ-और योजनाओं के पूरे पैलेट का प्रदर्शन किया था जिसे मैं अंत में देखना चाहता था। एक बार, गलती से, मैंने कोड के एक हिस्से में पुनरावृत्ति की बहुत अधिक संभावना दी और मुझे 52,000 (!) लाइनें मिलीं और एक ही समय में यह काम कर रहा था (हालांकि COMP 30 सेकंड के लिए निलंबित कर दिया गया था)। यह एल्गोरिथ्म की विश्वसनीयता को भी इंगित करता है।

संभवतः, मुख्य समारोह को किसी अन्य तरीके से रचना करने के लिए, कहीं और अधिक संक्षिप्त रूप से लिखना संभव था, लेकिन मुख्य बात यह है कि यह कोड काम करता है और प्रति सेकंड लगभग 250 पीढ़ी उत्पन्न करता है, जो कि, मेरी राय में, काफी स्वीकार्य है।

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

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

पायथन में रैंडम ब्रांच बनाना

More articles: