• Home
• com.github.ptrajdos
• WekaNearestCentroid
• 1.2.6
• source code
• NearestCentroidClassifier.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

weka.classifiers.functions.NearestCentroidClassifier Maven / Gradle / Ivy

/**
 * 
 */
package weka.classifiers.functions;

import java.util.Collections;
import java.util.Enumeration;
import java.util.Vector;

import weka.classifiers.AbstractClassifier;
import weka.core.Attribute;
import weka.core.Capabilities;
import weka.core.Capabilities.Capability;
import weka.core.DenseInstance;
import weka.core.DistanceFunction;
import weka.core.EuclideanDistance;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.NormalizableDistance;
import weka.core.Option;
import weka.core.RevisionUtils;
import weka.core.Utils;
import weka.core.WeightedInstancesHandler;

/**
 * @author Pawel Trajdos
 *
 */
public class NearestCentroidClassifier extends AbstractClassifier implements WeightedInstancesHandler {

	/**
	 * 
	 */
	private static final long serialVersionUID = 8462836067571523903L;
	
	protected DistanceFunction distFun = null;
	protected Instance[] centroids = null;
	protected boolean[] activeCentroids = null;
	

	/**
	 * 
	 */
	public NearestCentroidClassifier() {
		
		EuclideanDistance tmpDist = new EuclideanDistance();
		tmpDist.setDontNormalize(true);
		this.distFun = tmpDist;

	}

	/**
	 * Builds the classifier.
	 * @param data -- training set
	 */
	@Override
	public void buildClassifier(Instances data) throws Exception {
		this.getCapabilities().testWithFail(data);
		this.distFun.setInstances(data);
		
		int numClasses = data.numClasses();
		int numAttrs = data.numAttributes();
		this.centroids = new Instance[numClasses];
		this.activeCentroids = new boolean[numClasses];
		
		int classIdx = data.classIndex();
		double[][] centroidsDoubles = new double[numClasses][numAttrs];
		double[] classObjCounts = new double[numClasses];
		
		//Initialise centroids
		for(int i=0;i max){
				max = tmp;
				maxIdx = c;
			}
			tmp = Math.exp(-tmp);
			if(this.activeCentroids[c]) {
				distribution[c] = tmp;
				distSum+=tmp;
			}
		}
		boolean err =false;
		
		err = Utils.eq(distSum, 0)? true:false;
		
		if(!err)
		for(int c =0;c listOptions() {
		Vector newVector = new Vector(1);
		
		 newVector.addElement(new Option(
			      "\tThe distance function to use "+
		          "(default: weka.core.EuclideanDistance).\n",
			      "A", 0, "-A"));
		 
		 newVector.addAll(Collections.list(super.listOptions()));
		    
		return newVector.elements();
	}

	/**
	 * Gets current options of NearesCentroidClassifier
	 */
	@Override
	public String[] getOptions() {
		

	    Vector options = new Vector();
	    

	    options.add("-A");
	    options.add(this.distFun.getClass().getName()+" "+Utils.joinOptions(this.distFun.getOptions())); 
	    
	    Collections.addAll(options, super.getOptions());
	    
	    return options.toArray(new String[0]);
	}

	/** 
	 * Parses and sets options
	 *
	   * 
Valid options are:
	   *
	   * 
 -A
	   *  The distance function to use.
	   *
	   * 
	 */
	@Override
	public void setOptions(String[] options) throws Exception {
		
		String distanceFunString = Utils.getOption('A', options);
	    if(distanceFunString.length() != 0) {
	      String distanceFunClassSpec[] = Utils.splitOptions(distanceFunString);
	      if(distanceFunClassSpec.length == 0) { 
	        throw new Exception("Invalid Distance function " +
	                            "specification string."); 
	      }
	      String className = distanceFunClassSpec[0];
	      distanceFunClassSpec[0] = "";

	      this.setDistFun( (DistanceFunction)
	                  Utils.forName( NormalizableDistance.class, 
	                                 className, 
	                                 distanceFunClassSpec)
	                                        );
	    }
	    else 
	      this.setDistFun(new EuclideanDistance());
		
		super.setOptions(options);
		
	}

	/* (non-Javadoc)
	 * @see weka.classifiers.AbstractClassifier#getCapabilities()
	 */
	@Override
	public Capabilities getCapabilities() {
		Capabilities caps = super.getCapabilities();
		caps.disableAll();
		
		
	    caps.enable(Capability.NOMINAL_CLASS);
	    caps.enable(Capability.MISSING_CLASS_VALUES);
	    
	    caps.enable(Capability.NUMERIC_ATTRIBUTES);
	    caps.enable(Capability.BINARY_ATTRIBUTES);
	    
	    

	    // instances
	    caps.setMinimumNumberInstances(2);
	    
		return caps; 
	}
	
	
	

	/* (non-Javadoc)
	 * @see java.lang.Object#toString()
	 */
	@Override
	public String toString() {
		
		if(this.centroids == null){
			return "The model has not been built yet.";
		}
		
		StringBuffer result = new StringBuffer();
		result.append("Nearest Centroid Classifier: \n\nCentroids:\n");
		Attribute classAttrib = this.centroids[0].classAttribute();
		for(int c=0;c