package jsat.classifiers.calibration;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import jsat.classifiers.CategoricalResults;
import jsat.classifiers.DataPoint;

/**
 * Isotonic Calibration is non-parametric, and only assumes that the underlying 
 * distribution from negative to positive examples is strictly a non-decreasing 
 * function. It will then attempt to model the distribution. This may over-fit 
 * for small data sizes, and imposes an additional O(log n) search look 
 * up when performing classification, where n is <= the number of data points
 * in the data set. 
 * 

* Isotonic Calibration inherently creates non-adjacent bins of varying size. * Smooth transitions in output probability are created by simple linear * interpolation between bin values. *

* See: Niculescu-Mizil, A.,&Caruana, R. (2005). Predicting Good * Probabilities with Supervised Learning. International Conference on * Machine Learning (pp. 625–632). Retrieved from * here * * @author Edward Raff */ public class IsotonicCalibration extends BinaryCalibration { private static final long serialVersionUID = -1295979238755262335L; private double[] outputs; private double[] scores; /** * Creates a new Isotonic Calibration object * @param base the base model to calibrate the outputs of * @param mode the calibration mode to use */ public IsotonicCalibration(BinaryScoreClassifier base, CalibrationMode mode) { super(base, mode); } /** * Copy constructor * @param toCopy the object to copy */ protected IsotonicCalibration(IsotonicCalibration toCopy) { super(toCopy.base.clone(), toCopy.mode); if (toCopy.outputs != null) this.outputs = Arrays.copyOf(toCopy.outputs, toCopy.outputs.length); if (toCopy.scores != null) this.scores = Arrays.copyOf(toCopy.scores, toCopy.scores.length); } private static class Point implements Comparable { public double weight; public double score; public double output; public double min, max; public Point(double score, double output) { this.weight = 1; min = max = this.score = score; this.output = output; } public void merge(Point next) { double newWeight = this.weight +next.weight; this.score = (this.weight*this.score + next.weight*next.score)/newWeight; this.output = (this.weight*this.output + next.weight*next.output)/newWeight; this.weight = newWeight; this.min = Math.min(this.min, next.min); this.max = Math.max(this.max, next.max); } public boolean nextViolates(Point next) { return this.output >= next.output; } @Override public int compareTo(Point o) { return Double.compare(score, o.score); } } @Override protected void calibrate(boolean[] label, double[] deci, int len) { List points = new ArrayList(len); for(int i = 0; i < len; i++) points.add(new Point(deci[i], label[i] ? 1 : 0)); Collections.sort(points); boolean violators = true; while(violators) { violators = false; for(int i = 0; i < points.size()-1; i++) { if(points.get(i).nextViolates(points.get(i+1))) { violators = true; points.get(i).merge(points.remove(i+1)); i--; } } } scores = new double[points.size()*2]; outputs = new double[points.size()*2]; int pos = 0; for(Point p : points) { scores[pos] = p.min; outputs[pos++] = p.output; scores[pos] = p.max; outputs[pos++] = p.output; } } @Override public IsotonicCalibration clone() { return new IsotonicCalibration(this); } @Override public CategoricalResults classify(DataPoint data) { double score = base.getScore(data); CategoricalResults cr = new CategoricalResults(2); int indx = Arrays.binarySearch(scores, score); if(indx < 0) indx = (-(indx) - 1); if(indx == scores.length) { double maxScore = scores[scores.length-1]; if(score > maxScore*3) cr.setProb(1, 1.0); else { double p = (maxScore*3-score)/(maxScore*2)*outputs[scores.length-1]; cr.setProb(0, 1-p); cr.setProb(1, p); } } else if(indx == 0) { double minScore = scores[0]; if(score < minScore/3) cr.setProb(0, 1.0); else { double p = (minScore-score)/(minScore-minScore/3)*outputs[0]; cr.setProb(0, 1-p); cr.setProb(1, p); } } else { double score0 = scores[indx-1]; double score1 = scores[indx]; if(score0 == score1) { cr.setProb(0, 1-outputs[indx]); cr.setProb(1, outputs[indx]); return cr; } double weight = (score1-score)/(score1-score0); double p = outputs[indx-1]*weight + outputs[indx]*(1-weight); cr.setProb(0, 1-p); cr.setProb(1, p); } return cr; } @Override public boolean supportsWeightedData() { return base.supportsWeightedData(); } }

Ads help maintain this website.