package jsat.classifiers.boosting;

import java.util.concurrent.CountDownLatch;
import java.util.logging.Level;
import java.util.logging.Logger;
import jsat.classifiers.CategoricalData;
import jsat.classifiers.CategoricalResults;
import jsat.classifiers.ClassificationDataSet;
import jsat.classifiers.Classifier;
import jsat.classifiers.DataPoint;
import jsat.parameters.Parameterized;
import jsat.utils.FakeExecutor;
import jsat.utils.SystemInfo;
import jsat.utils.concurrent.ParallelUtils;

/**
 * Arc-x4 is a ensemble-classifier that performs re-weighting of the data points 
 * based on the total number of errors that have occurred for the data point.
 * 

* See: Breiman, L. (1998). Arcing Classifiers. The Annals of Statistics, * 26(3), 801–824. * * @author Edward Raff */ public class ArcX4 implements Classifier, Parameterized { private static final long serialVersionUID = 3831448932874147550L; private Classifier weakLearner; private int iterations; private double coef = 1; private double expo = 4; private CategoricalData predicing; private Classifier[] hypoths; /** * Creates a new Arc-X4 classifier * * @param weakLearner the weak learner to use * @param iterations the number of iterations to perform */ public ArcX4(Classifier weakLearner, int iterations) { setWeakLearner(weakLearner); setIterations(iterations); } /** * Sets the weak learner used at each iteration of learning * @param weakLearner the weak learner to use */ public void setWeakLearner(Classifier weakLearner) { if(!weakLearner.supportsWeightedData()) throw new RuntimeException("Weak learners must support weighted data samples"); this.weakLearner = weakLearner; } /** * Returns the weak learner used * @return the weak learner used */ public Classifier getWeakLearner() { return weakLearner; } /** * Sets the number of iterations to perform * @param iterations the number of iterations to do */ public void setIterations(int iterations) { this.iterations = iterations; } /** * Returns the number of iterations to learn * @return the number of iterations to learn */ public int getIterations() { return iterations; } /** * Weights are updated as 1+coef*errorsexpo. This sets the * coefficient used to update the errors * * @param coef the multiplicative factor on the errors in weight construction */ public void setCoefficient(double coef) { if(coef <= 0 || Double.isInfinite(coef) || Double.isNaN(coef)) throw new ArithmeticException("The coefficient must be a positive constant"); this.coef = coef; } /** * Returns the coefficient use when re-weighting * @return the coefficient use when re-weighting */ public double getCoefficient() { return coef; } /** * Weights are updated as 1+coef*errorsexpo. This sets the * exponent used to update the errors * @param expo the exponent to use */ public void setExponent(double expo) { if(expo <= 0 || Double.isInfinite(expo) || Double.isNaN(expo)) throw new ArithmeticException("The exponent must be a positive constant"); this.expo = expo; } /** * Returns the exponent used when re-weighting * @return the exponent used when re-weighting */ public double getExponent() { return expo; } @Override public CategoricalResults classify(DataPoint data) { CategoricalResults cr = new CategoricalResults(predicing.getNumOfCategories()); for(Classifier hypoth : hypoths) cr.incProb(hypoth.classify(data).mostLikely(), 1.0); cr.normalize(); return cr; } @Override public void train(ClassificationDataSet dataSet, boolean parallel) { //Create a low memory clone that only has different dataPoint Objects to save space ClassificationDataSet cds = dataSet.shallowClone(); for(int i = 0; i < cds.getSampleSize(); i++) { DataPoint dp = cds.getDataPoint(i); cds.setDataPoint(i, new DataPoint(dp.getNumericalValues(), dp.getCategoricalValues(), dp.getCategoricalData())); } //Everyone starts with no errors int[] errors = new int[cds.getSampleSize()]; hypoths = new Classifier[iterations]; for(int t = 0; t < hypoths.length; t++) { for(int i = 0; i < cds.getSampleSize(); i++) cds.getDataPoint(i).setWeight(1+coef*Math.pow(errors[i], expo)); Classifier hypoth = weakLearner.clone(); hypoth.train(cds, parallel); hypoths[t] = hypoth; ParallelUtils.run(parallel, errors.length, (start, end) -> { for(int i = start; i < end; i++) if(hypoth.classify(cds.getDataPoint(i)).mostLikely() != cds.getDataPointCategory(i)) errors[i]++; }); } this.predicing = cds.getPredicting(); } @Override public boolean supportsWeightedData() { return false; } @Override public ArcX4 clone() { ArcX4 clone = new ArcX4(weakLearner.clone(), iterations); clone.coef = this.coef; clone.expo = this.expo; if(this.predicing != null) clone.predicing = this.predicing.clone(); if(this.hypoths != null) { clone.hypoths = new Classifier[this.hypoths.length]; for(int i = 0; i < clone.hypoths.length; i++) clone.hypoths[i] = this.hypoths[i].clone(); } return clone; } }

Ads help maintain this website.