source: branches/MetisMQI/src/main/java/weka/classifiers/trees/lmt/LMTNode.java

/*
 *    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.
 */

/*
 *    LMTNode.java
 *    Copyright (C) 2003 University of Waikato, Hamilton, New Zealand
 *
 */

package weka.classifiers.trees.lmt;

import weka.classifiers.Evaluation;
import weka.classifiers.functions.SimpleLinearRegression;
import weka.classifiers.trees.j48.ClassifierSplitModel;
import weka.classifiers.trees.j48.ModelSelection;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.RevisionHandler;
import weka.core.RevisionUtils;
import weka.filters.Filter;
import weka.filters.supervised.attribute.NominalToBinary;

import java.util.Collections;
import java.util.Comparator;
import java.util.Vector;

/** 
 * Auxiliary class for list of LMTNodes
 */
class CompareNode 
    implements Comparator, RevisionHandler {

    /**
     * Compares its two arguments for order.
     * 
     * @param o1 first object
     * @param o2 second object
     * @return a negative integer, zero, or a positive integer as the first 
     *         argument is less than, equal to, or greater than the second.
     */
    public int compare(Object o1, Object o2) {          
        if ( ((LMTNode)o1).m_alpha < ((LMTNode)o2).m_alpha) return -1;
        if ( ((LMTNode)o1).m_alpha > ((LMTNode)o2).m_alpha) return 1;
        return 0;       
    }        
    
    /**
     * Returns the revision string.
     * 
     * @return          the revision
     */
    public String getRevision() {
      return RevisionUtils.extract("$Revision: 1.8 $");
    }
}

/**
 * Class for logistic model tree structure. 
 * 
 * 
 * @author Niels Landwehr 
 * @author Marc Sumner 
 * @version $Revision: 1.8 $
 */
