weka.knowledgeflow.steps

Class Classifier

java.lang.Object

weka.knowledgeflow.steps.BaseStep

weka.knowledgeflow.steps.WekaAlgorithmWrapper

weka.knowledgeflow.steps.Classifier

All Implemented Interfaces:

java.io.Serializable, BaseStepExtender, PairedDataHelper.PairedProcessor<Classifier>, Step

@KFStep(name="Classifier",
        category="Classifiers",
        toolTipText="Weka classifier wrapper",
        iconPath="",
        resourceIntensive=true)
public class Classifier
extends WekaAlgorithmWrapper
implements PairedDataHelper.PairedProcessor<Classifier>

Step that wraps a Weka classifier. Handles instance, trainingSet and testSet incoming connections. If the base classifier is Updateable, then it can be optionally updated incrementall on an incoming connection of type instance. Otherwise, instance connections are used for testing a classifier incrementally. In the case of a single incoming testSet connection it is assumed that the classifier has already been trained.

See Also:

Serialized Form

Field Summary

Fields

Modifier and Type	Field and Description
protected boolean	m_classifierIsIncremental True if the classifier in use is Updateable
protected Classifier	m_classifierTemplate The template for constructing concrete instances of the classifier to train
protected Data	m_incrementalData Reusable data for incremental streaming classifiers
protected boolean	m_isReset True if we've been reset
protected java.io.File	m_loadModelFileName Optional file to load a pre-trained model to score with (batch, or to score and update (incremental) in the case of testSet only (batch) or instance (incremental) connections
protected boolean	m_resetIncrementalClassifier True if we should resent an Updateable classifier at the start of processing for an incoming "instance" stream
protected boolean	m_streaming True if we are processing streaming data
protected Classifier	m_trainedClassifier Holds the trained classifier in the case of single train/test pairs or instance stream connections
protected Instances	m_trainedClassifierHeader
protected PairedDataHelper<Classifier>	m_trainTestHelper Handles train test pair routing and synchronization for us
protected boolean	m_updateIncrementalClassifier True if we should update an incremental classifier when there is a incoming "instance" stream

Fields inherited from class weka.knowledgeflow.steps.WekaAlgorithmWrapper

m_defaultIconPath, m_defaultPackageIconPath, m_iconPath, m_wrappedAlgorithm

Fields inherited from class weka.knowledgeflow.steps.BaseStep

m_stepIsResourceIntensive, m_stepManager, m_stepName

Constructor Summary

Constructors

Constructor and Description
Classifier()

Method Summary

Modifier and Type	Method and Description
Classifier	getClassifier() Get the classifier to train
java.util.List<java.lang.String>	getIncomingConnectionTypes() Get a list of incoming connection types that this step can accept.
java.io.File	getLoadClassifierFileName() Get the name of the classifier to load at execution time.
java.util.List<java.lang.String>	getOutgoingConnectionTypes() Get a list of outgoing connection types that this step can produce.
boolean	getResetIncrementalClassifier() Get whether to reset an incremental classifier at the start of an incoming instance stream
boolean	getUpdateIncrementalClassifier() Get whether to update an incremental classifier on an incoming instance stream
java.lang.Class	getWrappedAlgorithmClass() Get the class of the algorithm being wrapped
protected void	loadModel(java.lang.String filePath) Load a pre-trained model from the supplied path
protected void	outputGraphData(Classifier classifier, int setNum) Output a Data object containing a dot graph, if the model is Drawable and we have downstream steps receiving graph connections.
protected void	outputTextData(Classifier classifier, int setNum) Output a Data object containing a textual description of a model to any outgoing text connections
void	processIncoming(Data data) Process an incoming data payload (if the step accepts incoming connections)
protected void	processOnlyTestSet(Data data) Process a Data object in the case where we only have an incoming testSet connection
Classifier	processPrimary(java.lang.Integer setNum, java.lang.Integer maxSetNum, Data data, PairedDataHelper<Classifier> helper) Process a training split (primary data handled by the PairedDataHelper)
void	processSecondary(java.lang.Integer setNum, java.lang.Integer maxSetNum, Data data, PairedDataHelper<Classifier> helper) Process a test split/fold (secondary data handled by PairedDataHelper)
protected void	processStreaming(Data data) Process a Data object in the case of an incoming instance (streaming) connection
void	setClassifier(Classifier classifier) Set the classifier to train
void	setLoadClassifierFileName(java.io.File filename) Set the name of the classifier to load at execution time.
void	setResetIncrementalClassifier(boolean reset) Set whether to reset an incremental classifier at the start of an incoming instance stream
void	setUpdateIncrementalClassifier(boolean update) Set whether to update an incremental classifier on an incoming instance stream
void	setWrappedAlgorithm(java.lang.Object algo) Set the wrapped algorithm
void	stepInit() Initialize the step.

Methods inherited from class weka.knowledgeflow.steps.WekaAlgorithmWrapper

getDefaultIconPath, getDefaultPackageLevelIconPath, getIconPath, getWrappedAlgorithm, globalInfo

Methods inherited from class weka.knowledgeflow.steps.BaseStep

environmentSubstitute, getCustomEditorForStep, getDefaultSettings, getInteractiveViewers, getInteractiveViewersImpls, getName, getStepManager, isResourceIntensive, isStopRequested, outputStructureForConnectionType, setName, setStepIsResourceIntensive, setStepManager, setStepMustRunSingleThreaded, start, stepMustRunSingleThreaded, stop

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

m_classifierTemplate

protected Classifier m_classifierTemplate

The template for constructing concrete instances of the classifier to train

m_trainedClassifier

protected Classifier m_trainedClassifier

Holds the trained classifier in the case of single train/test pairs or instance stream connections

m_trainedClassifierHeader

protected Instances m_trainedClassifierHeader

m_loadModelFileName

protected java.io.File m_loadModelFileName

Optional file to load a pre-trained model to score with (batch, or to score and update (incremental) in the case of testSet only (batch) or instance (incremental) connections

m_resetIncrementalClassifier

protected boolean m_resetIncrementalClassifier

True if we should resent an Updateable classifier at the start of processing for an incoming "instance" stream

m_updateIncrementalClassifier

protected boolean m_updateIncrementalClassifier

True if we should update an incremental classifier when there is a incoming "instance" stream

m_streaming

protected boolean m_streaming

True if we are processing streaming data

m_classifierIsIncremental

protected boolean m_classifierIsIncremental

True if the classifier in use is Updateable

m_trainTestHelper

protected transient PairedDataHelper<Classifier> m_trainTestHelper

Handles train test pair routing and synchronization for us

m_incrementalData

protected Data m_incrementalData

Reusable data for incremental streaming classifiers

m_isReset

protected boolean m_isReset

True if we've been reset

Constructor Detail

Classifier

public Classifier()

Method Detail

getWrappedAlgorithmClass

public java.lang.Class getWrappedAlgorithmClass()

Description copied from class: WekaAlgorithmWrapper

Get the class of the algorithm being wrapped

Specified by:

getWrappedAlgorithmClass in class WekaAlgorithmWrapper

Returns:

the class of the algorithm being wrapped

setWrappedAlgorithm

public void setWrappedAlgorithm(java.lang.Object algo)

Description copied from class: WekaAlgorithmWrapper

Set the wrapped algorithm

Overrides:

setWrappedAlgorithm in class WekaAlgorithmWrapper

Parameters:

algo - the algorithm to wrao

getClassifier

public Classifier getClassifier()

Get the classifier to train

Returns:

the classifier to train

setClassifier

@ProgrammaticProperty
public void setClassifier(Classifier classifier)

Set the classifier to train

Parameters:

classifier - the classifier to train

stepInit

public void stepInit()
              throws WekaException

Description copied from interface: Step

Initialize the step.

Specified by:

stepInit in interface BaseStepExtender

Specified by:

stepInit in interface Step

Throws:

WekaException - if a problem occurs during initialization

getLoadClassifierFileName

public java.io.File getLoadClassifierFileName()

Get the name of the classifier to load at execution time. This only applies in the case where the only incoming connection is a test set connection (batch mode) or an instance connection (incremental mode).

Returns:

the name of the file to load the model from

setLoadClassifierFileName

@OptionMetadata(displayName="Classifier model to load",
                description="Optional Path to a classifier to load at execution time (only applies when using testSet or instance connections)")
 @FilePropertyMetadata(fileChooserDialogType=0,
                      directoriesOnly=false)
public void setLoadClassifierFileName(java.io.File filename)

Set the name of the classifier to load at execution time. This only applies in the case where the only incoming connection is a test set connection (batch mode) or an instance connection (incremental mode).

Parameters:

filename - the name of the file to load the model from

getResetIncrementalClassifier

public boolean getResetIncrementalClassifier()

Get whether to reset an incremental classifier at the start of an incoming instance stream

Returns:

true if the classifier should be reset

setResetIncrementalClassifier

@OptionMetadata(displayName="Reset incremental classifier",
                description="Reset classifier (if it is incremental) at the start of the incoming instance stream")
public void setResetIncrementalClassifier(boolean reset)

Set whether to reset an incremental classifier at the start of an incoming instance stream

Parameters:

reset - true if the classifier should be reset

getUpdateIncrementalClassifier

public boolean getUpdateIncrementalClassifier()

Get whether to update an incremental classifier on an incoming instance stream

Returns:

true if an incremental classifier should be updated

setUpdateIncrementalClassifier

@OptionMetadata(displayName="Update incremental classifier",
                description=" Update an incremental classifier on incoming instance stream")
public void setUpdateIncrementalClassifier(boolean update)

Set whether to update an incremental classifier on an incoming instance stream

Parameters:

update - true if an incremental classifier should be updated

processIncoming

public void processIncoming(Data data)
                     throws WekaException

Description copied from class: BaseStep

Process an incoming data payload (if the step accepts incoming connections)

Specified by:

processIncoming in interface BaseStepExtender

Specified by:

processIncoming in interface Step

Overrides:

processIncoming in class BaseStep

Parameters:

data - the payload to process

Throws:

WekaException - if a problem occurs

processPrimary

public Classifier processPrimary(java.lang.Integer setNum,
                                 java.lang.Integer maxSetNum,
                                 Data data,
                                 PairedDataHelper<Classifier> helper)
                          throws WekaException

Process a training split (primary data handled by the PairedDataHelper)

Specified by:

processPrimary in interface PairedDataHelper.PairedProcessor<Classifier>

Parameters:

setNum - the number of this split/fold

maxSetNum - the maximum number of splits/folds in the group

data - the actual split/fold data

helper - the PairedDataHelper managing the paired data

Returns:

a Classifier trained on this training split

Throws:

WekaException - if a problem occurs

processSecondary

public void processSecondary(java.lang.Integer setNum,
                             java.lang.Integer maxSetNum,
                             Data data,
                             PairedDataHelper<Classifier> helper)
                      throws WekaException

Process a test split/fold (secondary data handled by PairedDataHelper)

Specified by:

processSecondary in interface PairedDataHelper.PairedProcessor<Classifier>

Parameters:

setNum - the set number of this split/fold

maxSetNum - the maximum number of splits/folds in the group

data - the actual split/fold data

helper - the PairedDataHelper managing the paried data

Throws:

WekaException - if a problem occurs

processOnlyTestSet

protected void processOnlyTestSet(Data data)
                           throws WekaException

Process a Data object in the case where we only have an incoming testSet connection

Parameters:

data - the Data object to process

Throws:

WekaException - if a problem occurs

processStreaming

protected void processStreaming(Data data)
                         throws WekaException

Process a Data object in the case of an incoming instance (streaming) connection

Parameters:

data - the Data object to process

Throws:

WekaException - if a problem occurs

outputTextData

protected void outputTextData(Classifier classifier,
                              int setNum)
                       throws WekaException

Output a Data object containing a textual description of a model to any outgoing text connections

Parameters:

classifier - the classifier to get the textual description of

setNum - the set number of the training data

Throws:

WekaException - if a problem occurs

outputGraphData

protected void outputGraphData(Classifier classifier,
                               int setNum)
                        throws WekaException

Output a Data object containing a dot graph, if the model is Drawable and we have downstream steps receiving graph connections.

Parameters:

classifier - the classifier to generate the graph from

setNum - the set number of the data used to generate the graph

Throws:

WekaException - if a problem occurs

getIncomingConnectionTypes

public java.util.List<java.lang.String> getIncomingConnectionTypes()

Description copied from interface: Step

Get a list of incoming connection types that this step can accept. Ideally (and if appropriate), this should take into account the state of the step and any existing incoming connections. E.g. a step might be able to accept one (and only one) incoming batch data connection.

Specified by:

getIncomingConnectionTypes in interface BaseStepExtender

Specified by:

getIncomingConnectionTypes in interface Step

Returns:

a list of incoming connections that this step can accept given its current state

getOutgoingConnectionTypes

public java.util.List<java.lang.String> getOutgoingConnectionTypes()

Description copied from interface: Step

Get a list of outgoing connection types that this step can produce. Ideally (and if appropriate), this should take into account the state of the step and the incoming connections. E.g. depending on what incoming connection is present, a step might be able to produce a trainingSet output, a testSet output or neither, but not both.

Specified by:

getOutgoingConnectionTypes in interface BaseStepExtender

Specified by:

getOutgoingConnectionTypes in interface Step

Returns:

a list of outgoing connections that this step can produce

loadModel

protected void loadModel(java.lang.String filePath)
                  throws java.lang.Exception

Load a pre-trained model from the supplied path

Parameters:

filePath - the path to load the model from

Throws:

java.lang.Exception - if a problem occurs