/*
 * Copyright 2015, Yahoo Inc.
 * Copyrights licensed under the GPL License.
 * See the accompanying LICENSE file for terms.
 */

// A simple model that does not require a forecasting model.
// It looks weather or not the max value for the past N hours exceeds
// X %.

package com.yahoo.egads.models.adm;

import java.util.Properties;

import com.yahoo.egads.data.Anomaly.IntervalSequence;
import com.yahoo.egads.data.Anomaly.Interval;
import com.yahoo.egads.data.TimeSeries.DataSequence;
import java.util.Map;
import java.util.ArrayList;
import java.util.HashMap;
import com.yahoo.egads.data.AnomalyErrorStorage;
import com.yahoo.egads.utilities.AutoSensitivity;

import org.json.JSONObject;
import org.json.JSONStringer;

public class NaiveModel extends AnomalyDetectionAbstractModel {

    // The constructor takes a set of properties
    // needed for the simple model. This includes the sensitivity.
    private Map threshold;
    private int maxHrsAgo;
    private long windowStart;
    private Float window_size;
    // modelName.
    public static String modelName = "NaiveModel";
    public AnomalyErrorStorage aes = new AnomalyErrorStorage();

    public NaiveModel(Properties config) {
        super(config);

        if (config.getProperty("MAX_ANOMALY_TIME_AGO") == null) {
            throw new IllegalArgumentException("MAX_ANOMALY_TIME_AGO is NULL");
        }
        this.maxHrsAgo = new Integer(config.getProperty("MAX_ANOMALY_TIME_AGO"));
        this.windowStart = new Long(config.getProperty("DETECTION_WINDOW_START_TIME"));
        if (config.getProperty("WINDOW_SIZE") == null) {
            throw new IllegalArgumentException("WINDOW_SIZE is NULL");
        }
        this.window_size = new Float(config.getProperty("WINDOW_SIZE"));
        if (config.getProperty("THRESHOLD") == null) {
        	throw new IllegalArgumentException("THRESHOLD is NULL");
        }
        this.threshold = parseMap(config.getProperty("THRESHOLD"));
        if (config.getProperty("THRESHOLD") != null && this.threshold.isEmpty() == true) {
            throw new IllegalArgumentException("THRESHOLD PARSE ERROR");
        } 
    }
    
    public void toJson(JSONStringer json_out) {

    }

    public void fromJson(JSONObject json_obj) {

    }

    public String getModelName() {
        return modelName;
    }

    @Override
    public String getType() {
        return "point_outlier";
    }

    @Override
    public void reset() {
        // At this point, reset does nothing.
    }

    @Override
    public void tune(DataSequence observedSeries, DataSequence expectedSeries,
            IntervalSequence anomalySequence) throws Exception {
        // TODO: auto detect thresholds.
    }
    // Returns true this point is identified as a potential anomaly.
    public boolean isAnomaly(Float[] errors, Map threshold) {
        // Cycle through all available thresholds and return
        // true if any of them matches.
        for (Map.Entry entry : threshold.entrySet()) {
            // disable mapee and mape.
            if (aes.getErrorToIndex().containsKey(entry.getKey()) == true &&
                Math.abs(errors[aes.getErrorToIndex().get(entry.getKey())]) >= Math.abs(entry.getValue())) {
                return true;
            }
        }
        return false;
    }
   
    @Override
    public IntervalSequence detect(DataSequence observedSeries,
            DataSequence expectedSeries) throws Exception {
        
        // Get an array of thresholds.
        Float[] thresholdErrors = new Float[aes.getErrorToIndex().size()];
        for (Map.Entry entry : this.threshold.entrySet()) {
            thresholdErrors[aes.getErrorToIndex().get(entry.getKey())] = Math.abs(entry.getValue());
        }
        
        IntervalSequence output = new IntervalSequence();
        int n = observedSeries.size();
        Integer cutIndex = null;
        
        // Handle fractional windows which are interpreted as
        // % of the entire TimeSeries size.
        if (window_size < 1.0) {
            cutIndex = Math.round(window_size * ((float) n));
        } else {
        	cutIndex = Math.round(window_size);
        }
        
        if (cutIndex + 1 > n) {
            return output;
        }

        Float[] observed = new Float[] {observedSeries.get(0).value, observedSeries.get(0).value};
        Float[] expected = new Float[] {expectedSeries.get(0).value, expectedSeries.get(0).value};
        
        int maxIndex = 0;
        int minIndex = 0;
        
        int anomaly = 0;
        
        for (int k = 0; k < n; k++) {
        	
        	if (observed[0] < observedSeries.get(k).value) {
        		observed[0] = observedSeries.get(k).value;
        		maxIndex = k;
        		anomaly = 1;
        	}
        	
        	if (observed[1] > observedSeries.get(k).value) {
        		observed[1] = observedSeries.get(k).value;
        		minIndex = k;
        		anomaly = 1;
        	}
        	
        	if (k < cutIndex) {
        		continue;
        	}
        	
        	expected[0] = Math.max(expected[0], observedSeries.get(k - cutIndex).value);
        	expected[1] = Math.min(expected[1], observedSeries.get(k - cutIndex).value);        	
        	        	
            // Check for anomalies for min/max.
        	int anomalyIndex = 0;
            for (int i = 0; i < 2; i++) {
                Float[] errors = aes.computeErrorMetrics(expected[i], observed[i]);
                boolean actualAnomaly = false;
                if (i == 0 && observed[i] > expected[i]) {
                    actualAnomaly = true;
                    anomalyIndex = maxIndex;
                }
                if (i == 1 && observed[i] < expected[i]) {
                    actualAnomaly = true;
                    anomalyIndex = minIndex;
                }
                
                if (isAnomaly(errors, threshold) == true && actualAnomaly == true && anomaly == 1 &&
                    (isDetectionWindowPoint(maxHrsAgo, windowStart, observedSeries.get(anomalyIndex).time, observedSeries.get(0).time) ||
        						(maxHrsAgo == 0 && i == (n - 1)))) {
                	anomaly = 0;
                    logger.debug("TS:" + observedSeries.get(anomalyIndex).time + ",E:" + arrayF2S(errors) + ",TH:" + arrayF2S(thresholdErrors) + ",OV:" + observedSeries.get(anomalyIndex).value + ",EV:" + expected[i]);
                    output.add(new Interval(observedSeries.get(anomalyIndex).time,
                    		   anomalyIndex,
                               errors,
                               thresholdErrors,
                               observed[i],
                               expected[i],
                               isAnomaly(errors, threshold)));
                }
            }  
        }
        return output;
    }
}

 

Ads help maintain this website.