public class LMTNode 
    extends LogisticBase {
  
    /** for serialization */
    static final long serialVersionUID = 1862737145870398755L;
    
    /** Total number of training instances. */
    protected double m_totalInstanceWeight;
    
    /** Node id*/
    protected int m_id;
    
    /** ID of logistic model at leaf*/
    protected int m_leafModelNum;
 
    /** Alpha-value (for pruning) at the node*/
    public double m_alpha;
    
    /** Weighted number of training examples currently misclassified by the logistic model at the node*/ 
    public double m_numIncorrectModel;

    /** Weighted number of training examples currently misclassified by the subtree rooted at the node*/
    public double m_numIncorrectTree;

    /**minimum number of instances at which a node is considered for splitting*/
    protected int m_minNumInstances;
    
    /**ModelSelection object (for splitting)*/
    protected ModelSelection m_modelSelection;     

    /**Filter to convert nominal attributes to binary*/
    protected NominalToBinary m_nominalToBinary;  
   
    /**Simple regression functions fit by LogitBoost at higher levels in the tree*/
    protected SimpleLinearRegression[][] m_higherRegressions;
    
    /**Number of simple regression functions fit by LogitBoost at higher levels in the tree*/
    protected int m_numHigherRegressions = 0;
    
    /**Number of folds for CART pruning*/
    protected static int m_numFoldsPruning = 5;

    /**Use heuristic that determines the number of LogitBoost iterations only once in the beginning? */
    protected boolean m_fastRegression;
    
    /**Number of instances at the node*/
    protected int m_numInstances;    

    /**The ClassifierSplitModel (for splitting)*/
    protected ClassifierSplitModel m_localModel; 
 
    /**Array of children of the node*/
    protected LMTNode[] m_sons;           

    /**True if node is leaf*/
    protected boolean m_isLeaf;                   

    /**
     * Constructor for logistic model tree node. 
     *
     * @param modelSelection selection method for local splitting model
     * @param numBoostingIterations sets the numBoostingIterations parameter
     * @param fastRegression sets the fastRegression parameter
     * @param errorOnProbabilities Use error on probabilities for stopping criterion of LogitBoost?
     * @param minNumInstances minimum number of instances at which a node is considered for splitting
     */
    public LMTNode(ModelSelection modelSelection, int numBoostingIterations, 
                   boolean fastRegression, 
                   boolean errorOnProbabilities, int minNumInstances,
                   double weightTrimBeta, boolean useAIC) {
        m_modelSelection = modelSelection;
        m_fixedNumIterations = numBoostingIterations;      
        m_fastRegression = fastRegression;
        m_errorOnProbabilities = errorOnProbabilities;
        m_minNumInstances = minNumInstances;
        m_maxIterations = 200;
        setWeightTrimBeta(weightTrimBeta);
        setUseAIC(useAIC);
    }         
    
    /**
     * Method for building a logistic model tree (only called for the root node).
     * Grows an initial logistic model tree and prunes it back using the CART pruning scheme.
     *
     * @param data the data to train with
     * @throws Exception if something goes wrong
     */
    public void buildClassifier(Instances data) throws Exception{
        
        //heuristic to avoid cross-validating the number of LogitBoost iterations
        //at every node: build standalone logistic model and take its optimum number
        //of iteration everywhere in the tree.
        if (m_fastRegression && (m_fixedNumIterations < 0)) m_fixedNumIterations = tryLogistic(data);
        
        //Need to cross-validate alpha-parameter for CART-pruning
        Instances cvData = new Instances(data);
        cvData.stratify(m_numFoldsPruning);
        
        double[][] alphas = new double[m_numFoldsPruning][];
        double[][] errors = new double[m_numFoldsPruning][];
        
        for (int i = 0; i < m_numFoldsPruning; i++) {
            //for every fold, grow tree on training set...
            Instances train = cvData.trainCV(m_numFoldsPruning, i);
            Instances test = cvData.testCV(m_numFoldsPruning, i);
            
            buildTree(train, null, train.numInstances() , 0);   
            
            int numNodes = getNumInnerNodes();     
            alphas[i] = new double[numNodes + 2];
            errors[i] = new double[numNodes + 2];
            
            //... then prune back and log alpha-values and errors on test set
            prune(alphas[i], errors[i], test);             
        }
        
        //build tree using all the data
        buildTree(data, null, data.numInstances(), 0);
        int numNodes = getNumInnerNodes();

        double[] treeAlphas = new double[numNodes + 2]; 
        
        //prune back and log alpha-values     
        int iterations = prune(treeAlphas, null, null);
        
        double[] treeErrors = new double[numNodes + 2];
        
        for (int i = 0; i <= iterations; i++){
            //compute midpoint alphas
            double alpha = Math.sqrt(treeAlphas[i] * treeAlphas[i+1]);
            double error = 0;
            
            //compute error estimate for final trees from the midpoint-alphas and the error estimates gotten in 
            //the cross-validation
            for (int k = 0; k < m_numFoldsPruning; k++) {
                int l = 0;
                while (alphas[k][l] <= alpha) l++;
                error += errors[k][l - 1];
            }

            treeErrors[i] = error;                         
        }
        
        //find best alpha 
        int best = -1;
        double bestError = Double.MAX_VALUE;
        for (int i = iterations; i >= 0; i--) {
            if (treeErrors[i] < bestError) {
                bestError = treeErrors[i];
                best = i;
            }       
        }

        double bestAlpha = Math.sqrt(treeAlphas[best] * treeAlphas[best + 1]);          
        
        //"unprune" final tree (faster than regrowing it)
        unprune();

        //CART-prune it with best alpha
        prune(bestAlpha);                       
        cleanup();      
    }

    /**
     * Method for building the tree structure.
     * Builds a logistic model, splits the node and recursively builds tree for child nodes.
     * @param data the training data passed on to this node
     * @param higherRegressions An array of regression functions produced by LogitBoost at higher 
     * levels in the tree. They represent a logistic regression model that is refined locally 
     * at this node.
     * @param totalInstanceWeight the total number of training examples
     * @param higherNumParameters effective number of parameters in the logistic regression model built
     * in parent nodes
     * @throws Exception if something goes wrong
     */
    public void buildTree(Instances data, SimpleLinearRegression[][] higherRegressions, 
                          double totalInstanceWeight, double higherNumParameters) throws Exception{

        //save some stuff
        m_totalInstanceWeight = totalInstanceWeight;
        m_train = new Instances(data);
        
        m_isLeaf = true;
        m_sons = null;
        
        m_numInstances = m_train.numInstances();
        m_numClasses = m_train.numClasses();                            
        
        //init 
        m_numericData = getNumericData(m_train);                  
        m_numericDataHeader = new Instances(m_numericData, 0);
        
        m_regressions = initRegressions();
        m_numRegressions = 0;
        
        if (higherRegressions != null) m_higherRegressions = higherRegressions;
        else m_higherRegressions = new SimpleLinearRegression[m_numClasses][0]; 

        m_numHigherRegressions = m_higherRegressions[0].length; 
        
        m_numParameters = higherNumParameters;
        
        //build logistic model
        if (m_numInstances >= m_numFoldsBoosting) {
            if (m_fixedNumIterations > 0){
                performBoosting(m_fixedNumIterations);
            } else if (getUseAIC()) {
                performBoostingInfCriterion();
            } else {
                performBoostingCV();
            }
        }
        
        m_numParameters += m_numRegressions;
        
        //only keep the simple regression functions that correspond to the selected number of LogitBoost iterations
        m_regressions = selectRegressions(m_regressions);

        boolean grow;
        //split node if more than minNumInstances...
        if (m_numInstances > m_minNumInstances) {
            //split node: either splitting on class value (a la C4.5) or splitting on residuals
            if (m_modelSelection instanceof ResidualModelSelection) {   
                //need ps/Ys/Zs/weights
                double[][] probs = getProbs(getFs(m_numericData));
                double[][] trainYs = getYs(m_train);
                double[][] dataZs = getZs(probs, trainYs);
                double[][] dataWs = getWs(probs, trainYs);
                m_localModel = ((ResidualModelSelection)m_modelSelection).selectModel(m_train, dataZs, dataWs); 
            } else {
                m_localModel = m_modelSelection.selectModel(m_train);   
            }
            //... and valid split found
            grow = (m_localModel.numSubsets() > 1);
        } else {
            grow = false;
        }
        
        if (grow) {     
            //create and build children of node
            m_isLeaf = false;               
            Instances[] localInstances = m_localModel.split(m_train);       
            m_sons = new LMTNode[m_localModel.numSubsets()];
            for (int i = 0; i < m_sons.length; i++) {
                m_sons[i] = new LMTNode(m_modelSelection, m_fixedNumIterations, 
                                         m_fastRegression,  
                                         m_errorOnProbabilities,m_minNumInstances,
                                        getWeightTrimBeta(), getUseAIC());
                //the "higherRegressions" (partial logistic model fit at higher levels in the tree) passed
                //on to the children are the "higherRegressions" at this node plus the regressions added
                //at this node (m_regressions).
                m_sons[i].buildTree(localInstances[i],
                                  mergeArrays(m_regressions, m_higherRegressions), m_totalInstanceWeight, m_numParameters);             
                localInstances[i] = null;
            }       
        } 
    }

    /** 
     * Prunes a logistic model tree using the CART pruning scheme, given a 
     * cost-complexity parameter alpha.
     * 
     * @param alpha the cost-complexity measure  
     * @throws Exception if something goes wrong
     */
    public void prune(double alpha) throws Exception {
        
        Vector nodeList;        
        CompareNode comparator = new CompareNode();     
        
        //determine training error of logistic models and subtrees, and calculate alpha-values from them
        modelErrors();
        treeErrors();
        calculateAlphas();
        
        //get list of all inner nodes in the tree
        nodeList = getNodes();
                
        boolean prune = (nodeList.size() > 0);
        
        while (prune) {
            
            //select node with minimum alpha
            LMTNode nodeToPrune = (LMTNode)Collections.min(nodeList,comparator);
            
            //want to prune if its alpha is smaller than alpha
            if (nodeToPrune.m_alpha > alpha) break; 
            
            nodeToPrune.m_isLeaf = true;
            nodeToPrune.m_sons = null;
            
            //update tree errors and alphas
            treeErrors();
            calculateAlphas();

            nodeList = getNodes();
            prune = (nodeList.size() > 0);        
        }  
    }

    /**
     * Method for performing one fold in the cross-validation of the cost-complexity parameter.
     * Generates a sequence of alpha-values with error estimates for the corresponding (partially pruned)
     * trees, given the test set of that fold.
     * @param alphas array to hold the generated alpha-values
     * @param errors array to hold the corresponding error estimates
     * @param test test set of that fold (to obtain error estimates)
     * @throws Exception if something goes wrong
     */
    public int prune(double[] alphas, double[] errors, Instances test) throws Exception {
        
        Vector nodeList; 
        
        CompareNode comparator = new CompareNode();     

        //determine training error of logistic models and subtrees, and calculate alpha-values from them
        modelErrors();
        treeErrors();
        calculateAlphas();

        //get list of all inner nodes in the tree
        nodeList = getNodes();
       
        boolean prune = (nodeList.size() > 0);                          

        //alpha_0 is always zero (unpruned tree)
        alphas[0] = 0;

        Evaluation eval;

        //error of unpruned tree
        if (errors != null) {
            eval = new Evaluation(test);
            eval.evaluateModel(this, test);
            errors[0] = eval.errorRate(); 
        }       
       
        int iteration = 0;
        while (prune) {

            iteration++;
            
            //get node with minimum alpha
            LMTNode nodeToPrune = (LMTNode)Collections.min(nodeList,comparator);

            nodeToPrune.m_isLeaf = true;
            //Do not set m_sons null, want to unprune
            
            //get alpha-value of node
            alphas[iteration] = nodeToPrune.m_alpha;
            
            //log error
            if (errors != null) {
                eval = new Evaluation(test);
                eval.evaluateModel(this, test);
                errors[iteration] = eval.errorRate(); 
            }

            //update errors/alphas
            treeErrors();
            calculateAlphas();

            nodeList = getNodes();         
            prune = (nodeList.size() > 0);         
        } 
        
        //set last alpha 1 to indicate end
        alphas[iteration + 1] = 1.0;    
        return iteration;
    }


    /**
     *Method to "unprune" a logistic model tree.
     *Sets all leaf-fields to false.
     *Faster than re-growing the tree because the logistic models do not have to be fit again. 
     */
    protected void unprune() {
        if (m_sons != null) {
            m_isLeaf = false;
            for (int i = 0; i < m_sons.length; i++) m_sons[i].unprune();
        }
    }

    /**
     *Determines the optimum number of LogitBoost iterations to perform by building a standalone logistic 
     *regression function on the training data. Used for the heuristic that avoids cross-validating this
     *number again at every node.
     *@param data training instances for the logistic model
     *@throws Exception if something goes wrong
     */
    protected int tryLogistic(Instances data) throws Exception{
        
        //convert nominal attributes
        Instances filteredData = new Instances(data);   
        NominalToBinary nominalToBinary = new NominalToBinary();                        
        nominalToBinary.setInputFormat(filteredData);
        filteredData = Filter.useFilter(filteredData, nominalToBinary); 
        
        LogisticBase logistic = new LogisticBase(0,true,m_errorOnProbabilities);
        
        //limit LogitBoost to 200 iterations (speed)
        logistic.setMaxIterations(200);
        logistic.setWeightTrimBeta(getWeightTrimBeta()); // Not in Marc's code. Added by Eibe.
        logistic.setUseAIC(getUseAIC());
        logistic.buildClassifier(filteredData);
        
        //return best number of iterations
        return logistic.getNumRegressions(); 
    }

    /**
     * Method to count the number of inner nodes in the tree
     * @return the number of inner nodes
     */
    public int getNumInnerNodes(){
        if (m_isLeaf) return 0;
        int numNodes = 1;
        for (int i = 0; i < m_sons.length; i++) numNodes += m_sons[i].getNumInnerNodes();
        return numNodes;
    }

    /**
     * Returns the number of leaves in the tree.
     * Leaves are only counted if their logistic model has changed compared to the one of the parent node.
     * @return the number of leaves
     */
     public int getNumLeaves(){
        int numLeaves;
        if (!m_isLeaf) {
            numLeaves = 0;
            int numEmptyLeaves = 0;
            for (int i = 0; i < m_sons.length; i++) {
                numLeaves += m_sons[i].getNumLeaves();
                if (m_sons[i].m_isLeaf && !m_sons[i].hasModels()) numEmptyLeaves++;
            }
            if (numEmptyLeaves > 1) {
                numLeaves -= (numEmptyLeaves - 1);
            }
        } else {
            numLeaves = 1;
        }          
        return numLeaves;       
    }

    /**
     *Updates the numIncorrectModel field for all nodes. This is needed for calculating the alpha-values. 
     */
    public void modelErrors() throws Exception{
                
        Evaluation eval = new Evaluation(m_train);
                
        if (!m_isLeaf) {
            m_isLeaf = true;
            eval.evaluateModel(this, m_train);
            m_isLeaf = false;
            m_numIncorrectModel = eval.incorrect();
            for (int i = 0; i < m_sons.length; i++) m_sons[i].modelErrors();
        } else {
            eval.evaluateModel(this, m_train);
            m_numIncorrectModel = eval.incorrect();
        }
    }
    
    /**
     *Updates the numIncorrectTree field for all nodes. This is needed for calculating the alpha-values. 
     */
    public void treeErrors(){
        if (m_isLeaf) {
            m_numIncorrectTree = m_numIncorrectModel;
        } else {
            m_numIncorrectTree = 0;
            for (int i = 0; i < m_sons.length; i++) {
                m_sons[i].treeErrors();
                m_numIncorrectTree += m_sons[i].m_numIncorrectTree;
            }    
        }       
    }

    /**
     *Updates the alpha field for all nodes.
     */
    public void calculateAlphas() throws Exception {            
                
        if (!m_isLeaf) {        
            double errorDiff = m_numIncorrectModel - m_numIncorrectTree;                    
            
            if (errorDiff <= 0) {
                //split increases training error (should not normally happen).
                //prune it instantly.
                m_isLeaf = true;
                m_sons = null;
                m_alpha = Double.MAX_VALUE;             
            } else {
                //compute alpha
                errorDiff /= m_totalInstanceWeight;             
                m_alpha = errorDiff / (double)(getNumLeaves() - 1);
                
                for (int i = 0; i < m_sons.length; i++) m_sons[i].calculateAlphas();
            }
        } else {            
            //alpha = infinite for leaves (do not want to prune)
            m_alpha = Double.MAX_VALUE;
        }
    }
    
    /**
     * Merges two arrays of regression functions into one
     * @param a1 one array
     * @param a2 the other array
     *
     * @return an array that contains all entries from both input arrays
     */
    protected SimpleLinearRegression[][] mergeArrays(SimpleLinearRegression[][] a1,     
                                                           SimpleLinearRegression[][] a2){
        int numModels1 = a1[0].length;
        int numModels2 = a2[0].length;          
        
        SimpleLinearRegression[][] result =
            new SimpleLinearRegression[m_numClasses][numModels1 + numModels2];
        
        for (int i = 0; i < m_numClasses; i++)
            for (int j = 0; j < numModels1; j++) {
                result[i][j]  = a1[i][j];
            }
        for (int i = 0; i < m_numClasses; i++)
            for (int j = 0; j < numModels2; j++) result[i][j+numModels1] = a2[i][j];
        return result;
    }

    /**
     * Return a list of all inner nodes in the tree
     * @return the list of nodes
     */
    public Vector getNodes(){
        Vector nodeList = new Vector();
        getNodes(nodeList);
        return nodeList;
    }

    /**
     * Fills a list with all inner nodes in the tree
     * 
     * @param nodeList the list to be filled
     */
    public void getNodes(Vector nodeList) {
        if (!m_isLeaf) {
            nodeList.add(this);
            for (int i = 0; i < m_sons.length; i++) m_sons[i].getNodes(nodeList);
        }       
    }
    
    /**
     * Returns a numeric version of a set of instances.
     * All nominal attributes are replaced by binary ones, and the class variable is replaced
     * by a pseudo-class variable that is used by LogitBoost.
     */
    protected Instances getNumericData(Instances train) throws Exception{
        
        Instances filteredData = new Instances(train);  
        m_nominalToBinary = new NominalToBinary();                      
        m_nominalToBinary.setInputFormat(filteredData);
        filteredData = Filter.useFilter(filteredData, m_nominalToBinary);       

        return super.getNumericData(filteredData);
    }

    /**
     * Computes the F-values of LogitBoost for an instance from the current logistic model at the node
     * Note that this also takes into account the (partial) logistic model fit at higher levels in 
     * the tree.
     * @param instance the instance
     * @return the array of F-values 
     */
    protected double[] getFs(Instance instance) throws Exception{
        
        double [] pred = new double [m_numClasses];
        
        //Need to take into account partial model fit at higher levels in the tree (m_higherRegressions) 
        //and the part of the model fit at this node (m_regressions).

        //Fs from m_regressions (use method of LogisticBase)
        double [] instanceFs = super.getFs(instance);           

        //Fs from m_higherRegressions
        for (int i = 0; i < m_numHigherRegressions; i++) {
            double predSum = 0;
            for (int j = 0; j < m_numClasses; j++) {
                pred[j] = m_higherRegressions[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; 
    }
    
    /**
     *Returns true if the logistic regression model at this node has changed compared to the
     *one at the parent node.
     *@return whether it has changed
     */
    public boolean hasModels() {
        return (m_numRegressions > 0);
    }

    /**
     * Returns the class probabilities for an instance according to the logistic model at the node.
     * @param instance the instance
     * @return the array of probabilities
     */
    public double[] modelDistributionForInstance(Instance instance) throws Exception {
        
        //make copy and convert nominal attributes
        instance = (Instance)instance.copy();           
        m_nominalToBinary.input(instance);
        instance = m_nominalToBinary.output();  
        
        //saet numeric pseudo-class
        instance.setDataset(m_numericDataHeader);               
        
        return probs(getFs(instance));
    }

    /**
     * Returns the class probabilities for an instance given by the logistic model tree.
     * @param instance the instance
     * @return the array of probabilities
     */
    public double[] distributionForInstance(Instance instance) throws Exception {
        
        double[] probs;
        
        if (m_isLeaf) {     
            //leaf: use logistic model
            probs = modelDistributionForInstance(instance);
        } else {
            //sort into appropiate child node
            int branch = m_localModel.whichSubset(instance);
            probs = m_sons[branch].distributionForInstance(instance);
        }                       
        return probs;
    }

    /**
     * Returns the number of leaves (normal count).
     * @return the number of leaves
     */
    public int numLeaves() {    
        if (m_isLeaf) return 1; 
        int numLeaves = 0;
        for (int i = 0; i < m_sons.length; i++) numLeaves += m_sons[i].numLeaves();
        return numLeaves;
    }
    
    /**
     * Returns the number of nodes.
     * @return the number of nodes
     */
    public int numNodes() {
        if (m_isLeaf) return 1; 
        int numNodes = 1;
        for (int i = 0; i < m_sons.length; i++) numNodes += m_sons[i].numNodes();
        return numNodes;
    }

    /**
     * Returns a description of the logistic model tree (tree structure and logistic models)
     * @return describing string
     */
    public String toString(){   
        //assign numbers to logistic regression functions at leaves
        assignLeafModelNumbers(0);      
        try{
            StringBuffer text = new StringBuffer();
            
            if (m_isLeaf) {
                text.append(": ");
                text.append("LM_"+m_leafModelNum+":"+getModelParameters());
            } else {
                dumpTree(0,text);                   
            }
            text.append("\n\nNumber of Leaves  : \t"+numLeaves()+"\n");
            text.append("\nSize of the Tree : \t"+numNodes()+"\n");     
                
            //This prints logistic models after the tree, comment out if only tree should be printed
            text.append(modelsToString());
            return text.toString();
        } catch (Exception e){
            return "Can't print logistic model tree";
        }
        
        
    }

    /**
     * Returns a string describing the number of LogitBoost iterations performed at this node, the total number
     * of LogitBoost iterations performed (including iterations at higher levels in the tree), and the number
     * of training examples at this node.
     * @return the describing string
     */
    public String getModelParameters(){
        
        StringBuffer text = new StringBuffer();
        int numModels = m_numRegressions+m_numHigherRegressions;
        text.append(m_numRegressions+"/"+numModels+" ("+m_numInstances+")");
        return text.toString();
    }
    
   
    /**
     * Help method for printing tree structure.
     *
     * @throws Exception if something goes wrong
     */
    protected void dumpTree(int depth,StringBuffer text) 
        throws Exception {
        
        for (int i = 0; i < m_sons.length; i++) {
            text.append("\n");
            for (int j = 0; j < depth; j++)
                text.append("|   ");
            text.append(m_localModel.leftSide(m_train));
            text.append(m_localModel.rightSide(i, m_train));
            if (m_sons[i].m_isLeaf) {
                text.append(": ");
                text.append("LM_"+m_sons[i].m_leafModelNum+":"+m_sons[i].getModelParameters());
            }else
                m_sons[i].dumpTree(depth+1,text);
        }
    }

    /**
     * Assigns unique IDs to all nodes in the tree
     */
    public int assignIDs(int lastID) {
        
        int currLastID = lastID + 1;
        
        m_id = currLastID;
        if (m_sons != null) {
            for (int i = 0; i < m_sons.length; i++) {
                currLastID = m_sons[i].assignIDs(currLastID);
            }
        }
        return currLastID;
    }
    
    /**
     * Assigns numbers to the logistic regression models at the leaves of the tree
     */
    public int assignLeafModelNumbers(int leafCounter) {
        if (!m_isLeaf) {
            m_leafModelNum = 0;
            for (int i = 0; i < m_sons.length; i++){
                leafCounter = m_sons[i].assignLeafModelNumbers(leafCounter);
            }
        } else {
            leafCounter++;
            m_leafModelNum = leafCounter;
        } 
        return leafCounter;
    }

    /**
     * Returns an array containing the coefficients of the logistic regression function at this node.
     * @return the array of coefficients, first dimension is the class, second the attribute. 
     */
    protected double[][] getCoefficients(){
       
        //Need to take into account partial model fit at higher levels in the tree (m_higherRegressions) 
        //and the part of the model fit at this node (m_regressions).
        
        //get coefficients from m_regressions: use method of LogisticBase
        double[][] coefficients = super.getCoefficients();
        //get coefficients from m_higherRegressions:
        double constFactor = (double)(m_numClasses - 1) / (double)m_numClasses; // (J - 1)/J
        for (int j = 0; j < m_numClasses; j++) {
            for (int i = 0; i < m_numHigherRegressions; i++) {          
                double slope = m_higherRegressions[j][i].getSlope();
                double intercept = m_higherRegressions[j][i].getIntercept();
                int attribute = m_higherRegressions[j][i].getAttributeIndex();
                coefficients[j][0] += constFactor * intercept;
                coefficients[j][attribute + 1] += constFactor * slope;
            }
        }

        return coefficients;
    }
    
    /**
     * Returns a string describing the logistic regression function at the node.
     */
    public String modelsToString(){
        
        StringBuffer text = new StringBuffer();
        if (m_isLeaf) {
            text.append("LM_"+m_leafModelNum+":"+super.toString());
        } else {
            for (int i = 0; i < m_sons.length; i++) {
                text.append("\n"+m_sons[i].modelsToString());
            }
        }
        return text.toString();     
    }

    /**
     * Returns graph describing the tree.
     *
     * @throws Exception if something goes wrong
     */
    public String graph() throws Exception {
        
        StringBuffer text = new StringBuffer();
        
        assignIDs(-1);
        assignLeafModelNumbers(0);
        text.append("digraph LMTree {\n");
        if (m_isLeaf) {
            text.append("N" + m_id + " [label=\"LM_"+m_leafModelNum+":"+getModelParameters()+"\" " + 
                        "shape=box style=filled");
            text.append("]\n");
        }else {
            text.append("N" + m_id 
                        + " [label=\"" + 
                        m_localModel.leftSide(m_train) + "\" ");
            text.append("]\n");
            graphTree(text);
        }
    
        return text.toString() +"}\n";
    }

    /**
     * Helper function for graph description of tree
     *
     * @throws Exception if something goes wrong
     */
    private void graphTree(StringBuffer text) throws Exception {
        
        for (int i = 0; i < m_sons.length; i++) {
            text.append("N" + m_id  
                        + "->" + 
                        "N" + m_sons[i].m_id +
                        " [label=\"" + m_localModel.rightSide(i,m_train).trim() + 
                        "\"]\n");
            if (m_sons[i].m_isLeaf) {
                text.append("N" +m_sons[i].m_id + " [label=\"LM_"+m_sons[i].m_leafModelNum+":"+
                            m_sons[i].getModelParameters()+"\" " + "shape=box style=filled");
                text.append("]\n");
            } else {
                text.append("N" + m_sons[i].m_id +
                            " [label=\""+m_sons[i].m_localModel.leftSide(m_train) + 
                            "\" ");
                text.append("]\n");
                m_sons[i].graphTree(text);
            }
        }
    } 
    
    /**
     * Cleanup in order to save memory.
     */
    public void cleanup() {
        super.cleanup();
        if (!m_isLeaf) {
            for (int i = 0; i < m_sons.length; i++) m_sons[i].cleanup();
        }
    }
    
    /**
     * Returns the revision string.
     * 
     * @return          the revision
     */
    public String getRevision() {
      return RevisionUtils.extract("$Revision: 1.8 $");
    }
}