कोई हजारों IF… THEN… ELSE नियम कैसे प्रबंधित कर सकता है?


214

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

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

मैंने नियम इंजनों के बारे में थोड़ा पढ़ा है, लेकिन मुझे नहीं लगता कि वे इस जटिलता के आसपास कैसे पहुंचेंगे।


22
आपको DSL प्रोग्रामिंग पर एक नज़र डालने की आवश्यकता है: en.wikipedia.org/wiki/Domain-specific_language आगे आप संभवतः कुछ डेटा संचालित मेटा नियम इंजन भी बना सकते हैं। उदाहरण के लिए, आप डेटा से मॉडल तैयार कर सकते हैं (उदाहरण के लिए डेटा-खनन केडीडी)
डार्कनाइट

14
"विशेषज्ञ प्रणाली" और "रीट नेट" के लिए Google; सौभाग्य।
स्टीवन ए। लोव

9
हार्ड कोडित को स्थानांतरित करें यदि / फिर स्रोत कोड से बाहरी डेटा में स्टेटमेंट निकलता है जो सिमुलेशन को ड्राइव करता है।
कुवेबल

6
मैं एक टेक्स्ट फ़ाइल में कुछ मानों को बाँधूँगा और एक हैशपॉप के नाम से जाने के लिए एक लूप का उपयोग करूँगा।
जेम्स पी।

2
डेविड - 15 से अधिक उत्तर पोस्ट किए जाने पर प्रोग्रामर के प्रश्नों को सीडब्ल्यू में बदल दिया जाता है। हम यह नियंत्रित नहीं कर सकते कि 16 वीं उत्तर पोस्ट कौन करे।
ChrisF

जवाबों:


73

तर्क प्रोग्रामिंग भाषा प्रोलॉग वह हो सकता है जिसे आप खोज रहे हैं। आपका समस्या कथन मेरे लिए यह आकलन करने के लिए पर्याप्त विशिष्ट नहीं है कि क्या यह एक अच्छा फिट है, बल्कि यह आपके कहने के समान है।

एक प्रोलॉग कार्यक्रम में तथ्यों और नियमों को लागू किया जाता है। यहाँ एक सरल उदाहरण नियम है जिसमें कहा गया है कि "एक गाय किसी स्थान पर जाती है अगर गाय भूखी है और पुराने स्थान की तुलना में नए स्थान पर अधिक भोजन है":

moves_to(Cow, Location) :-
  hungry(Cow),
  current_location(Cow, OldLoc),
  food_in(OldLoc, OldFood), food_in(Location, NewFood),
  NewFood > OldFood.

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

नियमों के अलावा, तथ्यों का एक डेटाबेस प्रदान किया जाता है। एक सरल उदाहरण जो उपरोक्त नियमों के साथ काम करता है, वह कुछ इस तरह हो सकता है:

current_location(white_cow, pasture).

current_location(black_cow, barn).
hungry(black_cow).

current_location(angry_bull, forest).
hungry(angry_bull).

food_in(barn, 3).
food_in(pasture, 5).
food_in(forest, 1).

ध्यान दें कि श्वेतपत्रिका में श्वेतपत्रिकाएँ और चरागाह आदि नहीं लिखे गए हैं। वे चर नहीं हैं, वे परमाणु हैं।

अंत में आप एक प्रश्न करें और पूछें कि क्या होने वाला है।

?- moves_to(white_cow, Destination).
No.
?- moves_to(black_cow, Destination).
Destination = pasture
?- moves_to(Cow, Destination).
Cow = black_cow, Destination = pasture
Cow = angry_bull, Destination = barn
Cow = angry_bull, Destination = pasture

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

दूसरी क्वेरी पूछती है कि काली गाय कहां चलती है। यह खाने के लिए चारागाह में चला जाता है।

