入门文献复现——Belief function combination and conflict management

为了更好的读懂论文，一边阅读一边尝试复现论文

在这篇论文中，作者提出了基于加权因子w(A,m) 的通用框架。将此加权因子的计算分为三类。

1、直接定值：Yager与Semts的融合规则适用
2、计算加权因子：Dempster与Dubios&Prade的融合规则适用
3、自动学习加权因子

1.融于框架后的Dempster融合规则

1.1.这里就先不详细写推导过程，本博文主要写的是程序复现这一部分

#基于通用框架的改进的Dempster方法
#本程序并不完善，过于冗余
#
#如果想增加（减少）数据源的个数，那么需要在 def K(X_set,n)和def m(str_one) 函数下，
#1、增加（减少）空集合，及set_1,set_2,这些是用来做 ∩ 运算
#2、增加（减少）for循环
#3、改变if条件语句


import math
#1、首先说明辩框X
set_List=['A','B','C'];
X_set=set(set_List);#变成集合
empty_set=set();#这是一个空集
#2、列出不同证据源的bpa
# m_1={'A':0.98,'B':0.01,'C':0.01};
# m_2={'A':0,'B':0.01,'C':0.99};
k=0.1;#固定值
#e=0.1,0.01,0.001,0.0001;#变化值
e=0.0001
z=1-k-e;#z+e+k=1
m_1={'A':e,'B':k,'C':z};
m_2={'A':z,'B':k,'C':e};
#3、计算K值即冲突质量m(ϕ)
def K(X_set,n):
    sum=0.00;
    set_1=set();
    set_2=set();
    if(n<1):
        #print("只有一个证据,Fail！\n");
        return -1;
    #print("当前有{0}个证据来源\n".format(n));
    for m1 in X_set:
        set_1.add(m1);
        for m2 in X_set:
            set_2.add(m2);
            #print(type(set_2),set_2)
            if(set_1.intersection(set_2)==set()):
                #此时相交集合为空集合
                sum+=m_1[m1]*m_2[m2];
            set_2.clear()
        set_1.clear();
    #print(sum);
    return sum;

#4、计算m_∩(A)
def m(str_one):
    i=1
    sum=0.00
    set_one=set(str_one);#将字符str_one放在一个集合中
    set_2=set();#为了方便集合运算，创建一个临时的空集合
    for m2 in m_2:
        set_2.add(m2);
        if(set_one.intersection(set_2)==set_one):
            sum+=m_1[str_one]*m_2[m2];
            i+=1
        set_2.clear();
    #dict_one=dict.fromkeys(str_one,sum)
    #return dict_one
    return sum;

#5、计算单个的加权因子w(A,m)，A={H1,H2,H3}
def weight_compute(X_set,n,str_one):
    m_insert=m(str_one);
    m_empty=K(X_set,n);
    if m_empty!=1:
        weights = m_insert / (1 - m_empty);
    else:
        print("Failed:m_empty=1")
        exit(0);
    return weights;
#6、计算出所有的加权因子
#以字典的形式返回
def weight_Frame(X_set):
    n=2;
    dict_result=dict();
    for str_one in X_set:
        values=weight_compute(X_set,n,str_one);
        values=round(values,4)
        dict_result.update(dict.fromkeys(str_one,values));
    return dict_result;
#7、计算出在通用框架下Dempster融合之后的值
def combination_Evidence(X_set,n):
    dict_weight=weight_Frame(X_set);#这是权重
    dict_result=dict();#这是结果
    sum=0.000
    for str_item in X_set:
        m_insert=m(str_item);#M∩(H)
        m_empty=K(X_set,n);#M(∅)
        m_weight=weight_compute(X_set,n,str_item);#加权因子
        sum=m_insert+m_weight*m_empty;
        #print("m_insert=",m_insert,"m_weight=",m_weight,"m_empty=",m_empty)
        #print("sum",sum)
        sum=round(sum,4)
        dict_result.update(dict.fromkeys(str_item,sum));
    return dict_result;

if __name__ == '__main__':
    print("**********加权因子***************\n");
    print(weight_Frame(X_set));
    print("\n");
    print("**********融合后的结果***********\n")
    print(combination_Evidence(X_set, 2))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

