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

कार्यक्रमों की 1. स्वचालित पीढ़ी

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

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

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

विषय क्षेत्र के लिए सिस्टम ट्यूनिंग उत्पन्न कक्षाओं का एक उपयुक्त पदानुक्रम विकसित करके किया जाता है।

एक उत्पन्न स्क्रिप्ट का एक उदाहरण जो कक्षा के लिए कोड बनाता है "वेक्टर प्रसंस्करण (न्यूनतम, अधिकतम, अंकगणितीय माध्य)":

<? if ($Stage == stInit) { $argumentID = $Arg["ID"][0]; $argumentSize = $Arg["Size"][0]; $resultID = GetNextMail("result" . $this->ID); if ($this->Op == "Min") { echo " " . $resultID . " = 1E300;\n"; } else if ($this->Op == "Max") { echo " " . $resultID . " = -1E300;\n"; } elseif ($this->Op == "Avr") { echo " " . $resultID . " = 0.0;\n"; } ?> for (i = 0; i < <? echo $argumentSize; ?>; i++) <? if ($this->Op == "Min") { ?> if (<? echo $argumentID . "[i] < " . $resultID; ?>) <? echo $resultID . " = " . $argumentID . "[i];\n"; } else if ($this->Op == "Max") { ?> if (<? echo $argumentID . "[i] > " . $resultID; ?>) <? echo $resultID . " = " . $argumentID . "[i];\n"; } elseif ($this->Op == "Avr") { echo " " . $resultID . " += " . $argumentID . "[i];\n"; } if ($this->Op == "Avr") { echo " " . $resultID . " /= " . $argumentSize . ";\n"; } } ?> 

यह एक अपेक्षाकृत सरल योजना है जो काम करती है। ऐसी प्रणाली जो ऐसी पीढ़ी योजना (PGEN ++) को लागू करती है, उदाहरण के लिए, निम्नलिखित क्षेत्रों में निर्णायक कार्यक्रमों की पीढ़ी की अनुमति देती है:

क) प्रदूषण के प्रसार की मॉडलिंग प्रक्रियाएं;
बी) सरल रोबोट मैनिपुलेटर की कुछ कीनेमेटिक्स समस्याओं का समाधान;
स) वेक्टर डेटा के साथ काम करने के लिए सरल प्रशिक्षण कार्यक्रम (न्यूनतम, अधिकतम, अंकगणितीय माध्य की खोज);
डी) मनोवैज्ञानिक परीक्षण प्रणाली PROFTEST के लिए परीक्षणों का विकास।

ब्लॉक आरेख के रूप में समस्या के प्रारंभिक विवरण (एक साधारण वेक्टर डेटा प्रोसेसिंग प्रोग्राम) का एक उदाहरण है :



और यह कार्यक्रम उत्पन्न करने का परिणाम है :

2. उलटा समस्या: उत्पन्न कार्यक्रम के अनुसार समस्या (प्रारंभिक मॉडल) के बयान का पुनर्निर्माण। उत्पन्न कार्यक्रमों का सत्यापन

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

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

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

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

3. प्रोग्राम जनरेशन सिस्टम के लिए प्राकृतिक-भाषा इंटरफ़ेस

उलटा समस्या को हल करते समय (ऊपर वर्णित), समस्या के मॉडल के पुनर्निर्माण के लिए स्रोत सामग्री के प्रकार पर कोई प्रतिबंध नहीं है। यह अच्छी तरह से प्राकृतिक भाषा में एक पाठ हो सकता है। बस उपयुक्त मान्यता विधियाँ लिखें। इसलिए, उलटा समस्या का एक अप्रत्याशित अनुप्रयोग पीढ़ी प्रणाली के लिए एक प्राकृतिक भाषा इंटरफ़ेस का कार्यान्वयन हो सकता है:

a) समस्या का विवरण सरल प्राकृतिक भाषा में लिखा गया है;
बी) उलटा समस्या हल हो गई है - एक औपचारिक बयान प्राकृतिक भाषा के बयान (विषय क्षेत्र के वस्तुओं-तत्वों का एक नेटवर्क) से निकाला जाता है;
ग) प्राप्त औपचारिक विवरण के अनुसार कार्यक्रम तैयार करने के लिए सिस्टम लॉन्च किया गया है।

और यह सर्किट काम भी करता है। वेक्टर डेटा के साथ काम करने के लिए सरल प्रशिक्षण कार्यक्रमों के एक ही मामले के लिए एक उदाहरण विकसित किया गया है।

