package jsat.classifiers;

import java.util.ArrayList;
import java.util.List;
import jsat.classifiers.calibration.BinaryScoreClassifier;
import jsat.parameters.Parameter.ParameterHolder;
import jsat.parameters.Parameterized;
import jsat.utils.concurrent.ParallelUtils;

/**
 * This classifier turns any classifier, specifically binary classifiers, into 
 * multi-class classifiers. For a problem with k target classes, OneVsALl
 * will create k different classifiers. Each one is a reducing of one 
 * class against all other classes. Then all k classifiers's results are
 * summed to produce a final classifier
 * 

* If the base learner is an instance of {@link BinaryScoreClassifier}, then the * winning class label will be the associated classifier that produced the * highest score. * * @author Edward Raff */ public class OneVSAll implements Classifier, Parameterized { private static final long serialVersionUID = -326668337438092217L; private Classifier[] oneVsAlls; @ParameterHolder private Classifier baseClassifier; private CategoricalData predicting; private boolean concurrentTraining; private boolean useScoreIfAvailable = true; /** * Creates a new One VS All classifier. * * @param baseClassifier the base classifier to replicate * @see #setConcurrentTraining(boolean) */ public OneVSAll(Classifier baseClassifier) { this(baseClassifier, true); } /** * Creates a new One VS All classifier. * * @param baseClassifier the base classifier to replicate * @param concurrentTraining controls whether or not classifiers are trained * simultaneously or using sequentially using their * {@link Classifier#train(jsat.classifiers.ClassificationDataSet, java.util.concurrent.ExecutorService) } method. * @see #setConcurrentTraining(boolean) */ public OneVSAll(Classifier baseClassifier, boolean concurrentTraining) { this.baseClassifier = baseClassifier; this.concurrentTraining = concurrentTraining; } /** * Controls what method of parallel training to use when * {@link #train(jsat.classifiers.ClassificationDataSet, java.util.concurrent.ExecutorService) } * is called. If set to true, each of the k classifiers will be trained in parallel, using * their serial algorithms. If set to false, the k classifiers will be trained sequentially, * calling the {@link Classifier#train(jsat.classifiers.ClassificationDataSet, java.util.concurrent.ExecutorService) } * for each classifier.
*
* This should be set to true for classifiers that do not support parallel training.
* Setting this to true also uses k times the memory, since each classifier is being created and trained at the same time. * @param concurrentTraining whether or not to train the classifiers in parallel */ public void setConcurrentTraining(boolean concurrentTraining) { this.concurrentTraining = concurrentTraining; } @Override public CategoricalResults classify(DataPoint data) { CategoricalResults cr = new CategoricalResults(predicting.getNumOfCategories()); if(useScoreIfAvailable && oneVsAlls[0] instanceof BinaryScoreClassifier) { int maxIndx = 0; double maxScore = Double.NEGATIVE_INFINITY; for(int i = 0; i < predicting.getNumOfCategories(); i++) { double score = -( (BinaryScoreClassifier)oneVsAlls[i]).getScore(data); if(score > maxScore) { maxIndx = i; maxScore =score; } } cr.setProb(maxIndx, 1); } else { for(int i = 0; i < predicting.getNumOfCategories(); i++) { CategoricalResults oneVsAllCR = oneVsAlls[i].classify(data); double tmp = oneVsAllCR.getProb(0); if(tmp > 0) cr.setProb(i, tmp); } cr.normalize(); } return cr; } @Override public void train(ClassificationDataSet dataSet, boolean parallel) { oneVsAlls = new Classifier[dataSet.getClassSize()]; predicting = dataSet.getPredicting(); List> categorized = new ArrayList>(); for(int i = 0; i < oneVsAlls.length; i++) { List tmp = dataSet.getSamples(i); ArrayList oneCat = new ArrayList(tmp.size()); oneCat.addAll(tmp); categorized.add(oneCat); } int numer = dataSet.getNumNumericalVars(); CategoricalData[] categories = dataSet.getCategories(); ParallelUtils.range(0, oneVsAlls.length, parallel && concurrentTraining).forEach( i -> { final ClassificationDataSet cds = new ClassificationDataSet(numer, categories, new CategoricalData(2)); for(DataPoint dp : categorized.get(i))//add the ones cds.addDataPoint(dp.getNumericalValues(), dp.getCategoricalValues(), 0); //Add all the 'others' for(int j = 0; j < categorized.size(); j++) if(j != i) for(DataPoint dp: categorized.get(j)) cds.addDataPoint(dp.getNumericalValues(), dp.getCategoricalValues(), 1); oneVsAlls[i] = baseClassifier.clone(); if(concurrentTraining)//we are training all models in parallel, so tell each model to do single-thread oneVsAlls[i].train(cds, false); else oneVsAlls[i].train(cds, parallel); }); } @Override public OneVSAll clone() { OneVSAll clone = new OneVSAll(baseClassifier.clone(), concurrentTraining); if(this.predicting != null) clone.predicting = this.predicting.clone(); if(this.oneVsAlls != null) { clone.oneVsAlls = new Classifier[this.oneVsAlls.length]; for(int i = 0; i < oneVsAlls.length; i++) if(this.oneVsAlls[i] != null) clone.oneVsAlls[i] = this.oneVsAlls[i].clone(); } return clone; } @Override public boolean supportsWeightedData() { return baseClassifier.supportsWeightedData(); } }

Ads help maintain this website.