weka.gui.explorer.ExplorerDefaults Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of weka-stable Show documentation
Show all versions of weka-stable Show documentation
The Waikato Environment for Knowledge Analysis (WEKA), a machine
learning workbench. This is the stable version. Apart from bugfixes, this version
does not receive any other updates.
/*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see weka/gui/explorer/Explorer.props.
*
* @author FracPete (fracpete at waikato dot ac dot nz)
* @version $Revision: 10222 $
* @see #PROPERTY_FILE
*/
public class ExplorerDefaults implements Serializable {
/** for serialization. */
private static final long serialVersionUID = 4954795757927524225L;
/** The name of the properties file. */
public final static String PROPERTY_FILE = "weka/gui/explorer/Explorer.props";
/** Properties associated with the explorer options. */
protected static Properties PROPERTIES;
static {
try {
PROPERTIES = Utils.readProperties(PROPERTY_FILE);
} catch (Exception e) {
System.err.println("Problem reading properties. Fix before continuing.");
e.printStackTrace();
PROPERTIES = new Properties();
}
}
/**
* returns the value for the specified property, if non-existent then the
* default value.
*
* @param property the property to retrieve the value for
* @param defaultValue the default value for the property
* @return the value of the specified property
*/
public static String get(String property, String defaultValue) {
return PROPERTIES.getProperty(property, defaultValue);
}
public static void set(String property, String value) {
PROPERTIES.setProperty(property, value);
}
/**
* returns the associated properties file.
*
* @return the props file
*/
public final static Properties getProperties() {
return PROPERTIES;
}
/**
* Tries to instantiate the class stored for this property, optional options
* will be set as well. Returns null if unsuccessful.
*
* @param property the property to get the object for
* @param defaultValue the default object spec string
* @return if successful the fully configured object, null otherwise
*/
protected static Object getObject(String property, String defaultValue) {
return getObject(property, defaultValue, Object.class);
}
/**
* Tries to instantiate the class stored for this property, optional options
* will be set as well. Returns null if unsuccessful.
*
* @param property the property to get the object for
* @param defaultValue the default object spec string
* @param cls the class the object must be derived from
* @return if successful the fully configured object, null otherwise
*/
protected static Object getObject(String property, String defaultValue,
Class cls) {
Object result;
String tmpStr;
String[] tmpOptions;
result = null;
try {
tmpStr = get(property, defaultValue);
tmpOptions = Utils.splitOptions(tmpStr);
if (tmpOptions.length != 0) {
tmpStr = tmpOptions[0];
tmpOptions[0] = "";
result = Utils.forName(cls, tmpStr, tmpOptions);
}
} catch (Exception e) {
e.printStackTrace();
result = null;
}
return result;
}
/**
* returns if the GOEs in the Explorer will be initialized based on the data
* that is loaded into the Explorer.
*
* @return true if the GOEs get initialized
*/
public static boolean getInitGenericObjectEditorFilter() {
return Boolean.parseBoolean(get("InitGenericObjectEditorFilter", "false"));
}
/**
* returns an array with the classnames of all the additional panels to
* display as tabs in the Explorer.
*
* @return the classnames
*/
public static String[] getTabs() {
String[] result;
String tabs;
// read and split on comma
tabs = get(
"Tabs",
"weka.gui.explorer.ClassifierPanel,weka.gui.explorer.ClustererPanel,weka.gui.explorer.AssociationsPanel,weka.gui.explorer.AttributeSelectionPanel,weka.gui.explorer.VisualizePanel");
result = tabs.split(",");
return result;
}
/**
* Returns the initial directory for the file chooser used for opening
* datasets.
*
* The following placeholders are recognized:
*
*
* %t - the temp directory
* %h - the user's home directory
* %c - the current directory
* %% - gets replaced by a single percentage sign
*
*
* @return the default directory
*/
public static String getInitialDirectory() {
String result;
result = get("InitialDirectory", "%c");
result = result.replaceAll("%t", System.getProperty("java.io.tmpdir"));
result = result.replaceAll("%h", System.getProperty("user.home"));
result = result.replaceAll("%c", System.getProperty("user.dir"));
result = result.replaceAll("%%", System.getProperty("%"));
return result;
}
/**
* returns the default filter (fully configured) for the preprocess panel.
*
* @return the default filter, null if none
*/
public static Object getFilter() {
return getObject("Filter", "", weka.filters.Filter.class);
}
/**
* returns the default classifier (fully configured) for the classify panel.
*
* @return the default classifier, ZeroR by default
*/
public static Object getClassifier() {
Object result;
result = getObject("Classifier",
weka.classifiers.rules.ZeroR.class.getName(),
weka.classifiers.Classifier.class);
if (result == null) {
result = new weka.classifiers.rules.ZeroR();
}
return result;
}
/**
* returns the default classifier test mode for the classify panel.
*
* @return the default test mode
*/
public static int getClassifierTestMode() {
return Integer.parseInt(get("ClassifierTestMode", "1"));
}
/**
* returns the default number of folds of the CV in the classify panel.
*
* @return the default number of folds
*/
public static int getClassifierCrossvalidationFolds() {
return Integer.parseInt(get("ClassifierCrossvalidationFolds", "10"));
}
/**
* returns the default classifier test mode for the classify panel (0-99).
*
* @return the default precentage split
*/
public static int getClassifierPercentageSplit() {
return Integer.parseInt(get("ClassifierPercentageSplit", "66"));
}
/**
* returns whether the built model is output.
*
* @return true if the built model is output
*/
public static boolean getClassifierOutputModel() {
return Boolean.parseBoolean(get("ClassifierOutputModel", "true"));
}
/**
* returns whether additional per-class stats of the classifier are output.
*
* @return true if stats are output
*/
public static boolean getClassifierOutputPerClassStats() {
return Boolean.parseBoolean(get("ClassifierOutputPerClassStats", "true"));
}
/**
* returns whether entropy-based evaluation meastures of the classifier are
* output.
*
* @return true if output
*/
public static boolean getClassifierOutputEntropyEvalMeasures() {
return Boolean.parseBoolean(get("ClassifierOutputEntropyEvalMeasures",
"false"));
}
/**
* returns whether the confusion matrix for the classifier is output.
*
* @return true if matrix is output
*/
public static boolean getClassifierOutputConfusionMatrix() {
return Boolean.parseBoolean(get("ClassifierOutputConfusionMatrix", "true"));
}
/**
* returns whether the predictions of the classifier are output as well.
*
* @return true if predictions are output as well
*/
public static boolean getClassifierOutputPredictions() {
return Boolean.parseBoolean(get("ClassifierOutputPredictions", "false"));
}
/**
* returns the string with the additional indices to output alongside the
* predictions.
*
* @return the indices, 0 if none are output
*/
public static String getClassifierOutputAdditionalAttributes() {
return get("ClassifierOutputAdditionalAttributes", "");
}
/**
* returns whether the predictions of the classifier are stored for
* visualization.
*
* @return true if predictions are stored
*/
public static boolean getClassifierStorePredictionsForVis() {
return Boolean
.parseBoolean(get("ClassifierStorePredictionsForVis", "true"));
}
/**
* returns whether the evaluation of the classifier is done cost-sensitively.
*
* @return true if cost-sensitively done
*/
public static boolean getClassifierCostSensitiveEval() {
return Boolean.parseBoolean(get("ClassifierCostSensitiveEval", "false"));
}
/**
* returns the default random seed value for the classifier for the classify
* panel.
*
* @return the default random seed
*/
public static int getClassifierRandomSeed() {
return Integer.parseInt(get("ClassifierRandomSeed", "1"));
}
/**
* returns whether the order is preserved in case of the percentage split in
* the classify tab.
*
* @return true if order is preserved
*/
public static boolean getClassifierPreserveOrder() {
return Boolean.parseBoolean(get("ClassifierPreserveOrder", "false"));
}
/**
* returns whether the source of a sourcable Classifier is output in the
* classify tab.
*
* @return true if the source code is output
*/
public static boolean getClassifierOutputSourceCode() {
return Boolean.parseBoolean(get("ClassifierOutputSourceCode", "false"));
}
/**
* returns the default classname for a sourcable Classifier in the classify
* tab.
*
* @return the default classname
*/
public static String getClassifierSourceCodeClass() {
return get("ClassifierSourceCodeClass", "Foobar");
}
/**
* Returns an instance of the class used for generating plot instances for
* displaying the classifier errors.
*
* @return an instance of the class
*/
public static ClassifierErrorsPlotInstances getClassifierErrorsPlotInstances() {
ClassifierErrorsPlotInstances result;
String classname;
String[] options;
try {
options = Utils.splitOptions(get("ClassifierErrorsPlotInstances",
"weka.gui.explorer.ClassifierErrorsPlotInstances"));
classname = options[0];
options[0] = "";
result = (ClassifierErrorsPlotInstances) Utils.forName(
ClassifierErrorsPlotInstances.class, classname, options);
} catch (Exception e) {
e.printStackTrace();
result = new ClassifierErrorsPlotInstances();
}
return result;
}
/**
* Returns the minimum size in pixels for plots of plotting classifier errors
* of numeric attributes.
*
* @return the size
*/
public static int getClassifierErrorsMinimumPlotSizeNumeric() {
return Integer.parseInt(get("ClassifierErrorsMinimumPlotSizeNumeric", "1"));
}
/**
* Returns the maximum size in pixels for plots of plotting classifier errors
* of numeric attributes.
*
* @return the size
*/
public static int getClassifierErrorsMaximumPlotSizeNumeric() {
return Integer
.parseInt(get("ClassifierErrorsMaximumPlotSizeNumeric", "20"));
}
/**
* returns the default clusterer (fully configured) for the clusterer panel.
*
* @return the default clusterer, EM by default
*/
public static Object getClusterer() {
Object result;
result = getObject("Clusterer", weka.clusterers.EM.class.getName(),
weka.clusterers.Clusterer.class);
if (result == null) {
result = new weka.clusterers.EM();
}
return result;
}
/**
* returns the default cluster test mode for the cluster panel.
*
* @return the default test mode
*/
public static int getClustererTestMode() {
return Integer.parseInt(get("ClustererTestMode", "3"));
}
/**
* returns whether the clusters are storeed for visualization purposes in the
* cluster panel.
*
* @return true if clusters are stored
*/
public static boolean getClustererStoreClustersForVis() {
return Boolean.parseBoolean(get("ClustererStoreClustersForVis", "true"));
}
/**
* Returns an instance of the class used for generating plot instances for
* displaying the cluster assignments.
*
* @return an instance of the class
*/
public static ClustererAssignmentsPlotInstances getClustererAssignmentsPlotInstances() {
ClustererAssignmentsPlotInstances result;
String classname;
String[] options;
try {
options = Utils.splitOptions(get("ClustererAssignmentsPlotInstances",
"weka.gui.explorer.ClustererAssignmentsPlotInstances"));
classname = options[0];
options[0] = "";
result = (ClustererAssignmentsPlotInstances) Utils.forName(
ClustererAssignmentsPlotInstances.class, classname, options);
} catch (Exception e) {
e.printStackTrace();
result = new ClustererAssignmentsPlotInstances();
}
return result;
}
/**
* returns the default associator (fully configured) for the associations
* panel.
*
* @return the default associator, Apriori by default
*/
public static Object getAssociator() {
Object result;
result = getObject("Associator", weka.associations.Apriori.class.getName(),
weka.associations.Associator.class);
if (result == null) {
result = new weka.associations.Apriori();
}
return result;
}
/**
* returns the default attribute evalautor (fully configured) for the
* attribute selection panel.
*
* @return the default attribute evaluator, CfsSubsetEval by default
*/
public static Object getASEvaluator() {
Object result;
result = getObject("ASEvaluation",
weka.attributeSelection.CfsSubsetEval.class.getName(),
weka.attributeSelection.ASEvaluation.class);
if (result == null) {
result = new weka.attributeSelection.CfsSubsetEval();
}
return result;
}
/**
* returns the default attribute selection search scheme (fully configured)
* for the attribute selection panel.
*
* @return the default search scheme, BestFirst by default
*/
public static Object getASSearch() {
Object result;
result = getObject("ASSearch",
weka.attributeSelection.BestFirst.class.getName(),
weka.attributeSelection.ASSearch.class);
if (result == null) {
result = new weka.attributeSelection.BestFirst();
}
return result;
}
/**
* returns the default attribute selection test mode for the attribute
* selection panel.
*
* @return the default test mode
*/
public static int getASTestMode() {
return Integer.parseInt(get("ASTestMode", "0"));
}
/**
* returns the default number of folds of the CV in the attribute selection
* panel.
*
* @return the default number of folds
*/
public static int getASCrossvalidationFolds() {
return Integer.parseInt(get("ASCrossvalidationFolds", "10"));
}
/**
* returns the default random seed value in the attribute selection panel.
*
* @return the default random seed
*/
public static int getASRandomSeed() {
return Integer.parseInt(get("ASRandomSeed", "1"));
}
/**
* only for testing - prints the content of the props file.
*
* @param args commandline parameters - ignored
*/
public static void main(String[] args) {
Enumeration names;
String name;
Vector sorted;
System.out.println("\nExplorer defaults:");
names = PROPERTIES.propertyNames();
// sort names
sorted = new Vector();
while (names.hasMoreElements()) {
sorted.add(names.nextElement().toString());
}
Collections.sort(sorted);
names = sorted.elements();
// output
while (names.hasMoreElements()) {
name = names.nextElement().toString();
System.out.println("- " + name + ": " + PROPERTIES.getProperty(name, ""));
}
System.out.println();
}
}