/**
* Parses a given list of options.
*
* <p>
* <!-- options-start -->
* <!-- options-end -->
*/
@Override
public void setOptions(String[] options) throws Exception {
if (m_delegate == null) {
init();
}
((OptionHandler) m_delegate).setOptions(options);
}
/**
* Returns an enumeration describing the available options.
*
* @return an enumeration of all the available options.
*/
@Override
public Enumeration<Option> listOptions() {
if (m_delegate == null) {
init();
}
return ((OptionHandler) m_delegate).listOptions();
}
/**
* Returns default capabilities of the classifier.
*
* @return the capabilities of this classifier
*/
@Override
public Capabilities getCapabilities() {
if (m_delegate == null) {
init();
}
return ((CapabilitiesHandler) m_delegate).getCapabilities();
}
/**
* Batch scoring method
*
* @param insts the instances to push over to R and get predictions for
* @return an array of probability distributions, one for each instance
* @throws Exception if a problem occurs
*/
@Override
public double[][] distributionsForInstances(Instances insts) throws Exception {
if (m_delegate == null) {
init();
}
return ((BatchPredictor) m_delegate).distributionsForInstances(insts);
}
/**
* Gets the current settings of MLRClassifier.
*
* @return an array of strings suitable for passing to setOptions()
*/
@Override
public String[] getOptions() {
if (m_delegate == null) {
init();
}
return ((OptionHandler) m_delegate).getOptions();
}
/**
* Set the parameters for the R learner. This should be specified in the same way (i.e. comma
* separated) as they would be if using the R console.
*
* @param learnerParams the parameters (comma separated) to pass to the R learner.
*/
public void setLearnerParams(String learnerParams) {
if (m_delegate == null) {
init();
}
try {
Method m =
m_delegate.getClass().getDeclaredMethod("setLearnerParams", new Class[] {String.class});
m.invoke(m_delegate, new Object[] {learnerParams});
} catch (Exception ex) {
ex.printStackTrace();
}
}
/**
* Set the base R learner to use
*
* @param learner the learner to use
*/
public void setRLearner(SelectedTag learner) {
if (m_delegate == null) {
init();
}
try {
Method m =
m_delegate.getClass().getDeclaredMethod("setRLearner", new Class[] {SelectedTag.class});
m.invoke(m_delegate, new Object[] {learner});
} catch (Exception ex) {
ex.printStackTrace();
}
}
/**
* Set whether to output debugging info
*
* @param d true if debugging info is to be output
*/
@Override
public void setDebug(boolean d) {
if (m_delegate == null) {
init();
}
try {
Method m = m_delegate.getClass().getDeclaredMethod("setDebug", new Class[] {Boolean.TYPE});
m.invoke(m_delegate, new Object[] {new Boolean(d)});
} catch (Exception ex) {
ex.printStackTrace();
}
}
/**
* Get the parameters for the R learner. This should be specified in the same way (i.e. comma
* separated) as they would be if using the R console.
*
* @return the parameters (comma separated) to pass to the R learner.
*/
public String getLearnerParams() {
if (m_delegate == null) {
init();
}
try {
Method m = m_delegate.getClass().getDeclaredMethod("getLearnerParams", new Class[] {});
Object result = m.invoke(m_delegate, new Object[] {});
return result.toString();
} catch (Exception ex) {
ex.printStackTrace();
}
return "";
}
/**
* Set the batch size for prediction (i.e. how many instances to push over into an R data frame at
* a time).
*
* @return the batch size for prediction
*/
@Override
public void setBatchSize(String size) {
if (m_delegate == null) {
init();
}
try {
Method m =
m_delegate.getClass().getDeclaredMethod("setBatchSize", new Class[] {String.class});
m.invoke(m_delegate, new Object[] {size});
} catch (Exception ex) {
ex.printStackTrace();
}
}
/**
* Returns the tip text for this property
*
* @return tip text for this property suitable for displaying in the explorer/experimenter gui
*/
public String logMessagesFromRTipText() {
if (m_delegate == null) {
init();
}
try {
Method m = m_delegate.getClass().getDeclaredMethod("logMessagesFromRTipText", new Class[] {});
Object result = m.invoke(m_delegate, new Object[] {});
return result.toString();
} catch (Exception ex) {
ex.printStackTrace();
}
return "";
}
/**
* Get the base R learner to use
*
* @return the learner to use
*/
public SelectedTag getRLearner() {
if (m_delegate == null) {
init();
}
try {
Method m = m_delegate.getClass().getDeclaredMethod("getRLearner", new Class[] {});
Object result = m.invoke(m_delegate, new Object[] {});
return (SelectedTag) result;
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}
/**
* Get whether to log info/warning messages from R to the console.
*
* @return true if info/warning messages should be logged to the console.
*/
public boolean getLogMessagesFromR() {
if (m_delegate == null) {
init();
}
try {
Method m = m_delegate.getClass().getDeclaredMethod("getLogMessagesFromR", new Class[] {});
Object result = m.invoke(m_delegate, new Object[] {});
return ((Boolean) result).booleanValue();
} catch (Exception ex) {
ex.printStackTrace();
}
return false;
}
/**
* Build the specified R learner on the incoming training data.
*
* @param data the training data to be used for generating the R model.
* @throws Exception if the classifier could not be built successfully.
*/
@Override
public void buildClassifier(Instances data) throws Exception {
if (m_delegate == null) {
init();
}
try {
// m_delegate.buildClassifier(data);
Method m =
m_delegate.getClass().getDeclaredMethod("buildClassifier", new Class[] {Instances.class});
m.invoke(m_delegate, new Object[] {data});
} catch (InvocationTargetException e) {
Throwable cause = e.getCause();
throw new Exception(cause);
}
}
/**
* Set whether to log info/warning messages from R to the console.
*
* @param l true if info/warning messages should be logged to the console.
*/
public void setLogMessagesFromR(boolean l) {
if (m_delegate == null) {
init();
}
try {
Method m =
m_delegate
.getClass()
.getDeclaredMethod("setLogMessagesFromR", new Class[] {Boolean.TYPE});
m.invoke(m_delegate, new Object[] {new Boolean(l)});
} catch (Exception ex) {
ex.printStackTrace();
}
}
public void setLaunchedFromCommandLine(boolean l) {
if (m_delegate == null) {
init();
}
try {
Method m =
m_delegate
.getClass()
.getDeclaredMethod("setLaunchedFromCommandLine", new Class[] {Boolean.class});
m.invoke(m_delegate, new Object[] {new Boolean(l)});
} catch (Exception ex) {
ex.printStackTrace();
}
}
/**
* Calculates the class membership probabilities for the given test instance.
*
* @param instance the instance to be classified
* @return predicted class probability distribution
* @throws Exception if distribution can't be computed successfully
*/
@Override
public double[] distributionForInstance(Instance inst) throws Exception {
if (m_delegate == null) {
init();
}
try {
Method m =
m_delegate
.getClass()
.getDeclaredMethod("distributionForInstance", new Class[] {Instance.class});
Object result = m.invoke(m_delegate, new Object[] {inst});
return (double[]) result;
} catch (InvocationTargetException e) {
Throwable cause = e.getCause();
throw new Exception(cause);
}
}
