/**
* Returns an enumeration describing the available options.
*
* @return an enumeration of all the available options.
*/
public Enumeration listOptions() {
Vector newVector = new Vector(4);
newVector.addElement(
new Option(
"\tclass name of attribute evaluator to use for ranking. Place any\n"
+ "\tevaluator options LAST on the command line following a \"--\".\n"
+ "\teg.:\n"
+ "\t\t-A weka.attributeSelection.GainRatioAttributeEval ... -- -M\n"
+ "\t(default: weka.attributeSelection.GainRatioAttributeEval)",
"A",
1,
"-A <attribute evaluator>"));
newVector.addElement(
new Option(
"\tnumber of attributes to be added from the"
+ "\n\tranking in each iteration (default = 1).",
"S",
1,
"-S <step size>"));
newVector.addElement(
new Option(
"\tpoint in the ranking to start evaluating from. "
+ "\n\t(default = 0, ie. the head of the ranking).",
"R",
1,
"-R <start point>"));
if ((m_ASEval != null) && (m_ASEval instanceof OptionHandler)) {
newVector.addElement(
new Option(
"",
"",
0,
"\nOptions specific to " + "evaluator " + m_ASEval.getClass().getName() + ":"));
Enumeration enu = ((OptionHandler) m_ASEval).listOptions();
while (enu.hasMoreElements()) {
newVector.addElement(enu.nextElement());
}
}
return newVector.elements();
}
/**
* Parses a given list of options.
*
* <p>
* <!-- options-start -->
* Valid options are:
*
* <p>
*
* <pre> -A <attribute evaluator>
* class name of attribute evaluator to use for ranking. Place any
* evaluator options LAST on the command line following a "--".
* eg.:
* -A weka.attributeSelection.GainRatioAttributeEval ... -- -M
* (default: weka.attributeSelection.GainRatioAttributeEval)</pre>
*
* <pre> -S <step size>
* number of attributes to be added from the
* ranking in each iteration (default = 1).</pre>
*
* <pre> -R <start point>
* point in the ranking to start evaluating from.
* (default = 0, ie. the head of the ranking).</pre>
*
* <pre>
* Options specific to evaluator weka.attributeSelection.GainRatioAttributeEval:
* </pre>
*
* <pre> -M
* treat missing values as a seperate value.</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('S', options);
if (optionString.length() != 0) {
setStepSize(Integer.parseInt(optionString));
}
optionString = Utils.getOption('R', options);
if (optionString.length() != 0) {
setStartPoint(Integer.parseInt(optionString));
}
optionString = Utils.getOption('A', options);
if (optionString.length() == 0) optionString = GainRatioAttributeEval.class.getName();
setAttributeEvaluator(ASEvaluation.forName(optionString, Utils.partitionOptions(options)));
}
/**
* Ranks attributes using the specified attribute evaluator and then searches the ranking using
* the supplied subset evaluator.
*
* @param ASEval the subset evaluator to guide the search
* @param data the training instances.
* @return an array (not necessarily ordered) of selected attribute indexes
* @throws Exception if the search can't be completed
*/
public int[] search(ASEvaluation ASEval, Instances data) throws Exception {
double best_merit = -Double.MAX_VALUE;
double temp_merit;
BitSet temp_group, best_group = null;
if (!(ASEval instanceof SubsetEvaluator)) {
throw new Exception(ASEval.getClass().getName() + " is not a " + "Subset evaluator!");
}
m_SubsetEval = ASEval;
m_Instances = data;
m_numAttribs = m_Instances.numAttributes();
/* if (m_ASEval instanceof AttributeTransformer) {
throw new Exception("Can't use an attribute transformer "
+"with RankSearch");
} */
if (m_ASEval instanceof UnsupervisedAttributeEvaluator
|| m_ASEval instanceof UnsupervisedSubsetEvaluator) {
m_hasClass = false;
/* if (!(m_SubsetEval instanceof UnsupervisedSubsetEvaluator)) {
throw new Exception("Must use an unsupervised subset evaluator.");
} */
} else {
m_hasClass = true;
m_classIndex = m_Instances.classIndex();
}
if (m_ASEval instanceof AttributeEvaluator) {
// generate the attribute ranking first
Ranker ranker = new Ranker();
m_ASEval.buildEvaluator(m_Instances);
if (m_ASEval instanceof AttributeTransformer) {
// get the transformed data a rebuild the subset evaluator
m_Instances = ((AttributeTransformer) m_ASEval).transformedData(m_Instances);
((ASEvaluation) m_SubsetEval).buildEvaluator(m_Instances);
}
m_Ranking = ranker.search(m_ASEval, m_Instances);
} else {
GreedyStepwise fs = new GreedyStepwise();
double[][] rankres;
fs.setGenerateRanking(true);
((ASEvaluation) m_ASEval).buildEvaluator(m_Instances);
fs.search(m_ASEval, m_Instances);
rankres = fs.rankedAttributes();
m_Ranking = new int[rankres.length];
for (int i = 0; i < rankres.length; i++) {
m_Ranking[i] = (int) rankres[i][0];
}
}
// now evaluate the attribute ranking
for (int i = m_startPoint; i < m_Ranking.length; i += m_add) {
temp_group = new BitSet(m_numAttribs);
for (int j = 0; j <= i; j++) {
temp_group.set(m_Ranking[j]);
}
temp_merit = ((SubsetEvaluator) m_SubsetEval).evaluateSubset(temp_group);
if (temp_merit > best_merit) {
best_merit = temp_merit;
;
best_group = temp_group;
}
}
m_bestMerit = best_merit;
return attributeList(best_group);
}