IGSSResult.java

/*
 *  RapidMiner
 *
 *  Copyright (C) 2001-2008 by Rapid-I and the contributors
 *
 *  Complete list of developers available at our web site:
 *
 *       http://rapid-i.com
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU Affero General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Affero General Public License for more details.
 *
 *  You should have received a copy of the GNU Affero General Public License
 *  along with this program.  If not, see http://www.gnu.org/licenses/.
 */
package com.rapidminer.operator.learner.igss;

import java.util.LinkedList;
import java.util.Iterator;

import com.rapidminer.example.Example;
import com.rapidminer.example.ExampleSet;
import com.rapidminer.operator.ResultObjectAdapter;
import com.rapidminer.operator.learner.igss.hypothesis.Hypothesis;
import com.rapidminer.tools.Tools;


/**
 * This class stores all results found by the IGSS algorithm. It contains method to calculate the prior probabilities and the diversity in the results of the predictions.
 * 
 * @author Dirk Dach
 * @version $Id: IGSSResult.java,v 1.4 2008/05/09 19:23:18 ingomierswa Exp $
 */
public class IGSSResult extends ResultObjectAdapter {

    private static final long serialVersionUID = -3021620651938759878L;

	/** The list of results. */
    private LinkedList<Result> results;

    /** The default probability of the positive class */
    private double[] priors;

    public IGSSResult(ExampleSet eSet) {
        this.priors = getPriors(eSet);
        results = new LinkedList<Result>();
    }

    /** Adds a result. */
    public void addResult(Result r) {
        this.results.addLast(r);
    }

    /** Returns a list of all stored results. */
    public LinkedList<Result> getResults() {
        return this.results;
    }

    /** Returns the default probability of the example set the object was constructed with. */
    public double[] getPriors() {
        return this.priors;
    }

    /** Returns the default probability of the given example set. */
    public static double[] getPriors(ExampleSet exampleSet) {
        Iterator<Example> reader = exampleSet.iterator();
        double totalWeight = 0.0d;
        double totalPositiveWeight = 0.0d;
        while (reader.hasNext()) {
            Example e = reader.next();
            totalWeight += e.getWeight();
            if ((int) e.getLabel() == Hypothesis.POSITIVE_CLASS) {
                totalPositiveWeight += e.getWeight();
            }
        }
        double[] result = new double[2];
        result[Hypothesis.POSITIVE_CLASS] = totalPositiveWeight / totalWeight;
        result[Hypothesis.NEGATIVE_CLASS] = 1.0d - result[Hypothesis.POSITIVE_CLASS];
        return result;
    }

    /** Calculates the diversity in the predictions of the results for the given example set. */
    public static double calculateDiversity(ExampleSet exampleSet, LinkedList theResults) {
        Iterator<Example> reader = exampleSet.iterator();
        int[][] predictionMatrix = new int[exampleSet.size()][2];
        for (int i = 0; reader.hasNext(); i++) { // all examples
            Example e = reader.next();
            Iterator it = theResults.iterator();
            while (it.hasNext()) { // all results
                Hypothesis hypo = ((Result) it.next()).getHypothesis(); // get hypothesis
                if (hypo.applicable(e)) {
                    predictionMatrix[i][hypo.getPrediction()]++;
                } else {
                    predictionMatrix[i][1 - hypo.getPrediction()]++;
                }
            }
        }
        double sum1 = 0.0d;
        for (int i = 0; i < predictionMatrix.length; i++) {
            if (predictionMatrix[i][0] != 0 && predictionMatrix[i][1] != 0) { // avoid Double.NaN for p0=0 or p1=0
                double p0 = (double) predictionMatrix[i][0] / (double) theResults.size();
                double p1 = (double) predictionMatrix[i][1] / (double) theResults.size();
                sum1 = sum1 + ((-1) * p0 * log2(p0)) + ((-1) * p1 * log2(p1));
            }
        }

        double result = sum1 / predictionMatrix.length;
        return result;
    }

    /** Returns a String-representation of the results in this object. */
    public String toString() {
        LinkedList<Result> includedResultsForDiversityCalculation = new LinkedList<Result>();
        StringBuffer result = new StringBuffer("(Rule, Utility)" + Tools.getLineSeparator());
        Iterator it = this.results.iterator();
        double cumulativeWeight = 0.0d;
        for (int i = 1; it.hasNext(); i++) {
            result.append(i + ") ");
            Result r = (Result) it.next();
            includedResultsForDiversityCalculation.addLast(r);
            cumulativeWeight = cumulativeWeight + r.getTotalWeight();
            result.append(r.getHypothesis().toString() + ", " + r.getUtility() + Tools.getLineSeparator());
        }
        result.append("total necessary example weight: " + cumulativeWeight + Tools.getLineSeparator());
        result.append("a priori probability: " + this.priors[Hypothesis.POSITIVE_CLASS] + Tools.getLineSeparator());
        return result.toString();
    }

    /** Returns the logarithm to base 2. */
    public static double log2(double arg) {
        return Math.log(arg) / Math.log(2);
    }
    
    public String getExtension() { return "gss"; }
    
    public String getFileDescription() { return "IGSS results"; }
    
}