अंतिम प्रश्न पूछता है कि सभी गाय कहां चलती हैं। परिणामस्वरूप आप सभी संभव (गाय, गंतव्य) प्राप्त करते हैं जो समझ में आता है। इस मामले में काला बैल उम्मीद के मुताबिक चारागाह में चला जाता है। हालांकि, गुस्से में बैल के पास दो विकल्प हैं जो नियमों को पूरा करते हैं, यह या तो चारागाह या खलिहान में जा सकता है।

नोट: जब मैंने पिछली बार प्रोलॉग लिखा था, तब से यह वर्ष है, सभी उदाहरण वाक्यगत रूप से मान्य नहीं हो सकते हैं लेकिन विचार सही होना चाहिए।


10
-1: मुझे नहीं लगता कि प्रोलॉग कभी सही उत्तर हो सकता है। हां, प्रोलॉग में अगर-और नियम मिलते हैं तो यह आसान हो सकता है। लेकिन निश्चित रूप से आपको कुछ और करना होगा। और कोई फर्क नहीं पड़ता कि यह क्या है (आईओ; जीयूआई, वेब विकास, ...) यह प्रोलॉग के साथ एक दर्द होगा।
मार्टिन थोमा

4
बाहर की जाँच करें learnprolognow.com और दूसरी भाषा के अंदर प्रोलॉगिंग एम्बेड करना बहुत आसान है जितना कि इसका इस्तेमाल किया जा सकता है
Zachary K

@ZacharyK: लिंक टूट गया है।
RenniePet

@MartinThoma: क्या आप अपनी टिप्पणी समझा सकते हैं? Prolog IMHO के साथ मुख्य समस्याएं हैं 1. खोज को नियंत्रित करने का एक घोषणात्मक तरीका और 2. टाइपिंग। लेकिन अगर आपका आवेदन इन दोनों पर बहुत अधिक निर्भर नहीं करता है, तो मैं यहाँ एक प्राथमिकता को प्रॉब्लम का उपयोग करने में कोई समस्या नहीं देखता हूँ
एसएन

139

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

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

यदि आप अपने मॉडल को तोड़ते रहते हैं तो आप अंततः इस संयोजन प्रभाव को पूरी तरह से भंग कर देंगे। हालाँकि इस रास्ते को लेते समय अपने डिजाइन में खो जाना आसान होता है और इससे भी बड़ी गड़बड़ पैदा होती है, यहाँ पूर्णतावाद जरूरी नहीं कि आपका दोस्त ही हो।

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

इसे अपने डोमेन पर लागू करने का उदाहरण।

आप मॉडल बनाने की कोशिश कर रहे हैं कि गाय एक इलाके के माध्यम से कैसे आगे बढ़ रही हैं। हालाँकि, आपके प्रश्न में विवरण का अभाव है, मुझे लगता है कि आपकी बड़ी मात्रा में निर्णय के टुकड़े शामिल हैं, if cow.isStanding then cow.canRun = trueलेकिन जैसे ही आप उदाहरण के लिए इलाके का विवरण जोड़ते हैं। तो हर क्रिया के लिए आपको अपने हर पहलुओं की जाँच करनी होगी जो आप सोच सकते हैं और अगली क्रिया के लिए इन सत्यापनों को दोहरा सकते हैं।

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

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

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

क्योंकि मैं FSM के लिए समान कोड का पुनः उपयोग कर रहा हूं, यह मूल रूप से FSM का एक विन्यास है। याद है जब हमने DSL के पहले का उल्लेख किया था? यह वह जगह है जहाँ DSL बहुत अच्छा कर सकता है यदि आपके पास लिखने के लिए बहुत सारे नियम और बदलाव हैं।

गहराई तक जा रहे हैं

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

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

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

आप पोषक तत्वों के स्तर और घास के विकास चक्र को मॉडलिंग करके अभी भी गहरा धक्का दे सकते हैं, आपने अनुमान लगाया है ... इलाके के पैच मॉडल में एक घास FSM एम्बेडेड है।

यदि आप इस विचार को बहुत दूर तक धकेल देते हैं कि GOD के पास बहुत कम काम है क्योंकि सभी पहलू बहुत अधिक स्व प्रबंधित हैं, अधिक ईश्वरीय चीजों पर खर्च करने के लिए समय को मुक्त करते हैं।

