weka.attributeSelection.ASSearch Java Examples

@Override
public IReconstructionPlan getConstructionPlan() {
	try {
		if (this.wrappedClassifier instanceof MLPipeline) {
			MLPipeline pipeline = (MLPipeline) this.wrappedClassifier;
			Classifier classifier = pipeline.getBaseClassifier();
			ASSearch searcher = pipeline.getPreprocessors().get(0).getSearcher();
			ASEvaluation evaluator = pipeline.getPreprocessors().get(0).getEvaluator();
			return new ReconstructionPlan(
					Arrays.asList(new ReconstructionInstruction(WekaClassifier.class.getMethod("createPipeline", String.class, List.class, String.class, List.class, String.class, List.class), searcher.getClass().getName(),
							((OptionHandler) searcher).getOptions(), evaluator.getClass().getName(), ((OptionHandler) evaluator).getOptions(), classifier.getClass().getName(), ((OptionHandler) classifier).getOptions())));
		} else {
			return new ReconstructionPlan(Arrays.asList(new ReconstructionInstruction(WekaClassifier.class.getMethod("createBaseClassifier", String.class, List.class), this.name, this.getOptionsAsList())));
		}
	} catch (NoSuchMethodException | SecurityException e) {
		throw new UnsupportedOperationException(e);
	}
}
 

public static WekaClassifier createPipeline(final String searcher, final List<String> searcherOptions, final String evaluator, final List<String> evaluatorOptions, final String classifier, final List<String> classifierOptions)
		throws Exception {
	ASSearch search = ASSearch.forName(searcher, searcherOptions.toArray(new String[0]));
	ASEvaluation eval = ASEvaluation.forName(evaluator, evaluatorOptions.toArray(new String[0]));
	Classifier c = AbstractClassifier.forName(classifier, classifierOptions.toArray(new String[0]));
	return new WekaClassifier(new MLPipeline(search, eval, c));
}
 

/**
  * Gets the search specification string, which contains the class name of
  * the search method and any options to it
  *
  * @return the search string.
  */
 protected String getSearchSpec() {
   
   ASSearch s = getSearch();
   if (s instanceof OptionHandler) {
     return s.getClass().getName() + " "
+ Utils.joinOptions(((OptionHandler)s).getOptions());
   }
   return s.getClass().getName();
 }
 

public SupervisedFilterSelector(final ASSearch searcher, final ASEvaluation evaluator) {
	super();
	this.searcher = searcher;
	this.evaluator = evaluator;
	this.selector = new AttributeSelection();
	this.selector.setSearch(searcher);
	this.selector.setEvaluator(evaluator);
}
 

public MLPipeline(final ASSearch searcher, final ASEvaluation evaluator, final Classifier baseClassifier) {
	super();
	if (baseClassifier == null) {
		throw new IllegalArgumentException("Base classifier must not be null!");
	}
	if (searcher != null && evaluator != null) {
		AttributeSelection selector = new AttributeSelection();
		selector.setSearch(searcher);
		selector.setEvaluator(evaluator);
		this.preprocessors.add(new SupervisedFilterSelector(searcher, evaluator, selector));
	}
	super.setClassifier(baseClassifier);
}
 

public SuvervisedFilterPreprocessor(final ASSearch searcher, final ASEvaluation evaluator) {
	super();
	this.searcher = searcher;
	this.evaluator = evaluator;
	this.selector = new AttributeSelection();
	this.selector.setSearch(searcher);
	this.selector.setEvaluator(evaluator);
}
 

/**
 * Gets the search specification string, which contains the class name of
 * the search method and any options to it
 *
 * @return the search string.
 */
protected String getSearchSpec() {

  ASSearch s = getSearch();
  if (s instanceof OptionHandler) {
    return s.getClass().getName() + " "
    + Utils.joinOptions(((OptionHandler)s).getOptions());
  }
  return s.getClass().getName();
}
 

/**
 * Gets the current search method
 * 
 * @return the search method used
 */
public ASSearch getSearch() {
  if (m_backwardWithDelete == null) {
    setUpSearch();
    //      setSearch(m_backwardWithDelete);
    m_search = m_backwardWithDelete;
  }
  return m_search;
}
 

private void next(final IKVStore resultSet) throws Exception {
	try {
		// Get pipeline
		ComponentInstance ci;
		if (resultSet.getAsString("searcher") != null && resultSet.getAsString("evaluator") != null) {
			ci = this.factory.convertToComponentInstance(
					new MLPipeline(ASSearch.forName(resultSet.getAsString("searcher"), null), ASEvaluation.forName(resultSet.getAsString("evaluator"), null), AbstractClassifier.forName(resultSet.getAsString("classifier"), null)));
		} else {
			ci = this.factory.convertToComponentInstance(new MLPipeline(new ArrayList<SupervisedFilterSelector>(), AbstractClassifier.forName(resultSet.getAsString("classifier"), null)));
		}

		// Get pipeline performance values (errorRate,dataset array)
		String[] results = resultSet.getAsString("results").split(";");
		HashMap<String, List<Double>> datasetPerformances = new HashMap<>();
		for (int j = 0; j < results.length; j++) {
			String[] errorRatePerformance = results[j].split(",");
			if (!datasetPerformances.containsKey(errorRatePerformance[0])) {
				datasetPerformances.put(errorRatePerformance[0], new ArrayList<Double>());
			}

			if (errorRatePerformance.length > 1) {
				datasetPerformances.get(errorRatePerformance[0]).add(Double.parseDouble(errorRatePerformance[1]));
			}

		}

		this.pipelines.add(ci);
		this.pipelinePerformances.add(datasetPerformances);
	} catch (ComponentNotFoundException e) {
		// Could not convert pipeline - component not in loaded configuration
		this.logger.warn("Could not convert component due to {}", e);
	}
}
 

