/*
* 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 2 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, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/*
* LogisticBase.java
* Copyright (C) 2003 University of Waikato, Hamilton, New Zealand
*
*/
package weka.classifiers.trees.lmt;
import weka.classifiers.Classifier;
import weka.classifiers.AbstractClassifier;
import weka.classifiers.Evaluation;
import weka.classifiers.functions.SimpleLinearRegression;
import weka.core.Attribute;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.RevisionUtils;
import weka.core.Utils;
import weka.core.WeightedInstancesHandler;
/**
* Base/helper class for building logistic regression models with the LogitBoost algorithm.
* Used for building logistic model trees (weka.classifiers.trees.lmt.LMT)
* and standalone logistic regression (weka.classifiers.functions.SimpleLogistic).
*
<!-- options-start -->
* Valid options are: <p/>
*
* <pre> -D
* If set, classifier is run in debug mode and
* may output additional info to the console</pre>
*
<!-- options-end -->
*
* @author Niels Landwehr
* @author Marc Sumner
* @version $Revision: 5928 $
*/
public class LogisticBase
extends AbstractClassifier
implements WeightedInstancesHandler {
/** for serialization */
static final long serialVersionUID = 168765678097825064L;
/** Header-only version of the numeric version of the training data*/
protected Instances m_numericDataHeader;
/**
* Numeric version of the training data. Original class is replaced by a numeric pseudo-class.
*/
protected Instances m_numericData;
/** Training data */
protected Instances m_train;
/** Use cross-validation to determine best number of LogitBoost iterations ?*/
protected boolean m_useCrossValidation;
/**Use error on probabilities for stopping criterion of LogitBoost? */
protected boolean m_errorOnProbabilities;
/**Use fixed number of iterations for LogitBoost? (if negative, cross-validate number of iterations)*/
protected int m_fixedNumIterations;
/**Use heuristic to stop performing LogitBoost iterations earlier?
* If enabled, LogitBoost is stopped if the current (local) minimum of the error on a test set as
* a function of the number of iterations has not changed for m_heuristicStop iterations.
*/
protected int m_heuristicStop = 50;
/**The number of LogitBoost iterations performed.*/
protected int m_numRegressions = 0;
/**The maximum number of LogitBoost iterations*/
protected int m_maxIterations;
/**The number of different classes*/
protected int m_numClasses;
/**Array holding the simple regression functions fit by LogitBoost*/
protected SimpleLinearRegression[][] m_regressions;
/**Number of folds for cross-validating number of LogitBoost iterations*/
protected static int m_numFoldsBoosting = 5;
/**Threshold on the Z-value for LogitBoost*/
protected static final double Z_MAX = 3;
/** If true, the AIC is used to choose the best iteration*/
private boolean m_useAIC = false;
/** Effective number of parameters used for AIC / BIC automatic stopping */
protected double m_numParameters = 0;
/**Threshold for trimming weights. Instances with a weight lower than this (as a percentage
* of total weights) are not included in the regression fit.
**/
protected double m_weightTrimBeta = 0;
/**
* Constructor that creates LogisticBase object with standard options.
*/
public LogisticBase(){
m_fixedNumIterations = -1;
m_useCrossValidation = true;
m_errorOnProbabilities = false;
m_maxIterations = 500;
m_useAIC = false;
m_numParameters = 0;
}
/**
* Constructor to create LogisticBase object.
* @param numBoostingIterations fixed number of iterations for LogitBoost (if negative, use cross-validation or
* stopping criterion on the training data).
* @param useCrossValidation cross-validate number of LogitBoost iterations (if false, use stopping
* criterion on the training data).
* @param errorOnProbabilities if true, use error on probabilities
* instead of misclassification for stopping criterion of LogitBoost
*/
public LogisticBase(int numBoostingIterations, boolean useCrossValidation, boolean errorOnProbabilities){
m_fixedNumIterations = numBoostingIterations;
m_useCrossValidation = useCrossValidation;
m_errorOnProbabilities = errorOnProbabilities;
m_maxIterations = 500;
m_useAIC = false;
m_numParameters = 0;
}
/**
* Builds the logistic regression model usiing LogitBoost.
*
* @param data the training data
* @throws Exception if something goes wrong
*/
public void buildClassifier(Instances data) throws Exception {
m_train = new Instances(data);
m_numClasses = m_train.numClasses();
//init the array of simple regression functions
m_regressions = initRegressions();
m_numRegressions = 0;
//get numeric version of the training data (class variable replaced by numeric pseudo-class)
m_numericData = getNumericData(m_train);
//save header info
m_numericDataHeader = new Instances(m_numericData, 0);
if (m_fixedNumIterations > 0) {
//run LogitBoost for fixed number of iterations
performBoosting(m_fixedNumIterations);
} else if (m_useAIC) { // Marc had this after the test for m_useCrossValidation. Changed by Eibe.
//run LogitBoost using information criterion for stopping
performBoostingInfCriterion();
} else if (m_useCrossValidation) {
//cross-validate number of LogitBoost iterations
performBoostingCV();
} else {
//run LogitBoost with number of iterations that minimizes error on the training set
performBoosting();
}
//only keep the simple regression functions that correspond to the selected number of LogitBoost iterations
m_regressions = selectRegressions(m_regressions);
}
/**
* Runs LogitBoost, determining the best number of iterations by cross-validation.
*
* @throws Exception if something goes wrong
*/
protected void performBoostingCV() throws Exception{
//completed iteration keeps track of the number of iterations that have been
//performed in every fold (some might stop earlier than others).
//Best iteration is selected only from these.
int completedIterations = m_maxIterations;
Instances allData = new Instances(m_train);
allData.stratify(m_numFoldsBoosting);
double[] error = new double[m_maxIterations + 1];
for (int i = 0; i < m_numFoldsBoosting; i++) {
//split into training/test data in fold
Instances train = allData.trainCV(m_numFoldsBoosting,i);
Instances test = allData.testCV(m_numFoldsBoosting,i);
//initialize LogitBoost
m_numRegressions = 0;
m_regressions = initRegressions();
//run LogitBoost iterations
int iterations = performBoosting(train,test,error,completedIterations);
if (iterations < completedIterations) completedIterations = iterations;
}
//determine iteration with minimum error over the folds
int bestIteration = getBestIteration(error,completedIterations);
//rebuild model on all of the training data
m_numRegressions = 0;
performBoosting(bestIteration);
}
/**
* Runs LogitBoost, determining the best number of iterations by an information criterion (currently AIC).
*/
protected void performBoostingInfCriterion() throws Exception{
double criterion = 0.0;
double bestCriterion = Double.MAX_VALUE;
int bestIteration = 0;
int noMin = 0;
// Variable to keep track of criterion values (AIC)
double criterionValue = Double.MAX_VALUE;
// initialize Ys/Fs/ps
double[][] trainYs = getYs(m_train);
double[][] trainFs = getFs(m_numericData);
double[][] probs = getProbs(trainFs);
// Array with true/false if the attribute is included in the model or not
boolean[][] attributes = new boolean[m_numClasses][m_numericDataHeader.numAttributes()];
int iteration = 0;
while (iteration < m_maxIterations) {
//perform single LogitBoost iteration
boolean foundAttribute = performIteration(iteration, trainYs, trainFs, probs, m_numericData);
if (foundAttribute) {
iteration++;
m_numRegressions = iteration;
} else {
//could not fit simple linear regression: stop LogitBoost
break;
}
double numberOfAttributes = m_numParameters + iteration;
// Fill criterion array values
criterionValue = 2.0 * negativeLogLikelihood(trainYs, probs) +
2.0 * numberOfAttributes;
//heuristic: stop LogitBoost if the current minimum has not changed for <m_heuristicStop> iterations
if (noMin > m_heuristicStop) break;
if (criterionValue < bestCriterion) {
bestCriterion = criterionValue;
bestIteration = iteration;
noMin = 0;
} else {
noMin++;
}
}
m_numRegressions = 0;
performBoosting(bestIteration);
}
/**
* Runs LogitBoost on a training set and monitors the error on a test set.
* Used for running one fold when cross-validating the number of LogitBoost iterations.
* @param train the training set
* @param test the test set
* @param error array to hold the logged error values
* @param maxIterations the maximum number of LogitBoost iterations to run
* @return the number of completed LogitBoost iterations (can be smaller than maxIterations
* if the heuristic for early stopping is active or there is a problem while fitting the regressions
* in LogitBoost).
* @throws Exception if something goes wrong
*/
protected int performBoosting(Instances train, Instances test,
double[] error, int maxIterations) throws Exception{
//get numeric version of the (sub)set of training instances
Instances numericTrain = getNumericData(train);
//initialize Ys/Fs/ps
double[][] trainYs = getYs(train);
double[][] trainFs = getFs(numericTrain);
double[][] probs = getProbs(trainFs);
int iteration = 0;
int noMin = 0;
double lastMin = Double.MAX_VALUE;
if (m_errorOnProbabilities) error[0] += getMeanAbsoluteError(test);
else error[0] += getErrorRate(test);
while (iteration < maxIterations) {
//perform single LogitBoost iteration
boolean foundAttribute = performIteration(iteration, trainYs, trainFs, probs, numericTrain);
if (foundAttribute) {
iteration++;
m_numRegressions = iteration;
} else {
//could not fit simple linear regression: stop LogitBoost
break;
}
if (m_errorOnProbabilities) error[iteration] += getMeanAbsoluteError(test);
else error[iteration] += getErrorRate(test);
//heuristic: stop LogitBoost if the current minimum has not changed for <m_heuristicStop> iterations
if (noMin > m_heuristicStop) break;
if (error[iteration] < lastMin) {
lastMin = error[iteration];
noMin = 0;
} else {
noMin++;
}
}
return iteration;
}
/**
* Runs LogitBoost with a fixed number of iterations.
* @param numIterations the number of iterations to run
* @throws Exception if something goes wrong
*/
protected void performBoosting(int numIterations) throws Exception{
//initialize Ys/Fs/ps
double[][] trainYs = getYs(m_train);
double[][] trainFs = getFs(m_numericData);
double[][] probs = getProbs(trainFs);
int iteration = 0;
//run iterations
while (iteration < numIterations) {
boolean foundAttribute = performIteration(iteration, trainYs, trainFs, probs, m_numericData);
if (foundAttribute) iteration++;
else break;
}
m_numRegressions = iteration;
}
/**
* Runs LogitBoost using the stopping criterion on the training set.
* The number of iterations is used that gives the lowest error on the training set, either misclassification
* or error on probabilities (depending on the errorOnProbabilities option).
* @throws Exception if something goes wrong
*/
protected void performBoosting() throws Exception{
//initialize Ys/Fs/ps
double[][] trainYs = getYs(m_train);
double[][] trainFs = getFs(m_numericData);
double[][] probs = getProbs(trainFs);
int iteration = 0;
double[] trainErrors = new double[m_maxIterations+1];
trainErrors[0] = getErrorRate(m_train);
int noMin = 0;
double lastMin = Double.MAX_VALUE;
while (iteration < m_maxIterations) {
boolean foundAttribute = performIteration(iteration, trainYs, trainFs, probs, m_numericData);
if (foundAttribute) {
iteration++;
m_numRegressions = iteration;
} else {
//could not fit simple regression
break;
}
trainErrors[iteration] = getErrorRate(m_train);
//heuristic: stop LogitBoost if the current minimum has not changed for <m_heuristicStop> iterations
if (noMin > m_heuristicStop) break;
if (trainErrors[iteration] < lastMin) {
lastMin = trainErrors[iteration];
noMin = 0;
} else {
noMin++;
}
}
//find iteration with best error
m_numRegressions = getBestIteration(trainErrors, iteration);
}
/**
* Returns the misclassification error of the current model on a set of instances.
* @param data the set of instances
* @return the error rate
* @throws Exception if something goes wrong
*/
protected double getErrorRate(Instances data) throws Exception {
Evaluation eval = new Evaluation(data);
eval.evaluateModel(this,data);
return eval.errorRate();
}
/**
* Returns the error of the probability estimates for the current model on a set of instances.
* @param data the set of instances
* @return the error
* @throws Exception if something goes wrong
*/
protected double getMeanAbsoluteError(Instances data) throws Exception {
Evaluation eval = new Evaluation(data);
eval.evaluateModel(this,data);
return eval.meanAbsoluteError();
}
/**
* Helper function to find the minimum in an array of error values.
*
* @param errors an array containing errors
* @param maxIteration the maximum of iterations
* @return the minimum
*/
protected int getBestIteration(double[] errors, int maxIteration) {
double bestError = errors[0];
int bestIteration = 0;
for (int i = 1; i <= maxIteration; i++) {
if (errors[i] < bestError) {
bestError = errors[i];
bestIteration = i;
}
}
return bestIteration;
}
/**
* Performs a single iteration of LogitBoost, and updates the model accordingly.
* A simple regression function is fit to the response and added to the m_regressions array.
* @param iteration the current iteration
* @param trainYs the y-values (see description of LogitBoost) for the model trained so far
* @param trainFs the F-values (see description of LogitBoost) for the model trained so far
* @param probs the p-values (see description of LogitBoost) for the model trained so far
* @param trainNumeric numeric version of the training data
* @return returns true if iteration performed successfully, false if no simple regression function
* could be fitted.
* @throws Exception if something goes wrong
*/
protected boolean performIteration(int iteration,
double[][] trainYs,
double[][] trainFs,
double[][] probs,
Instances trainNumeric) throws Exception {
for (int j = 0; j < m_numClasses; j++) {
// Keep track of sum of weights
double[] weights = new double[trainNumeric.numInstances()];
double weightSum = 0.0;
//make copy of data (need to save the weights)
Instances boostData = new Instances(trainNumeric);
for (int i = 0; i < trainNumeric.numInstances(); i++) {
//compute response and weight
double p = probs[i][j];
double actual = trainYs[i][j];
double z = getZ(actual, p);
double w = (actual - p) / z;
//set values for instance
Instance current = boostData.instance(i);
current.setValue(boostData.classIndex(), z);
current.setWeight(current.weight() * w);
weights[i] = current.weight();
weightSum += current.weight();
}
Instances instancesCopy = new Instances(boostData);
if (weightSum > 0) {
// Only the (1-beta)th quantile of instances are sent to the base classifier
if (m_weightTrimBeta > 0) {
double weightPercentage = 0.0;
int[] weightsOrder = new int[trainNumeric.numInstances()];
weightsOrder = Utils.sort(weights);
instancesCopy.delete();
for (int i = weightsOrder.length-1; (i >= 0) && (weightPercentage < (1-m_weightTrimBeta)); i--) {
instancesCopy.add(boostData.instance(weightsOrder[i]));
weightPercentage += (weights[weightsOrder[i]] / weightSum);
}
}
//Scale the weights
weightSum = instancesCopy.sumOfWeights();
for (int i = 0; i < instancesCopy.numInstances(); i++) {
Instance current = instancesCopy.instance(i);
current.setWeight(current.weight() * (double)instancesCopy.numInstances() / weightSum);
}
}
//fit simple regression function
m_regressions[j][iteration].buildClassifier(instancesCopy);
boolean foundAttribute = m_regressions[j][iteration].foundUsefulAttribute();
if (!foundAttribute) {
//could not fit simple regression function
return false;
}
}
// Evaluate / increment trainFs from the classifier
for (int i = 0; i < trainFs.length; i++) {
double [] pred = new double [m_numClasses];
double predSum = 0;
for (int j = 0; j < m_numClasses; j++) {
pred[j] = m_regressions[j][iteration]
.classifyInstance(trainNumeric.instance(i));
predSum += pred[j];
}
predSum /= m_numClasses;
for (int j = 0; j < m_numClasses; j++) {
trainFs[i][j] += (pred[j] - predSum) * (m_numClasses - 1)
/ m_numClasses;
}
}
// Compute the current probability estimates
for (int i = 0; i < trainYs.length; i++) {
probs[i] = probs(trainFs[i]);
}
return true;
}
/**
* Helper function to initialize m_regressions.
*
* @return the generated classifiers
*/
protected SimpleLinearRegression[][] initRegressions(){
SimpleLinearRegression[][] classifiers =
new SimpleLinearRegression[m_numClasses][m_maxIterations];
for (int j = 0; j < m_numClasses; j++) {
for (int i = 0; i < m_maxIterations; i++) {
classifiers[j][i] = new SimpleLinearRegression();
classifiers[j][i].setSuppressErrorMessage(true);
}
}
return classifiers;
}
/**
* Converts training data to numeric version. The class variable is replaced by a pseudo-class
* used by LogitBoost.
*
* @param data the data to convert
* @return the converted data
* @throws Exception if something goes wrong
*/
protected Instances getNumericData(Instances data) throws Exception{
Instances numericData = new Instances(data);
int classIndex = numericData.classIndex();
numericData.setClassIndex(-1);
numericData.deleteAttributeAt(classIndex);
numericData.insertAttributeAt(new Attribute("'pseudo class'"), classIndex);
numericData.setClassIndex(classIndex);
return numericData;
}
/**
* Helper function for cutting back m_regressions to the set of classifiers
* (corresponsing to the number of LogitBoost iterations) that gave the
* smallest error.
*
* @param classifiers the original set of classifiers
* @return the cut back set of classifiers
*/
protected SimpleLinearRegression[][] selectRegressions(SimpleLinearRegression[][] classifiers){
SimpleLinearRegression[][] goodClassifiers =
new SimpleLinearRegression[m_numClasses][m_numRegressions];
for (int j = 0; j < m_numClasses; j++) {
for (int i = 0; i < m_numRegressions; i++) {
goodClassifiers[j][i] = classifiers[j][i];
}
}
return goodClassifiers;
}
/**
* Computes the LogitBoost response variable from y/p values
* (actual/estimated class probabilities).
*
* @param actual the actual class probability
* @param p the estimated class probability
* @return the LogitBoost response
*/
protected double getZ(double actual, double p) {
double z;
if (actual == 1) {
z = 1.0 / p;
if (z > Z_MAX) { // threshold
z = Z_MAX;
}
} else {
z = -1.0 / (1.0 - p);
if (z < -Z_MAX) { // threshold
z = -Z_MAX;
}
}
return z;
}
/**
* Computes the LogitBoost response for an array of y/p values
* (actual/estimated class probabilities).
*
* @param dataYs the actual class probabilities
* @param probs the estimated class probabilities
* @return the LogitBoost response
*/
protected double[][] getZs(double[][] probs, double[][] dataYs) {
double[][] dataZs = new double[probs.length][m_numClasses];
for (int j = 0; j < m_numClasses; j++)
for (int i = 0; i < probs.length; i++) dataZs[i][j] = getZ(dataYs[i][j], probs[i][j]);
return dataZs;
}
/**
* Computes the LogitBoost weights from an array of y/p values
* (actual/estimated class probabilities).
*
* @param dataYs the actual class probabilities
* @param probs the estimated class probabilities
* @return the LogitBoost weights
*/
protected double[][] getWs(double[][] probs, double[][] dataYs) {
double[][] dataWs = new double[probs.length][m_numClasses];
for (int j = 0; j < m_numClasses; j++)
for (int i = 0; i < probs.length; i++){
double z = getZ(dataYs[i][j], probs[i][j]);
dataWs[i][j] = (dataYs[i][j] - probs[i][j]) / z;
}
return dataWs;
}
/**
* Computes the p-values (probabilities for the classes) from the F-values
* of the logistic model.
*
* @param Fs the F-values
* @return the p-values
*/
protected double[] probs(double[] Fs) {
double maxF = -Double.MAX_VALUE;
for (int i = 0; i < Fs.length; i++) {
if (Fs[i] > maxF) {
maxF = Fs[i];
}
}
double sum = 0;
double[] probs = new double[Fs.length];
for (int i = 0; i < Fs.length; i++) {
probs[i] = Math.exp(Fs[i] - maxF);
sum += probs[i];
}
Utils.normalize(probs, sum);
return probs;
}
/**
* Computes the Y-values (actual class probabilities) for a set of instances.
*
* @param data the data to compute the Y-values from
* @return the Y-values
*/
protected double[][] getYs(Instances data){
double [][] dataYs = new double [data.numInstances()][m_numClasses];
for (int j = 0; j < m_numClasses; j++) {
for (int k = 0; k < data.numInstances(); k++) {
dataYs[k][j] = (data.instance(k).classValue() == j) ?
1.0: 0.0;
}
}
return dataYs;
}
/**
* Computes the F-values for a single instance.
*
* @param instance the instance to compute the F-values for
* @return the F-values
* @throws Exception if something goes wrong
*/
protected double[] getFs(Instance instance) throws Exception{
double [] pred = new double [m_numClasses];
double [] instanceFs = new double [m_numClasses];
//add up the predictions from the simple regression functions
for (int i = 0; i < m_numRegressions; i++) {
double predSum = 0;
for (int j = 0; j < m_numClasses; j++) {
pred[j] = m_regressions[j][i].classifyInstance(instance);
predSum += pred[j];
}
predSum /= m_numClasses;
for (int j = 0; j < m_numClasses; j++) {
instanceFs[j] += (pred[j] - predSum) * (m_numClasses - 1)
/ m_numClasses;
}
}
return instanceFs;
}
/**
* Computes the F-values for a set of instances.
*
* @param data the data to work on
* @return the F-values
* @throws Exception if something goes wrong
*/
protected double[][] getFs(Instances data) throws Exception{
double[][] dataFs = new double[data.numInstances()][];
for (int k = 0; k < data.numInstances(); k++) {
dataFs[k] = getFs(data.instance(k));
}
return dataFs;
}
/**
* Computes the p-values (probabilities for the different classes) from
* the F-values for a set of instances.
*
* @param dataFs the F-values
* @return the p-values
*/
protected double[][] getProbs(double[][] dataFs){
int numInstances = dataFs.length;
double[][] probs = new double[numInstances][];
for (int k = 0; k < numInstances; k++) {
probs[k] = probs(dataFs[k]);
}
return probs;
}
/**
* Returns the negative loglikelihood of the Y-values (actual class probabilities) given the
* p-values (current probability estimates).
*
* @param dataYs the Y-values
* @param probs the p-values
* @return the likelihood
*/
protected double negativeLogLikelihood(double[][] dataYs, double[][] probs) {
double logLikelihood = 0;
for (int i = 0; i < dataYs.length; i++) {
for (int j = 0; j < m_numClasses; j++) {
if (dataYs[i][j] == 1.0) {
logLikelihood -= Math.log(probs[i][j]);
}
}
}
return logLikelihood;// / (double)dataYs.length;
}
/**
* Returns an array of the indices of the attributes used in the logistic model.
* The first dimension is the class, the second dimension holds a list of attribute indices.
* Attribute indices start at zero.
* @return the array of attribute indices
*/
public int[][] getUsedAttributes(){
int[][] usedAttributes = new int[m_numClasses][];
//first extract coefficients
double[][] coefficients = getCoefficients();
for (int j = 0; j < m_numClasses; j++){
//boolean array indicating if attribute used
boolean[] attributes = new boolean[m_numericDataHeader.numAttributes()];
for (int i = 0; i < attributes.length; i++) {
//attribute used if coefficient > 0
if (!Utils.eq(coefficients[j][i + 1],0)) attributes[i] = true;
}
int numAttributes = 0;
for (int i = 0; i < m_numericDataHeader.numAttributes(); i++) if (attributes[i]) numAttributes++;
//"collect" all attributes into array of indices
int[] usedAttributesClass = new int[numAttributes];
int count = 0;
for (int i = 0; i < m_numericDataHeader.numAttributes(); i++) {
if (attributes[i]) {
usedAttributesClass[count] = i;
count++;
}
}
usedAttributes[j] = usedAttributesClass;
}
return usedAttributes;
}
/**
* The number of LogitBoost iterations performed (= the number of simple
* regression functions fit).
*
* @return the number of LogitBoost iterations performed
*/
public int getNumRegressions() {
return m_numRegressions;
}
/**
* Get the value of weightTrimBeta.
*
* @return Value of weightTrimBeta.
*/
public double getWeightTrimBeta(){
return m_weightTrimBeta;
}
/**
* Get the value of useAIC.
*
* @return Value of useAIC.
*/
public boolean getUseAIC(){
return m_useAIC;
}
/**
* Sets the parameter "maxIterations".
*
* @param maxIterations the maximum iterations
*/
public void setMaxIterations(int maxIterations) {
m_maxIterations = maxIterations;
}
/**
* Sets the option "heuristicStop".
*
* @param heuristicStop the heuristic stop to use
*/
public void setHeuristicStop(int heuristicStop){
m_heuristicStop = heuristicStop;
}
/**
* Sets the option "weightTrimBeta".
*/
public void setWeightTrimBeta(double w){
m_weightTrimBeta = w;
}
/**
* Set the value of useAIC.
*
* @param c Value to assign to useAIC.
*/
public void setUseAIC(boolean c){
m_useAIC = c;
}
/**
* Returns the maxIterations parameter.
*
* @return the maximum iteration
*/
public int getMaxIterations(){
return m_maxIterations;
}
/**
* Returns an array holding the coefficients of the logistic model.
* First dimension is the class, the second one holds a list of coefficients.
* At position zero, the constant term of the model is stored, then, the coefficients for
* the attributes in ascending order.
* @return the array of coefficients
*/
protected double[][] getCoefficients(){
double[][] coefficients = new double[m_numClasses][m_numericDataHeader.numAttributes() + 1];
for (int j = 0; j < m_numClasses; j++) {
//go through simple regression functions and add their coefficient to the coefficient of
//the attribute they are built on.
for (int i = 0; i < m_numRegressions; i++) {
double slope = m_regressions[j][i].getSlope();
double intercept = m_regressions[j][i].getIntercept();
int attribute = m_regressions[j][i].getAttributeIndex();
coefficients[j][0] += intercept;
coefficients[j][attribute + 1] += slope;
}
}
// Need to multiply all coefficients by (J-1) / J
for (int j = 0; j < coefficients.length; j++) {
for (int i = 0; i < coefficients[0].length; i++) {
coefficients[j][i] *= (double)(m_numClasses - 1) / (double)m_numClasses;
}
}
return coefficients;
}
/**
* Returns the fraction of all attributes in the data that are used in the
* logistic model (in percent).
* An attribute is used in the model if it is used in any of the models for
* the different classes.
*
* @return the fraction of all attributes that are used
*/
public double percentAttributesUsed(){
boolean[] attributes = new boolean[m_numericDataHeader.numAttributes()];
double[][] coefficients = getCoefficients();
for (int j = 0; j < m_numClasses; j++){
for (int i = 1; i < m_numericDataHeader.numAttributes() + 1; i++) {
//attribute used if it is used in any class, note coefficients are shifted by one (because
//of constant term).
if (!Utils.eq(coefficients[j][i],0)) attributes[i - 1] = true;
}
}
//count number of used attributes (without the class attribute)
double count = 0;
for (int i = 0; i < attributes.length; i++) if (attributes[i]) count++;
return count / (double)(m_numericDataHeader.numAttributes() - 1) * 100.0;
}
/**
* Returns a description of the logistic model (i.e., attributes and
* coefficients).
*
* @return the description of the model
*/
public String toString(){
StringBuffer s = new StringBuffer();
//get used attributes
int[][] attributes = getUsedAttributes();
//get coefficients
double[][] coefficients = getCoefficients();
for (int j = 0; j < m_numClasses; j++) {
s.append("\nClass "+j+" :\n");
//constant term
s.append(Utils.doubleToString(coefficients[j][0],4,2)+" + \n");
for (int i = 0; i < attributes[j].length; i++) {
//attribute/coefficient pairs
s.append("["+m_numericDataHeader.attribute(attributes[j][i]).name()+"]");
s.append(" * " + Utils.doubleToString(coefficients[j][attributes[j][i]+1],4,2));
if (i != attributes[j].length - 1) s.append(" +");
s.append("\n");
}
}
return new String(s);
}
/**
* Returns class probabilities for an instance.
*
* @param instance the instance to compute the distribution for
* @return the class probabilities
* @throws Exception if distribution can't be computed successfully
*/
public double[] distributionForInstance(Instance instance) throws Exception {
instance = (Instance)instance.copy();
//set to numeric pseudo-class
instance.setDataset(m_numericDataHeader);
//calculate probs via Fs
return probs(getFs(instance));
}
/**
* Cleanup in order to save memory.
*/
public void cleanup() {
//save just header info
m_train = new Instances(m_train,0);
m_numericData = null;
}
/**
* Returns the revision string.
*
* @return the revision
*/
public String getRevision() {
return RevisionUtils.extract("$Revision: 5928 $");
}
}