संक्षिप्त

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

मैं एक कोड उदाहरण प्रदान करूंगा, लेकिन यह सब मैं अभी कर सकता हूं।


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

-1 मैं यह नहीं देखता कि इसे केवल निर्णय वृक्ष के माध्यम से हल क्यों नहीं किया जा सकता है? (एक DSL के साथ युग्मित जो मॉडल लेता है और इसे रन करने योग्य कोड में बदल देता है)?
डार्क नाइट

14
भगवान बनाम FSM?
जॉन क्रॉमार्टी

1
निर्णय पेड़ों और नियम इंजनों का उपयोग ठीक-ठाक मामलों में किया जाता है, जहां हाथों पर पहलुओं को मॉडलिंग करने के लिए कोई आंतरिक मूल्य नहीं है क्योंकि वे गणना के अंत तक केवल एक साधन हैं। आप इसे हर समय हेल्थकेयर सॉफ्टवेयर में देखते हैं। कहा जा रहा है कि यदि आप वास्तविक व्यवहार की कोशिश कर रहे हैं तो आपको ऐसा करने की कोशिश करनी चाहिए। ऐसे मामलों के टन हैं जहां एक समस्या में पाया जाने वाला एकमात्र तर्क हजारों का परिणाम है अगर यह तब है कि विज्ञापन infinitum। और इसकी वैध, यही वजह है कि हमारे पास इससे निपटने के लिए उपकरण हैं।
Delete_user

1
यह गेम प्रोग्रामिंग की दुनिया में बहुत सफल साबित हुआ है; किसी नियम या संपत्ति को बदलने के लिए यह बहुत तेज़ और आसान है और व्यवहार को उभरने दें, फिर उस पर कार्य करने के तरीके का निर्णय करने के लिए एक मूल्य की जांच करें।
बेन लेगिएरो

89

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

आपकी समस्या की प्रकृति के आधार पर, वास्तविक दुनिया को मॉडल करने के कई अलग-अलग तरीके हैं। आपकी विभिन्न स्थितियाँ नियम या अड़चन बन सकती हैं जो अनुकरण पर लागू होती हैं। कोड के बजाय जो दिखता है:

if (sunLevel > 0.75) {
   foreach(cow in cows) {
       cow.desireForShade += 0.5;
   }
}
if (precipitation > 0.2) {
   foreach(cow in cows) {
       cow.desireForShelter += 0.8;
   }
}

इसके बजाय आपके पास ऐसा कोड हो सकता है जो दिखता है:

foreach(rule in rules) {
   foreach (cow in cows) {
      cow.apply(rule);
   }
}

या, यदि आप एक रेखीय कार्यक्रम विकसित कर सकते हैं जो गाय व्यवहार को मॉडल देता है तो कई इनपुट दिए जाते हैं, प्रत्येक बाधा समीकरणों की प्रणाली में एक पंक्ति बन सकती है। फिर आप उस मार्कोव मॉडल में बदल सकते हैं जिसे आप पुन: व्यवस्थित कर सकते हैं।

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


4
कृपया वर्णन करें कि कैसे "काउ.प्पली (नियम);" विन्यास फाइल के साथ काम करता है?
क्रॉस्टर

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

2
@ क्रॉम - सरल। आप नियम को पढ़ेंगे और फिर उसे दी गई गाय पर लागू करेंगे।
रामहाउंड

5
फ़ाइलों को कॉन्फ़िगर करने के लिए मूविंग कोड हमेशा एक अच्छा तरीका नहीं होता है। मैजिक डिबग करना कठिन है।
रिकी क्लार्कसन

44

किसी ने भी इसका उल्लेख नहीं किया है, इसलिए मैंने सोचा कि मैं इसे स्पष्ट रूप से कहूंगा:

"इफ .. तब .. एल्स" नियमों के हजारों एक बुरी तरह से डिज़ाइन किए गए एप्लिकेशन का संकेत है।

