测量加权 numpy 数组的平衡性

Question

我有玩家

A

和

B

，他们都与不同的对手比赛。

玩家	对手	几天前
A	C	1
A	C	2
A	D	10
A	F	100
A	F	101
A	F	102
A	G	1
B	C	1
B	C	2
B	D	10
B	F	100
B	F	101
B	F	102
B	G	1
B	G	2
B	G	3
B	G	4
B	G	5
B	G	6
B	G	7
B	G	8

首先，我想找到最常见的对手。我对“最常见”的定义不是匹配总数，而是匹配的平衡数量。 例如，如果玩家

A

和

B

分别对战

C

99 次和 1 次，我更喜欢对手

D

，其中

A

和

B

都对战 49 次。

为了测量“平衡性”，我编写了以下函数：

import numpy as np
from collections import Counter


def balanceness(array: np.ndarray):
    classes = [(c, cnt) for c, cnt in Counter(array).items()]
    m = len(classes)
    n = len(array)

    H = -sum([(cnt / n) * np.log((cnt / n)) for c, cnt in classes])

    return H / np.log(m)

此功能按预期工作：

>> balanceness(array=np.array([0, 0, 0, 1, 1, 1]))
1.0

如果我在不同的对手上运行该函数，我会看到以下结果：

对手	平衡性	n_匹配
C	1	4
D	1	2
F	1	6
G	0.5032583347756457	9

显然，对手

F

是最常见的。然而，

A

和

B

与

F

的比赛相对较旧。

我应该如何将新近度因素纳入我的计算中以找到“最近的常见对手”？

Answer 1

import numpy as np

data = np.array([['A', 'C', 1],
                ['A', 'C', 2],
                ['A', 'D', 10],
                ['A', 'F', 100],
                ['A', 'F', 101],
                ['A', 'F', 102],
                ['A', 'G', 1],
                ['B', 'C', 1],
                ['B', 'C', 2],
                ['B', 'D', 10],
                ['B', 'F', 100],
                ['B', 'F', 101],
                ['B', 'F', 102],
                ['B', 'G', 1],
                ['B', 'G', 2],
                ['B', 'G', 3],
                ['B', 'G', 4],
                ['B', 'G', 5],
                ['B', 'G', 6],
                ['B', 'G', 7],
                ['B', 'G', 8]], dtype=object)
                
# Convert the data to a structured format
players = data[:, 0]
opponents = data[:, 1]
days_ago = data[:, 2].astype(int)

# initiate dct_A and dct_B

dct_A = {'C':0, 'D':0, 'F':0, 'G':0}
dct_B = {'C':0, 'D':0, 'F':0, 'G':0}

for i,x in enumerate(opponents):
    if players[i] == 'A':
        dct_A[x] = dct_A[x] + days_ago[i]
        
    else:
        dct_B[x] = dct_B[x] + days_ago[i]
opps = [x for x in dct_A.keys()]
ls_A = [x for x in dct_A.values()]
ls_B = [x for x in dct_B.values()]
balanceness = [abs(ls_A[i] - ls_B[i])/2 for i in range(len(ls_A))]
dct = {opps[i] : balanceness[i] for i in range(len(balanceness))}

print(dct) # Output : {'C': 0.0, 'D': 0.0, 'F': 0.0, 'G': 17.5}