样本熵和泊松指数的计算流程！！！

1. 泊松指数计算

泊松指数通常指方差与均值的比率，用于衡量数据是否符合泊松分布（泊松分布的方差与均值相等，比率为1）。

计算步骤：

1、计算均值（μ） ：

数据总和 = 3 + 4 + 5 + 6 + 1 + 7 + 8 + 9 + 2 = 45

数据点数 n = 9

均值 μ = 45 / 9 = 5

2、计算方差（σ²） ：

使用总体方差公式（除以 n）：

方差 σ² = Σ(xi - μ)² / n

偏差平方和：

(3-5)² = 4, (4-5)² = 1, (5-5)² = 0, (6-5)² = 1, (1-5)² = 16, (7-5)² = 4, (8-5)² = 9, (9-5)² = 16, (2-5)² = 9

总和 = 4 + 1 + 0 + 1 + 16 + 4 + 9 + 16 + 9 = 60

方差 σ² = 60 / 9 = 6.6667

3、计算泊松指数 ：

泊松指数 = 方差 / 均值 = 6.6667 / 5 = 1.3333

精确值 = 4/3 ≈ 1.3333

2、样本熵的计算（很重要的一个指标），我们详细的记录一下：

1、通俗的概念：

样本熵 是一种用于衡量时间序列复杂性和规律性的指标。它的核心思想是：

"如果两个模式在短距离内相似，那么它们在更长距离内也应该保持相似"

直观理解

想象你有两段音乐旋律：

规律旋律：do-re-mi-fa-so-fa-mi-re-do

随机旋律：do-so-re-fa-mi-do-fa-re-so

对于规律旋律，如果你知道前几个音符，你很容易预测后面的音符。对于随机旋律，即使知道前几个音符，也很难预测后面的。

样本熵就是量化这种"不可预测性"的指标：

低样本熵 = 规律性强，容易预测

高样本熵 = 复杂性高，难以预测

数学定义（简化版）

样本熵的计算基于两个参数：

m：模式长度（通常为2）

r：相似性容限（通常为0.1-0.25倍的标准差）

例如这样分解数据：

复制代码

# 对于序列 [1, 2, 3, 4, 5] 和 m=2
向量X(1) = [1, 2]
向量X(2) = [2, 3] 
向量X(3) = [3, 4]
向量X(4) = [4, 5]

2、计算相似模式数量

1、对于每个m维向量，统计有多少其他m维向量与它的距离 ≤ r

2、同样统计m+1维向量的相似数量

3、样本熵公式

复制代码

SampleEn(m, r) = -ln( A / B )
其中：
B = m维相似模式的平均数量
A = (m+1)维相似模式的平均数量

假设有一组序列：

$1.0, 1.2, 1.0, 1.3, 1.1, 1.4$

步骤1：设置参数

m = 2
r = 0.2

步骤2：构建模式

m=2维模式：

复制代码

X1 = [1.0, 1.2]
X2 = [1.2, 1.0] 
X3 = [1.0, 1.3]
X4 = [1.3, 1.1]
X5 = [1.1, 1.4]

m+1=3维模式：

复制代码

Y1 = [1.0, 1.2, 1.0]
Y2 = [1.2, 1.0, 1.3]
Y3 = [1.0, 1.3, 1.1]
Y4 = [1.3, 1.1, 1.4]

详细的计算流程：

样本熵的计算步骤：

设定参数：m（模式长度）和 r（容限阈值）。通常m=2，r=0.1~0.25倍的标准差。

将时间序列拆分为长度为m的向量序列：X(1), X(2), ..., X(N-m+1)

定义距离d[X(i), X(j)]为两个向量对应元素的最大差值的绝对值。

对于每个i，统计d[X(i), X(j)] <= r 的j的个数（不包括i本身），记作B_i。

计算B = (1/(N-m)) * sum(B_i)

