教你用java实现时序数据异常检测(1)LOF-ICAD方法

package LOF;

import java.util.ArrayList;

/**
 * Local Outlier Factor
 *
 * @author mezereon E-mail:mezereon@gmail.com
 * @since 18-4-12
 */
public class LOF {

  private int k;

  public LOF(int k) {
    this.k = k;
  }

  /**
   * 返回异常程度的分数， 越接近1则越异常
   *
   * @param knn 输入一个时序数据生成的旋转矩阵
   * @param x 输入测试的序列
   */
  public double getLOF(double[][] knn, double[] x) {
    double sum = 0;
    for (double[] o : knn) {
      sum += getLocDens(knn, o) / getLocDens(knn, x);
    }
    return sum / k;
  }

  /**
   * 获取local density
   *
   * @param knn 输入一个时序数据生成的旋转矩阵
   * @param x 输入测试的序列
   */
  public double getLocDens(double[][] knn, double[] x) {
    double[] nnk = findKthPoint(knn, x);

    double sum = 0;
    for (double[] o : knn) {
      sum += reachDist(o, x, nnk);
    }
    return sum / k;
  }

  /**
   * 找到第k个相似的序列
   *
   * @param knn 输入一个时序数据生成的旋转矩阵
   * @param x 输入测试的序列
   */
  public double[] findKthPoint(double[][] knn, double[] x) {

    ArrayList list = new ArrayList();
    for (int i = 0; i < knn.length; i++) {
      list.add(knn[i]);
    }
    int index = 0;
    double minDist = dist(knn[0], x);

    for (int i = 0; i < k; i++) {
      index = 0;
      minDist = dist((double[]) list.get(0), x);
      for (int j = 0; j < list.size(); j++) {
        if (minDist > dist((double[]) list.get(j), x)) {
          minDist = dist((double[]) list.get(j), x);
          index = j;
        }
      }
      if (i != k - 1) {
        list.remove(index);
      }
    }

    return (double[]) list.get(index);
  }

  /**
   * 返回与相似序列的距离比较之下的较大值
   *
   * @param o 输入序列
   * @param x 测试序列
   * @param nnk 第k相似的序列
   */
  public double reachDist(double[] o, double[] x, double[] nnk) {
    return Math.max(dist(o, x), dist(nnk, x));
  }

  /**
   * 返回序列之间的欧几里德距离
   *
   * @param nnk 第k相似的序列
   * @param x 测试序列
   */
  private double dist(double[] nnk, double[] x) {

    double sum = 0;
    for (int i = 0; i < nnk.length; i++) {
      sum += (nnk[i] - x[i]) * (nnk[i] - x[i]);
    }

    return Math.sqrt(sum);
  }

  public int getK() {
    return k;
  }

  public void setK(int k) {
    this.k = k;
  }
}

package LOF;

import Tool.DetectTool;
import Util.MatrixUtil;

/**
 * @author mezereon E-mail:mezereon@gmail.com
 * @since 18-4-26
 */
public class LOFDetectTool implements DetectTool {

  private int T;// 时间序列用来训练的长度
  private int L;// 时间序列的所利用的窗口长度
  private int K = 1;//  LOF算法中的k值, 默认设置为1, 也就是取历史最相似的序列进行预测

  /**
   * LOF检测工具的构造方法
   *
   * @param T 时间序列用来训练的长度
   * @param L 时间序列的所利用的窗口长度
   */
  public LOFDetectTool(int T, int L) {
    this.T = T;
    this.L = L;
  }


  /**
   * 利用LOF进行时间序列分析
   * 打印最后一段窗口的异常分数, 越接近1则越异常
   */
  public void timeSeriesAnalyse(double[] series) {

    // 利用T和L, 以及时间序列生成测试矩阵
    double[][] mat = MatrixUtil.getMat(series, T, series.length - T - L + 1, L);

    //一个窗口大小的测试序列, 默认是原序列中最后窗口大小的序列
    double[] test = MatrixUtil.getTestSeries(series, series.length - L - 1, L);;

    double[][] matC = MatrixUtil.getMatC(mat, T, series.length - T - L + 1, L);
    double[][] matT = MatrixUtil.getMatT(mat, T, series.length - T - L + 1, L);

    LOF lof = new LOF(K);

    double[] ncmForC = new double[matC.length];

    for (int i = 0; i < matC.length; i++) {
      ncmForC[i] = lof.getLOF(matT, matC[i]);
    }

    double ncmForTest = lof.getLOF(matT, test);
    double count = 0;
    for (double x : ncmForC) {
      if (ncmForTest <= x) {
        count++;
      }
    }
    count /= matC.length;
    System.out.println("Anomaly Score is "+count);
  }
}

public class LOFDetectToolTest {

  public double[] testData;
  @Before
  public void setUp() throws Exception {
    testData = FileTool.getData("data.json");
  }

  @Test
  public void timeSeriesAnalyse() throws Exception {
    LOFDetectTool lofDetectTool = new LOFDetectTool(200, 50);
    lofDetectTool.timeSeriesAnalyse(testData);
  }

}