क्लोजर डीएजी (बेयसियन नेटवर्क)

Question

मैं क्लोजर में बेयसियन नेटवर्क बनाना चाहता हूं, क्योंकि मुझे कोई भी इसी तरह की परियोजना नहीं मिली है।

मैंने बीएन के बहुत सारे सिद्धांत का अध्ययन किया है लेकिन फिर भी मैं नहीं देख सकता कि नेटवर्क को कैसे कार्यान्वित किया जाता है (मैं नहीं हूं कि लोग कुछ भी के लिए "गुरु" कहते हैं, लेकिन विशेष रूप से कार्यात्मक प्रोग्रामिंग के लिए नहीं)।

मुझे पता है कि एक बी एन (प्रत्येक नोड के लिए एक) एक DAG से ज्यादा कुछ नहीं है और एक बहुत संभावना तालिका है लेकिन अब मैं कोई गोंद कैसे DAG को लागू करने की है। (: कुंजी शायद एक) एक संभावना तालिका का एक वेक्टर (एक और नक्शा?)

मेरा पहला विचार कुछ थोड़ा नक्शे के साथ एक विशाल सेट (DAG) (DAG के नोड), हर कोई नाम होना चाहिए था माता-पिता और आखिरकार गैर-वेसेंडेंट का वेक्टर।

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

मैं सोच रहा था कि एक वेक्टर के बजाय मैं और अधिक सेट का उपयोग कर सकता है, इस तरह से तेजी से किया जाएगा एक नोड के वंशज हैं।

संभावना तालिका जहां मैं अभी भी अन्य नोड्स पर कुछ संदर्भ की आवश्यकता के लिए इसी तरह की समस्या।

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

क्या मुझे उत्परिवर्तनीय प्रकारों का उपयोग करना चाहिए या वे केवल जटिलता में वृद्धि करेंगे?

Answer 1

आप यहां तक ​​कि चापलूसी करने की कोशिश कर सकते हैं और नोड आईडी द्वारा अनुक्रमित कई मानचित्र हैं: संभावनाओं के लिए एक मानचित्र, माता-पिता के लिए एक और गैर-वंश के लिए एक (मैं कोई बीएन विशेषज्ञ नहीं हूं: यह क्या है, इसका उपयोग कैसे किया जाता है इत्यादि? ऐसा कुछ ऐसा लगता है जिसे माता-पिता तालिका^डब्ल्यू रिलेशन^डब्ल्यू मैप से पुनः संयोजित किया जा सकता है)।

Answer 2

यह एक पूरा जवाब नहीं है, लेकिन यहां wikipedia article से उदाहरण नेटवर्क के लिए एक संभावित एन्कोडिंग है। प्रत्येक नोड एक नाम, उत्तराधिकारियों (बच्चों) की एक सूची है और एक संभावना टेबल है:

(defn node [name children fn] 
    {:name name :children children :table fn}) 

इसके अलावा, यहां सही/गलत संभावनाओं के निर्माण के लिए थोड़ा सहायक कार्य हैं:

;; builds a true/false probability map 
(defn tf [true-prob] #(if % true-prob (- 1.0 true-prob))) 

ऊपर समारोह रिटर्न एक बंद, जिसे, true मान (resp। false मान) दिया गया है, घटना X=true (X संभाव्यता चर के लिए हम एन्कोडिंग कर रहे हैं) की संभावना देता है।

के बाद से नेटवर्क एक DAG है, हम संदर्भ एक दूसरे से सीधे वृत्तीय संदर्भ के बारे में परवाह किए बिना (वास्तव में संकेत आप का उल्लेख की तरह) नोड कर सकते हैं।

(let [gw (node "grass wet" [] (fn [& {:keys [sprinkler rain]}] 
          (tf (cond (and sprinkler rain) 0.99 
             sprinkler 0.9 
             rain 0.8 
             :else 0.0)))) 

    sk (node "sprinkler" [gw] 
      (fn [& {:keys [rain]}] (tf (if rain 0.01 0.4)))) 

    rn (node "rain" [sk gw] 
      (constantly (tf 0.2)))] 

    (def dag {:nodes {:grass-wet gw :sprinkler sk :rain rn} 
     :joint (fn [g s r] 
       (* 
        (((:table gw) :sprinkler s :rain r) g) 
        (((:table sk) :rain r) s) 
        (((:table rn)) r)))})) 

प्रत्येक नोड की संभावना तालिका माता पिता नोड्स के राज्यों के एक समारोह के रूप में दिया जाता है और true और false मूल्यों के लिए संभावना देता है: हम सिर्फ संस्थानिक क्रम में ग्राफ का निर्माण।उदाहरण के लिए,

((:table (:grass-wet dag)) :sprinkler true :rain false) 

... {:true 0.9, :false 0.09999999999999998} देता है।

P(G,S,R) = P(G|S,R).P(S|R).P(R) 

और ((:joint dag) true true true) रिटर्न .0019800000000000004:

जिसके परिणामस्वरूप संयुक्त समारोह इस सूत्र के अनुसार संभावनाओं को जोड़ती है। दरअसल, ((:table <x>) <args>) द्वारा लौटाए गए प्रत्येक मान एक if के चारों ओर एक बंद है, जो संभावना रिटर्न संभावना चर के राज्य जानते हुए भी है। हम संबंधित true/false से प्रत्येक का मान बंद फोन उचित संभावना निकालने, और उन्हें गुणा करने के लिए।

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

Answer 3

सामान्य में, जिस तरह से एक बी एन के संयुक्त वितरण की गणना करने के

prod(P(node | parents of node)) 

इस हासिल करने के लिए, आप जहां प्रत्येक नोड

• नोड नाम
• शामिल नोड्स की एक सूची की जरूरत है माता-पिता की सूची
• संभाव्यता तालिका
• बच्चों की सूची

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

नोड्स केवल एक पंक्ति है।

प्रत्येक पंक्ति के बाद जो पी (नोड | माता-पिता) सामान्यीकृत किया जाना चाहिए = तालिका [पंक्ति, स्तंभ]

आप वास्तव में बच्चों की सूची की जरूरत नहीं है, लेकिन यह आसान छँटाई संस्थानिक बना सकता है। एक डीएजी स्थलीय रूप से क्रमबद्ध होने में सक्षम होना चाहिए।

सबसे बड़ी समस्या यह संभावना तालिका में कोशिकाओं की संख्या के रूप में पैदा होती है माता-पिता और स्वयं के आयामों के सभी का उत्पाद है। मैंने पंक्ति मैपिंग का उपयोग करके एक स्पैस टेबल का उपयोग करके इसे C++ में संभाला।

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

मुझे एहसास है कि आप विशेष रूप से कार्यान्वयन की तलाश में हैं, लेकिन थोड़ा काम करके, आप अपना खुद का रोल कर सकते हैं।