论文学习笔记

RCML

RCML的融合方法，A,B视图融合后仍能保持原来的性质，验证代码如下：

import numpy as np


def generate_numbers(k):
    # 生成 k-1 个非负随机数（b）
    b = np.random.rand(k - 1)
    b = np.abs(b)  # 确保所有 b 都是非负数
    total_b = np.sum(b)

    # 生成一个非负随机数（u）
    u = np.random.rand()
    u = max(0, u)  # 确保 u 是非负数

    # 将 u 添加到 b 中，使得所有 b 的和再加上 u 等于 1
    total_sum = total_b + u
    if total_sum != 1:
        scale_factor = 1 / total_sum
        b *= scale_factor
        u *= scale_factor

    # 返回 b 和 u
    return b, u


# 测试生成数字
k = 5  # 设置数字的数量
bA, uA = generate_numbers(k+1)
SA=k/uA
alphaA=SA*bA+1
print("SA:",SA)
print("数字 bA 和 uA 的总和：", np.sum(bA) + uA)
print("wA的参数：")
print("生成的数字 bA：", bA)
print("生成的数字 uA：", uA)
print("alphaA",alphaA)



bB, uB = generate_numbers(k+1)
SB=k/uB
alphaB=SB*bB+1
print("SB:",SB)
print("数字 bB 和 uB 的总和：", np.sum(bB) + uB)
print("wB的参数：")
print("生成的数字 bB：", bB)
print("生成的数字 uB：", uB)
print("alphaB",alphaB)


#A,B融合后
bAB=(bA*uB+bB*uA)/(uA+uB)

uAB=2*uA*uB/(uA+uB)

alphaAB=(alphaA+alphaB)/2

print("wAB的参数：")
print("生成的数字 bAB：", bAB)
print("生成的数字 uAB：", uAB)
print("alphaAB",alphaAB)

#验证性质
print("数字 bAB 和 uAB 的总和：", np.sum(bAB) + uAB)

SAB=k/uAB
print("SAB:",SAB)
alphaAB1=SAB*bAB+1
print("alphaAB1",alphaAB1)

代码运行结果如下图：

只是从结果的角度证明了这个结论，暂时没有数学推导，先放着吧hhh。

2024/4/26补充：

TMC

TMC的融合方法

和融合公式为：


容易发现白色和棕色方格之和为1，且C为白色方格之和，1-C为棕色方格之和

思路：上述融合规则描述的是两个观点W1和W2的融合，而当有W1,W2,W3时，则需要先使用W_new=W1 “+” W2(此“+”为融合的意思)，再计算W_end=W_new “+” W3,再W1,W2,W3的出现顺序不同时，按照这样的规则融合得出的最后的W_end的参数似乎都不相同。
因此，参考上图中，将W1,W2的参数画成2维概率论网格的思路，W1,W2,W3可以画成下图所示：

得出一个由W1=(b11,b12,b13,u1);W2=(b21,b22,b23,u2);W3=(b31,b32,b33,u3)确定的三维概率论空间，容易发现这个大正方体的体积为1，其简要证明如下：

类比TMC中融合公式可以写出一次性将W1,W2,W3融合的公式Function（W1,W2,W3）为：

图中符号说明：上标为视图号(1<=v<=V)，下标为类别号(1<=k<=N)


1.先代码验证一下这样一次性将W1,W2,W3,W4,W5融合后是否满足基本性质。

import random
print("\n")
import random

def generate_numbers(n):
    numbers = [random.random() for _ in range(n)]
    total = sum(numbers)
    normalized_numbers = [x / total for x in numbers]
    return normalized_numbers

V = 5
K = 5
dt = [generate_numbers(K+1) for _ in range(V)]

# #dt[0]=[0.1,0.2,0.2,0.3,0.2,0.00000000000001]
# dt[0]=[0.01,0.02,0.03,0.02,0.02,0.9]
# dt[1]=[0.01,0.02,0.03,0.04,0.1,0.8]
# dt[2]=[0.01,0.02,0.03,0.04,0.1,0.8]
# dt[3]=[0.01,0.02,0.03,0.02,0.02,0.9]
# dt[4]=[0.01,0.02,0.03,0.04,0.1,0.8]

for i in range(1, V+1):
    print(f"视图{i}得出的观点：" + ", ".join(["{:.12f}".format(x) for x in dt[i-1]]))

def cal_1c(dt):
    res = 0
    for k in range(K):
        temp = 1
        for v in range(V):
            temp *= dt[v][k]
        res += temp

    uu = 1
    for v in range(V):
        uu *= dt[v][K]
    res += uu

    for v in range(V):
        temp = uu / dt[v][K]
        sum = 0
        for k in range(K):
            sum += dt[v][k]
        temp *= sum
        res += temp
    return res

c1 = cal_1c(dt)
print(c1)

def cal_uu(dt):
    uu=1
    for v in range(V):
        uu*=dt[v][K]
    return uu