将m增加1，重复步骤2-5，得到A（其中A_i是m+1维向量的相似个数，然后A = (1/(N-m)) * sum(A_i)）

样本熵 = -ln(A/B)

注意：在计算A时，我们使用m+1，并且要求m+1维的向量在容限r内。

现在，我们使用m=2，r=0.2 * 标准差来计算。

首先，计算数据的基本信息：

数据: [1,2,8,10,3,5,6,8,1]

均值: (1+2+8+10+3+5+6+8+1)/9 = 44/9 ≈ 4.8889

标准差:

计算每个数据与均值的差的平方和，然后除以n-1，再开方。

方差 = [(1-4.8889)^2 + (2-4.8889)^2 + (8-4.8889)^2 + (10-4.8889)^2 + (3-4.8889)^2 + (5-4.8889)^2 + (6-4.8889)^2 + (8-4.8889)^2 + (1-4.8889)^2] / 8

= [15.1235 + 8.3457 + 9.6790 + 26.1235 + 3.5679 + 0.0123 + 1.2346 + 9.6790 + 15.1235] / 8

= 88.8889 / 8 = 11.1111

标准差 = sqrt(11.1111) ≈ 3.3333

取 r = 0.2 * 标准差 ≈ 0.6667

现在我们用m=2，r=0.6667来计算。

步骤1：构建m=2的向量

向量1: [1,2]

向量2: [2,8]

向量3: [8,10]

向量4: [10,3]

向量5: [3,5]

向量6: [5,6]

向量7: [6,8]

向量8: [8,1]

步骤2：计算距离并统计相似向量个数（不包括自身）

我们定义距离d为两个向量对应元素差值的绝对值的最大值。

以向量1 [1,2] 为例：

与向量2 [2,8]：距离 = max(|1-2|, |2-8|) = max(1,6)=6 > 0.6667 -> 不相似

与向量3 [8,10]：距离 = max(|1-8|,|2-10|)=max(7,8)=8 > 0.6667 -> 不相似

与向量4 [10,3]：距离 = max(|1-10|,|2-3|)=max(9,1)=9 -> 不相似

与向量5 [3,5]：距离 = max(|1-3|,|2-5|)=max(2,3)=3 -> 不相似

与向量6 [5,6]：距离 = max(|1-5|,|2-6|)=max(4,4)=4 -> 不相似

与向量7 [6,8]：距离 = max(|1-6|,|2-8|)=max(5,6)=6 -> 不相似

与向量8 [8,1]：距离 = max(|1-8|,|2-1|)=max(7,1)=7 -> 不相似

所以，对于向量1，没有相似的（除了自己，但我们不包括自己），所以B_1=0。

同样计算其他向量：

向量2 [2,8]：

与向量1：距离=6 -> 不相似

与向量3：max(|2-8|,|8-10|)=max(6,2)=6 -> 不相似

与向量4：max(|2-10|,|8-3|)=max(8,5)=8 -> 不相似

与向量5：max(|2-3|,|8-5|)=max(1,3)=3 -> 不相似

与向量6：max(|2-5|,|8-6|)=max(3,2)=3 -> 不相似

与向量7：max(|2-6|,|8-8|)=max(4,0)=4 -> 不相似

与向量8：max(|2-8|,|8-1|)=max(6,7)=7 -> 不相似

B_2=0

向量3 [8,10]：

与向量1：8 -> 不相似

与向量2：6 -> 不相似

与向量4：max(|8-10|,|10-3|)=max(2,7)=7 -> 不相似

与向量5：max(|8-3|,|10-5|)=max(5,5)=5 -> 不相似

与向量6：max(|8-5|,|10-6|)=max(3,4)=4 -> 不相似

与向量7：max(|8-6|,|10-8|)=max(2,2)=2 -> 不相似

与向量8：max(|8-8|,|10-1|)=max(0,9)=9 -> 不相似

B_3=0

向量4 [10,3]：

与向量1：9 -> 不相似

与向量2：8 -> 不相似

