用python进行小波包分解_pywt.waveletpacket

由于最近正好在学习用python进行小波分解，看的英文的pywt库的各种属性和方法及其使用示例，在这里记录下来，方便以后查阅，前面的小波分解部分忘了记录了，就只能从小波包分解开始了。
小波包：
首先导入pywt库：

>>> import pywt
1

一、创建小波包结构：
接下来我们实例化一个小波包对象：

>>> x = [1, 2, 3, 4, 5, 6, 7, 8]
>>> wp = pywt.WaveletPacket(data=x, wavelet='db1', mode='symmetric')
1
2

输入数据和分解系数（细节系数和逼近系数）都可以通过WaveletPacket.data得到：

>>> print(wp.data)
[1, 2, 3, 4, 5, 6, 7, 8]

1
2
3

小波包树的节点由路径标识。标识根节点的路径是’ ',根节点的分解层数为0。

>>> print(repr(wp.path))
''
>>> print(wp.level)
0

1
2
3
4
5

关于最大分解层数，如果构造函数中没有指定参数，则自动计算。

>>> print(wp['ad'].maxlevel)
3
1
2

二、遍历小波包树
获取子节点：

>>> x = [1, 2, 3, 4, 5, 6, 7, 8]
>>> wp = pywt.WaveletPacket(data=x, wavelet='db1', mode='symmetric')

1
2
3

首先要先检查最大分解层数：

>>> print(wp.maxlevel)
3

1
2
3

下面开始获取小波包树的子节点：

• 1st level

>>> print(wp['a'].data)
[  2.12132034   4.94974747   7.77817459  10.60660172]
>>> print(wp['a'].path)
a
1
2
3
4

• 2nd level

>>> print(wp['aa'].data)
[  5.  13.]
>>> print(wp['aa'].path)
aa
1
2
3
4

• 3rd level

>>> print(wp['aaa'].data)
[ 12.72792206]
>>> print(wp['aaa'].path)
aaa
1
2
3
4

以上，我们已经达到了最大分解层数，如果接着往下遍历会产生一个索引错误。

>>> print(wp['aaaa'].data)
Traceback (most recent call last):
...
IndexError: Path length is out of range.
1
2
3
4

现在我们尝试一下输入错误的路径：

>>> print(wp['ac'])
Traceback (most recent call last):
...
ValueError: Subnode name must be in ['a', 'd'], not 'c'.
1
2
3
4

产生一个value error。

获取子节点属性：

小波包树对象是一个树状结构，拥有一系列子节点对象。小波包只是节点类中的一个特殊子类。
小波包树的节点可以通过以下操作符来进行访问：obj[x] (Node.__ getitem__()).每一个节点都有一系列属性：data,path,node_name,parent,level,maxlevel 和 mode。

>>> x = [1, 2, 3, 4, 5, 6, 7, 8]
>>> wp = pywt.WaveletPacket(data=x, wavelet='db1', mode='symmetric')
1
2

>>> print(wp['ad'].data)
[-2. -2.]
1
2

>>> print(wp['ad'].path)
ad
1
2

>>> print(wp['ad'].node_name)
d
1
2

>>> print(wp['ad'].parent.path)
a
1
2

>>> print(wp['ad'].level)
2
1
2

>>> print(wp['ad'].maxlevel)
3
1
2

>>> print(wp['ad'].mode)
symmetric
1
2

提取符合条件的节点：

>>> x = [1, 2, 3, 4, 5, 6, 7, 8]
>>> wp = pywt.WaveletPacket(data=x, wavelet='db1', mode='symmetric')
1
2

我们可以按自然顺序得到特定层上的所有节点：

>>> print([node.path for node in wp.get_level(3, 'natural')])
['aaa', 'aad', 'ada', 'add', 'daa', 'dad', 'dda', 'ddd']
1
2

或者按频带频率进行排序：

>>> print([node.path for node in wp.get_level(3, 'freq')])
['aaa', 'aad', 'add', 'ada', 'dda', 'ddd', 'dad', 'daa']
1
2

注意，WaveletPacket.get_level()也会执行自动分解，直到达到指定的级别。

从小波包树重构信号：

>>> x = [1, 2, 3, 4, 5, 6, 7, 8]
>>> wp = pywt.WaveletPacket(data=x, wavelet='db1', mode='symmetric')
1
2

现在新建一个小波包树，并且给它的节点赋一些值。

>>> new_wp = pywt.WaveletPacket(data=None, wavelet='db1', mode='symmetric')

