samoa-api/src/main/java/org/apache/samoa/learners/classifiers/rules/common/RuleRegressionNode.java - incubator-samoa - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */

 package org.apache.samoa.learners.classifiers.rules.common;

 import java.io.Serializable;

 import org.apache.samoa.instances.Instance;
 import org.apache.samoa.moa.core.DoubleVector;

 /**
  * The base class for LearningNode for regression rule.
  *
  * @author Anh Thu Vu
  *
  */
 public abstract class RuleRegressionNode implements Serializable {

   private static final long serialVersionUID = 9129659494380381126L;

   protected int predictionFunction;
   protected int ruleNumberID;
   // The statistics for this node:
   // Number of instances that have reached it
   // Sum of y values
   // Sum of squared y values
   protected DoubleVector nodeStatistics;

   protected Perceptron perceptron;
   protected TargetMean targetMean;
   protected double learningRatio;

   /*
    * Simple setters & getters
    */
   public Perceptron getPerceptron() {
     return perceptron;
   }

   public void setPerceptron(Perceptron perceptron) {
     this.perceptron = perceptron;
   }

   public TargetMean getTargetMean() {
     return targetMean;
   }

   public void setTargetMean(TargetMean targetMean) {
     this.targetMean = targetMean;
   }

   /*
    * Create a new RuleRegressionNode
    */
   public RuleRegressionNode(double[] initialClassObservations) {
     this.nodeStatistics = new DoubleVector(initialClassObservations);
   }

   public RuleRegressionNode() {
     this(new double[0]);
   }

   /*
    * Update statistics with input instance
    */
   public abstract void updateStatistics(Instance instance);

   /*
    * Predictions
    */
   public double[] getPrediction(Instance instance) {
     int predictionMode = this.getLearnerToUse(this.predictionFunction);
     return getPrediction(instance, predictionMode);
   }

   public double[] getSimplePrediction() {
     if (this.targetMean != null)
       return this.targetMean.getVotesForInstance();
     else
       return new double[] { 0 };
   }

   public double[] getPrediction(Instance instance, int predictionMode) {
     double[] ret;
     if (predictionMode == 1)
       ret = this.perceptron.getVotesForInstance(instance);
     else
       ret = this.targetMean.getVotesForInstance(instance);
     return ret;
   }

   public double getNormalizedPrediction(Instance instance) {
     double res;
     double[] aux;
     switch (this.predictionFunction) {
     // perceptron - 1
     case 1:
       res = this.perceptron.normalizedPrediction(instance);
       break;
     // target mean - 2
     case 2:
       aux = this.targetMean.getVotesForInstance();
       res = normalize(aux[0]);
       break;
     // adaptive - 0
     case 0:
       int predictionMode = this.getLearnerToUse(0);
       if (predictionMode == 1)
       {
         res = this.perceptron.normalizedPrediction(instance);
       }
       else {
         aux = this.targetMean.getVotesForInstance(instance);
         res = normalize(aux[0]);
       }
       break;
     default:
       throw new UnsupportedOperationException("Prediction mode not in range.");
     }
     return res;
   }

   /*
    * Get learner mode
    */
   public int getLearnerToUse(int predMode) {
     int predictionMode = predMode;
     if (predictionMode == 0) {
       double perceptronError = this.perceptron.getCurrentError();
       double meanTargetError = this.targetMean.getCurrentError();
       if (perceptronError < meanTargetError)
         predictionMode = 1; // PERCEPTRON
       else
         predictionMode = 2; // TARGET MEAN
     }
     return predictionMode;
   }

   /*
    * Error and change detection
    */
   public double computeError(Instance instance) {
     double normalizedPrediction = getNormalizedPrediction(instance);
     double normalizedClassValue = normalize(instance.classValue());
     return Math.abs(normalizedClassValue - normalizedPrediction);
   }

   public double getCurrentError() {
     double error;
     if (this.perceptron != null) {
       if (targetMean == null)
         error = perceptron.getCurrentError();
       else {
         double errorP = perceptron.getCurrentError();
         double errorTM = targetMean.getCurrentError();
         error = (errorP < errorTM) ? errorP : errorTM;
       }
     }
     else
       error = Double.MAX_VALUE;
     return error;
   }

   /*
    * no. of instances seen
    */
   public long getInstancesSeen() {
     if (nodeStatistics != null) {
       return (long) this.nodeStatistics.getValue(0);
     } else {
       return 0;
     }
   }

   public DoubleVector getNodeStatistics() {
     return this.nodeStatistics;
   }

   /*
    * Anomaly detection
    */
   public boolean isAnomaly(Instance instance,
       double uniVariateAnomalyProbabilityThreshold,
       double multiVariateAnomalyProbabilityThreshold,
       int numberOfInstanceesForAnomaly) {
     // AMRUles is equipped with anomaly detection. If on, compute the anomaly
     // value.
     long perceptronIntancesSeen = this.perceptron.getInstancesSeen();
     if (perceptronIntancesSeen >= numberOfInstanceesForAnomaly) {
       double attribSum;
       double attribSquaredSum;
       double D = 0.0;
       double N = 0.0;
       double anomaly;

       for (int x = 0; x < instance.numAttributes() - 1; x++) {
         // Perceptron is initialized each rule.
         // this is a local anomaly.
         int instAttIndex = modelAttIndexToInstanceAttIndex(x, instance);
         attribSum = this.perceptron.perceptronattributeStatistics.getValue(x);
         attribSquaredSum = this.perceptron.squaredperceptronattributeStatistics.getValue(x);
         double mean = attribSum / perceptronIntancesSeen;
         double sd = computeSD(attribSquaredSum, attribSum, perceptronIntancesSeen);
         double probability = computeProbability(mean, sd, instance.value(instAttIndex));

         if (probability > 0.0) {
           D = D + Math.abs(Math.log(probability));
           if (probability < uniVariateAnomalyProbabilityThreshold) {// 0.10
             N = N + Math.abs(Math.log(probability));
           }
         }
       }

       anomaly = 0.0;
       if (D != 0.0) {
         anomaly = N / D;
       }
       if (anomaly >= multiVariateAnomalyProbabilityThreshold) {
         // debuganomaly(instance,
         // uniVariateAnomalyProbabilityThreshold,
         // multiVariateAnomalyProbabilityThreshold,
         // anomaly);
         return true;
       }
     }
     return false;
   }

   /*
    * Helpers
    */
   public static double computeProbability(double mean, double sd, double value) {
     double probability = 0.0;

     if (sd > 0.0) {
       double k = (Math.abs(value - mean) / sd); // One tailed variant of Chebyshev's inequality
       probability = 1.0 / (1 + k * k);
     }

     return probability;
   }

   public static double computeHoeffdingBound(double range, double confidence, double n) {
     return Math.sqrt(((range * range) * Math.log(1.0 / confidence)) / (2.0 * n));
   }

   private double normalize(double value) {
     double meanY = this.nodeStatistics.getValue(1) / this.nodeStatistics.getValue(0);
     double sdY = computeSD(this.nodeStatistics.getValue(2), this.nodeStatistics.getValue(1),
         (long) this.nodeStatistics.getValue(0));
     double normalizedY = 0.0;
     if (sdY > 0.0000001) {
       normalizedY = (value - meanY) / (sdY);
     }
     return normalizedY;
   }

   public double computeSD(double squaredVal, double val, long size) {
     if (size > 1) {
       return Math.sqrt((squaredVal - ((val * val) / size)) / (size - 1.0));
     }
     return 0.0;
   }

   /**
    * Gets the index of the attribute in the instance, given the index of the attribute in the learner.
    *
    * @param index
    *          the index of the attribute in the learner
    * @param inst
    *          the instance
    * @return the index in the instance
    */
   protected static int modelAttIndexToInstanceAttIndex(int index, Instance inst) {
     return index <= inst.classIndex() ? index : index + 1;
   }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/

	package org.apache.samoa.learners.classifiers.rules.common;

	import java.io.Serializable;

	import org.apache.samoa.instances.Instance;
	import org.apache.samoa.moa.core.DoubleVector;

	/**
	* The base class for LearningNode for regression rule.
	*
	* @author Anh Thu Vu
	*
	*/
	public abstract class RuleRegressionNode implements Serializable {

	private static final long serialVersionUID = 9129659494380381126L;

	protected int predictionFunction;
	protected int ruleNumberID;
	// The statistics for this node:
	// Number of instances that have reached it
	// Sum of y values
	// Sum of squared y values
	protected DoubleVector nodeStatistics;

	protected Perceptron perceptron;
	protected TargetMean targetMean;
	protected double learningRatio;

	/*
	* Simple setters & getters
	*/
	public Perceptron getPerceptron() {
	return perceptron;
	}

	public void setPerceptron(Perceptron perceptron) {
	this.perceptron = perceptron;
	}

	public TargetMean getTargetMean() {
	return targetMean;
	}

	public void setTargetMean(TargetMean targetMean) {
	this.targetMean = targetMean;
	}

	/*
	* Create a new RuleRegressionNode
	*/
	public RuleRegressionNode(double[] initialClassObservations) {
	this.nodeStatistics = new DoubleVector(initialClassObservations);
	}

	public RuleRegressionNode() {
	this(new double[0]);
	}

	/*
	* Update statistics with input instance
	*/
	public abstract void updateStatistics(Instance instance);

	/*
	* Predictions
	*/
	public double[] getPrediction(Instance instance) {
	int predictionMode = this.getLearnerToUse(this.predictionFunction);
	return getPrediction(instance, predictionMode);
	}

	public double[] getSimplePrediction() {
	if (this.targetMean != null)
	return this.targetMean.getVotesForInstance();
	else
	return new double[] { 0 };
	}

	public double[] getPrediction(Instance instance, int predictionMode) {
	double[] ret;
	if (predictionMode == 1)
	ret = this.perceptron.getVotesForInstance(instance);
	else
	ret = this.targetMean.getVotesForInstance(instance);
	return ret;
	}

	public double getNormalizedPrediction(Instance instance) {
	double res;
	double[] aux;
	switch (this.predictionFunction) {
	// perceptron - 1
	case 1:
	res = this.perceptron.normalizedPrediction(instance);
	break;
	// target mean - 2
	case 2:
	aux = this.targetMean.getVotesForInstance();
	res = normalize(aux[0]);
	break;
	// adaptive - 0
	case 0:
	int predictionMode = this.getLearnerToUse(0);
	if (predictionMode == 1)
	{
	res = this.perceptron.normalizedPrediction(instance);
	}
	else {
	aux = this.targetMean.getVotesForInstance(instance);
	res = normalize(aux[0]);
	}
	break;
	default:
	throw new UnsupportedOperationException("Prediction mode not in range.");
	}
	return res;
	}

	/*
	* Get learner mode
	*/
	public int getLearnerToUse(int predMode) {
	int predictionMode = predMode;
	if (predictionMode == 0) {
	double perceptronError = this.perceptron.getCurrentError();
	double meanTargetError = this.targetMean.getCurrentError();
	if (perceptronError < meanTargetError)
	predictionMode = 1; // PERCEPTRON
	else
	predictionMode = 2; // TARGET MEAN
	}
	return predictionMode;
	}

	/*
	* Error and change detection
	*/
	public double computeError(Instance instance) {
	double normalizedPrediction = getNormalizedPrediction(instance);
	double normalizedClassValue = normalize(instance.classValue());
	return Math.abs(normalizedClassValue - normalizedPrediction);
	}

	public double getCurrentError() {
	double error;
	if (this.perceptron != null) {
	if (targetMean == null)
	error = perceptron.getCurrentError();
	else {
	double errorP = perceptron.getCurrentError();
	double errorTM = targetMean.getCurrentError();
	error = (errorP < errorTM) ? errorP : errorTM;
	}
	}
	else
	error = Double.MAX_VALUE;
	return error;
	}

	/*
	* no. of instances seen
	*/
	public long getInstancesSeen() {
	if (nodeStatistics != null) {
	return (long) this.nodeStatistics.getValue(0);
	} else {
	return 0;
	}
	}

	public DoubleVector getNodeStatistics() {
	return this.nodeStatistics;
	}

	/*
	* Anomaly detection
	*/
	public boolean isAnomaly(Instance instance,
	double uniVariateAnomalyProbabilityThreshold,
	double multiVariateAnomalyProbabilityThreshold,
	int numberOfInstanceesForAnomaly) {
	// AMRUles is equipped with anomaly detection. If on, compute the anomaly
	// value.
	long perceptronIntancesSeen = this.perceptron.getInstancesSeen();
	if (perceptronIntancesSeen >= numberOfInstanceesForAnomaly) {
	double attribSum;
	double attribSquaredSum;
	double D = 0.0;
	double N = 0.0;
	double anomaly;

	for (int x = 0; x < instance.numAttributes() - 1; x++) {
	// Perceptron is initialized each rule.
	// this is a local anomaly.
	int instAttIndex = modelAttIndexToInstanceAttIndex(x, instance);
	attribSum = this.perceptron.perceptronattributeStatistics.getValue(x);
	attribSquaredSum = this.perceptron.squaredperceptronattributeStatistics.getValue(x);
	double mean = attribSum / perceptronIntancesSeen;
	double sd = computeSD(attribSquaredSum, attribSum, perceptronIntancesSeen);
	double probability = computeProbability(mean, sd, instance.value(instAttIndex));

	if (probability > 0.0) {
	D = D + Math.abs(Math.log(probability));
	if (probability < uniVariateAnomalyProbabilityThreshold) {// 0.10
	N = N + Math.abs(Math.log(probability));
	}
	}
	}

	anomaly = 0.0;
	if (D != 0.0) {
	anomaly = N / D;
	}
	if (anomaly >= multiVariateAnomalyProbabilityThreshold) {
	// debuganomaly(instance,
	// uniVariateAnomalyProbabilityThreshold,
	// multiVariateAnomalyProbabilityThreshold,
	// anomaly);
	return true;
	}
	}
	return false;
	}

	/*
	* Helpers
	*/
	public static double computeProbability(double mean, double sd, double value) {
	double probability = 0.0;

	if (sd > 0.0) {
	double k = (Math.abs(value - mean) / sd); // One tailed variant of Chebyshev's inequality
	probability = 1.0 / (1 + k * k);
	}

	return probability;
	}

	public static double computeHoeffdingBound(double range, double confidence, double n) {
	return Math.sqrt(((range * range) * Math.log(1.0 / confidence)) / (2.0 * n));
	}

	private double normalize(double value) {
	double meanY = this.nodeStatistics.getValue(1) / this.nodeStatistics.getValue(0);
	double sdY = computeSD(this.nodeStatistics.getValue(2), this.nodeStatistics.getValue(1),
	(long) this.nodeStatistics.getValue(0));
	double normalizedY = 0.0;
	if (sdY > 0.0000001) {
	normalizedY = (value - meanY) / (sdY);
	}
	return normalizedY;
	}

	public double computeSD(double squaredVal, double val, long size) {
	if (size > 1) {
	return Math.sqrt((squaredVal - ((val * val) / size)) / (size - 1.0));
	}
	return 0.0;
	}

	/**
	* Gets the index of the attribute in the instance, given the index of the attribute in the learner.
	*
	* @param index
	* the index of the attribute in the learner
	* @param inst
	* the instance
	* @return the index in the instance
	*/
	protected static int modelAttIndexToInstanceAttIndex(int index, Instance inst) {
	return index <= inst.classIndex() ? index : index + 1;
	}
	}