Python时间序列异常检测ADTK

pip install adtk 
1.

stamps = pd.date_range("2012-10-08 18:15:05", periods=4, freq="D")  
# DatetimeIndex(['2012-10-08 18:15:05', '2012-10-09 18:15:05',  
#           '2012-10-10 18:15:05', '2012-10-11 18:15:05'],  
#          dtype='datetime64[ns]', freq='D') 
1.
2.
3.
4.

tmp = pd.Timestamp("2018-01-05") + pd.Timedelta("1 day")  
 print(tmp, tmp.timestamp(), tmp.strftime('%Y-%m-%d'))  
 # 2018-01-06 00:00:00 1515196800.0 2018-01-06  
 pd.Timestamp( tmp.timestamp(), unit='s', tz='Asia/Shanghai')  
 # Timestamp('2018-01-06 08:00:00+0800', tz='Asia/Shanghai') 
1.
2.
3.
4.
5.

import pandas as pd  
from adtk.data import validate_series  
from adtk.visualization import plot  
df = pd.read_csv('./data/nyc_taxi.csv', index_col="timestamp", parse_dates=True)  
df = validate_series(df)  
plot(df) 
1.
2.
3.
4.
5.
6.

import pandas as pd  
  from adtk.data import validate_series  
  from adtk.transformer import RollingAggregate  
  from adtk.transformer import DoubleRollingAggregate  
  s = pd.read_csv('./data/nyc_taxi.csv', index_col="timestamp", parse_dates=True)  
  s = validate_series(s)  
  s_transformed = RollingAggregate(agg='quantile',agg_params={"q": [0.25, 0.75]}, window=5).transform(s) 
1.
2.
3.
4.
5.
6.
7.

import pandas as pd  
from adtk.data import validate_series  
from adtk.transformer import DoubleRollingAggregate  
s = pd.read_csv('./data/ec2_cpu_utilization_53ea38.csv', index_col="timestamp", parse_dates=True)  
s = validate_series(s)  
s_transformed = DoubleRollingAggregate(  
    agg="median",  
    window=5,  
    diff="diff").transform(s) 
1.
2.
3.
4.
5.
6.
7.
8.
9.

from adtk.transformer import ClassicSeasonalDecomposition  
s = pd.read_csv('./data/nyc_taxi.csv', index_col="timestamp", parse_dates=True)  
s = validate_series(s) 
s_transformed = ClassicSeasonalDecomposition().fit_transform(s) 
1.
2.
3.
4.

s_transformed = ClassicSeasonalDecomposition(trend=True).fit_transform(s) 
1.

df = pd.read_csv('./data/generator.csv', index_col="Time", parse_dates=True)  
df = validate_series(df)  
from adtk.transformer import PcaProjection  
s = PcaProjection(k=1).fit_transform(df)  
plot(pd.concat([df, s], axis=1), ts_linewidth=1, ts_markersize=3, curve_group=[("Speed (kRPM)", "Power (kW)"), "pc0"]); 
1.
2.
3.
4.
5.

from adtk.transformer import PcaReconstruction  
df_transformed = PcaReconstruction(k=1).fit_transform(df).rename(columns={"Speed (kRPM)": "Speed reconstruction (kRPM)", "Power (kW)": "Power reconstruction (kW)"}) 
plot(pd.concat([df, df_transformed], axis=1), ts_linewidth=1, ts_markersize=3, curve_group=[("Speed (kRPM)", "Power (kW)"), ("Speed reconstruction (kRPM)", "Power reconstruction (kW)")]); 
../_images/notebooks_demo_99_0.png 
1.
2.
3.
4.

adtk.detector.ThresholdAD(low=None, high=None)  
 参数：  
 low：下限，小于此值，视为异常  
 high：上限，大于此值，视为异常  
 原理：通过认为设定上下限来识别异常  
 总结：固定阈值算法  
1.
2.
3.
4.
5.
6.

from adtk.detector import ThresholdAD  
threshold_ad = ThresholdAD(high=30, low=15)  
anomalies = threshold_ad.detect(s) 
1.
2.
3.

adtk.detector.QuantileAD(low=None, high=None)  
参数：  
low：分位下限，范围(0,1)，当low=0.25时，表示Q1  
high：分位上限，范围(0,1)，当low=0.25时，表示Q3  
原理：通过历史数据计算出给定low与high对应的分位值Q_low,Q_high，小于Q_low或大于Q_high，视为异常  
总结：分位阈值算法  
1.
2.
3.
4.
5.
6.

from adtk.detector import QuantileAD  
quantile_ad = QuantileAD(high=0.99, low=0.01)  
anomalies = quantile_ad.fit_detect(s) 
1.
2.
3.

adtk.detector.InterQuartileRangeAD(c=3.0)  
参数：  
c：分位距的系数，用来确定上下限，可为float，也可为(float,float)  
原理： 
当c为float时，通过历史数据计算出 Q3+c*IQR 作为上限值，大于上限值视为异常  
当c=(float1,float2)时，通过历史数据计算出 (Q1-c1*IQR, Q3+c2*IQR) 作为正常范围，不在正常范围视为异常  
总结：箱线图算法  
1.
2.
3.
4.
5.
6.
7.

