org.bigml.binding.MultiVote Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of bigml-binding Show documentation
An open source Java client that gives you a simple binding to interact with BigML. You can use it to easily create, retrieve, list, update, and delete BigML resources.
There is a newer version: 2.1.1
Show newest version
package org.bigml.binding;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.bigml.binding.utils.Utils;
import org.json.simple.JSONArray;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * A multiple vote prediction
 *
 * Uses a number of predictions to generate a combined prediction.
 */
public class MultiVote implements Serializable {
    
	private static final long serialVersionUID = 1L;
	
    /**
     * Logging
     */
    static Logger LOGGER = LoggerFactory.getLogger(MultiVote.class.getName());
    
    public final static String[] PREDICTION_HEADERS = new String[] { 
    		"prediction", "confidence", "order", "distribution", "count" };
    
    private final static String[] COMBINATION_WEIGHTS = new String[] {
            null , "confidence", "probability", null, "weight" };
    
    
    private final static String[][] WEIGHT_KEYS = new String[][] { {},
            { "confidence" }, { "distribution", "count" }, {}, { "weight" } };
            
    private final static String[] WEIGHT_LABELS = new String[] { "plurality",
            "confidence", "probability", "threshold" };

    final static int BINS_LIMIT = 32;
    
    final static String BOOSTING_CLASS = "class";
    
    public HashMap[] predictions;
    public boolean boosting = false;
    public JSONArray boostingOffsets;
    
    
    /**
     * MultiVote: combiner class for ensembles voting predictions.
     */
    public MultiVote() {
        this(null, null);
    }
        
    /**
     * MultiVote: combiner class for ensembles voting predictions.
     *
     * @param predictionsArr {array|object} predictions Array of model's predictions
     * @param boostingOffsets
     */
    public MultiVote(HashMap[] predictionsArr, JSONArray boostingOffsets) {
        int i, len;
        if (predictionsArr == null) {
            predictionsArr = new HashMap[0];
        }
        predictions = predictionsArr;
        
        boosting = boostingOffsets != null && !boostingOffsets.isEmpty();
        this.boostingOffsets = boostingOffsets;
        
        boolean allOrdered = true;
        for (i = 0, len = predictions.length; i < len; i++) {
            if (!predictions[i].containsKey("order")) {
                allOrdered = false;
                break;
            }
        }
        if (!allOrdered) {
            for (i = 0, len = predictions.length; i < len; i++) {
                predictions[i].put("order", i);
            }
        }
    }
    
    public HashMap[] getPredictions() {
        return predictions;
    }
    
    /**
     * Check if this is a regression model
     *
     * @return {boolean} True if all the predictions are numbers.
     */
    private boolean isRegression() {
    	int index, len;
    	HashMap prediction;
    	
    	if (boosting) {
    		for (index = 0, len = this.predictions.length; index < len; index++) {
                prediction = this.predictions[index];
                if (prediction.get("class") == null) {
                    return true;
                }
    		}
    		return false;
    	}
    	
        for (index = 0, len = this.predictions.length; index < len; index++) {
            prediction = this.predictions[index];
            if (!(prediction.get("prediction") instanceof Number)) {
                return false;
            }
        }
        return true;
    };
    
    /**
     * Return the next order to be assigned to a prediction
     *
     * Predictions in MultiVote are ordered in arrival sequence when
     * added using the constructor or the append and extend methods.
     * This order is used to break even cases in combination
     * methods for classifications.
     *
     * @return the next order to be assigned to a prediction
     */
    private int nextOrder() {
        if( predictions != null && predictions.length > 0 ) {
            return ((Number) predictions[predictions.length - 1].get("order")).intValue() + 1;
        }

        return 0;
    }
    
    
    /**
     * Adds a new prediction into a list of predictions
     *
     * prediction_info should contain at least:
     *      - prediction: whose value is the predicted category or value
     *
     * for instance:
     *      {'prediction': 'Iris-virginica'}
     *
     * it may also contain the keys:
     *      - confidence: whose value is the confidence/error of the prediction
     *      - distribution: a list of [category/value, instances] pairs
     *                      describing the distribution at the prediction node
     *      - count: the total number of instances of the training set in the
     *                  node
     *
     * @param predictionInfo the prediction to be appended
     * @return the this instance
     */
    public MultiVote append(HashMap predictionInfo) {

        if( predictionInfo == null || predictionInfo.isEmpty() ||
                !predictionInfo.containsKey("prediction") ) {
            throw new IllegalArgumentException("Failed to add the prediction.\\n" +
                    "The minimal key for the prediction is 'prediction'" +
                    ":\n{'prediction': 'Iris-virginica'");
        }

        int order = nextOrder();
        predictionInfo.put("order", order);
        HashMap[] temp = predictions.clone();
        predictions = new HashMap[predictions.length + 1];
        System.arraycopy(temp, 0, predictions, 0, temp.length);
        predictions[order] = predictionInfo;

        return this;
    }
    
    /**
     * Adds a new prediction into a list of predictions
     *
     * predictionHeaders should contain the labels for the predictionRow
     *  values in the same order.
     *
     * predictionHeaders should contain at least the following string
     *      - 'prediction': whose associated value in predictionRow
     *                      is the predicted category or value
     *
     * for instance:
     *      predictionRow = ['Iris-virginica']
     *      predictionHeaders = ['prediction']
     *
     * it may also contain the following headers and values:
     *      - 'confidence': whose associated value in prediction_row
     *                      is the confidence/error of the prediction
     *      - 'distribution': a list of [category/value, instances] pairs
     *                      describing the distribution at the prediction node
     *      - 'count': the total number of instances of the training set in the
     *                      node
     *
     * @param predictionRow the list of predicted values and extra info
     * @param predictionHeaders the name of each value in the predictionRow
     * @return the this instance
     */
    public MultiVote appendRow(List