/**
* Build one rule using the growing data
*
* @param data the growing data used to build the rule
* @throws Exception if the consequent is not set yet
*/
public void grow(Instances data) throws Exception {
if (m_Consequent == -1) throw new Exception(" Consequent not set yet.");
Instances growData = data;
double sumOfWeights = growData.sumOfWeights();
if (!Utils.gr(sumOfWeights, 0.0)) return;
/* Compute the default accurate rate of the growing data */
double defAccu = computeDefAccu(growData);
double defAcRt = (defAccu + 1.0) / (sumOfWeights + 1.0);
/* Keep the record of which attributes have already been used*/
boolean[] used = new boolean[growData.numAttributes()];
for (int k = 0; k < used.length; k++) used[k] = false;
int numUnused = used.length;
// If there are already antecedents existing
for (int j = 0; j < m_Antds.size(); j++) {
Antd antdj = (Antd) m_Antds.elementAt(j);
if (!antdj.getAttr().isNumeric()) {
used[antdj.getAttr().index()] = true;
numUnused--;
}
}
double maxInfoGain;
while (Utils.gr(growData.numInstances(), 0.0) && (numUnused > 0) && Utils.sm(defAcRt, 1.0)) {
// We require that infoGain be positive
/*if(numAntds == originalSize)
maxInfoGain = 0.0; // At least one condition allowed
else
maxInfoGain = Utils.eq(defAcRt, 1.0) ?
defAccu/(double)numAntds : 0.0; */
maxInfoGain = 0.0;
/* Build a list of antecedents */
Antd oneAntd = null;
Instances coverData = null;
Enumeration enumAttr = growData.enumerateAttributes();
/* Build one condition based on all attributes not used yet*/
while (enumAttr.hasMoreElements()) {
AttributeWeka att = (AttributeWeka) (enumAttr.nextElement());
if (m_Debug) System.err.println("\nOne condition: size = " + growData.sumOfWeights());
Antd antd = null;
if (att.isNumeric()) antd = new NumericAntd(att);
else antd = new NominalAntd(att);
if (!used[att.index()]) {
/* Compute the best information gain for each attribute,
it's stored in the antecedent formed by this attribute.
This procedure returns the data covered by the antecedent*/
Instances coveredData = computeInfoGain(growData, defAcRt, antd);
if (coveredData != null) {
double infoGain = antd.getMaxInfoGain();
if (m_Debug)
System.err.println(
"Test of \'"
+ antd.toString()
+ "\': infoGain = "
+ infoGain
+ " | Accuracy = "
+ antd.getAccuRate()
+ "="
+ antd.getAccu()
+ "/"
+ antd.getCover()
+ " def. accuracy: "
+ defAcRt);
if (infoGain > maxInfoGain) {
oneAntd = antd;
coverData = coveredData;
maxInfoGain = infoGain;
}
}
}
}
if (oneAntd == null) break; // Cannot find antds
if (Utils.sm(oneAntd.getAccu(), m_MinNo)) break; // Too low coverage
// Numeric attributes can be used more than once
if (!oneAntd.getAttr().isNumeric()) {
used[oneAntd.getAttr().index()] = true;
numUnused--;
}
m_Antds.addElement(oneAntd);
growData = coverData; // Grow data size is shrinking
defAcRt = oneAntd.getAccuRate();
}
}
/**
* This function fits the rule to the data which it overlaps. This way the rule can only
* interpolate but not extrapolate.
*
* @param instances The data to which the rule shall be fitted
*/
public void fitAndSetCoreBound(Instances instances) {
if (m_Antds == null) return;
boolean[] antExistingForDimension = new boolean[instances.numAttributes() - 1];
for (int i = 0; i < m_Antds.size(); i++) {
antExistingForDimension[((Antd) m_Antds.elementAt(i)).att.index()] = true;
}
FastVector newAntds = new FastVector(10);
// for (int i=0; i < instances.numAttributes()-1; i++){
for (int iterator = 0; iterator < m_Antds.size(); iterator++) {
int i = ((Antd) m_Antds.elementAt(iterator)).getAttr().index();
if (!antExistingForDimension[i]) continue; // Excluding non existant antecedents
Instances instancesWithoutMissingValues = new Instances(instances);
instancesWithoutMissingValues.deleteWithMissing(i);
if (instancesWithoutMissingValues.attribute(i).isNumeric()
&& instancesWithoutMissingValues.numInstances() > 0) {
boolean bag0AntdExists = false;
boolean bag1AntdExists = false;
for (int j = 0; j < m_Antds.size(); j++) {
if (((Antd) m_Antds.elementAt(j)).att.index() == i) {
if (((Antd) m_Antds.elementAt(j)).value == 0) {
bag0AntdExists = true;
} else {
bag1AntdExists = true;
}
newAntds.addElement((Antd) m_Antds.elementAt(j));
}
}
double higherCore = Double.NaN;
double lowerCore = Double.NaN;
if (!bag0AntdExists) {
if (Double.isNaN(higherCore))
higherCore =
instancesWithoutMissingValues.kthSmallestValue(
i, instancesWithoutMissingValues.numInstances());
NumericAntd antd;
antd = new NumericAntd(instancesWithoutMissingValues.attribute(i));
antd.value = 0;
antd.splitPoint = higherCore;
newAntds.addElement(antd);
}
if (!bag1AntdExists) {
if (Double.isNaN(lowerCore))
lowerCore = instancesWithoutMissingValues.kthSmallestValue(i, 1);
NumericAntd antd;
antd = new NumericAntd(instancesWithoutMissingValues.attribute(i));
antd.value = 1;
antd.splitPoint = lowerCore;
newAntds.addElement(antd);
}
} else {
for (int j = 0; j < m_Antds.size(); j++) {
if (((Antd) m_Antds.elementAt(j)).att.index() == i) {
newAntds.addElement(m_Antds.elementAt(j));
}
}
}
}
m_Antds = newAntds;
}
/** Main method for testing this class. */
public static void main(String[] options) {
try {
// Create numeric attributes "length" and "weight"
Attribute length = new Attribute("length");
Attribute weight = new Attribute("weight");
// Create vector to hold nominal values "first", "second", "third"
FastVector my_nominal_values = new FastVector(3);
my_nominal_values.addElement("first");
my_nominal_values.addElement("second");
// Create nominal attribute "position"
Attribute position = new Attribute("position", my_nominal_values);
// Create vector of the above attributes
FastVector attributes = new FastVector(3);
attributes.addElement(length);
attributes.addElement(weight);
attributes.addElement(position);
// Create the empty dataset "race" with above attributes
Instances race = new Instances("race", attributes, 0);
// Make position the class attribute
race.setClassIndex(position.index());
// Create empty instance with three attribute values
BinarySparseInstance inst = new BinarySparseInstance(3);
// Set instance's values for the attributes "length", "weight", and "position"
inst.setValue(length, (float) 5.3);
inst.setValue(weight, 300);
inst.setValue(position, "first");
// Set instance's dataset to be the dataset "race"
inst.setDataset(race);
// Print the instance
System.out.println("The instance: " + inst);
// Print the first attribute
System.out.println("First attribute: " + inst.attribute(0));
// Print the class attribute
System.out.println("Class attribute: " + inst.classAttribute());
// Print the class index
System.out.println("Class index: " + inst.classIndex());
// Say if class is missing
System.out.println("Class is missing: " + inst.classIsMissing());
// Print the instance's class value in internal format
System.out.println("Class value (internal format): " + inst.classValue());
// Print a shallow copy of this instance
SparseInstance copy = (SparseInstance) inst.copy();
System.out.println("Shallow copy: " + copy);
// Set dataset for shallow copy
copy.setDataset(inst.dataset());
System.out.println("Shallow copy with dataset set: " + copy);
// Print out all values in internal format
System.out.print("All stored values in internal format: ");
for (int i = 0; i < inst.numValues(); i++) {
if (i > 0) {
System.out.print(",");
}
System.out.print(inst.valueSparse(i));
}
System.out.println();
// Set all values to zero
System.out.print("All values set to zero: ");
while (inst.numValues() > 0) {
inst.setValueSparse(0, 0);
}
for (int i = 0; i < inst.numValues(); i++) {
if (i > 0) {
System.out.print(",");
}
System.out.print(inst.valueSparse(i));
}
System.out.println();
// Set all values to one
System.out.print("All values set to one: ");
for (int i = 0; i < inst.numAttributes(); i++) {
inst.setValue(i, 1);
}
for (int i = 0; i < inst.numValues(); i++) {
if (i > 0) {
System.out.print(",");
}
System.out.print(inst.valueSparse(i));
}
System.out.println();
// Unset dataset for copy, delete first attribute, and insert it again
copy.setDataset(null);
copy.deleteAttributeAt(0);
copy.insertAttributeAt(0);
copy.setDataset(inst.dataset());
System.out.println("Copy with first attribute deleted and inserted: " + copy);
// Same for second attribute
copy.setDataset(null);
copy.deleteAttributeAt(1);
copy.insertAttributeAt(1);
copy.setDataset(inst.dataset());
System.out.println("Copy with second attribute deleted and inserted: " + copy);
// Same for last attribute
copy.setDataset(null);
copy.deleteAttributeAt(2);
copy.insertAttributeAt(2);
copy.setDataset(inst.dataset());
System.out.println("Copy with third attribute deleted and inserted: " + copy);
// Enumerate attributes (leaving out the class attribute)
System.out.println("Enumerating attributes (leaving out class):");
Enumeration enu = inst.enumerateAttributes();
while (enu.hasMoreElements()) {
Attribute att = (Attribute) enu.nextElement();
System.out.println(att);
}
// Headers are equivalent?
System.out.println("Header of original and copy equivalent: " + inst.equalHeaders(copy));
// Test for missing values
System.out.println("Length of copy missing: " + copy.isMissing(length));
System.out.println("Weight of copy missing: " + copy.isMissing(weight.index()));
System.out.println("Length of copy missing: " + Instance.isMissingValue(copy.value(length)));
System.out.println("Missing value coded as: " + Instance.missingValue());
// Prints number of attributes and classes
System.out.println("Number of attributes: " + copy.numAttributes());
System.out.println("Number of classes: " + copy.numClasses());
// Replace missing values
float[] meansAndModes = {2, 3, 0};
copy.replaceMissingValues(meansAndModes);
System.out.println("Copy with missing value replaced: " + copy);
// Setting and getting values and weights
copy.setClassMissing();
System.out.println("Copy with missing class: " + copy);
copy.setClassValue(0);
System.out.println("Copy with class value set to first value: " + copy);
copy.setClassValue("second");
System.out.println("Copy with class value set to \"second\": " + copy);
copy.setMissing(1);
System.out.println("Copy with second attribute set to be missing: " + copy);
copy.setMissing(length);
System.out.println("Copy with length set to be missing: " + copy);
copy.setValue(0, 0);
System.out.println("Copy with first attribute set to 0: " + copy);
copy.setValue(weight, 1);
System.out.println("Copy with weight attribute set to 1: " + copy);
copy.setValue(position, "second");
System.out.println("Copy with position set to \"second\": " + copy);
copy.setValue(2, "first");
System.out.println("Copy with last attribute set to \"first\": " + copy);
System.out.println("Current weight of instance copy: " + copy.weight());
copy.setWeight(2);
System.out.println("Current weight of instance copy (set to 2): " + copy.weight());
System.out.println("Last value of copy: " + copy.toString(2));
System.out.println("Value of position for copy: " + copy.toString(position));
System.out.println("Last value of copy (internal format): " + copy.value(2));
System.out.println("Value of position for copy (internal format): " + copy.value(position));
} catch (Exception e) {
e.printStackTrace();
}
}