Python莫兰生死抑制放大进化图

🎯要点

🎯种群离散时间莫兰生死动态图解 | 🎯良好混合种群的固定概率 | 🎯数值求解生成埃尔多斯-雷尼图 | 🎯计算马尔可夫链的转移矩阵概率 | 🎯出生死亡动态和死亡出生动态概率无向随机图和有向随机图，转移矩阵概率计算

📜进化图用例

📜Python种群邻接矩阵彗星风筝进化图算法

📜Python和C++骨髓细胞进化解析数学模型

🍪语言内容分比

🍇Python转移矩阵

令 E E E 定义构成时间序列数据的 k k k 个唯一事件集。例如，时间序列可能由以下三个基本且唯一的事件组成，这些事件表示在离散时间步长上绘制数据时观察到的路径轨迹类型：向下、持平和向上。令 S S S 定义长度为 n n n（表示离散时间步长）的序列，该序列由 E E E 中定义的事件组成，表示部分或全部数据。例如，序列 [向上、向下、向上、持平、向上] 表示五个时间步长的数据。

现在可以定义一个维度为 k 2 k^2 k2的马尔可夫转移矩阵 M M M，使得每个元素 M ( i , j ) M(i, j) M(i,j) 描述在给定时间序列中从时间步骤 t t t 中的事件 E ( i ) E(i) E(i)转移到时间步骤 t + 1 t +1 t+1 中的事件 E ( j ) E(j) E(j) 的概率。换句话说，$M(i, j) 表示在连续时间步骤中两个事件之间转移的条件概率。从图论意义上讲，如果时间序列数据中 E ( i ) E(i) E(i) 后面是 E ( j ) E(j) E(j)，则事件 E(i)$ 和 E ( j ) E(j) E(j) 可以被认为是由有向边 E ( i ) → E ( j ) E(i) \rightarrow E(j) E(i)→E(j) 连接的节点，那么马尔可夫转移矩阵 M M M​​ 本质上表示图中节点所描绘事件的邻接矩阵（或共现矩阵）的规范化版本。

假设我们有以下涵盖 11 个连续时间步长的原始时间序列数据：[1, 2, -2, -1, 0, 0, 2, 2, 1, 2, 3]。使用上面描述的路径轨迹的简化视图，我们可以将数据转换为以下 10 个事件序列，这些事件描述相邻时间步长之间的转换：[上、下、上、上、平、上、平、下、上、上]。

我们现在可以构建以下邻接矩阵来捕获事件序列中同时出现的模式：
A = ( 2 2 1 1 0 1 2 0 0 ) A=\left(\begin{array}{lll} 2 & 2 & 1 \\ 1 & 0 & 1 \\ 2 & 0 & 0 \end{array}\right) A= 212200110

元素 A ( i , j ) A(i, j) A(i,j) 表示事件序列中某个时间步 t t t 的事件 i i i 后面跟着时间步 t + 1 t+1 t+1 的事件 j j j 的次数； i i i 和 j j j 分别是行索引和列索引。请注意，行表示从上到下、从上到下的顺序的事件，而列从左到右表示相同的事件。例如， A A A 的左上角元素表示在给定的事件序列中，上事件后紧跟着另一个上事件两次。 A A A 的中右元素表示在事件序列中，平事件之后紧接着下事件。等等。

我们可以按行或按列标准化矩阵 A A A 以生成转换矩阵。如果我们使用基于行的归一化，则元素 M ( i , j ) M(i, j) M(i,j) 将描述给定事件 E ( i ) E(i) E(i) 在时间步 t + 1 t+1 t+1 中看到事件 E ( j ) E(j) E(j) 的概率时间步 t t t。因此，每行中的概率之和应为 1 。在我们的示例中，行归一化矩阵如下所示：
M rnorm = ( 2 / 5 2 / 5 1 / 5 1 / 2 0 1 / 2 2 / 2 0 0 ) = ( 0.4 0.4 0.2 0.5 0 0.5 1 0 0 ) M_{\text {rnorm }}=\left(\begin{array}{ccc} 2 / 5 & 2 / 5 & 1 / 5 \\ 1 / 2 & 0 & 1 / 2 \\ 2 / 2 & 0 & 0 \end{array}\right)=\left(\begin{array}{ccc} 0.4 & 0.4 & 0.2 \\ 0.5 & 0 & 0.5 \\ 1 & 0 & 0 \end{array}\right) Mrnorm = 2/51/22/22/5001/51/20 = 0.40.510.4000.20.50

