转移概率矩阵

Question

我有以下数组：

a=[['A', 'B'],
 ['B', 'B'],
 ['B', 'C'],
 ['C', 'B'],
 ['B', 'A'],
 ['A', 'D'],
 ['D', 'D'],
 ['D', 'A'],
 ['A', 'B'],
 ['B', 'A'],
 ['A', 'D']]

我想制作一个转移概率矩阵，这样我就可以得到：

[[P_AA,P_AB,P_AC,P_AD],
[P_BA,P_BB,P_BC,P_BD],
[P_CA,P_CB,P_CC,P_CD],
[P_DA,P_DB,P_DC,P_DD]]

（以上是为了说明），其中 P_AA 计算数组 a 中有多少 ["A","A"] 等等除以 P_AA+P_AB+P_AC+P_AD 。我已经开始使用计数器

from collections import Counter
Counter(tuple(x) for x in l)

正确计算数组元素为：

Counter({('A', 'B'): 2,
         ('B', 'B'): 1,
         ('B', 'C'): 1,
         ('C', 'B'): 1,
         ('B', 'A'): 2,
         ('A', 'D'): 2,
         ('D', 'D'): 1,
         ('D', 'A'): 1})

所以矩阵应该是，

[[0,2/5,0,2/5],[2/4,1/4,1/4,0],[0,1,0,0],[1/2,0,0,1/2]]

Answer 1

这是一个非常适合itertools和Counter的问题。看看下面的¹:

l = [['A', 'B'],
     ['B', 'B'],
     ['B', 'C'],
     ['C', 'B'],
     ['B', 'A'],
     ['A', 'D'],
     ['D', 'D'],
     ['D', 'A'],
     ['A', 'B'],
     ['B', 'A'],
     ['A', 'D']]

from collections import Counter
from itertools import product, groupby

unique_elements = set(x for y in l for x in y)  # -> {'B', 'C', 'A', 'D'}

appearances = Counter(tuple(x) for x in l)

# generating all possible combinations to get the probabilities
all_combinations = sorted(list(product(unique_elements, unique_elements)))

# calculating and arranging the probabilities
table = []
for i, g in groupby(all_combinations, key=lambda x: x[0]):
    g = list(g)
    local_sum = sum(appearances.get(y, 0) for y in g)
    table.append([appearances.get(x, 0) / local_sum for x in g])

# [[0.0, 0.5, 0.0, 0.5], [0.5, 0.25, 0.25, 0.0], [0.0, 1.0, 0.0, 0.0], [0.5, 0.0, 0.0, 0.5]]

¹ 我假设您在问题的表述上有误："...其中 P_AA 计算了多少 ["A","A"] 在数组 a 中，依此类推除以 P_AA + P_AB + P_AC + P_AD..."= 23=]。你的意思是和其他东西分开，对吧？

Answer 2

如果元素个数少，直接遍历所有元素应该没问题：

import numpy as np

a = [['A', 'B'], ['B', 'B'], ['B', 'C'], ['C', 'B'], ['B', 'A'],
        ['A', 'D'], ['D', 'D'], ['D', 'A'] ['A', 'B'], ['B', 'A'], ['A', 'D']]                                                                                                                                      

a = np.asarray(a)                                                                                                                                   
elems = np.unique(a)                                                                                                                                
dim = len(elems)                                                                                                                                    
P = np.zeros((dim, dim))                                                                                                                            

for j, x_in in enumerate(elems):                                                                                                                    
    for k, x_out in enumerate(elems):                                                                                                               
        P[j,k] = (a == [x_in, x_out]).all(axis=1).sum()                                                                                             

    if P[j,:].sum() > 0:                                                                                                                            
        P[j,:] /= P[j,:].sum()

输出：

array([[0.  , 0.5 , 0.  , 0.5 ],
       [0.5 , 0.25, 0.25, 0.  ],
       [0.  , 1.  , 0.  , 0.  ],
       [0.5 , 0.  , 0.  , 0.5 ]])

但您也可以使用带有预分配转换矩阵的计数器，将元素映射到索引，将计数分配为值，然后归一化（就像我所做的最后两个步骤）。

Answer 3

from collections import Counter

a = [['A', 'B'],
     ['B', 'B'],
     ['B', 'C'],
     ['C', 'B'],
     ['B', 'A'],
     ['A', 'D'],
     ['D', 'D'],
     ['D', 'A'],
     ['A', 'B'],
     ['B', 'A'],
     ['A', 'D']]

counts = Counter(map(tuple, a))

letters = 'ABCD'
p = []    

for letter in letters:
     d = sum(v for k, v in counts.items() if k[0] == letter)
     p.append([counts.get((letter, x), 0) / d  for x in letters])

print(p)

输出:

[[0.0, 0.5, 0.0, 0.5],
 [0.5, 0.25, 0.25, 0.0],
 [0.0, 1.0, 0.0, 0.0],
 [0.5, 0.0, 0.0, 0.5]]

Answer 4

基于pandas的解决方案：

import pandas as pd
from collections import Counter
# Create a raw transition matrix
matrix = pd.Series(Counter(map(tuple, a))).unstack().fillna(0)
# Normalize the rows
matrix.divide(matrix.sum(axis=1),axis=0)
#     A     B     C    D
#A  0.0  0.50  0.00  0.5
#B  0.5  0.25  0.25  0.0
#C  0.0  1.00  0.00  0.0
#D  0.5  0.00  0.00  0.5

转移概率矩阵

Transition probability matrix

python

arrays

matrix

linear-algebra