/**
* Parses a given list of options.
*
* <p>
* <!-- options-start -->
* Valid options are:
*
* <p>
*
* <pre> -A
* The nearest neighbour search algorithm to use (default: weka.core.neighboursearch.LinearNNSearch).
* </pre>
*
* <pre> -K <number of neighbours>
* Set the number of neighbours used to set the kernel bandwidth.
* (default all)</pre>
*
* <pre> -U <number of weighting method>
* Set the weighting kernel shape to use. 0=Linear, 1=Epanechnikov,
* 2=Tricube, 3=Inverse, 4=Gaussian.
* (default 0 = Linear)</pre>
*
* <pre> -D
* If set, classifier is run in debug mode and
* may output additional info to the console</pre>
*
* <pre> -W
* Full name of base classifier.
* (default: weka.classifiers.trees.DecisionStump)</pre>
*
* <pre>
* Options specific to classifier weka.classifiers.trees.DecisionStump:
* </pre>
*
* <pre> -D
* If set, classifier is run in debug mode and
* may output additional info to the console</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 knnString = Utils.getOption('K', options);
if (knnString.length() != 0) {
setKNN(Integer.parseInt(knnString));
} else {
setKNN(-1);
}
String weightString = Utils.getOption('U', options);
if (weightString.length() != 0) {
setWeightingKernel(Integer.parseInt(weightString));
} else {
setWeightingKernel(LINEAR);
}
String nnSearchClass = Utils.getOption('A', options);
if (nnSearchClass.length() != 0) {
String nnSearchClassSpec[] = Utils.splitOptions(nnSearchClass);
if (nnSearchClassSpec.length == 0) {
throw new Exception("Invalid NearestNeighbourSearch algorithm " + "specification string.");
}
String className = nnSearchClassSpec[0];
nnSearchClassSpec[0] = "";
setNearestNeighbourSearchAlgorithm(
(NearestNeighbourSearch)
Utils.forName(NearestNeighbourSearch.class, className, nnSearchClassSpec));
} else this.setNearestNeighbourSearchAlgorithm(new LinearNNSearch());
super.setOptions(options);
}
@Override
public void setOptions(String[] options) throws Exception {
// these are options to the hadoop map task (especially the -names-file)
String existing = Utils.getOption("existing-header", options);
setPathToExistingHeader(existing);
String attNames = Utils.getOption('A', options);
setAttributeNames(attNames);
String namesFile = Utils.getOption("names-file", options);
setAttributeNamesFile(namesFile);
String outputName = Utils.getOption("header-file-name", options);
setOutputHeaderFileName(outputName);
super.setOptions(options);
// any options to pass on to the underlying Weka csv to arff map task?
CSVToARFFHeaderMapTask tempMap = new CSVToARFFHeaderMapTask();
tempMap.setOptions(options);
String optsToWekaMapTask = Utils.joinOptions(tempMap.getOptions());
if (!DistributedJobConfig.isEmpty(optsToWekaMapTask)) {
setCsvToArffTaskOptions(optsToWekaMapTask);
}
}
/**
* Parses a given list of options.
*
* <p>
* <!-- options-start -->
* Valid options are:
*
* <p>
*
* <pre> -find <regexp>
* The regular expression that the attribute names must match.
* (default: ([\s\S]+))</pre>
*
* <pre> -replace <string>
* The string to replace the regular expression of matching attributes with.
* Cannot be used in conjunction with '-remove'.
* (default: $0)</pre>
*
* <pre> -remove
* In case the matching string needs to be removed instead of replaced.
* Cannot be used in conjunction with '-replace <string>'.
* (default: off)</pre>
*
* <pre> -all
* Replaces all occurrences instead of just the first.
* (default: only first occurrence)</pre>
*
* <pre> -R <range>
* The attribute range to work on.
* This is a comma separated list of attribute indices, with "first" and "last" valid values.
* Specify an inclusive range with "-".
* E.g: "first-3,5,6-10,last".
* (default: first-last)</pre>
*
* <pre> -V
* Inverts the attribute selection range.
* (default: off)</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 tmpStr;
tmpStr = Utils.getOption("find", options);
if (tmpStr.length() != 0) setFind(tmpStr);
else setFind("([\\s\\S]+)");
if (Utils.getFlag("remove", options)) {
setReplace("");
} else {
tmpStr = Utils.getOption("replace", options);
if (tmpStr.length() > 0) setReplace(tmpStr);
else setReplace("$0");
}
setReplaceAll(Utils.getFlag("all", options));
tmpStr = Utils.getOption("R", options);
if (tmpStr.length() != 0) setAttributeIndices(tmpStr);
else setAttributeIndices("first-last");
setInvertSelection(Utils.getFlag("V", options));
if (getInputFormat() != null) setInputFormat(getInputFormat());
}
/**
* Sets the options.
*
* @param options the options
* @throws Exception if invalid option
*/
@Override
public void setOptions(String[] options) throws Exception {
String tmpStr;
super.setOptions(options);
tmpStr = Utils.getOption('a', options);
if (tmpStr.length() != 0) {
setNumAttributes(Integer.parseInt(tmpStr));
} else {
setNumAttributes(defaultNumAttributes());
}
setClassFlag(Utils.getFlag('c', options));
tmpStr = Utils.getOption('b', options);
setBooleanIndices(tmpStr);
m_booleanCols.setUpper(getNumAttributes() - 1);
tmpStr = Utils.getOption('m', options);
setNominalIndices(tmpStr);
m_nominalCols.setUpper(getNumAttributes() - 1);
// check indices
tmpStr = checkIndices();
if (tmpStr.length() > 0) {
throw new IllegalArgumentException(tmpStr);
}
}
/**
* Parses a given list of options.
*
* <p>
* <!-- options-start -->
* Valid options are:
*
* <p>
*
* <pre> -B <num>
* Manual blend setting (default 20%)
* </pre>
*
* <pre> -E
* Enable entropic auto-blend setting (symbolic class only)
* </pre>
*
* <pre> -M <char>
* Specify the missing value treatment mode (default a)
* Valid options are: a(verage), d(elete), m(axdiff), n(ormal)
* </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 debug = "(KStar.setOptions)";
String blendStr = Utils.getOption('B', options);
if (blendStr.length() != 0) {
setGlobalBlend(Integer.parseInt(blendStr));
}
setEntropicAutoBlend(Utils.getFlag('E', options));
String missingModeStr = Utils.getOption('M', options);
if (missingModeStr.length() != 0) {
switch (missingModeStr.charAt(0)) {
case 'a':
setMissingMode(new SelectedTag(M_AVERAGE, TAGS_MISSING));
break;
case 'd':
setMissingMode(new SelectedTag(M_DELETE, TAGS_MISSING));
break;
case 'm':
setMissingMode(new SelectedTag(M_MAXDIFF, TAGS_MISSING));
break;
case 'n':
setMissingMode(new SelectedTag(M_NORMAL, TAGS_MISSING));
break;
default:
setMissingMode(new SelectedTag(M_AVERAGE, TAGS_MISSING));
}
}
Utils.checkForRemainingOptions(options);
}
/**
* Parses a given list of options.
*
* <p>
* <!-- options-start -->
* Valid options are:
*
* <p>
*
* <pre> -M
* Minimize expected misclassification cost. Default is to
* reweight training instances according to costs per class</pre>
*
* <pre> -C <cost file name>
* File name of a cost matrix to use. If this is not supplied,
* a cost matrix will be loaded on demand. The name of the
* on-demand file is the relation name of the training data
* plus ".cost", and the path to the on-demand file is
* specified with the -N option.</pre>
*
* <pre> -N <directory>
* Name of a directory to search for cost files when loading
* costs on demand (default current directory).</pre>
*
* <pre> -cost-matrix <matrix>
* The cost matrix in Matlab single line format.</pre>
*
* <pre> -S <num>
* Random number seed.
* (default 1)</pre>
*
* <pre> -D
* If set, classifier is run in debug mode and
* may output additional info to the console</pre>
*
* <pre> -W
* Full name of base classifier.
* (default: weka.classifiers.rules.ZeroR)</pre>
*
* <pre>
* Options specific to classifier weka.classifiers.rules.ZeroR:
* </pre>
*
* <pre> -D
* If set, classifier is run in debug mode and
* may output additional info to the console</pre>
*
* <!-- options-end -->
* Options after -- are passed to the designated classifier.
*
* <p>
*
* @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 {
setMinimizeExpectedCost(Utils.getFlag('M', options));
String costFile = Utils.getOption('C', options);
if (costFile.length() != 0) {
try {
setCostMatrix(new CostMatrix(new BufferedReader(new FileReader(costFile))));
} catch (Exception ex) {
// now flag as possible old format cost matrix. Delay cost matrix
// loading until buildClassifer is called
setCostMatrix(null);
}
setCostMatrixSource(new SelectedTag(MATRIX_SUPPLIED, TAGS_MATRIX_SOURCE));
m_CostFile = costFile;
} else {
setCostMatrixSource(new SelectedTag(MATRIX_ON_DEMAND, TAGS_MATRIX_SOURCE));
}
String demandDir = Utils.getOption('N', options);
if (demandDir.length() != 0) {
setOnDemandDirectory(new File(demandDir));
}
String cost_matrix = Utils.getOption("cost-matrix", options);
if (cost_matrix.length() != 0) {
StringWriter writer = new StringWriter();
CostMatrix.parseMatlab(cost_matrix).write(writer);
setCostMatrix(new CostMatrix(new StringReader(writer.toString())));
setCostMatrixSource(new SelectedTag(MATRIX_SUPPLIED, TAGS_MATRIX_SOURCE));
}
super.setOptions(options);
}
/**
* Parses a given list of options.
*
* <p>
* <!-- options-start -->
* Valid options are:
*
* <p>
*
* <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('P', options);
if (optionString.length() != 0) {
setStartSet(optionString);
}
optionString = Utils.getOption('D', options);
if (optionString.length() != 0) {
setDirection(new SelectedTag(Integer.parseInt(optionString), TAGS_SELECTION));
} else {
setDirection(new SelectedTag(SELECTION_FORWARD, TAGS_SELECTION));
}
optionString = Utils.getOption('N', options);
if (optionString.length() != 0) {
setSearchTermination(Integer.parseInt(optionString));
}
optionString = Utils.getOption('S', options);
if (optionString.length() != 0) {
setLookupCacheSize(Integer.parseInt(optionString));
}
m_debug = Utils.getFlag('Z', options);
}
/**
* Parses a given list of options.
*
* <p>
* <!-- options-start -->
* Valid options are:
*
* <p>
*
* <pre> -C <col>
* Index of the attribute to be changed
* (default last attribute)</pre>
*
* <pre> -M
* Treat missing values as an extra value
* </pre>
*
* <pre> -P <num>
* Specify the percentage of noise introduced
* to the data (default 10)</pre>
*
* <pre> -S <num>
* Specify the random number seed (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 indexString = Utils.getOption('C', options);
if (indexString.length() != 0) {
setAttributeIndex(indexString);
} else {
setAttributeIndex("last");
}
if (Utils.getFlag('M', options)) {
setUseMissing(true);
}
String percentString = Utils.getOption('P', options);
if (percentString.length() != 0) {
setPercent((int) Double.valueOf(percentString).doubleValue());
} else {
setPercent(10);
}
String seedString = Utils.getOption('S', options);
if (seedString.length() != 0) {
setRandomSeed(Integer.parseInt(seedString));
} else {
setRandomSeed(1);
}
}
/**
* Parses a given list of options.
*
* <p>
* <!-- options-start -->
* Valid options are:
*
* <p>
*
* <pre> -B
* Binary splits (convert nominal attributes to binary ones) </pre>
*
* <pre> -P
* Use error on probabilities instead of misclassification error for stopping criterion of LogitBoost.
* </pre>
*
* <pre> -I <numIterations>
* Set fixed number of iterations for LogitBoost (instead of using cross-validation)</pre>
*
* <pre> -F <modelType>
* Set Funtional Tree type to be generate: 0 for FT, 1 for FTLeaves and 2 for FTInner</pre>
*
* <pre> -M <numInstances>
* Set minimum number of instances at which a node can be split (default 15)</pre>
*
* <pre> -W <beta>
* Set beta for weight trimming for LogitBoost. Set to 0 (default) for no weight trimming.</pre>
*
* <pre> -A
* The AIC is used to choose the best iteration.</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 {
setBinSplit(Utils.getFlag('B', options));
setErrorOnProbabilities(Utils.getFlag('P', options));
String optionString = Utils.getOption('I', options);
if (optionString.length() != 0) {
setNumBoostingIterations((new Integer(optionString)).intValue());
}
optionString = Utils.getOption('F', options);
if (optionString.length() != 0) {
setModelType(new SelectedTag(Integer.parseInt(optionString), TAGS_MODEL));
// setModelType((new Integer(optionString)).intValue());
}
optionString = Utils.getOption('M', options);
if (optionString.length() != 0) {
setMinNumInstances((new Integer(optionString)).intValue());
}
optionString = Utils.getOption('W', options);
if (optionString.length() != 0) {
setWeightTrimBeta((new Double(optionString)).doubleValue());
}
setUseAIC(Utils.getFlag('A', options));
Utils.checkForRemainingOptions(options);
}
/**
* Parses a given list of options.
*
* <p>
* <!-- options-start -->
* Valid options are:
*
* <p>
*
* <pre> -T <NUM|NOM|STR|DAT>
* The type of attribute to create:
* NUM = Numeric attribute
* NOM = Nominal attribute
* STR = String attribute
* DAT = Date attribute
* (default: NUM)</pre>
*
* <pre> -C <index>
* Specify where to insert the column. First and last
* are valid indexes.(default: last)</pre>
*
* <pre> -N <name>
* Name of the new attribute.
* (default: 'Unnamed')</pre>
*
* <pre> -L <label1,label2,...>
* Create nominal attribute with given labels
* (default: numeric attribute)</pre>
*
* <pre> -F <format>
* The format of the date values (see ISO-8601)
* (default: yyyy-MM-dd'T'HH:mm:ss)</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 tmpStr;
tmpStr = Utils.getOption('T', options);
if (tmpStr.length() != 0) setAttributeType(new SelectedTag(tmpStr, TAGS_TYPE));
else setAttributeType(new SelectedTag(Attribute.NUMERIC, TAGS_TYPE));
tmpStr = Utils.getOption('C', options);
if (tmpStr.length() == 0) tmpStr = "last";
setAttributeIndex(tmpStr);
setAttributeName(Utils.unbackQuoteChars(Utils.getOption('N', options)));
if (m_AttributeType == Attribute.NOMINAL) {
tmpStr = Utils.getOption('L', options);
if (tmpStr.length() != 0) setNominalLabels(tmpStr);
} else if (m_AttributeType == Attribute.DATE) {
tmpStr = Utils.getOption('F', options);
if (tmpStr.length() != 0) setDateFormat(tmpStr);
}
if (getInputFormat() != null) {
setInputFormat(getInputFormat());
}
}
/**
* Parses a given list of options.
*
* <p>
* <!-- options-start -->
* Valid options are:
*
* <p>
*
* <pre> -R <col1,col2-col4,...>
* Specifies list of columns to Discretize. First and last are valid indexes.
* (default none)</pre>
*
* <pre> -V
* Invert matching sense of column indexes.</pre>
*
* <pre> -D
* Output binary attributes for discretized attributes.</pre>
*
* <pre> -Y
* Use bin numbers rather than ranges for discretized attributes.</pre>
*
* <pre> -E
* Use better encoding of split point for MDL.</pre>
*
* <pre> -K
* Use Kononenko's MDL criterion.</pre>
*
* <pre> -precision <integer>
* Precision for bin boundary labels.
* (default = 6 decimal places).</pre>
*
* <!-- options-end -->
*
* @param options the list of options as an array of strings
* @throws Exception if an option is not supported
*/
@Override
public void setOptions(String[] options) throws Exception {
setMakeBinary(Utils.getFlag('D', options));
setUseBinNumbers(Utils.getFlag('Y', options));
setUseBetterEncoding(Utils.getFlag('E', options));
setUseKononenko(Utils.getFlag('K', options));
setInvertSelection(Utils.getFlag('V', options));
String convertList = Utils.getOption('R', options);
if (convertList.length() != 0) {
setAttributeIndices(convertList);
} else {
setAttributeIndices("first-last");
}
String precisionS = Utils.getOption("precision", options);
if (precisionS.length() > 0) {
setBinRangePrecision(Integer.parseInt(precisionS));
}
if (getInputFormat() != null) {
setInputFormat(getInputFormat());
}
Utils.checkForRemainingOptions(options);
}
/**
* Parses a given list of options controlling the behaviour of this object. Valid options are:
*
* <p>-l "directory name"<br>
* Specifies name of directory.
*
* <p>-m "model name"<br>
* Specifies name of model.
*
* <p>-e "encoding"<br>
* Specifies encoding.
*
* <p>-n<br>
* Specifies number of phrases to be output (default: 5).
*
* <p>-d<br>
* Turns debugging mode on.
*
* <p>-a<br>
* Also write stemmed phrase and score into ".key" file.
*
* <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 dirName = Utils.getOption('l', options);
if (dirName.length() > 0) {
setDirName(dirName);
} else {
setDirName(null);
throw new Exception("Name of directory required argument.");
}
String modelName = Utils.getOption('m', options);
if (modelName.length() > 0) {
setModelName(modelName);
} else {
setModelName(null);
throw new Exception("Name of model required argument.");
}
String encoding = Utils.getOption('e', options);
if (encoding.length() > 0) {
setEncoding(encoding);
} else {
setEncoding("default");
}
String numPhrases = Utils.getOption('n', options);
if (numPhrases.length() > 0) {
setNumPhrases(Integer.parseInt(numPhrases));
} else {
setNumPhrases(5);
}
setDebug(Utils.getFlag('d', options));
setAdditionalInfo(Utils.getFlag('a', options));
Utils.checkForRemainingOptions(options);
}
/**
* Parses a given list of options.
*
* <p>
* <!-- options-start -->
* Valid options are:
*
* <p>
*
* <pre> -C <col>
* Sets the attribute index (default last).</pre>
*
* <pre> -F <value index>
* Sets the first value's index (default first).</pre>
*
* <pre> -S <value index>
* Sets the second value's index (default last).</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 attIndex = Utils.getOption('C', options);
if (attIndex.length() != 0) {
setAttributeIndex(attIndex);
} else {
setAttributeIndex("last");
}
String firstValIndex = Utils.getOption('F', options);
if (firstValIndex.length() != 0) {
setFirstValueIndex(firstValIndex);
} else {
setFirstValueIndex("first");
}
String secondValIndex = Utils.getOption('S', options);
if (secondValIndex.length() != 0) {
setSecondValueIndex(secondValIndex);
} else {
setSecondValueIndex("last");
}
if (getInputFormat() != null) {
setInputFormat(getInputFormat());
}
}
/**
* Parses a given list of options.
*
* <p>
* <!-- options-start -->
* Valid options are:
*
* <p>
*
* <pre> -L <double>
* The epsilon parameter in epsilon-insensitive loss function.
* (default 1.0e-3)</pre>
*
* <pre> -W <double>
* The random number seed.
* (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 tmpStr;
tmpStr = Utils.getOption('L', options);
if (tmpStr.length() != 0) {
setEpsilonParameter(Double.parseDouble(tmpStr));
} else {
setEpsilonParameter(1.0e-3);
}
/*
tmpStr = Utils.getOption('S', options);
if (tmpStr.length() != 0)
setLossType(new SelectedTag(tmpStr, TAGS_LOSS_TYPE));
else
setLossType(new SelectedTag(EPSILON, TAGS_LOSS_TYPE));
*/
tmpStr = Utils.getOption('W', options);
if (tmpStr.length() != 0) {
setSeed(Integer.parseInt(tmpStr));
} else {
setSeed(1);
}
}
/**
* Parses a given list of options.
* <!-- options-start -->
* Valid options are:
*
* <p>
*
* <pre>
* -S <num>
* Specifies the random number seed
* (default 1)
* </pre>
*
* <pre>
* -P <percentage>
* Specifies percentage of SMOTE instances to create.
* (default 100.0)
* </pre>
*
* <pre>
* -K <nearest-neighbors>
* Specifies the number of nearest neighbors to use.
* (default 5)
* </pre>
*
* <pre>
* -C <value-index>
* Specifies the index of the nominal class value to SMOTE
* (default 0: auto-detect non-empty minority class))
* </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 seedStr = Utils.getOption('S', options);
if (seedStr.length() != 0) {
setRandomSeed(Integer.parseInt(seedStr));
} else {
setRandomSeed(1);
}
String percentageStr = Utils.getOption('P', options);
if (percentageStr.length() != 0) {
setPercentage(new Double(percentageStr).doubleValue());
} else {
setPercentage(100.0);
}
String nnStr = Utils.getOption('K', options);
if (nnStr.length() != 0) {
setNearestNeighbors(Integer.parseInt(nnStr));
} else {
setNearestNeighbors(5);
}
String classValueIndexStr = Utils.getOption('C', options);
if (classValueIndexStr.length() != 0) {
setClassValue(classValueIndexStr);
} else {
m_DetectMinorityClass = true;
}
}
/**
* Parses a given list of options.
*
* <p>
* <!-- options-start -->
* Valid options are:
*
* <p>
*
* <pre> -F <filter specification>
* Full class name of filter to use, followed
* by filter options.
* eg: "weka.filters.unsupervised.attribute.Remove -V -R 1,2"
* (default: weka.filters.MultiFilter with
* weka.filters.unsupervised.attribute.ReplaceMissingValues)</pre>
*
* <pre> -c <the class index>
* The class index.
* (default: -1, i.e. unset)</pre>
*
* <pre> -W
* Full name of base associator.
* (default: weka.associations.Apriori)</pre>
*
* <pre>
* Options specific to associator weka.associations.Apriori:
* </pre>
*
* <pre> -N <required number of rules output>
* The required number of rules. (default = 10)</pre>
*
* <pre> -T <0=confidence | 1=lift | 2=leverage | 3=Conviction>
* The metric type by which to rank rules. (default = confidence)</pre>
*
* <pre> -C <minimum metric score of a rule>
* The minimum confidence of a rule. (default = 0.9)</pre>
*
* <pre> -D <delta for minimum support>
* The delta by which the minimum support is decreased in
* each iteration. (default = 0.05)</pre>
*
* <pre> -U <upper bound for minimum support>
* Upper bound for minimum support. (default = 1.0)</pre>
*
* <pre> -M <lower bound for minimum support>
* The lower bound for the minimum support. (default = 0.1)</pre>
*
* <pre> -S <significance level>
* If used, rules are tested for significance at
* the given level. Slower. (default = no significance testing)</pre>
*
* <pre> -I
* If set the itemsets found are also output. (default = no)</pre>
*
* <pre> -R
* Remove columns that contain all missing values (default = no)</pre>
*
* <pre> -V
* Report progress iteratively. (default = no)</pre>
*
* <pre> -A
* If set class association rules are mined. (default = no)</pre>
*
* <pre> -c <the class index>
* The class index. (default = last)</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 tmpStr;
tmpStr = Utils.getOption('F', options);
if (tmpStr.length() > 0) {
String[] filterSpec = Utils.splitOptions(tmpStr);
if (filterSpec.length == 0)
throw new IllegalArgumentException("Invalid filter specification string");
String filterName = filterSpec[0];
filterSpec[0] = "";
setFilter((Filter) Utils.forName(Filter.class, filterName, filterSpec));
} else {
setFilter(new weka.filters.supervised.attribute.Discretize());
}
tmpStr = Utils.getOption('c', options);
if (tmpStr.length() > 0) {
if (tmpStr.equalsIgnoreCase("last")) {
setClassIndex(0);
} else if (tmpStr.equalsIgnoreCase("first")) {
setClassIndex(1);
} else {
setClassIndex(Integer.parseInt(tmpStr));
}
} else {
setClassIndex(-1);
}
super.setOptions(options);
}
/**
* Parses the options for this object.
*
* <p>
* <!-- options-start -->
* Valid options are:
*
* <p>
*
* <pre> -D
* Turns on output of debugging information.</pre>
*
* <pre> -A <Haar>
* The algorithm to use.
* (default: HAAR)</pre>
*
* <pre> -P <Zero>
* The padding to use.
* (default: ZERO)</pre>
*
* <pre> -F <filter specification>
* The filter to use as preprocessing step (classname and options).
* (default: MultiFilter with ReplaceMissingValues and Normalize)</pre>
*
* <pre>
* Options specific to filter weka.filters.MultiFilter ('-F'):
* </pre>
*
* <pre> -D
* Turns on output of debugging information.</pre>
*
* <pre> -F <classname [options]>
* A filter to apply (can be specified multiple times).</pre>
*
* <!-- options-end -->
*
* @param options the options to use
* @throws Exception if the option setting fails
*/
public void setOptions(String[] options) throws Exception {
String tmpStr;
String[] tmpOptions;
Filter filter;
super.setOptions(options);
tmpStr = Utils.getOption("A", options);
if (tmpStr.length() != 0) setAlgorithm(new SelectedTag(tmpStr, TAGS_ALGORITHM));
else setAlgorithm(new SelectedTag(ALGORITHM_HAAR, TAGS_ALGORITHM));
tmpStr = Utils.getOption("P", options);
if (tmpStr.length() != 0) setPadding(new SelectedTag(tmpStr, TAGS_PADDING));
else setPadding(new SelectedTag(PADDING_ZERO, TAGS_PADDING));
tmpStr = Utils.getOption("F", options);
tmpOptions = Utils.splitOptions(tmpStr);
if (tmpOptions.length != 0) {
tmpStr = tmpOptions[0];
tmpOptions[0] = "";
setFilter((Filter) Utils.forName(Filter.class, tmpStr, tmpOptions));
} else {
filter = new MultiFilter();
((MultiFilter) filter)
.setFilters(
new Filter[] {
new weka.filters.unsupervised.attribute.ReplaceMissingValues(),
new weka.filters.unsupervised.attribute.Normalize()
});
setFilter(filter);
}
}
/**
* 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.
*
* <p>
* <!-- options-start -->
* Valid options are:
*
* <p>
*
* <pre> -i <the input file>
* The input file</pre>
*
* <pre> -o <the output file>
* The output file</pre>
*
* <pre> -c <the class index>
* The class index</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 outputString = Utils.getOption('o', options);
String inputString = Utils.getOption('i', options);
String indexString = Utils.getOption('c', options);
ArffLoader loader = new ArffLoader();
resetOptions();
// parse index
int index = -1;
if (indexString.length() != 0) {
if (indexString.equals("first")) index = 0;
else {
if (indexString.equals("last")) index = -1;
else index = Integer.parseInt(indexString);
}
}
if (inputString.length() != 0) {
try {
File input = new File(inputString);
loader.setFile(input);
Instances inst = loader.getDataSet();
if (index == -1) inst.setClassIndex(inst.numAttributes() - 1);
else inst.setClassIndex(index);
setInstances(inst);
} catch (Exception ex) {
throw new IOException(
"No data set loaded. Data set has to be arff format (Reason: " + ex.toString() + ").");
}
} else throw new IOException("No data set to save.");
if (outputString.length() != 0) {
// add appropriate file extension
if (!outputString.endsWith(getFileExtension())) {
if (outputString.lastIndexOf('.') != -1)
outputString =
(outputString.substring(0, outputString.lastIndexOf('.'))) + getFileExtension();
else outputString = outputString + getFileExtension();
}
try {
File output = new File(outputString);
setFile(output);
} catch (Exception ex) {
throw new IOException("Cannot create output file.");
}
}
if (index == -1) index = getInstances().numAttributes() - 1;
getInstances().setClassIndex(index);
}
/**
* Parses a given list of options.
*
* <p>
* <!-- options-start -->
* Valid options are:
*
* <p>
*
* <pre>
* -C <pruning confidence>
* Set confidence threshold for pruning.
* (default 0.25)
* </pre>
*
* <pre>
* -M <minimum number of objects>
* Set minimum number of objects per leaf.
* (default 2)
* </pre>
*
* <pre>
* -R
* Use reduced error pruning.
* </pre>
*
* <pre>
* -N <number of folds>
* Set number of folds for reduced error
* pruning. One fold is used as pruning set.
* (default 3)
* </pre>
*
* <pre>
* -B
* Use binary splits only.
* </pre>
*
* <pre>
* -U
* Generate unpruned decision list.
* </pre>
*
* <pre>
* -J
* Do not use MDL correction for info gain on numeric attributes.
* </pre>
*
* <pre>
* -Q <seed>
* Seed for random data shuffling (default 1).
* </pre>
*
* <pre>
* -doNotMakeSplitPointActualValue
* Do not make split point actual value.
* </pre>
*
* <!-- options-end -->
*
* @param options the list of options as an array of strings
* @throws Exception if an option is not supported
*/
@Override
public void setOptions(String[] options) throws Exception {
// Pruning options
m_unpruned = Utils.getFlag('U', options);
m_reducedErrorPruning = Utils.getFlag('R', options);
m_binarySplits = Utils.getFlag('B', options);
m_useMDLcorrection = !Utils.getFlag('J', options);
m_doNotMakeSplitPointActualValue = Utils.getFlag("doNotMakeSplitPointActualValue", options);
String confidenceString = Utils.getOption('C', options);
if (confidenceString.length() != 0) {
if (m_reducedErrorPruning) {
throw new Exception("Setting CF doesn't make sense " + "for reduced error pruning.");
} else {
m_CF = (new Float(confidenceString)).floatValue();
if ((m_CF <= 0) || (m_CF >= 1)) {
throw new Exception("CF 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"
+ " does only make sense for"
+ " reduced error pruning.");
} else {
m_numFolds = Integer.parseInt(numFoldsString);
}
} else {
m_numFolds = 3;
}
// Other options
String minNumString = Utils.getOption('M', options);
if (minNumString.length() != 0) {
m_minNumObj = Integer.parseInt(minNumString);
} else {
m_minNumObj = 2;
}
String seedString = Utils.getOption('Q', options);
if (seedString.length() != 0) {
m_Seed = Integer.parseInt(seedString);
} else {
m_Seed = 1;
}
super.setOptions(options);
}
/**
* Parses a given list of options.
*
* <p>
* <!-- options-start -->
* Valid options are:
*
* <p>
*
* <pre> -unset-class-temporarily
* Unsets the class index temporarily before the filter is
* applied to the data.
* (default: no)</pre>
*
* <pre> -S <num>
* The scaling factor for the output range.
* (default: 1.0)</pre>
*
* <pre> -T <num>
* The translation of the output range.
* (default: 0.0)</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 tmpStr;
tmpStr = Utils.getOption('S', options);
if (tmpStr.length() != 0) setScale(Double.parseDouble(tmpStr));
else setScale(1.0);
tmpStr = Utils.getOption('T', options);
if (tmpStr.length() != 0) setTranslation(Double.parseDouble(tmpStr));
else setTranslation(0.0);
if (getInputFormat() != null) setInputFormat(getInputFormat());
}
/**
* Parses a given list of options.
*
* <p>
* <!-- options-start -->
* Valid options are:
*
* <p>
*
* <pre> -D
* Turns on output of debugging information.</pre>
*
* <pre> -N <double>
* The number of attributes to randomly select.
* If < 1 then percentage, >= 1 absolute number.
* (default: 0.5)</pre>
*
* <pre> -S <int>
* The seed value.
* (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 tmpStr;
tmpStr = Utils.getOption("N", options);
if (tmpStr.length() != 0) setNumAttributes(Double.parseDouble(tmpStr));
else setNumAttributes(0.5);
tmpStr = Utils.getOption("S", options);
if (tmpStr.length() != 0) setSeed(Integer.parseInt(tmpStr));
else setSeed(1);
super.setOptions(options);
}
/**
* Parses a given list of options.
*
* <p>
* <!-- options-start -->
* Valid options are:
*
* <p>
*
* <pre>
* -W <classifier specification>
* Full class name of classifier to use, followed
* by scheme options. eg:
* "weka.classifiers.bayes.NaiveBayes -D"
* (default: weka.classifiers.rules.ZeroR)
* </pre>
*
* <pre>
* -C <class index>
* Attribute on which misclassifications are based.
* If < 0 will use any current set class or default to the last attribute.
* </pre>
*
* <pre>
* -F <number of folds>
* The number of folds to use for cross-validation cleansing.
* (<2 = no cross-validation - default).
* </pre>
*
* <pre>
* -T <threshold>
* Threshold for the max error when predicting numeric class.
* (Value should be >= 0, default = 0.1).
* </pre>
*
* <pre>
* -I
* The maximum number of cleansing iterations to perform.
* (<1 = until fully cleansed - default)
* </pre>
*
* <pre>
* -V
* Invert the match so that correctly classified instances are discarded.
* </pre>
*
* <!-- options-end -->
*
* @param options the list of options as an array of strings
* @throws Exception if an option is not supported
*/
@Override
public void setOptions(String[] options) throws Exception {
String classifierString = Utils.getOption('W', options);
if (classifierString.length() == 0) {
classifierString = weka.classifiers.rules.ZeroR.class.getName();
}
String[] classifierSpec = Utils.splitOptions(classifierString);
if (classifierSpec.length == 0) {
throw new Exception("Invalid classifier specification string");
}
String classifierName = classifierSpec[0];
classifierSpec[0] = "";
setClassifier(AbstractClassifier.forName(classifierName, classifierSpec));
String cString = Utils.getOption('C', options);
if (cString.length() != 0) {
setClassIndex((new Double(cString)).intValue());
} else {
setClassIndex(-1);
}
String fString = Utils.getOption('F', options);
if (fString.length() != 0) {
setNumFolds((new Double(fString)).intValue());
} else {
setNumFolds(0);
}
String tString = Utils.getOption('T', options);
if (tString.length() != 0) {
setThreshold((new Double(tString)).doubleValue());
} else {
setThreshold(0.1);
}
String iString = Utils.getOption('I', options);
if (iString.length() != 0) {
setMaxIterations((new Double(iString)).intValue());
} else {
setMaxIterations(0);
}
if (Utils.getFlag('V', options)) {
setInvert(true);
} else {
setInvert(false);
}
Utils.checkForRemainingOptions(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 {
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 list of options for this object. Valid options are:
*
* <p>-E expression <br>
* Specify the expression to apply. Eg. a1^2*a5/log(a7*4.0).
*
* <p>-N name <br>
* Specify a name for the new attribute. Default is to name it with the expression provided with
* the -E option.
*
* <p>-D <br>
* Debug. Names the attribute with the postfix parse of the expression.
*
* <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 expString = Utils.getOption('E', options);
if (expString.length() != 0) {
setExpression(expString);
} else {
throw new Exception("Must specify an expression with the -E option");
}
String name = Utils.getOption('N', options);
if (name.length() != 0) {
setName(name);
}
setDebug(Utils.getFlag('D', options));
}
/**
* Parses the options for this object.
*
* <p>
* <!-- options-start -->
* Valid options are:
*
* <p>
*
* <pre> -D
* Turns on output of debugging information.</pre>
*
* <pre> -R <index1,index2-index4,...>
* Specify list of string attributes to convert to words.
* (default: select all relational attributes)</pre>
*
* <pre> -V
* Inverts the matching sense of the selection.</pre>
*
* <pre> -S <CASE|NON-CASE>
* Determines the type of sorting:
* CASE = Case-sensitive
* NON-CASE = Case-insensitive
* (default: CASE)</pre>
*
* <!-- options-end -->
*
* @param options the options to use
* @throws Exception if setting of options fails
*/
public void setOptions(String[] options) throws Exception {
String tmpStr;
tmpStr = Utils.getOption('R', options);
if (tmpStr.length() != 0) setAttributeIndices(tmpStr);
else setAttributeIndices("first-last");
setInvertSelection(Utils.getFlag('V', options));
tmpStr = Utils.getOption('S', options);
if (tmpStr.length() != 0) setSortType(new SelectedTag(tmpStr, TAGS_SORTTYPE));
else setSortType(new SelectedTag(SORT_CASESENSITIVE, TAGS_SORTTYPE));
super.setOptions(options);
}
/**
* Parses a given list of options.
*
* <p>
* <!-- options-start -->
* Valid options are:
*
* <p>
*
* <pre> -D
* Enables debug output.
* (default: off)</pre>
*
* <pre> -F
* Stores the filename in an additional attribute.
* (default: off)</pre>
*
* <pre> -dir <directory>
* The directory to work on.
* (default: current directory)</pre>
*
* <pre> -charset <charset name>
* The character set to use, e.g UTF-8.
* (default: use the default character set)</pre>
*
* <pre> -R
* Retain all string attribute values when reading incrementally.</pre>
*
* <!-- options-end -->
*
* @param options the options
* @throws Exception if options cannot be set
*/
public void setOptions(String[] options) throws Exception {
setDebug(Utils.getFlag("D", options));
setOutputFilename(Utils.getFlag("F", options));
setDirectory(new File(Utils.getOption("dir", options)));
String charSet = Utils.getOption("charset", options);
m_charSet = "";
if (charSet.length() > 0) {
m_charSet = charSet;
}
setRetainStringValues(Utils.getFlag('R', options));
}
/**
* Parses a given list of options. Valid options are:
*
* <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>
*
* @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 {
// Iterate through the schemes
Vector classifiers = new Vector();
while (true) {
String classifierString = Utils.getOption('B', options);
if (classifierString.length() == 0) {
break;
}
String[] classifierSpec = Utils.splitOptions(classifierString);
if (classifierSpec.length == 0) {
throw new IllegalArgumentException("Invalid classifier specification string");
}
String classifierName = classifierSpec[0];
classifierSpec[0] = "";
classifiers.addElement(Classifier.forName(classifierName, classifierSpec));
}
if (classifiers.size() == 0) {
classifiers.addElement(new weka.classifiers.rules.ZeroR());
}
Classifier[] classifiersArray = new Classifier[classifiers.size()];
for (int i = 0; i < classifiersArray.length; i++) {
classifiersArray[i] = (Classifier) classifiers.elementAt(i);
}
setClassifiers(classifiersArray);
}
/** Main method for testing this class. */
public static void main(String[] options) {
String trainFileString;
StringBuffer text = new StringBuffer();
PredictiveApriori apriori = new PredictiveApriori();
Reader reader;
try {
text.append("\n\nPredictiveApriori options:\n\n");
text.append("-t <training file>\n");
text.append("\tThe name of the training file.\n");
Enumeration enu = apriori.listOptions();
while (enu.hasMoreElements()) {
Option option = (Option) enu.nextElement();
text.append(option.synopsis() + '\n');
text.append(option.description() + '\n');
}
trainFileString = Utils.getOption('t', options);
if (trainFileString.length() == 0) throw new Exception("No training file given!");
apriori.setOptions(options);
reader = new BufferedReader(new FileReader(trainFileString));
apriori.buildAssociations(new Instances(reader));
System.out.println(apriori);
} catch (Exception e) {
e.printStackTrace();
System.out.println("\n" + e.getMessage() + text);
}
}