2、Dubios和Prade在通用框架下的公式

利用下面定义的w(A,m)的通用框架可以直接推改进的公式

#这是在通用框架下的Dubios&Prade规则
#这个新的规则之前没有写过原版的，就直接写改进的吧
#这个程序主要分为：m*、m_intersection、m_empty

#1、确定辩框
theta=['A','B','C'];
theta_set=set(theta);

#2、确定证据源
k=0.1;#固定值
e=0.1;#变化值
z=1-k-e;#因变量
m_1={'A':e,'B':k,'C':z};
m_2={'A':z,'B':k,'C':e};

#2.1 抽取每一个证据源中的焦元，返回一个集合
def focal_Element(m_dict):
    key_m=[];
    m_key=m_dict.keys();
    for item in m_key:
        key_m.append(item)
    keym_set=set(key_m);
    return keym_set;

#3、计算m_empty
def computeEmpty(m_1,m_2,n):
    F1=focal_Element(m_1);
    F2=focal_Element(m_2);
    # 构造空集合
    theta_set1 = set();
    theta_set2 = set();
    empty = set();
    m_empty = 0.00
    for item1 in F1:
        theta_set1.update(item1);
        for item2 in F2:
            theta_set2.update(item2);
            if (theta_set1.intersection(theta_set2) == empty):
                m_empty += m_1[item1] * m_2[item2];
            theta_set2.clear();
        theta_set1.clear();
    return m_empty;

#4、计算m*
def computLocal(m_1,m_2,n,thetaSet):
    F1=focal_Element(m_1);
    F2=focal_Element(m_2);
    #空集合
    f1_set=set();
    f2_set=set();
    empty=set();
    m_local=dict();
    for item1 in F1:
        f1_set.update(item1);
        for item2 in F2:
            f2_set.update(item2);
            if (f1_set.intersection(f2_set) == empty):
                if(f1_set.union(f2_set).intersection(thetaSet)!=empty):
                    sum = m_1[item1] * m_2[item2];
                    str_=item1+"∪"+item2;
                    str_copy=item2+"∪"+item1;
                    #sum = round(sum, 4);
                    if str_copy not in m_local.keys():
                        if str_ in m_local.keys():
                            m_local[str_] = sum;
                        else:
                            m_local[str_]=sum;
                    else:
                        m_local[str_copy]=m_local[str_copy]+sum;
            f2_set.clear();
        f1_set.clear();
    return m_local;

#5、计算 m_intersection
def computeInter(m_1,m_2,thetaSet):
    F1=focal_Element(m_1);
    F2=focal_Element(m_2);
    #空集合
    f1_set=set();
    f2_set=set();
    strSet=set();

    inter=dict();
    for item0 in thetaSet:
        strSet.update(item0);
        sum=0.00
        for item1 in F1:
            f1_set.update(item1);
            for item2 in F2:
                f2_set.update(item2);
                if(f1_set.intersection(f2_set)==strSet):
                    sum+=m_1[item1]*m_2[item2];
                f2_set.clear();
            f1_set.clear();
        inter.update(dict.fromkeys(item0,sum));
        strSet.clear();
    return inter;
#6、计算融合
def combinationEvidence(m_1,m_2,n,thetaSet):
    m_insert=computeInter(m_1,m_2,thetaSet);#字典类型
    m_empty=computeEmpty(m_1,m_2,n);#float类型
    m_local=computLocal(m_1,m_2,n,thetaSet);#字典类型
    #计算出各个w值
    print("***************加权因子********************");
    for item1 in m_local.keys():
        if item1 in m_local:
            m_local[item1]=round(m_local[item1]*m_empty,4);
    print(m_local);
    print();
    print("**************融合后的MASS*****************");
    #m_combination=dict();
    for item0 in thetaSet:
        if item0 in m_insert:
            m_intersection=m_insert[item0];
        else:
            m_intersection=0;
        if item0 in m_local:
            m_c=m_local[item0];
        else:
            m_c=0
        print(item0,round(m_intersection+m_c,4));
    print()
    print("***************intersection*****************");
    print(m_insert);
    return 0;
if __name__ == '__main__':
    print("e = ",e)
    combinationEvidence(m_1,m_2,2,theta_set);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127