/**
* Parses a given list of options.
*
* @param options the list of options as an array of strings
* @exception Exception if an option is not supported
*/
public void setOptions(String[] options) throws Exception {
String optionString = Utils.getOption('A', options);
if (optionString.length() != 0) setAlphaStar(Double.parseDouble(optionString));
optionString = Utils.getOption('S', options);
if (optionString.length() != 0) setSigma(Double.parseDouble(optionString));
optionString = Utils.getOption('R', options);
if (optionString.length() != 0) setR(Double.parseDouble(optionString));
setUseSparseMatrix(Utils.getFlag('M', options));
}
/**
* Parses a given list of options.
*
* @param options the list of options as an array of strings
* @exception Exception if an option is not supported
*/
public void setOptions(String[] options) throws Exception {
// Other options
String minNumString = Utils.getOption('M', options);
if (minNumString.length() != 0) {
m_minNumObj = Integer.parseInt(minNumString);
} else {
m_minNumObj = 2;
}
m_binarySplits = Utils.getFlag('B', options);
m_useLaplace = Utils.getFlag('A', options);
// Pruning options
m_unpruned = Utils.getFlag('U', options);
m_subtreeRaising = !Utils.getFlag('S', options);
m_noCleanup = Utils.getFlag('L', options);
if ((m_unpruned) && (!m_subtreeRaising)) {
throw new Exception("Subtree raising doesn't need to be unset for unpruned tree!");
}
m_reducedErrorPruning = Utils.getFlag('R', options);
if ((m_unpruned) && (m_reducedErrorPruning)) {
throw new Exception(
"Unpruned tree and reduced error pruning can't be selected " + "simultaneously!");
}
String confidenceString = Utils.getOption('C', options);
if (confidenceString.length() != 0) {
if (m_reducedErrorPruning) {
throw new Exception(
"Setting the confidence doesn't make sense " + "for reduced error pruning.");
} else if (m_unpruned) {
throw new Exception("Doesn't make sense to change confidence for unpruned " + "tree!");
} else {
m_CF = (new Float(confidenceString)).floatValue();
if ((m_CF <= 0) || (m_CF >= 1)) {
throw new Exception("Confidence has to be greater than zero and smaller " + "than one!");
}
}
} else {
m_CF = 0.25f;
}
String numFoldsString = Utils.getOption('N', options);
if (numFoldsString.length() != 0) {
if (!m_reducedErrorPruning) {
throw new Exception(
"Setting the number of folds"
+ " doesn't make sense if"
+ " reduced error pruning is not selected.");
} else {
m_numFolds = Integer.parseInt(numFoldsString);
}
} else {
m_numFolds = 3;
}
}
/**
* Parses a given list of options.
*
* @param options the list of options as an array of strings
* @exception Exception if an option is not supported
*/
public void setOptions(String[] options) throws Exception {
String optionString = Utils.getOption('N', options);
if (optionString.length() != 0) {
setNumClusters(Integer.parseInt(optionString));
}
optionString = Utils.getOption('S', options);
if (optionString.length() != 0) {
setSeed(Integer.parseInt(optionString));
}
}
/**
* Parses a given list of options. Valid options are:
*
* <p>-D <br>
* Turn on debugging output.
*
* <p>-W classname <br>
* Specify the full class name of a weak classifier as the basis for Decorate (required).
*
* <p>-E num <br>
* Specify the desired size of the committee (default 10).
*
* <p>-I iterations <br>
* Set the maximum number of Decorate iterations (default 10).
*
* <p>-S seed <br>
* Seed for random number generator. (default 0).
*
* <p>-R factor <br>
* Factor that determines number of artificial examples to generate.
*
* <p>Options after -- are passed to the designated classifier.
*
* <p>
*
* @param options the list of options as an array of strings
* @exception Exception if an option is not supported
*/
public void setOptions(String[] options) throws Exception {
String desiredSize = Utils.getOption('E', options);
if (desiredSize.length() != 0) {
setDesiredSize(Integer.parseInt(desiredSize));
} else {
setDesiredSize(10);
}
String artSize = Utils.getOption('R', options);
if (artSize.length() != 0) {
setArtificialSize(Double.parseDouble(artSize));
} else {
setArtificialSize(1.0);
}
super.setOptions(options);
}
/**
* 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());
}
/**
* Parses a given list of options. Valid options are:
*
* <p>-D <br>
* Turn on debugging output.
*
* <p>-S seed <br>
* Random number seed (default 1).
*
* <p>-B classifierstring <br>
* Classifierstring should contain the full class name of a scheme included for selection followed
* by options to the classifier (required, option should be used once for each classifier).
*
* <p>-X num_folds <br>
* Use cross validation error as the basis for classifier selection. (default 0, is to use error
* on the training data instead)
*
* <p>
*
* @param options the list of options as an array of strings
* @exception Exception if an option is not supported
*/
public void setOptions(String[] options) throws Exception {
setDebug(Utils.getFlag('D', options));
String numFoldsString = Utils.getOption('X', options);
if (numFoldsString.length() != 0) {
setNumFolds(Integer.parseInt(numFoldsString));
} else {
setNumFolds(0);
}
String randomString = Utils.getOption('S', options);
if (randomString.length() != 0) {
setSeed(Integer.parseInt(randomString));
} else {
setSeed(1);
}
// Iterate through the schemes
FastVector classifiers = new FastVector();
while (true) {
String classifierString = Utils.getOption('B', options);
if (classifierString.length() == 0) {
break;
}
String[] classifierSpec = Utils.splitOptions(classifierString);
if (classifierSpec.length == 0) {
throw new Exception("Invalid classifier specification string");
}
String classifierName = classifierSpec[0];
classifierSpec[0] = "";
classifiers.addElement(Classifier.forName(classifierName, classifierSpec));
}
if (classifiers.size() <= 1) {
throw new Exception("At least two classifiers must be specified" + " with the -B option.");
} else {
Classifier[] classifiersArray = new Classifier[classifiers.size()];
for (int i = 0; i < classifiersArray.length; i++) {
classifiersArray[i] = (Classifier) classifiers.elementAt(i);
}
setClassifiers(classifiersArray);
}
}
/**
* Parses the options for this object.
*
* <p>
* <!-- options-start -->
* Valid options are:
*
* <p>
*
* <pre> -S <search method specification>
* Full class name of search method, followed
* by its options.
* eg: "weka.attributeSelection.BestFirst -D 1"
* (default weka.attributeSelection.BestFirst)</pre>
*
* <pre> -X <number of folds>
* Use cross validation to evaluate features.
* Use number of folds = 1 for leave one out CV.
* (Default = leave one out CV)</pre>
*
* <pre> -E <acc | rmse | mae | auc>
* Performance evaluation measure to use for selecting attributes.
* (Default = accuracy for discrete class and rmse for numeric class)</pre>
*
* <pre> -I
* Use nearest neighbour instead of global table majority.</pre>
*
* <pre> -R
* Display decision table rules.
* </pre>
*
* <pre>
* Options specific to search method weka.attributeSelection.BestFirst:
* </pre>
*
* <pre> -P <start set>
* Specify a starting set of attributes.
* Eg. 1,3,5-7.</pre>
*
* <pre> -D <0 = backward | 1 = forward | 2 = bi-directional>
* Direction of search. (default = 1).</pre>
*
* <pre> -N <num>
* Number of non-improving nodes to
* consider before terminating search.</pre>
*
* <pre> -S <num>
* Size of lookup cache for evaluated subsets.
* Expressed as a multiple of the number of
* attributes in the data set. (default = 1)</pre>
*
* <!-- options-end -->
*
* @param options the list of options as an array of strings
* @throws Exception if an option is not supported
*/
public void setOptions(String[] options) throws Exception {
String optionString;
resetOptions();
optionString = Utils.getOption('X', options);
if (optionString.length() != 0) {
m_CVFolds = Integer.parseInt(optionString);
}
m_useIBk = Utils.getFlag('I', options);
m_displayRules = Utils.getFlag('R', options);
optionString = Utils.getOption('E', options);
if (optionString.length() != 0) {
if (optionString.equals("acc")) {
setEvaluationMeasure(new SelectedTag(EVAL_ACCURACY, TAGS_EVALUATION));
} else if (optionString.equals("rmse")) {
setEvaluationMeasure(new SelectedTag(EVAL_RMSE, TAGS_EVALUATION));
} else if (optionString.equals("mae")) {
setEvaluationMeasure(new SelectedTag(EVAL_MAE, TAGS_EVALUATION));
} else if (optionString.equals("auc")) {
setEvaluationMeasure(new SelectedTag(EVAL_AUC, TAGS_EVALUATION));
} else {
throw new IllegalArgumentException("Invalid evaluation measure");
}
}
String searchString = Utils.getOption('S', options);
if (searchString.length() == 0)
searchString = weka.attributeSelection.BestFirst.class.getName();
String[] searchSpec = Utils.splitOptions(searchString);
if (searchSpec.length == 0) {
throw new IllegalArgumentException("Invalid search specification string");
}
String searchName = searchSpec[0];
searchSpec[0] = "";
setSearch(ASSearch.forName(searchName, searchSpec));
}