pyts入门之时间序列的简单特征提取（一）

简介

pyts简单的说就是打包了多种时间序列分类和处理算法的类scikit-learn库，国内介绍该库的文档相对较少，所以本人打算开一个新坑，在学习的同时结合自身的理解介绍pyts库的主要api和功能。

那么在进入正题前先介绍一下pyts的基本概念，定义时间序列（x1,x2,x3…,xn)，如果一个时间序列只有一个特征，那么xi属于实数集R，该时间序列为单变量时间序列，如果一个时间序列有多个特征，那么xi属于R^d，d指维度，xi为一个d维向量，该时间序列为多元时间序列（比如一串GPS就有纬度和经度两个坐标特征）。

处理单个特征和多个特征的算法是不同的，pyts中提供的大多数算法适用于单个特征。此外在一个时间序列数据集中，会存在长度不等的时间序列和长度相等的时间序列，pyts中的算法也集中于处理长度相等的时间序列，至于长度不等的如前文介绍过的dtw算法就可以处理。

接下来介绍pyts的输入和输出。对于单个变量的时间序列，输入为(n个样本，n个时间戳），对于多个变量的时间序列，输入为（n个样本，n个特征，n个时间戳），对于分类的输出为，一维的0或1组成的向量。

此外可能有人会问，我们不能以传统的机器学习算法来进行时间序列的分类吗？答案是可以，比如启发式KNN就有不错的效果，但是关键点在于时间序列本身存在很高的自相关性，所以不适合用传统的机器学习算法来解决。

那么本节，我们将进行时间序列的特征工程的基础篇，Approximating time series（近似时间序列）。

实践

pip install pyts
或
conda install -c conda-forge pyts
或
git clone https://github.com/johannfaouzi/pyts.git
cd pyts
pip install .
#安装完后可pytest pyts测试能否正常运行

首先是安装环节，这个库的安装非常简单，虽然官方提供了三种方式，不过直接用pip安装是最快的。
安装好之后进入正题，第一篇，近似时间序列，也即对未处理的时间序列进行简单的数据预处理，在保留数据主要特征的同时清理掉数据中的噪声，当然，不同的算法对数据的基本要求是不一样的，怎么灵活的处理在这里就不讨论了，今天来介绍几种基本的处理方式。

方式一：Piecewise Aggregate Approximation（分段聚合近似)
理解：分段，或者说窗口，比如每两个时间点为一个窗口，再对该窗口进行聚合操作（Aggregate这个词最早在SQL数据库里接触到，聚合函数，即sum()，count()之类的），以此来逼近原始序列，具体是怎么样呢？
例子：

