精华内容
下载资源
问答
  • 异常检测

    千次阅读 2016-01-24 14:18:05
    异常检测

    异常检测

    异常检测(Anomaly Detection):异常检测就是从数据集中检测出异常样本,是一种无监督学习。

    引例

    飞机制造商在飞机引擎从生产线上流出时,会考虑进行异常检测,以防止不合格引擎对整机造成的巨大影响,而为了进行异常检测,通常就需要采集一些特征,比如会采集如下特征:

    1. x1x^1x1=引擎运转时产生的热量
    2. x2x^2x2=引擎的振荡频率

    对于一系列的数据集(特征向量集合):x(1),⋯,x(m){x^{(1)},⋯,x^{(m)} }x(1),,x(m)x(1),⋯,x(m){x^{(1)},⋯,x^{(m)} }x(1),,x(m), 这些数据都是正常样本,我们将其绘制到二维平面上:

    飞机引擎数据集

    如果一个新的测试样本居于样本布密度较大的地方如:

    正常飞机引擎

    那么我们有很大的把握认为这个测试样本是正常的。
    反之如果一个新的测试样本远离分布集中的地方如:

    异常飞机引擎

    那么我们也有很大的把握认为这个测试样本是正常的。

    小结:
    如果我们拥有一个测试集x(1),⋯,x(m){x^{(1)},⋯,x^{(m)} }x(1),,x(m),我们根据已知的数据集建立模型p(x)p(x)p(x),该模型可以将正常样本与异常样本分离。

    断言

    建立模型

    高斯分布(正态分布)

    正态分布可以表示成X∼N(μ,δ2)X∼N(\mu,\delta^2)XN(μ,δ2),表示XXX服从均值为μ\muμ,方差为δ2\delta^2δ2的正态分布。
    P(x;μ,δ2)=12πδexp(−(x−μ)22δ2) P(x;\mu,\delta^2)=\frac{1}{\sqrt{2\pi}\delta}exp(-\frac{(x-\mu)^2}{2\delta^2}) P(x;μ,δ2)=2πδ1exp(2δ2(xμ)2)
    参数估计:
    若有x(1),⋯,x(m){x^{(1)},⋯,x^{(m)} }x(1),,x(m)x(i)∼N(μ,δ2)x^{(i)}∼N(\mu,\delta^2)x(i)N(μ,δ2)
    μ=1mΣi=1mx(i)δ2=1mΣi=1m(x(i)−μ)2 \mu=\frac{1}{m}\Sigma_{i=1}^mx^{(i)}\\ \delta^2=\frac{1}{m}\Sigma_{i=1}^m(x^{(i)}-\mu)^2 μ=m1Σi=1mx(i)δ2=m1Σi=1m(x(i)μ)2
    证明可以中最大似然估计。

    异常检测算法

    训练集:x(1),⋯,x(m){x^{(1)},⋯,x^{(m)} }x(1),,x(m)x(i)∼N(μi,δi2)x^{(i)}∼N(\mu_i,\delta^2_i)x(i)N(μi,δi2)
    建立模型:
    P(X)=P(x(1);μ1,δ12)∗,...,∗P(x(m);μm,δm2)=Πi=1mP(x(i);μi,δi2)                        P(X)=P(x^{(1)};\mu_1,\delta^2_1)*,...,*P(x^{(m)};\mu_m,\delta^2_m)\\ =\Pi_{i=1}^mP(x^{(i)};\mu_i,\delta^2_i)~~~~~~~~~~~~~~~~~~~~~~~ P(X)=P(x(1);μ1,δ12),...,P(x(m);μm,δm2)=Πi=1mP(x(i);μi,δi2)                       
    参数拟合:
    μj=1mΣi=1mxj(i)δj2=1mΣi=1m(xj(i)−μj)2 \mu_j=\frac{1}{m}\Sigma_{i=1}^mx^{(i)}_j\\ \delta^2_j=\frac{1}{m}\Sigma_{i=1}^m(x^{(i)}_j-\mu_j)^2 μj=m1Σi=1mxj(i)δj2=m1Σi=1m(xj(i)μj)2
    计算P(X)P(X)P(X)
    P(X)=Πj=1n12πδjexp(−(xj−μj)22δj2) P(X)=\Pi_{j=1}^n\frac{1}{\sqrt{2\pi}\delta_j}exp(-\frac{(x_j-\mu_j)^2}{2\delta^2_j}) P(X)=Πj=1n2πδj1exp(2δj2(xjμj)2)
    判断P(X)P(X)P(X)是否小于ϵ\epsilonϵ,若小于ϵ\epsilonϵ则为异常。

    异常检测算法的评估

    1. 对数据按6:2:2比例进行分配,分别为训练集,交叉验证集,测试集,训练集中全是无标签数据,异常数据在交叉验证集与测试集中按比例进行分配
    2. 通过训练集对参数进行拟合
    3. 对交叉验证集和测试集中的数据进行测试
    4. 由于异常样本的数量非常的少,导致预测十分偏斜,可以通过考察准确率,召回率,F1值来评估模型的效果。
    5. 通过交叉验证集来调节参数ϵ\epsilonϵ

    异常检测与监督学习

    因为我们可能已经知道了训练数据是否为异常数据,那么就难免有个疑惑我们为什么不用监督学习的算法比如logistics regression来做呢?
    下面我们来比较一下异常检测与监督学习

    项目 异常检测 逻辑回归
    样本 异常样本数量少(0~20),大量负样本 正负样本数量都很多
    应用 欺诈检测,工业制造,数据中心的监测机器 垃圾邮件分类,天气预报,癌症判断

    注:大量的正样本可以让算法学习到正样本的特征,并且肯能出现的正样本与训练集中的正样本相似,而异常可能是从未出现过的异常。

    数据处理

    通常我们先画出特征值的柱状图,看其是否接近与高斯分布,若不是我们可以对特征值进行相关的处理,使其接近于高斯分布,例如取对数,取幂等等。特征值的分布越接近高斯分布则算法的效果越好。

    多元高斯分布

    我们不再单独考虑每个特征值的高斯分布而是考虑特征向量XXX的高斯分布
    P(X;μ,Σ)=1(2π)2n∣Σ∣12exp(−12(X−μ)τΣ−1(X−μ)) P(X;\mu,\Sigma)=\frac{1}{(2\pi)^{\frac{2}{n}}|\Sigma|^{\frac{1}{2}}}exp(-\frac{1}{2}(X-\mu)^{\tau}\Sigma^{-1}(X-\mu)) P(X;μ,Σ)=(2π)n2Σ211exp(21(Xμ)τΣ1(Xμ))

    算法流程

    参数拟合
    μ=1mΣi=1mx(i)Σ=1mΣi=1m(x(i)−μ)(x(i)−μ)τ \mu=\frac{1}{m}\Sigma_{i=1}^m x^{(i)}\\ \Sigma = \frac{1}{m}\Sigma_{i=1}^m (x^{(i)}-\mu)(x^{(i)}-\mu)^{\tau} μ=m1Σi=1mx(i)Σ=m1Σi=1m(x(i)μ)(x(i)μ)τ
    剩下的流程同高斯分布相同。

    高斯分布与多元高斯分布比较

    高斯分布 多元高斯分布
    需要手动创建新的特征去捕获不正常变量值的组合 自动捕获不同特征变量之间的相关性
    运算亮小,适应n很大的情况,即使m很小也可以运行的很好 计算量大,m必须大于n,通常当m>=10时才考虑

    注:如果发现Σ\SigmaΣ是不可逆的一般有两种情况

    • m< n
    • 有冗余变量(变量间存在线性相关的关系)

    MatlabCode

    参数拟合Code

    function [mu sigma2] = estimateGaussian(X)
    %ESTIMATEGAUSSIAN This function estimates the parameters of a 
    %Gaussian distribution using the data in X
    %   [mu sigma2] = estimateGaussian(X), 
    %   The input X is the dataset with each n-dimensional data point in one row
    %   The output is an n-dimensional vector mu, the mean of the data set
    %   and the variances sigma^2, an n x 1 vector
    % 
    
    % Useful variables
    [m, n] = size(X);
    
    % You should return these values correctly
    mu = zeros(n, 1);
    sigma2 = zeros(n, 1);
    
    % ====================== YOUR CODE HERE ======================
    % Instructions: Compute the mean of the data and the variances
    %               In particular, mu(i) should contain the mean of
    %               the data for the i-th feature and sigma2(i)
    %               should contain variance of the i-th feature.
    %
    for i=1:n
        mu(i)=sum(X(:,i))/m;
    end;
    
    for i=1:n
        sigma2(i)=sum((X(:,i)-mu(i)).^2)/m;
    end;  
    % =============================================================
    end
    

    更新ϵ\epsilonϵ

    function [bestEpsilon bestF1] = selectThreshold(yval, pval)
    %SELECTTHRESHOLD Find the best threshold (epsilon) to use for selecting
    %outliers
    %   [bestEpsilon bestF1] = SELECTTHRESHOLD(yval, pval) finds the best
    %   threshold to use for selecting outliers based on the results from a
    %   validation set (pval) and the ground truth (yval).
    %
    
    bestEpsilon = 0;
    bestF1 = 0;
    F1 = 0;
    
    stepsize = (max(pval) - min(pval)) / 1000;
    for epsilon = min(pval):stepsize:max(pval)
        
        % ====================== YOUR CODE HERE ======================
        % Instructions: Compute the F1 score of choosing epsilon as the
        %               threshold and place the value in F1. The code at the
        %               end of the loop will compare the F1 score for this
        %               choice of epsilon and set it to be the best epsilon if
        %               it is better than the current choice of epsilon.
        %               
        % Note: You can use predictions = (pval < epsilon) to get a binary vector
        %       of 0's and 1's of the outlier predictions
        predicted = (pval<epsilon);
        truepostive = sum((predicted==1)&(yval==1));
        falsepostive = sum((predicted==1)&(yval==0));
        falsenegative = sum((predicted==0)&(yval==1));
        pre = truepostive/(truepostive+falsepostive);
        rec = truepostive/(truepostive+falsenegative);
        F1 = 2*pre*rec/(pre+rec);
        % =============================================================
    
        if F1 > bestF1
           bestF1 = F1;
           bestEpsilon = epsilon;
        end
    end
    
    end
    
    

    更多信息/快速联系博主

    在这里插入图片描述

    展开全文
  • 本文转载自:... 《异常检测——从经典算法到深度学习》 0 概论1 基于隔离森林的异常检测算法 2 基于LOF的异常检测算法3 基于One-Class SVM的异常检测算法4 基于高斯概率密度异常检测算法5 Opprent

    本文转载自:https://blog.csdn.net/smileyan9/article/details/106587227/

    《异常检测——从经典算法到深度学习》

    5 Opprentice 系统

    论文名称:Opprentice: Towards Practical and Automatic Anomaly Detection Through Machine Learning
    年份:2015
    论文下载地址:https://wws.lanzous.com/id06nxa

    请读者注意

    • 并不是对全部论文的翻译;
    • 略过了一些背景介绍;
    • 对一些内容进行了概括;
    • 对于翻译可能引起争议的部分保留了原文;
    • 如果有错误的地方请务必指出,一定改正,万分感谢!

    5.0 ABSTRACT

    主要内容包括以下几点:

    • Opprentice: Operators’ apprentice. 操作员学徒。
    • 操作人员的唯一手工任务是使用方便的工具定期地给异常数据打标签。将多个现有检测器并行应用于性能数据中,提取异常特征。
    • 然后根据这些提取出来的特征来训练生成一个 随机森林(random forest) 分类模型,使用这个模型自动地选择合适的检测器的参数组合和阈值。
    • 对世界顶级搜索引擎中三种不同的KPI,Opprentice可以自动满足或接近合理准确的效果(recall>=0.66 and precision >= 0.66)
    • Opprentice 让操作员可以在几十分钟内完成以前需要十多天才可能完成的任务。

    5.1 INTRODUCTION

    5.1.1 异常检测算法面临的挑战:

    • 异常的定义。现实生活中的异常很难有个明确的定义。
    • 异常的检测。选择最合适的检测方法通常需要算法经验与KPI数据相关的专业知识。效果最优的参数与阈值通常高度依赖于真实数据,所有通常需要花费大量的时间来确定异常检测算法的所有参数值和阈值,有时候甚至需要组合多种异常检测算法。因此,为了找到合适的检测模型和确定合适的参数与阈值,通常需要多次执行这种耗时的迭代操作。(操作人员调参,重现训练模型)

    5.1.2 论文中介绍的方法依赖于两个关键观测(key observation):

    • 操作员可以直观地检查时间序列数据并标记他们识别的异常情况。操作员唯一需要手动做的事情就是定期给新来的数据打标签(例如每周)。由于异常情况通常很少发生,因此在专用标记工具的帮助下,标记时间是相当合理的。
    • 不同检测模型测得的异常严重度自然可以作为机器学习的特征,因此每个检测模型都可以作为特征提取器。接着Opprenice根据已经标记的数据进行学习,自然而然地从操作人员的标记中捕获相关的专业知识(the domain knowledge),就跟一个聪明且勤奋的学徒一样。
      特别的是,多个检测算法对KPI数据进行平行的特征提取。然后这些特征与标签就可以用来训练模型,比如说随机森林,自动地选择合适的检测参数组合和阈值。

    5.1.3 论文的主要贡献:

    • Opprentice 是第一个将机器学习应用于获取真实异常定义、自动组合和调整各种检测器以满足操作员精度偏好的检测框架。
    • Opprentice 解决了将机器学习应用于此类问题的一些挑战:标签开销、不经常出现的问题、类不平衡以及不相关和冗余的特性,这些在第3.2条和第4条中有详细阐述。
    • 在一个顶级的全球搜索引擎中构建和评估Opprentice,已经实现了14个现有的检测器并将其插入Oppertice。 对于三种不同业务的KPI数据,Opprentice 可以自动满足或接近合理的精度(recall ≥ 0.66 and precision ≥ 0.66)。
    • 而且,尽管Opprentice 中最优参数组合会因为KPI数据的不同而改变,但 Opprentice 不断表现得和以前相似甚至比以前更好。
    • 更重要的是,Opprentice 只需要几十分钟就能完成以前操作员可能需要几十天才能完车的事情。我们相信这是第一个不需要人工选择检测器、不需要参数配置和阈值调整的框架。

    5.2 BACKGROUND

    5.2.1 KPIs 与 KPI Anomalies

    • KPIs: KPI 数据是时间序列数据,格式为(时间戳,数值)。本论文使用的是全球顶级搜索引擎中三类有代表性的数据。
    • KPI Anomalies:KPI 时间序列数据还可以在不同的严重程度上呈现出几种意外的模式(例如,抖动、缓慢的上升、突然的上升和下降),例如突然下降20%或50%。
    • 搜索引擎一周内三种主要的 KPI 对应图像:
      KPIs
    • 不同KPI除了物理意义不同,它们的特征也不一样的。搜索引擎中三种类型KPI的特征表
      三种类型KPI的特征表

    5.2.2 Problem and Goal

    • 异常检测的基本目标是准确,识别出更多真实异常(ground truth),减少错误异常。
    • 该论文使用 recall 和 precision 作为算法 Opprentice 的评测指标。
    • 因为跟异常相关的数据很少,所以对那些检测器来说达到高 recall 和 高precision 是很难的事情。
    • Opprentice 的一个质量目标:具有足够的自动化,因此操作人员不会参与选择和组合合适的探测器,或调整它们。

    5.3 OPPRENTICE OVERVIEW

    5.3.1 核心思想

    • Opprentice 使用的是有监督学习;有监督学习现在比较流行。
    • 在Oppertice中应用机器学习的高级理念,如图所示:高级理念
      • 首先,操作员需要标记数据中的异常。
      • 利用现有的基本异常检测器分别从多个角度量化数据的异常水平。
      • 探测器的结果作为数据的特征,与操作员的标记构成训练集,然后利用机器学习算法建立分类模型。比如图2中的判定边界,由问号表示的点被称为异常。
    • 优点如下:
      • 节省操作员的时间。操作员只需要标记异常数据即可;
      • Opprentice 是首个使用机器学习算法来提取特征的框架;而其他那些用于异常检测的机器学习算法都只是用作基本的异常检测器。

    5.3.2 机器学习的挑战

    尽管上述基于机器学习的思想似乎很有前途,但将其应用于机会设计却带来了许多内在的和实际的挑战。

    • 标签开销(Labeling overhead) 我们开发了一个简单且方便的交互式界面作为打标签的工具,减少操作员的时间开销。
    • 不完全异常案例(Incomplete anomaly) 训练集是否包含足够的异常情况会影响机器学习算法的性能。然而,由于异常在实际中发生的频率较低,任意的训练集不太可能覆盖足够的异常。例如,未来可能会出现新的异常类型。为了解决这个问题,我们使用新标记的数据 递增地重新训练分类器 。通过这种方式,Opprentice能够捕捉并学习初始训练集中没有出现的新类型异常。
    • 样本类别不均衡(Class imbalance problem) 因为异常数据只占极少数样本,所以分类器可能更加趋向于把测试数据归类为正常数据。我们通过 调整机器学习分类器的阈值 来解决这个问题(从今以后把这个阈值叫做 cThld,后面将经常提到这个 cThld )。
    • 无关特征与冗余特征(Irrelevant and redundant features) 为了节省人工操作时间,我们既没有选择合适的检测器,也不调整其内部参数,而是使用具有不同参数的检测器提取特征。所以提取的特征中可能无关,也可能冗余,这可能会降低算法的精度。我们使用 集成学习算法来解决这个问题。

    5.4 DESIGN

    5.4.1 体系结构

    Opprentice 的体系结构如下图所示。
    Opprentice 体系 结构
    从操作者的角度来看,操作者通过两种方式与 Opprentice 进行互动(如下图中a部分)。

    • 首先,操作员根据需要指定一个特定的精准度目标(偏好) (specify an accuracy preference),recall >= x, precision >= y. 我们假设指定的 x 与 y 不会改变。这个目标(preference) 将会用于指导 cThld (阈值) 的自动调整。
    • 其次,操作员需要使用一个便捷的工具对最开始的历史数据中的异常进行标记,并且以后定周期进行标记(比如每周一次)。所有的数据只被标记一次。

    从Opprentice 的角度来看

    • 首先以如下方式训练出一个分类器:应用很多的检测器作为特征提取器,从原始数据中提取出多个特征,再加上操作人员的标签,可以用于某种机器学习算法(如本文中的随机森林),进行递增地对异常分类器进行训练。
    • 其后,如上图(图3) b Detecting anomaly ,相同的检测器集合提取输入数据的特征,并且使用分类器对它们进行异常的检测与分类。注意,这里与以往的不同,这里的提取器只提取特征,而不检测异常。

    接下来,我们将详细介绍每一组的设计。

    5.4.2 标签工具(Labeling Tool)

    我们开发了专门的工具,帮助操作者给异常打标签。
    打标工具

    • 首先,加载KPI数据并以图像的形式展示出来,如图4所示。为了帮助操作人员识别异常,前一天的数据以及上一周的数据都会以浅色展示出来。

    • 操作人员使用方向键 (arrow keys) 来浏览数据,比如放大区间,缩小区间,左移右移等等,使用鼠标左键标记异常,鼠标右键取消标记。请查看图4便可理解。

      这里的标记与取消标记的对象(也就是图像中加深颜色的部分),可以理解为“目前浏览的窗口",也就是论文中的 window,这里记录一下,是因为后面的同样来自清华大学的异常检测方面的论文中,基于滑动窗口异常检测的想法,从本质上来讲极有可能跟这个手动地选择window有一定的联系。

    使用这个工具进行打标工作效率很高,操作人员不需要逐个时间段进行标记,只需要标记出现异常的部分。首先他们看到的KPI曲线是一个相当放大的视图,在这个视图中,KPI曲线是不平滑曲线,所以异常部分对于操作人员来说是可见的。然后操作人员可以放大视图,定位异常出现的时间段,并通过窗口进行打标。在我们研究的KPI中,操作员只需要几分钟就能标记一个月的数据。

    标记的一个问题是可能会引入误差,特别是在标记时,异常窗口的边界经常被扩大或缩小。然而,机器学习以其对噪声的鲁棒性而闻名。我们在第5条中的评估也证明了操作员的真实标签是可行的。

    标记工具类似于WebClass,但是它只支持NetFlow数据,而不支持一般的时间序列数据。更重要的是,它只允许操作员将检测器已经识别的异常标记为假阳性或未知。相比之下,我们的标记工具使操作员能够自由标记所有数据,而不是标记检测结果。

    5.4.3 检测器 (Detector)

    我们接下来描述的内容如下:

    • 异常的检测器如何用作异常特征的提取器;
    • 如何选择检测器与 Opprentice 一起使用。

    1)检测器用作提取器

    我们使用统一的模式代表不同的检测器:

         d
        
        
         a
        
        
         t
        
        
         a
        
        
         &nbsp;
        
        
         p
        
        
         o
        
        
         i
        
        
         n
        
        
         t
        
        
         &nbsp;&nbsp;
        
        
         
          
           a
          
          
           &nbsp;
          
          
           d
          
          
           e
          
          
           t
          
          
           e
          
          
           c
          
          
           t
          
          
           o
          
          
           r
          
          
           &nbsp;
          
          
           w
          
          
           i
          
          
           t
          
          
           h
          
          
           &nbsp;
          
          
           p
          
          
           a
          
          
           r
          
          
           a
          
          
           m
          
          
           e
          
          
           t
          
          
           e
          
          
           r
          
          
           s
          
         
         
          →
         
        
        
         &nbsp;&nbsp;
        
        
         s
        
        
         e
        
        
         v
        
        
         e
        
        
         r
        
        
         i
        
        
         t
        
        
         y
        
        
         &nbsp;&nbsp;
        
        
         
          
           s
          
          
           T
          
          
           h
          
          
           l
          
          
           d
          
         
         
          →
         
        
        
         &nbsp;&nbsp;
        
        
         {
        
        
         1
        
        
         ,
        
        
         0
        
        
         }
        
       
       
         data\ point \ \ \underrightarrow{a\ detector\ with\ parameters} \ \ severity \ \ \underrightarrow{sThld} \ \ \{1,0\} 
       
      
     </span><span class="katex-html"><span class="base"><span class="strut" style="height: 1.41088em; vertical-align: -0.522em;"></span><span class="mord mathdefault">d</span><span class="mord mathdefault">a</span><span class="mord mathdefault">t</span><span class="mord mathdefault">a</span><span class="mspace">&nbsp;</span><span class="mord mathdefault">p</span><span class="mord mathdefault">o</span><span class="mord mathdefault">i</span><span class="mord mathdefault">n</span><span class="mord mathdefault">t</span><span class="mspace">&nbsp;</span><span class="mspace">&nbsp;</span><span class="mord accentunder"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height: 0.88888em;"><span class="svg-align" style="top: -2.478em;"><span class="pstrut" style="height: 3em;"></span><span class="hide-tail" style="height: 0.522em; min-width: 0.888em;">
            <svg width="400em" height="0.522em" viewBox="0 0 400000 522" preserveAspectRatio="xMaxYMin slice">
             <path d="M0 241v40h399891c-47.3 35.3-84 78-110 128
    

    -16.7 32-27.7 63.7-33 95 0 1.3-.2 2.7-.5 4-.3 1.3-.5 2.3-.5 3 0 7.3 6.7 11 20
    11 8 0 13.2-.8 15.5-2.5 2.3-1.7 4.2-5.5 5.5-11.5 2-13.3 5.7-27 11-41 14.7-44.7
    39-84.5 73-119.5s73.7-60.2 119-75.5c6-2 9-5.7 9-11s-3-9-9-11c-45.3-15.3-85
    -40.5-119-75.5s-58.3-74.8-73-119.5c-4.7-14-8.3-27.3-11-40-1.3-6.7-3.2-10.8-5.5
    -12.5-2.3-1.7-7.5-2.5-15.5-2.5-14 0-21 3.7-21 11 0 2 2 10.3 6 25 20.7 83.3 67
    151.7 139 205zm0 0v40h399900v-40z">
    a detector with parameters  severity  


    sThld
      {1,0}

    • 首先,当检测器接收到一个输入数据时,它会在内部产生一个非负值,severity,以测量该点的异常程度。例如,Holt-Winters 使用残差(即每个数据点的测试值与实际值之间的绝对差)来度量 severity;历史平均值假设数据遵循高斯分布,并使用该点偏离平均值的标准差多少倍来度量 severity.
      大多数检测器都是参数化的,并且有一组内部参数。比如Holt-Winters有三个参数

            α
           
          
          
           \alpha
          
         
        </span><span class="katex-html"><span class="base"><span class="strut" style="height: 0.43056em; vertical-align: 0em;"></span><span class="mord mathdefault" style="margin-right: 0.0037em;">α</span></span></span></span></span>、<span class="katex--inline"><span class="katex"><span class="katex-mathml">
        
         
          
           
            β
           
          
          
           \beta
          
         
        </span><span class="katex-html"><span class="base"><span class="strut" style="height: 0.88888em; vertical-align: -0.19444em;"></span><span class="mord mathdefault" style="margin-right: 0.05278em;">β</span></span></span></span></span>、<span class="katex--inline"><span class="katex"><span class="katex-mathml">
        
         
          
           
            γ
           
          
          
           \gamma
          
         
        </span><span class="katex-html"><span class="base"><span class="strut" style="height: 0.625em; vertical-align: -0.19444em;"></span><span class="mord mathdefault" style="margin-right: 0.05556em;">γ</span></span></span></span></span>,而历史平均值有一个窗口长度参数。输入数据点的 <code>severity</code> 取决于检测器以及其内部参数。</p> </li><li> <p>检测器还需要阈值来将严重性转换成二进制输出(即有无异常),我们将此阈值称为 <code>severity</code> 阈值,简称 <code>sThld</code>。</p> </li></ul> 
      

    因为 severity 描述了数据的异常程度,所以把 severity 当成异常检测的特征是正常的,为了产生特征,对于每个参数化检测器,我们对它们的参数进行采样,这样就可以得到几个固定的检测器。我们称这些具有特定采样参数的检测器为检测器配置。因此,这样的配置可以充当特征提取器。

         d
        
        
         a
        
        
         t
        
        
         a
        
        
         &nbsp;
        
        
         p
        
        
         o
        
        
         i
        
        
         n
        
        
         t
        
        
         &nbsp;&nbsp;
        
        
         
          
           c
          
          
           o
          
          
           n
          
          
           f
          
          
           i
          
          
           g
          
          
           u
          
          
           r
          
          
           a
          
          
           t
          
          
           i
          
          
           o
          
          
           n
          
          
           &nbsp;
          
          
           (
          
          
           d
          
          
           e
          
          
           t
          
          
           e
          
          
           c
          
          
           t
          
          
           o
          
          
           r
          
          
           +
          
          
           s
          
          
           a
          
          
           m
          
          
           p
          
          
           l
          
          
           e
          
          
           d
          
          
           &nbsp;
          
          
           p
          
          
           a
          
          
           r
          
          
           a
          
          
           m
          
          
           e
          
          
           t
          
          
           e
          
          
           r
          
          
           s
          
          
           )
          
         
         
          →
         
        
        
         &nbsp;&nbsp;
        
        
         f
        
        
         e
        
        
         a
        
        
         t
        
        
         u
        
        
         r
        
        
         e
        
       
       
         data\ point \ \ \underrightarrow{configuration \ (detector + sampled\ parameters)} \ \ feature 
       
      
     </span><span class="katex-html"><span class="base"><span class="strut" style="height: 1.522em; vertical-align: -0.522em;"></span><span class="mord mathdefault">d</span><span class="mord mathdefault">a</span><span class="mord mathdefault">t</span><span class="mord mathdefault">a</span><span class="mspace">&nbsp;</span><span class="mord mathdefault">p</span><span class="mord mathdefault">o</span><span class="mord mathdefault">i</span><span class="mord mathdefault">n</span><span class="mord mathdefault">t</span><span class="mspace">&nbsp;</span><span class="mspace">&nbsp;</span><span class="mord accentunder"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height: 1em;"><span class="svg-align" style="top: -2.478em;"><span class="pstrut" style="height: 3em;"></span><span class="hide-tail" style="height: 0.522em; min-width: 0.888em;">
            <svg width="400em" height="0.522em" viewBox="0 0 400000 522" preserveAspectRatio="xMaxYMin slice">
             <path d="M0 241v40h399891c-47.3 35.3-84 78-110 128
    

    -16.7 32-27.7 63.7-33 95 0 1.3-.2 2.7-.5 4-.3 1.3-.5 2.3-.5 3 0 7.3 6.7 11 20
    11 8 0 13.2-.8 15.5-2.5 2.3-1.7 4.2-5.5 5.5-11.5 2-13.3 5.7-27 11-41 14.7-44.7
    39-84.5 73-119.5s73.7-60.2 119-75.5c6-2 9-5.7 9-11s-3-9-9-11c-45.3-15.3-85
    -40.5-119-75.5s-58.3-74.8-73-119.5c-4.7-14-8.3-27.3-11-40-1.3-6.7-3.2-10.8-5.5
    -12.5-2.3-1.7-7.5-2.5-15.5-2.5-14 0-21 3.7-21 11 0 2 2 10.3 6 25 20.7 83.3 67
    151.7 139 205zm0 0v40h399900v-40z">
    configuration (detector+sampled parameters)  feature

    Oppertice中的特征提取、训练和分类(检测)都是针对单个数据点而设计的,而不是针对异常窗口。这样,机器学习算法可以有足够的训练数据,分类器可以快速检测出个别异常数据点.

    2)检测器的选择

    当选择检测器的时候,我们有三个总体要求:

    • 第一,检测器应该可以拟合上述模型,或者能检测数据的 severity (严重性)。事实上,许多被广泛应用的检测器也是这样工作的。
    • 第二,因为检测异常要求实时性,所以检测器应该能线上检测。也就是说,一旦异常到达就应该被检测到,不需要等待任何后续数据。
    • 第三,检测器的计算时间必须小于时间窗的事件间隔。
    • 此外,一些检测器,如基于移动平均的检测器,需要一个数据窗口来预热。我们通过跳过热身窗口中的数据检测来处理这些检测器,这对将来的数据检测没有影响

    由于我们打算让操作人员不必仔细选择探测器,因此满足上述要求的探测器用于 Oppertice ,而无需仔细评估其有效性。尽管有些检测器在检测某些 KPI 时可能不准确,Opprentice 可以从广泛选择的检测器中找到合适的检测器,并获得相对较高的精度。本文以 Oppertice 中14个广泛使用的探测器(稍后将在第5.2节中介绍)为例进行了研究。

    3)采样参数

    很多检测器有很多组参数,现在需要从中采样。采样方法有两种:

    • 扫描参数空间。我们观察到一些检测器的参数具有直观意义。比如说 EWMA(Exponentially Weighted Moving Average),一个基于预测的检测器,它只有一个权重参数
           α
          
          
           &nbsp;
          
          
           ∈
          
          
           [
          
          
           0
          
          
           ,
          
          
           1
          
          
           ]
          
         
         
          \alpha\ \in[0, 1]
         
        
       </span><span class="katex-html"><span class="base"><span class="strut" style="height: 0.5782em; vertical-align: -0.0391em;"></span><span class="mord mathdefault" style="margin-right: 0.0037em;">α</span><span class="mspace" style="margin-right: 0.277778em;"></span><span class="mspace">&nbsp;</span><span class="mrel">∈</span><span class="mspace" style="margin-right: 0.277778em;"></span></span><span class="base"><span class="strut" style="height: 1em; vertical-align: -0.25em;"></span><span class="mopen">[</span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right: 0.166667em;"></span><span class="mord">1</span><span class="mclose">]</span></span></span></span></span>。当 <span class="katex--inline"><span class="katex"><span class="katex-mathml">
       
        
         
          
           α
          
         
         
          \alpha
         
        
       </span><span class="katex-html"><span class="base"><span class="strut" style="height: 0.43056em; vertical-align: 0em;"></span><span class="mord mathdefault" style="margin-right: 0.0037em;">α</span></span></span></span></span> 增大时,预测将会更加依赖于最近的数据而不是更久以前的历史数据。<br> 因此,我们可以从 <span class="katex--inline"><span class="katex"><span class="katex-mathml">
       
        
         
          
           α
          
          
           &nbsp;
          
          
           ∈
          
          
           
            0.1
           
           
            ,
           
           
            0.3
           
           
            ,
           
           
            0.5
           
           
            ,
           
           
            0.7
           
           
            ,
           
           
            0.9
           
          
         
         
          \alpha \ \in {0.1, 0.3, 0.5, 0.7, 0.9}
         
        
       </span><span class="katex-html"><span class="base"><span class="strut" style="height: 0.5782em; vertical-align: -0.0391em;"></span><span class="mord mathdefault" style="margin-right: 0.0037em;">α</span><span class="mspace" style="margin-right: 0.277778em;"></span><span class="mspace">&nbsp;</span><span class="mrel">∈</span><span class="mspace" style="margin-right: 0.277778em;"></span></span><span class="base"><span class="strut" style="height: 0.83888em; vertical-align: -0.19444em;"></span><span class="mord"><span class="mord">0</span><span class="mord">.</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right: 0.166667em;"></span><span class="mord">0</span><span class="mord">.</span><span class="mord">3</span><span class="mpunct">,</span><span class="mspace" style="margin-right: 0.166667em;"></span><span class="mord">0</span><span class="mord">.</span><span class="mord">5</span><span class="mpunct">,</span><span class="mspace" style="margin-right: 0.166667em;"></span><span class="mord">0</span><span class="mord">.</span><span class="mord">7</span><span class="mpunct">,</span><span class="mspace" style="margin-right: 0.166667em;"></span><span class="mord">0</span><span class="mord">.</span><span class="mord">9</span></span></span></span></span></span> 中进行取样,从EWMA中或者五种典型的特征。<br> 对于那些有多个参数和很大的参数区间的检测器,我们可以减小取样粒度。比如说,Holt-Winters 有三个 [0,1] 区间中的参数 <span class="katex--inline"><span class="katex"><span class="katex-mathml">
       
        
         
          
           α
          
          
           ,
          
          
           β
          
          
           ,
          
          
           γ
          
         
         
          \alpha,\beta,\gamma
         
        
       </span><span class="katex-html"><span class="base"><span class="strut" style="height: 0.88888em; vertical-align: -0.19444em;"></span><span class="mord mathdefault" style="margin-right: 0.0037em;">α</span><span class="mord cjk_fallback">,</span><span class="mord mathdefault" style="margin-right: 0.05278em;">β</span><span class="mord cjk_fallback">,</span><span class="mord mathdefault" style="margin-right: 0.05556em;">γ</span></span></span></span></span>。我们为了限制取样的数目,我们可以对它们选择 {0.5,0.4,0.6,0.8} 几种数值,可以得到 <span class="katex--inline"><span class="katex"><span class="katex-mathml">
       
        
         
          
           
            4
           
           
            3
           
          
          
           =
          
          
           64
          
         
         
          4^3 = 64
         
        
       </span><span class="katex-html"><span class="base"><span class="strut" style="height: 0.814108em; vertical-align: 0em;"></span><span class="mord"><span class="mord">4</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height: 0.814108em;"><span class="" style="top: -3.063em; margin-right: 0.05em;"><span class="pstrut" style="height: 2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">3</span></span></span></span></span></span></span></span><span class="mspace" style="margin-right: 0.277778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right: 0.277778em;"></span></span><span class="base"><span class="strut" style="height: 0.64444em; vertical-align: 0em;"></span><span class="mord">6</span><span class="mord">4</span></span></span></span></span> 个特征。其他类型的检测器可能需要窗口参数(window parameters),我们可以根据检测器的特点采用几个时间点、几天或者几周的窗口。例如,基于短窗口移动平均的检测器旨在识别局部异常,而时间序列分解通常使用一个周的窗口来捕获长期的异常行为(violations)。 虽然由于采样粒度相对较粗,这种采样策略不能保证我们能够找到最合适的参数(或特征),但我们只需要一组足够好的特征,而opprintice通过将它们结合起来就可以获得很好的精度。</li></ul> 
      

    5.4.4 机器学习

    1)思考和选择

    选择机器学习算法的时候要特别小心,因为在我们的问题中,存在冗余和不相关的特征,这是由于使用检测器时没有仔细评估而造成的。在一些机器学习算法中,如朴素贝叶斯、logistic回归、决策树和线性支持向量机,在处理这些训练数据时会表现得很差。另外,一个有前途的算法应该是参数较少且对其参数不敏感的,这样就可以很容易地应用于不同的数据集。本论文中采用的是随机森冷算法,它可以很好地处理噪音特征,在实际操作中效果很好。而且, 随机森林只有两个参数,并且算法效果对这两个参数不敏感。评估结果也展示随机森林算法效果更好,更加稳定。

    请注意,我们确实了解特征选择是一种常用的解决方案,用于减轻不相关和冗余特征的影响。然而,本文并没有对特征选择进行深入的研究,而是将其作为未来的工作,因为它可能会带来额外的计算开销,而且随机森林本身也能很好地工作。

    2)随机森林

    预备工作 (preliminaries):决策树

    随机森林(random forest):
    一个随机森林是一个使用了很多个决策树的集成分类器。它的主要思想是,一群弱学习者(例如,个体决策树)可以集成为一个强学习者。为了建立不同的树,一个随机的森林增加了一些元素或随机性。首先,对每棵树进行原始训练集的子集训练。其次,树不是在每一级评估所有特征,而是每次只考虑特征的随机子集。因此,如果树不使用这些特征,一些树可能不受或更少地受到不相关和冗余特征的影响。所有的树都是这样建立的,没有修剪。然后,随机森林以多数票将这些树合并。也就是说,给定一个新的数据点,每个树都给出自己的分类。例如,如果100棵树中有40棵树将该点分类为异常,则其异常概率为40%。默认情况下,随机林使用50%作为分类阈值(即cThld)。

    上述的随机性和集成特性使得随机森林比决策树对噪声更具鲁棒性,在面对无关和冗余特征时表现更好。

    5.4.5 配置分类阈值(Configuring cThld)

    1) PC-Score: 选择合适 cThld 的指标

    我们需要配置 cThld 而不是使用默认数值(比如0.5),有两个原因:

    • 数据集分类不均的问题(异常点可能是极少数)
    • 操作人员可以根据自己的偏好来配置异常检测的精度和召回率。配置cThld 是一种 在精确性和召回率进行权衡的通用方法。

    因此,我们应该适当地配置随机森林的 cThld,以满足操作人员的偏好。

    PR curve
    在描述如何配置cThld之前,我们首先使用 PR (Precision Recall) 曲线图来提供一些直观信息。PR曲线被广泛用于评估二值分类器的准确性,尤其是在数据不平衡的情况下。通常,精确性和召回之间存在权衡。如上图所示(图6),根据PV数据训练和测试的随机森林导出的示例 PR 曲线。两种假定的操作者 偏好(1) “recall ≥ 0.75 and precision ≥ 0.6”和 偏好(2) “recall ≥ 0.5 and precision ≥ 0.9” 阴影矩形表示。cThlds 的配置即在PR曲线上寻找一个合适的点。在图6中,三角形符号由默认的 cThld = 0.5选择。

    此外,我们还展示了另外两个精确度量的结果:

    • F-score
    • SD(1,1) 它选择到右上角的欧几里德距离最短的点,在这里精度和召回都是完美的。

    我们在图6中看到,PR曲线在两个矩形内都有点,但是默认阈值只满足 偏好(2),而不满足 偏好(1);F-score 和 SD(1,1) 两种偏好都不能满足。这是因为这些指标选择cThld时没有考虑操作员的偏好。

    基于上述事实,我们提出了一种简单而有效的基于 F-score 的准确度度量方法,即PC-score(preference centric Score),以明确考虑操操作人员的偏好。
    首先,对于p r曲线上的每个点(r,p),我们计算其 PC-score 如下:

         f
        
        
         (
        
        
         n
        
        
         )
        
        
         =
        
        
         
          {
         
         
          
           
            
             
              
               
                
                 2
                
                
                 ∗
                
                
                 r
                
                
                 ∗
                
                
                 p
                
               
               
                
                 r
                
                
                 +
                
                
                 p
                
               
              
              
               +
              
              
               1
              
              
               ,
              
             
            
           
           
            
             
              
               r
              
              
               ≥
              
              
               R
              
              
               &nbsp;
              
              
               a
              
              
               n
              
              
               d
              
              
               &nbsp;
              
              
               p
              
              
               ≥
              
              
               P
              
             
            
           
          
          
           
            
             
              
               
                
                 2
                
                
                 ∗
                
                
                 r
                
                
                 ∗
                
                
                 p
                
               
               
                
                 r
                
                
                 +
                
                
                 p
                
               
              
              
               ,
              
             
            
           
           
            
             
              
               o
              
              
               t
              
              
               h
              
              
               e
              
              
               r
              
              
               w
              
              
               i
              
              
               s
              
              
               e
              
             
            
           
          
         
        
       
       
         f(n)= <span class="MathJax_Preview" style="color: inherit; display: none;"></span><div class="MathJax_Display"><span class="MathJax MathJax_FullWidth" id="MathJax-Element-1-Frame" tabindex="0" data-mathml="<math xmlns=&quot;http://www.w3.org/1998/Math/MathML&quot; display=&quot;block&quot;><mrow><mo>{</mo><mtable columnalign=&quot;left left&quot; rowspacing=&quot;.2em&quot; columnspacing=&quot;1em&quot; displaystyle=&quot;false&quot;><mtr><mtd><mfrac><mrow><mn>2</mn><mo>&amp;#x2217;</mo><mi>r</mi><mo>&amp;#x2217;</mo><mi>p</mi></mrow><mrow><mi>r</mi><mo>+</mo><mi>p</mi></mrow></mfrac><mo>+</mo><mn>1</mn><mo>,</mo></mtd><mtd><mrow class=&quot;MJX-TeXAtom-ORD&quot;><mi>r</mi><mo>&amp;#x2265;</mo><mi>R</mi><mtext>&amp;#xA0;</mtext><mi>a</mi><mi>n</mi><mi>d</mi><mtext>&amp;#xA0;</mtext><mi>p</mi><mo>&amp;#x2265;</mo><mi>P</mi></mrow></mtd></mtr><mtr><mtd><mfrac><mrow><mn>2</mn><mo>&amp;#x2217;</mo><mi>r</mi><mo>&amp;#x2217;</mo><mi>p</mi></mrow><mrow><mi>r</mi><mo>+</mo><mi>p</mi></mrow></mfrac><mo>,</mo></mtd><mtd><mrow class=&quot;MJX-TeXAtom-ORD&quot;><mi>o</mi><mi>t</mi><mi>h</mi><mi>e</mi><mi>r</mi><mi>w</mi><mi>i</mi><mi>s</mi><mi>e</mi></mrow></mtd></mtr></mtable><mo fence=&quot;true&quot; stretchy=&quot;true&quot; symmetric=&quot;true&quot;></mo></mrow></math>" role="presentation" style="position: relative;"><nobr aria-hidden="true"><span class="math" id="MathJax-Span-1" style="width: 100%; display: inline-block; min-width: 13.376em;"><span style="display: inline-block; position: relative; width: 100%; height: 0px;"><span style="position: absolute; clip: rect(2.275em, 1013.34em, 5.837em, -1000.01em); top: -4.283em; left: 0em; width: 100%;"><span class="mrow" id="MathJax-Span-2"><span style="display: inline-block; position: relative; width: 100%; height: 0px;"><span style="position: absolute; clip: rect(2.275em, 1013.34em, 5.837em, -1000.01em); top: -4.283em; left: 50%; margin-left: -6.658em;"><span class="mrow" id="MathJax-Span-3"><span class="mo" id="MathJax-Span-4" style="vertical-align: -0.772em;"><span style="font-family: STIXSizeFourSym;">{</span></span><span class="mtable" id="MathJax-Span-5" style="padding-right: 0.157em; padding-left: 0.157em;"><span style="display: inline-block; position: relative; width: 11.982em; height: 0px;"><span style="position: absolute; clip: rect(2.275em, 1004em, 5.837em, -1000.01em); top: -4.283em; left: 0em;"><span style="display: inline-block; position: relative; width: 4.082em; height: 0px;"><span style="position: absolute; width: 100%; clip: rect(2.791em, 1004em, 4.598em, -1000.01em); top: -4.851em; left: 0em;"><span class="mtd" id="MathJax-Span-6"><span class="mrow" id="MathJax-Span-7"><span style="display: inline-block; position: relative; width: 100%; height: 0px;"><span style="position: absolute; clip: rect(2.791em, 1004em, 4.598em, -1000.01em); top: -3.973em; left: 50%; margin-left: -2.011em;"><span class="mfrac" id="MathJax-Span-8"><span style="display: inline-block; position: relative; width: 1.861em; height: 0px; margin-right: 0.106em; margin-left: 0.106em;"><span style="position: absolute; clip: rect(3.359em, 1001.72em, 4.288em, -1000.01em); top: -4.541em; left: 50%; margin-left: -0.875em;"><span class="mrow" id="MathJax-Span-9"><span style="display: inline-block; position: relative; width: 1.758em; height: 0px;"><span style="position: absolute; clip: rect(3.359em, 1001.72em, 4.288em, -1000.01em); top: -3.973em; left: 0em;"><span class="mn" id="MathJax-Span-10" style="font-size: 70.7%; font-family: STIXGeneral-Regular;">2</span><span class="mo" id="MathJax-Span-11" style="font-size: 70.7%; font-family: STIXGeneral-Regular;">∗</span><span class="mi" id="MathJax-Span-12" style="font-size: 70.7%; font-family: STIXGeneral-Italic;">r<span style="display: inline-block; overflow: hidden; height: 1px; width: 0.003em;"></span></span><span class="mo" id="MathJax-Span-13" style="font-size: 70.7%; font-family: STIXGeneral-Regular;">∗</span><span class="mi" id="MathJax-Span-14" style="font-size: 70.7%; font-family: STIXGeneral-Italic;">p</span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span></span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span><span style="position: absolute; clip: rect(3.462em, 1001.1em, 4.288em, -1000.01em); top: -3.612em; left: 50%; margin-left: -0.565em;"><span class="mrow" id="MathJax-Span-15"><span style="display: inline-block; position: relative; width: 1.139em; height: 0px;"><span style="position: absolute; clip: rect(3.462em, 1001.1em, 4.288em, -1000.01em); top: -3.973em; left: 0em;"><span class="mi" id="MathJax-Span-16" style="font-size: 70.7%; font-family: STIXGeneral-Italic;">r<span style="display: inline-block; overflow: hidden; height: 1px; width: 0.003em;"></span></span><span class="mo" id="MathJax-Span-17" style="font-size: 70.7%; font-family: STIXGeneral-Regular;">+</span><span class="mi" id="MathJax-Span-18" style="font-size: 70.7%; font-family: STIXGeneral-Italic;">p</span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span></span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span><span style="position: absolute; clip: rect(0.88em, 1001.88em, 1.242em, -1000.01em); top: -1.288em; left: 0em;"><span style="display: inline-block; overflow: hidden; vertical-align: 0em; border-top: 1.3px solid; width: 1.861em; height: 0px;"></span><span style="display: inline-block; width: 0px; height: 1.087em;"></span></span></span></span><span class="mo" id="MathJax-Span-19" style="font-family: STIXGeneral-Regular; padding-left: 0.261em;">+</span><span class="mn" id="MathJax-Span-20" style="font-family: STIXGeneral-Regular; padding-left: 0.261em;">1</span><span class="mo" id="MathJax-Span-21" style="font-family: STIXGeneral-Regular;">,</span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span></span></span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span><span style="position: absolute; width: 100%; clip: rect(2.791em, 1002.29em, 4.598em, -1000.01em); top: -3.096em; left: 0em;"><span class="mtd" id="MathJax-Span-37"><span class="mrow" id="MathJax-Span-38"><span style="display: inline-block; position: relative; width: 100%; height: 0px;"><span style="position: absolute; clip: rect(2.791em, 1002.29em, 4.598em, -1000.01em); top: -3.973em; left: 50%; margin-left: -1.185em;"><span class="mfrac" id="MathJax-Span-39"><span style="display: inline-block; position: relative; width: 1.861em; height: 0px; margin-right: 0.106em; margin-left: 0.106em;"><span style="position: absolute; clip: rect(3.359em, 1001.72em, 4.288em, -1000.01em); top: -4.541em; left: 50%; margin-left: -0.875em;"><span class="mrow" id="MathJax-Span-40"><span style="display: inline-block; position: relative; width: 1.758em; height: 0px;"><span style="position: absolute; clip: rect(3.359em, 1001.72em, 4.288em, -1000.01em); top: -3.973em; left: 0em;"><span class="mn" id="MathJax-Span-41" style="font-size: 70.7%; font-family: STIXGeneral-Regular;">2</span><span class="mo" id="MathJax-Span-42" style="font-size: 70.7%; font-family: STIXGeneral-Regular;">∗</span><span class="mi" id="MathJax-Span-43" style="font-size: 70.7%; font-family: STIXGeneral-Italic;">r<span style="display: inline-block; overflow: hidden; height: 1px; width: 0.003em;"></span></span><span class="mo" id="MathJax-Span-44" style="font-size: 70.7%; font-family: STIXGeneral-Regular;">∗</span><span class="mi" id="MathJax-Span-45" style="font-size: 70.7%; font-family: STIXGeneral-Italic;">p</span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span></span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span><span style="position: absolute; clip: rect(3.462em, 1001.1em, 4.288em, -1000.01em); top: -3.612em; left: 50%; margin-left: -0.565em;"><span class="mrow" id="MathJax-Span-46"><span style="display: inline-block; position: relative; width: 1.139em; height: 0px;"><span style="position: absolute; clip: rect(3.462em, 1001.1em, 4.288em, -1000.01em); top: -3.973em; left: 0em;"><span class="mi" id="MathJax-Span-47" style="font-size: 70.7%; font-family: STIXGeneral-Italic;">r<span style="display: inline-block; overflow: hidden; height: 1px; width: 0.003em;"></span></span><span class="mo" id="MathJax-Span-48" style="font-size: 70.7%; font-family: STIXGeneral-Regular;">+</span><span class="mi" id="MathJax-Span-49" style="font-size: 70.7%; font-family: STIXGeneral-Italic;">p</span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span></span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span><span style="position: absolute; clip: rect(0.88em, 1001.88em, 1.242em, -1000.01em); top: -1.288em; left: 0em;"><span style="display: inline-block; overflow: hidden; vertical-align: 0em; border-top: 1.3px solid; width: 1.861em; height: 0px;"></span><span style="display: inline-block; width: 0px; height: 1.087em;"></span></span></span></span><span class="mo" id="MathJax-Span-50" style="font-family: STIXGeneral-Regular;">,</span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span></span></span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span><span style="display: inline-block; width: 0px; height: 4.288em;"></span></span><span style="position: absolute; clip: rect(2.275em, 1006.78em, 5.063em, -1000.01em); top: -3.973em; left: 5.166em;"><span style="display: inline-block; position: relative; width: 6.767em; height: 0px;"><span style="position: absolute; width: 100%; clip: rect(3.152em, 1006.78em, 4.34em, -1000.01em); top: -4.851em; left: 0em;"><span class="mtd" id="MathJax-Span-22"><span class="mrow" id="MathJax-Span-23"><span style="display: inline-block; position: relative; width: 100%; height: 0px;"><span style="position: absolute; clip: rect(3.152em, 1006.78em, 4.34em, -1000.01em); top: -3.973em; left: 50%; margin-left: -3.405em;"><span class="texatom" id="MathJax-Span-24"><span class="mrow" id="MathJax-Span-25"><span style="display: inline-block; position: relative; width: 6.767em; height: 0px;"><span style="position: absolute; clip: rect(3.152em, 1006.78em, 4.34em, -1000.01em); top: -3.973em; left: 0em;"><span class="mi" id="MathJax-Span-26" style="font-family: STIXGeneral-Italic;">r<span style="display: inline-block; overflow: hidden; height: 1px; width: 0.003em;"></span></span><span class="mo" id="MathJax-Span-27" style="font-family: STIXGeneral-Regular; padding-left: 0.312em;">≥</span><span class="mi" id="MathJax-Span-28" style="font-family: STIXGeneral-Italic; padding-left: 0.312em;">R</span><span class="mtext" id="MathJax-Span-29" style="font-family: STIXGeneral-Regular;">&nbsp;</span><span class="mi" id="MathJax-Span-30" style="font-family: STIXGeneral-Italic;">a</span><span class="mi" id="MathJax-Span-31" style="font-family: STIXGeneral-Italic;">n</span><span class="mi" id="MathJax-Span-32" style="font-family: STIXGeneral-Italic;">d<span style="display: inline-block; overflow: hidden; height: 1px; width: 0.054em;"></span></span><span class="mtext" id="MathJax-Span-33" style="font-family: STIXGeneral-Regular;">&nbsp;</span><span class="mi" id="MathJax-Span-34" style="font-family: STIXGeneral-Italic;">p</span><span class="mo" id="MathJax-Span-35" style="font-family: STIXGeneral-Regular; padding-left: 0.312em;">≥</span><span class="mi" id="MathJax-Span-36" style="font-family: STIXGeneral-Italic; padding-left: 0.312em;">P</span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span></span></span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span></span></span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span><span style="position: absolute; width: 100%; clip: rect(3.152em, 1003.89em, 4.133em, -1000.01em); top: -3.096em; left: 0em;"><span class="mtd" id="MathJax-Span-51"><span class="mrow" id="MathJax-Span-52"><span style="display: inline-block; position: relative; width: 100%; height: 0px;"><span style="position: absolute; clip: rect(3.152em, 1003.89em, 4.133em, -1000.01em); top: -3.973em; left: 50%; margin-left: -1.96em;"><span class="texatom" id="MathJax-Span-53"><span class="mrow" id="MathJax-Span-54"><span style="display: inline-block; position: relative; width: 3.927em; height: 0px;"><span style="position: absolute; clip: rect(3.152em, 1003.89em, 4.133em, -1000.01em); top: -3.973em; left: 0em;"><span class="mi" id="MathJax-Span-55" style="font-family: STIXGeneral-Italic;">o</span><span class="mi" id="MathJax-Span-56" style="font-family: STIXGeneral-Italic;">t<span style="display: inline-block; overflow: hidden; height: 1px; width: 0.003em;"></span></span><span class="mi" id="MathJax-Span-57" style="font-family: STIXGeneral-Italic;">h</span><span class="mi" id="MathJax-Span-58" style="font-family: STIXGeneral-Italic;">e</span><span class="mi" id="MathJax-Span-59" style="font-family: STIXGeneral-Italic;">r<span style="display: inline-block; overflow: hidden; height: 1px; width: 0.003em;"></span></span><span class="mi" id="MathJax-Span-60" style="font-family: STIXGeneral-Italic;">w</span><span class="mi" id="MathJax-Span-61" style="font-family: STIXGeneral-Italic;">i</span><span class="mi" id="MathJax-Span-62" style="font-family: STIXGeneral-Italic;">s</span><span class="mi" id="MathJax-Span-63" style="font-family: STIXGeneral-Italic;">e</span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span></span></span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span></span></span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span></span><span class="mo" id="MathJax-Span-64"></span></span><span style="display: inline-block; width: 0px; height: 4.288em;"></span></span></span></span><span style="display: inline-block; width: 0px; height: 4.288em;"></span></span></span><span style="display: inline-block; overflow: hidden; vertical-align: -1.443em; border-left: 0px solid; width: 0px; height: 3.359em;"></span></span></nobr><span class="MJX_Assistive_MathML MJX_Assistive_MathML_Block" role="presentation"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow><mo>{</mo><mtable columnalign="left left" rowspacing=".2em" columnspacing="1em" displaystyle="false"><mtr><mtd><mfrac><mrow><mn>2</mn><mo>∗</mo><mi>r</mi><mo>∗</mo><mi>p</mi></mrow><mrow><mi>r</mi><mo>+</mo><mi>p</mi></mrow></mfrac><mo>+</mo><mn>1</mn><mo>,</mo></mtd><mtd><mrow class="MJX-TeXAtom-ORD"><mi>r</mi><mo>≥</mo><mi>R</mi><mtext>&nbsp;</mtext><mi>a</mi><mi>n</mi><mi>d</mi><mtext>&nbsp;</mtext><mi>p</mi><mo>≥</mo><mi>P</mi></mrow></mtd></mtr><mtr><mtd><mfrac><mrow><mn>2</mn><mo>∗</mo><mi>r</mi><mo>∗</mo><mi>p</mi></mrow><mrow><mi>r</mi><mo>+</mo><mi>p</mi></mrow></mfrac><mo>,</mo></mtd><mtd><mrow class="MJX-TeXAtom-ORD"><mi>o</mi><mi>t</mi><mi>h</mi><mi>e</mi><mi>r</mi><mi>w</mi><mi>i</mi><mi>s</mi><mi>e</mi></mrow></mtd></mtr></mtable><mo fence="true" stretchy="true" symmetric="true"></mo></mrow></math></span></span></div><script type="math/tex; mode=display" id="MathJax-Element-1">\begin{cases} \frac{2*r*p}{r+p}+1, & {r \geq R\ and\ p \geq P} \\ \frac{2*r*p}{r+p}, & {otherwise} \end{cases}</script> 
       
      
     </span><span class="katex-html"><span class="base"><span class="strut" style="height: 1em; vertical-align: -0.25em;"></span><span class="mord mathdefault" style="margin-right: 0.10764em;">f</span><span class="mopen">(</span><span class="mord mathdefault">n</span><span class="mclose">)</span><span class="mspace" style="margin-right: 0.277778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right: 0.277778em;"></span></span><span class="base"><span class="strut" style="height: 3.00003em; vertical-align: -1.25003em;"></span><span class="minner"><span class="mopen delimcenter" style="top: 0em;"><span class="delimsizing size4">{<!-- --></span></span><span class="mord"><span class="mtable"><span class="col-align-l"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height: 1.73911em;"><span class="" style="top: -3.73911em;"><span class="pstrut" style="height: 3.008em;"></span><span class="mord"><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height: 0.897216em;"><span class="" style="top: -2.655em;"><span class="pstrut" style="height: 3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathdefault mtight" style="margin-right: 0.02778em;">r</span><span class="mbin mtight">+</span><span class="mord mathdefault mtight">p</span></span></span></span><span class="" style="top: -3.23em;"><span class="pstrut" style="height: 3em;"></span><span class="frac-line" style="border-bottom-width: 0.04em;"></span></span><span class="" style="top: -3.44611em;"><span class="pstrut" style="height: 3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">2</span><span class="mbin mtight">∗</span><span class="mord mathdefault mtight" style="margin-right: 0.02778em;">r</span><span class="mbin mtight">∗</span><span class="mord mathdefault mtight">p</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height: 0.481108em;"><span class=""></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mspace" style="margin-right: 0.222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right: 0.222222em;"></span><span class="mord">1</span><span class="mpunct">,</span></span></span><span class="" style="top: -2.25em;"><span class="pstrut" style="height: 3.008em;"></span><span class="mord"><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height: 0.897216em;"><span class="" style="top: -2.655em;"><span class="pstrut" style="height: 3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathdefault mtight" style="margin-right: 0.02778em;">r</span><span class="mbin mtight">+</span><span class="mord mathdefault mtight">p</span></span></span></span><span class="" style="top: -3.23em;"><span class="pstrut" style="height: 3em;"></span><span class="frac-line" style="border-bottom-width: 0.04em;"></span></span><span class="" style="top: -3.44611em;"><span class="pstrut" style="height: 3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">2</span><span class="mbin mtight">∗</span><span class="mord mathdefault mtight" style="margin-right: 0.02778em;">r</span><span class="mbin mtight">∗</span><span class="mord mathdefault mtight">p</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height: 0.481108em;"><span class=""></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mpunct">,</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height: 1.23911em;"><span class=""></span></span></span></span></span><span class="arraycolsep" style="width: 1em;"></span><span class="col-align-l"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height: 1.73911em;"><span class="" style="top: -3.73911em;"><span class="pstrut" style="height: 3.008em;"></span><span class="mord"><span class="mord"><span class="mord mathdefault" style="margin-right: 0.02778em;">r</span><span class="mspace" style="margin-right: 0.277778em;"></span><span class="mrel">≥</span><span class="mspace" style="margin-right: 0.277778em;"></span><span class="mord mathdefault" style="margin-right: 0.00773em;">R</span><span class="mspace">&nbsp;</span><span class="mord mathdefault">a</span><span class="mord mathdefault">n</span><span class="mord mathdefault">d</span><span class="mspace">&nbsp;</span><span class="mord mathdefault">p</span><span class="mspace" style="margin-right: 0.277778em;"></span><span class="mrel">≥</span><span class="mspace" style="margin-right: 0.277778em;"></span><span class="mord mathdefault" style="margin-right: 0.13889em;">P</span></span></span></span><span class="" style="top: -2.25em;"><span class="pstrut" style="height: 3.008em;"></span><span class="mord"><span class="mord"><span class="mord mathdefault">o</span><span class="mord mathdefault">t</span><span class="mord mathdefault">h</span><span class="mord mathdefault">e</span><span class="mord mathdefault" style="margin-right: 0.02778em;">r</span><span class="mord mathdefault" style="margin-right: 0.02691em;">w</span><span class="mord mathdefault">i</span><span class="mord mathdefault">s</span><span class="mord mathdefault">e</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height: 1.23911em;"><span class=""></span></span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span></span></span></span></span></span><br> 其中的R和P是来自于操作人员的偏好 "recall<span class="katex--inline"><span class="katex"><span class="katex-mathml">
    
     
      
       
        ≥
       
       
        R
       
      
      
       \geq R
      
     
    </span><span class="katex-html"><span class="base"><span class="strut" style="height: 0.77194em; vertical-align: -0.13597em;"></span><span class="mrel">≥</span><span class="mspace" style="margin-right: 0.277778em;"></span></span><span class="base"><span class="strut" style="height: 0.68333em; vertical-align: 0em;"></span><span class="mord mathdefault" style="margin-right: 0.00773em;">R</span></span></span></span></span> and precision <span class="katex--inline"><span class="katex"><span class="katex-mathml">
    
     
      
       
        ≥
       
       
        P
       
      
      
       \geq P
      
     
    </span><span class="katex-html"><span class="base"><span class="strut" style="height: 0.77194em; vertical-align: -0.13597em;"></span><span class="mrel">≥</span><span class="mspace" style="margin-right: 0.277778em;"></span></span><span class="base"><span class="strut" style="height: 0.68333em; vertical-align: 0em;"></span><span class="mord mathdefault" style="margin-right: 0.13889em;">P</span></span></span></span></span>"。PC-score 基本上是用来衡量 (r,p) 的F-score。为了找到满足操作人员偏好的点(如果存在的话),当 <span class="katex--inline"><span class="katex"><span class="katex-mathml">
    
     
      
       
        r
       
       
        ≥
       
       
        R
       
       
        &nbsp;
       
       
        a
       
       
        n
       
       
        d
       
       
        &nbsp;
       
       
        p
       
       
        ≥
       
       
        P
       
      
      
       r \geq R\ and\ p \geq P
      
     
    </span><span class="katex-html"><span class="base"><span class="strut" style="height: 0.77194em; vertical-align: -0.13597em;"></span><span class="mord mathdefault" style="margin-right: 0.02778em;">r</span><span class="mspace" style="margin-right: 0.277778em;"></span><span class="mrel">≥</span><span class="mspace" style="margin-right: 0.277778em;"></span></span><span class="base"><span class="strut" style="height: 0.88888em; vertical-align: -0.19444em;"></span><span class="mord mathdefault" style="margin-right: 0.00773em;">R</span><span class="mspace">&nbsp;</span><span class="mord mathdefault">a</span><span class="mord mathdefault">n</span><span class="mord mathdefault">d</span><span class="mspace">&nbsp;</span><span class="mord mathdefault">p</span><span class="mspace" style="margin-right: 0.277778em;"></span><span class="mrel">≥</span><span class="mspace" style="margin-right: 0.277778em;"></span></span><span class="base"><span class="strut" style="height: 0.68333em; vertical-align: 0em;"></span><span class="mord mathdefault" style="margin-right: 0.13889em;">P</span></span></span></span></span> 时,我们给 F-score 计算公式加1,作为激励常数(an incentive constant)。由于 F-score 不超过1,这个激励常数确保满足偏好的分数必须比不满足偏好的分数具有更大的PC分数。因此,我们选择与 PC-score 最大的点对应的 cThld 参数。在图6中,我们看到基于 PC-score 选择的两个点分别位于两个阴影接收角内。请注意,在PR曲线在偏好区域内没有点的情况下,PC-score 无法找到所需的点,但它仍然可以选择近似的召回率和精确度。</p> 
    

    2)基于EWMA的 cThld 预测

    EWMA 在4.3.3 介绍过 (Exponentially Weighted Moving Average),一个基于预测的检测器

    上面描述了如何在离线或“oracle”模式下根据PC-score 配置cThld。也就是说,我们在要检测的数据(也称为测试集)已经到达之后配置 cThld 。这些 cThld 是我们可以配置用于检测这些数据的最佳cThld,称为 best cThld 。然而,对于在线检测,我们需要预测 cThld 来检测未来的数据。

    为此,另一种方法是 k-fold 交叉验证。首先,将历史训练集划分为相同长度的k个子集。在每个测试(总共k个测试)中,使用子集中的k-1训练分类器,并使用cThld候选者对其余的分类器进行测试。在k个测试中获得最小平均PC分数的候选用于将来的检测。在本文中,我们使用k=5,并以0.001的非常细的粒度扫描cThld的空间,即我们在[0,1]的范围内评估1000个cThld候选。

    然而,我们发现这种交叉验证方法在我们的问题中并不十分有效(参加5.6)。一个可能的解释是,如图7所示,最佳 cThld 在数周内可能有很大的差异。因此,在交叉验证中,在所有历史数据上获得最高平均性能的 cThld 可能与未来一周的最佳 cThld 差别很大。

    best cThld
    我们的方法是由图7中的另一个观察结果驱动的。也就是说,尽管最好的cthld会在几周内发生变化,但它们可能更类似于相邻几周的 cThld。一种可能的解释是,导致KPI异常的潜在问题可能会在它们真正修复之前持续一段时间,因此相邻的几周更有可能出现类似的异常,并需要类似的 cThld。因此,我们基于历史数据中最好的cThld,采用 cThld 来预测 第 i 周(或者第 i 个测试集)的 cThld。
    特别的是,EWMA 通过以下方式工作:

         c
        
        
         T
        
        
         h
        
        
         l
        
        
         
          d
         
         
          i
         
         
          p
         
        
        
         =
        
        
         
          {
         
         
          
           
            
             
              
               
                α
               
               
                ∗
               
               
                c
               
               
                T
               
               
                h
               
               
                l
               
               
                
                 d
                
                
                 
                  i
                 
                 
                  −
                 
                 
                  1
                 
                
                
                 b
                
               
              
              
               +
              
              
               (
              
              
               1
              
              
               −
              
              
               α
              
              
               )
              
              
               ∗
              
              
               c
              
              
               T
              
              
               h
              
              
               l
              
              
               
                d
               
               
                
                 i
                
                
                 −
                
                
                 1
                
               
               
                p
               
              
              
               ,
              
             
            
           
           
            
             
              
               i
              
              
               &gt;
              
              
               1
              
             
            
           
          
          
           
            
             
              
               5
              
              
               &nbsp;
              
              
               f
              
              
               o
              
              
               l
              
              
               d
              
              
               &nbsp;
              
              
               p
              
              
               r
              
              
               e
              
              
               d
              
              
               i
              
              
               c
              
              
               t
              
              
               i
              
              
               o
              
              
               n
              
              
               ,
              
             
            
           
           
            
             
              
               i
              
              
               =
              
              
               1
              
             
            
           
          
         
        
       
       
         cThld^p_i = <span class="MathJax_Preview" style="color: inherit; display: none;"></span><div class="MathJax_Display"><span class="MathJax MathJax_FullWidth" id="MathJax-Element-2-Frame" tabindex="0" data-mathml="<math xmlns=&quot;http://www.w3.org/1998/Math/MathML&quot; display=&quot;block&quot;><mrow><mo>{</mo><mtable columnalign=&quot;left left&quot; rowspacing=&quot;.2em&quot; columnspacing=&quot;1em&quot; displaystyle=&quot;false&quot;><mtr><mtd><mrow class=&quot;MJX-TeXAtom-ORD&quot;><mi>&amp;#x03B1;</mi><mo>&amp;#x2217;</mo><mi>c</mi><mi>T</mi><mi>h</mi><mi>l</mi><msubsup><mi>d</mi><mrow class=&quot;MJX-TeXAtom-ORD&quot;><mi>i</mi><mo>&amp;#x2212;</mo><mn>1</mn></mrow><mi>b</mi></msubsup></mrow><mo>+</mo><mo stretchy=&quot;false&quot;>(</mo><mn>1</mn><mo>&amp;#x2212;</mo><mi>&amp;#x03B1;</mi><mo stretchy=&quot;false&quot;>)</mo><mo>&amp;#x2217;</mo><mi>c</mi><mi>T</mi><mi>h</mi><mi>l</mi><msubsup><mi>d</mi><mrow class=&quot;MJX-TeXAtom-ORD&quot;><mi>i</mi><mo>&amp;#x2212;</mo><mn>1</mn></mrow><mi>p</mi></msubsup><mo>,</mo></mtd><mtd><mrow class=&quot;MJX-TeXAtom-ORD&quot;><mi>i</mi><mo>&amp;gt;</mo><mn>1</mn></mrow></mtd></mtr><mtr><mtd><mn>5</mn><mtext>&amp;#xA0;</mtext><mi>f</mi><mi>o</mi><mi>l</mi><mi>d</mi><mtext>&amp;#xA0;</mtext><mi>p</mi><mi>r</mi><mi>e</mi><mi>d</mi><mi>i</mi><mi>c</mi><mi>t</mi><mi>i</mi><mi>o</mi><mi>n</mi><mo>,</mo></mtd><mtd><mrow class=&quot;MJX-TeXAtom-ORD&quot;><mi>i</mi><mo>=</mo><mn>1</mn></mrow></mtd></mtr></mtable><mo fence=&quot;true&quot; stretchy=&quot;true&quot; symmetric=&quot;true&quot;></mo></mrow></math>" role="presentation" style="position: relative;"><nobr aria-hidden="true"><span class="math" id="MathJax-Span-65" style="width: 100%; display: inline-block; min-width: 18.385em;"><span style="display: inline-block; position: relative; width: 100%; height: 0px;"><span style="position: absolute; clip: rect(2.326em, 1018.4em, 5.114em, -1000.01em); top: -3.973em; left: 0em; width: 100%;"><span class="mrow" id="MathJax-Span-66"><span style="display: inline-block; position: relative; width: 100%; height: 0px;"><span style="position: absolute; clip: rect(2.326em, 1018.4em, 5.114em, -1000.01em); top: -3.973em; left: 50%; margin-left: -9.188em;"><span class="mrow" id="MathJax-Span-67"><span class="mo" id="MathJax-Span-68" style="vertical-align: -0.565em;"><span style="font-family: STIXSizeThreeSym;">{</span></span><span class="mtable" id="MathJax-Span-69" style="padding-right: 0.157em; padding-left: 0.157em;"><span style="display: inline-block; position: relative; width: 17.145em; height: 0px;"><span style="position: absolute; clip: rect(2.326em, 1013.91em, 5.114em, -1000.01em); top: -3.973em; left: 0em;"><span style="display: inline-block; position: relative; width: 13.944em; height: 0px;"><span style="position: absolute; width: 100%; clip: rect(2.997em, 1013.91em, 4.546em, -1000.01em); top: -4.645em; left: 0em;"><span class="mtd" id="MathJax-Span-70"><span class="mrow" id="MathJax-Span-71"><span style="display: inline-block; position: relative; width: 100%; height: 0px;"><span style="position: absolute; clip: rect(2.997em, 1013.91em, 4.546em, -1000.01em); top: -3.973em; left: 50%; margin-left: -6.968em;"><span class="texatom" id="MathJax-Span-72"><span class="mrow" id="MathJax-Span-73"><span style="display: inline-block; position: relative; width: 5.063em; height: 0px;"><span style="position: absolute; clip: rect(2.997em, 1005.08em, 4.546em, -1000.01em); top: -3.973em; left: 0em;"><span class="mi" id="MathJax-Span-74" style="font-family: STIXGeneral-Italic;">α</span><span class="mo" id="MathJax-Span-75" style="font-family: STIXGeneral-Regular; padding-left: 0.261em;">∗</span><span class="mi" id="MathJax-Span-76" style="font-family: STIXGeneral-Italic; padding-left: 0.261em;">c</span><span class="mi" id="MathJax-Span-77" style="font-family: STIXGeneral-Italic;">T<span style="display: inline-block; overflow: hidden; height: 1px; width: 0.054em;"></span></span><span class="mi" id="MathJax-Span-78" style="font-family: STIXGeneral-Italic;">h</span><span class="mi" id="MathJax-Span-79" style="font-family: STIXGeneral-Italic;">l<span style="display: inline-block; overflow: hidden; height: 1px; width: 0.003em;"></span></span><span class="msubsup" id="MathJax-Span-80"><span style="display: inline-block; position: relative; width: 1.603em; height: 0px;"><span style="position: absolute; clip: rect(3.152em, 1000.54em, 4.133em, -1000.01em); top: -3.973em; left: 0em;"><span class="mi" id="MathJax-Span-81" style="font-family: STIXGeneral-Italic;">d<span style="display: inline-block; overflow: hidden; height: 1px; width: 0.054em;"></span></span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span><span style="position: absolute; clip: rect(3.359em, 1000.43em, 4.133em, -1000.01em); top: -4.335em; left: 0.571em;"><span class="mi" id="MathJax-Span-82" style="font-size: 70.7%; font-family: STIXGeneral-Italic;">b</span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span><span style="position: absolute; clip: rect(3.359em, 1001.1em, 4.237em, -1000.01em); top: -3.664em; left: 0.519em;"><span class="texatom" id="MathJax-Span-83"><span class="mrow" id="MathJax-Span-84"><span style="display: inline-block; position: relative; width: 1.035em; height: 0px;"><span style="position: absolute; clip: rect(3.359em, 1000.95em, 4.237em, -1000.01em); top: -3.973em; left: 0em;"><span class="mi" id="MathJax-Span-85" style="font-size: 70.7%; font-family: STIXGeneral-Italic;">i</span><span class="mo" id="MathJax-Span-86" style="font-size: 70.7%; font-family: STIXGeneral-Regular;">−</span><span class="mn" id="MathJax-Span-87" style="font-size: 70.7%; font-family: STIXGeneral-Regular;">1</span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span></span></span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span></span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span></span></span><span class="mo" id="MathJax-Span-88" style="font-family: STIXGeneral-Regular; padding-left: 0.261em;">+</span><span class="mo" id="MathJax-Span-89" style="font-family: STIXGeneral-Regular; padding-left: 0.261em;">(</span><span class="mn" id="MathJax-Span-90" style="font-family: STIXGeneral-Regular;">1</span><span class="mo" id="MathJax-Span-91" style="font-family: STIXGeneral-Regular; padding-left: 0.261em;">−</span><span class="mi" id="MathJax-Span-92" style="font-family: STIXGeneral-Italic; padding-left: 0.261em;">α</span><span class="mo" id="MathJax-Span-93" style="font-family: STIXGeneral-Regular;">)</span><span class="mo" id="MathJax-Span-94" style="font-family: STIXGeneral-Regular; padding-left: 0.261em;">∗</span><span class="mi" id="MathJax-Span-95" style="font-family: STIXGeneral-Italic; padding-left: 0.261em;">c</span><span class="mi" id="MathJax-Span-96" style="font-family: STIXGeneral-Italic;">T<span style="display: inline-block; overflow: hidden; height: 1px; width: 0.054em;"></span></span><span class="mi" id="MathJax-Span-97" style="font-family: STIXGeneral-Italic;">h</span><span class="mi" id="MathJax-Span-98" style="font-family: STIXGeneral-Italic;">l<span style="display: inline-block; overflow: hidden; height: 1px; width: 0.003em;"></span></span><span class="msubsup" id="MathJax-Span-99"><span style="display: inline-block; position: relative; width: 1.603em; height: 0px;"><span style="position: absolute; clip: rect(3.152em, 1000.54em, 4.133em, -1000.01em); top: -3.973em; left: 0em;"><span class="mi" id="MathJax-Span-100" style="font-family: STIXGeneral-Italic;">d<span style="display: inline-block; overflow: hidden; height: 1px; width: 0.054em;"></span></span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span><span style="position: absolute; clip: rect(3.514em, 1000.43em, 4.288em, -1000.01em); top: -4.438em; left: 0.571em;"><span class="mi" id="MathJax-Span-101" style="font-size: 70.7%; font-family: STIXGeneral-Italic;">p</span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span><span style="position: absolute; clip: rect(3.359em, 1001.1em, 4.237em, -1000.01em); top: -3.664em; left: 0.519em;"><span class="texatom" id="MathJax-Span-102"><span class="mrow" id="MathJax-Span-103"><span style="display: inline-block; position: relative; width: 1.035em; height: 0px;"><span style="position: absolute; clip: rect(3.359em, 1000.95em, 4.237em, -1000.01em); top: -3.973em; left: 0em;"><span class="mi" id="MathJax-Span-104" style="font-size: 70.7%; font-family: STIXGeneral-Italic;">i</span><span class="mo" id="MathJax-Span-105" style="font-size: 70.7%; font-family: STIXGeneral-Regular;">−</span><span class="mn" id="MathJax-Span-106" style="font-size: 70.7%; font-family: STIXGeneral-Regular;">1</span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span></span></span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span></span><span class="mo" id="MathJax-Span-107" style="font-family: STIXGeneral-Regular;">,</span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span></span></span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span><span style="position: absolute; width: 100%; clip: rect(3.152em, 1007.09em, 4.34em, -1000.01em); top: -3.199em; left: 0em;"><span class="mtd" id="MathJax-Span-115"><span class="mrow" id="MathJax-Span-116"><span style="display: inline-block; position: relative; width: 100%; height: 0px;"><span style="position: absolute; clip: rect(3.152em, 1007.09em, 4.34em, -1000.01em); top: -3.973em; left: 50%; margin-left: -3.56em;"><span class="mn" id="MathJax-Span-117" style="font-family: STIXGeneral-Regular;">5</span><span class="mtext" id="MathJax-Span-118" style="font-family: STIXGeneral-Regular;">&nbsp;</span><span class="mi" id="MathJax-Span-119" style="font-family: STIXGeneral-Italic;">f<span style="display: inline-block; overflow: hidden; height: 1px; width: 0.157em;"></span></span><span class="mi" id="MathJax-Span-120" style="font-family: STIXGeneral-Italic;">o</span><span class="mi" id="MathJax-Span-121" style="font-family: STIXGeneral-Italic;">l<span style="display: inline-block; overflow: hidden; height: 1px; width: 0.003em;"></span></span><span class="mi" id="MathJax-Span-122" style="font-family: STIXGeneral-Italic;">d<span style="display: inline-block; overflow: hidden; height: 1px; width: 0.054em;"></span></span><span class="mtext" id="MathJax-Span-123" style="font-family: STIXGeneral-Regular;">&nbsp;</span><span class="mi" id="MathJax-Span-124" style="font-family: STIXGeneral-Italic;">p</span><span class="mi" id="MathJax-Span-125" style="font-family: STIXGeneral-Italic;">r<span style="display: inline-block; overflow: hidden; height: 1px; width: 0.003em;"></span></span><span class="mi" id="MathJax-Span-126" style="font-family: STIXGeneral-Italic;">e</span><span class="mi" id="MathJax-Span-127" style="font-family: STIXGeneral-Italic;">d<span style="display: inline-block; overflow: hidden; height: 1px; width: 0.054em;"></span></span><span class="mi" id="MathJax-Span-128" style="font-family: STIXGeneral-Italic;">i</span><span class="mi" id="MathJax-Span-129" style="font-family: STIXGeneral-Italic;">c</span><span class="mi" id="MathJax-Span-130" style="font-family: STIXGeneral-Italic;">t<span style="display: inline-block; overflow: hidden; height: 1px; width: 0.003em;"></span></span><span class="mi" id="MathJax-Span-131" style="font-family: STIXGeneral-Italic;">i</span><span class="mi" id="MathJax-Span-132" style="font-family: STIXGeneral-Italic;">o</span><span class="mi" id="MathJax-Span-133" style="font-family: STIXGeneral-Italic;">n</span><span class="mo" id="MathJax-Span-134" style="font-family: STIXGeneral-Regular;">,</span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span></span></span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span><span style="position: absolute; clip: rect(2.481em, 1001.98em, 4.908em, -1000.01em); top: -3.973em; left: 15.08em;"><span style="display: inline-block; position: relative; width: 2.068em; height: 0px;"><span style="position: absolute; width: 100%; clip: rect(3.152em, 1001.98em, 4.133em, -1000.01em); top: -4.645em; left: 0em;"><span class="mtd" id="MathJax-Span-108"><span class="mrow" id="MathJax-Span-109"><span style="display: inline-block; position: relative; width: 100%; height: 0px;"><span style="position: absolute; clip: rect(3.152em, 1001.98em, 4.133em, -1000.01em); top: -3.973em; left: 50%; margin-left: -1.03em;"><span class="texatom" id="MathJax-Span-110"><span class="mrow" id="MathJax-Span-111"><span style="display: inline-block; position: relative; width: 2.068em; height: 0px;"><span style="position: absolute; clip: rect(3.152em, 1001.98em, 4.133em, -1000.01em); top: -3.973em; left: 0em;"><span class="mi" id="MathJax-Span-112" style="font-family: STIXGeneral-Italic;">i</span><span class="mo" id="MathJax-Span-113" style="font-family: STIXGeneral-Regular; padding-left: 0.312em;">&gt;</span><span class="mn" id="MathJax-Span-114" style="font-family: STIXGeneral-Regular; padding-left: 0.312em;">1</span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span></span></span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span></span></span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span><span style="position: absolute; width: 100%; clip: rect(3.152em, 1001.98em, 4.133em, -1000.01em); top: -3.199em; left: 0em;"><span class="mtd" id="MathJax-Span-135"><span class="mrow" id="MathJax-Span-136"><span style="display: inline-block; position: relative; width: 100%; height: 0px;"><span style="position: absolute; clip: rect(3.152em, 1001.98em, 4.133em, -1000.01em); top: -3.973em; left: 50%; margin-left: -1.03em;"><span class="texatom" id="MathJax-Span-137"><span class="mrow" id="MathJax-Span-138"><span style="display: inline-block; position: relative; width: 2.068em; height: 0px;"><span style="position: absolute; clip: rect(3.152em, 1001.98em, 4.133em, -1000.01em); top: -3.973em; left: 0em;"><span class="mi" id="MathJax-Span-139" style="font-family: STIXGeneral-Italic;">i</span><span class="mo" id="MathJax-Span-140" style="font-family: STIXGeneral-Regular; padding-left: 0.312em;">=</span><span class="mn" id="MathJax-Span-141" style="font-family: STIXGeneral-Regular; padding-left: 0.312em;">1</span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span></span></span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span></span></span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span></span><span class="mo" id="MathJax-Span-142"></span></span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span></span><span style="display: inline-block; width: 0px; height: 3.978em;"></span></span></span><span style="display: inline-block; overflow: hidden; vertical-align: -1.03em; border-left: 0px solid; width: 0px; height: 2.584em;"></span></span></nobr><span class="MJX_Assistive_MathML MJX_Assistive_MathML_Block" role="presentation"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow><mo>{</mo><mtable columnalign="left left" rowspacing=".2em" columnspacing="1em" displaystyle="false"><mtr><mtd><mrow class="MJX-TeXAtom-ORD"><mi>α</mi><mo>∗</mo><mi>c</mi><mi>T</mi><mi>h</mi><mi>l</mi><msubsup><mi>d</mi><mrow class="MJX-TeXAtom-ORD"><mi>i</mi><mo>−</mo><mn>1</mn></mrow><mi>b</mi></msubsup></mrow><mo>+</mo><mo stretchy="false">(</mo><mn>1</mn><mo>−</mo><mi>α</mi><mo stretchy="false">)</mo><mo>∗</mo><mi>c</mi><mi>T</mi><mi>h</mi><mi>l</mi><msubsup><mi>d</mi><mrow class="MJX-TeXAtom-ORD"><mi>i</mi><mo>−</mo><mn>1</mn></mrow><mi>p</mi></msubsup><mo>,</mo></mtd><mtd><mrow class="MJX-TeXAtom-ORD"><mi>i</mi><mo>&gt;</mo><mn>1</mn></mrow></mtd></mtr><mtr><mtd><mn>5</mn><mtext>&nbsp;</mtext><mi>f</mi><mi>o</mi><mi>l</mi><mi>d</mi><mtext>&nbsp;</mtext><mi>p</mi><mi>r</mi><mi>e</mi><mi>d</mi><mi>i</mi><mi>c</mi><mi>t</mi><mi>i</mi><mi>o</mi><mi>n</mi><mo>,</mo></mtd><mtd><mrow class="MJX-TeXAtom-ORD"><mi>i</mi><mo>=</mo><mn>1</mn></mrow></mtd></mtr></mtable><mo fence="true" stretchy="true" symmetric="true"></mo></mrow></math></span></span></div><script type="math/tex; mode=display" id="MathJax-Element-2">\begin{cases} {\alpha*cThld^b_{i-1}}+(1-\alpha)*cThld^p_{i-1}, & {i> 1} \\ 5\ fold \ prediction, & {i=1} \end{cases}</script> 
       
      
     </span><span class="katex-html"><span class="base"><span class="strut" style="height: 1.05916em; vertical-align: -0.276864em;"></span><span class="mord mathdefault">c</span><span class="mord mathdefault" style="margin-right: 0.13889em;">T</span><span class="mord mathdefault">h</span><span class="mord mathdefault" style="margin-right: 0.01968em;">l</span><span class="mord"><span class="mord mathdefault">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height: 0.7823em;"><span class="" style="top: -2.42314em; margin-left: 0em; margin-right: 0.05em;"><span class="pstrut" style="height: 2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight">i</span></span></span><span class="" style="top: -3.18091em; margin-right: 0.05em;"><span class="pstrut" style="height: 2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight">p</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height: 0.276864em;"><span class=""></span></span></span></span></span></span><span class="mspace" style="margin-right: 0.277778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right: 0.277778em;"></span></span><span class="base"><span class="strut" style="height: 3.00003em; vertical-align: -1.25003em;"></span><span class="minner"><span class="mopen delimcenter" style="top: 0em;"><span class="delimsizing size4">{<!-- --></span></span><span class="mord"><span class="mtable"><span class="col-align-l"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height: 1.69em;"><span class="" style="top: -3.69em;"><span class="pstrut" style="height: 3.008em;"></span><span class="mord"><span class="mord"><span class="mord mathdefault" style="margin-right: 0.0037em;">α</span><span class="mspace" style="margin-right: 0.222222em;"></span><span class="mbin">∗</span><span class="mspace" style="margin-right: 0.222222em;"></span><span class="mord mathdefault">c</span><span class="mord mathdefault" style="margin-right: 0.13889em;">T</span><span class="mord mathdefault">h</span><span class="mord mathdefault" style="margin-right: 0.01968em;">l</span><span class="mord"><span class="mord mathdefault">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height: 0.849108em;"><span class="" style="top: -2.44134em; margin-left: 0em; margin-right: 0.05em;"><span class="pstrut" style="height: 2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathdefault mtight">i</span><span class="mbin mtight">−</span><span class="mord mtight">1</span></span></span></span><span class="" style="top: -3.063em; margin-right: 0.05em;"><span class="pstrut" style="height: 2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight">b</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height: 0.316995em;"><span class=""></span></span></span></span></span></span></span><span class="mspace" style="margin-right: 0.222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right: 0.222222em;"></span><span class="mopen">(</span><span class="mord">1</span><span class="mspace" style="margin-right: 0.222222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right: 0.222222em;"></span><span class="mord mathdefault" style="margin-right: 0.0037em;">α</span><span class="mclose">)</span><span class="mspace" style="margin-right: 0.222222em;"></span><span class="mbin">∗</span><span class="mspace" style="margin-right: 0.222222em;"></span><span class="mord mathdefault">c</span><span class="mord mathdefault" style="margin-right: 0.13889em;">T</span><span class="mord mathdefault">h</span><span class="mord mathdefault" style="margin-right: 0.01968em;">l</span><span class="mord"><span class="mord mathdefault">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height: 0.7823em;"><span class="" style="top: -2.42314em; margin-left: 0em; margin-right: 0.05em;"><span class="pstrut" style="height: 2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathdefault mtight">i</span><span class="mbin mtight">−</span><span class="mord mtight">1</span></span></span></span><span class="" style="top: -3.18091em; margin-right: 0.05em;"><span class="pstrut" style="height: 2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight">p</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height: 0.335195em;"><span class=""></span></span></span></span></span></span><span class="mpunct">,</span></span></span><span class="" style="top: -2.25em;"><span class="pstrut" style="height: 3.008em;"></span><span class="mord"><span class="mord">5</span><span class="mspace">&nbsp;</span><span class="mord mathdefault" style="margin-right: 0.10764em;">f</span><span class="mord mathdefault">o</span><span class="mord mathdefault" style="margin-right: 0.01968em;">l</span><span class="mord mathdefault">d</span><span class="mspace">&nbsp;</span><span class="mord mathdefault">p</span><span class="mord mathdefault" style="margin-right: 0.02778em;">r</span><span class="mord mathdefault">e</span><span class="mord mathdefault">d</span><span class="mord mathdefault">i</span><span class="mord mathdefault">c</span><span class="mord mathdefault">t</span><span class="mord mathdefault">i</span><span class="mord mathdefault">o</span><span class="mord mathdefault">n</span><span class="mpunct">,</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height: 1.19em;"><span class=""></span></span></span></span></span><span class="arraycolsep" style="width: 1em;"></span><span class="col-align-l"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height: 1.69em;"><span class="" style="top: -3.69em;"><span class="pstrut" style="height: 3.008em;"></span><span class="mord"><span class="mord"><span class="mord mathdefault">i</span><span class="mspace" style="margin-right: 0.277778em;"></span><span class="mrel">&gt;</span><span class="mspace" style="margin-right: 0.277778em;"></span><span class="mord">1</span></span></span></span><span class="" style="top: -2.25em;"><span class="pstrut" style="height: 3.008em;"></span><span class="mord"><span class="mord"><span class="mord mathdefault">i</span><span class="mspace" style="margin-right: 0.277778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right: 0.277778em;"></span><span class="mord">1</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height: 1.19em;"><span class=""></span></span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span></span></span></span></span></span><br> 其中 <span class="katex--inline"><span class="katex"><span class="katex-mathml">
    
     
      
       
        c
       
       
        T
       
       
        h
       
       
        l
       
       
        
         d
        
        
         
          i
         
         
          −
         
         
          1
         
        
        
         p
        
       
      
      
       cThld^p_{i-1}
      
     
    </span><span class="katex-html"><span class="base"><span class="strut" style="height: 1.11749em; vertical-align: -0.335195em;"></span><span class="mord mathdefault">c</span><span class="mord mathdefault" style="margin-right: 0.13889em;">T</span><span class="mord mathdefault">h</span><span class="mord mathdefault" style="margin-right: 0.01968em;">l</span><span class="mord"><span class="mord mathdefault">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height: 0.7823em;"><span class="" style="top: -2.42314em; margin-left: 0em; margin-right: 0.05em;"><span class="pstrut" style="height: 2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathdefault mtight">i</span><span class="mbin mtight">−</span><span class="mord mtight">1</span></span></span></span><span class="" style="top: -3.18091em; margin-right: 0.05em;"><span class="pstrut" style="height: 2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight">p</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height: 0.335195em;"><span class=""></span></span></span></span></span></span></span></span></span></span> 是第 <code>i-1</code> 周最好的 cThld。<span class="katex--inline"><span class="katex"><span class="katex-mathml">
    
     
      
       
        c
       
       
        T
       
       
        h
       
       
        l
       
       
        
         d
        
        
         i
        
        
         p
        
       
      
      
       cThld^p_i
      
     
    </span><span class="katex-html"><span class="base"><span class="strut" style="height: 1.05916em; vertical-align: -0.276864em;"></span><span class="mord mathdefault">c</span><span class="mord mathdefault" style="margin-right: 0.13889em;">T</span><span class="mord mathdefault">h</span><span class="mord mathdefault" style="margin-right: 0.01968em;">l</span><span class="mord"><span class="mord mathdefault">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height: 0.7823em;"><span class="" style="top: -2.42314em; margin-left: 0em; margin-right: 0.05em;"><span class="pstrut" style="height: 2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight">i</span></span></span><span class="" style="top: -3.18091em; margin-right: 0.05em;"><span class="pstrut" style="height: 2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight">p</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height: 0.276864em;"><span class=""></span></span></span></span></span></span></span></span></span></span> 是第 <code>i</code> 周预测的 cThld,也是第 <code>i</code> 周用于检测时用到的参数。<span class="katex--inline"><span class="katex"><span class="katex-mathml">
    
     
      
       
        α
       
       
        ∈
       
       
        [
       
       
        0
       
       
        ,
       
       
        1
       
       
        ]
       
      
      
       \alpha \in [0,1]
      
     
    </span><span class="katex-html"><span class="base"><span class="strut" style="height: 0.5782em; vertical-align: -0.0391em;"></span><span class="mord mathdefault" style="margin-right: 0.0037em;">α</span><span class="mspace" style="margin-right: 0.277778em;"></span><span class="mrel">∈</span><span class="mspace" style="margin-right: 0.277778em;"></span></span><span class="base"><span class="strut" style="height: 1em; vertical-align: -0.25em;"></span><span class="mopen">[</span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right: 0.166667em;"></span><span class="mord">1</span><span class="mclose">]</span></span></span></span></span> 是平滑常数。第一周时,我们采用 5-fold 交叉验证的方法来初始化 <span class="katex--inline"><span class="katex"><span class="katex-mathml">
    
     
      
       
        c
       
       
        T
       
       
        h
       
       
        l
       
       
        
         d
        
        
         1
        
        
         p
        
       
      
      
       cThld^p_1
      
     
    </span><span class="katex-html"><span class="base"><span class="strut" style="height: 1.04861em; vertical-align: -0.266308em;"></span><span class="mord mathdefault">c</span><span class="mord mathdefault" style="margin-right: 0.13889em;">T</span><span class="mord mathdefault">h</span><span class="mord mathdefault" style="margin-right: 0.01968em;">l</span><span class="mord"><span class="mord mathdefault">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height: 0.7823em;"><span class="" style="top: -2.43369em; margin-left: 0em; margin-right: 0.05em;"><span class="pstrut" style="height: 2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span><span class="" style="top: -3.18091em; margin-right: 0.05em;"><span class="pstrut" style="height: 2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight">p</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height: 0.266308em;"><span class=""></span></span></span></span></span></span></span></span></span></span> 。EWMA 简单但是在这里非常有效,因为它不需要大量的历史数据来启动。随着 <span class="katex--inline"><span class="katex"><span class="katex-mathml">
    
     
      
       
        α
       
      
      
       \alpha
      
     
    </span><span class="katex-html"><span class="base"><span class="strut" style="height: 0.43056em; vertical-align: 0em;"></span><span class="mord mathdefault" style="margin-right: 0.0037em;">α</span></span></span></span></span> 的增大, EWMA 更加容易得出最近最优 cThld,它在预测中有更大的影响。本论文中采用 <span class="katex--inline"><span class="katex"><span class="katex-mathml">
    
     
      
       
        α
       
       
        =
       
       
        0.8
       
      
      
       \alpha=0.8
      
     
    </span><span class="katex-html"><span class="base"><span class="strut" style="height: 0.43056em; vertical-align: 0em;"></span><span class="mord mathdefault" style="margin-right: 0.0037em;">α</span><span class="mspace" style="margin-right: 0.277778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right: 0.277778em;"></span></span><span class="base"><span class="strut" style="height: 0.64444em; vertical-align: 0em;"></span><span class="mord">0</span><span class="mord">.</span><span class="mord">8</span></span></span></span></span> 来快速捕捉 cThld 值。实验结果表明:基于cThld的EWMA 预测方法 比 5-fold交叉验证有更好的预测效果。</p> 
    

    5.5 EVALUATION

    我们使用Python、R和C++代码9500行来实现Opple和14个检测器。机器学习块基于scikit学习库。在本节中,我们使用来自顶级全球搜索引擎的三种KPI数据来评估Oppertice。这些数据由操作员使用我们的标记工具标记。

    图8示出了评估流程。在前四个步骤中,我们用不同的方法比较了机会的各个组成部分的准确性。Opprentice 的准确性见第5.6节。除了准确性之外,Oppertice 的质量目标,即自动化,也通过直接将oppertice应用到三个不同的kpi,而无需调整来评估。唯一的手动操作是标记KPI数据。我们还询问了操作人员之前的检测器调整时间,并将其与标记时间(见5.7)进行了比较。最后,我们评估了 Oppertice 的在线检测和离线训练时间(见5.8)。接下来,我们首先描述第5.1节中的数据集和第5.2节中选择的检测器,然后展示评估结果。
    evaluation flow

    5.5.1 数据集

    我们从一个大型搜索引擎(见2.1)中收集了三种具有代表性的 KPI 数据(即PV、#SR和SRT)。这些数据由搜索引擎的操作员使用我们的标记工具标记。分别有7.8%、2.8%和7.4%的数据点被标记为PV、SR和SRT异常。虽然我们使用的数据来自搜索引擎,但它们并不仅仅是搜索引擎的特例。例如,根据以前的文献和我们的经验,我们使用的PV数据在视觉上与其他类型的体积数据相似。例如,其他基于Web的服务的PV、RTT(往返时间)和ISP的总流量以及在线购物收入。因此,我们相信这三种 KPI 足以评估机会的想法,我们认为,作为我们未来的工作,我们将使用来自搜索之外的其他领域的数据进行更广泛的评估。表2显示了从标记的数据集生成训练集和测试集的几种方法。

    表2

    5.5.2 检测器与参数选择

    根据探测器要求(见4.3.2),在这个概念验证原型中,我们使用14个广泛使用的探测器评估Opprentice(表3)
    表3
    在本研究之前,我们研究的搜索引擎已经使用了其中的两个检测器。一种是Diff,它简单地利用当前点与最后一个时隙点、最后一天点和上周点之间的差异来测量异常严重性。另一种方法,即“差分平均法”,利用当前点与最后一个时隙点之差的移动平均值来测量严重性。这个检测器是用来发现连续的抖动。其他12个探测器来自于以前的文献。在这些检测器中,有两种不同的检测器使用中间值周围的MAD(中间值绝对偏差)而不是平均值周围的标准偏差来测量异常严重性。该补丁可以提高对缺失数据和异常值的鲁棒性。为了空间的利益,这些探测器的细节和它们产生严重性的方式没有进一步介绍,但是可以在表3的参考文献中找到。各探测器采样参数见表3。在这里,ARIMA的参数是根据数据估计的。对于其他探测器,我们扫描它们的参数空间。

    总共,我们有14个探测器和133个配置,或133个随机森林特征。请注意,Opprentice不仅限于我们使用的探测器,而且可以包含新兴探测器,只要它们满足我们在第4.3.2节中的探测器要求。

    5.5.3 随机森林的精度

    现在我们展示评估结果。首先,我们比较了在离线模式下随机森林和其他检测方法的准确性。因为我们不知道其他方法的阈值,所以我们无法公平地比较特定的召回和精确性。或者,我们使用PR曲线下的面积(AUCPR)作为精度度量。AUCPR是在所有可能的阈值上检测性能的单个数字摘要。AUCPR范围从0到1。直观地说,AUCPR较大的检测方法更有可能获得较高的查全率和查准率。

    随机森林 vs 基本检测器和基本探测器的静态组合

    首先,在图9中,我们将随机森林与表中具有不同参数设置(133个配置)的14个基本检测器进行比较。三。我们还将随机森林与两种静态组合方法进行了比较:标准化模式[21]和多数投票[8]。这两种方法被设计用来组合不同的检测器,但不管它们的精度如何,它们都是同等对待的。为了便于比较,在本文中,我们还使用这两种方法将133个配置组合为随机林。以上方法都是从第9周开始检测数据。前8周作为随机森林的初始训练集。

    表4
    图9
    在图9的左侧,我们看到对于AUCPR,随机林在图9(a)和图9(b)中排名第一,在图9(c)中排名第二,其中随机林的AUCPR仅比最高的低0.01。另一方面,两种静态组合方法的AUCPR始终排名较低。这是因为大多数配置是不准确的(在图9中AUCPR很低),因为我们没有手动选择合适的检测器或调整它们的参数。然而,这两种静态组合方法处理具有相同优先级的所有配置(例如,同等权重的投票)。因此,它们可能会受到不准确配置的严重影响。

    图9的右侧显示了随机森林的PR曲线、两种组合方法和前3个最高AUCPR基本检测器。我们观察到,每个KPI的最佳基本检测器是不同的,这表明操作员对每个KPI的不同类型的异常感兴趣。表4显示了当这些方法的召回满足操作者的偏好时(召回≥0.66)的最大精确度。我们发现,对于所有的kpi,随机森林达到了很高的精度(大于0.8)。结果表明,随机森林的性能明显优于两种静态组合方法,并且对每个KPI的性能与最精确的基本检测器相似,甚至优于最精确的基本检测器。

    随机森林 vs 其他算法

    我们还比较了随机森林和其他几种机器学习算法:决策树、logistic回归、线性支持向量机(SVMs)和朴素贝叶斯。所有这些算法都在 表2 中的 I1 上进行了训练和测试。为了说明不相关特征(例如,图9中具有低AUCPR的配置)和冗余特征(例如,具有相似参数设置的检测器)的影响,我们通过第一次使用一个特征并每次添加一个以上特征来训练这些学习算法。这些特征是按照它们的相互信息的顺序添加的,这是特征选择的一个公共度量。在图10中,我们观察到,虽然其他学习算法的AUCPR是不稳定的,并且随着更多特征的使用而降低,但是即使使用了所有133个特征,随机森林的AUCPR仍然很高。结果表明,在实际应用中,随机森林对不相关和冗余特征具有很强的鲁棒性。

    图10

    5.5.4 增量训练 (Incremental Retraining)

    在演示了随机森林的准确性和稳定性之后,我们想展示不同训练集的效果。在本次评估和以下评估步骤中,我们将只关注随机森林。我们比较了表2中生成训练集的三种方法:I4、F4和R4。图11示出了不同训练集上随机森林的AUCPR。我们发现,在大多数情况下,I4(也称为增量再训练)比其他两个训练集表现更好。这个结果与前面提到的挑战一致,即任意数据集不太可能包含足够种类的异常。在图11(b)中,我们看到三个训练集产生相似的AUCPR。这意味着#SR的异常类型相对简单,变化不大,因此可以很好地被这些训练集捕获。总的来说,由于标记异常不需要花费太多时间(见5.7),我们认为增量再训练是生成训练集的更通用和准确的方法。

    图11

    5.5.5 PC-Score vs 其他精度指标

    图11
    到目前为止,我们已经展示了没有特定 cThld 的随机森林的离线AUCPR。接下来,我们评估用于配置 cThld 的不同精度度量。我们将提出的PC评分与默认的cThld、F-score 和SD(1,1)进行比较。具体来说,我们在 表2 中的 I1 上训练和测试随机林,并让这四个度量确定每个一周测试集的 cThld 。然后,我们使用每周的回忆和精确性来衡量他们的表现。请注意,此评估考虑脱机或oracle设置,我们假设在配置 cThld 时有测试集。我们将在5.6节中展示未来测试集(在线检测)的 cThld 预测。

    图12分别示出了三种 KPI 的四个度量的结果。在左边的热图中,每个点代表一周的召回率(recall) 和精确性(precision)。第一行显示偏好下的结果(recall≥0.66,precision≥0.66),称为中度偏好。我们还评估了另外两种偏好:第二行对精确性敏感(recall≥0.6和precision≥0.8),第三行对召回率敏感(recall ≥ 0.8和 precision ≥ 0.6)。首选项由热图右上角的框表示。如果我们使用原始或降低的首选项(例如,向上缩放框),右侧的折线图将显示框内的点的百分比(满足首选项)。

    通过对热图的分析,我们发现,当其他三个指标所得到的分数在不同偏好下保持不变时,PC-score 具有根据不同偏好调整查全率和查准率的能力。由于这一优势,我们在折线图中看到,无论是最初的偏好还是放大的偏好,PC-score 总是在框内获得最多的分数。

    我们还注意到,要满足所有周的偏好并不容易,因为异常在某些周非常罕见。例如,我们发现在没有点满足中等偏好的周,PV和SR的异常分别比其他周少73%和78%。因此,不可避免地会产生更多的误报,以识别这些少数异常,从而导致低精度。此外,仅仅遗漏一些异常可能会导致召回率明显下降。幸运的是,由于这几周异常很少,相对较低的准确率或召回率不会导致大量的假阳性(false positive)或假阴性(false negative)。例如,如果有10个异常数据点,而我们识别了其中的4个(40%的召回率),我们将只漏掉6个异常数据点;在这种情况下,如果我们有40%的精度,我们将只识别6个误报。与我们一起工作的操作员表示,他们实际上可以处理少量的误报或漏报。

    5.5.6 cThld 预测中,EWMA vs 5-fold

    在此之前,我们展示了对cThld配置的不同度量的离线评估,发现PC得分优于其他三个。现在,我们评估了基于PC评分的在线cThld预测的性能,这也是Oppertice整体的检测精度。我们将 oppertice 使用的基于EWMA的方法与5倍交叉验证进行了比较。评估与第5.5节相似,但 cThld 预测仅使用历史数据(训练集)而非未来数据(测试集)。如前所述,由于异常在某些周内相当罕见,因此每周的结果可能有很大差异。为了得到一个稳定的结果,我们计算了4周移动窗口的平均召回率和精确度。窗口为每个步骤移动一天,以便我们可以获得更细粒度的结果。在这里,我们给出了在操作者实际偏好下的结果(recall ≥ 0.66,precision ≥ 0.66)。图13示出了每个窗口的召回率和精确度。离线检测结果(这里称为最佳情况)作为基线。

    图13
    结果表明,对于PV、SR和SRT,与5倍交叉验证相比,EWMA在阴影区域内分别多出40%、23%和110%的点。共有8403个(7.3%)、2544个(2.1%)和86个(6.4%)数据点分别在三个关键绩效指标的测试集中(第9周后)被Oppertice识别为异常(未显示)。我们注意到有一些点落在阴影区域之外,例如图13(a)中58到70之间的窗口。这主要是因为那几周的异常非常罕见。 例如,在58到70之间的窗口中,平均只有4%的光伏数据的地面真值异常点。然而,如第5.5节所述,在这种情况下,稍低的精确度或召回率不会对操作者产生许多误报或漏报。总之,Oppertice 可以自动满足或近似于操作员的精度偏好。

    5.5.7 打标时间 vs 调谐时间(Labeling Time vs. Tuning Time)

    接下来,我们将展示标签的时间成本,这是操作员使用 Oppertice 时所需的唯一手动工作。图14显示了操作员使用我们的工具(4.2节)标记三种类型的 KPI 数据时的标记时间。结果表明,一个月数据的标记时间基本上随该月异常窗口数的增加而增加。异常窗口是指由一个标记动作产生的连续异常窗口。在这三个 KPI 中,SRT 每个月的数据标记时间较少,因为它的数据间隔是60分钟,因此一个月的数据点较少。总体而言,一个月数据的标注时间小于6分钟。PV、#SR和SRT的总标记时间分别为16、17和6分钟。标记开销低的一个直观原因是,操作员每次都标记一个异常窗口,而不是逐个标记单个异常数据点。异常窗口可以比数据中的异常点小得多(图14)
    图14
    为了说明Oppertice如何帮助减少操作员的手动操作,我们还提供了一些操作员调整探测器时间的事件示例,包括他们学习探测器和了解其参数的时间。我们采访了三位来自搜索引擎的操作人员,他们都有过调试检测器的经验。第一个操作员使用 SVD,他说他花了大约8天时间调试探测器;第二个操作员使用 Holt-Winters 和 Historical Average,他花了大约12天时间调试这两个探测器;第三个操作员应用时间序列分解,他说在探测器实现之后,他还花了大约10天的时间来测试和调试探测器。在上述情况下,经过几天的调试,只有第一个操作员的检测器工作得比较好,而另外两个操作员对其检测器的精度仍然不满意,最后放弃了它们。我们在第5.3.1节中比较了 Oppertice 和这些基本探测器的准确性。

    尽管上面报告的时间不是用于调整的确切时间,但它提供了手动调整检测器的开销和困难的基本概念。我们采访的运营商证实,探测器调谐非常耗时,他们对此既不感兴趣,也不感到舒适。总之,Opprentice 可以用快速方便的异常标记来代替耗时且枯燥的探测器调谐。

    5.5.8 检测时延和训练时间(Detection Lag and Training Time)

    检测时延原则上由特征提取时间和分类时间组成。我们使用Intel Xeon E5-2420 CPU和24GB内存在Dell PowerEdge R420 服务器上运行Oppertice。对于每个数据点,提取133个特征的总时间平均为0.15秒。分类所需时间很短,平均每个数据点不到0.0001秒。此外,每轮离线训练时间不到5分钟。由于所有的检测器都可以并行运行,随机林的训练也可以并行化,我们相信利用多线程技术和服务器集群上的分布式计算可以获得更好的性能。

    5.6 DISSCUSSION

    实际上,异常检测是复杂的。在这一部分中,我们讨论了异常检测的一些问题,并澄清了机会的范围。

    • 异常检测,不排除故障(Anomaly detection, not troubleshooting):有时,尽管运营商承认 KPI 曲线中存在异常,但他们往往忽略这些异常,因为他们知道这些异常是由一些正常的活动(如服务升级和可预测的社会事件)引起的。然而,由于我们的研究重点是识别 KPI 数据的异常行为(本文称为异常检测),因此我们要求操作人员根据数据曲线本身来标记异常,而不考虑其背后的原因。异常检测是监控服务性能的第一个重要步骤。我们认为,检测结果应该报告给操作人员,让操作人员决定如何处理,或者更理想的是,输入到故障排除系统中,以分析根本原因并生成更可行的建议。例如,故障排除系统可能会发现异常是由于正常的系统升级引起的,并建议操作员忽略这些异常。然而,排除异常本身超出了我们的研究范围。
    • 异常持续时间(Anomaly duration):持续异常的持续时间可能是发出警报的另一个重要考虑因素。在本文中,我们确实故意忽略了这个因素。一个原因是,这将使我们的模型过于复杂,无法显示核心思想。另一个是,基于我们检测到的点水平异常,实现持续时间滤波器相对容易。例如,如果操作员只对持续超过5分钟的连续异常感兴趣,可以通过简单的阈值过滤器来解决 。
    • 跨相同类型的关键绩效指标进行检测(Detection across the same types of KPIs):一些KPI 属于同一类型,运营商通常关心它们的类似异常类型。例如,PV来自不同的 ISP。在这种情况下,运营商只需标注一个或几个关键绩效指标。然后,在这些标记数据上训练的分类器可用于检测相同类型的kpi。需要注意的是,为了对不同尺度的数据重用分类器,需要对基本检测器提取的异常特征进行规范化。我们计划在今后的工作中探索这个方向。
    • 脏数据(Dirty data):一个众所周知的问题是,检测器经常受到“脏数据”的影响。脏数据是指数据中的异常或缺失点,它们会污染探测器,造成探测器的误差。我们用三种方法解决这个问题。
      • a) 我们的一些检测器,例如加权MA和SVD,只能使用最近的数据生成异常特征。因此,它们可以快速消除脏数据的污染。
      • b) 我们利用MAD[3,15]使一些检测器,如TSD,对脏数据更加健壮;
      • c) 由于oppertice同时使用许多检测器,即使少数检测器受到污染,oppertice仍然可以自动选择和使用剩余的检测器。
    • 学习限制(Learning limitations):基于监督学习的方法需要标记数据进行初始化。与直接应用基本检测器相比,这是额外的开销。幸运的是,现在的KPI数据很容易获得[1、4、9、12、14、17、26]。同时,标签也可以是有效的,成本较低的时间,正如我们之前所证明的,与标签工具。另一个问题是,基于学习的方法受到训练集中异常的限制。例如,异常可能很罕见,未来可能会出现新类型的异常。我们通过逐步地重新训练分类器来收集更多的异常案例和学习新出现的异常类型来解决这个问题。
    • 检测精度(Detection accuracy):由于上述诸多实际挑战,异常检测是一项复杂而富有挑战性的任务。一直以来,要达到较高的准确率和召回率是很难的。我们也不能保证 Oppertice 能够始终满足运营商的精度偏好。但我们的评估表明,Oppertice 的准确性仍然是有希望的,特别是对于运营商在所研究的服务中的偏好。

    5.7 RELATED WORK

    在异常检测领域进行了大量的工作。研究人员使用不同的技术开发了许多探测器[1-24]。此外,研究人员试图解决探测器在实际应用中的几个挑战。

    • a) 为了自动调整探测器的内部参数,Krishnamurthy等人。[11] 提出了一种多通道网格搜索方法,从数据中寻找合适的参数。Himura等人。[23]搜索参数以最大化检测到的事件的比率。相比之下,除了检测器内部参数外,我们还考虑了自动选择检测器及其阈值。
    • b) 一些工作使用ROC曲线来评估不同检测器的性能,而不管它们的阈值是什么[9,14,26]。这项技术也用于我们的工作中。
    • c) MAD用于提高检测器对脏数据的鲁棒性。我们还用MAD实现了两个检测器。
    • d) 一些解决方案试图静态地将不同的探测器组合在一起[8,21]。我们和他们比较了机会。
    • e) 机器学习也被应用于异常检测,但它是基本的检测器。相反,我们使用机器学习来组合不同的现有检测器。

    异常检测的另一个重要挑战是获取地面真实性来评估探测器。三种常用的解决方案是:

    • a) 使用域运算符识别或确认的真实异常[1、4、9、12、14、17、26];
    • b) 通过将真实或预定义异常注入背景数据[9、14、18、19]来生成合成异常;
    • c) 成对比较,将其他检测器报告的异常视为地面真理[1,8,10,17,18]。

    因为我们的基本目标是满足运营商的需求,所以我们认为解决方案(a)在本文中更有意义。

    5.8 CONCLUSION

    将异常检测应用于基于 Internet 的服务在实践中具有挑战性。这是因为异常很难定量定义,现有的探测器在部署之前有参数和阈值需要调整。我们提出的框架 Oppertice 通过一种新的基于机器学习的方法来应对上述挑战。通过机器学习从真实数据和操作者的标签中获取不清晰的异常概念,同时通过机器学习可以自动组合大量现有的检测器来训练分类器来识别异常。我们对实际搜索kpi的评估表明,Oppertice 的性能始终与性能最好的基本检测器相似,甚至优于性能最好的基本检测器,后者可以针对不同的数据集进行更改。

    据我们所知,Oppertice 是第一个将机器学习应用于获取实际异常概念、自动组合和调整各种已知检测器以满足操作员精度偏好的检测框架。新出现的检测器不必经过耗时且常常令人沮丧的参数调整,而是可以很容易地插入Oppertice,从而使前者更容易部署,后者更精确。此外,虽然机器学习是一个很有前途的解决方案,但在设计实际系统时需要小心,因为它会带来一些有趣的挑战,例如不平衡类和不相关的冗余特征。本文对其中的一些问题进行了探讨和解决。我们相信 Opperentice 提供了一种新的方案,以弥合实际操作需求与最先进异常检测器之间的差距。在我们未来的工作中,我们计划解决第6节中提到的几个问题,并将 Oppertice 的思想应用到其他网络操作任务中,如自动入侵检测和网络故障排除。


    感谢您的 点赞收藏评论关注

    展开全文
  • 作者:Mia Morton编译:ronghuaiyang导读创建异常检测模型,实现生产线上异常检测过程的自动化。在选择数据集来训练和测试模型之后,我们能够成功地检测出86%到90%的异常。...


    作者:Mia Morton

    编译:ronghuaiyang

    导读

    创建异常检测模型,实现生产线上异常检测过程的自动化。在选择数据集来训练和测试模型之后,我们能够成功地检测出86%到90%的异常

    介绍

    异常是指偏离预期的事件或项目。与标准事件的频率相比,异常事件的频率较低。产品中可能出现的异常通常是随机的,例如颜色或纹理的变化、划痕、错位、缺件或比例错误。

    异常检测使我们能够从生产流程中修复或消除那些处于不良状态的部件。因此,由于避免生产和销售有缺陷的产品,制造成本降低了。在工厂中,异常检测由于其特点而成为质量控制系统的一个有用工具,对机器学习工程师来说是一个巨大的挑战。

    不推荐使用监督学习,因为:在异常检测中需要内在特征,并且需要在完整数据集(训练/验证)中使用少量的异常。另一方面,图像比较可能是一个可行的解决方案,但标准图像处理多个变量,如光线、物体位置、到物体的距离等,它不允许与标准图像进行像素对像素的比较。在异常检测中,像素到像素的比较是不可或缺的。

    除了最后的条件外,我们的建议包括使用合成数据作为增加训练数据集的方法,我们选择了两种不同的合成数据,随机合成数据和相似异常合成数据。(详见数据部分)

    这个项目的目标是使用无监督学习和合成数据作为数据增强方法来分类异常 — 非异常。

    背景研究

    异常检测与金融和检测“银行欺诈、医疗问题、结构缺陷、设备故障”有关(Flovik等,2018年)。该项目的重点是利用图像数据集进行异常检测。它的应用是在生产线上。在项目开始时,我们熟悉了自动编码器在异常检测中的功能和架构。作为数据计划的一部分,我们研究了包括合成噪声图像和真实噪声图像的重要性(Dwibedi et al, 2017)。

    数据计划是这个项目的重要组成部分。选择一个数据集,有足够的原始图像和足够的真实噪声的图像。同时使用合成图像和真实图像。在处理真实图像时,这些数据需要对目标有全覆盖,但是在尺度和视角方面无法完全获得。“……要区分这些实例需要数据集对对象的视角和尺度有很好的覆盖”(Dwibedi et al, 2017)。合成数据的使用允许“实例和视角的良好覆盖”(Dwibedi et al, 2017)。合成图像数据集的创建,包括合成渲染的场景和对象,是通过使用Flip Library完成的,这是一个由LinkedAI创建的开源python库。“剪切,粘贴和学习:非常简单的合成实例检测”,通过这些数据的训练和评估表明,使用合成数据集的训练在结果上与在真实图像数据集上的训练具有可比性。

    自动编码器体系结构“通常”学习数据集的表示,以便对原始数据进行维数缩减(编码),从而产生bottleneck。从原始的简化编码,产生一个表示。生成的表示(重构)尽可能接近原始。自动编码器的输入层和输出层节点数相同。“bottleneck值是通过从随机正态分布中挑选出来的”(Patuzzo, 2020)。在重构后的输出图像中存在一些重构损失(Flovik, 2018),可以通过分布来定义原始图像输入的阈值。阈值是可以确定异常的值。

    去噪自动编码器允许隐藏层学习“更鲁棒的滤波器”并减少过拟合。一个自动编码器被“从它的一个损坏版本”来训练来重建输入(去噪自动编码器(dA))。训练包括原始图像以及噪声或“损坏的图像”。随着随机破坏过程的引入,去噪自编码器被期望对输入进行编码,然后通过去除图像中的噪声(破坏)来重建原始输入。用去噪自编码器提取和组合鲁棒特征,去噪自编码器应该能够找到结构和规律作为输入的特征。关于图像,结构和规律必须是“从多个输入维度的组合”捕获。Vincent等(2020)的假设引用“对输入的部分破坏的鲁棒性”应该是“良好的中间表示”的标准。

    在这种情况下,重点将放在获取和创建大量原始和有噪声图像的能力上。我们使用真实数据和合成数据创建了大量的图像来训练我们的模型。

    根据Huszar(2016)的说法,扩张卷积自动编码器“支持感受野的指数扩展,而不丢失分辨率或覆盖范围。“保持图像的分辨率和覆盖范围,对于通过扩大卷积自动编码器重建图像和使用图像进行异常检测是不可或缺的。这使得自动编码器在解码器阶段,从创建原始图像的重建到更接近“典型”自动编码器结构可能产生的结果。Dilated Convolutional Autoencoders Yu et al.(2017),“Network Intrusion Detection through Stacking Dilated Convolutional Autoencoders”,该模型的目标是将无监督学习特征和CNN结合起来,从大量未标记的原始流量数据中学习特征。他们的兴趣在于识别和检测复杂的攻击。通过允许“非常大的感受野,而只以对数的方式增加参数的数量”,Huszar (2016),结合无监督CNN的特征学习,将这些层堆叠起来(Yu et al., 2017),能够从他们的模型中获得“卓越的性能”。

    技术

    Flip Library (LinkedAI):https://github.com/LinkedAi/flip

    Flip是一个python库,允许你从由背景和对象组成的一小组图像(可能位于背景中的图像)中在几步之内生成合成图像。它还允许你将结果保存为jpg、json、csv和pascal voc文件。

    Python Libraries

    在这个项目中有几个Python库被用于不同的目的:

    可视化(图像、指标):

    • OpenCV

    • Seaborn

    • Matplotlib

    处理数组:

    • Numpy

    模型:

    • TensorFlow

    • Keras

    • Random

    图像相似度比较:

    • Imagehash

    • PIL

    • Seaborn (Histogram)

    Weights and Biases

    Weights and bias是一个开发者工具,它可以跟踪机器学习模型,并创建模型和训练的可视化。它是一个Python库,可以作为import wandb导入。它工作在Tensorflow, Keras, Pytorch, Scikit,Hugging Face,和XGBoost上。使用wandb.config配置输入和超参数,跟踪指标并为输入、超参数、模型和训练创建可视化,使它更容易看到可以和需要更改的地方来改进模型。

    模型&结构

    我们基于当前的自动编码器架构开始了我们的项目,该架构专注于使用带有卷积网络的图像(见下图)。经过一些初步的测试,基于研究(参见参考资料)和导师的建议,我们更改为最终的架构。

    自编码器的典型结构

    使用扩张特征

    扩张特征是一种特殊的卷积网络,在传统的卷积核中插入孔洞。在我们的项目中,我们特别的对通道维度应用了膨,不影响图像分辨率。

    最终的结构

    图像相似度

    这个项目的关键点之一是找到一个图像比较的指标。利用图像比较度量对模型进行训练,建立直方图,并计算阈值,根据该阈值对图像进行异常和非异常的分类。

    我们从逐个像素的L2欧氏距离开始。结果并不能确定其中的一些差异。我们使用了带有不同散列值(感知、平均和差异)的Python Imagehash库,对于相似的图像,我们得到了不同的结果。我们发现SSIM(结构相似度指数度量)度量为我们提供了一对图像之间相似度的度量,此外,它是Keras库的一个内置损失。

    直方图

    在对模型进行训练和评估后,利用其各自的数据集,对重建后的图像和原始图像之间的相似度进行识别。当然,由于原始图像的多样性(如,大小,位置,颜色,亮度和其他变量),这种相似性有一个范围。我们使用直方图作为图的表示,以可视化这个范围,并观察在哪个点会有不同的图像。

    直方图的例子

    数据

    使用的数据从Kaggle下载:表面裂纹检测数据集:https://www.kaggle.com/arunrk7/surface-crack-detection和铸造产品质量检查图像数据:https://www.kaggle.com/ravirajsinh45/real-life-industrial-dataset-of-casting-product?select=casting_data。

    第一个是裂缝数据集,包含20,000张负样本墙图像(无裂缝)和20,000张正样本墙图像(有裂缝)。在这种情况下,裂缝被认为是异常的。所有数据都是227x227像素的RGB通道。下面显示了每个组的示例。

    ![](Anomaly Detection with Computer Vision.assets/0_wkppduibzb5UMKe4.png)

    我们从没有异常的组中选取了10,000张图像来生成不同的合成数据集。然后合成的数据集被分为两种类型:一种是带有类似异常的噪声(51张图像是用Photoshop创建的),另一种是使用水果、植物和动物等随机物体。所有用作噪声的图像都是png格式的,背景是透明的。下面是用于模型训练的两种类型的数据集的一些例子。

    ![](Anomaly Detection with Computer Vision.assets/0_QOK2rwxMoVZiFd5Q.png)

    第二个数据集,cast数据集分为两组,一组为512x512像素的图像(有异常的781张,无异常的519张),另一组为300x300像素的图像(有异常的3137张,有异常的4211张)。所有图像都有RGB通道。使用的是300 x 300像素的图像。后者,来自Kaggle,91.65%的数据被分为训练,其余的测试。对于该数据集,异常包括:边缘碎片、划痕、表面翘曲和孔洞。下面是一些有和没有异常的图像示例。

    我们使用1,000张属于训练组的无缺陷图像来生成合成数据数据集。在前面的例子中,我们创建了两种类型的数据集:一种带有类似于异常的噪声(51张图像是用Photoshop创建的),另一种带有随机对象的噪声,如动物、花朵和植物(裂缝数据集中使用的相同的80张图像)。下面是一些在模型训练中使用的图像示例。

    所有合成数据都是使用Flip库创建的。在每个生成的图像中,选择两个对象并随机放置。对象应用了三种类型的转换:翻转、旋转和调整大小。生成的图像保存为jpg格式。项目使用的数据集如下表所示:

    实验

    根据上述表格说明,我们的主要目的是研究数据集的哪些变化可能呈现最好的结果,我们用这些数据和获得的结果训练了模型(见下面的图表)。

    对于每个数据集,我们评估了几个指标,如(SSIM)损失、召回、精度、F1和精度。在每一次实验中,我们将评估代表这组噪声图像和重建图像之间图像相似性的直方图。

    为了跟踪和比较我们的结果,我们使用了library Weight & bias,它允许一种简单的方式来存储和比较每个实验的结果。

    训练

    为了在我们的环境中保持少量的变量,我们决定总是使用一个有1000个样本的数据集,而不管真实数据和合成数据之间的关系。

    在算法中,我们将各自的数据集分割为95%进行训练,5%进行测试结果。除此之外,我们的评估只使用了真实的数据。

    评估和结果

    下面是一些实验的主要结果。你可在以下连结找到所有的结果:

    裂缝数据集:https://wandb.ai/heimer-rojas/anomaly-detector-cracks?workspace=user-

    裂缝直方图

    裂缝数据集的异常检测

    对于裂纹数据集,实验结果也很好(91% ~ 98%),实验之间没有显著差异。与无异常的图像相比,其行为主要取决于裂纹大小和颜色等变量。

    铸造工件数据集:https://wandb.ai/heimer-rojas/anomaly-detector-cast?workspace=user-heimer-rojas

    铸造工件数据集的准确率和召回率

    铸造件E1&E3

    铸造件数据集的异常检测

    挑战

    • 训练时间长,在谷歌Colab和专业版中使用GPU训练。

    • 通过上传压缩后的zip格式的数据来解决长时间的数据加载问题,这样每个数据集上传一个文件,大大减少了时间。

    • 最初的提议是使用哥伦比亚汽车生产线的数据集,不幸的是,正样本和负样本图像的质量和数量都不足以创建一个合适的机器学习模型。这种情况促使我们决定使用Kaggle的数据集,与生产线生产的条件类似。

    • 每个数据集在异常情况下的可视化差异是不同的,需要考虑正常的图像结构,如图像的颜色、亮度等内在特征

    • 需要人类的专业知识来根据真实数据或合成数据的阈值选择适当的阈值。这可能要视情况而定。

    讨论

    实现一个真正的机器学习项目需要几个步骤,从想法到模型的实现。这包括数据集的选择、收集和处理。

    在使用图像的项目中有“调试脚本”是很重要的。在我们的例子中,我们使用了一个允许我们可视化的脚本:原始数据集、新的合成图像和自编码器去噪之后的图像,使我们能够评估模型的性能。

    英文原文:https://medium.com/linkedai/anomaly-detection-production-line-b8340e1eca43

    更多精彩内容(请点击图片进行阅读)

    公众号:AI蜗牛车

    保持谦逊、保持自律、保持进步

    个人微信

    备注:昵称+学校/公司+方向

    如果没有备注不拉群!

    拉你进AI蜗牛车交流群

    展开全文
  • Autoencoder异常检测 - Paddle2.0实现时序数据异常检测Autoencoder异常检测 - Paddle2.0实现时序数据异常检测1.Autoencoder简介2.Autoencoder无监督异常检测3.Paddle2.0基于AUTOENCODER实现异常时序检测4....

    Autoencoder异常检测 - Paddle2.0实现时序数据异常检测

    Autoencoder算法是一种常见的基于神经网络的无监督学习降维方法。

    1.Autoencoder简介

    Autoencoder,中文称作自编码器,是一种无监督式学习模型。本质上它使用了一个神经网络来产生一个高维输入的低维表示。Autoencoder与主成分分析PCA类似,但是Autoencoder在使用非线性激活函数时克服了PCA线性的限制

    Autoencoder包含两个主要的部分,**encoder(编码器)**和 decoder(解码器)

    • Encoder的作用是用来发现给定数据的压缩表示
    • decoder是用来重建原始输入

    在训练时,decoder 强迫 autoencoder 选择最有信息量的特征,最终保存在压缩表示中。最终压缩后的表示就在中间的coder层当中。

    以下图为例,原始数据的维度是10,encoder和decoder分别有两层,中间的coder共有3个节点,也就是说原始数据被降到了只有3维。Decoder根据降维后的数据再重建原始数据,重新得到10维的输出。从Input到Ouptut的这个过程中,autoencoder实际上也起到了降噪的作用。

    在这里插入图片描述

    2.Autoencoder无监督异常检测

    异常检测(anomaly detection)通常分为有监督和无监督两种情形。在无监督的情况下,我们没有异常样本用来学习,而算法基本上假设是异常点服从不同的分布。根据正常数据训练出来的Autoencoder,能够将正常样本重建还原,但是却无法将异于正常分布的数据点较好地还原,导致还原误差较大。

    如果样本的特征都是数值变量,我们可以用MSE或者MAE作为还原误差。

    3.Paddle2.0基于AUTOENCODER实现异常时序检测

    1. 训练数据

    在这里插入图片描述

    1. 预测数据(红色为检测到的异常数据)

    在这里插入图片描述

    gitee - Paddle2.0基于AUTOENCODER实现异常时序检测

    4.参考内容:

    利用Autoencoder进行无监督异常检测(Python)

    AIStudio - Paddle2.0基于AUTOENCODER实现异常时序检测

    展开全文
  • 今天开始撰写一个全新的系列-异常检测,希望通过几次专题系统梳理异常检测的知识点。本专题依托Datawhale开源社区的异常检测材料加以思考,拓展而成。本文大纲什么是异常检测异常检测常用方法常用开源库实战演练1、...
  • 异常检测概述

    2021-01-12 20:38:16
    异常检测概述重点笔记异常检测应用领域传统方法集成方法机器学习的分类方法异常检测库PyOD 异常检测应用领域 故障检测 物联网异常检测 欺诈检测 工业异常检测 时间序列异常检测 Key 视频异常检测 日志异常检测 医疗...
  • 异常检测介绍

    2021-01-12 23:47:17
    一、了解异常检测基本概念 1、什么是异常检测 异常检测是指识别出与主体分布数据的分布相差较大或者与预测分布的数据相差较大的数据。 2、异常的类别 点异常 上下文异常 群体异常 3、异常检测任务分类 二、异常检测...
  • 入门, 利用一些标记的异常实例执行异常通知的异常检测由于缺乏大规模的标记异常数据,现有的(深度或浅度)异常检测方法通常被设计为无监督学习(针对完全未标记的数据进行训练)或半监督学习(针对仅标记的正常数据进行...
  • 异常检测算法

    万次阅读 2018-07-27 22:32:28
    异常检测(Anomaly Detection)是为了发现运维中偏离正常值的异常数据。 异常检测算法的基本思想是:用正常的数据去训练模型,得到阈值,然后去判断新的数据是否异常。 异常检测如今被广泛应用于:欺诈用户检测,...
  • 异常检测算法的实现过程: 首先我们来说明密度估计的概念,由于服从正态分布,我们假设这里x服从独立假设,所以x的密度p(x)= 1、我们选择那些产生异常的特征xi; 2、我们计算出训练集的均值和方差; 3、我们...
  • 异常检测2

    2019-09-30 17:48:51
    异常检测2
  • 时序数据异常检测

    2019-02-15 10:33:47
    outlier detection for temporal data 的综述,时序数据异常检测
  • 用于Elasticsearch异常检测的Open Distro 通过Open Distro for Elasticsearch异常检测插件,您可以利用基于机器学习的算法来自动检测异常,以提取日志数据。 结合警报功能,您可以实时监控数据并自动发送警报通知。...
  • 异常检测方法

    万次阅读 2017-12-04 20:13:42
    异常检测可谓是一个博大精深的研究方向,在故障检测、欺诈检测、入侵检测领域有着广泛应用。本文只是结合各网络资源对其基础进行简单介绍,涉及到具体的领域和实际应用,还需进行深入研究和尝试。什么是异常检测异常...
  • 1.异常检测简介 异常检测,它的任务是发现与大部分其他对象不同的对象,我们称为异常对象。异常检测算法已经广泛应用于电信、互联网和信用卡的诈骗检测、贷款审批、电子商务、网络入侵和天气预报等领域。这些异常...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,659
精华内容 7,863
关键字:

异常检测