与向量3：7 -> 不相似

与向量5：max(|10-3|,|3-5|)=max(7,2)=7 -> 不相似

与向量6：max(|10-5|,|3-6|)=max(5,3)=5 -> 不相似

与向量7：max(|10-6|,|3-8|)=max(4,5)=5 -> 不相似

与向量8：max(|10-8|,|3-1|)=max(2,2)=2 -> 不相似

B_4=0

向量5 [3,5]：

与向量1：3 -> 不相似

与向量2：3 -> 不相似

与向量3：5 -> 不相似

与向量4：7 -> 不相似

与向量6：max(|3-5|,|5-6|)=max(2,1)=2 -> 不相似（因为2>0.6667）

与向量7：max(|3-6|,|5-8|)=max(3,3)=3 -> 不相似

与向量8：max(|3-8|,|5-1|)=max(5,4)=5 -> 不相似

B_5=0

向量6 [5,6]：

与向量1：4 -> 不相似

与向量2：3 -> 不相似

与向量3：4 -> 不相似

与向量4：5 -> 不相似

与向量5：2 -> 不相似

与向量7：max(|5-6|,|6-8|)=max(1,2)=2 -> 不相似

与向量8：max(|5-8|,|6-1|)=max(3,5)=5 -> 不相似

B_6=0

向量7 [6,8]：

与向量1：6 -> 不相似

与向量2：4 -> 不相似

与向量3：2 -> 不相似

与向量4：5 -> 不相似

与向量5：3 -> 不相似

与向量6：2 -> 不相似

与向量8：max(|6-8|,|8-1|)=max(2,7)=7 -> 不相似

B_7=0

向量8 [8,1]：

与向量1：7 -> 不相似

与向量2：7 -> 不相似

与向量3：9 -> 不相似

与向量4：2 -> 不相似

与向量5：5 -> 不相似

与向量6：5 -> 不相似

与向量7：7 -> 不相似

B_8=0

所以，所有B_i都是0，那么B=0。

但是，注意：我们通常要求r不能太小，否则可能没有匹配。这里r=0.6667，而数据之间的差异最小是1（比如[1,2]和[2,8]的差值最小是1），所以没有匹配是可能的。

因此，我们尝试调整r。通常r取0.2倍标准差，但这里标准差是3.33，0.2倍是0.6667，而数据是整数，且最小差值为1，所以我们需要增大r。

我们尝试将r设为1（即允许1以内的差异），再看一下。

用r=1，m=2：

向量1 [1,2]：

与向量2：距离=6 -> 不相似

与向量3：8 -> 不相似

与向量4：9 -> 不相似

与向量5：3 -> 不相似

与向量6：4 -> 不相似

与向量7：6 -> 不相似

与向量8：7 -> 不相似

B_1=0

同样，其他向量也都找不到距离<=1的，因为任意两个不同的向量，对应位置的差值至少有一个大于1。

所以我们再增大r，比如r=2。

用r=2，m=2：

向量1 [1,2]：

与向量2：6 -> 不相似

与向量3：8 -> 不相似

与向量4：9 -> 不相似

与向量5：3 -> 不相似

与向量6：4 -> 不相似

与向量7：6 -> 不相似

与向量8：7 -> 不相似

B_1=0

还是不行。我们注意到，这个序列的波动很大，相邻向量的距离都很大。

我们尝试计算整个序列中任意两个向量（m=2）的距离矩阵：

向量1: [1,2]

向量2: [2,8] -> 与向量1距离: max(1,6)=6

向量3: [8,10] -> 与向量1: max(7,8)=8; 与向量2: max(6,2)=6

向量4: [10,3] -> 与向量1: max(9,1)=9; 与向量2: max(8,5)=8; 与向量3: max(2,7)=7

向量5: [3,5] -> 与向量1: max(2,3)=3; 与向量2: max(1,3)=3; 与向量3: max(5,5)=5; 与向量4: max(7,2)=7