from pyts.approximation import PiecewiseAggregateApproximation
import matplotlib.pyplot as plt
import numpy as np
X = np.array([0, 4, 2, 1, 7, 6, 3, 5,2, 5, 4, 5, 3, 4, 2, 3])
n_timestamps = len(X) #时间戳长度就是有多少个数字
window_size = 2 #定义窗口大小为2
transformer = PiecewiseAggregateApproximation(window_size=window_size) #实例化
X_transform = transformer.transform(X.reshape(1,-1)) #转换
#print(x_transform)转换后结果
#array([[2. , 1.5, 6.5, 4. , 3.5, 4.5, 3.5, 2.5]])
#下面是作图部分
plt.plot(X,'o--',label='Original') #o--定义线条的style
plt.plot(np.arange(window_size // 2,n_timestamps + window_size // 2,window_size),X_transform[0],'o--',label='PAA') 
plt.legend(loc='best', fontsize=10) #loc='best'自动寻找最好的位置
plt.xlabel('Time', fontsize=12)
plt.title('Piecewise Aggregate Approximation', fontsize=16)
plt.vlines(np.arange(0, n_timestamps, window_size)-0.5, #-0.5往左移动看的清楚
           X.min(), X.max(), color='g', linestyles='--', linewidth=0.5) #图中的绿线

上面的窗口为2，所以每两个数字进行一次聚合，（0+4）/2 = 2，（2+1）/2=1.5…以此类推，把十六个数字的序列变成了八个数字，是不是非常简单？而且也可以发现它的使用方法和sklearn基本一致，都是先实例化一个class，然后调用继承的通用方法进行转换，十分简单。
图中也可以非常清晰的看到两个蓝色的点变成了一个橙色的点，也就是我们转换后的值，至于作图过程能注释的都注释了，此外新手在学习时要千万注意数组的shape，为什么在代码中要先X.reshape（1，-1），和为什么取x_transform[0]，这里就留给大家自己探索吧。

相关参数说明：
class pyts.approximation.PiecewiseAggregateApproximation(window_size=1, output_size=None, overlapping=True)

参数	说明
window_size=1	窗口大小默认为1，若为浮点数则为转换后百分比
output_size=None	返回时间序列的大小，如果定义了window_size则忽略该参数
overlapping=True	若为False，在一些情况下窗口大小是变化的

方法二：Symbolic Aggregate approximation（符号聚合近似）
理解：其实就是数据分箱，即把一串连续的数据转换为不同等级的数据。比如1,3,3,5,5,7就可以分为四个等级，A，B，C，D，一个数字代表一类，或者三个等级，A（1），B（3,5），C（7），或者两个等级，A（1,3），B（5,7）。
例子：

import numpy as np
import matplotlib.lines as mlines
import matplotlib.pyplot as plt
from scipy.stats import norm
from pyts.approximation import SymbolicAggregateApproximation
X = np.array([[0, 4, 2, 1, 7, 6, 3, 5],
               [2, 5, 4, 5, 3, 4, 2, 3]])
n_bins = 4
sax = SymbolicAggregateApproximation(n_bins=n_bins)
X_sax = sax.fit_transform(X)
#print(X_sax)
#array([['a', 'c', 'b', 'a', 'd', 'd', 'b', 'c'],
       #['a', 'd', 'c', 'd', 'b', 'c', 'a', 'b']], dtype='<U1')

可以看到它会根据每一条序列的数字大小来划分等级，在第一条序列中，a等级包含0和1，b等级包含2和3，c等级包含4和5，d等级包含6和7。而在第二条序列中，a等级包含2，b等级包含3，c等级包含4，d等级包含5。
可能有人问，既然是划分等级，为什么一定要用字母表示呢？其实这是因为我们可以用自然语言处理的一些手法来继续操作，比如词袋模型。

相关参数说明：
class pyts.approximation.SymbolicAggregateApproximation(n_bins=4, strategy=‘quantile’, raise_warning=True, alphabet=None)

参数	说明
n_bins : 4	整数，数据分箱的箱数，范围在2到（时间戳和26的最小值）之间
strategy : ‘uniform’, ‘quantile’ or ‘normal’ (默认是‘quantile’)	默认方法每个分箱中的数字数目是一样的，若为normal则服从标准正态分布 ，若为uniform，则分箱的宽度相同
raise_warning :True	若为False则没有分箱报错提醒
alphabet : None	如果为‘ordinal’，则使用整数，默认是字母表前N个字母，或者也可以传入自定义数组

方法三：Multiple Coefficient Binning（多重系数分箱）
理解：命名很玄乎，其实和方法二是类似的操作，只不过方法二是对一条条时间序列进行独立操作（横向），方法三是对一个个时间点进行独立操作（纵向）。

例子：

from pyts.approximation import MultipleCoefficientBinning
X = [[0, 4],
     [2, 7],
     [1, 6],
     [3, 5]]
transformer = MultipleCoefficientBinning(n_bins=4)
print(transformer.fit_transform(X))

#[['a' 'a']
 #['c' 'd']
 #['b' 'c']
 #['d' 'b']]

观察第一列的acbd和第二列的adcb，看懂了吗？其实这也是pyts输入的体现，这里再次强调一下，横轴是一条条样本，纵轴是一个个时间点，即（n_samples,n_timestamps)。

相关参数说明：
class pyts.approximation.MultipleCoefficientBinning(n_bins=4, strategy=‘quantile’, alphabet=None)

参数	说明
n_bins : 4	整数，数据分箱的箱数，范围在2到（时间戳和26的最小值）之间
strategy : ‘quantile’	默认方法每个分箱中的数字数目是一样的，若为normal则服从标准正态分布 ，若为uniform，则分箱的宽度相同，若为entropy，则用信息熵计算
alphabet : None	如果为‘ordinal’，则使用整数，默认是字母表前N个字母，或者也可以传入自定义数组

方法四：Discrete Fourier Transform（离散傅里叶变换）
理解：
具体怎么变换的可以参考这个公式，由欧拉公式推导而来。在pyts中主要是抽取傅里叶系数，即把K个时间点变换为你要的N个系数，从第一个系数到后面的系数，趋势含量越来越少，噪声含量越来越多，所以会选取前面的N个系数来代表趋势，忽略后面的噪声。

示例：

from pyts.approximation import DiscreteFourierTransform
from pyts.datasets import load_gunpoint
X, _, _, _ = load_gunpoint(return_X_y=True) #这里只用load x_train所以后面都为空
print(X.shape)
#(50, 150)
transformer = DiscreteFourierTransform(n_coefs=4)
X_new = transformer.fit_transform(X)
print(X_new.shape)
#(50, 4)

本示例中就把150个时间点压缩成为了4个系数，具体怎么压缩的看接下来的参数说明。

相关参数说明：
class pyts.approximation.DiscreteFourierTransform(n_coefs=None, drop_sum=False, anova=False, norm_mean=False, norm_std=False)

参数	说明
n_coefs=None	默认是保留全部的，即多少个时间点就有多少个系数，如果anova=True，同时设定了N个系数，那么会返回方差分析中前N个重要的系数，如果anova=False，则返回前N个系数。
drop_sum=False	如果为True，会drop第一个傅里叶系数
anova=False	如果为True，选取系数将通过单因素方差分析
norm_mean =False	如果为True，会中心化输入的序列
norm_std=False	如果为True，会进行单位方差的变换

方法五：Symbolic Fourier Approximation（符号傅里叶近似）
其实是方法三和方法四的组合，首先会通过离散傅里叶变换选取出前N个系数，再通过多重系数分箱来进行分箱。参数说明也是一模一样的组合，在这里就不多说了，直接调用pyts.approximation.SymbolicFourierApproximation即可。

相关资料参考

1.https://pyts.readthedocs.io/en/stable/modules/approximation.html
2.https://pyts.readthedocs.io/en/stable/auto_examples/approximation/plot_dft.html#sphx-glr-auto-examples-approximation-plot-dft-py
3.https://pyts.readthedocs.io/en/stable/generated/pyts.approximation.MultipleCoefficientBinning.html#pyts.approximation.MultipleCoefficientBinning
4.https://brilliant.org/wiki/discrete-fourier-transform/