/**
* GetKs - return [K_1,K_2,...,K_L] where each Y_j \in {1,...,K_j}. In the multi-label case, K[j]
* = 2 for all j = 1,...,L.
*
* @param D a dataset
* @return an array of the number of values that each label can take
*/
private static int[] getKs(Instances D) {
int L = D.classIndex();
int K[] = new int[L];
for (int k = 0; k < L; k++) {
K[k] = D.attribute(k).numValues();
}
return K;
}
/**
* loads the given dataset and prints the Capabilities necessary to process it.
*
* <p>Valid parameters:
*
* <p>-file filename <br>
* the file to load
*
* <p>-c index the explicit index of the class attribute (default: none)
*
* @param args the commandline arguments
* @throws Exception if something goes wrong
*/
public static void main(String[] args) throws Exception {
String tmpStr;
String filename;
DataSource source;
Instances data;
int classIndex;
Capabilities cap;
Iterator iter;
if (args.length == 0) {
System.out.println(
"\nUsage: " + Capabilities.class.getName() + " -file <dataset> [-c <class index>]\n");
return;
}
// get parameters
tmpStr = Utils.getOption("file", args);
if (tmpStr.length() == 0) throw new Exception("No file provided with option '-file'!");
else filename = tmpStr;
tmpStr = Utils.getOption("c", args);
if (tmpStr.length() != 0) {
if (tmpStr.equals("first")) classIndex = 0;
else if (tmpStr.equals("last")) classIndex = -2; // last
else classIndex = Integer.parseInt(tmpStr) - 1;
} else {
classIndex = -3; // not set
}
// load data
source = new DataSource(filename);
if (classIndex == -3) data = source.getDataSet();
else if (classIndex == -2) data = source.getDataSet(source.getStructure().numAttributes() - 1);
else data = source.getDataSet(classIndex);
// determine and print capabilities
cap = forInstances(data);
System.out.println("File: " + filename);
System.out.println(
"Class index: " + ((data.classIndex() == -1) ? "not set" : "" + (data.classIndex() + 1)));
System.out.println("Capabilities:");
iter = cap.capabilities();
while (iter.hasNext()) System.out.println("- " + iter.next());
}
/**
* Calculates the distance between two instances
*
* @param test the first instance
* @param train the second instance
* @return the distance between the two given instances, between 0 and 1
*/
protected double distance(Instance first, Instance second) {
double distance = 0;
int firstI, secondI;
for (int p1 = 0, p2 = 0; p1 < first.numValues() || p2 < second.numValues(); ) {
if (p1 >= first.numValues()) {
firstI = m_instances.numAttributes();
} else {
firstI = first.index(p1);
}
if (p2 >= second.numValues()) {
secondI = m_instances.numAttributes();
} else {
secondI = second.index(p2);
}
if (firstI == m_instances.classIndex()) {
p1++;
continue;
}
if (secondI == m_instances.classIndex()) {
p2++;
continue;
}
double diff;
if (firstI == secondI) {
diff = difference(firstI, first.valueSparse(p1), second.valueSparse(p2));
p1++;
p2++;
} else if (firstI > secondI) {
diff = difference(secondI, 0, second.valueSparse(p2));
p2++;
} else {
diff = difference(firstI, first.valueSparse(p1), 0);
p1++;
}
distance += diff * diff;
}
return Math.sqrt(distance / m_instances.numAttributes());
}
/**
* Tests a certain range of attributes of the given data, whether it can be processed by the
* handler, given its capabilities. Classifiers implementing the <code>
* MultiInstanceCapabilitiesHandler</code> interface are checked automatically for their
* multi-instance Capabilities (if no bags, then only the bag-structure, otherwise only the first
* bag).
*
* @param data the data to test
* @param fromIndex the range of attributes - start (incl.)
* @param toIndex the range of attributes - end (incl.)
* @return true if all the tests succeeded
* @see MultiInstanceCapabilitiesHandler
* @see #m_InstancesTest
* @see #m_MissingValuesTest
* @see #m_MissingClassValuesTest
* @see #m_MinimumNumberInstancesTest
*/
public boolean test(Instances data, int fromIndex, int toIndex) {
int i;
int n;
int m;
Attribute att;
Instance inst;
boolean testClass;
Capabilities cap;
boolean missing;
Iterator iter;
// shall we test the data?
if (!m_InstancesTest) return true;
// no Capabilities? -> warning
if ((m_Capabilities.size() == 0)
|| ((m_Capabilities.size() == 1) && handles(Capability.NO_CLASS)))
System.err.println(createMessage("No capabilities set!"));
// any attributes?
if (toIndex - fromIndex < 0) {
m_FailReason = new WekaException(createMessage("No attributes!"));
return false;
}
// do wee need to test the class attribute, i.e., is the class attribute
// within the range of attributes?
testClass =
(data.classIndex() > -1)
&& (data.classIndex() >= fromIndex)
&& (data.classIndex() <= toIndex);
// attributes
for (i = fromIndex; i <= toIndex; i++) {
att = data.attribute(i);
// class is handled separately
if (i == data.classIndex()) continue;
// check attribute types
if (!test(att)) return false;
}
// class
if (!handles(Capability.NO_CLASS) && (data.classIndex() == -1)) {
m_FailReason = new UnassignedClassException(createMessage("Class attribute not set!"));
return false;
}
// special case: no class attribute can be handled
if (handles(Capability.NO_CLASS) && (data.classIndex() > -1)) {
cap = getClassCapabilities();
cap.disable(Capability.NO_CLASS);
iter = cap.capabilities();
if (!iter.hasNext()) {
m_FailReason = new WekaException(createMessage("Cannot handle any class attribute!"));
return false;
}
}
if (testClass && !handles(Capability.NO_CLASS)) {
att = data.classAttribute();
if (!test(att, true)) return false;
// special handling of RELATIONAL class
// TODO: store additional Capabilities for this case
// missing class labels
if (m_MissingClassValuesTest) {
if (!handles(Capability.MISSING_CLASS_VALUES)) {
for (i = 0; i < data.numInstances(); i++) {
if (data.instance(i).classIsMissing()) {
m_FailReason =
new WekaException(createMessage("Cannot handle missing class values!"));
return false;
}
}
} else {
if (m_MinimumNumberInstancesTest) {
int hasClass = 0;
for (i = 0; i < data.numInstances(); i++) {
if (!data.instance(i).classIsMissing()) hasClass++;
}
// not enough instances with class labels?
if (hasClass < getMinimumNumberInstances()) {
m_FailReason =
new WekaException(
createMessage(
"Not enough training instances with class labels (required: "
+ getMinimumNumberInstances()
+ ", provided: "
+ hasClass
+ ")!"));
return false;
}
}
}
}
}
// missing values
if (m_MissingValuesTest) {
if (!handles(Capability.MISSING_VALUES)) {
missing = false;
for (i = 0; i < data.numInstances(); i++) {
inst = data.instance(i);
if (inst instanceof SparseInstance) {
for (m = 0; m < inst.numValues(); m++) {
n = inst.index(m);
// out of scope?
if (n < fromIndex) continue;
if (n > toIndex) break;
// skip class
if (n == inst.classIndex()) continue;
if (inst.isMissing(n)) {
missing = true;
break;
}
}
} else {
for (n = fromIndex; n <= toIndex; n++) {
// skip class
if (n == inst.classIndex()) continue;
if (inst.isMissing(n)) {
missing = true;
break;
}
}
}
if (missing) {
m_FailReason =
new NoSupportForMissingValuesException(
createMessage("Cannot handle missing values!"));
return false;
}
}
}
}
// instances
if (m_MinimumNumberInstancesTest) {
if (data.numInstances() < getMinimumNumberInstances()) {
m_FailReason =
new WekaException(
createMessage(
"Not enough training instances (required: "
+ getMinimumNumberInstances()
+ ", provided: "
+ data.numInstances()
+ ")!"));
return false;
}
}
// Multi-Instance? -> check structure (regardless of attribute range!)
if (handles(Capability.ONLY_MULTIINSTANCE)) {
// number of attributes?
if (data.numAttributes() != 3) {
m_FailReason =
new WekaException(
createMessage("Incorrect Multi-Instance format, must be 'bag-id, bag, class'!"));
return false;
}
// type of attributes and position of class?
if (!data.attribute(0).isNominal()
|| !data.attribute(1).isRelationValued()
|| (data.classIndex() != data.numAttributes() - 1)) {
m_FailReason =
new WekaException(
createMessage(
"Incorrect Multi-Instance format, must be 'NOMINAL att, RELATIONAL att, CLASS att'!"));
return false;
}
// check data immediately
if (getOwner() instanceof MultiInstanceCapabilitiesHandler) {
MultiInstanceCapabilitiesHandler handler = (MultiInstanceCapabilitiesHandler) getOwner();
cap = handler.getMultiInstanceCapabilities();
boolean result;
if (data.numInstances() > 0) result = cap.test(data.attribute(1).relation(0));
else result = cap.test(data.attribute(1).relation());
if (!result) {
m_FailReason = cap.m_FailReason;
return false;
}
}
}
// passed all tests!
return true;
}
/**
* returns a Capabilities object specific for this data. The minimum number of instances is not
* set, the check for multi-instance data is optional.
*
* @param data the data to base the capabilities on
* @param multi if true then the structure is checked, too
* @return a data-specific capabilities object
* @throws Exception in case an error occurrs, e.g., an unknown attribute type
*/
public static Capabilities forInstances(Instances data, boolean multi) throws Exception {
Capabilities result;
Capabilities multiInstance;
int i;
int n;
int m;
Instance inst;
boolean missing;
result = new Capabilities(null);
// class
if (data.classIndex() == -1) {
result.enable(Capability.NO_CLASS);
} else {
switch (data.classAttribute().type()) {
case Attribute.NOMINAL:
if (data.classAttribute().numValues() == 1) result.enable(Capability.UNARY_CLASS);
else if (data.classAttribute().numValues() == 2) result.enable(Capability.BINARY_CLASS);
else result.enable(Capability.NOMINAL_CLASS);
break;
case Attribute.NUMERIC:
result.enable(Capability.NUMERIC_CLASS);
break;
case Attribute.STRING:
result.enable(Capability.STRING_CLASS);
break;
case Attribute.DATE:
result.enable(Capability.DATE_CLASS);
break;
case Attribute.RELATIONAL:
result.enable(Capability.RELATIONAL_CLASS);
break;
default:
throw new UnsupportedAttributeTypeException(
"Unknown class attribute type '" + data.classAttribute() + "'!");
}
// missing class values
for (i = 0; i < data.numInstances(); i++) {
if (data.instance(i).classIsMissing()) {
result.enable(Capability.MISSING_CLASS_VALUES);
break;
}
}
}
// attributes
for (i = 0; i < data.numAttributes(); i++) {
// skip class
if (i == data.classIndex()) continue;
switch (data.attribute(i).type()) {
case Attribute.NOMINAL:
result.enable(Capability.UNARY_ATTRIBUTES);
if (data.attribute(i).numValues() == 2) result.enable(Capability.BINARY_ATTRIBUTES);
else if (data.attribute(i).numValues() > 2) result.enable(Capability.NOMINAL_ATTRIBUTES);
break;
case Attribute.NUMERIC:
result.enable(Capability.NUMERIC_ATTRIBUTES);
break;
case Attribute.DATE:
result.enable(Capability.DATE_ATTRIBUTES);
break;
case Attribute.STRING:
result.enable(Capability.STRING_ATTRIBUTES);
break;
case Attribute.RELATIONAL:
result.enable(Capability.RELATIONAL_ATTRIBUTES);
break;
default:
throw new UnsupportedAttributeTypeException(
"Unknown attribute type '" + data.attribute(i).type() + "'!");
}
}
// missing values
missing = false;
for (i = 0; i < data.numInstances(); i++) {
inst = data.instance(i);
if (inst instanceof SparseInstance) {
for (m = 0; m < inst.numValues(); m++) {
n = inst.index(m);
// skip class
if (n == inst.classIndex()) continue;
if (inst.isMissing(n)) {
missing = true;
break;
}
}
} else {
for (n = 0; n < data.numAttributes(); n++) {
// skip class
if (n == inst.classIndex()) continue;
if (inst.isMissing(n)) {
missing = true;
break;
}
}
}
if (missing) {
result.enable(Capability.MISSING_VALUES);
break;
}
}
// multi-instance data?
if (multi) {
if ((data.numAttributes() == 3)
&& (data.attribute(0).isNominal()) // bag-id
&& (data.attribute(1).isRelationValued()) // bag
&& (data.classIndex() == data.numAttributes() - 1)) {
multiInstance = new Capabilities(null);
multiInstance.or(result.getClassCapabilities());
multiInstance.enable(Capability.NOMINAL_ATTRIBUTES);
multiInstance.enable(Capability.RELATIONAL_ATTRIBUTES);
multiInstance.enable(Capability.ONLY_MULTIINSTANCE);
result.assign(multiInstance);
}
}
return result;
}
/**
* Evaluates a feature subset by cross validation
*
* @param feature_set the subset to be evaluated
* @param num_atts the number of attributes in the subset
* @return the estimated accuracy
* @throws Exception if subset can't be evaluated
*/
protected double estimatePerformance(BitSet feature_set, int num_atts) throws Exception {
m_evaluation = new Evaluation(m_theInstances);
int i;
int[] fs = new int[num_atts];
double[] instA = new double[num_atts];
int classI = m_theInstances.classIndex();
int index = 0;
for (i = 0; i < m_numAttributes; i++) {
if (feature_set.get(i)) {
fs[index++] = i;
}
}
// create new hash table
m_entries = new Hashtable((int) (m_theInstances.numInstances() * 1.5));
// insert instances into the hash table
for (i = 0; i < m_numInstances; i++) {
Instance inst = m_theInstances.instance(i);
for (int j = 0; j < fs.length; j++) {
if (fs[j] == classI) {
instA[j] = Double.MAX_VALUE; // missing for the class
} else if (inst.isMissing(fs[j])) {
instA[j] = Double.MAX_VALUE;
} else {
instA[j] = inst.value(fs[j]);
}
}
insertIntoTable(inst, instA);
}
if (m_CVFolds == 1) {
// calculate leave one out error
for (i = 0; i < m_numInstances; i++) {
Instance inst = m_theInstances.instance(i);
for (int j = 0; j < fs.length; j++) {
if (fs[j] == classI) {
instA[j] = Double.MAX_VALUE; // missing for the class
} else if (inst.isMissing(fs[j])) {
instA[j] = Double.MAX_VALUE;
} else {
instA[j] = inst.value(fs[j]);
}
}
evaluateInstanceLeaveOneOut(inst, instA);
}
} else {
m_theInstances.randomize(m_rr);
m_theInstances.stratify(m_CVFolds);
// calculate 10 fold cross validation error
for (i = 0; i < m_CVFolds; i++) {
Instances insts = m_theInstances.testCV(m_CVFolds, i);
evaluateFoldCV(insts, fs);
}
}
switch (m_evaluationMeasure) {
case EVAL_DEFAULT:
if (m_classIsNominal) {
return m_evaluation.pctCorrect();
}
return -m_evaluation.rootMeanSquaredError();
case EVAL_ACCURACY:
return m_evaluation.pctCorrect();
case EVAL_RMSE:
return -m_evaluation.rootMeanSquaredError();
case EVAL_MAE:
return -m_evaluation.meanAbsoluteError();
case EVAL_AUC:
double[] classPriors = m_evaluation.getClassPriors();
Utils.normalize(classPriors);
double weightedAUC = 0;
for (i = 0; i < m_theInstances.classAttribute().numValues(); i++) {
double tempAUC = m_evaluation.areaUnderROC(i);
if (!Utils.isMissingValue(tempAUC)) {
weightedAUC += (classPriors[i] * tempAUC);
} else {
System.err.println("Undefined AUC!!");
}
}
return weightedAUC;
}
// shouldn't get here
return 0.0;
}
/**
* Calculates the accuracy on a test fold for internal cross validation of feature sets
*
* @param fold set of instances to be "left out" and classified
* @param fs currently selected feature set
* @return the accuracy for the fold
* @throws Exception if something goes wrong
*/
double evaluateFoldCV(Instances fold, int[] fs) throws Exception {
int i;
int ruleCount = 0;
int numFold = fold.numInstances();
int numCl = m_theInstances.classAttribute().numValues();
double[][] class_distribs = new double[numFold][numCl];
double[] instA = new double[fs.length];
double[] normDist;
DecisionTableHashKey thekey;
double acc = 0.0;
int classI = m_theInstances.classIndex();
Instance inst;
if (m_classIsNominal) {
normDist = new double[numCl];
} else {
normDist = new double[2];
}
// first *remove* instances
for (i = 0; i < numFold; i++) {
inst = fold.instance(i);
for (int j = 0; j < fs.length; j++) {
if (fs[j] == classI) {
instA[j] = Double.MAX_VALUE; // missing for the class
} else if (inst.isMissing(fs[j])) {
instA[j] = Double.MAX_VALUE;
} else {
instA[j] = inst.value(fs[j]);
}
}
thekey = new DecisionTableHashKey(instA);
if ((class_distribs[i] = (double[]) m_entries.get(thekey)) == null) {
throw new Error("This should never happen!");
} else {
if (m_classIsNominal) {
class_distribs[i][(int) inst.classValue()] -= inst.weight();
} else {
class_distribs[i][0] -= (inst.classValue() * inst.weight());
class_distribs[i][1] -= inst.weight();
}
ruleCount++;
}
m_classPriorCounts[(int) inst.classValue()] -= inst.weight();
}
double[] classPriors = m_classPriorCounts.clone();
Utils.normalize(classPriors);
// now classify instances
for (i = 0; i < numFold; i++) {
inst = fold.instance(i);
System.arraycopy(class_distribs[i], 0, normDist, 0, normDist.length);
if (m_classIsNominal) {
boolean ok = false;
for (int j = 0; j < normDist.length; j++) {
if (Utils.gr(normDist[j], 1.0)) {
ok = true;
break;
}
}
if (!ok) { // majority class
normDist = classPriors.clone();
}
// if (ok) {
Utils.normalize(normDist);
if (m_evaluationMeasure == EVAL_AUC) {
m_evaluation.evaluateModelOnceAndRecordPrediction(normDist, inst);
} else {
m_evaluation.evaluateModelOnce(normDist, inst);
}
/* } else {
normDist[(int)m_majority] = 1.0;
if (m_evaluationMeasure == EVAL_AUC) {
m_evaluation.evaluateModelOnceAndRecordPrediction(normDist, inst);
} else {
m_evaluation.evaluateModelOnce(normDist, inst);
}
} */
} else {
if (Utils.eq(normDist[1], 0.0)) {
double[] temp = new double[1];
temp[0] = m_majority;
m_evaluation.evaluateModelOnce(temp, inst);
} else {
double[] temp = new double[1];
temp[0] = normDist[0] / normDist[1];
m_evaluation.evaluateModelOnce(temp, inst);
}
}
}
// now re-insert instances
for (i = 0; i < numFold; i++) {
inst = fold.instance(i);
m_classPriorCounts[(int) inst.classValue()] += inst.weight();
if (m_classIsNominal) {
class_distribs[i][(int) inst.classValue()] += inst.weight();
} else {
class_distribs[i][0] += (inst.classValue() * inst.weight());
class_distribs[i][1] += inst.weight();
}
}
return acc;
}
/**
* Returns a description of the classifier.
*
* @return a description of the classifier as a string.
*/
public String toString() {
if (m_entries == null) {
return "Decision Table: No model built yet.";
} else {
StringBuffer text = new StringBuffer();
text.append(
"Decision Table:"
+ "\n\nNumber of training instances: "
+ m_numInstances
+ "\nNumber of Rules : "
+ m_entries.size()
+ "\n");
if (m_useIBk) {
text.append("Non matches covered by IB1.\n");
} else {
text.append("Non matches covered by Majority class.\n");
}
text.append(m_search.toString());
/*text.append("Best first search for feature set,\nterminated after "+
m_maxStale+" non improving subsets.\n"); */
text.append("Evaluation (for feature selection): CV ");
if (m_CVFolds > 1) {
text.append("(" + m_CVFolds + " fold) ");
} else {
text.append("(leave one out) ");
}
text.append("\nFeature set: " + printFeatures());
if (m_displayRules) {
// find out the max column width
int maxColWidth = 0;
for (int i = 0; i < m_dtInstances.numAttributes(); i++) {
if (m_dtInstances.attribute(i).name().length() > maxColWidth) {
maxColWidth = m_dtInstances.attribute(i).name().length();
}
if (m_classIsNominal || (i != m_dtInstances.classIndex())) {
Enumeration e = m_dtInstances.attribute(i).enumerateValues();
while (e.hasMoreElements()) {
String ss = (String) e.nextElement();
if (ss.length() > maxColWidth) {
maxColWidth = ss.length();
}
}
}
}
text.append("\n\nRules:\n");
StringBuffer tm = new StringBuffer();
for (int i = 0; i < m_dtInstances.numAttributes(); i++) {
if (m_dtInstances.classIndex() != i) {
int d = maxColWidth - m_dtInstances.attribute(i).name().length();
tm.append(m_dtInstances.attribute(i).name());
for (int j = 0; j < d + 1; j++) {
tm.append(" ");
}
}
}
tm.append(m_dtInstances.attribute(m_dtInstances.classIndex()).name() + " ");
for (int i = 0; i < tm.length() + 10; i++) {
text.append("=");
}
text.append("\n");
text.append(tm);
text.append("\n");
for (int i = 0; i < tm.length() + 10; i++) {
text.append("=");
}
text.append("\n");
Enumeration e = m_entries.keys();
while (e.hasMoreElements()) {
DecisionTableHashKey tt = (DecisionTableHashKey) e.nextElement();
text.append(tt.toString(m_dtInstances, maxColWidth));
double[] ClassDist = (double[]) m_entries.get(tt);
if (m_classIsNominal) {
int m = Utils.maxIndex(ClassDist);
try {
text.append(m_dtInstances.classAttribute().value(m) + "\n");
} catch (Exception ee) {
System.out.println(ee.getMessage());
}
} else {
text.append((ClassDist[0] / ClassDist[1]) + "\n");
}
}
for (int i = 0; i < tm.length() + 10; i++) {
text.append("=");
}
text.append("\n");
text.append("\n");
}
return text.toString();
}
}
/**
* Generates the classifier.
*
* @param data set of instances serving as training data
* @throws Exception if the classifier has not been generated successfully
*/
public void buildClassifier(Instances data) throws Exception {
// can classifier handle the data?
getCapabilities().testWithFail(data);
// remove instances with missing class
m_theInstances = new Instances(data);
m_theInstances.deleteWithMissingClass();
m_rr = new Random(1);
if (m_theInstances.classAttribute().isNominal()) { // Set up class priors
m_classPriorCounts = new double[data.classAttribute().numValues()];
Arrays.fill(m_classPriorCounts, 1.0);
for (int i = 0; i < data.numInstances(); i++) {
Instance curr = data.instance(i);
m_classPriorCounts[(int) curr.classValue()] += curr.weight();
}
m_classPriors = m_classPriorCounts.clone();
Utils.normalize(m_classPriors);
}
setUpEvaluator();
if (m_theInstances.classAttribute().isNumeric()) {
m_disTransform = new weka.filters.unsupervised.attribute.Discretize();
m_classIsNominal = false;
// use binned discretisation if the class is numeric
((weka.filters.unsupervised.attribute.Discretize) m_disTransform).setBins(10);
((weka.filters.unsupervised.attribute.Discretize) m_disTransform).setInvertSelection(true);
// Discretize all attributes EXCEPT the class
String rangeList = "";
rangeList += (m_theInstances.classIndex() + 1);
// System.out.println("The class col: "+m_theInstances.classIndex());
((weka.filters.unsupervised.attribute.Discretize) m_disTransform)
.setAttributeIndices(rangeList);
} else {
m_disTransform = new weka.filters.supervised.attribute.Discretize();
((weka.filters.supervised.attribute.Discretize) m_disTransform).setUseBetterEncoding(true);
m_classIsNominal = true;
}
m_disTransform.setInputFormat(m_theInstances);
m_theInstances = Filter.useFilter(m_theInstances, m_disTransform);
m_numAttributes = m_theInstances.numAttributes();
m_numInstances = m_theInstances.numInstances();
m_majority = m_theInstances.meanOrMode(m_theInstances.classAttribute());
// Perform the search
int[] selected = m_search.search(m_evaluator, m_theInstances);
m_decisionFeatures = new int[selected.length + 1];
System.arraycopy(selected, 0, m_decisionFeatures, 0, selected.length);
m_decisionFeatures[m_decisionFeatures.length - 1] = m_theInstances.classIndex();
// reduce instances to selected features
m_delTransform = new Remove();
m_delTransform.setInvertSelection(true);
// set features to keep
m_delTransform.setAttributeIndicesArray(m_decisionFeatures);
m_delTransform.setInputFormat(m_theInstances);
m_dtInstances = Filter.useFilter(m_theInstances, m_delTransform);
// reset the number of attributes
m_numAttributes = m_dtInstances.numAttributes();
// create hash table
m_entries = new Hashtable((int) (m_dtInstances.numInstances() * 1.5));
// insert instances into the hash table
for (int i = 0; i < m_numInstances; i++) {
Instance inst = m_dtInstances.instance(i);
insertIntoTable(inst, null);
}
// Replace the global table majority with nearest neighbour?
if (m_useIBk) {
m_ibk = new IBk();
m_ibk.buildClassifier(m_theInstances);
}
// Save memory
if (m_saveMemory) {
m_theInstances = new Instances(m_theInstances, 0);
m_dtInstances = new Instances(m_dtInstances, 0);
}
m_evaluation = null;
}