向量6: [5,6] -> 与向量1: max(4,4)=4; 与向量2: max(3,2)=3; 与向量3: max(3,4)=4; 与向量4: max(5,3)=5; 与向量5: max(2,1)=2

向量7: [6,8] -> 与向量1: max(5,6)=6; 与向量2: max(4,0)=4; 与向量3: max(2,2)=2; 与向量4: max(4,5)=5; 与向量5: max(3,3)=3; 与向量6: max(1,2)=2

向量8: [8,1] -> 与向量1: max(7,1)=7; 与向量2: max(6,7)=7; 与向量3: max(0,9)=9; 与向量4: max(2,2)=2; 与向量5: max(5,4)=5; 与向量6: max(3,5)=5; 与向量7: max(2,7)=7

我们发现，最小的距离是2（出现在向量6和向量5之间，向量7和向量3之间，向量7和向量6之间，向量8和向量4之间）。所以，如果r<2，那么不会有任何匹配。

因此，我们取r=2，再计算一次：

向量1：没有距离<=2的，B_1=0

向量2：没有距离<=2的，B_2=0

向量3：与向量7的距离=2 -> 相似，所以B_3=1

向量4：与向量8的距离=2 -> 相似，所以B_4=1

向量5：与向量6的距离=2 -> 相似，所以B_5=1

向量6：与向量5的距离=2 -> 相似，所以B_6=1

向量7：与向量3和向量6的距离都是2 -> 相似，所以B_7=2

向量8：与向量4的距离=2 -> 相似，所以B_8=1

所以，B_i的值：0,0,1,1,1,1,2,1

则 B = (0+0+1+1+1+1+2+1) / (9-2) = 7/7 = 1

现在，我们计算m=3的情况。

构建m=3的向量：

向量1: [1,2,8]

向量2: [2,8,10]

向量3: [8,10,3]

向量4: [10,3,5]

向量5: [3,5,6]

向量6: [5,6,8]

向量7: [6,8,1]

现在计算这些向量在r=2下的相似个数（注意：现在比较的是3个点）

向量1 [1,2,8]：

与向量2 [2,8,10]：距离=max(|1-2|,|2-8|,|8-10|)=max(1,6,2)=6 -> 不相似

与向量3 [8,10,3]：max(7,8,5)=8 -> 不相似

与向量4 [10,3,5]：max(9,1,3)=9 -> 不相似

与向量5 [3,5,6]：max(2,3,2)=3 -> 不相似

与向量6 [5,6,8]：max(4,4,0)=4 -> 不相似

与向量7 [6,8,1]：max(5,6,7)=7 -> 不相似

A_1=0

向量2 [2,8,10]：

与向量1：6 -> 不相似

与向量3：max(|2-8|,|8-10|,|10-3|)=max(6,2,7)=7 -> 不相似

与向量4：max(|2-10|,|8-3|,|10-5|)=max(8,5,5)=8 -> 不相似

与向量5：max(|2-3|,|8-5|,|10-6|)=max(1,3,4)=4 -> 不相似

与向量6：max(|2-5|,|8-6|,|10-8|)=max(3,2,2)=3 -> 不相似

与向量7：max(|2-6|,|8-8|,|10-1|)=max(4,0,9)=9 -> 不相似

A_2=0

向量3 [8,10,3]：

与向量1：8 -> 不相似

与向量2：7 -> 不相似

与向量4：max(|8-10|,|10-3|,|3-5|)=max(2,7,2)=7 -> 不相似

与向量5：max(|8-3|,|10-5|,|3-6|)=max(5,5,3)=5 -> 不相似

与向量6：max(|8-5|,|10-6|,|3-8|)=max(3,4,5)=5 -> 不相似

与向量7：max(|8-6|,|10-8|,|3-1|)=max(2,2,2)=2 -> 相似，所以A_3=1

向量4 [10,3,5]：

与向量1：9 -> 不相似

与向量2：8 -> 不相似

