🤰🏾 🦕 🚴🏾 सेलुलर ऑटोमेटा का विकास 🛌🏽 💐 🌆

सेलुलर ऑटोमेटा को आनुवंशिक एल्गोरिथ्म के साथ कनेक्ट करें और देखें कि क्या होता है।

आलेख में Gif (ट्रैफ़िक!) और विषम छवियां हैं। मिर्गी के दौरे में मिर्गी का दौरा पड़ सकता है।

सेलुलर ऑटोमेटा के लिए नियम

सबसे सरल सेलुलर ऑटोमोबोन एक आयामी सेलुलर ऑटोमोबोन है (शून्य-शून्य ऑटोमेटा भी हैं - हम उनके बारे में नीचे बात करेंगे)। एक-आयामी सेलुलर ऑटोमेटन में, हमारे पास एक-आयामी सरणी होती है, जिनमें से कोशिकाएं (कोशिकाएं) दो अवस्थाओं में से एक (1/0, सत्य / असत्य, श्वेत / काला, सजीव / मृत) ले सकती हैं। सरणी में सेल की अगली स्थिति कुछ नियम के अनुसार, सेल की वर्तमान स्थिति और दो पड़ोसी कोशिकाओं की स्थिति से निर्धारित होती है।

कुल मौजूद है

$2 ^ 3 = 8$ सेल राज्यों और दो पड़ोसी कोशिकाओं का संयोजन:

अगला, प्रत्येक संयोजन के लिए, हम अगली पुनरावृत्ति के लिए सेल की स्थिति लिखते हैं (ऑटोमेटन के अगले राज्य के लिए):

एक सेलुलर ऑटोमेटन के लिए एक नियम मिला। एक आयामी सेलुलर ऑटोमेटा के नियम 8 बिट्स ("टंगस्टन कोड") के साथ एन्कोड किए गए हैं। कुल मौजूद है

$2 ^ 8 = 256$ प्राथमिक सेलुलर ऑटोमेटा:

256 मशीनों को मैन्युअल रूप से हल किया जा सकता है। हम उन पर वास नहीं करेंगे। हम दो आयामी सेलुलर ऑटोमेटा के लिए मौजूदा नियमों की संख्या की गणना करते हैं।

एक दो-आयामी सेलुलर ऑटोमेटन एक दो-आयामी सरणी का उपयोग करता है। प्रत्येक कोशिका में मूर के आसपास के क्षेत्र में 8 पड़ोसी हैं (एक वॉन न्यूमैन पड़ोस भी है जिसमें विकर्ण कोशिकाओं को ध्यान में नहीं रखा जाता है। हम लेख में इस पर विचार नहीं करेंगे):

सुविधा के लिए, हम कोशिकाओं को एक पंक्ति में लिखते हैं (हम लेख में बाद में चयनित क्रम का उपयोग करेंगे):

द्वि-आयामी सेलुलर ऑटोमेटन के लिए वहां मौजूद है

$2 ^ 9 = 512$ सेल राज्यों और 8 पड़ोसी कोशिकाओं का संयोजन:

द्वि-आयामी सेलुलर ऑटोमेटन के लिए नियम 512 बिट्स के साथ एन्कोडेड है। कुल मौजूद है

$2 ^ {512}$ दो आयामी सेलुलर ऑटोमेटा:

संख्या:

$2 ^ {512} \ लगभग 1.340781 \ गुना 10 ^ {154}$

अवलोकनीय ब्रह्मांड में अधिक परमाणु (

$10 ^ {80}$ )।
मैन्युअल रूप से मशीनों की इस संख्या को हल नहीं किया जा सकता है। अगर हम यूनिवर्स के अस्तित्व के दौरान हर सेकंड एक ऑटोमेटन को देखते, तो हम सब कुछ देखने में कामयाब होते

$\ approx4.35 \ times10 ^ {17}$ स्वचालित मशीनें।

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

हम जावास्क्रिप्ट में प्रोग्राम करेंगे। सभी कोड के टुकड़े स्पॉइलर के नीचे छिपे हुए हैं ताकि पाठकों को भ्रमित न करें जो प्रोग्रामिंग भाषाओं से परिचित नहीं हैं।

दो आयामी सेलुलर automaton

हम एक यादृच्छिक नियम के साथ दो-आयामी सेलुलर ऑटोमेटन लिखते हैं। हम नियम को नियम सरणी में संग्रहीत करेंगे, जिसकी लंबाई = 512 है:

नियम सरणी भरें

var rulesize=512; var rule=[]; for(var i=0;i<rulesize;i++) rule[i]=Math.round(Math.random());

अगला, एक यादृच्छिक घर के साथ मशीन की प्रारंभिक स्थिति भरें:

हम मशीन की प्रारंभिक अवस्था में भरते हैं

 var sizex=89; var sizey=89; var size=2; var a=[]; for(var x=0;x<sizex;x++){ a[x]=[] for(var y=0;y<sizey;y++){ a[x][y]=Math.round(Math.random()); if(a[x][y]) context.fillRect(x*size, y*size, 1*size, 1*size); } }

(यहां और आगे लेख में, मशीन की चौड़ाई और ऊंचाई के रूप में, एक यादृच्छिक संख्या ली गई है - बहुत बड़ी नहीं और बहुत छोटी विषम नहीं 89)

