/**
* Recursively descends through the tree, removing
* the supplied node and any descendants from
* the internal node list.
*
* @param node The root node of the subtree to remove.
*/
public void recursiveRemoveSubtree(DecisionTreeNode node)
{
if (node == null)
{
return;
}
// First, recursively remove all the node's children.
// (This loop doesn't run if the node is a leaf node)
for (int i = 0; i < node.getArcLabelCount(); i++)
{
if (node.getChild(i) != null)
{
recursiveRemoveSubtree(node.getChild(i));
}
}
// Remove this node from the vector.
Nodes.Remove(node);
// If the node was a leaf, then we have to update
// the classification statistics.
if (node.isLeaf())
{
TrainingCorrect -=
node.getTrainingEgsCorrectClassUsingBestTrainingIndex();
TestingCorrect -=
node.getTestingEgsCorrectClassUsingBestTrainingIndex();
}
else
{
InternalNodes--;
}
}
/// <summary>
/// Search through the current tree and return the first
/// node without a complete set of children. The arc
/// number for the first missing child is returned in
/// position 0 of the arcNum array.
/// </summary>
/// <param name="node">The node at which to begin the search.</param>
/// <param name="arcNum">An integer array of size 1. The arc
/// number for the first missing child is
/// returned in arcNum[0].</param>
/// <returns>A reference to the first incomplete node
/// in the tree (farthest left). The method
/// returns null if the tree is already complete,
/// or if the tree is empty.</returns>
public DecisionTreeNode findIncompleteNode(DecisionTreeNode node, int[] arcNum)
{
// The search is recursive - at some point, we
// may want to change this to a non-recursive
// algorithm (if we start dealing with extremely
// large trees?)
// Base cases.
if (node == null || node.isLeaf())
{
return(null);
}
// Recursive case. This node is not a leaf - so descend.
for (int i = 0; i < node.getArcLabelCount(); i++)
{
DecisionTreeNode nextNode;
if ((nextNode = findIncompleteNode(node.getChild(i), arcNum)) != null)
{
return(nextNode);
}
}
if ((arcNum[0] = node.getFirstMissingChild()) >= 0)
{
// We found a node with a missing child, which
// is already stored in arcNum - so return this
// node.
return(node);
}
// We searched all the subtrees attached to this
// node, and didn't find anything, so return null.
return(null);
}
/**
* An implementation of the recursive decision tree
* pessimistic pruning algorithm. Given a parent
* node, the method will prune all the branches
* below the node.
*
* @param node The root node of the tree to prune.
*
* @param error A <code>double</code> array of size 1. The
* array is used to store the current error value.
*
* @return <code>true</code> if an entire subtree was successfully
* pruned, or <code>false</code> otherwise.
*/
public bool prunePessimisticDT(DecisionTreeNode node, double[] error)
{
// Post-order walk through the tree, marking
// our path as we go along.
if (node.isLeaf())
{
if (node.getTrainingEgsAtNode() == 0)
{
error[0] = 0;
return true;
}
else
{
// We do the error calculation in two steps -
// Here we multiply the error value by the number
// of examples that reach the node. When the method
// is called recursively, this value will be divided
// by the number of examples that reach the parent
// node (thus weighting the error from each child).
int errors1 = (int)node.getTrainingEgsAtNode() - node.getTrainingEgsCorrectClassUsingBestTrainingIndex();
double p1 = (double)(errors1 + 1.0) / (node.getTrainingEgsAtNode() + 2.0);
error[0] = node.getTrainingEgsAtNode() * errorBar(p1, node.getTrainingEgsAtNode()) + errors1;
return true;
}
}
// We're at an internal node, so compute the error
// of the children and use the result to determine
// if we prune or not.
double errorSum = 0;
for (int i = 0; i < node.getArcLabelCount(); i++)
{
// Mark our current path.
Tree.flagNode(node, i);
if (!prunePessimisticDT(node.getChild(i), error))
{
Tree.flagNode(node, -2);
return false;
}
errorSum += error[0];
}
// Mark the node as our current target.
Tree.flagNode(node, -1);
// Get the worst-case performance of this node.
double errorWorst;
if (node.getTrainingEgsAtNode() == 0)
{
error[0] = 0;
return true;
}
int errors = (int)node.getTrainingEgsAtNode() - node.getTrainingEgsCorrectClassUsingBestTrainingIndex();
double p = (double)(errors + 1.0) / (node.getTrainingEgsAtNode() + 2.0);
errorWorst = (double)node.getTrainingEgsAtNode() * errorBar(p, node.getTrainingEgsAtNode()) + errors;
DecisionTreeNode newNode = node;
if (errorWorst < errorSum)
{
// We need to "prune" this node to a leaf.
DecisionTreeNode parent = node.getParent();
int arcNum = -1;
if (parent != null)
{
arcNum = parent.getChildPosition(node);
}
Tree.pruneSubtree(node);
// Figure out the label for the new leaf.
String label = null;
try
{
label = DatasetUse.getTargetAttribute().getAttributeValueByNum(node.getTrainingBestTarget());
}
catch (Exception e)
{
// Should never happen.
//e.printStackTrace();
}
node.getMask().mask(0, node.getTrainingBestTarget());
newNode =
Tree.addLeafNode(parent, arcNum, label,
node.getMask(),
node.getTrainingEgsAtNode(),
node.getTrainingBestTarget(),
node.getTrainingEgsCorrectClassUsingBestTrainingIndex(),
node.getTestingEgsCorrectClassUsingBestTrainingIndex(),
node.getTestingEgsAtNode(),
node.getTestingBestTarget(),
node.getTestingEgsCorrectClassUsingBestTestingIndex(),
node.getTrainingEgsCorrectClassUsingBestTestingIndex());
}
// Update the count.
if (newNode.isLeaf())
{
error[0] = errorWorst;
}
else
{
error[0] = errorSum;
}
// All finished, unmark the node if it still exists.
Tree.flagNode(node, -2);
return true;
}
public void ExtractRulesFromDTTree(DecisionTreeNode currentRoot)
{
if (currentRoot.isLeaf())
{
BackTrackRule(currentRoot);
}
else
{
DecisionTreeNode temp = currentRoot;
for (int i = 0; i < temp.Children.Length; i++)
{
currentRoot = temp.Children[i];
ExtractRulesFromDTTree(currentRoot);
}
}
}
/**
* An implementation of the recursive decision tree
* reduced error pruning algorithm. Given a parent
* node, the method will prune all the branches
* below the node.
*
* @param node The root node of the tree to prune.
*
* @param error A <code>double</code> array of size 1. The
* array is used to store the current error value.
*
* @return <code>true</code> if an entire subtree was successfully
* pruned, or <code>false</code> otherwise.
*/
public bool pruneReducedErrorDT(DecisionTreeNode node, double[] error)
{
if (node.isLeaf())
{
error[0] = node.getTestingEgsAtNode() - node.getTestingEgsCorrectClassUsingBestTrainingIndex();
return true;
}
// We're at an internal node, so compute the error
// of the children and use the result to determine
// if we prune or not.
double errorSum = 0;
for (int i = 0; i < node.getArcLabelCount(); i++)
{
// Mark our current path.
Tree.flagNode(node, i);
if (!pruneReducedErrorDT(node.getChild(i), error))
{
Tree.flagNode(node, -2);
return false;
}
errorSum += error[0];
}
// Mark the node as our current target.
Tree.flagNode(node, -1);
// Get the best-case performance of this node.
double errorBest = node.getTestingEgsAtNode() - node.getTestingEgsCorrectClassUsingBestTestingIndex();
DecisionTreeNode newNode = node;
if (errorBest < errorSum)
{
// We need to "prune" this node to a leaf.
DecisionTreeNode parent = node.getParent();
int arcNum = -1;
if (parent != null)
{
arcNum = parent.getChildPosition(node);
}
Tree.pruneSubtree(node);
// Figure out the label for the new leaf.
String label = null;
try
{
label = DatasetUse.getTargetAttribute().getAttributeValueByNum(node.getTestingBestTarget());
}
catch (Exception e)
{
// Should never happen.
//e.printStackTrace();
}
node.getMask().mask(0, node.getTestingBestTarget());
newNode = Tree.addLeafNode(parent, arcNum, label,
node.getMask(),
node.getTrainingEgsAtNode(),
node.getTestingBestTarget(),
node.getTrainingEgsCorrectClassUsingBestTestingIndex(),
node.getTestingEgsCorrectClassUsingBestTestingIndex(),
node.getTestingEgsAtNode(),
node.getTestingBestTarget(),
node.getTestingEgsCorrectClassUsingBestTestingIndex(),
node.getTrainingEgsCorrectClassUsingBestTestingIndex());
}
// Update the count.
if (newNode.isLeaf())
{
error[0] = errorBest;
}
else
{
error[0] = errorSum;
}
// All finished, unmark the node if it still exists.
Tree.flagNode(node, -2);
return true;
}
/**
* Recursively descends through the tree, removing
* the supplied node and any descendants from
* the internal node list.
*
* @param node The root node of the subtree to remove.
*/
public void recursiveRemoveSubtree(DecisionTreeNode node)
{
if (node == null) return;
// First, recursively remove all the node's children.
// (This loop doesn't run if the node is a leaf node)
for (int i = 0; i < node.getArcLabelCount(); i++)
if (node.getChild(i) != null)
recursiveRemoveSubtree(node.getChild(i));
// Remove this node from the vector.
Nodes.Remove(node);
// If the node was a leaf, then we have to update
// the classification statistics.
if (node.isLeaf())
{
TrainingCorrect -=
node.getTrainingEgsCorrectClassUsingBestTrainingIndex();
TestingCorrect -=
node.getTestingEgsCorrectClassUsingBestTrainingIndex();
}
else
InternalNodes--;
}
/// <summary>
/// Search through the current tree and return the first
/// node without a complete set of children. The arc
/// number for the first missing child is returned in
/// position 0 of the arcNum array.
/// </summary>
/// <param name="node">The node at which to begin the search.</param>
/// <param name="arcNum">An integer array of size 1. The arc
/// number for the first missing child is
/// returned in arcNum[0].</param>
/// <returns>A reference to the first incomplete node
/// in the tree (farthest left). The method
/// returns null if the tree is already complete,
/// or if the tree is empty.</returns>
public DecisionTreeNode findIncompleteNode(DecisionTreeNode node, int[] arcNum)
{
// The search is recursive - at some point, we
// may want to change this to a non-recursive
// algorithm (if we start dealing with extremely
// large trees?)
// Base cases.
if (node == null || node.isLeaf())
{
return null;
}
// Recursive case. This node is not a leaf - so descend.
for (int i = 0; i < node.getArcLabelCount(); i++)
{
DecisionTreeNode nextNode;
if ((nextNode = findIncompleteNode(node.getChild(i), arcNum)) != null)
{
return nextNode;
}
}
if ((arcNum[0] = node.getFirstMissingChild()) >= 0)
{
// We found a node with a missing child, which
// is already stored in arcNum - so return this
// node.
return node;
}
// We searched all the subtrees attached to this
// node, and didn't find anything, so return null.
return null;
}