与向量3：7 -> 不相似

与向量5：max(|10-3|,|3-5|,|5-6|)=max(7,2,1)=7 -> 不相似

与向量6：max(|10-5|,|3-6|,|5-8|)=max(5,3,3)=5 -> 不相似

与向量7：max(|10-6|,|3-8|,|5-1|)=max(4,5,4)=5 -> 不相似

A_4=0

向量5 [3,5,6]：

与向量1：3 -> 不相似

与向量2：4 -> 不相似

与向量3：5 -> 不相似

与向量4：7 -> 不相似

与向量6：max(|3-5|,|5-6|,|6-8|)=max(2,1,2)=2 -> 相似，所以A_5=1

与向量7：max(|3-6|,|5-8|,|6-1|)=max(3,3,5)=5 -> 不相似

A_5=1

向量6 [5,6,8]：

与向量1：4 -> 不相似

与向量2：3 -> 不相似

与向量3：5 -> 不相似

与向量4：5 -> 不相似

与向量5：2 -> 相似，所以A_6=1

与向量7：max(|5-6|,|6-8|,|8-1|)=max(1,2,7)=7 -> 不相似

A_6=1

向量7 [6,8,1]：

与向量1：7 -> 不相似

与向量2：9 -> 不相似

与向量3：2 -> 相似，所以A_7=1

与向量4：5 -> 不相似

与向量5：5 -> 不相似

与向量6：7 -> 不相似

A_7=1

所以，A_i的值：0,0,1,0,1,1,1

则 A = (0+0+1+0+1+1+1) / (9-3) = 4/6 = 2/3

现在，我们计算样本熵：

样本熵 = -ln(A/B) = -ln( (2/3) / 1 ) = -ln(2/3) = -ln(0.6667) ≈ 0.4055

因此，这组数据的样本熵约为0.4055。

相似结果为1，不相似结果为0，然后取总数减去平均数。

利用公式：样本熵=-ln(A/B)

健康注意：

在房颤检测中的意义

心律类型	样本熵值	解释
正常窦性心律	低 (0.5-1.2)	心跳相对规律，模式可预测
房颤心律	高 (1.5-2.5+)	心跳完全不规则，模式复杂难预测
噪音/异常	异常高或低	数据质量问题

编程演示：

复制代码

import math

def simple_sample_entropy(data, m=2, r=0.2):
    """简化版样本熵计算"""
    if len(data) < m + 1:
        return 0
    
    # 计算标准差
    std = np.std(data)
    r_val = r * std
    
    def count_similar(vectors, template):
        """计算与模板向量相似的向量数量"""
        count = 0
        for vec in vectors:
            if max(abs(a - b) for a, b in zip(vec, template)) <= r_val:
                count += 1
        return count
    
    # 构建m维和m+1维向量
    vectors_m = [data[i:i+m] for i in range(len(data)-m)]
    vectors_m1 = [data[i:i+m+1] for i in range(len(data)-m-1)]
    
    # 计算B和A
    B = sum(count_similar(vectors_m, vec) for vec in vectors_m) / len(vectors_m)
    A = sum(count_similar(vectors_m1, vec) for vec in vectors_m1) / len(vectors_m1)
    
    if A == 0 or B == 0:
        return 0
    
    return -math.log(A / B)

# 测试
normal_rhythm = [1.0, 1.1, 1.0, 1.1, 1.0, 1.1]  # 规律心律
afib_rhythm = [1.0, 1.8, 0.9, 1.5, 1.1, 1.7]    # 房颤心律

print(f"正常心律样本熵: {simple_sample_entropy(normal_rhythm):.3f}")
print(f"房颤心律样本熵: {simple_sample_entropy(afib_rhythm):.3f}")

样本熵是一个无参数、稳健的复杂性度量，特别适合分析生理信号如心率变异性的规律性。在房颤检测中，高样本熵是重要的警示信号，表明心跳模式异常复杂和不规则。