from adtk.detector import InterQuartileRangeAD  
iqr_ad = InterQuartileRangeAD(c=1.5)  
anomalies = iqr_ad.fit_detect(s) 
1.
2.
3.

adtk.detector.GeneralizedESDTestAD(alpha=0.05)  
   参数：  
   alpha：显著性水平 (Significance level)，alpha越小，表示识别出的异常约有把握是真异常  
   原理:将样本点的值与样本的均值作差后除以样本标准差，取最大值，通过t分布计算阈值，对比阈值确定异常点  
   计算步骤简述：  
   设置显著水平alpha，通常取0.05  
   指定离群比例h，若h=5%，则表示50各样本中存在离群点数为2  
   计算数据集的均值mu与标准差sigma，将所有样本与均值作差，取绝对值，再除以标准差，找出最大值，得到esd_1  
   在剩下的样本点中，重复步骤3，可以得到h个esd值  
   为每个esd值计算critical value: lambda_i (采用t分布计算)  
   统计每个esd是否大于lambda_i，大于的认为你是异常  
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

from adtk.detector import GeneralizedESDTestAD  
esd_ad = GeneralizedESDTestAD(alpha=0.3)  
anomalies = esd_ad.fit_detect(s) 
1.
2.
3.

adtk.detector.PersistAD(window=1, c=3.0, side='both', min_periods=None, agg='median')  
   参数：  
   window：参考窗长度，可为int, str  
   c：分位距倍数，用于确定上下限范围  
   side：检测范围，为'positive'时检测突增，为'negative'时检测突降，为'both'时突增突降都检测  
   min_periods：参考窗中最小个数，小于此个数将会报异常，默认为None，表示每个时间点都得有值  
   agg：参考窗中的统计量计算方式，因为当前值是与参考窗中产生的统计量作比较，所以得将参考窗中的数据计算成统计量，默认'median'，表示去参考窗的中位值  
   原理：  
   用滑动窗口遍历历史数据，将窗口后的一位数据与参考窗中的统计量做差，得到一个新的时间序列s1;  
   计算s1的(Q1-c*IQR, Q3+c*IQR) 作为正常范围； 
   若当前值与它参考窗中的统计量之差，不在2中的正常范围内，视为异常。  
   调参：  
   window：越大，模型越不敏感，不容易被突刺干扰  
   c：越大，对于波动大的数据，正常范围放大较大，对于波动较小的数据，正常范围放大较小  
   min_periods：对缺失值的容忍程度，越大，越不允许有太多的缺失值  
   agg：统计量的聚合方式，跟统计量的特性有关，如 'median'不容易受极端值影响  
   总结：先计算一条新的时间序列，再用箱线图作异常检测  
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.

from adtk.detector import PersistAD  
persist_ad = PersistAD(c=3.0, side='positive')  
anomalies = persist_ad.fit_detect(s) 
1.
2.
3.

adtk.detector.LevelShiftAD(window, c=6.0, side='both', min_periods=None)  
 参数：  
 window：支持(10,5)，表示使用两个相邻的滑动窗，左侧的窗中的中位值表示参考值，右侧窗中的中位值表示当前值  
 c：越大，对于波动大的数据，正常范围放大较大，对于波动较小的数据，正常范围放大较小，默认6.0  
 side：检测范围，为'positive'时检测突增，为'negative'时检测突降，为'both'时突增突降都检测  
 min_periods：参考窗中最小个数，小于此个数将会报异常，默认为None，表示每个时间点都得有值  
 原理： 
 该模型用于检测突变情况，相比于PersistAD，其抗抖动能力较强，不容易出现误报  
1.
2.
3.
4.
5.
6.
7.
8.

from adtk.detector import LevelShiftAD  
level_shift_ad = LevelShiftAD(c=6.0, side='both', window=5)  
anomalies = level_shift_ad.fit_detect(s) 
1.
2.
3.

adtk.detector.SeasonalAD(freq=None, side='both', c=3.0, trend=False)  
SeasonalAD主要是根据ClassicSeasonalDecomposition来处理，判断。  
参数：  
freq：季节性周期  
c：越大，对于波动大的数据，正常范围放大较大，对于波动较小的数据，正常范围放大较小，默认6.0  
side：检测范围，为'positive'时检测突增，为'negative'时检测突降，为'both'时突增突降都检测  
trend： 是否考虑趋势      
1.
2.
3.
4.
5.
6.
7.

from adtk.detector import SeasonalAD  
      seasonal_ad = SeasonalAD(c=3.0, side="both")  
      anomalies = seasonal_ad.fit_detect(s)  
      plot(s, anomaly=anomalies, ts_markersize=1, anomaly_color='red', anomaly_tag="marker", anomaly_markersize=2); 
1.
2.
3.
4.

from adtk.pipe import Pipeline  
   steps = [  
       ("deseasonal", ClassicSeasonalDecomposition()),  
       ("quantile_ad", QuantileAD(high=0.995, low=0.005))  
   ] 
   pipeline = Pipeline(steps)  
   anomalies = pipeline.fit_detect(s)  
   plot(s, anomaly=anomalies, ts_markersize=1, anomaly_markersize=2, anomaly_tag="marker", anomaly_color='red'); 
1.
2.
3.
4.
5.
6.
7.
8.