public SupervisedFilterSelector(final ASSearch searcher, final ASEvaluation evaluator, final AttributeSelection selector) {
	super();
	this.searcher = searcher;
	this.evaluator = evaluator;
	this.selector = selector;
}
 

public static String getPreprocessorDescriptor(final ASSearch c) {
	return getDescriptor(c);
}
 

public ASSearch getSearcher() {
	return this.searcher;
}
 

/**
 * Sets the search method to use
 * 
 * @param search
 */
public void setSearch(ASSearch search) {
  // Search method cannot be changed.
  // Must be BackwardsWithDelete
  return;
}
 

public SuvervisedFilterPreprocessor(final ASSearch searcher, final ASEvaluation evaluator, final AttributeSelection selector) {
	super();
	this.searcher = searcher;
	this.evaluator = evaluator;
	this.selector = selector;
}
 

public ASSearch getSearcher() {
	return this.searcher;
}
 

/**
 * Parses a given list of options. <p/>
 *
 <!-- options-start -->
 * Valid options are: <p/>
 * 
 * <pre> -E &lt;attribute evaluator specification&gt;
 *  Full class name of attribute evaluator, followed
 *  by its options.
 *  eg: "weka.attributeSelection.CfsSubsetEval -L"
 *  (default weka.attributeSelection.CfsSubsetEval)</pre>
 * 
 * <pre> -S &lt;search method specification&gt;
 *  Full class name of search method, followed
 *  by its options.
 *  eg: "weka.attributeSelection.BestFirst -D 1"
 *  (default weka.attributeSelection.BestFirst)</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.J48)</pre>
 * 
 * <pre> 
 * Options specific to classifier weka.classifiers.trees.J48:
 * </pre>
 * 
 * <pre> -U
 *  Use unpruned tree.</pre>
 * 
 * <pre> -C &lt;pruning confidence&gt;
 *  Set confidence threshold for pruning.
 *  (default 0.25)</pre>
 * 
 * <pre> -M &lt;minimum number of instances&gt;
 *  Set minimum number of instances per leaf.
 *  (default 2)</pre>
 * 
 * <pre> -R
 *  Use reduced error pruning.</pre>
 * 
 * <pre> -N &lt;number of folds&gt;
 *  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> -S
 *  Don't perform subtree raising.</pre>
 * 
 * <pre> -L
 *  Do not clean up after the tree has been built.</pre>
 * 
 * <pre> -A
 *  Laplace smoothing for predicted probabilities.</pre>
 * 
 * <pre> -Q &lt;seed&gt;
 *  Seed for random data shuffling (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 {

  // same for attribute evaluator
  String evaluatorString = Utils.getOption('E', options);
  if (evaluatorString.length() == 0)
    evaluatorString = weka.attributeSelection.CfsSubsetEval.class.getName();
  String [] evaluatorSpec = Utils.splitOptions(evaluatorString);
  if (evaluatorSpec.length == 0) {
    throw new Exception("Invalid attribute evaluator specification string");
  }
  String evaluatorName = evaluatorSpec[0];
  evaluatorSpec[0] = "";
  setEvaluator(ASEvaluation.forName(evaluatorName, evaluatorSpec));

  // same for search method
  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 Exception("Invalid search specification string");
  }
  String searchName = searchSpec[0];
  searchSpec[0] = "";
  setSearch(ASSearch.forName(searchName, searchSpec));

  super.setOptions(options);
}
 

/**
 * Get the name of the search method
 *
 * @return the name of the search method as a string
 */
public ASSearch getSearch() {
  
    return m_ASSearch;
}
 

/**
 * Set search class
 * 
 * @param search the search class to use
 */
public void setSearch(ASSearch search) {
  m_ASSearch = search;
}
 

/**
  * Parses the options for this object. <p/>
  *
  <!-- options-start -->
  * Valid options are: <p/>
  * 
  * <pre> -S &lt;search method specification&gt;
  *  Full class name of search method, followed
  *  by its options.
  *  eg: "weka.attributeSelection.BestFirst -D 1"
  *  (default weka.attributeSelection.BestFirst)</pre>
  * 
  * <pre> -X &lt;number of folds&gt;
  *  Use cross validation to evaluate features.
  *  Use number of folds = 1 for leave one out CV.
  *  (Default = leave one out CV)</pre>
  * 
  * <pre> -E &lt;acc | rmse | mae | auc&gt;
  *  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 &lt;start set&gt;
  *  Specify a starting set of attributes.
  *  Eg. 1,3,5-7.</pre>
  * 
  * <pre> -D &lt;0 = backward | 1 = forward | 2 = bi-directional&gt;
  *  Direction of search. (default = 1).</pre>
  * 
  * <pre> -N &lt;num&gt;
  *  Number of non-improving nodes to
  *  consider before terminating search.</pre>
  * 
  * <pre> -S &lt;num&gt;
  *  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));
 }
 

/**
 * Gets the current search method
 * 
 * @return the search method used
 */
public ASSearch getSearch() {
  return m_search;
}
 

/**
 * Sets the search method to use
 * 
 * @param search
 */
public void setSearch(ASSearch search) {
  m_search = search;
}
 

/**
 * Gets the search method used
 *
 * @return the search method
 */
public ASSearch getSearch() {
  return m_Search;
}
 

/**
 * Sets the search method
 *
 * @param search the search method with all options set.
 */
public void setSearch(ASSearch search) {
  m_Search = search;
}