🤟🏽 😹 🍆 स्काला नियम-आधारित इंजेक्शन इंजन 🚘 🖐🏼 👨🏽‍🔧

सभी को नमस्कार! मैं जनता को अपने ओपन फॉरवर्ड चेनिंग इंजन को फजी लॉजिक सपोर्ट के साथ काम करने वाले टाइटल स्काला इंट्रेंस इंजन (sie) ( कोड ) के तहत दिखाना चाहता हूं।

युपीडी।
पुस्तकालय केंद्रीय मावेन भंडार में पोस्ट किया गया है:

<dependency> <groupId>net.sf.brunneng.fusie</groupId> <artifactId>fusie</artifactId> </dependency>

इस इंजन का स्थान अपनी तरह का है

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

ड्रॉल्स - एक वयस्क, अच्छी तरह से कॉन्फ़िगर करने योग्य ओपन सोर्स इंजन फॉरवर्ड चेनिंग का उपयोग करना। नियमों को परिभाषित करने का सिंटैक्स यहाँ पाया जा सकता है ।

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

jColibry - जैसा कि मैं इसे समझता हूं, इस लाइब्रेरी को बड़ी संख्या में विकल्पों से इंटरैक्टिव डेटा पुनर्प्राप्ति के लिए डिज़ाइन किया गया है।

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

“नियम सिंटैक्स गणना की अनुमति नहीं देता है, अर्थात यदि ((a + b) m से अधिक है) तो x; या बाहरी वस्तुओं पर बाहरी कार्यक्रमों, लिपियों या तरीकों को निष्पादित करना। * दूसरे शब्दों में, ग्राहक को परामर्श सत्र से परिणामों के आधार पर किसी अन्य बाहरी वस्तु या स्क्रिप्ट को निष्पादित करना होगा। "

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

मंदारैक्स एक नियम संकलक है। नुकसान यह है कि यह स्थिर है - नियमों के प्रत्येक सेट को जावा कोड के रूप में संकलित किया जाना चाहिए, और यह गतिशील रूप से नहीं किया जा सकता है।

और अन्य ।

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

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

हत्यारा सुविधा

हम "अतिव्यापी नियमों की अवधारणा" का परिचय देते हैं। ये ऐसे नियम हैं जो समान चर के बारे में निष्कर्ष देते हैं। उदाहरण के लिए

 when a > 300 then b = 5 when a < 400 then b = 10

इस स्थिति में, यदि 'a' 300 और 400 के बीच मान लेता है, तो दोनों नियम पूरे होते हैं और सिस्टम को यह तय करना चाहिए कि आगे के आउटपुट के लिए कौन सा रास्ता जाना चाहिए, क्योंकि 'b' एक ही समय में 5 और 10 नहीं हो सकता है। आम तौर पर, बोलने के कई तरीके होते हैं। संघर्ष की स्थिति को कैसे हल करें:

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

ड्रोल में संघर्ष संकल्प रणनीतियाँ ।
वर्तमान कार्यान्वयन (और मैंने इस तरह से कभी नहीं देखा है) एक अलग तरह से जाता है।
4) मान लें कि दोनों नियम बराबर हैं और 0.5 संभावना है कि पहली पूरी हो गई है और 0.5 कि दूसरी (या सामान्य स्थिति में 1 / एन संभावना है, अगर एन ओवरलैपिंग नियम हैं)।
इसके अलावा, आउटपुट को भागों में विभाजित किया जाता है, और जब तक वांछित चर नहीं मिलता तब तक प्रत्येक शाखाओं के लिए अलग-अलग जारी रहता है। इसके बाद, आउटपुट की सभी शाखाओं के लिए वांछित चर के प्रत्येक संभावित मूल्य के लिए कुल संभावना पर विचार किया जाता है।

यह देखते हुए कि नियम पूर्ववर्ती स्थितियों में उपयोग किए जाने वाले चरों के लिए एक दूसरे पर निर्भर हो सकते हैं, कि निष्कर्ष में विभिन्न चर के लिए असाइनमेंट हो सकते हैं (ताकि नियमों के प्रतिच्छेद समूह संभव हों, जैसे कि X चौराहे वाई से चर के रूप में, Y चरों के साथ Y चौराहे Z ख) विचार का सरल मौखिक विवरण एक गैर-सरल कार्यान्वयन में बदल जाता है। मुख्य लक्ष्य जो प्राप्त किया गया है वह वांछित चर द्वारा लिए गए मूल्यों की संभावनाओं की सही गणना है।