uu=cal_uu(dt)
print(uu)

def cal_u(dt):
    return cal_uu(dt)/c1

def cal_b(dt,uu,c1):
    b=[]
    for k in range(K):
        sum=0
        bbk=1
        for v in range(V):
            bbk*=dt[v][k]
        sum+=bbk

        for v in range(V):
            sum+=dt[v][k]*uu/dt[v][K]

        sum/=c1

        b.append(sum)
    return b

endb=cal_b(dt,uu,c1)
endu=cal_u(dt)
print(endb)
print(endu)

checksum=sum(endb)+endu
print(checksum)

发现sum(b)+u=1

2.再验证是否满足TMC文中这四个性质：
(1) 当两个观点都具有高不确定性（u1和u2都很大）时，最终的分类必须有低置信度（bk较小）；
(2) 当两个观点都具有低不确定性（u1和u2都很小）时，最终的分类可能有高置信度（bk较大）；
(3) 当只有一个观点具有低不确定性（只有u1或u2较大）时，最终的分类只取决于置信度高的观点；
(4) 当两个观点的意见冲突时，C和u都会相应增加。

数学太弱了，没怎么证明出来，简单用代码结果验证一下：
（1）

W1,W2,W3,W4,W5的u都很大，最后得出的b很小
（2）

W1,W2,W3,W4,W5的u都很小时，得出的b很大
（3）

只有W1的u很小，其他的u都很大时，最终的b和W1的b很像
（4）
什么是冲突我忘了，看看书再搞这个hhh。

🤡🤡🤡了！

BCF的融合方法：

它在证据层面的融合等价于：

然后用e1,e2,e3换几个顺序就发现，e_end都一样
结论：BCF的二元融合操作符满足结合律，顺序不影响最终结果！

代码验证了一下，BCF在123，132等顺序下，以及使用我自己推到的公式的结果：

import numpy as np

K=10
def e2w(e):
    e_sum=e.sum()
    w=e/(e_sum+K)
    w=np.append(w,K/(e_sum+K))
    return w

def w2e(w):
    u=w[K]
    e=K*w/u
    e=e[:-1]
    return e

e1=np.random.randint(1,100,K)
e2=np.random.randint(1,100,K)
e3=np.random.randint(1,100,K)

w1=e2w(e1)
w2=e2w(e2)
w3=e2w(e3)

print('w1',w1)
print('w2',w2)
print('w3',w3)

def cal_C(w1,w2):
    b1=w1[:-1]
    u1=w1[K]
    b2=w2[:-1]
    u2=w2[K]
    b1b2=b1*b2
    C_complement=b1b2.sum()+u1*b2.sum()+u2*b1.sum()+u1*u2
    C=1-C_complement
    return C

def BCF(w1,w2):
    C=cal_C(w1,w2)
    b1 = w1[:-1]
    u1 = w1[K]
    b2 = w2[:-1]
    u2 = w2[K]

    b=(b1*b2+b1*u2+b2*u1)/(1-C)
    u=u1*u2/(1-C)
    w=b
    w=np.append(w,u)
    return w

def BCF_e(e1,e2):
    e=e1+e2+e1*e2/K
    return e

def experiment(w1,w2,w3):
    w=BCF(w1,w2)
    w=BCF(w,w3)
    return w

print('123',BCF(BCF(w1,w2),w3))
#print(e2w(BCF_e(BCF_e(e1,e2),e3)))
print('132',BCF(BCF(w1,w3),w2))
print('213',BCF(BCF(w2,w1),w3))
print('231',BCF(BCF(w2,w3),w1))
print('312',BCF(BCF(w3,w1),w2))
print('321',BCF(BCF(w3,w2),w1))
#一模一样！BCF不受顺序影响！

def cal_C1(w1,w2,w3):
    b1 = w1[:-1]
    u1 = w1[K]
    b2 = w2[:-1]
    u2 = w2[K]
    b3 = w3[:-1]
    u3 = w3[K]

    u_pai=u1*u2*u3
    b_pai=b1*b2*b3
    C_complement=b_pai.sum()+u_pai+u_pai/u1*b1.sum()+u_pai/u2*b2.sum()+u_pai/u3*b3.sum()
    C=1-C_complement
    return C

def BCFall(w1,w2,w3):
    C1=cal_C1(w1,w2,w3)
    b1 = w1[:-1]
    u1 = w1[K]
    b2 = w2[:-1]
    u2 = w2[K]
    b3 = w3[:-1]
    u3 = w3[K]
    u_pai=u1*u2*u3
    b=(b1*b2*b3+b1*u_pai/u1+b2*u_pai/u2+b3*u_pai/u3)/(1-C1)
    u=(u_pai)/(1-C1)

    w = b
    w = np.append(w, u)
    return w

w_end=BCFall(w1,w2,w3)
print('我的公式w_end',w_end)

如上图所示，123,132,213,231,312,321结果都一样，但是和我的公式的结果不一样。