类似地，如果我们要使用基于列的归一化，则元素 M ( i , j ) M(i, j) M(i,j) 将描述给定时间步 t t t 中的事件 E ( j ) E(j) E(j) 的情况下，在时间步 t − 1 t-1 t−1 中发生事件 E ( i ) E(i) E(i) 的概率。现在每列中的概率之和应为 1。在我们的示例中，列归一化矩阵如下所示：
M cnorm = ( 2 / 5 2 / 2 1 / 2 1 / 5 0 1 / 2 2 / 5 0 0 ) = ( 0.4 1 0.5 0.2 0 0.5 0.4 0 0 ) M_{\text {cnorm }}=\left(\begin{array}{ccc} 2 / 5 & 2 / 2 & 1 / 2 \\ 1 / 5 & 0 & 1 / 2 \\ 2 / 5 & 0 & 0 \end{array}\right)=\left(\begin{array}{ccc} 0.4 & 1 & 0.5 \\ 0.2 & 0 & 0.5 \\ 0.4 & 0 & 0 \end{array}\right) Mcnorm = 2/51/52/52/2001/21/20 = 0.40.20.41000.50.50

请注意，行归一化（名义上向前看时间）的条件概率可能与列归一化（向后看时间）的条件概率不同。

代码计算

import pandas as pd

def get_transition_tuples(ls):
   
    return [(ls[i-1], ls[i]) for i in range(1, len(ls))]

def get_transition_event(tup):

    transition_event = 'flat'
    if tup[0] < tup[1]:
        transition_event = 'up'
    if tup[0] > tup[1]:
        transition_event = 'down'
    return transition_event

ls_raw_time_series = [1, 2, -2, -1, 0, 0, 2, 2, 1, 2, 3]
ls_transitions = get_transition_tuples(ls_raw_time_series)
ls_events = [get_transition_event(tup) for tup in ls_transitions]
ls_event_transitions = get_transition_tuples(ls_events)
ls_index = ['up', 'flat', 'down']
df = pd.DataFrame(0, index=ls_index, columns=ls_index)


for i, j in ls_event_transitions:
    df[j][i] += 1  

df_rnorm = df.div(df.sum(axis=1), axis=0).fillna(0.00)


df_cnorm = df.div(df.sum(axis=0), axis=1).fillna(0.00)

这应该产生以下转换矩阵：

>>> df  
      up    flat  down
up    2     2     1
flat  1     0     1
down  2     0     0
>>> df_rnorm  
      up    flat  down
up    0.4   0.4   0.2
flat  0.5   0.0   0.5
down  1.0   0.0   0.0
>>> df_cnorm  
      up    flat  down
up    0.4   1.0   0.5
flat  0.2   0.0   0.5
down  0.4   0.0   0.0

可视化转移状态

def get_df_edgelist(df, ls_index):

    edgelist = []
    for i in ls_index:
        for j in ls_index:
            edgelist.append([i, j, df[j][i]])
    return pd.DataFrame(edgelist, columns=['src', 'dst', 'weight'])

def edgelist_to_digraph(df_edgelist):
    g = Digraph(format='jpeg')
    g.attr(rankdir='LR', size='30')
    g.attr('node', shape='circle')
    nodelist = []
    for _, row in df_edgelist.iterrows():
        node1, node2, weight = [str(item) for item in row]
        if node1 not in nodelist:
            g.node(node1, **{'width': '1', 'height': '1'})
            nodelist.append(node1)
        if node2 not in nodelist:
            g.node(node2, **{'width': '1', 'height': '1'})
            nodelist.append(node2)
        g.edge(node1, node2, label=weight)
    return g

def render_graph(fname, df, ls_index):
    df_edgelist = get_df_edgelist(df, ls_index)
    g = edgelist_to_digraph(df_edgelist)
    g.render(fname, view=True)

render_graph('adjmat', df, ls_index)
render_graph('transmat_rnorm', df_rnorm, ls_index)
render_graph('transmat_cnorm', df_cnorm, ls_index)

👉参阅、更新：计算思维 | 亚图跨际