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

 package org.apache.samoa.learners.classifiers;

 /*
  * #%L
  * SAMOA
  * %%
  * Copyright (C) 2014 - 2015 Apache Software Foundation
  * %%
  * Licensed 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.
  * #L%
  */

 import java.util.HashMap;
 import java.util.Map;

 import org.apache.samoa.instances.Instance;
 import org.apache.samoa.instances.Instances;
 import org.apache.samoa.moa.classifiers.core.attributeclassobservers.GaussianNumericAttributeClassObserver;
 import org.apache.samoa.moa.core.GaussianEstimator;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 /**
  * Implementation of a non-distributed Naive Bayes classifier.
  *
  * At the moment, the implementation models all attributes as numeric attributes.
  *
  * @author Olivier Van Laere (vanlaere yahoo-inc dot com)
  */
 public class NaiveBayes implements LocalLearner {

   /**
    * Default smoothing factor. For now fixed to 1E-20.
    */
   private static final double ADDITIVE_SMOOTHING_FACTOR = 1e-20;

   /**
    * serialVersionUID for serialization
    */
   private static final long serialVersionUID = 1325775209672996822L;

   /**
    * Instance of a logger for use in this class.
    */
   private static final Logger logger = LoggerFactory.getLogger(NaiveBayes.class);

   /**
    * The actual model.
    */
   protected Map<Integer, GaussianNumericAttributeClassObserver> attributeObservers;

   /**
    * Class statistics
    */
   protected Map<Integer, Double> classInstances;

   /**
    * Class zero-prototypes.
    */
   protected Map<Integer, Double> classPrototypes;

   /**
    * Retrieve the number of classes currently known to this local model
    *
    * @return the number of classes currently known to this local model
    */
   protected int getNumberOfClasses() {
     return this.classInstances.size();
   }

   /**
    * Track training instances seen.
    */
   protected long instancesSeen = 0L;

   /**
    * Explicit no-arg constructor.
    */
   public NaiveBayes() {
     // Init the model
     resetLearning();
   }

   /**
    * Create an instance of this LocalLearner implementation.
    */
   @Override
   public LocalLearner create() {
     return new NaiveBayes();
   }

   /**
    * Predicts the class memberships for a given instance. If an instance is unclassified, the returned array elements
    * will be all zero.
    *
    * Smoothing is being implemented by the AttributeClassObserver classes. At the moment, the
    * GaussianNumericProbabilityAttributeClassObserver needs no smoothing as it processes continuous variables.
    *
    * Please note that we transform the scores to log space to avoid underflow, and we replace the multiplication with
    * addition.
    *
    * The resulting scores are no longer probabilities, as a mixture of probability densities and probabilities can be
    * used in the computation.
    *
    * @param inst
    *          the instance to be classified
    * @return an array containing the estimated membership scores of the test instance in each class, in log space.
    */
   @Override
   public double[] getVotesForInstance(Instance inst) {
     // Prepare the results array
     double[] votes = new double[getNumberOfClasses()];
     // Over all classes
     for (int classIndex = 0; classIndex < votes.length; classIndex++) {
       // Get the prior for this class
       votes[classIndex] = Math.log(getPrior(classIndex));
       // Iterate over the instance attributes
       for (int index = 0; index < inst.numAttributes(); index++) {
         int attributeID = inst.index(index);
         // Skip class attribute
         if (attributeID == inst.classIndex())
           continue;
         Double value = inst.value(attributeID);
         // Get the observer for the given attribute
         GaussianNumericAttributeClassObserver obs = attributeObservers.get(attributeID);
         // Init the estimator to null by default
         GaussianEstimator estimator = null;
         if (obs != null && obs.getEstimator(classIndex) != null) {
           // Get the estimator
           estimator = obs.getEstimator(classIndex);
         }
         double valueNonZero;
         // The null case should be handled by smoothing!
         if (estimator != null) {
           // Get the score for a NON-ZERO attribute value
           valueNonZero = estimator.probabilityDensity(value);
         }
         // We don't have an estimator
         else {
           // Assign a very small probability that we do see this value
           valueNonZero = ADDITIVE_SMOOTHING_FACTOR;
         }
         votes[classIndex] += Math.log(valueNonZero); // - Math.log(valueZero);
       }
       // Check for null in the case of prequential evaluation
       if (this.classPrototypes.get(classIndex) != null) {
         // Add the prototype for the class, already in log space
         votes[classIndex] += Math.log(this.classPrototypes.get(classIndex));
       }
     }
     return votes;
   }

   /**
    * Compute the prior for the given classIndex.
    *
    * Implemented by maximum likelihood at the moment.
    *
    * @param classIndex
    *          Id of the class for which we want to compute the prior.
    * @return Prior probability for the requested class
    */
   private double getPrior(int classIndex) {
     // Maximum likelihood
     Double currentCount = this.classInstances.get(classIndex);
     if (currentCount == null || currentCount == 0)
       return 0;
     else
       return currentCount * 1. / this.instancesSeen;
   }

   /**
    * Resets this classifier. It must be similar to starting a new classifier from scratch.
    */
   @Override
   public void resetLearning() {
     // Reset priors
     this.instancesSeen = 0L;
     this.classInstances = new HashMap<>();
     this.classPrototypes = new HashMap<>();
     // Init the attribute observers
     this.attributeObservers = new HashMap<>();
   }

   /**
    * Trains this classifier incrementally using the given instance.
    *
    * @param inst
    *          the instance to be used for training
    */
   @Override
   public void trainOnInstance(Instance inst) {
     // Update class statistics with weights
     int classIndex = (int) inst.classValue();
     Double weight = this.classInstances.get(classIndex);
     if (weight == null)
       weight = 0.;
     this.classInstances.put(classIndex, weight + inst.weight());

     // Get the class prototype
     Double classPrototype = this.classPrototypes.get(classIndex);
     if (classPrototype == null)
       classPrototype = 1.;

     // Iterate over the attributes of the given instance
     for (int attributePosition = 0; attributePosition < inst
         .numAttributes(); attributePosition++) {
       // Get the attribute index - Dense -> 1:1, Sparse is remapped
       int attributeID = inst.index(attributePosition);
       // Skip class attribute
       if (attributeID == inst.classIndex())
         continue;
       // Get the attribute observer for the current attribute
       GaussianNumericAttributeClassObserver obs = this.attributeObservers
           .get(attributeID);
       // Lazy init of observers, if null, instantiate a new one
       if (obs == null) {
         // FIXME: At this point, we model everything as a numeric
         // attribute
         obs = new GaussianNumericAttributeClassObserver();
         this.attributeObservers.put(attributeID, obs);
       }

       // Get the probability density function under the current model
       GaussianEstimator obs_estimator = obs.getEstimator(classIndex);
       if (obs_estimator != null) {
         // Fetch the probability that the feature value is zero
         double probDens_zero_current = obs_estimator.probabilityDensity(0);
         classPrototype -= probDens_zero_current;
       }

       // FIXME: Sanity check on data values, for now just learn
       // Learn attribute value for given class
       obs.observeAttributeClass(inst.valueSparse(attributePosition),
           (int) inst.classValue(), inst.weight());

       // Update obs_estimator to fetch the pdf from the updated model
       obs_estimator = obs.getEstimator(classIndex);
       // Fetch the probability that the feature value is zero
       double probDens_zero_updated = obs_estimator.probabilityDensity(0);
       // Update the class prototype
       classPrototype += probDens_zero_updated;
     }
     // Store the class prototype
     this.classPrototypes.put(classIndex, classPrototype);
     // Count another training instance
     this.instancesSeen++;
   }

   @Override
   public void setDataset(Instances dataset) {
     // Do nothing
   }
 }
	package org.apache.samoa.learners.classifiers;

	/*
	* #%L
	* SAMOA
	* %%
	* Copyright (C) 2014 - 2015 Apache Software Foundation
	* %%
	* Licensed 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.
	* #L%
	*/

	import java.util.HashMap;
	import java.util.Map;

	import org.apache.samoa.instances.Instance;
	import org.apache.samoa.instances.Instances;
	import org.apache.samoa.moa.classifiers.core.attributeclassobservers.GaussianNumericAttributeClassObserver;
	import org.apache.samoa.moa.core.GaussianEstimator;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	/**
	* Implementation of a non-distributed Naive Bayes classifier.
	*
	* At the moment, the implementation models all attributes as numeric attributes.
	*
	* @author Olivier Van Laere (vanlaere yahoo-inc dot com)
	*/
	public class NaiveBayes implements LocalLearner {

	/**
	* Default smoothing factor. For now fixed to 1E-20.
	*/
	private static final double ADDITIVE_SMOOTHING_FACTOR = 1e-20;

	/**
	* serialVersionUID for serialization
	*/
	private static final long serialVersionUID = 1325775209672996822L;

	/**
	* Instance of a logger for use in this class.
	*/
	private static final Logger logger = LoggerFactory.getLogger(NaiveBayes.class);

	/**
	* The actual model.
	*/
	protected Map<Integer, GaussianNumericAttributeClassObserver> attributeObservers;

	/**
	* Class statistics
	*/
	protected Map<Integer, Double> classInstances;

	/**
	* Class zero-prototypes.
	*/
	protected Map<Integer, Double> classPrototypes;

	/**
	* Retrieve the number of classes currently known to this local model
	*
	* @return the number of classes currently known to this local model
	*/
	protected int getNumberOfClasses() {
	return this.classInstances.size();
	}

	/**
	* Track training instances seen.
	*/
	protected long instancesSeen = 0L;

	/**
	* Explicit no-arg constructor.
	*/
	public NaiveBayes() {
	// Init the model
	resetLearning();
	}

	/**
	* Create an instance of this LocalLearner implementation.
	*/
	@Override
	public LocalLearner create() {
	return new NaiveBayes();
	}

	/**
	* Predicts the class memberships for a given instance. If an instance is unclassified, the returned array elements
	* will be all zero.
	*
	* Smoothing is being implemented by the AttributeClassObserver classes. At the moment, the
	* GaussianNumericProbabilityAttributeClassObserver needs no smoothing as it processes continuous variables.
	*
	* Please note that we transform the scores to log space to avoid underflow, and we replace the multiplication with
	* addition.
	*
	* The resulting scores are no longer probabilities, as a mixture of probability densities and probabilities can be
	* used in the computation.
	*
	* @param inst
	* the instance to be classified
	* @return an array containing the estimated membership scores of the test instance in each class, in log space.
	*/
	@Override
	public double[] getVotesForInstance(Instance inst) {
	// Prepare the results array
	double[] votes = new double[getNumberOfClasses()];
	// Over all classes
	for (int classIndex = 0; classIndex < votes.length; classIndex++) {
	// Get the prior for this class
	votes[classIndex] = Math.log(getPrior(classIndex));
	// Iterate over the instance attributes
	for (int index = 0; index < inst.numAttributes(); index++) {
	int attributeID = inst.index(index);
	// Skip class attribute
	if (attributeID == inst.classIndex())
	continue;
	Double value = inst.value(attributeID);
	// Get the observer for the given attribute
	GaussianNumericAttributeClassObserver obs = attributeObservers.get(attributeID);
	// Init the estimator to null by default
	GaussianEstimator estimator = null;
	if (obs != null && obs.getEstimator(classIndex) != null) {
	// Get the estimator
	estimator = obs.getEstimator(classIndex);
	}
	double valueNonZero;
	// The null case should be handled by smoothing!
	if (estimator != null) {
	// Get the score for a NON-ZERO attribute value
	valueNonZero = estimator.probabilityDensity(value);
	}
	// We don't have an estimator
	else {
	// Assign a very small probability that we do see this value
	valueNonZero = ADDITIVE_SMOOTHING_FACTOR;
	}
	votes[classIndex] += Math.log(valueNonZero); // - Math.log(valueZero);
	}
	// Check for null in the case of prequential evaluation
	if (this.classPrototypes.get(classIndex) != null) {
	// Add the prototype for the class, already in log space
	votes[classIndex] += Math.log(this.classPrototypes.get(classIndex));
	}
	}
	return votes;
	}

	/**
	* Compute the prior for the given classIndex.
	*
	* Implemented by maximum likelihood at the moment.
	*
	* @param classIndex
	* Id of the class for which we want to compute the prior.
	* @return Prior probability for the requested class
	*/
	private double getPrior(int classIndex) {
	// Maximum likelihood
	Double currentCount = this.classInstances.get(classIndex);
	if (currentCount == null \|\| currentCount == 0)
	return 0;
	else
	return currentCount * 1. / this.instancesSeen;
	}

	/**
	* Resets this classifier. It must be similar to starting a new classifier from scratch.
	*/
	@Override
	public void resetLearning() {
	// Reset priors
	this.instancesSeen = 0L;
	this.classInstances = new HashMap<>();
	this.classPrototypes = new HashMap<>();
	// Init the attribute observers
	this.attributeObservers = new HashMap<>();
	}

	/**
	* Trains this classifier incrementally using the given instance.
	*
	* @param inst
	* the instance to be used for training
	*/
	@Override
	public void trainOnInstance(Instance inst) {
	// Update class statistics with weights
	int classIndex = (int) inst.classValue();
	Double weight = this.classInstances.get(classIndex);
	if (weight == null)
	weight = 0.;
	this.classInstances.put(classIndex, weight + inst.weight());

	// Get the class prototype
	Double classPrototype = this.classPrototypes.get(classIndex);
	if (classPrototype == null)
	classPrototype = 1.;

	// Iterate over the attributes of the given instance
	for (int attributePosition = 0; attributePosition < inst
	.numAttributes(); attributePosition++) {
	// Get the attribute index - Dense -> 1:1, Sparse is remapped
	int attributeID = inst.index(attributePosition);
	// Skip class attribute
	if (attributeID == inst.classIndex())
	continue;
	// Get the attribute observer for the current attribute
	GaussianNumericAttributeClassObserver obs = this.attributeObservers
	.get(attributeID);
	// Lazy init of observers, if null, instantiate a new one
	if (obs == null) {
	// FIXME: At this point, we model everything as a numeric
	// attribute
	obs = new GaussianNumericAttributeClassObserver();
	this.attributeObservers.put(attributeID, obs);
	}

	// Get the probability density function under the current model
	GaussianEstimator obs_estimator = obs.getEstimator(classIndex);
	if (obs_estimator != null) {
	// Fetch the probability that the feature value is zero
	double probDens_zero_current = obs_estimator.probabilityDensity(0);
	classPrototype -= probDens_zero_current;
	}

	// FIXME: Sanity check on data values, for now just learn
	// Learn attribute value for given class
	obs.observeAttributeClass(inst.valueSparse(attributePosition),
	(int) inst.classValue(), inst.weight());

	// Update obs_estimator to fetch the pdf from the updated model
	obs_estimator = obs.getEstimator(classIndex);
	// Fetch the probability that the feature value is zero
	double probDens_zero_updated = obs_estimator.probabilityDensity(0);
	// Update the class prototype
	classPrototype += probDens_zero_updated;
	}
	// Store the class prototype
	this.classPrototypes.put(classIndex, classPrototype);
	// Count another training instance
	this.instancesSeen++;
	}

	@Override
	public void setDataset(Instances dataset) {
	// Do nothing
	}
	}