विश्वास प्रचार कार्यान्वयन

Question

मैं Bayesian नेटवर्क को लागू करने की कोशिश कर रहा हूं।

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

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

मैंने पूछा कि इस तरह के फ़ंक्शन को कैसे कार्यान्वित करें here।

मैं जानना चाहता हूं कि ऐसी चीज करने का कोई बेहतर तरीका है या मैं जितना करना चाहता हूं उससे कहीं अधिक सरल और तेज़ दृष्टिकोण हैं।

Answer 1

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

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

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

इन सभी को नीचे दिखाया गया है।

def f1(map1): 

    # set to contain seen variables as keys 
    seen_keys = set() 

    computed_val1 = 0.0 

    for key in map1.keys(): 
     val = map1[key] 
     computed_val1 += val 

     # remember keys already in 1st computed 
     seen_keys.add(key) 

    def f2(map2): 
     computed_val2 = computed_val1 

     for key2 in map2.keys(): 
      # omit keys in first computation 
      if key2 in seen_keys: 
       continue 

      val2 = map2[key2] 
      computed_val2 += val2 

     return computed_val2 

    return f2 

if __name__ == '__main__': 

    partial_map = {'factor1': 1, 'factor2': 2} 
    func = f1(partial_map) 

    remaining_map1 = {'factor3': 3} 
    answer1A = func(remaining_map1) 
    print "Answer after using partial and remaining maps = ", answer1A 

    # complete the partial map with factor3 to show that 
    # the return function will ignore variables already seen in 1st computaion 
    partial_map['factor3'] = 3 
    answer1B = func(partial_map) 
    print "Answer with completed map to same func = ", answer1B 

    # Compute remaining map with different value for factor 3 
    remaining_map2 = {'factor3': 15} 
    answer2 = func(remaining_map2) 
    print "Answer with different second map = ", answer2