>>> new_wp['aa'] = wp['aa'].data
>>> new_wp['ad'] = [-2., -2.]

1
2
3
4
5
6

为了方便，也可以从节点对象中自动提取数据：

>>> new_wp['d'] = wp['d']
1

接下来，对aa，ad，d这三个节点包中的数据进行重构。

>>> print(new_wp.reconstruct(update=False))
[ 1.  2.  3.  4.  5.  6.  7.  8.]
1
2

如果reconstruct方法中的update参数被设置为False，那么根节点的数据将不会被更新。

>>> print(new_wp.data)
None
1
2

否则，根节点的data属性将被设置为重建后的数据。

>>> print(new_wp.reconstruct(update=True))
[ 1.  2.  3.  4.  5.  6.  7.  8.]
>>> print(new_wp.data)
[ 1.  2.  3.  4.  5.  6.  7.  8.]
1
2
3
4

>>> print([n.path for n in new_wp.get_leaf_nodes(False)])
['aa', 'ad', 'd']
1
2

>>> print([n.path for n in new_wp.get_leaf_nodes(True)])
['aaa', 'aad', 'ada', 'add', 'daa', 'dad', 'dda', 'ddd']
1
2

从小波包树中移除节点：

>>> x = [1, 2, 3, 4, 5, 6, 7, 8]
>>> wp = pywt.WaveletPacket(data=x, wavelet='db1', mode='symmetric')
1
2

首先，从一个二层的小波包树分解开始，树中的子节点是：

>>> dummy = wp.get_level(2)
>>> for n in wp.get_leaf_nodes(False):
...     print(n.path, format_array(n.data))
aa [  5.  13.]
ad [-2. -2.]
da [-1. -1.]
dd [ 0.  0.]
1
2
3
4
5
6
7

>>> node = wp['ad']
>>> print(node)
ad: [-2. -2.]
1
2
3

要从WP树中删除一个节点，可以使用Python的del obj[x] (node . __ delitem __):

>>> del wp['ad']
1

于是，树中剩余的节点为：

>>> for n in wp.get_leaf_nodes():
...     print(n.path, format_array(n.data))
aa [  5.  13.]
da [-1. -1.]
dd [ 0.  0.]
1
2
3
4
5

如果此时重构信号的话：

>>> print(wp.reconstruct())
[ 2.  3.  2.  3.  6.  7.  6.  7.]
1
2

现在恢复删除的节点及其对应的值：

>>> wp['ad'].data = node.data
1

打印叶子节点和重建后的信号，确认重构信号是正确的。

>>> for n in wp.get_leaf_nodes(False):
...     print(n.path, format_array(n.data))
aa [  5.  13.]
ad [-2. -2.]
da [-1. -1.]
dd [ 0.  0.]
1
2
3
4
5
6

>>> print(wp.reconstruct())
[ 1.  2.  3.  4.  5.  6.  7.  8.]
1
2

惰性求值
我的理解是：
Lazy evaluation(惰性求值)的意思是把一个表达式本身存储起来，并不进行求值。需要求值的时候再明确的让它求值。
如：(defparameter temp (+ 2 3))这种情况下，temp等于5
如果用Lazy, (defparameter temp (lazy (+ 2 3)) 这时temp等于一个表达式，再需要对它进行求值的时候用(force temp)把它evaluation。
它显而易见的好处是表达式只需要在需要的时候求值，可以避免了重复的计算。这个说法也不太准确，准确点的好处是在使用递归方法求值时避免了提前进行没有用到的求值。
注意：本节仅用于演示pywt的内部组件。不要依懒于本例中所示的对节点的属性访问。

>>> x = [1, 2, 3, 4, 5, 6, 7, 8]
>>> wp = pywt.WaveletPacket(data=x, wavelet='db1', mode='symmetric')
1
2

• 1 一开始wp的属性a是None。

>>> print(wp.a)
None
1
2

要记得千万不要依懒于这种属性访问方式。

• 2 .首先尝试访问节点，它是通过分解其父节点（wp对象本身）计算出来的。

>>> print(wp['a'])
a: [  2.12132034   4.94974747   7.77817459  10.60660172]
1
2

• 3 .现在wp的属性a已经被设置成了新创建的节点。

>>> print(wp.a)
a: [  2.12132034   4.94974747   7.77817459  10.60660172]
1
2

节点d也同样被设置成了新创建的节点。

>>> print(wp.d)
d: [-0.70710678 -0.70710678 -0.70710678 -0.70710678]

1
2
3