/** * Parses a given list of options. * * @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; m_GroovyOptions = new String[0]; tmpStr = Utils.getOption('G', options); if (tmpStr.length() != 0) setGroovyModule(new File(tmpStr)); else setGroovyModule(new File(System.getProperty("user.dir"))); setGroovyOptions(Utils.joinOptions(Utils.partitionOptions(options).clone())); super.setOptions(options); }
/** * Parses a given list of options. * * <p> * <!-- options-start --> * Valid options are: * * <p> * * <pre> -c <class index> * The index of the class attribute. * (default last)</pre> * * <pre> -t <name of arff file> * The name of the arff file used for the decomposition.</pre> * * <pre> -T <training pool size> * The number of instances placed in the training pool. * The remainder will be used for testing. (default 100)</pre> * * <pre> -s <seed> * The random number seed used.</pre> * * <pre> -x <num> * The number of training repetitions used. * (default 50)</pre> * * <pre> -D * Turn on debugging output.</pre> * * <pre> -W <classifier class name> * Full class name of the learner used in the decomposition. * eg: weka.classifiers.bayes.NaiveBayes</pre> * * <pre> * Options specific to learner 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 sub-learner. * * <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 { setDebug(Utils.getFlag('D', options)); String classIndex = Utils.getOption('c', options); if (classIndex.length() != 0) { if (classIndex.toLowerCase().equals("last")) { setClassIndex(0); } else if (classIndex.toLowerCase().equals("first")) { setClassIndex(1); } else { setClassIndex(Integer.parseInt(classIndex)); } } else { setClassIndex(0); } String trainIterations = Utils.getOption('x', options); if (trainIterations.length() != 0) { setTrainIterations(Integer.parseInt(trainIterations)); } else { setTrainIterations(50); } String trainPoolSize = Utils.getOption('T', options); if (trainPoolSize.length() != 0) { setTrainPoolSize(Integer.parseInt(trainPoolSize)); } else { setTrainPoolSize(100); } String seedString = Utils.getOption('s', options); if (seedString.length() != 0) { setSeed(Integer.parseInt(seedString)); } else { setSeed(1); } String dataFile = Utils.getOption('t', options); if (dataFile.length() == 0) { throw new Exception("An arff file must be specified" + " with the -t option."); } setDataFileName(dataFile); String classifierName = Utils.getOption('W', options); if (classifierName.length() == 0) { throw new Exception("A learner must be specified with the -W option."); } setClassifier(AbstractClassifier.forName(classifierName, Utils.partitionOptions(options))); }
@Override public void setOptions(String[] options) throws Exception { String ns = Utils.getOption('N', options); if (ns.length() > 0) { setNamespace(ns); } // scheme options after the -- String[] schemeOpts = Utils.partitionOptions(options); if (schemeOpts != null && schemeOpts.length > 0) { String sO = Utils.joinOptions(schemeOpts); setSchemeOptions(sO); } }
/** * Parses a given list of options. * * <p> * <!-- options-start --> * Valid options are: * * <p> * * <pre> -no-size * Skips the determination of sizes (train/test/classifier) * (default: sizes are determined)</pre> * * <pre> -W <class name> * The full class name of the classifier. * eg: weka.classifiers.bayes.NaiveBayes</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 --> * All option after -- will be passed to the classifier. * * @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 { m_NoSizeDetermination = Utils.getFlag("no-size", options); String cName = Utils.getOption('W', options); if (cName.length() == 0) { throw new Exception("A classifier must be specified with" + " the -W option."); } // Do it first without options, so if an exception is thrown during // the option setting, listOptions will contain options for the actual // Classifier. setClassifier(AbstractClassifier.forName(cName, null)); if (getClassifier() instanceof OptionHandler) { ((OptionHandler) getClassifier()).setOptions(Utils.partitionOptions(options)); updateOptions(); } }
/** * 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))); }
/** * Parses a given list of options. * * <pre> * -T <task_id> * The OpenML task to run the experiment on. (required) * </pre> * * <pre> * -C <class name> * The full class name of the classifier. * eg: weka.classifiers.bayes.NaiveBayes * </pre> * * <!-- options-end --> * All options after -- will be passed to the 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 { Integer task_id = Integer.parseInt(Utils.getOption('T', options)); String classifierName = Utils.getOption('C', options); String[] classifierOptions = Utils.partitionOptions(options); DefaultListModel<Task> tasks = new DefaultListModel<Task>(); tasks.add(0, apiconnector.taskGet(task_id)); setTasks(tasks); Classifier[] cArray = new Classifier[1]; try { cArray[0] = (Classifier) Utils.forName(Classifier.class, classifierName, classifierOptions); } catch (Exception e) { // Try again, this time loading packages first weka.core.WekaPackageManager.loadPackages(false); cArray[0] = (Classifier) Utils.forName(Classifier.class, classifierName, classifierOptions); } setPropertyArray(cArray); }