हालांकि डोमेन विशिष्ट डेटा प्रतिनिधित्व इन नियमों की तरह लग सकता है, क्या आप पूरी तरह से निश्चित हैं कि आपका कार्यान्वयन डोमेन विशिष्ट प्रतिनिधित्व जैसा होना चाहिए?


18
जरूरी नहीं कि सच हो। ऐसी समस्याएं हैं जो केवल विशाल निर्णय पेड़ों के माध्यम से हल की जा सकती हैं। लेकिन निश्चित रूप से अगर-तब-तब के शाब्दिक पेड़ से बना एक समाधान एक बुरी तरह से डिजाइन किया गया है। ऐसा करने के कहीं अधिक लचीले और बनाए रखने योग्य तरीके मौजूद हैं।
एसएफ।

43
मुझे लगा कि सवाल का बिंदु था। ओपी के पास अपने डोमेन के लिए एक समस्या है जो एक निष्कपट कार्यान्वयन में, हजारों की आवश्यकता होगी ... तब ... और। उन्हें एक अंतर्ज्ञान था कि यह परेशान करने वाला था और ऐसा करने के बेहतर तरीकों के बारे में यहां समुदाय से पूछताछ की। सवाल पूछा गया एक मात्र अच्छा गाना है कि यह पहले से ही समझ में आ गया था, आपका जवाब, हालांकि सही है, किसी भी तरह से प्रश्न की मदद नहीं करता है।
1

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

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

17

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

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


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

13

नियम इंजन मदद कर सकते हैं क्योंकि यदि बहुत सारे हैं तो / यदि नियम हैं तो उन सभी को कार्यक्रम के बाहर एक जगह पर लाना मददगार हो सकता है जहाँ उपयोगकर्ता प्रोग्रामिंग भाषा जानने की आवश्यकता के बिना उन्हें संपादित कर सकते हैं। इसके अलावा, विज़ुअलाइज़ेशन उपकरण उपलब्ध हो सकते हैं।

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


11

यह अचानक मुझ पर हावी हो गया है:

आपको एक डिसिजन लर्निंग ट्री (ID3 एलगोरिदम) का उपयोग करने की आवश्यकता है ।

इसकी अत्यधिक संभावना है कि किसी ने इसे आपकी भाषा में लागू किया हो। यदि आप मौजूदा लाइब्रेरी को पोर्ट नहीं कर सकते हैं


ऊपर दिए गए DSL विचार के साथ जाएं। एक प्रतीकात्मक बीजगणित के किसी न किसी रूप में समस्या को कैसे अमूर्त करें, यह जानने की कोशिश करें, फिर उस पर अमल करें।
Zachary K

11

यह एक समुदाय विकी उत्तर से अधिक है, अन्य उत्तरों द्वारा सुझाए गए विभिन्न मॉडलिंग टूलों को एकत्र करना, मैंने अभी संसाधनों के अतिरिक्त लिंक जोड़े हैं।

मुझे नहीं लगता कि आराम करने की कोई आवश्यकता है कि आपको हजारों हार्ड-कोडेड के लिए एक अलग दृष्टिकोण का उपयोग करना चाहिए अगर / और कथन।


9

प्रत्येक बड़े अनुप्रयोग में हजारों if-then-elseकथन होते हैं, अन्य प्रवाह नियंत्रणों की गिनती नहीं करते हैं, और उन अनुप्रयोगों को उनकी जटिलता के बावजूद भी डिबग और बनाए रखा जाता है।

साथ ही, कथनों की संख्या प्रवाह को अप्रत्याशित नहीं बनाती है । अतुल्यकालिक प्रोग्रामिंग करता है। यदि आप नियतकालिक एल्गोरिदम का उपयोग करते हैं, तो आपके पास हर बार एक 100% अनुमानित व्यवहार होगा।

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


1
अधिकांश ऐप्स में 2-3 स्तर के नेस्टिंग और 1-लाइन स्थितियां होती हैं। उस समस्या के बारे में जो निर्णय लेने के लिए 50 स्तर नीचे घोंसले के पेड़ की आवश्यकता होती है, और कई स्थितियों में प्रत्येक के 30 या अधिक चर के तार्किक यौगिक होते हैं?
एसएफ।