इस प्रकार, इंजन संभवतः परस्पर विरोधी नियमों के आधार के साथ अच्छी तरह से मुकाबला करता है जो प्रतिच्छेद करते हैं:

अनजाने में, यदि नियम अलग-अलग विशेषज्ञों द्वारा तैयार किए गए थे और सभी की अपनी राय है।
जानबूझकर, यदि एक ही चर की गणना विभिन्न तरीकों से की जा सकती है, उदाहरण के लिए:
```
 when graphicCardType == "Top" then graphicCard = "Nvidia super card" when graphicCardType == "Top" then graphicCard = "Radeon super card" 
```
इस उदाहरण में, वीडियो कार्ड चयन सलाहकार Nvidia से एक कार्ड और Radeon से समान संभावना वाले कार्ड की सलाह दे सकता है।

इस तरह, आउटपुट में फ़ज़ी तत्व का समर्थन किया जाता है।

समस्या परिभाषा भाषा

समस्या परिभाषा संरचना:

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

समस्या पूरी तरह से प्रोग्रामेटिक रूप से निर्धारित की जा सकती है, लेकिन एक विशेष (गैर-xml) सिंटैक्स का उपयोग करके ऐसा करना अधिक सुविधाजनक है जिसे प्रोग्रामिंग अनुभव वाले व्यक्ति के लिए संक्षिप्त और तुरंत समझने के उद्देश्य से विकसित किया गया था।

उदाहरण 1: वित्तीय सलाहकार

 int amountSaved <- "How many savings you have?" int earnings <- "What is you year income?" bool steady <- "Your year income is stable?" int dependents = min: 0 <- "How many dependents you have?" when true then minincome = 15000 + (4000 * dependents) when true then minsavings = 5000 * dependents when savingsAccount == "inadequate" then investment = "savings" when (savingsAccount == "adequate") && (income == "adequate") then investment = "stocks" when savingsAccount == "adequate" income == "inadequate" then investment = "combination" when amountSaved > minsavings then savingsAccount = "adequate" when amountSaved <= minsavings then savingsAccount = "inadequate" when steady earnings > minincome then income = "adequate" when steady earnings <= minincome then income = "inadequate" when !steady then income = "inadequate" find investment

पहले चर परिभाषा ब्लॉक आता है:

 int amountSaved <- "How many savings you have?" int earnings <- "What is you year income?" bool steady <- "Your year income is stable?" int dependents = min: 0 <- "How many dependents you have?"

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

पूर्वधारणाओं और निष्कर्षों में, किसी भी जटिलता के भावों का उपयोग किया जा सकता है (उदाहरण में सबसे मुश्किल है minincome = 15000 + (4000 * dependents)) , लेकिन यह सीमा से बहुत दूर है)
अंकगणित संचालन के शब्दार्थ जावा में समान हैं। जहाँ आवश्यकता हो वहां इंट टू डबल के निहित रूपांतरणों का समर्थन किया जाता है। डिफ़ॉल्ट रूप से, java.lang.Math से फ़ंक्शन कॉल समर्थित हैं, लेकिन आप अपने कार्यों को भी पंजीकृत कर सकते हैं।

नियम देखें

 when true then minsavings = 5000 * dependents

तथ्य को निर्धारित करता है, क्योंकि उनकी प्रस्तावना हमेशा पूरी होती है।

रिकॉर्डिंग

 when (savingsAccount == "adequate") && (income == "adequate") then investment = "stocks"  when savingsAccount == "adequate" income == "adequate" then investment = "stocks"

समतुल्य के रूप में पूर्व शर्त में लाइनों के बीच, && (और) ऑपरेशन निहित है।

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

पार्सर विशेषताएं:

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

पार्सर को scala.util.parsing.JavaTokenParsers से वारिस के रूप में लागू किया गया था।
मैं केवल यह कह सकता हूं कि यह लिखना एक खुशी की बात थी, इस तथ्य के बावजूद कि इससे पहले मुझे लिखने का अनुभव मामूली से अधिक है। इस उपकरण की शक्ति इस तथ्य में निहित है कि आप पार्स करने के लिए पैटर्न सेट कर सकते हैं और तुरंत संस्थाओं को परिणाम मैप कर सकते हैं।

परीक्षण

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

उदाहरण

com.greentea.sie.examples में कई कक्षाएं हैं जो कुछ अलग-अलग विषय क्षेत्रों के लिए नियम परिभाषाओं के जीवंत उदाहरणों के साथ हैं: FinancialAdviser, ProgrammingLanguageAdviser, LoanarAdviser ।

आगे की दिशा

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

स्काला नियम-आधारित इंजेक्शन इंजन