यहां एक मान्यता पद्धति ("एक वेक्टर या एक स्केलर दर्ज करें" कीपैड वर्ग) का एक उदाहरण है , जो दो संस्करणों (प्रोग्राम पाठ की मान्यता (प्रोग्राम मोड) या रूसी (रूसी मोड) में एक समस्या बयान के टुकड़े के मान्यता) की मान्यता में विभाजित है। शीर्ष पर मान्यता हिस्सा है, फिर GNU प्रोलॉग पर भविष्यवाणी करता है।

 @versions(Programmatical) @global_unique(PROCESS,infinity):- (\s*for\s*\(i\s*\=\s*0\;\s*i\s*\<\s*(\d+)->{N}\;\s*i\+\+\)\s*\{\\n\s*printf\(\"(\w+)->{VECTOR} \[\%i\]\s*\=\s*\"\,\s*i\)\;\\n\s*scanf\(\"\%lf\"\,\s*\&(\w+)==>{VECTOR}\[i\]\)\;\\n\s*\}\\n)| (\s*printf\(\"(\w+)->{SCALAR}\s*\=\s*\"\)\;\\n\s*scanf\(\"\%lf\"\,\s*\&(\w+)==>{SCALAR}\)\;\\n). @versions(Russian) @nearest(db_vvedem,2,"db_vvedem.csv"). @fast(db_var,"db_var.csv"). @global_unique(PROCESS,infinity):- (()->{VAR}([--]+)?=>{db_vvedem($)}\s+((\s+\s+)?)->{KEYB} ([--]+)?=>{db_var($,$VAR)}\s+(\w+)->{ID}((\s+\s+)?)!=>{KEYB}\s*\.). @versions(Russian) handle:-xpath('PROCESS','//ID/text()',[VText]), xpath('PROCESS','//VAR/text()',['0']), simple_vector(_,VText,_), global_id(GID),assertz(simple_act(GID,in,VText,'')),!. handle:-xpath('PROCESS','//ID/text()',[SText]), xpath('PROCESS','//VAR/text()',['1']), global_id(GID),assertz(simple_act(GID,in,SText,'')),!. @versions(Programmatical) handle:-xpath('PROCESS','//VECTOR/text()',[VText]), xpath('PROCESS','//N/text()',[NText]), simple_vector(_,VText,NText), global_id(GID),assertz(simple_act(GID,in,VText,'')),!. handle:-xpath('PROCESS','//SCALAR/text()',[SText]), simple_scalar(_,SText), global_id(GID),assertz(simple_act(GID,in,SText,'')),!. @versions(Programmatical,Russian) @goal:- handle,!. @done:- clear_db. 

रूसी में एक समस्या बयान का एक उदाहरण:

  .   max.   min.   V  10 .   V  .    V      min.     V      max.   min  .   max  .   V  .      . 

और उपरोक्त प्राकृतिक-भाषा विवरण से प्रणाली द्वारा प्राप्त समस्या का मॉडल :

4. उलटा समस्या के अन्य अनुप्रयोग

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

एक संकलक द्वारा संसाधित कंप्यूटिंग सी कार्यक्रम का एक उदाहरण (उसने cilk_spawn और cilk_syncbives डाला):

 #include <stdio.h> #include <math.h> #include <omp.h> #define PI 3.14159265358 #define NX 100 #define NY 100 #define MaxT 0.001 #define h 0.01 #define tau 0.00001 #define cilk_spawn _Cilk_spawn #define cilk_sync _Cilk_sync void F( double x, double y, double t, double * val ){ double r = sqrt(x*x + y*y); double result = 0.0; int i; for ( i = 0; i < 300; i++ ) result += exp(-r*t)*sin(0.1*i*r + 0.5*PI); *val = result; } int main( ){ double f[NY][NX] = {0.0}; double v[NY][NX] = {0.0}; double v1[NY][NX] = {0.0}; double t; int x, y; double start = omp_get_wtime(); for ( t = 0.0; t < MaxT; t += tau ) { for ( y = 1; y < NY-1; y++ ) for ( x = 1; x < NX-1; x++ ) cilk_spawn F(x*h, y*h, t, &f[y][x]); for ( y = 1; y < NY-1; y++ ) for ( x = 1; x < NX-1; x++ ) { cilk_sync; v1[y][x] = v[y][x] + tau*((v[y-1][x]+v[y+1][x]+v[y][x-1]+v[y][x+1]-4.0*v[y][x])/h/h - f[y][x]); } for ( y = 1; y < NY-1; y++ ) for ( x = 1; x < NX-1; x++ ) v[y][x] = v1[y][x]; } for ( y = 0; y < NY; y++ ) { for ( x = 0; x < NX; x++ ) printf("%lf ", v[y][x]); printf("\n"); } printf("Total time = %lf\n", omp_get_wtime() - start); return 0; } 

5. एक काल्पनिक कथा। बंद स्रोत कोड के साथ मनमानी कार्यक्रमों का सत्यापन और पहचान

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

6. निष्कर्ष

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