जबकि "हर बड़ा अनुप्रयोग ..." निश्चित रूप से सच है, यह बहुत स्पष्ट है कि ओपी सशर्त अभिव्यक्तियों के लंबे अनुक्रमों के बारे में बात कर रहा है जो अनिवार्य रूप से एक मॉडल में नियम बनाते हैं। ifबयानों के विशाल नेस्टेड समूह जल्दी से सबसे अच्छे हो जाते हैं, इसलिए बेहतर दृष्टिकोण की आवश्यकता होती है।
कालेब

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

2

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


2

अपनी समस्या से बाहर निकलने के लिए अपने तरीके को डिजाइन करने का एक ही तरीका नहीं होगा, लेकिन अगर आप अलग-अलग क्षेत्रों को अलग करने की कोशिश करते हैं तो आप अपने आप को अलग-अलग क्षेत्रों से अलग करने की कोशिश कर सकते हैं जहां आप अपने बयानों के बड़े ब्लॉक लिखते हैं और समाधान लागू करते हैं। उन छोटी समस्याओं में से प्रत्येक के लिए।

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

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

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


2

मेरा सुझाव है कि आप एक नियम इंजन का उपयोग करें। जावा के मामले में, jBPM या Oracle BPM उपयोगी हो सकता है। नियम इंजन मूल रूप से आपको XML के माध्यम से एप्लिकेशन को कॉन्फ़िगर करने की अनुमति देते हैं।


+1 मैं नियमों को व्यक्त करने के लिए भाषा के रूप में मवेल के साथ-साथ ड्रोल का हाल ही में उपयोग कर रहा हूं, और यह वही है जो आप देख रहे हैं। इस तथ्य के बावजूद कि यह बहुत तेज़ है।
जलयन्

ड्रोल एक अच्छा विकल्प है। मैं व्यक्तिगत रूप से अभी Oracle BPM का उपयोग कर रहा हूँ। वहाँ भी Feugo है। उपलब्ध स्रोत और स्वामित्व के बहुत सारे उपकरण।
सिड

2

समस्या "नियमों" से अच्छी तरह से हल नहीं हुई है, चाहे "अगर-तब" प्रक्रियात्मक कोड द्वारा वर्णित हो या व्यावसायिक अनुप्रयोगों के लिए तैयार किए गए कई नियमों के समाधान। मशीन लर्निंग ऐसे परिदृश्यों की मॉडलिंग के लिए कई तंत्र प्रदान करता है।

मूल रूप से, किसी को "सिस्टम" (यानी, एक चरागाह में गायों) को प्रभावित करने वाले कारकों (जैसे, सूरज, हवा, भोजन के स्रोत, अचानक घटनाओं आदि) के अवरोही प्रतिनिधित्व के लिए कुछ योजना तैयार करनी होती है। इस गलत धारणा के बावजूद कि कोई वास्तविक मूल्यवान कार्यात्मक प्रतिनिधित्व बना सकता है, असतत के विपरीत, वास्तविक दुनिया में कोई भी कंप्यूटर (मानव तंत्रिका तंत्र सहित) वास्तविक मूल्य आधारित नहीं है या वास्तविक मूल्यों के आधार पर गणना करता है।

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

एक सेलुलर स्वचालित मॉडल निष्पादित करने के लिए अच्छी तरह से काम करता है। वास्तविक मूल्यवान गणित की दुनिया में गाय के पालन के लिए प्रेरित गणित एक क्षेत्र ढाल वाला मॉडल है। कथित कम उपयोगिता मूल्य के पदों से गायों को कथित उच्च उपयोगिता मूल्य के पदों पर ले जाया जाता है।

