/*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* NominalPrediction.java
* Copyright (C) 2002-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.classifiers.evaluation;
import java.io.Serializable;
import weka.core.RevisionHandler;
import weka.core.RevisionUtils;
/**
* Encapsulates an evaluatable nominal prediction: the predicted probability
* distribution plus the actual class value.
*
* @author Len Trigg (len@reeltwo.com)
* @version $Revision: 8034 $
*/
public class NominalPrediction
implements Prediction, Serializable, RevisionHandler {
/**
* Remove this if you change this class so that serialization would be
* affected.
*/
static final long serialVersionUID = -8871333992740492788L;
/** The predicted probabilities */
private double [] m_Distribution;
/** The actual class value */
private double m_Actual = MISSING_VALUE;
/** The predicted class value */
private double m_Predicted = MISSING_VALUE;
/** The weight assigned to this prediction */
private double m_Weight = 1;
/**
* Creates the NominalPrediction object with a default weight of 1.0.
*
* @param actual the actual value, or MISSING_VALUE.
* @param distribution the predicted probability distribution. Use
* NominalPrediction.makeDistribution() if you only know the predicted value.
*/
public NominalPrediction(double actual, double [] distribution) {
this(actual, distribution, 1);
}
/**
* Creates the NominalPrediction object.
*
* @param actual the actual value, or MISSING_VALUE.
* @param distribution the predicted probability distribution. Use
* NominalPrediction.makeDistribution() if you only know the predicted value.
* @param weight the weight assigned to the prediction.
*/
public NominalPrediction(double actual, double [] distribution,
double weight) {
if (distribution == null) {
throw new NullPointerException("Null distribution in NominalPrediction.");
}
m_Actual = actual;
m_Distribution = distribution.clone();
m_Weight = weight;
updatePredicted();
}
/**
* Gets the predicted probabilities
*
* @return the predicted probabilities
*/
public double [] distribution() {
return m_Distribution;
}
/**
* Gets the actual class value.
*
* @return the actual class value, or MISSING_VALUE if no
* prediction was made.
*/
public double actual() {
return m_Actual;
}
/**
* Gets the predicted class value.
*
* @return the predicted class value, or MISSING_VALUE if no
* prediction was made.
*/
public double predicted() {
return m_Predicted;
}
/**
* Gets the weight assigned to this prediction. This is typically the weight
* of the test instance the prediction was made for.
*
* @return the weight assigned to this prediction.
*/
public double weight() {
return m_Weight;
}
/**
* Calculates the prediction margin. This is defined as the difference
* between the probability predicted for the actual class and the highest
* predicted probability of the other classes.
*
* @return the margin for this prediction, or
* MISSING_VALUE if either the actual or predicted value
* is missing.
*/
public double margin() {
if ((m_Actual == MISSING_VALUE) ||
(m_Predicted == MISSING_VALUE)) {
return MISSING_VALUE;
}
double probActual = m_Distribution[(int)m_Actual];
double probNext = 0;
for(int i = 0; i < m_Distribution.length; i++)
if ((i != m_Actual) &&
(m_Distribution[i] > probNext))
probNext = m_Distribution[i];
return probActual - probNext;
}
/**
* Convert a single prediction into a probability distribution
* with all zero probabilities except the predicted value which
* has probability 1.0. If no prediction was made, all probabilities
* are zero.
*
* @param predictedClass the index of the predicted class, or
* MISSING_VALUE if no prediction was made.
* @param numClasses the number of possible classes for this nominal
* prediction.
* @return the probability distribution.
*/
public static double [] makeDistribution(double predictedClass,
int numClasses) {
double [] dist = new double [numClasses];
if (predictedClass == MISSING_VALUE) {
return dist;
}
dist[(int)predictedClass] = 1.0;
return dist;
}
/**
* Creates a uniform probability distribution -- where each of the
* possible classes is assigned equal probability.
*
* @param numClasses the number of possible classes for this nominal
* prediction.
* @return the probability distribution.
*/
public static double [] makeUniformDistribution(int numClasses) {
double [] dist = new double [numClasses];
for (int i = 0; i < numClasses; i++) {
dist[i] = 1.0 / numClasses;
}
return dist;
}
/**
* Determines the predicted class (doesn't detect multiple
* classifications). If no prediction was made (i.e. all zero
* probababilities in the distribution), m_Prediction is set to
* MISSING_VALUE.
*/
private void updatePredicted() {
int predictedClass = -1;
double bestProb = 0.0;
for(int i = 0; i < m_Distribution.length; i++) {
if (m_Distribution[i] > bestProb) {
predictedClass = i;
bestProb = m_Distribution[i];
}
}
if (predictedClass != -1) {
m_Predicted = predictedClass;
} else {
m_Predicted = MISSING_VALUE;
}
}
/**
* Gets a human readable representation of this prediction.
*
* @return a human readable representation of this prediction.
*/
public String toString() {
StringBuffer sb = new StringBuffer();
sb.append("NOM: ").append(actual()).append(" ").append(predicted());
sb.append(' ').append(weight());
double [] dist = distribution();
for (int i = 0; i < dist.length; i++) {
sb.append(' ').append(dist[i]);
}
return sb.toString();
}
/**
* Returns the revision string.
*
* @return the revision
*/
public String getRevision() {
return RevisionUtils.extract("$Revision: 8034 $");
}
}