精华内容
下载资源
问答
  • 2022-03-13 16:29:44

    转载于知乎:微调。

    异常检测(又称outlier detection、anomaly detection,离群值检测)是一种重要的数据挖掘方法可以找到与“主要数据分布”不同的异常值(deviant from the general data distribution),比如从信用卡交易中找出诈骗案例,从正常的网络数据流中找出入侵,有非常广泛的商业应用价值。同时它可以被用于机器学习任务中的预处理(preprocessing),防止因为少量异常点存在而导致的训练或预测失败。

    今天要介绍的工具库,**Python Outlier Detection(PyOD)**是当下最流行的Python异常检测工具库,其主要亮点包括:

    • 包括近20种常见的异常检测算法,比如经典的LOF/LOCI/ABOD以及最新的深度学习如对抗生成模型(GAN)和集成异常检测(outlier ensemble)
    • 支持不同版本的Python:包括2.7和3.5+;支持多种操作系统:windows,macOS和Linux
    • 简单易用且一致的API只需要几行代码就可以完成异常检测,方便评估大量算法
    • 使用JIT和并行化(parallelization)进行优化,加速算法运行及扩展性(scalability),可以处理大量数据

    从2018年5月正式发布以来,PyOD已经获得了超过300,000次下载2,500个GitHub Star,在所有GitHub数据挖掘(data mining)工具库[1]排名8 。**PyOD论文**也已经在 **Journal of Machine Learning Research (JMLR)**上发表。同时它也被运用于多项学术研究中[2][3][4][5][6],我也曾在回答中使用过PyOD:「数据挖掘中常见的「异常检测」算法有哪些?」。

    因为现阶段所有文档与实例全部为英文,为了方便大家使用,特别创作了这篇中文使用指南,欢迎转载(无需授权)

    1. 背景概览(package overview)

    PyOD提供了约20种异常检测算法(详见图1),部分算法介绍可以参考「数据挖掘中常见的「异常检测」算法有哪些?」或异常检测领域的经典教科书[7]。同时该工具库也包含了一系列辅助功能,包括数据可视化及结果评估等:

    img图1. PyOD中所包括的算法一栏

    工具库相关的重要信息汇总如下:

    PyOD提供两种非常简单的安装方法。我个人推荐使用pip进行安装:

    pip install pyod

    使用其包含的算法也很简单:每个算法均有相对应的例子,方便使用者学习了解API(示例文件夹),比如LOF算法的对应例子就叫做lof_example.py,非常容易找到。除此之外,作者还提供了**可互动的Jupyter Notebook示例**,无需安装,直接从浏览器打开notebook就可以尝试PyOD工具库。

    2. API介绍与实例(API References & Examples)

    特别需要注意的是,异常检测算法基本都是无监督学习,所以只需要X(输入数据),而不需要y(标签)。PyOD的使用方法和Sklearn中聚类分析很像,它的检测器(detector)均有统一的API。所有的PyOD检测器clf均有统一的API以便使用,完整的API使用参考可以查阅(API CheatSheet - pyod 0.6.8 documentation):

    • fit(X): 用数据X来“训练/拟合”检测器clf。即在初始化检测器clf后,用X来“训练”它。
    • fit_predict_score(X, y): 用数据X来训练检测器clf,并预测X的预测值,并在真实标签y上进行评估。此处的y只是用于评估,而非训练
    • decision_function(X): 在检测器clf被fit后,可以通过该函数来预测未知数据的异常程度,返回值为原始分数,并非0和1。返回分数越高,则该数据点的异常程度越高
    • predict(X): 在检测器clf被fit后,可以通过该函数来预测未知数据的异常标签,返回值为二分类标签(0为正常点,1为异常点)
    • predict_proba(X): 在检测器clf被fit后,预测未知数据的异常概率,返回该点是异常点概率

    当检测器clf被初始化且fit(X)函数被执行后,clf就会生成两个重要的属性:

    • decision_scores: 数据X上的异常打分,分数越高,则该数据点的异常程度越高
    • labels_: 数据X上的异常标签,返回值为二分类标签(0为正常点,1为异常点)

    不难看出,当我们初始化一个检测器clf后,可以直接用数据X来“训练”clf,之后我们便可以得到X的异常分值(clf.decision_scores)以及异常标签(clf.labels_)。当clf被训练后(当fit函数被执行后),我们可以使用decision_function()和predict()函数来对未知数据进行训练。

    在有了背景知识后,我们可以使用PyOD来实现一个简单的异常检测实例:

    from pyod.models.knn import KNN   # imprt kNN分类器
    
    # 训练一个kNN检测器
    clf_name = 'kNN'
    clf = KNN() # 初始化检测器clf
    clf.fit(X_train) # 使用X_train训练检测器clf
    
    # 返回训练数据X_train上的异常标签和异常分值
    y_train_pred = clf.labels_  # 返回训练数据上的分类标签 (0: 正常值, 1: 异常值)
    y_train_scores = clf.decision_scores_  # 返回训练数据上的异常值 (分值越大越异常)
    
    # 用训练好的clf来预测未知数据中的异常值
    y_test_pred = clf.predict(X_test)  # 返回未知数据上的分类标签 (0: 正常值, 1: 异常值)
    y_test_scores = clf.decision_function(X_test)  #  返回未知数据上的异常值 (分值越大越异常)
    

    不难看出,PyOD的API和scikit-learn非常相似,只需要几行就可以得到数据的异常值。当检测器得到输出后,我们可以用以下代码评估其表现,或者直接可视化分类结果(图2

    # 评估预测结果
    print("\nOn Test Data:")
    evaluate_print(clf_name, y_test, y_test_scores)
    
    # 可视化
    visualize(clf_name, X_train, y_train, X_test, y_test, y_train_pred,
        y_test_pred, show_figure=True, save_figure=False)
    

    img图2. 预测结果(右图)与真实结果(左图)对比

    3. 相关教程、资源与未来计划

    除此之外,不少网站都曾提供过如何使用PyOD的教程,比较权威的有:

    根据开发团队的计划(Todo & Contribution Guidance),很多后续功能会被逐步添加:

    • 支持GPU运算
    • 支持conda安装
    • 增加中文文档

    除此之外,开发团队也整理异常检测相关的资源汇总(课程、论文、数据等),非常值得关注:anomaly-detection-resources

    总结来看,PyOD是当下最为流行的异常检测工具库,且处于持续更新中。建议大家尝试、关注并参与到PyOD的开发当中。有鉴于功能可能会不断更新,请以GitHub版本为准。


    引用PyOD非常方便,可参考如下:

    Zhao, Y., Nasrullah, Z. and Li, Z., 2019. PyOD: A Python Toolbox for Scalable Outlier Detection. Journal of machine learning research (JMLR), 20(96), pp.1-7.
    

    或者

    @article{zhao2019pyod,
      author  = {Zhao, Yue and Nasrullah, Zain and Li, Zheng},
      title   = {PyOD: A Python Toolbox for Scalable Outlier Detection},
      journal = {Journal of Machine Learning Research},
      year    = {2019},
      volume  = {20},
      number  = {96},
      pages   = {1-7},
      url     = {http://jmlr.org/papers/v20/19-011.html}
    }
    

    参考

    1. ^https://github.com/topics/data-mining
    2. ^Ramakrishnan, J., Shaabani, E., Li, C. and Sustik, M.A., 2019. Anomaly Detection for an E-commerce Pricing System. arXiv preprint arXiv:1902.09566.
    3. ^Zhao, Y., Nasrullah, Z., Hryniewicki, M.K. and Li, Z., 2019, May. LSCP: Locally selective combination in parallel outlier ensembles. In Proceedings of the 2019 SIAM International Conference on Data Mining (pp. 585-593). Society for Industrial and Applied Mathematics.
    4. ^Ishii, Y. and Takanashi, M., 2019. Low-cost Unsupervised Outlier Detection by Autoencoders with Robust Estimation. Journal of Information Processing, 27, pp.335-339.
    5. ^Klaeger, T., Schult, A. and Oehm, L., 2019. Using anomaly detection to support classification of fast running (packaging) processes. arXiv preprint arXiv:1906.02473.
    6. ^Krishnan, S. and Wu, E., 2019. AlphaClean: Automatic Generation of Data Cleaning Pipelines. arXiv preprint arXiv:1904.11827.
    7. ^Aggarwal, C.C., 2015. Outlier analysis. In Data mining (pp. 237-263). Springer, Cham.
    更多相关内容
  • PyOD - 用于异常值检测的Python工具包(也称为异常检测) Python 异常值检测 (PyOD) 部署、文档和统计信息 构建状态、覆盖率、可维护性和许可证 PyOD 是一个全面且可扩展的 Python 工具包,用于检测多元数据中的外围...
  • 资源分类:Python库 所属语言:Python 资源全名:pyod-0.4.3.tar.gz 资源来源:官方 安装方法:https://lanzao.blog.csdn.net/article/details/101784059
  • 资源来自pypi官网。 资源全名:pyod-0.7.1.tar.gz
  • 资源来自pypi官网。 资源全名:pyod-0.4.0.tar.gz
  • 使用PyOD来进行异常值检测

    千次阅读 2021-07-25 11:29:42
    bagging import FeatureBagging from pyod.models.hbos import HBOS from pyod.models.iforest import IForest from pyod.models.knn import KNN from pyod.models.lof import LOF from pyod.models.mcd import MCD ...

    异常值检测主要是为了发现数据集中的一些"与众不同"的数据值,所谓“与众不同”的数据值是指这些数据与大多数数据存在较大的差异我们称之为“异常值”,并且在现实中这些“异常值”并没有被打上标签,因此我们必须通过某种算法来自动识别出这些异常值。对于异常值我们有如下的定义:

    1. 异常值所占整体数据的比例较少,产生异常值的概率非常低。
    2. 异常值本身的特征与其他正常值有明显的差异。

    数据

    在本篇博客中我们的数据来自于国外某连锁零售企业的客流量与订单数量统计数据,为了让数据更加清晰,我们只保留了如下3个字段:

    1. date:日期,
    2. num_people: 客流量,
    3. num_order: 订单数量量

    你可以在这里下载数据(点击下载这两个字)

    import pandas as pd
    import numpy as np
    from numpy import percentile
    import matplotlib
    import matplotlib.pyplot as plt
    import seaborn as sns
    sns.set_theme();
    sns.set_style("darkgrid",{"font.sans-serif":['simhei','Droid Sans Fallback']})
    from sklearn.ensemble import IsolationForest
    from sklearn.preprocessing import MinMaxScaler
    
    from pyod.models.abod import ABOD
    from pyod.models.cblof import CBLOF
    from pyod.models.feature_bagging import FeatureBagging
    from pyod.models.hbos import HBOS
    from pyod.models.iforest import IForest
    from pyod.models.knn import KNN
    from pyod.models.lof import LOF
    from pyod.models.mcd import MCD
    from pyod.models.ocsvm import OCSVM
    from pyod.models.pca import PCA
    from pyod.models.lscp import LSCP
    import warnings
    warnings.filterwarnings("ignore")
    df=pd.read_csv("order_num.csv")
    df

    过滤缺失值 

    除异常值以外,真实的数据中往往还会存在数据缺失的情况(即有些数据的值为NaN),对于缺失值一般会有2种处理方式比如:1.直接删除缺失值;2.对缺失值进行填充.对缺失值进行填充时一般会用均值或者使用某些插值算法插入一些符合数据历史趋势的数值。在这里我们使用最简单的方式即直接删除缺失值的方式来处理数据缺失,这样做的目的是让问题简单化。

    print("在 num_people 列中总共有 %d 个空值." % df['num_people'].isnull().sum())
    print("在 num_order 列中总共有 %d 个空值." % df['num_order'].isnull().sum())
    df=df[~df.num_people.isnull()==True]
    df=df[~df.num_order.isnull()==True]
    print("删除缺失值以后记录总数:",len(df))

     计算客流量、订单量数据分布

    print(df.num_people.describe())
    print()
    print(df.num_order.describe())
    plt.figure(figsize=(15,8), dpi=80)
    plt.subplot(221)
    sns.distplot(df['num_people']);
    
    plt.subplot(222)
    sns.distplot(df['num_order']);

     

     ​​​​​

     从分布上看客流量(num_people)明显严重右偏,右侧有长尾,并且我们看到客流量(num_people)的异常区域大致应该分布在上图的红圈范围内。而订单量数据呈现正太分布,异常值区域位于分布左右两侧。下面我们查看num_people的偏度(Skewness)与峰度(Kurtosis),偏度反应的是分布的偏斜程度,可能是左偏,右偏,长尾等形态,峰度反应分布的形状的胖瘦(宽窄),具体解释请参考这篇博客: https://blog.csdn.net/binbigdata/article/details/79897160

    print("num_people's Skewness: %f" % df['num_people'].skew())
    print("num_people's Kurtosis: %f " % df['num_people'].kurt())
    print()
    print("num_order's Skewness: %f" % df['num_order'].skew())
    print("num_order's Kurtosis: %f" % df['num_order'].kurt())

     

    IsolationForest(隔离森林)

    IsolationForest是一种简单有效的检测异常值的算法,它可以在数据的分布区域中找出异常值所在的区域,并对所有数据进行评分,那些落在异常区域的数据值会获得较低的分数,而那些不在异常区域中的数据将会获得较高的分数,大家可以参考这篇文章(https://dzone.com/articles/spotting-outliers-with-isolation-forest-using-skle )。在这篇文章中作者随机生成了两个正太分布N(-2,5)和N(2,5),同时通过隔离森林算法找到到了这两个分布中的异常区域,并且生成一条评分曲线,落在异常区域内的数据将会得到低分,落在异常区域内以外的数据将会获得高分:

    import numpy as np 
    import matplotlib.pyplot as plt 
    x = np.concatenate((np.random.normal(loc=-2, scale=.5,size=500), np.random.normal(loc=2, scale=.5, size=500)))
    
    isolation_forest = IsolationForest(n_estimators=100) 
    isolation_forest.fit(x.reshape(-1, 1)) 
    xx = np.linspace(-6, 6, 100).reshape(-1,1) 
    anomaly_score = isolation_forest.decision_function(xx) 
    outlier = isolation_forest.predict(xx)
    
    plt.figure(figsize=(10,8))
    plt.subplot(2,1,1)
    plt.hist(x) 
    plt.xlim([-5, 5]) 
    
    plt.subplot(2,1,2)
    plt.plot(xx, anomaly_score, label='异常值分数') 
    plt.fill_between(xx.T[0], np.min(anomaly_score), np.max(anomaly_score), where=outlier==-1, color='r', alpha=.4, label='异常值区域') 
    plt.legend() 
    plt.ylabel('异常值分数') 
    plt.xlabel('x') 
    plt.xlim([-5, 5]) 
    plt.show()

     

    使用隔离森林算法来监测客流量,订单量的异常值区域

    隔离森林是一种检测异常值的算法,使用IsolationForest算法返回每个样本的异常分数,该算法基于这样的思想:异常是少数和在特征上不同的数据点。隔离森林是一种基于树的模型。在这些树中,通过首先随机选择特征然后在所选特征的最小值和最大值之间选择随机分割值来创建分区。下面我们使用隔离森林算法来探测客流量与订单量的异常值区域,并生成评分曲线:

    #定义隔离森林
    IF1 = IsolationForest(n_estimators=100)
    #训练客流量数据
    IF1.fit(df['num_people'].values.reshape(-1, 1))
    #在客流量的最小值和最大值之间分割数据
    x1 = np.linspace(df['num_people'].min(), df['num_people'].max(), len(df)).reshape(-1,1)
    #生成所有数据的异常值分数
    anomaly_score1 = IF1.decision_function(x1)
    #预测异常值
    outlier1 = IF1.predict(x1)
    
    IF2 = IsolationForest(n_estimators=100)
    #训练订单量数据
    IF2.fit(df['num_order'].values.reshape(-1, 1))
    #在订单量的最小值和最大值之间分割数据
    x2 = np.linspace(df['num_order'].min(), df['num_order'].max(), len(df)).reshape(-1,1)
    #生成所有数据的异常值分数
    anomaly_score2 = IF2.decision_function(x2)
    #预测异常值
    outlier2 = IF2.predict(x2)
    
    plt.figure(figsize=(18,8))
    plt.subplot(2,2,1)
    sns.distplot(df['num_people'])
    
    plt.subplot(2,2,2)
    sns.distplot(df['num_order'])
    
    plt.subplot(2,2,3)
    plt.plot(x1, anomaly_score1, label='异常值分数')
    plt.fill_between(x1.T[0], np.min(anomaly_score1), np.max(anomaly_score1), 
                     where=outlier1==-1, color='r', 
                     alpha=.4, label='异常值区域')
    plt.legend()
    plt.ylabel('异常值分数')
    plt.xlabel('客流量(num_people)')
    
    plt.subplot(2,2,4)
    plt.plot(x2, anomaly_score2, label='异常值分数')
    plt.fill_between(x2.T[0], np.min(anomaly_score2), np.max(anomaly_score2), 
                     where=outlier2==-1, color='r', 
                     alpha=.4, label='异常值区域')
    plt.legend()
    plt.ylabel('异常值分数')
    plt.xlabel('订单量(num_order)')
    plt.show();

     

     

    在上图中隔离森林算法轻松的探测出来了客流量(num_people)与订单量(num_order)的异常值区域,并生成了评分曲线。当数据落在红色矩形区域内时将会得到较低的分数,而当数据落在红色矩形框的范围之外将会得到较高的分数。下面我们计算每个分布的异常值区域的边界值(上图红圈中的值)

    x1_outlier = x1[outlier1==-1]
    right_min=x1_outlier[x1_outlier>1000].min()
    left_max = x1_outlier[x1_outlier<1000].max()
    print('客流量异常值区域中左侧最大异常值为:',df[df.num_people<=left_max].num_people.max())
    print('客流量异常值区域中右侧最小异常值为:',df[df.num_people>=right_min].num_people.min())
    print()
    x2_outlier = x2[outlier2==-1]
    right_min=x2_outlier[x2_outlier>248].min()
    left_max = x2_outlier[x2_outlier<248].max()
    print('订单量异常值区域中左侧最大异常值为:',df[df.num_order<=left_max].num_order.max())
    print('订单量异常值区域中右侧最小异常值为:',df[df.num_order>=right_min].num_order.min())
    

     

    我们分别计算了客流量和订单量的异常值区域(红色区域)的边界值:
    客流量异常值所在区域:x<=459 和 x>=1508
    订单量异常值所在区域:x<=156 和 x>=357

    上述两个可视化结果显示了异常值分数并突出显示异常值所在的区域。从图中可见异常分数反映了基础分布的形状,异常区域对应于低概率区域。然而,到目前为止我们只是对客流量和订单量这两个单一变量分别进行了分析。如果我们仔细研究,可能会发现,由我们的模型确定的一些异常值只不过是数学统计上的异常,它可能并非是我们业务场景中的异常值,比如某些时候订单量很高可能是由于客流量很高所导致,它可能在统计分布上是异常值,但它在实际的业务场景中并不应该是异常值。下面我们同时观察客流量(num_people)和订单量(num_order)这两个变量的散点分布,并对客流量和订单量进行线性拟合,那些严重偏离拟合曲线的点,可以被认为是异常值,以这样的方式来判定异常值更符合实际的业务场景。

    plt.figure(figsize=(10,6), dpi=80)
    sns.regplot(data=df,x="num_people", y="num_order");

     

     当我们的数据不是单变量而是多维度变量时,异常检测的方法使得计算难道更高并且在数学上更复杂。

    关于PyOD

    PyOD 是一个全面且可扩展的Python 工具包,用于检测多维数据中的异常对象。这个令人兴奋但具有挑战性的领域通常被称为 异常值检测 或异常检测。

    PyOD 包括 30 多种检测算法,从经典的 LOF (SIGMOD 2000) 到最新的 COPOD (ICDM 2020)。自 2017 年以来,PyOD [ AZNL19 ]已成功应用于众多学术研究和商业产品[ AGSW19 , ALCJ+19 , AWDL+19 , AZNHL19 ]。它也得到了机器学习社区的广泛认可,有各种专门的帖子/教程,包括 Analytics Vidhya、 Towards Data Science、 KDnuggets、 Computer Vision News和 awesome-machine-learning。

    PyOD官方文档:https://pyod.readthedocs.io/en/latest/index.html

    本例中将会使用以下种类的异常探测模型:

    1.异常探测的线性模型

    PCA:主成分分析使用到特征向量超平面的加权投影距离之和作为异常值异常值)
    MCD:最小协方差行列式(使用马氏距离作为异常值)
    OCSVM:一类支持向量机

    2.基于邻近度的异常值检测模型

    LOF:局部异常因子
    CBLOF:基于聚类的局部异常值因子
    kNN:k Nearest Neighbors(使用到第k个最近邻居的距离作为异常值)
    Median kNN 异常值检测(使用到 k 个最近邻居的中值距离作为异常值分数)
    HBOS:基于直方图的异常值分数

    3.异常值检测的概率模型

    ABOD:基于角度的异常值检测

    4.使用集成分类(回归)器的异常检查模型

    Isolation Forest:隔离森林
    Feature Bagging:特征装袋
    LSCP

    使用PyOD 进行异常检测步骤

    • 数据缩放:将客流量和订单量标准化处理将其缩放到0到1之间。
    • 设置异常值比例: 根据经验将设置异常值比例设置为1%。
    • 初始化异常检查模型: 初始化12种异常检测模型。
    • 拟合数据:使用异常检测模型拟合数据并预测结果。
    • 判断异常值:使用阈值来判断数据点是正常值还是异常值。
    • 计算异常值分数:使用决策函数计算每个点的异常值分数。

    下面的代码参考了"比较所有已实现的离群值检测模型的例子"(https://github.com/yzhao062/pyod/blob/master/notebooks/Compare%20All%20Models.ipynb) 和"使用PyOD库在Python中学习异常检测的一个很棒的教程"(https://www.analyticsvidhya.com/blog/2019/02/outlier-detection-python-pyod/) 这两篇文章。

    对数据进行缩放

    将客流量和订单量标准化处理将其缩放到0到1之间

    #数据缩放
    cols = ['num_people', 'num_order']
    minmax = MinMaxScaler(feature_range=(0, 1))
    print(df[cols].head())
    print('--------------------------')
    df[['num_people','num_order']] = minmax.fit_transform(df[cols])
    print(df[cols].head())

    初始化异常值检测模型

    在这里我们将初始化常见的12种异常检测模型

    #设定异常值比例
    outliers_fraction = 0.01
    
    # 初始化 LSCP 探测集
    detector_list = [LOF(n_neighbors=5), LOF(n_neighbors=10), LOF(n_neighbors=15),
                     LOF(n_neighbors=20), LOF(n_neighbors=25), LOF(n_neighbors=30),
                     LOF(n_neighbors=35), LOF(n_neighbors=40), LOF(n_neighbors=45),
                     LOF(n_neighbors=50)]
    classifiers = {
        'Angle-based Outlier Detector (ABOD)':
            ABOD(contamination=outliers_fraction),
        'Cluster-based Local Outlier Factor (CBLOF)':
            CBLOF(contamination=outliers_fraction,
                  check_estimator=False, random_state=0),
        'Feature Bagging':
            FeatureBagging(LOF(n_neighbors=35),
                           contamination=outliers_fraction,
                           random_state=0),
        'Histogram-base Outlier Detection (HBOS)': HBOS(
            contamination=outliers_fraction),
        'Isolation Forest': IForest(contamination=outliers_fraction,
                                    random_state=0),
        'K Nearest Neighbors (KNN)': KNN(
            contamination=outliers_fraction),
        'Average KNN': KNN(method='mean',
                           contamination=outliers_fraction),
        'Local Outlier Factor (LOF)':
            LOF(n_neighbors=35, contamination=outliers_fraction),
        'Minimum Covariance Determinant (MCD)': MCD(
            contamination=outliers_fraction, random_state=0),
        'One-class SVM (OCSVM)': OCSVM(contamination=outliers_fraction),
        'Principal Component Analysis (PCA)': PCA(
            contamination=outliers_fraction, random_state=0),
        'Locally Selective Combination (LSCP)': LSCP(
            detector_list, contamination=outliers_fraction,
            random_state=0)
    }
    
    for i, clf in enumerate(classifiers.keys()):
        print('Model', i + 1, clf)

     

    计算异常值

    在这里我们要做的是拟合数据,预测异常和正常数据,计算异常值分数,最后进行可视化。

    #将num_people和num_order合并成一个两列的numpy数组
    X1= df['num_people'].values.reshape(-1,1)
    X2 = df['num_order'].values.reshape(-1,1)
    X = np.concatenate((X1,X2),axis=1)
    
    xx , yy = np.meshgrid(np.linspace(0, 1, 100), np.linspace(0, 1, 100))
    plt.figure(figsize=(20, 15))
    for i, (clf_name, clf) in enumerate(classifiers.items()):
        #训练数据
        clf.fit(X)
        # 预测异常值分数
        scores_pred = clf.decision_function(X) * -1
        # 预测异常值和正常值的数据
        y_pred = clf.predict(X)
        n_inliers = len(y_pred) - np.count_nonzero(y_pred)
        n_outliers = np.count_nonzero(y_pred == 1)
    
        df1 = df
        df1['outlier'] = y_pred.tolist()
        #过滤出num_people和num_order的正常值
        inliers_people = np.array(df1['num_people'][df1['outlier'] == 0]).reshape(-1,1)
        inliers_order = np.array(df1['num_order'][df1['outlier'] == 0]).reshape(-1,1)
    
        #过滤出num_people和num_order的异常值
        outliers_people = df1['num_people'][df1['outlier'] == 1].values.reshape(-1,1)
        outliers_order = df1['num_order'][df1['outlier'] == 1].values.reshape(-1,1)
            
        # 设定一个阈值用以识别正常值和异常值的标准
        threshold = np.percentile(scores_pred, 100 * outliers_fraction)
    
        #决策函数为每一个数据点计算异常值分数
        Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()]) * -1
        Z = Z.reshape(xx.shape)
        
        plt.subplot(3,4,i+1)
        #在图上对从最小的异常值分数到阈值的范围内进行分层着色
        plt.contourf(xx, yy, Z, levels=np.linspace(Z.min(), threshold, 7),cmap=plt.cm.Blues_r)
        #在异常值分数等于阈值处画红色线条
        a = plt.contour(xx, yy, Z, levels=[threshold],linewidths=2, colors='red')
        
        #填充橙色轮廓线,其中异常分数的范围是从阈值到最大异常分数
        plt.contourf(xx, yy, Z, levels=[threshold, Z.max()],colors='orange')
        b = plt.scatter(x=inliers_people, y=inliers_order, c='white',s=20, edgecolor='k')    
        c = plt.scatter(x=outliers_people, y=outliers_order, c='black',s=20, edgecolor='k')
           
        plt.axis('tight')   
        plt.legend([a.collections[0], b,c], ['决策函数', '正常值','异常值'],
                    prop=matplotlib.font_manager.FontProperties(size=12),loc='upper right')
    
        plt.xlim((0, 1))
        plt.ylim((0, 1))
        ss = '异常值数量: '+str(n_outliers)+' 正常值数量: '+str(n_inliers)
        plt.title(clf_name)
        plt.xlabel(ss)
    plt.show();

     

     

     参考资料

    CBLOF(Cluster-based Local Outlier Factor)

    CBLOF算法时基于聚类组的本地异常因子计算异常值分数。 CBLOF将数据集和由聚类算法生成的聚类模型作为输入。它使用参数alpha和beta将群集分为小群集和大群集。然后基于该点所属的聚类的大小以及到最近的大聚类的距离来计算异常分数。()

    HBOS(基于直方图的离群值检测)¶

    HBOS假设特征独立,并通过构建直方图来计算异常程度。 在多变量异常检测中,可以计算每个单个特征的直方图,单独评分并在最后组合。

    IsolationForest(隔离森林) 

    隔离森林其原理与随机森林类似,建立在决策树的基础上。 隔离林通过随机选择特征然后根据特征的最大值和最小值之间的分割值来隔离观察。 PyOD Isolation Forest模块() 是Scikit-learn Isolation Forest的wrapper,它具有更多功能。

    KNN(K - Nearest Neighbors)

    用于离群检测的pyod.models.knn.KNN,对于数据,它与第k个最近邻居的距离可以被视为异常值。

    关于异常值检测的博客文章

    Example of Comparing All Implemented Outlier Detection Models 

    An Awesome Tutorial to Learn Outlier Detection in Python using PyOD Library

     完整代码下载:

    https://github.com/tongzm/ml-python/blob/master/pyod%E5%BC%82%E5%B8%B8%E5%80%BC%E6%A3%80%E6%B5%8B.ipynb

     

    展开全文
  • PyOD - 用于异常值检测的Python工具包(也称为异常检测)
  • pyod(Python Outlier Detection)是一个集成了30余种异常检测方法和模型的Python工具箱。从经典的 LOF (SIGMOD 2000) 到近两年的 COPOD (ICDM 2020) 和 SUOD (MLSys 2021) 。 一、pyod概述 特性 丰富的模型,从 ...

    pyod(Python Outlier Detection)是一个集成了30余种异常检测方法和模型的Python工具箱。从经典的 LOF (SIGMOD 2000) 到近两年的 COPOD (ICDM 2020) 和 SUOD (MLSys 2021) 。

    GitHub官网:PyOD

    一、pyod概述

    特性

    • 丰富的模型,从 scikit-learn 中的经典算法,到近期的深度学习算法,以及诸如 COPOD 的新兴算法。
    • 兼容 Python2 和 Python3。
    • pyod对所涵盖的各种异常检测算法提供了统一的API,便于学习和使用。

    异常检测算法基本都是无监督学习,所以只需要X(输入数据),而不需要y(标签)

    PyOD的使用方法和Sklearn中聚类分析很像,它的检测器(detector)均有统一的API。

    二、PyOD模型使用

    所有的PyOD检测器clf均有统一的API以便使用,完整的API使用参考可以查阅(API CheatSheet - pyod 0.6.8 documentation):

    • fit(X): 用数据X来“训练/拟合”检测器clf。即在初始化检测器clf后,用X来“训练”它。
    • fit_predict_score(X, y): 用数据X来训练检测器clf,并预测X的预测值,并在真实标签y上进行评估。此处的y只是用于评估,而非训练
    • decision_function(X): 在检测器clf被fit后,可以通过该函数来预测未知数据的异常程度,返回值为原始分数,并非0和1。返回分数越高,则该数据点的异常程度越高
    • predict(X): 在检测器clf被fit后,可以通过该函数来预测未知数据的异常标签,返回值为二分类标签(0为正常点,1为异常点)
    • predict_proba(X): 在检测器clf被fit后,预测未知数据的异常概率,返回该点是异常点概率
      当检测器clf被初始化且fit(X)函数被执行后,clf就会生成两个重要的属性:
    • decision_scores: 数据X上的异常打分,分数越高,则该数据点的异常程度越高
    • labels_: 数据X上的异常标签,返回值为二分类标签(0为正常点,1为异常点)

    不难看出,当我们初始化一个检测器clf后,可以直接用数据X来“训练”clf,之后我们便可以得到X的异常分值(clf.decision_scores)以及异常标签(clf.labels_)。当clf被训练后(当fit函数被执行后),我们可以使用decision_function()和predict()函数来对未知数据进行训练。

    在有了背景知识后,我们可以使用PyOD来实现一个简单的异常检测实例:

    from pyod.models.knn import KNN   # imprt kNN分类器
    # 训练一个kNN检测器
    clf_name = 'kNN'
    clf = KNN() # 初始化检测器clf
    clf.fit(X_train) # 使用X_train训练检测器clf
    # 返回训练数据X_train上的异常标签和异常分值
    y_train_pred = clf.labels_  # 返回训练数据上的分类标签 (0: 正常值, 1: 异常值)
    y_train_scores = clf.decision_scores_  # 返回训练数据上的异常值 (分值越大越异常)
    # 用训练好的clf来预测未知数据中的异常值
    y_test_pred = clf.predict(X_test)  # 返回未知数据上的分类标签 (0: 正常值, 1: 异常值)
    y_test_scores = clf.decision_function(X_test)  #  返回未知数据上的异常值 (分值越大越异常)
    

    不难看出,PyOD的API和scikit-learn非常相似,只需要几行就可以得到数据的异常值。当检测器得到输出后,我们可以用以下代码评估其表现,或者直接可视化分类结果(图2)。

    # 评估预测结果
    print("\nOn Test Data:")
    evaluate_print(clf_name, y_test, y_test_scores)
    # 可视化
    visualize(clf_name, X_train, y_train, X_test, y_test, y_train_pred,
        y_test_pred, show_figure=True, save_figure=False)
    

    在这里插入图片描述

    三、PyOD算法库

    1、Individual Detection Algorithms

    TypeAbbrAlgorithmYearRef
    ProbabilisticECODUnsupervised Outlier Detection Using Empirical Cumulative Distribution Functions2022[22]
    ProbabilisticABODAngle-Based Outlier Detection2008[17]
    ProbabilisticFastABODFast Angle-Based Outlier Detection using approximation2008[17]
    ProbabilisticCOPODCOPOD: Copula-Based Outlier Detection2020[21]
    ProbabilisticMADMedian Absolute Deviation (MAD)1993[14]
    ProbabilisticSOSStochastic Outlier Selection2012[15]
    Linear ModelPCAPrincipal Component Analysis (the sum of weighted projected distances to the eigenvector hyperplanes)2003[32]
    Linear ModelMCDMinimum Covariance Determinant (use the mahalanobis distances as the outlier scores)1999[12] [29]
    Linear ModelCDUse Cook’s distance for outlier detection1977[9]
    Linear ModelOCSVMOne-Class Support Vector Machines2001[31]
    Linear ModelLMDDDeviation-based Outlier Detection (LMDD)1996[6]
    Proximity-BasedLOFLocal Outlier Factor2000[7]
    Proximity-BasedCOFConnectivity-Based Outlier Factor2002[33]
    Proximity-Based(Incremental) COFMemory Efficient Connectivity-Based Outlier Factor (slower but reduce storage complexity)2002[33]
    Proximity-BasedCBLOFClustering-Based Local Outlier Factor2003[13]
    Proximity-BasedLOCILOCI: Fast outlier detection using the local correlation integral2003[25]
    Proximity-BasedHBOSHistogram-based Outlier Score2012[10]
    Proximity-BasedkNNk Nearest Neighbors (use the distance to the kth nearest neighbor as the outlier score)2000[28]
    Proximity-BasedAvgKNNAverage kNN (use the average distance to k nearest neighbors as the outlier score)2002[5]
    Proximity-BasedMedKNNMedian kNN (use the median distance to k nearest neighbors as the outlier score)2002[5]
    Proximity-BasedSODSubspace Outlier Detection2009[18]
    Proximity-BasedRODRotation-based Outlier Detection2020[4]
    Outlier EnsemblesIForestIsolation Forest2008[23]
    Outlier EnsemblesFBFeature Bagging2005[19]
    Outlier EnsemblesLSCPLSCP: Locally Selective Combination of Parallel Outlier Ensembles2019[36]
    Outlier EnsemblesXGBODExtreme Boosting Based Outlier Detection (Supervised)2018[35]
    Outlier EnsemblesLODALightweight On-line Detector of Anomalies2016[26]
    Outlier EnsemblesSUODSUOD: Accelerating Large-scale Unsupervised Heterogeneous Outlier Detection (Acceleration)2021[37]
    Neural NetworksAutoEncoderFully connected AutoEncoder (use reconstruction error as the outlier score)[1] [Ch.3]
    Neural NetworksVAEVariational AutoEncoder (use reconstruction error as the outlier score)2013[16]
    Neural NetworksBeta-VAEVariational AutoEncoder (all customized loss term by varying gamma and capacity)2018[8]
    Neural NetworksSO_GAALSingle-Objective Generative Adversarial Active Learning2019[24]
    Neural NetworksMO_GAALMultiple-Objective Generative Adversarial Active Learning2019[24]
    Neural NetworksDeepSVDDDeep One-Class Classification2018[30]

    2、Outlier Ensembles & Outlier Detector Combination Frameworks

    TypeAbbrAlgorithmYearRef
    Outlier EnsemblesFeature Bagging2005[19]
    Outlier EnsemblesLSCPLSCP: Locally Selective Combination of Parallel Outlier Ensembles2019[36]
    Outlier EnsemblesXGBODExtreme Boosting Based Outlier Detection (Supervised)2018[35]
    Outlier EnsemblesLODALightweight On-line Detector of Anomalies2016[26]
    Outlier EnsemblesSUODSUOD: Accelerating Large-scale Unsupervised Heterogeneous Outlier Detection (Acceleration)2021[37]
    CombinationAverageSimple combination by averaging the scores2015[2]
    CombinationWeighted AverageSimple combination by averaging the scores with detector weights2015[2]
    CombinationMaximizationSimple combination by taking the maximum scores2015[2]
    CombinationAOMAverage of Maximum2015[2]
    CombinationMOAMaximization of Average2015[2]
    CombinationMedianSimple combination by taking the median of the scores2015[2]
    Combinationmajority VoteSimple combination by taking the majority vote of the labels (weights can be used)2015[2]

    3、Utility Functions

    TypeNameFunctionDocumentation
    Datagenerate_dataSynthesized data generation; normal data is generated by a multivariate Gaussian and outliers are generated by a uniform distributiongenerate_data
    Datagenerate_data_clustersSynthesized data generation in clusters; more complex data patterns can be created with multiple clustersgenerate_data_clusters
    StatwpearsonrCalculate the weighted Pearson correlation of two sampleswpearsonr
    Utilityget_label_nTurn raw outlier scores into binary labels by assign 1 to top n outlier scoresget_label_n
    Utilityprecision_n_scorescalculate precision @ rank nprecision_n_scores

    四、代码及效果图

    #!/usr/bin/env python
    # -*- encoding: utf-8 -*-
    """
    @File    :   outlierDetection.py    
    @Modify Time      @Author    @Version    @Description
    ------------      -------    --------    -----------
    2021/8/12 14:06   SeafyLiang   1.0       离群点检测pyod
    """
    import numpy as np
    from scipy import stats
    import matplotlib.pyplot as plt
    import matplotlib.font_manager
    # 检测数据集中异常值的模型
    from pyod.models.abod import ABOD
    from pyod.models.cblof import CBLOF
    # from pyod.models.feature_bagging import FeatureBagging
    from pyod.models.hbos import HBOS
    from pyod.models.iforest import IForest
    from pyod.models.knn import KNN
    # from pyod.models.loci import LOCI
    # from pyod.models.sod import SOD
    from pyod.models.lof import LOF
    from pyod.models.mcd import MCD
    from pyod.models.ocsvm import OCSVM
    from pyod.models.pca import PCA
    from pyod.utils.data import generate_data, get_outliers_inliers
    
    """
    参考资料:
    https://blog.csdn.net/weixin_41697507/article/details/89408236
    https://blog.csdn.net/sparkexpert/article/details/81195418
    https://github.com/yzhao062/Pyod#ramaswamy2000efficient
    """
    
    # 创建一个带有异常值的随机数据集并绘制它
    # generate random data with two features
    X_train, Y_train = generate_data(n_train=200, train_only=True, n_features=2)
    # by default the outlier fraction is 0.1 in generate data function
    outlier_fraction = 0.1
    # store outliers and inliers in different numpy arrays
    x_outliers, x_inliers = get_outliers_inliers(X_train, Y_train)
    n_inliers = len(x_inliers)
    n_outliers = len(x_outliers)
    # separate the two features and use it to plot the data
    F1 = X_train[:, [0]].reshape(-1, 1)
    F2 = X_train[:, [1]].reshape(-1, 1)
    # create a meshgrid
    xx, yy = np.meshgrid(np.linspace(-10, 10, 200), np.linspace(-10, 10, 200))
    # scatter plot
    plt.scatter(F1, F2)
    plt.xlabel('F1')
    plt.ylabel('F2')
    plt.show()
    
    """
    Model 1 Angle-based Outlier Detector (ABOD)
    Model 2 Cluster-based Local Outlier Factor (CBLOF)
    Model 3 Feature Bagging
    Model 4 Histogram-base Outlier Detection (HBOS)
    Model 5 Isolation Forest
    Model 6 K Nearest Neighbors (KNN)
    Model 7 Fast outlier detection using the local correlation integral(LOCI)
    Model 8 Subspace Outlier Detection (SOD)
    Model 9 Local Outlier Factor (LOF)
    Model 10 Minimum Covariance Determinant (MCD)
    Model 11 One-class SVM (OCSVM)
    Model 12 Principal Component Analysis (PCA)
    """
    # 创建一个dictionary并添加要用于检测异常值的所有模型
    classifiers = {
        'ABOD': ABOD(contamination=outlier_fraction),
        'CBLOF': CBLOF(contamination=outlier_fraction),
        # 'Feature Bagging': FeatureBagging(contamination=outlier_fraction),
        'HBOS': HBOS(contamination=outlier_fraction),
        'IForest': IForest(contamination=outlier_fraction),
        'KNN': KNN(contamination=outlier_fraction),
        # 'LOCI': LOCI(contamination=outlier_fraction, ),
        # 'SOD': SOD(contamination=outlier_fraction, ),
        'LOF': LOF(contamination=outlier_fraction, ),
        'MCD': MCD(contamination=outlier_fraction, ),
        'OCSVM': OCSVM(contamination=outlier_fraction, ),
        'PCA': PCA(contamination=outlier_fraction, ),
    
    }
    # 将数据拟合到我们在dictionary中添加的每个模型,然后,查看每个模型如何检测异常值
    # set the figure size
    
    plt.figure(figsize=(10, 10))
    for i, (clf_name, clf) in enumerate(classifiers.items()):
        print()
        print(i + 1, 'fitting', clf_name)
        # fit the data and tag outliers
        clf.fit(X_train)
        scores_pred = clf.decision_function(X_train) * -1
        y_pred = clf.predict(X_train)
        threshold = stats.scoreatpercentile(scores_pred,
                                            100 * outlier_fraction)
        n_errors = (y_pred != Y_train).sum()
        # plot the levels lines and the points
    
        Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()]) * -1
        Z = Z.reshape(xx.shape)
        subplot = plt.subplot(3, 4, i + 1)
        subplot.contourf(xx, yy, Z, levels=np.linspace(Z.min(), threshold, 7),
                         cmap=plt.cm.Blues_r)
        a = subplot.contour(xx, yy, Z, levels=[threshold],
                            linewidths=2, colors='red')
        subplot.contourf(xx, yy, Z, levels=[threshold, Z.max()],
                         colors='orange')
        b = subplot.scatter(X_train[:-n_outliers, 0], X_train[:-n_outliers, 1], c='white',
                            s=20, edgecolor='k')
        c = subplot.scatter(X_train[-n_outliers:, 0], X_train[-n_outliers:, 1], c='black',
                            s=20, edgecolor='k')
        subplot.axis('tight')
        subplot.legend(
            [a.collections[0], b, c],
            ['learned decision function', 'true inliers', 'true outliers'],
            prop=matplotlib.font_manager.FontProperties(size=10),
            loc='lower right')
        subplot.set_xlabel("%d. %s (errors: %d)" % (i + 1, clf_name, n_errors))
        subplot.set_xlim((-7, 7))
        subplot.set_ylim((-7, 7))
    plt.show()
    

    在这里插入图片描述
    在这里插入图片描述




    参考资料:
    异常点检测算法工具库(pyod)介绍+代码
    Python异常检测工具箱——pyod
    SUOD: Accelerating Large-scare Unsupervised Heterogeneous Outlier Detection
    Yue Zhao-赵越首页
    离群点异常检测及可视化分析工具pyod测试
    Welcome to PyOD documentation!
    异常检测算法

    展开全文
  • 异常点检测算法工具库(pyod)一、PyOD介绍二、PyOD主要亮点三、工具库相关重要信息汇总:四、作者介绍:五、API介绍与实例(API References & Examples)六、代码及效果图6.1 代码6.2 效果图 项目地址: ...

    项目地址
    https://github.com/yzhao062/Pyod#ramaswamy2000efficient
    参考资料
    知乎-用PyOD工具库进行「异常检测」
    使用PyOD库在Python中进行离群值检测
    PyOD在线文档
    CSDN-离群点异常检测及可视化分析工具pyod测试

    一、PyOD介绍

    异常检测(又称outlier detection、anomaly detection,离群值检测)是一种重要的数据挖掘方法,可以找到与“主要数据分布”不同的异常值(deviant from the general data distribution),比如从信用卡交易中找出诈骗案例,从正常的网络数据流中找出入侵,有非常广泛的商业应用价值。同时它可以被用于机器学习任务中的预处理(preprocessing),防止因为少量异常点存在而导致的训练或预测失败。

    二、PyOD主要亮点

    ● 包括近20种常见的异常检测算法,比如经典的LOF/LOCI/ABOD以及最新的深度学习如对抗生成模型(GAN)和集成异常检测(outlier ensemble)
    ● 支持不同版本的Python:包括2.7和3.5+;支持多种操作系统:windows,macOS和Linux
    ● 简单易用且一致的API,只需要几行代码就可以完成异常检测,方便评估大量算法
    ● 使用JIT和并行化(parallelization)进行优化,加速算法运行及扩展性(scalability),可以处理大量数据

    三、工具库相关重要信息汇总:

    ● Github地址: pyod
    ● PyPI下载地址: pyod
    ● 文档与API介绍(英文): Welcome to PyOD documentation!
    ● Jupyter Notebook示例(notebooks文件夹): Binder (beta)
    ● JMLR论文: PyOD: A Python Toolbox for Scalable Outlier Detection

    四、作者介绍:

    在这里插入图片描述

    微调
    数据挖掘 | 机器学习系统 | 前咨询师 | 在读博士
    职业经历:
    斯坦福大学 (Stanford University) · Visiting Student Researcher
    艾昆纬 (IQVIA) · machine learning research intern
    普华永道 · 高级数据科学家
    教育经历:
    卡内基梅隆大学 (Carnegie Mellon University) · 信息系统
    多伦多大学 (University of Toronto) · 计算机科学
    辛辛那提大学 · 计算机工程(CE)
    山西省实验中学
    个人简介

    1. 机器学习系统架构师,参与设计了10个工具库/系统,GitHub Star>10000,下载量>300,0000
    2. 生物制药 x 机器学习: https://github.com/mims-harvard/TDC
    3. 大规模异常检测模型 SUOD:https://github.com/yzhao062/suod
    4. PyOD异常检测工具库:https://github.com/yzhao062/pyod
    5. 个人主页:https://www.andrew.cmu.edu/user/yuezhao2
    6. GayHub: https://github.com/yzhao062
    7. Google Scholar: https://scholar.google.com/cita

    五、API介绍与实例(API References & Examples)

    Examples可下载github项目中查看和运行。
    在这里插入图片描述
    特别需要注意的是,异常检测算法基本都是无监督学习,所以只需要X(输入数据),而不需要y(标签)。PyOD的使用方法和Sklearn中聚类分析很像,它的检测器(detector)均有统一的API。所有的PyOD检测器clf均有统一的API以便使用,完整的API使用参考可以查阅(API CheatSheet - pyod 0.6.8 documentation):

    • fit(X): 用数据X来“训练/拟合”检测器clf。即在初始化检测器clf后,用X来“训练”它。
    • fit_predict_score(X, y): 用数据X来训练检测器clf,并预测X的预测值,并在真实标签y上进行评估。此处的y只是用于评估,而非训练
    • decision_function(X): 在检测器clf被fit后,可以通过该函数来预测未知数据的异常程度,返回值为原始分数,并非0和1。返回分数越高,则该数据点的异常程度越高
    • predict(X): 在检测器clf被fit后,可以通过该函数来预测未知数据的异常标签,返回值为二分类标签(0为正常点,1为异常点)
    • predict_proba(X): 在检测器clf被fit后,预测未知数据的异常概率,返回该点是异常点概率
      当检测器clf被初始化且fit(X)函数被执行后,clf就会生成两个重要的属性:
    • decision_scores: 数据X上的异常打分,分数越高,则该数据点的异常程度越高
    • labels_: 数据X上的异常标签,返回值为二分类标签(0为正常点,1为异常点)
      不难看出,当我们初始化一个检测器clf后,可以直接用数据X来“训练”clf,之后我们便可以得到X的异常分值(clf.decision_scores)以及异常标签(clf.labels_)。当clf被训练后(当fit函数被执行后),我们可以使用decision_function()和predict()函数来对未知数据进行训练。
      在有了背景知识后,我们可以使用PyOD来实现一个简单的异常检测实例:
    from pyod.models.knn import KNN   # imprt kNN分类器
    # 训练一个kNN检测器
    clf_name = 'kNN'
    clf = KNN() # 初始化检测器clf
    clf.fit(X_train) # 使用X_train训练检测器clf
    # 返回训练数据X_train上的异常标签和异常分值
    y_train_pred = clf.labels_  # 返回训练数据上的分类标签 (0: 正常值, 1: 异常值)
    y_train_scores = clf.decision_scores_  # 返回训练数据上的异常值 (分值越大越异常)
    # 用训练好的clf来预测未知数据中的异常值
    y_test_pred = clf.predict(X_test)  # 返回未知数据上的分类标签 (0: 正常值, 1: 异常值)
    y_test_scores = clf.decision_function(X_test)  #  返回未知数据上的异常值 (分值越大越异常)
    

    不难看出,PyOD的API和scikit-learn非常相似,只需要几行就可以得到数据的异常值。当检测器得到输出后,我们可以用以下代码评估其表现,或者直接可视化分类结果(图2)。

    # 评估预测结果
    print("\nOn Test Data:")
    evaluate_print(clf_name, y_test, y_test_scores)
    # 可视化
    visualize(clf_name, X_train, y_train, X_test, y_test, y_train_pred,
        y_test_pred, show_figure=True, save_figure=False)
    

    在这里插入图片描述

    六、代码及效果图

    6.1 代码

    #!/usr/bin/env python
    # -*- encoding: utf-8 -*-
    """
    @File    :   outlierDetection.py    
    @Modify Time      @Author    @Version    @Description
    ------------      -------    --------    -----------
    2021/8/12 14:06   SeafyLiang   1.0       离群点检测pyod
    """
    import numpy as np
    from scipy import stats
    import matplotlib.pyplot as plt
    import matplotlib.font_manager
    # 检测数据集中异常值的模型
    from pyod.models.abod import ABOD
    from pyod.models.cblof import CBLOF
    # from pyod.models.feature_bagging import FeatureBagging
    from pyod.models.hbos import HBOS
    from pyod.models.iforest import IForest
    from pyod.models.knn import KNN
    # from pyod.models.loci import LOCI
    # from pyod.models.sod import SOD
    from pyod.models.lof import LOF
    from pyod.models.mcd import MCD
    from pyod.models.ocsvm import OCSVM
    from pyod.models.pca import PCA
    from pyod.utils.data import generate_data, get_outliers_inliers
    
    """
    参考资料:
    https://blog.csdn.net/weixin_41697507/article/details/89408236
    https://blog.csdn.net/sparkexpert/article/details/81195418
    https://github.com/yzhao062/Pyod#ramaswamy2000efficient
    """
    
    # 创建一个带有异常值的随机数据集并绘制它
    # generate random data with two features
    X_train, Y_train = generate_data(n_train=200, train_only=True, n_features=2)
    # by default the outlier fraction is 0.1 in generate data function
    outlier_fraction = 0.1
    # store outliers and inliers in different numpy arrays
    x_outliers, x_inliers = get_outliers_inliers(X_train, Y_train)
    n_inliers = len(x_inliers)
    n_outliers = len(x_outliers)
    # separate the two features and use it to plot the data
    F1 = X_train[:, [0]].reshape(-1, 1)
    F2 = X_train[:, [1]].reshape(-1, 1)
    # create a meshgrid
    xx, yy = np.meshgrid(np.linspace(-10, 10, 200), np.linspace(-10, 10, 200))
    # scatter plot
    plt.scatter(F1, F2)
    plt.xlabel('F1')
    plt.ylabel('F2')
    plt.show()
    
    """
    Model 1 Angle-based Outlier Detector (ABOD)
    Model 2 Cluster-based Local Outlier Factor (CBLOF)
    Model 3 Feature Bagging
    Model 4 Histogram-base Outlier Detection (HBOS)
    Model 5 Isolation Forest
    Model 6 K Nearest Neighbors (KNN)
    Model 7 Fast outlier detection using the local correlation integral(LOCI)
    Model 8 Subspace Outlier Detection (SOD)
    Model 9 Local Outlier Factor (LOF)
    Model 10 Minimum Covariance Determinant (MCD)
    Model 11 One-class SVM (OCSVM)
    Model 12 Principal Component Analysis (PCA)
    """
    # 创建一个dictionary并添加要用于检测异常值的所有模型
    classifiers = {
        'ABOD': ABOD(contamination=outlier_fraction),
        'CBLOF': CBLOF(contamination=outlier_fraction),
        # 'Feature Bagging': FeatureBagging(contamination=outlier_fraction),
        'HBOS': HBOS(contamination=outlier_fraction),
        'IForest': IForest(contamination=outlier_fraction),
        'KNN': KNN(contamination=outlier_fraction),
        # 'LOCI': LOCI(contamination=outlier_fraction, ),
        # 'SOD': SOD(contamination=outlier_fraction, ),
        'LOF': LOF(contamination=outlier_fraction, ),
        'MCD': MCD(contamination=outlier_fraction, ),
        'OCSVM': OCSVM(contamination=outlier_fraction, ),
        'PCA': PCA(contamination=outlier_fraction, ),
    
    }
    # 将数据拟合到我们在dictionary中添加的每个模型,然后,查看每个模型如何检测异常值
    # set the figure size
    
    plt.figure(figsize=(10, 10))
    for i, (clf_name, clf) in enumerate(classifiers.items()):
        print()
        print(i + 1, 'fitting', clf_name)
        # fit the data and tag outliers
        clf.fit(X_train)
        scores_pred = clf.decision_function(X_train) * -1
        y_pred = clf.predict(X_train)
        threshold = stats.scoreatpercentile(scores_pred,
                                            100 * outlier_fraction)
        n_errors = (y_pred != Y_train).sum()
        # plot the levels lines and the points
    
        Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()]) * -1
        Z = Z.reshape(xx.shape)
        subplot = plt.subplot(3, 4, i + 1)
        subplot.contourf(xx, yy, Z, levels=np.linspace(Z.min(), threshold, 7),
                         cmap=plt.cm.Blues_r)
        a = subplot.contour(xx, yy, Z, levels=[threshold],
                            linewidths=2, colors='red')
        subplot.contourf(xx, yy, Z, levels=[threshold, Z.max()],
                         colors='orange')
        b = subplot.scatter(X_train[:-n_outliers, 0], X_train[:-n_outliers, 1], c='white',
                            s=20, edgecolor='k')
        c = subplot.scatter(X_train[-n_outliers:, 0], X_train[-n_outliers:, 1], c='black',
                            s=20, edgecolor='k')
        subplot.axis('tight')
        subplot.legend(
            [a.collections[0], b, c],
            ['learned decision function', 'true inliers', 'true outliers'],
            prop=matplotlib.font_manager.FontProperties(size=10),
            loc='lower right')
        subplot.set_xlabel("%d. %s (errors: %d)" % (i + 1, clf_name, n_errors))
        subplot.set_xlim((-7, 7))
        subplot.set_ylim((-7, 7))
    plt.show()
    
    

    6.2 效果图

    在这里插入图片描述

    在这里插入图片描述

    展开全文
  • Pyod异常检测

    千次阅读 多人点赞 2019-09-03 23:20:55
    pip install pyod Pyod的API函数 Individual Detection Algorithms单样本检测 单样本检测,也就是说只有一个类别的数据集与标签,因为在工厂设备中,控制系统的任务是判断是是否有意外情况出现,例如产品质量...
  • 异常检测-pyod包的入门使用

    千次阅读 2021-01-12 14:22:17
    本文github地址:pyod包的入门使用 文章目录0异常检测简介1pyod包简介1.1注意事项1.2函数的通用使用方法1.3模型保存1.4三个函数组1.5不同模型在基准数据上的表现1.6多个基准检测器的结合2异常值检测示例2.1 ABOD ...
  • Python异常检测工具箱——pyod

    千次阅读 2021-12-12 23:44:12
    pyod(Python Outlier Detection)是一个集成了30余种异常检测方法和模型的Python工具箱。从经典的 LOF (SIGMOD 2000) 到近两年的 COPOD (ICDM 2020) 和 SUOD (MLSys 2021) 。 特性: 丰富的模型,从 scikit-learn ...
  • PyOD异常检测库

    2022-02-16 13:52:21
    PyOD 异常检测库
  • Python异常检测包:PyOD

    2020-11-23 19:58:21
    PyOD简介异常检测(anomaly detection),也叫异常分析(outlier analysis或者outlier detection)或者离群值检测,在工业上有非常广泛的应用场景:金融业:从海量数据中找到“欺诈案例”,如信用卡反诈骗,识别虚假信贷...
  • pyod库 检测异常值的不同方法案例

    千次阅读 2022-03-14 13:55:55
    目录 一、ABOD类使用案例 ...参考使用:All Models — pyod 0.9.8 documentation import numpy as np from scipy import stats import matplotlib.pyplot as plt import matplotlib.font_manager # 导入想要用来检
  • 使用PyOD库在Python中学习异常检测

    万次阅读 2019-04-19 21:13:25
    在本文中,我将带您了解异常值以及如何使用Python中的PyOD检测异常值。 本文假设您具有机器学习算法和Python语言的基本知识。 你可以参考这篇文章 - “ 机器学习要点 ”,了解 或刷新这些概念。 Table of ...
  • 我将使用两种不同的方法来演示PyOD: 使用模拟数据集 使用真实世界的数据集 - 大市场销售竞赛 模拟数据集上的PyOD 首先导入所需的库: 现在,导入想要用来检测数据集中异常值的模型。我们将使用ABOD和KNN: 现在创建...
  • 学习使用PyOD库生成toy example并调用HBOS 根据官方文档,pyod中用于生成toy数据的方法主要是 pyod.utils.data.generate_data() pyod.utils.data.generate_data_clusters() 下面给出具体的参数和用法。 函数的查询...
  • 资源分类:Python库 所属语言:Python 资源全名:pyod-0.5.3.tar.gz 资源来源:官方 安装方法:https://lanzao.blog.csdn.net/article/details/101784059
  • 目录 一、KNN检测案例 二、组合案例 三、相关api链接 一、KNN检测案例 ...from pyod.models.knn import KNN from pyod.utils.data import generate_data, evaluate_print ... # 2、生成样本数据pyod.utils.
  • # os.path.abspath(os.path.join(os.path.dirname("__file__"), '..'))) from pyod.models.hbos import HBOS from pyod.utils.data import generate_data from pyod.utils.data import evaluate_print from pyod....
  • python库。 资源全名:pyod-0.6.3.tar.gz
  • 用fit()方法拟合数据 from pyod.models import hbos from pyod.utils.example import visualize clf = hbos.HBOS() clf.fit(X_train) y_train_pred = clf.labels_ y_train_socres = clf.decision_scores_ y_test_...
  • 从导入所需的库并加载数据开始:import pandas as pd import numpy as np # Import models from pyod.models.abod import ABOD from pyod.models.cblof import CBLOF from pyod.models.feature_bagging import ...
  • pyod包是异常值检测的重要集成工具,开发者使用的演示方式是.mat文件,那么如何用csv文件进行pyod包的使用,并绘制ROC曲线呢? 1.导包 from pyod.models.lof import LOF # imprt LOF分类器 import pandas as pd from...
  • 感谢datawhale大部队! 异常检测中,统计学方法的优缺点 优点: 1、如果统计假定成立,这种方法...pyod库安装: # 直接命令行pip安装 pip install pyod 启动jupyter notebook: # 以前已安装jupyter,命令行直接启动即
  • 异常检测——基于统计学方法(参数方法、非参数方法、HBOS、pyod库) 涉及知识点 统计学异常检测的思想 基于参数方法的异常检测 基于非参数方法的异常检测 HBOS Python中PyOD库生成toy example并调用HBOS实例 1、...
  • 异常检测初识pyod Task2

    2021-01-15 15:32:18
    结果: ROC数值很高,但是precision @ n 很低 alpha越小,ROC的数值越高 目前测试集的ROC值高于训练集,感觉过拟合了,但是pyod的抑制过拟合的方法不太管用。后期可能探索sklearn交叉验证看看行不行。 当...
  • 采取多种算法结合的方法识别异常值,以2022年全国服务外包大赛A03异常商品识别问题为例。主要方法有 'PCA' 'COPOD' 'Iforest' 'LODA' 'CBLOF' 'HBOS' 'MCD' 'FB' 'KNN' 'LOF' 'ABOD' ...'AutoEncoder'

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 759
精华内容 303
关键字:

PyOD