यदि कोई सिस्टम में पर्यावरण परिवर्तन को इंजेक्ट करता है तो यह गाय की स्थिति के स्थिर समाधान तक नहीं जाएगा। यह एक मॉडल भी बन जाएगा, जिसमें गेम थ्योरी के पहलुओं को लागू किया जा सकता है; ऐसा नहीं है कि इस मामले में बहुत जरूरी होगा।

यहाँ लाभ वध गायों का है या नई गायों को प्राप्त करने के लिए आसानी से प्रबंधित किया जा सकता है और "गाय" कोशिकाओं को द्विदलीय ग्राफ में जोड़कर, जबकि मॉडल चल रहा है।


1

मुझे नहीं लगता कि आपको कई और-और कथनों को परिभाषित करना चाहिए। मेरी दृष्टि से आपकी समस्या के कई घटक हैं:

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

  • निर्णय वृक्ष का विन्यास लगातार बदलता रहता है। यह वास्तविक गाय की स्थिति, मौसम, समय, इलाके आदि पर निर्भर करता है ... एक जटिल इफ-ट्री बनाने के बजाय, मुझे लगता है कि हमें समस्या को एक पवन गुलाब या एक दिशा में कम करना चाहिए - वजन कार्य : आकृति 1 आंकड़ा 1 - दिशा - कुछ नियमों के लिए वजन कार्य करता है

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

  • यह करने के लिए आपको एक तंत्रिका नेटवर्क की आवश्यकता नहीं है, प्रत्येक नियम के लिए सिर्फ एक वर्ग, गायों के लिए एक वर्ग, शायद इलाके के लिए, आदि ... और परिदृश्य के लिए एक वर्ग (उदाहरण के लिए 3 गायों के लिए अलग नियम और 1 विशिष्ट भूभाग)। चित्र 2 चित्रा 2 - गाय एप्लिकेशन async निर्णय नोड्स और कनेक्शन

    • संदेश दिशा के लिए लाल - नियमों के माध्यम से वजन मानचित्र
    • निर्णय लेने के बाद अभिविन्यास और स्थिति अपडेट के लिए नीला
    • अभिविन्यास और स्थिति अद्यतन के बाद इनपुट अपडेट के लिए हरा
    • इनपुट पाने के लिए काला

    नोट: आपको शायद इस तरह से कुछ लागू करने के लिए एक मैसेजिंग फ्रेमवर्क की आवश्यकता होगी

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


0

मुझे लगता है कि यह मामला हो सकता है कि अगर आप वास्तव में हजारों IF के हैं ... तो आप नियमों की देखरेख कर सकते हैं। इसके लायक क्या है, तंत्रिका नेटवर्क मॉडलिंग वार्ता मैंने अक्सर "नियमों के एक साधारण सेट" के साथ शुरू करने के साथ शुरू की है वे काफी जटिल और यथोचित वास्तविकता-मिलान व्यवहार (उन मामलों में, कार्रवाई में वास्तविक न्यूरॉन्स) उत्पन्न कर सकते हैं। तो, क्या आप सुनिश्चित हैंआपको हजारों स्थितियों की आवश्यकता है? मेरा मतलब है, मौसम के 4-5 पहलुओं के अलावा, खाद्य स्रोतों का स्थान, अचानक होने वाली घटनाएं, हेरिंग और इलाके, क्या आप वास्तव में कई और चर रखने जा रहे हैं? निश्चित रूप से, यदि आपने उन स्थितियों के संयोजन के सभी संभव क्रमांकन करने की कोशिश की, तो आप आसानी से कई हजारों नियम बना सकते हैं, लेकिन यह सही दृष्टिकोण नहीं है। हो सकता है कि एक फजी लॉजिक शैली का दृष्टिकोण जिसमें विभिन्न कारक प्रत्येक गाय के स्थान पर एक पूर्वाग्रह का परिचय देते हैं जो एक समग्र निर्णय के लिए गठबंधन करते हैं, आपको बहुत कम नियमों में ऐसा करने की अनुमति देगा।

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


0

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

कई चिकित्सा प्रणाली पहले से ही इन इंजनों का उपयोग करती हैं, उदाहरण के लिए यूके की एनएचएस डायरेक्ट वेबसाइट

यदि आप एक .NET हैं। तो Infer.NET आपके लिए उपयोगी हो सकता है।


0

गाय की गति को देखने के बाद से, वे 360 डिग्री दिशा में फंस गए हैं (गाय उड़ नहीं सकती।) आपके पास एक दर भी है जो आपकी यात्रा पर है। इसे वेक्टर के रूप में परिभाषित किया जा सकता है।

अब आप सूर्य की स्थिति, पहाड़ी की ढलान, शोरगुल जैसी चीजों से कैसे निपटते हैं?

प्रत्येक डिग्री एक चर होगा जो उस दिशा में जाने की इच्छा को दर्शाता है। 90 डिग्री पर गाय के दाईं ओर एक टहनी को दबाएं (गाय का चेहरा 0 डिग्री है)। दाईं ओर जाने की इच्छा कम हो जाएगी और 270 (बाएं) जाने की इच्छा बढ़ जाएगी। एक दिशा में जाने की इच्छा रखने वाली गायों पर उनके प्रभाव को जोड़ने या घटाने वाले सभी उत्तेजनाओं से गुजरें। एक बार सभी उत्तेजनाओं को लागू करने के बाद, गाय उच्चतम इच्छा की दिशा में जाएगी।

आप ग्रेडिएंट भी लगा सकते हैं ताकि उत्तेजनाओं को द्विआधारी न होना पड़े। उदाहरण के लिए एक पहाड़ी सीधे एक दिशा में नहीं है। हो सकता है कि गाय एक घाटी में हो या पहाड़ी पर एक सड़क पर उसके फ्लैट सीधे आगे थे, 45 * मामूली पहाड़ी पर 90 * मामूली पहाड़ी पर। 180 * पर पहाड़ी तक खड़ी है।

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

बल्कि यह कहना कि गाय किसी भी 360 दिशा में जाएगी, बस 36 दिशाओं में उसे तोड़ सकती है। प्रत्येक 10 डिग्री से

बल्कि यह कहना कि गाय किसी भी 360 दिशा में जाएगी, बस 36 दिशाओं में उसे तोड़ सकती है। प्रत्येक 10 डिग्री से। निर्भर करता है कि आपको कितना विशिष्ट होना चाहिए।


-2

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

मदद करने के लिए एक प्रोग्रामर प्राप्त करें।

class COW_METHODS {

    Function = array('Action1','Action2',....'ActionX');

    function doAction() {
       execute(Function[random(1,5000]);
    }

    function execute(DynamicFunction) {
        exec(DynamicFunction());
    }

    Function Action1() {
        turnRight();
        eatGrass();
    }
    /*  keep adding functions for COW Methods ...  etc  */
    /*  and add classes for conditions inherit them as needed  */
    /*  keep an object to define conditions =  Singleton etc.  */
}

यह आखिरी जवाब क्यों है। यह उस बिंदु पर पहुंच जाता है, जो यह है कि हजारों अन्य विवरणों को बस अब एक कार्यक्रम डिजाइन करने का तरीका है।
wfbarksdale

1
क्योंकि " OOP का उपयोग करें। एक प्रोग्रामर की मदद करें। " सलाह देने के लायक है "सलाह अधिक फोन कॉल करें " के समान है। जब उनसे पूछा गया कि " मैं अपनी बिक्री को कैसे चौगुना कर सकता हूं? "। यह कड़ाई से गलत नहीं है, लेकिन यह बहुत मदद नहीं करता है।
जेएनएसजी

2
मैंने नीचा दिखाया, क्योंकि यह एक बुरा जवाब है। तकनीकी तौर पर, आपके जवाब का OOP से कोई लेना-देना नहीं है। एक वर्ग जिसे COW_METHODSशिथिल संबंधित विधियों के संग्रह से ज्यादा कुछ नहीं लगता है। चिंताओं का पृथक्करण कहां है? प्रश्न से संबंधित, यह पूछने वाले की मदद कैसे करता है?
19
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.