डीएसटी पर क्रैश कोर्स
डेम्पस्टर-शेफर सिद्धांत (डीएसटी) विश्वास बनाने के लिए साक्ष्य के विभिन्न स्रोतों को संयोजित करने की एक विधि प्रदान करता है। संभावित बयान की सूची (जिनमें से एक सही उत्तर है) को देखते हुए, बयानों के प्रत्येक संभावित संयोजन को एक "द्रव्यमान" सौंपा गया है जो सहायक साक्ष्य की डिग्री का संकेत देता है। सभी संयोजनों का कुल द्रव्यमान हमेशा 1 के बराबर होता है।
इन सामूहिक असाइनमेंट से, हम उस संयोजन की सच्चाई पर एक उचित लोअर बाउंड (विश्वास) और अपर बाउंड (पठनीयता) बना सकते हैं। bel(X)किसी भी सेट X का विश्वास एक्स के सभी सबसेट (खुद सहित) के द्रव्यमान का योग है। pl(X)किसी भी सेट X की पठनीयता "1 - सभी सेटों के द्रव्यमान का योग X है।" नीचे दिए गए आरेख से पता चलता है कि विश्वास और प्रशंसनीयता अनिश्चितता से कैसे संबंधित हैं।
उदाहरण के लिए, Gमान लें कि एक ट्रैफ़िक लाइट है, जो रेयन, एलो Y, या Rएड में से एक हो सकती है । विकल्पों और संभावित सामूहिक असाइनमेंट की सूची नीचे दी गई है:
binary interpretation m(X) bel(X) pl(x)
000 null 0 0 0
001 R 0.2 0.2 0.7
010 Y 0.1 0.1 0.3
011 Y||R 0.05 0.35 0.8
100 G 0.2 0.2 0.65
101 G||R 0.3 0.7 0.9
110 G||Y 0 0.3 0.8
111 G||Y||R 0.15 1 1
इन द्रव्यमानों को एक सारणी द्वारा देखा जा सकता है [0, 0.2, 0.1, 0.05, 0.2, 0.3, 0, 0.15]।
अब सवाल यह है कि हम यह कैसे तय करें कि जनता क्या है? मान लीजिए कि हमारे पास प्रकाश को देखने वाला एक सेंसर था, और यह सेंसर इंगित करता है कि प्रकाश हरा नहीं है ; हालाँकि, हम जानते हैं कि 20% संभावना है कि सेंसर ने एक यादृच्छिक, सुस्पष्ट संकेत भेजा। सबूत के इस टुकड़े को बड़े पैमाने पर वितरण द्वारा वर्णित किया जा सकता है [0, 0, 0, 0.8, 0, 0, 0, 0.2]जहां {Y, R} का द्रव्यमान 0.8 और {G, Y, R} का द्रव्यमान 0.2 है।
इसी तरह, मान लीजिए कि कुछ दूसरे सेंसर इंगित करते हैं कि प्रकाश लाल नहीं है , लेकिन हम यह भी जानते हैं कि 30% संभावना है कि सेंसर गलत है और प्रकाश वास्तव में लाल है। सबूत के इस टुकड़े का वर्णन किया जा सकता है [0, 0.3, 0, 0, 0, 0, 0.7, 0]जहां {G, Y} का द्रव्यमान 0.7 और {R} का द्रव्यमान 0.3 है।
एकल जन वितरण को बनाने के लिए सबूत के इन दो टुकड़ों को आत्मसात करने के लिए, हम Dempster के नियम संयोजन का उपयोग कर सकते हैं।
कॉम्बिनेशन का डेम्पिस्टर नियम
दो जन असाइनमेंट m1और निम्नलिखित सूत्रों का उपयोग करके m2फार्म में जोड़ा जा सकता है m1,2, जहां A, Bऔर Cसंभव संयोजनों का प्रतिनिधित्व करते हैं (ऊपर तालिका की पंक्तियों)।
जहां K "पुनर्संरचना के लिए" संघर्ष, "का एक उपाय है, और इसके द्वारा गणना की जाती है:
इस प्रक्रिया को ज्यामितीय रूप से वर्णन करना भी संभव है, जैसा कि नीचे की छवि में है। यदि A = 011(पीला या लाल) और B = 101(हरा या लाल), तो (लाल) के मूल्य में m1(A) * m2(B) योगदान का मूल्य (जोड़ा जाता है m1,2(001)) है। इस प्रक्रिया को ए और बी के सभी संभावित संयोजनों के लिए दोहराया जाता है जहां A&B != 0। अंत में, सरणी का नाम बदल दिया जाता है ताकि मान कुल 1 तक जुड़ जाएं।
यहाँ एक सरल जावा विधि है जो डेम्पस्टर के नियम के बाद दो सरणियों को जोड़ती है:
public static double[] combine(double[] a, double[] b) {
double[] res = new double[a.length];
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < b.length; j++) {
res[i & j] += a[i] * b[j];
}
}
for (int i = 1; i < res.length; i++) {
res[i] /= 1 - res[0];
}
res[0] = 0;
return res;
}
यह देखने के लिए कि यह व्यवहार में कैसे काम करता है, ऊपर ट्रैफिक लाइट सेंसर पर विचार करें, जो स्वतंत्र रूप से जनता को देते हैं [0, 0, 0, 0.8, 0, 0, 0, 0.2]और [0, 0.3, 0, 0, 0, 0, 0.7, 0]। डेम्पस्टर के शासन को करने के बाद, परिणामी संयुक्त द्रव्यमान है [0, 0.3, 0.56, 0, 0, 0, 0.14, 0]। द्रव्यमान का अधिकांश भाग "येलो" को सौंपा गया है, जो सहज ज्ञान युक्त समझ देता है कि दो सेंसर क्रमशः "हरे नहीं" और "लाल नहीं" हैं। माप की अनिश्चितता के कारण अन्य दो द्रव्यमान ("रेड" के लिए 0.3 और "ग्रीन या येलो" के लिए 0.14) हैं।
चुनौती
एक प्रोग्राम लिखें जो वास्तविक संख्याओं की दो सूचियों को लेता है और दो इनपुट सूचियों के लिए डेम्पस्टर के नियम को लागू करने का परिणाम देता है। दो इनपुट सूचियों की लंबाई समान होगी, और वह लंबाई 2 की शक्ति होगी, और कम से कम 4 होगी। प्रत्येक सूची के लिए, पहला मान हमेशा 0 होगा और शेष मान सभी गैर-ऋणात्मक और जोड़ देगा 1 तक।
आउटपुट एक सूची होनी चाहिए जिसमें इनपुट सूचियां समान हों। आप मान सकते हैं कि एक समाधान मौजूद है (यह समाधान के लिए मौजूद नहीं है जब सबूत और इस तरह के = 1 के बीच कुल संघर्ष होता है)। परिशुद्धता पर न्यूनतम आवश्यकता रखने के लिए, आपका कार्यक्रम चार दशमलव स्थानों पर गोल होने पर सटीक परिणाम उत्पन्न करने में सक्षम होना चाहिए।
उदाहरण I / O
in:
[0, 0, 0, 0.8, 0, 0, 0, 0.2]
[0, 0.3, 0, 0, 0, 0, 0.7, 0]
out:
[0.0, 0.3, 0.56, 0.0, 0.0, 0.0, 0.14, 0.0]
in:
[0.0, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.4]
[0.0, 0.2, 0.0, 0.2, 0.0, 0.2, 0.0, 0.4]
out:
[0.0, 0.2889, 0.0889, 0.1556, 0.0889, 0.1556, 0.0444, 0.1778]
in:
[0.0, 0.0, 0.5, 0.5]
[0.0, 0.7, 0.1, 0.2]
out:
[0.0, 0.53846, 0.30769, 0.15385]
in:
[0.0, 0.055, 0.042, 0.098, 0.0, 0.152, 0.0, 0.038, 0.031, 0.13, 0.027, 0.172, 0.016, 0.114, 0.058, 0.067]
[0.0, 0.125, 0.013, 0.001, 0.012, 0.004, 0.161, 0.037, 0.009, 0.15, 0.016, 0.047, 0.096, 0.016, 0.227, 0.086]
out: (doesn't have to be this precise)
[0.0, 0.20448589713416732, 0.11767361551134202, 0.028496524069011694, 0.11809792349331062, 0.0310457664246791, 0.041882026540181416, 0.008093533320057205, 0.12095719354780314, 0.11306959103499466, 0.06412594818690368, 0.02944697394862137, 0.06398564368086611, 0.014369896989336852, 0.03774983253978312, 0.006519633578941643]
in:
[0.0, 0.0, 0.1, 0.1, 0.0, 0.0, 0.0, 0.1, 0.1, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.1, 0.0, 0.0, 0.1, 0.0, 0.1, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.1, 0.0, 0.0, 0.0, 0.0]
[0.0, 0.0, 0.1, 0.0, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.1, 0.0, 0.0, 0.1, 0.0, 0.0, 0.0, 0.1, 0.1, 0.0, 0.0, 0.0, 0.1, 0.0, 0.0, 0.1, 0.0, 0.0, 0.1, 0.0, 0.1, 0.0]
out:
[0.0, 0.09090909090909094, 0.23376623376623382, 0.0, 0.07792207792207795, 0.025974025974026, 0.03896103896103895, 0.0, 0.10389610389610393, 0.05194805194805199, 0.02597402597402597, 0.0, 0.012987012987012984, 0.012987012987012993, 0.012987012987012984, 0.0, 0.09090909090909094, 0.038961038961038995, 0.06493506493506492, 0.0, 0.07792207792207796, 0.0, 0.0, 0.0, 0.012987012987012984, 0.012987012987013, 0.012987012987012984, 0.0, 0.0, 0.0, 0.0, 0.0]