python算法之近似熵、互近似熵算法
理论基础
近似熵?
定义:近似熵是一个随机复杂度,反应序列相邻的m个点所连成折线段的模式的互相近似的概率与由m+1个点所连成的折线段的模式相互近似的概率之差。
作用:用来描述复杂系统的不规则性,越是不规则的时间序列对应的近似熵越大。反应维数改变时产生的新的模式的可能性的大小。
对于eeg信号来说,由于噪声存在、和信号的微弱性、多重信号源叠加,反映出来的是混沌属性,但是同一个人在大脑活动相对平稳的情况下,其eeg近似熵应该变化不大。
- 证明和对应几何意义可参考论文:https://wenku.baidu.com/view/4ec89e44b307e87101f696ef.html
互近似熵
- 从近似熵定义引申出来的,近似熵描述的是一段序列的自相似程度,互近似熵比较的是两段序列的复杂度接近程度;熵值越大越不相似,越小越相似;
近似熵算法分析
设存在一个以等时间间隔采样获得的m维的时间序列u(1),u(2),...,u(N).
定义相关参数维数m,一般取值为2,相似容限即阀值r,其中,维数表示向量的长度;r表示“相似度”的度量值.
重构m维向量X(1),X(2),...,X(N−m+1),其中X(i)=[u(i),u(i+1),...,u(i+m−1)],X(j)=[u(j),u(j+1),...,u(j+m−1)];计算X(i)和X(j)之间的距离,由对应元素的最大差值决定;d[X,X∗]=maxa|u(a)−u∗(a)|d[X,X∗]=maxa|u(a)−u∗(a)|
统计所有的d[X,X∗]<=r的个数g,则g/(N-M)就是本次的i取值对应的相似概率,计算所有i和j取值的概率对数的平均值,即熵值Φm(r);
取m+1重复3、4过程,计算近似熵:
ApEn=Φm(r)−Φm+1(r)
参数选择:通常选择参数m=2或m=3;通常选择r=0.2∗std,其中std表示原时间序列的标准差.
- 互近似熵计算和近似熵的步骤一样,把计算X(i)和X(j)之间的距离改为计算序列a的向量X(i)和序列b的向量Y(j)的距离;相似容限r为两个原序列的0.2倍协方差;
python代码实现
github源码
使用Pincus提出的近似熵定义计算近似熵
class BaseApEn(object):
"""
近似熵基础类
"""
def __init__(self, m, r):
"""
初始化
:param U:一个矩阵列表,for example:
U = np.array([85, 80, 89] * 17)
:param m: 子集的大小,int
:param r: 阀值基数,0.1---0.2
"""
self.m = m
self.r = r
@staticmethod
def _maxdist(x_i, x_j):
"""计算矢量之间的距离"""
return np.max([np.abs(np.array(x_i) - np.array(x_j))])
@staticmethod
def _biaozhuncha(U):
"""
计算标准差的函数
:param U:
:return:
"""
if not isinstance(U, np.ndarray):
U = np.array(U)
return np.std(U, ddof=1)
class ApEn(BaseApEn):
"""
Pincus提出的算法,计算近似熵的类
"""
def _biaozhunhua(self, U):
"""
将数据标准化,
获取平均值
所有值减去平均值除以标准差
"""
self.me = np.mean(U)
self.biao = self._biaozhuncha(U)
return np.array([(x - self.me) / self.biao for x in U])
def _dazhi(self, U):
"""
获取阀值
:param U:
:return:
"""
if not hasattr(self, "f"):
self.f = self._biaozhuncha(U) * self.r
return self.f
def _phi(self, m, U):
"""
计算熵值
:param U:
:param m:
:return:
"""
# 获取矢量列表
x = [U[i:i + m] for i in range(len(U) - m + 1)]
# 获取所有的比值列表
C = [len([1 for x_j in x if self._maxdist(x_i, x_j) <= self._dazhi(U)]) / (len(U) - m + 1.0) for x_i in x]
# 计算熵
return np.sum(np.log(list(filter(lambda a: a, C)))) / (len(U) - m + 1.0)
def _phi_b(self, m, U):
"""
标准化数据计算熵值
:param m:
:param U:
:return:
"""
# 获取矢量列表
x = [U[i:i + m] for i in range(len(U) - m + 1)]
# 获取所有的比值列表
C = [len([1 for x_j in x if self._maxdist(x_i, x_j) <= self.r]) / (len(U) - m + 1.0) for x_i in x]
# 计算熵
return np.sum(np.log(list(filter(lambda x: x, C)))) / (len(U) - m + 1.0)
def jinshishang(self, U):
"""
计算近似熵
:return:
"""
return np.abs(self._phi(self.m + 1, U) - self._phi(self.m, U))
def jinshishangbiao(self, U):
"""
将原始数据标准化后的近似熵
:param U:
:return:
"""
eeg = self._biaozhunhua(U)
return np.abs(self._phi_b(self.m + 1, eeg) - self._phi_b(self.m, eeg))
if __name__ == "__main__":
U = np.array([2, 4, 6, 8, 10] * 17)
G = np.array([3, 4, 5, 6, 7] * 17)
ap = ApEn(2, 0.2)
ap.jinshishang(U) # 计算近似熵
说明:
jinshishang函数直接计算近似熵
jinshishangbiao函数将原始数据标准化后计算近似熵
使用Pincus提出的近似熵定义计算互近似熵
class HuApEn(BaseApEn):
def _xiefangcha(self, U, G):
"""
计算协方差的函数
:param U: 序列1,矩阵
:param G: 序列2,矩阵
:return: 协方差,float
"""
if not isinstance(U, np.ndarray):
U = np.array(U)
if not isinstance(G, np.ndarray):
G = np.array(G)
if len(U) != len(G):
raise AttributeError('参数错误!')
return np.cov(U, G, ddof=1)[0, 1]
def _biaozhunhua(self, U, G):
"""
对数据进行标准化
"""
self.me_u = np.mean(U)
self.me_g = np.mean(G)
self.biao_u = self._biaozhuncha(U)
self.biao_g = self._biaozhuncha(G)
# self.biao_u = self._xiefangcha(U, G)
# self.biao_g = self._xiefangcha(U, G)
return np.array([(x - self.me_u) / self.biao_u for x in U]), np.array(
[(x - self.me_g) / self.biao_g for x in U])
def _dazhi(self, U, G):
"""
获取阀值
:param r:
:return:
"""
if not hasattr(self, "f"):
self.f = self._xiefangcha(U, G) * self.r
return self.f
def _phi(self, m, U, G):
"""
计算熵值
:param m:
:return:
"""
# 获取X矢量列表
x = [U[i:i + m] for i in range(len(U) - m + 1)]
# 获取y矢量列表
y = [G[g:g + m] for g in range(len(G) - m + 1)]
# 获取所有的条件概率列表
C = [len([1 for y_k in y if self._maxdist(x_i, y_k) <= self._dazhi(U, G)]) / (len(U) - m + 1.0) for x_i in x]
# 计算熵
return np.sum(np.log(list(filter(lambda x_1: x_1, C)))) / (len(U) - m + 1.0)
def _phi_b(self, m, U, G):
"""
标准化数据计算熵值
:param m:
:param U:
:return:
"""
# 获取X矢量列表
x = [U[i:i + m] for i in range(len(U) - m + 1)]
# 获取y矢量列表
y = [G[g:g + m] for g in range(len(G) - m + 1)]
# 获取所有的条件概率列表
C = [len([1 for y_k in y if self._maxdist(x_i, y_k) <= self.r]) / (len(U) - m + 1.0) for x_i in x]
# 计算熵
return np.sum(np.log(list(filter(lambda x: x, C)))) / (len(U) - m + 1.0)
def hujinshishang(self, U, G):
"""
计算互近似熵
:return:
"""
return np.abs(self._phi(self.m + 1, U, G) - self._phi(self.m, U, G))
def hujinshishangbiao(self, U, G):
"""
将原始数据标准化后的互近似熵
:param U:
:param G:
:return:
"""
u, g = self._biaozhunhua(U, G)
return np.abs(self._phi_b(self.m + 1, u, g) - self._phi_b(self.m, u, g))
使用洪波提出的快速实用算法计算近似熵
class NewBaseApen(object):
"""新算法基类"""
@staticmethod
def _get_array_zeros(x):
"""
创建N*N的0矩阵
:param U:
:return:
"""
N = np.size(x, 0)
return np.zeros((N, N), dtype=int)
@staticmethod
def _get_c(z, m):
"""
计算熵值的算法
:param z:
:param m:
:return:
"""
N = len(z[0])
# 概率矩阵C计算
c = np.zeros((1, N - m + 1))
if m == 2:
for j in range(N - m + 1):
for i in range(N - m + 1):
c[0, j] += z[j, i] & z[j + 1, i + 1]
if m == 3:
for j in range(N - m + 1):
for i in range(N - m + 1):
c[0, j] += z[j, i] & z[j + 1, i + 1] & z[j + 2, i + 2]
if m != 2 and m != 3:
raise AttributeError('m的取值不正确!')
data = list(filter(lambda x:x, c[0]/(N - m + 1.0)))
if not all(data):
return 0
return np.sum(np.log(data)) / (N - m + 1.0)
class NewApEn(ApEn, NewBaseApen):
"""
洪波等人提出的快速实用算法计算近似熵
"""
def _get_distance_array(self, U):
"""
获取距离矩阵
:param U:
:return:
"""
z = self._get_array_zeros(U)
fa = self._dazhi(U)
for i in range(len(z[0])):
z[i, :] = (np.abs(U - U[i]) <= fa) + 0
return z
def _get_shang(self, m, U):
"""
计算熵值
:param U:
:return:
"""
# 获取距离矩阵
Z = self._get_distance_array(U)
return self._get_c(Z, m)
def hongbo_jinshishang(self, U):
"""
计算近似熵
:param U:
:return:
"""
return np.abs(self._get_shang(self.m + 1, U) - self._get_shang(self.m, U))
使用洪波提出的快速实用算法计算互近似熵
class NewHuApEn(HuApEn, NewBaseApen):
"""
洪波等人提出的快速实用算法计算互近似熵
"""
def _get_distance_array(self, U, G):
"""
获取距离矩阵
:param U:模板数据
:return:比较数据
"""
z = self._get_array_zeros(U)
fa = self._dazhi(U, G)
for i in range(len(z[0])):
z[i, :] = (np.abs(G - U[i]) <= fa) + 0
return z
def _get_shang(self, m, U, G):
"""
计算熵值
:param U:
:return:
"""
# 获取距离矩阵
Z = self._get_distance_array(U, G)
return self._get_c(Z, m)
def hongbo_hujinshishang(self, U, G):
"""
对外的计算互近似熵的接口
:param U:
:param G:
:return:
"""
return np.abs(self._get_shang(self.m + 1, U, G) - self._get_shang(self.m, U, G))
简单测试
if __name__ == "__main__":
import time
import random
U = np.array([random.randint(0, 100) for i in range(1000)])
G = np.array([random.randint(0, 100) for i in range(1000)])
ap = NewApEn(2, 0.2)
ap1 = NewHuApEn(2, 0.2)
t = time.time()
print(ap.jinshishang(U))
t1 = time.time()
print(ap.hongbo_jinshishang(U))
t2 = time.time()
print(ap1.hujinshishang(U, G))
t3 = time.time()
print(ap1.hongbo_hujinshishang(U, G))
t4 = time.time()
print(t1-t)
print(t2-t1)
print(t3-t2)
print(t4-t3)
测试后发现使用快速算法比使用定义算法的计算效率提高了6倍以上。
参考:
- 作者:天宇之游
- 出处:http://www.cnblogs.com/cwp-bg/
- 本文版权归作者和博客园共有,欢迎转载、交流,但未经作者同意必须保留此段声明,且在文章明显位置给出原文链接。
python算法之近似熵、互近似熵算法的更多相关文章
- Python机器学习笔记:奇异值分解(SVD)算法
完整代码及其数据,请移步小编的GitHub 传送门:请点击我 如果点击有误:https://github.com/LeBron-Jian/MachineLearningNote 奇异值分解(Singu ...
- Python下探究随机数的产生原理和算法
资源下载 #本文PDF版下载 Python下探究随机数的产生原理和算法(或者单击我博客园右上角的github小标,找到lab102的W7目录下即可) #本文代码下载 几种随机数算法集合(和下文出现过的 ...
- Python 最大公约数的欧几里得算法及Stein算法
greatest common divisor(最大公约数) 1.欧几里得算法 欧几里德算法又称辗转相除法,用于计算两个正整数a,b的最大公约数. 其计算原理依赖于下面的定理: 两个整数的最大公约数等 ...
- 《算法4》2.1 - 选择排序算法(Selection Sort), Python实现
选择排序算法(Selection Sort)是排序算法的一种初级算法.虽然比较简单,但是基础,理解了有助于后面学习更高深算法,勿以勿小而不为. 排序算法的语言描述: 给定一组物体,根据他们的某种可量化 ...
- 熵(Entropy),交叉熵(Cross-Entropy),KL-松散度(KL Divergence)
1.介绍: 当我们开发一个分类模型的时候,我们的目标是把输入映射到预测的概率上,当我们训练模型的时候就不停地调整参数使得我们预测出来的概率和真是的概率更加接近. 这篇文章我们关注在我们的模型假设这些类 ...
- [转]熵(Entropy),交叉熵(Cross-Entropy),KL-松散度(KL Divergence)
https://www.cnblogs.com/silent-stranger/p/7987708.html 1.介绍: 当我们开发一个分类模型的时候,我们的目标是把输入映射到预测的概率上,当我们训练 ...
- Python的多继承问题-MRO和C3算法
大部分内容转载自C3 线性化算法与 MRO 理解Python中的多继承 Python 中的方法解析顺序(Method Resolution Order, MRO)定义了多继承存在时 Python 解释 ...
- Python小白的数学建模课-16.最短路径算法
最短路径问题是图论研究中的经典算法问题,用于计算图中一个顶点到另一个顶点的最短路径. 在图论中,最短路径长度与最短路径距离却是不同的概念和问题,经常会被混淆. 求最短路径长度的常用算法是 Dijkst ...
- C++、Java、Python、Linux、Go、前端、算法,慕课资料分享
C++.Java.Python.Linux.Go.前端.算法,慕课资料分享 微信公众号:大道同行JAVA 如有问题或建议,请后台留言,我会尽力解决你的问题. 前言 又见面了.废话不多说,最近多了一些在 ...
随机推荐
- 深入解析ThreadLocal类
先了解一下ThreadLocal类提供的几个方法: public T get() { } public void set(T value) { } public void remove() { } p ...
- 第209天:jQuery运动框架封装(二)
运动框架 一.函数------单物体运动框架封装 1.基于时间的运动原理 动画时间进程 动画距离进程 图解: 物体从0移动到400 当物体移动到200的时候 走了50% 同样的,物体总共运行需要4秒 ...
- H5跳转到百度地图并定位
找了半天的JS api,发现没有,后来发现这个叫 url api,让我好找. 官方文档: http://lbsyun.baidu.com/index.php?title=uri/api/web : 简 ...
- Guide: Solr performance tuning--转载
原文地址:http://h3x.no/2011/05/10/guide-solr-performance-tuning Introduction I have for the last year be ...
- BZOJ3637 Query on a tree VI(树链剖分+线段树)
考虑对于每一个点维护子树内与其连通的点的信息.为了换色需要,记录每个点黑白两种情况下子树内连通块的大小. 查询时,找到深度最浅的同色祖先即可,这可以比较简单的树剖+线段树乱搞一下(似乎就是qtree3 ...
- CF487E Tourists 【圆方树 + 树剖 + 堆】
题目链接 CF487E 题解 圆方树 + 树剖 裸题 建好圆方树维护路径上最小值即可 方点的值为其儿子的最小值,这个用堆维护 为什么只维护儿子?因为这样修改点的时候就只需要修改其父亲的堆 这样充分利用 ...
- Linux内核分析3
周子轩创作品转载请注明出处 <Linux内核分析>MOOC课程http://mooc.study.163.com/course/USTC-1000029000 gdb跟踪start_ke ...
- Linux内核设计第一周学习总结 计算机如何工作
北京电子科技学院 20135310陈巧然 原创作品转载请注明出处 <Linux内核分析>MOOC课程http://mooc.study.163.com/course/USTC-100002 ...
- bzoj2734:[HNOI2012]集合选数(状压DP)
菜菜的喵喵题~ 化序列为矩阵!化腐朽为神奇!左上角为1,往右每次*3,往下每次*2,这样子就把问题转化成了在矩阵里选不相邻的数有几种可能. 举个矩阵的例子 1 3 9 27 2 6 18 54 4 1 ...
- OpenCV C++如何使RGB图像变为灰度图像
http://m.blog.csdn.net/blog/u014395105/41308979 最近在研究如何用C++来处理图像,而不使用封装好的OpenCV代码,这样能够更好的了解OpenCV的内部 ...