ऑटोमेटन की निम्नलिखित अवस्था की गणना करने वाला कार्य निम्न प्रकार से है (इसे लिटाने के लिए नहीं, इसने कैनवास के आरंभीकरण को हटा दिया:

हम ऑटोमेटन की निम्नलिखित स्थिति पर विचार करते हैं

 function countpoints(){ var temp=[]; var xm, xp, ym, yp, q; for(var x=0;x<sizex;x++){ xm=x-1; if(xm==-1) xm=sizex-1; xp=x+1; if(xp==sizex) xp=0; temp[x]=[]; for(var y=0;y<sizey;y++){ ym=y-1; if(ym==-1) ym=sizey-1; yp=y+1; if(yp==sizey) yp=0; q=''+a[xm][ym]+a[x][ym]+a[xp][ym]+a[xm][y]+a[x][y]+a[xp][y]+a[xm][yp]+a[x][yp]+a[xp][yp]; q=parseInt(q, 2); temp[x][y]=rule[q]; if(temp[x][y]) context.fillRect(x*size, y*size, 1*size, 1*size); } } a=temp; }

चर xm और xp पड़ोसी के X निर्देशांक को बाईं ओर और पड़ोसी को दाईं ओर (x ऋण और x प्लस) पर संग्रहीत करते हैं। चर ym और yp इसी Y निर्देशांक को संग्रहीत करते हैं।

यहां:

मशीन का क्षेत्र बैगेल में लुढ़का हुआ है

  xm=x-1; if(xm==-1) xm=sizex-1; xp=x+1; if(xp==sizex) xp=0;

हम आवधिक सीमा की स्थिति निर्धारित करते हैं (ऑटोमेटन का क्षेत्र टोरस की सतह है)।

अगला:

... आगे

  q=''+a[xm][ym]+a[x][ym]+a[xp][ym]+a[xm][y]+a[x][y]+a[xp][y]+a[xm][yp]+a[x][yp]+a[xp][yp]; q=parseInt(q, 2); temp[x][y]=rule[q];

उपरोक्त क्रम में, एक स्ट्रिंग में कोशिकाओं की सामग्री लिखें। हम स्ट्रिंग को दशमलव संख्या में अनुवाद करते हैं। इस संयोजन के लिए, हम नियम सरणी में पाते हैं कि x और y निर्देशांक वाले सेल को लेना चाहिए।

अनुकूलित विकल्प

 q=a[xm][ym]; q=(q<<1)+a[x][ym]; q=(q<<1)+a[xp][ym]; q=(q<<1)+a[xm][y]; q=(q<<1)+a[x][y]; q=(q<<1)+a[xp][y]; q=(q<<1)+a[xm][yp]; q=(q<<1)+a[x][yp]; q=(q<<1)+a[xp][yp]; temp[x][y]=rule[q];

सभी पुनरावृत्तियों के बाद, ऑटोमेटन की पिछली स्थिति को एक नए के साथ बदलें:

पिछले राज्य को एक नए के साथ बदलें

 a=temp;

हम सेटऑटरवल फ़ंक्शन का उपयोग करके एक ऑटोमेटन बनाते हैं:

setInterval

 timerId = setInterval(function() { countpoints(); }, 1);

ब्राउज़र में चलाएं

मैं लेख को पढ़ने से पहले 10-20 बार यादृच्छिक नियमों के साथ मशीन शुरू करने की सलाह देता हूं।

हम मशीन को अलग-अलग यादृच्छिक नियमों के साथ बहुत लंबे समय तक चला सकते हैं। जो चित्र हमें मिलता है वह संकेत के अभाव में टीवी स्क्रीन पर मौजूद चित्र से भिन्न नहीं होगा:

अगला, चलो आनुवंशिक एल्गोरिथ्म का उपयोग करके हमारे "टीवी" को स्थापित करने के लिए आगे बढ़ते हैं।

आनुवंशिक एल्गोरिथ्म

प्रारंभिक जनसंख्या का आकार 200 मशीनें (व्यक्ति) हैं। नियमों के लिए, नियम के एक आयामी सरणी के बजाय, हम जनसंख्या के दो-आयामी सरणी का उपयोग करेंगे। पहला इंडेक्स (एन) जनसंख्या में व्यक्ति की संख्या है।

एक जनसंख्या बनाएँ

 var PopulationSize=200; var rulesize=512; var population=[]; var fitness=[]; for(var n=0;n<PopulationSize;n++){ population[n]=[]; fitness[n]=0; for(var i=0;i<rulesize;i++){ population[n][i]=Math.round(Math.random()); } }

फिटनेस सरणी में प्रत्येक व्यक्ति के फिटनेस गुणांक होते हैं। यह सरणी चयन प्रक्रिया में भरी जाती है। चयन के बाद, हम विकासवादी प्रक्रिया शुरू करते हैं।

विकासवादी प्रक्रिया

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

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

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

फंक्शन evolute ();

 function evolute(){ var sizehalf=PopulationSize/2; var sizequarter=sizehalf/2; var arrayt=[]; for(var n=0; n<PopulationSize; n++) arrayt[n]=[population[n], fitness[n]]; arrayt.sort(sortf); arrayt.length=sizehalf; population=[]; fitness=[]; for(var i=0; i<sizequarter; i++){ var i0=i*4; var i1=i*4+1; var i2=i*4+2; var i3=i*4+3; var removed1=Math.floor(Math.random()*(arrayt.length)); var parent1f = arrayt.splice(removed1,1); var parent1=parent1f[0][0]; var removed2=Math.floor(Math.random()*(arrayt.length)); var parent2f = arrayt.splice(removed2,1); var parent2=parent2f[0][0]; var child1=[]; var child2=[]; var qen=Math.floor(Math.random()*rulesize); var temp0=parent1; var temp1=parent2; var temp2=temp0.splice(qen,rulesize); var temp3=temp1.splice(qen,rulesize); var parent1=temp0.concat(temp2); var parent2=temp1.concat(temp3); var child1=temp1.concat(temp2); var child2=temp0.concat(temp3); population[i0]=parent1; population[i1]=parent2; population[i2]=child1; population[i3]=child2; fitness[i0]=0; fitness[i1]=0; fitness[i2]=0; fitness[i3]=0; } var mutation=document.getElementById("mutatepercent").value*1; var m=100/mutation; var m2=0;//0 for(var i=0; i<PopulationSize; i++){ var rnd=Math.floor(Math.random()*(m))+1; if(rnd==1){ var rnd2=Math.floor(Math.random()*(m2))+1; for(var j=0;j<rnd2;j++){ var gen=Math.floor(Math.random()*(rulesize)); if(population[i][gen]) population[i][gen]=0; else population[i][gen]=1; } } } }

प्राकृतिक चयन

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

अग्रिम में क्या मापदंड निर्धारित किए जा सकते हैं? सबसे आसान लो। हमारा "टीवी" बहुत अधिक निमिष है। हम सेलुलर ऑटोमेटन के दो राज्यों को बचाते हैं - 99 पर और 100 पुनरावृत्तियों पर। उन कोशिकाओं की संख्या गिनें, जो नहीं बदली हैं। परिणामी संख्या का उपयोग फिटनेस गुणांक के रूप में किया जाएगा। जाहिर है, एक कसौटी हमारे लिए पर्याप्त नहीं है। ऑटोमेटन को मैन्युअल रूप से चुनना आसान है जो दिए गए मानदंड को पूरा करेगा: ऑटोमेटन [0,0,0, ..., 0] और ऑटोमेटन [1,1,1, ..., 1]। पहले पुनरावृत्ति पर, ये दो ऑटोमेटा शून्य या लोगों से भरे होते हैं और अपना राज्य बदलना बंद कर देते हैं। हम दूसरी कसौटी को परिभाषित करते हैं: मशीन में 0 और 1 (कोशिकाओं) की संख्या का अंतर 100 से अधिक नहीं होता है (संख्या "बुलडोजर से ली गई है")।

array1 - 99 वें पुनरावृत्ति पर ऑटोमेटन की स्थिति। array2 - 100 वें पुनरावृत्ति पर:

हम विचार करते हैं

 function countfitness(array1, array2){ var sum=0; var a0=0; var a1=0; for(var x=0;x<sizex;x++){ for(var y=0;y<sizey;y++){ if(array1[x][y]==array2[x][y]) sum++; if(array1[x][y]==0){ a0++; }else{ a1++; } } } if(Math.abs(a0-a1)<100) return sum; return 0; }

हम शुरू करते हैं। विकास के 421 वें चक्र पर इष्टतम समाधान पाया गया था। ग्राफ़ पर आप प्रगति देख सकते हैं:

ग्राफ को Y अक्ष के साथ बढ़ाया जाता है। निचला बिंदु 0 है, उच्चतम बिंदु 7921 है। यह स्पष्ट है कि 7921 इष्टतम समाधान है (89x89 मशीन में सभी कोशिकाएं निर्दिष्ट मानदंड को पूरा करती हैं)। 100 पुनरावृत्तियों के बाद, कोई भी कोशिका अपना राज्य नहीं बदलती है।

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

जनसंख्या का जीन पूल (वाई अक्ष के साथ व्यक्ति, एक्स अक्ष के साथ जीन):

आइए देखें कि कौन सा चैनल पकड़ा गया हमारा "टीवी":

पाया गया समाधान एकमात्र इष्टतम नहीं है। यदि हम विकास को फिर से चलाते हैं (यादृच्छिक प्रारंभिक जीनोटाइप के साथ), तो हम अन्य इष्टतम समाधान पाएंगे। उनमें से एक:

चयन मानदंड बदलें।

हम उन कोशिकाओं की संख्या पर विचार करेंगे जिनके लिए ऑर्डर 2 के मूर के आसपास के क्षेत्र में एक पैटर्न दिखाई देता है। चलो सरलतम पैटर्न लेते हैं:

यह मानदंड दिलचस्प है कि हम 25 कोशिकाओं की जांच करते हैं, जबकि ऑटोमेटन 9 कोशिकाओं के राज्यों के आधार पर कोशिका की स्थिति की गणना करता है।

कसौटी बहुत कठोर है। यदि हम एक यादृच्छिक ऑटोमेटोन लेते हैं, तो 100 पुनरावृत्तियों के बाद ऐसा दिखता है:

इस तरह के एक स्वचालित क्षेत्र में एक भी सेल दिए गए मानदंड से नहीं मिलता है। इसलिए, हम कसौटी को थोड़ा नरम करते हैं:

आइए पैटर्न में एक गलती करते हैं।
हम अंतिम पुनरावृत्ति पर प्रतिमान की खोज नहीं करेंगे, लेकिन अंतिम 50 पुनरावृत्तियों पर।

दूसरा मानदंड (सफेद और काले के बीच संतुलन) को हटा दिया जाता है।

हम शुरू करते हैं। अनुसूची:

Y अक्ष मनमाना है। (पिछली मशीन में, इष्टतम समाधान 7921 है। इस मशीन में, लगभग 30।)
एक्स अक्ष - 3569 विकास चक्र। दो सफेद ऊर्ध्वाधर रेखाएं 500 और 1000 चक्रों के विकास को चिह्नित करती हैं।
ब्लू डॉट्स - जनसंख्या में सबसे अच्छा व्यक्ति, लाल - सबसे खराब, काला - पूरी आबादी के लिए औसत अनुपात।

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

नीचे दिए गए तीन चित्रों में: 500 चक्र, 1000 चक्र और 3569 विकास चक्र:

जीन पूल (3569):

गतिकी में:

नीचे दी गई तस्वीर में आप देख सकते हैं कि इस मशीन में ऑसिलेटर (ग्लाइडर) कैसे बनता है:

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

इन जीनों में उत्परिवर्तन इस तथ्य के कारण जड़ नहीं लेते हैं कि वे पैटर्न के गठन को बाधित करते हैं।

हमारी मशीन में, एक काली कोशिका के चारों ओर केवल एक पैटर्न (वर्ग) बनता है। चलो दूसरी कसौटी के साथ विकासवादी प्रक्रिया शुरू करने की कोशिश करते हैं: सफेद और काली कोशिकाओं की संख्या के बीच का अंतर 400 से अधिक नहीं है।

हम विकास के 3569 चक्र शुरू करते हैं। अनुसूची:

ग्राफ पर ब्लैक डॉट्स एक आबादी में औसत फिटनेस गुणांक हैं। सफेद डॉट्स - पिछली मशीन की फिटनेस का औसत गुणांक। पैटर्न में एक त्रुटि के साथ एक समाधान मिला।

जीन पूल:

100 पहले पुनरावृत्तियों:

अंतिम (100) पुनरावृत्ति:

थोड़ा ऐसा नतीजा जो हमें उम्मीद थी। काले वर्ग हैं, सफेद - नहीं। दूसरी कसौटी पर कसें: श्वेत और श्याम कोशिकाओं की संख्या का अंतर 100 से अधिक नहीं होता है।

हम विकास के 14865 चक्र शुरू करते हैं।
ग्राफ आबादी के औसत फिटनेस गुणांक की तुलना करता है। ब्लू डॉट्स हमारी मशीन गन हैं। सफेद और काले पिछली मशीनें हैं।

एक ऑटोमेटन इतनी सख्ती से विकसित होता है कि ऐसा लग सकता है कि यह बिल्कुल भी विकसित नहीं होता है। दूसरा ग्राफ Y अक्ष के साथ बढ़ा है। दो सफेद रेखाएं - 500 और 1000 चक्र।

सर्वश्रेष्ठ व्यक्ति में, औसतन, 6 कोशिकाएं किसी दिए गए मानदंड के अनुरूप होती हैं।

आइए आबादी से एक यादृच्छिक मशीन को देखें।
50 पुनरावृत्तियों:

अंतिम (50) पुनरावृत्ति:

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

पैटर्न:

हम शुरू करते हैं। विकास के 3000 चक्र। अनुसूची:

जीन पूल:

गतिकी में (100 पुनरावृत्तियों):

अंतिम (100) पुनरावृत्ति:

पैटर्न:

पिछली मशीनों में, हमने पैटर्न में एक गलती करने की अनुमति दी थी। इस बार, आइए सटीक पैटर्न देखें।

हम विकास के 4549 चक्र शुरू करते हैं। अनुसूची:

सफेद खड़ी रेखा - 2500 चक्रों का विकास। इस बिंदु पर (थोड़ा पहले), आबादी की फिटनेस तेजी से बढ़ने लगी। एक अंतरिम समाधान को देखने के लिए आबादी को बचाया। विकास के 4549 वें चक्र पर समाधान की तुलना में मध्यवर्ती समाधान बहुत अधिक दिलचस्प निकला।

विकास के 4549 वें चक्र पर पाया समाधान:

Gif पर 100 पुनरावृत्तियों हैं। पुनरावृत्तियों की एक निश्चित संख्या (लगभग 500-2000) के बाद, ऑटोमेटन की स्थिति लगभग पूरी तरह से ऑर्डर की जाती है (ऑटोमेटन की ऊंचाई और चौड़ाई विशेष रूप से विषम संख्याओं द्वारा चुनी जाती है, ताकि ऑटोमेटन पूरी तरह से ऑर्डर नहीं किया जा सके):

पक्षों के आकार के साथ एक ऑटोमेटन, पुनरावृत्तियों की एक निश्चित संख्या के बाद, पूरी तरह से आदेशित स्थिति लेता है। स्वचालित 90x90, लगभग 1200 पुनरावृत्तियों:

मध्यवर्ती समाधान (विकास के 2500 वें चक्र पर पाया गया):

यह ऑटोमेटन यह भी जानता है कि एक निश्चित परिमित राज्य में एक निश्चित प्रारंभिक अराजक स्थिति को कैसे संसाधित किया जाए (अंतिम आदेश दिया गया राज्य X अक्ष के साथ बाईं + कई थरथरानवाला कोशिकाओं का पैटर्न है)।

16x16 मशीन ने लगभग 100 पुनरावृत्तियों में हल किया है:

32x32 - लगभग 1000 पुनरावृत्तियों:

64x64 - लगभग 6000 पुनरावृत्तियों:

90x90 - 370000 पुनरावृत्तियों के बारे में:

11x11 (ऑटोमेटन क्षेत्र के विषम आयाम) - लगभग 178700 पुनरावृत्तियों:

13x13 असाल्ट राइफल ने स्वीकार्य समय में सुव्यवस्थित नहीं किया।

नीचे दी गई तस्वीर में, 100,000 वें स्थान पर 256x256 फ़ील्ड पर मशीन:

मैं एक बड़े क्षेत्र में गतिशीलता में इस ऑटोमेटन को देखने की सलाह देता हूं - इस ऑटोमनटन में अराजकता के स्वयं-संगठन की प्रक्रिया का निरीक्षण करना बहुत दिलचस्प है: एक ब्राउज़र में चलाना

मध्यवर्ती आबादी का जीन पूल:

विकासवादी प्रक्रिया को फिर से शुरू करने से आपको अन्य समाधान खोजने की अनुमति मिलती है। उनमें से एक:

एक और पैटर्न:

पैटर्न की खोज करते समय, हम फिर से एक गलती करते हैं (त्रुटियों के बिना, चयनित पैटर्न वाला सिस्टम विकसित नहीं होता है)।

हम शुरू करते हैं। विकास के 5788 चक्र। अनुसूची:

पैमाना मनमाना है।

जीन पूल:

गतिकी में:

ऑटोमेटन की क्रमबद्ध स्थिति (वाई अक्ष + कई थरथरानवाला कोशिकाओं के साथ ऊपर की ओर पैटर्न):

यह अधिक दिलचस्प है कि मशीन स्वयं न देखें, लेकिन इस आबादी में दिखाई देने वाले म्यूटेंट:

Gif पर, मशीन 256x256 है। 200 पुनरावृत्तियों। शेष पुनरावृत्तियों को ब्राउज़र में देखा जा सकता है ।

कोई प्राकृतिक चयन के साथ समाप्त हो सकता है और कृत्रिम पर जा सकता है, लेकिन मैं यह दिखाना चाहता हूं कि कितना

$2 ^ {512}$ एक बड़ी संख्या। ऑटोमेटा की इस संख्या के बीच, हम एक ऑटोमेटन पा सकते हैं जो किसी भी दिए गए पैटर्न को आकर्षित करता है (अधिक जटिल पैटर्न के लिए कुछ सटीकता के साथ)।

निम्नलिखित पैटर्न:

पिछले प्रयोगों में, हमने उन कोशिकाओं के योग को गिना है जिनके चारों ओर एक पैटर्न बनता है (यदि एक त्रुटि के साथ, योग में 1 जोड़ दें, यदि त्रुटि के बिना, 2 जोड़ें)। परिणामी राशि का उपयोग आनुवंशिक एल्गोरिथ्म के लिए एक फिटनेस कारक के रूप में किया गया था।

अधिक जटिल पैटर्न के लिए, यह विधि काम नहीं करती है। एक ऑटोमेटन जिसमें कोशिकाओं की एक छोटी संख्या किसी दिए गए मानदंड से मेल खाती है (सेल के आसपास के क्षेत्र में पैटर्न से मेल खाने वाली कोशिकाओं की संख्या) प्रत्येक बार एक ऑटोमेटन से हार जाएगी जिसमें बड़ी संख्या में कोशिकाएं कम सटीकता से दिए गए मानदंड से मेल खाती हैं। ऊपर के वर्गों के साथ उदाहरण में:

वांछित पैटर्न के लिए, आबादी में प्रत्येक ऑटोमेटन के 100 वें पुनरावृत्ति पर, प्रत्येक सेल से घिरा हुआ है, हम पैटर्न से मेल खाने वाली कोशिकाओं की संख्या पर विचार करेंगे। हम प्रत्येक मशीन के लिए केवल सबसे अच्छा परिणाम लेंगे। पैटर्न से मेल खाने वाली कोशिकाओं की संख्या एक फिटनेस कारक के रूप में उपयोग की जाएगी। पैटर्न में 7x17 = 119 सेल होते हैं। इस संख्या को इष्टतम समाधान माना जाएगा। विकास के 6000 चक्रों ने हमें एक ऑटोमेटन खोजने की अनुमति दी जो 5 त्रुटियों के साथ एक पैटर्न तैयार करता है (114 कोशिकाएं पैटर्न के साथ मेल खाती हैं)।

मनमाना पैमाने पर ग्राफ:

उत्परिवर्तन के प्रतिशत में वृद्धि से जनसंख्या की फिटनेस ख़राब नहीं हुई।

जनसंख्या के जीन पूल में कई उत्परिवर्ती हैं:

गतिशीलता में आबादी से एक यादृच्छिक ऑटोमेटन:

100 वें पुनरावृत्ति पर सबसे अच्छी मशीन:

खोजा और पाया पैटर्न:

चयन मानदंड, ऑटोमेटन क्षेत्र के आकार और म्यूटेशन के प्रतिशत के साथ खेलने के बाद, यह आबादी में सुधार करने और एक ऑटोटोन खोजने के लिए निकला जो पैटर्न में केवल 3 त्रुटियां करता है।

जीन पूल:

मशीन 100 वें पुनरावृत्ति पर:

खोजा और पाया पैटर्न:

२ त्रुटियां

लेख लिखने की प्रक्रिया में, प्रणाली का विकास जारी रहा। अधिक सटीक खोज के लिए, मशीन के क्षेत्र का आकार बढ़ाकर 513x513 कर दिया गया है। एक ऑटोमेटन पाया गया जो पैटर्न में केवल दो त्रुटियां करता है:

चार रेखांकन में, आप देख सकते हैं कि सिस्टम विभिन्न उत्परिवर्तन संभावनाओं (1 जीन उत्परिवर्तन) के साथ कैसे विकसित होता है।

लाल डॉट्स एक आबादी में औसत फिटनेस गुणांक हैं। ब्लैक डॉट्स प्रत्येक व्यक्ति के फिटनेस गुणांक हैं। प्रत्येक प्रणाली के लिए 3000 विकास चक्र।

आबादी के जीन पूल (उसी क्रम में):

100 वें पुनरावृत्ति पर ऑटोमेटा:

चलिए एक और प्रयोग करते हैं। पैटर्न एक ही है। प्रारंभिक जीनोटाइप यादृच्छिक जीन से भरे हुए हैं। म्यूटेशन की संभावना 5% है। 1 से 8 जीन म्यूटेट (प्रत्येक व्यक्ति के लिए उत्परिवर्तित जीन की एक यादृच्छिक संख्या) ली जाती है। विकास के 100 चक्र।

ग्राफ गर्मी का नक्शा है। चार्ट पर बिंदु का आकार 5 पिक्सेल है। मूल ऊपरी बाएँ कोने है।
वाई अक्ष पर (0 से 100 तक) - विकास के चक्र। एक्स अक्ष पर (0 से 119 तक) - पैटर्न के साथ मेल खाने वाली कोशिकाओं की संख्या (जनसंख्या में प्रत्येक व्यक्ति के लिए हम सबसे अच्छा परिणाम लेते हैं)। बिंदु की चमक निर्दिष्ट (एक्स समन्वय) परिणाम वाले व्यक्तियों की संख्या है।

एक ही पैरामीटर (100 चक्र, 5% उत्परिवर्तन, 8 जीन म्यूटेट तक) के साथ आनुवंशिक एल्गोरिथ्म को 4 बार चलाएं। ग्राफ पर, सभी 5 शुरू होता है:

निम्न 5 शुरू होता है: 25% उत्परिवर्तन, 8 जीन तक उत्परिवर्तन:

नमूना छोटा है, लेकिन हम म्यूटेशन के प्रतिशत को बढ़ाने की प्रभावशीलता के बारे में निष्कर्ष निकाल सकते हैं।

आगे, मैं लेख में प्रयुक्त क्रॉसिंग विधि की अक्षमता दिखाऊंगा।

पूर्व में प्रयुक्त विधि:

वंश को दो भागों में विभाजित करने के बजाय, वंशज यादृच्छिक पैतृक जीन विरासत में मिलेगा:

5% म्यूटेशन:

25%:

आगे हम क्रॉस के इस तरीके का उपयोग करेंगे।

इस पर प्राकृतिक चयन खत्म। यदि किसी के पास प्राकृतिक चयन के मानदंड के बारे में दिलचस्प विचार हैं - कृपया उन्हें टिप्पणियों में बताएं।

कृत्रिम चयन के लिए हम दूसरे क्रम वाले सेलुलर ऑटोमेटा का उपयोग करेंगे।

द्वितीय-क्रम सेलुलर ऑटोमेटन

पहले आदेश के एक शून्य-आयामी सेलुलर ऑटोमेटन पर विचार करें (सभी सेलुलर ऑटोमेटा जिसे हम ऊपर माना जाता है, पहले क्रम के हैं)। एक शून्य-आयामी सेलुलर ऑटोमेटन में एक सेल होता है। एक सेल दो राज्यों में से एक में हो सकती है। कोशिका की अगली स्थिति (t) कोशिका की वर्तमान स्थिति (t-1) से निर्धारित होती है। कुल में, 4 शून्य-आयामी सेलुलर ऑटोमेटा हैं (उनमें से एक थरथरानवाला):

एक दूसरे क्रम के सेलुलर ऑटोमेटन में, सेल की अगली स्थिति (टी) वर्तमान स्थिति (टी -1) और सेल की पिछली स्थिति (टी -2) द्वारा निर्धारित की जाती है। कुल में, दो सेल राज्यों के 4 संयोजन हैं।

$2 ^ {4} = $ 1$ - दूसरे क्रम के शून्य-आयामी सेलुलर ऑटोमेटा की संख्या:

ऐसे सेलुलर ऑटोमेटा अधिक जटिल ऑसिलेटर्स का प्रदर्शन करते हैं।

$2 ^ {8} = 256$ तीसरे क्रम के सेलुलर ऑटोमेटा:

$2 ^ {16} = 65536$ चौथे क्रम के सेलुलर ऑटोमेटा को एक चित्र में नहीं दिखाया जा सकता है।

सेल ऑटोमेटन खोज

$एन$ -तथा आदेश एक दोलन अवधि के बराबर

$एन$ - कार्य गैर-तुच्छ और बेहद दिलचस्प है। यह विषय एक अलग लेख के योग्य है।

दूसरे आयामी एक आयामी सेलुलर ऑटोमेटा में, सेल की निम्नलिखित स्थिति तीन कोशिकाओं की वर्तमान स्थिति और एक सेल की पिछली स्थिति से निर्धारित होती है:

वहाँ है

$2 ^ {16} = 65536$ दूसरे क्रम का एक आयामी सेलुलर ऑटोमेटा।

कोड:

 var rule=[]; for(var i=0;i<16;i++) rule[i]=Math.round(Math.random()); var a=[]; var b=[]; var temp; for(var x=0;x<sizex;x++){ a[x]=0; b[x]=0; } b[63]=1; var xm, xp, q; for(var y=2;y<sizey;y++){ temp=[]; for(var x=0;x<sizex;x++){ xm=x-1; if(xm<0) xm=sizex+xm; xp=x+1; if(xp>=sizex) xp=xp-sizex; q=b[xm]; q=(q<<1)+b[x]; q=(q<<1)+b[xp]; q=(q<<1)+a[x]; temp[x]=rule[q]; if(temp[x]) context.fillRect(x*size, y*size, size, size); } a=b; b=temp; }

प्रथम-क्रम सेलुलर ऑटोमेटा की तुलना में द्वितीय-क्रम सेलुलर ऑटोमेटा अधिक जटिल पैटर्न बनाते हैं।

नीचे दिए गए चित्रों में, दूसरे क्रम की कई यादृच्छिक मशीनें (चित्र के बाईं ओर - राज्य में टी -1, एक सेल भरी हुई है, दाईं ओर - यादृच्छिक राज्यों के लिए टी -1 और टी -2, बाइनरी कोड नियम सरणी की सामग्री है:

0011111011001000:

0101101110011110:

0110000110010010:

0110011010010110:

1110011010010110:

0110111010000101:

1111101001110110:

1001010001100000:

एक ही मशीन 256x256:

512x512

अन्य मशीनें यहां पाई जा सकती हैं:
एक आयामी दूसरी क्रम वाली सेलुलर मशीन।
तीसरे क्रम का एक आयामी सेलुलर ऑटोमेटन।

दूसरे क्रम के एक आयामी सेलुलर ऑटोमेटा को वुल्फराम की पुस्तक ए न्यू काइंड ऑफ साइंस में पाया जा सकता है।

कृत्रिम चयन

दूसरे क्रम के एक-आयामी सेलुलर ऑटोमोबोन की तरह, दूसरे क्रम के दो-आयामी सेलुलर ऑटोमेटन में हम ऑटोमेटन के पिछले (टी -2) राज्य से एक अतिरिक्त सेल का उपयोग करेंगे।

सुविधा के लिए, हम इस सेल को बाइनरी लाइन की शुरुआत में रखते हैं:

सुविधा इस तथ्य में निहित है कि जब जीनोटाइप के पहले और दूसरे छमाही में संयोग होता है, तो ऑटोमेटन को प्रथम-ऑर्डर ऑटोमेटन माना जा सकता है:

एक सेल को जोड़कर, हमने मौजूदा ऑटोमेटा की संख्या में वृद्धि की है।

बार।

$2^{512}$

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

$2^{512} \times 2^{512} = 2^{1024}$

1. मशीन की प्रारंभिक अवस्था में, एक सेल भरा होता है

एक तरीका यह है कि सेलुलर ऑटोमेटन के विकास का निरीक्षण किया जाए, जिसमें प्रारंभिक अवस्था में एक कोशिका भरी होती है।

हम यादृच्छिक मशीनों के साथ प्रारंभिक जनसंख्या को भरते हैं। प्रारंभिक आबादी की कई मशीनें (प्रत्येक के लिए 30 पुनरावृत्तियों):

ये दोनों पलक झपकते हैं

जनसंख्या में कम अराजक व्यवहार प्रदर्शित करने वाली ऑटोमेटा की एक छोटी संख्या मौजूद है। हम उन्हें पार करने के लिए चुनेंगे:

प्रारंभिक जनसंख्या से 20 यादृच्छिक मशीनें (30 वें पुनरावृत्ति पर मशीनों की स्थिति):

विकास के तीन चक्रों के

बाद : विकास के आठ चक्रों के बाद: विकास के

आठ चक्र एक निश्चित विशेषता (एक मशीन जो त्रिकोण बनाते हैं) के साथ पूरी आबादी को भरने के लिए पर्याप्त थे ।

2. जीनोटाइप आंशिक रूप से भरा हुआ है

यदि जीनोटाइप में इकाइयों और शून्य के अनुपात का उल्लंघन किया जाता है, तो फेनोटाइप में इकाइयों और शून्य के अनुपात का उल्लंघन किया जाता है।

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

एक चार्ट बनाएँ।

200 मशीनों की आबादी बनाएँ। हम जीनोटाइप को जीरो से भरते हैं (दो-आयामी दूसरे क्रम के ऑटोमेटन के जीनोटाइप में 1024 जीन)। आगे

जीन इकाइयों में भरते हैं। पहली आबादी के लिए

$एन$

, 513 वीं जनसंख्या के लिए

$n=0$

$n=512$ । अक्ष के साथ

जनसंख्या संख्या है। अक्ष के साथ

$x$

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

$y$

उन मशीनों से तुलना करें जिनमें शून्य जीन हमेशा एक के बराबर होता है:

दूसरे क्रम वाली मशीनों में, एक और "शून्य" जीन होता है - 512 वां। आइए देखें कि यह जीन फेनोटाइप को कैसे प्रभावित करता है।

0 वां और 512 वां जीन हमेशा शून्य होता है: 0 वां जीन हमेशा शून्य

होता है। 512 वें जीन हमेशा एक के बराबर होते हैं:

हमारे सम्मानित एपिलेप्टिक्स का एक बार फिर से मजाक न करने के लिए, आनुवंशिक एल्गोरिथम की प्रारंभिक आबादी में 0 वें और 512 वें जीन को जीरो से भर दिया जाएगा।

आइए उन मशीनों को देखें जिन्हें हमने 0 और 512 वें जीन को शून्य सेट करके छुटकारा दिलाया।

एक ऑटोमेटन के पहले 8 राज्य जिसमें केवल 0

वां जीन भरा होता है (शून्य जीन एक होता है, शेष शून्य होते हैं): एक ऑटोमेटोन जिसमें केवल 512 वां जीन

भरा होता है : एक ऑटोमेटोन जिसमें केवल 0 वां और 512 जीन भरा होता है:

आइए हम ग्राफ पर एक स्थान बनाते हैं जहाँ जनसंख्या समूहों में विभाजित होने लगती है:

इस स्थान पर, जीनोटाइप 25% भरे हुए हैं।

दो आबादी की तुलना करें।

पहली आबादी। 1000 वीं पुनरावृत्ति पर 30 यादृच्छिक मशीनें। जीनोटाइप 50% पूर्ण (512 यूनिट और 512 शून्य) हैं:

दूसरी आबादी। 1000 वीं पुनरावृत्ति पर 30 यादृच्छिक मशीनें। जीनोटाइप 25% पूर्ण (256 यूनिट और 768 शून्य) हैं:

दूसरी आबादी कृत्रिम चयन के लिए उपयुक्त है। हम ऐसी मशीनों में कुछ संकेतों को आसानी से उजागर कर सकते हैं। उदाहरण के लिए: "गहरा", "कम अराजक" (ऑटोमेटा जिसमें सफेद कोशिकाओं को समूहीकृत किया जाता है), आदि।

हम "गहरा" चुनते हैं। म्यूटेशन की संभावना 10% है, 4 जीन म्यूटेट तक। पहले चयन के

बाद : दूसरे चयन के बाद:

आबादी में एक दिलचस्प ऑटोमेटन दिखाई दिया।

256x256, 1000 वें पुनरावृत्ति पर मशीन की स्थिति:

मशीन धीरे-धीरे आबादी भरती है।

आठवें चयन के बाद:

एक और दिलचस्प मशीन दिखाई दी।

256x256, 1000 वें पुनरावृत्ति पर ऑटोमेटन की स्थिति:

तेरह चयनों के बाद जनसंख्या:

इस जनसंख्या से कई ऑटोमेटा। 256x256, सभी के लिए 1000 वाँ पुनरावृत्ति। तस्वीर के नीचे एक लिंक है, जिस पर क्लिक करके, आप मशीन को डायनेमिक्स में देख सकते हैं:

डायनेमिक्स में देखें।

गतिशीलता में देखें।

3. स्वत: मशीन और तरह Conway

पहले क्रम का सबसे प्रसिद्ध दो आयामी सेलुलर ऑटोमेटन कॉनवे ऑटोमेटन गेम "लाइफ" है ।

कॉनवे ऑटोमेटन के लिए नियम निम्नानुसार हैं:
यदि किसी मृत कोशिका के आसपास 3 जीवित कोशिकाएं हैं, तो कोशिका जीवन में आती है (अन्यथा यह मृत बनी हुई है)।
यदि एक जीवित कोशिका के आसपास 2 या 3 जीवित कोशिकाएं हैं, तो कोशिका जीवित रहती है (अन्यथा यह मर जाती है)।
एक मृत कोशिका 0 है, एक जीवित कोशिका 1 है।

लगभग एक कोशिका 0 से 8 जीवित कोशिकाओं की हो सकती है। जीवित और मृत कोशिका के आसपास 9 विकल्पों के अनुसार। हम आर सरणी के सभी विकल्प लिखते हैं:

सरणी आर

 r=[ 0,0,0,1,0,0,0,0,0, 0,0,1,1,0,0,0,0,0 ];

सरणी का पहला भाग एक मृत कोशिका के लिए है, दूसरा जीवित कोशिका के लिए है।

हम एक सेल और 8 पड़ोसी कोशिकाओं के सभी संभावित (512) संयोजनों के लिए कॉनवे ऑटोमेटन के नियम का वर्णन कर सकते हैं:

नियम को रंग दें

 r=[ 0,0,0,1,0,0,0,0,0, 0,0,1,1,0,0,0,0,0 ]; var rule=[]; var q1, q2; for(var i=0;i<512;i++){ var ii=i.toString(2); for(var j=ii.length;j<9;j++) ii='0'+ii; q1=1*ii[4]; q2=1*ii[0]+1*ii[1]+1*ii[2]+1*ii[3]+1*ii[5]+1*ii[6]+1*ii[7]+1*ii[8]; if(q1==0) rule[i]=r[q2]; else rule[i]=r[q2+9]; }

अनुकूलित विकल्प

 r=[ 0,0,0,1,0,0,0,0,0, 0,0,1,1,0,0,0,0,0 ]; var rule=[]; for(var i=0;i<512;i++){ var q=((i>>4)&1)*8; for(var j=0;j<9;j++){ q+=(i>>j)&1; } rule[i]=r[q]; }

दूसरे क्रम के ऑटोमेटन के लिए, नियम सरणी के दूसरे भाग को पहले से कॉपी करें:

प्रतिलिपि

 for(var i=0;i<512;i++){ if(rule[i]==0) rule[i+512]=0; else rule[i+512]=1; }

हम मशीन को निर्दिष्ट नियम से शुरू करते हैं। हम विशेषता ग्लाइडर और दोलक देखते हैं। इस ऑटोमेटन के कई पुनरावृत्तियों:

एरे आर में 18 कोशिकाएं हैं। वहाँ है

ऑटोमेटा कॉनवे

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

$2^{18}=262144$

एक आनुवंशिक एल्गोरिथ्म के लिए, एक जीनोटाइप के रूप में, आप एक सरणी आर के रूप में उपयोग कर सकते हैं (

संयोजन), और नियम सरणी (

$2^{18}$

सेलुलर automaton के लिए पहले के आदेश के संयोजन और

$2^{512}$

- दूसरे क्रम के एक सेलुलर ऑटोमेटन के लिए)।

$2^{1024}$

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

$2^{18}$

... और इनके लिए

अगले पुनरावृत्ति पर कोशिका की स्थिति समान होती है। पहली क्रॉसिंग के बाद, वंशज व्यक्तियों के नियमों में समरूपता टूट जाती है। पैतृक व्यक्ति म्यूटेशन जमा करते हैं जो समरूपता को भी नष्ट करते हैं। जीनोटाइप में समरूपता का उल्लंघन फेनोटाइप में समरूपता के उल्लंघन का कारण बनता है।

फेनोटाइप में इस समरूपता के प्रकटन को देख सकते हैं यदि एक सेल ऑटोमेटन की प्रारंभिक अवस्था में भर जाता है।

चलो एक प्रयोग करते हैं। समरूपता बनाए रखने के लिए, हम आर सरणी का उपयोग जीनोटाइप के रूप में करेंगे। 5% उत्परिवर्तन, 1 जीन उत्परिवर्तन। प्रारंभिक अवस्था में, एक कोशिका भर जाती है।

प्रारंभिक आबादी से 30 यादृच्छिक मशीनें। 30 वें पुनरावृत्ति पर ऑटोमेटा की स्थिति:

आइए हम ऐसे ऑटोमेटा को अलग करने की कोशिश करें जो एक कोशिका से सबसे धीरे-धीरे विकसित (विकसित) हो।

पहले चयन के बाद, उन्हें ऑटोमेटा से छुटकारा मिला जो विकसित नहीं होते हैं:

नई आबादी में कई ऐसे ऑटोमेटा (जो विकसित नहीं होते हैं) हैं - ये असफल वंशज और म्यूटेंट हैं।

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

ब्लैक वेंडिंग मशीनें पलक झपकते हैं।

( — ) — . ( ) ( ). . — () . ( — , — ). 30- , — . ( 30- ) — ( ).

दूसरे चयन के बाद जनसंख्या:

3 चयन:

5 चयन:

8 चयन:

13 चयन:

60 वें पुनरावृत्ति में एक ही मशीन:

21 चयन। 30 वें पुनरावृत्ति पर ऑटोमेटा की

स्थिति: 60 वें पुनरावृत्ति में ऑटोमेटा की स्थिति:

34 चयन। 30 वें पुनरावृत्ति

पर ऑटोमेटा राज्य : 60 वें पुनरावृत्ति पर ऑटोमेटा राज्य:

इसके अलावा, सिस्टम विकसित नहीं होता है। इस जनसंख्या से तीन ऑटोमेटा (

प्रत्येक में 100 पुनरावृत्तियों): [1,0,1,1,1,0,0,1,0,0,1,1,0,1,0,1,1,1]

[1 , 0,1,1,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1]

[1,0,0,1,1,0,0,

तुलना के लिए 1,1,0,1,0,1,1,0,1,1,1] एक यादृच्छिक मशीन:

[1,0,0,1,1,1,0,1,1,1,0, 0,1,1,0,0,0,1]

4. Conway ऑटोमेटन और पसंद (2)

कॉनवे प्रकार के नियमों के साथ मशीनों में, हम मूर के आसपास के क्षेत्र में कोशिकाओं के रहने (इकाइयों) की संख्या की गणना करते हैं। इस पड़ोस को 4 जोड़े में विभाजित किया जा सकता है और इन जोड़ियों में जीवित कोशिकाओं की संख्या की गणना कर सकता है:

इस प्रकार, हम ऑटोमेटा की संख्या बढ़ाते हैं, लेकिन फेनोटाइप में समरूपता बनाए रखते हैं।

प्रत्येक जोड़ी में 0 से 2 जीवित कोशिकाएं हो सकती हैं। Par 4. संयोजनों की संख्या

$3^4=81$ ।जीवित और मृत कोशिका के आसपास 81 वें संयोजन के अनुसार। कुल मौजूद है

इस प्रकार की

स्वचालित मशीनें। संख्या:

$2^{162}$

$2^{162}\approx5.846\times10^{48}$

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

प्रत्येक व्यक्ति का जीनोटाइप आकार 162 जीन है:

यादृच्छिक मशीनों के साथ जनसंख्या भरें

 var rulesize=162; for(var n=0;n<PopulationSize;n++){ population[n]=[]; fitness[n]=0; for(var i=0;i<rulesize;i++){ population[n][i]=Math.round(Math.random()); } }

अगला, हम एक सेल और आठ पड़ोसी कोशिकाओं के सभी संभावित संयोजनों के लिए इस नियम को चित्रित करते हैं:

समारोह भरण ();

 function fillrule(){ var r; for(var n=0;n<PopulationSize;n++){ rule[n]=[]; r=population[n]; var q1, q2, q3, q4, q5; var q; for(var i=0;i<512;i++){ var ii=i.toString(2); for(var j=ii.length;j<9;j++) ii='0'+ii; q1=1*ii[4]; q2=1*ii[0]+1*ii[8]; q3=1*ii[1]+1*ii[7]; q4=1*ii[2]+1*ii[6]; q5=1*ii[3]+1*ii[5]; q=parseInt(''+q2+q3+q4+q5,3); if(q1==0) rule[n][i]=r[q]; else rule[n][i]=r[q+81]; } } }

हम ऑटोमोबाइल के अगले राज्य की गणना करते समय नियम सरणी का उपयोग करेंगे। हम पृष्ठ को लोड करने के बाद और evolute () फ़ंक्शन को कॉल करने के बाद फिलरेल () फ़ंक्शन को कॉल करते हैं।

प्रारंभिक आबादी अराजक दिखती है। 30 यादृच्छिक मशीनें, 1000 वीं पुनरावृत्ति:

यह अराजकता गतिशीलता में थोड़ा भिन्न होती है और मशीनें चयन के लिए काफी उपयुक्त होती हैं, लेकिन चलो इसे आसान बनाते हैं - हम "सबसे गहरे" का चयन करेंगे।

पांच चयनों के बाद जनसंख्या:

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

256x256, सभी के लिए 10000 वां पुनरावृत्ति। तस्वीर के नीचे एक लिंक है, जिस पर क्लिक करके, आप मशीन को डायनेमिक्स में देख सकते हैं:

डायनेमिक्स में देखें।

?

और आप यहां खेल सकते हैं:

दूसरे क्रम के दो-आयामी सेलुलर ऑटोमेटा।

इंटरफ़ेस:

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

नीचे 20 यादृच्छिक मशीनें (जनसंख्या का आकार - 200 मशीनें)। वेंडिंग मशीनों के तहत चेकबॉक्स। हम सबसे दिलचस्प चिह्नित करते हैं। प्रेस का चयन करें - मशीन की फिटनेस दाईं ओर इंगित संख्या से बढ़ जाएगी।
उत्परिवर्तन - उत्परिवर्तन की संभावना।
जीन उत्परिवर्तन जीन की संख्या है।

विकास शुरू करें - क्रॉस और म्यूटेशन के तंत्र को लॉन्च करता है।

जीनोटाइप भरें - प्रत्येक ऑटोमेटन के जीनोटाइप में जीन की निर्दिष्ट संख्या को भरता है।
कॉनवे - कोनवेव्स्की प्रकार की मशीनों के साथ आबादी को भरता है।

नीचे दो लाइनें हैं:
दिखाए गए मशीनों की संख्या।
फेनोटाइप सरणी की सामग्री।

आबादी का जीन पूल और भी कम है।

सभी प्रगति स्थानीय भंडारण में संग्रहीत की जाती है।

आप यहां कोनवेव्स्की टाइप असॉल्ट राइफल्स के साथ खेल सकते हैं (उन लोगों के साथ जो इस लेख में अंतिम बार माने गए थे): 4. कॉनवे ऑटोमेटन और लाइक

(2)।

सेलुलर ऑटोमेटा का विकास

सेलुलर ऑटोमेटा के लिए नियम

दो आयामी सेलुलर automaton

आनुवंशिक एल्गोरिथ्म

विकासवादी प्रक्रिया

प्राकृतिक चयन

द्वितीय-क्रम सेलुलर ऑटोमेटन

कृत्रिम चयन

1. मशीन की प्रारंभिक अवस्था में, एक सेल भरा होता है

2. जीनोटाइप आंशिक रूप से भरा हुआ है

3. स्वत: मशीन और तरह Conway

4. Conway ऑटोमेटन और पसंद (2)

?

More articles: