weka.knowledgeflow.steps

Class Filter

java.lang.Object

weka.knowledgeflow.steps.BaseStep

weka.knowledgeflow.steps.WekaAlgorithmWrapper

weka.knowledgeflow.steps.Filter

All Implemented Interfaces:

java.io.Serializable, BaseStepExtender, Step

@KFStep(name="Filter",
        category="Filters",
        toolTipText="Weka filter wrapper",
        iconPath="")
public class Filter
extends WekaAlgorithmWrapper

Step that wraps a Weka filter. Handles dataSet, trainingSet, testSet and instance connections.

See Also:

Serialized Form

Field Summary

Fields

Modifier and Type	Field and Description
protected java.util.Map<java.lang.Integer,Filter>	m_filterMap Map of filters that have processed the first batch
protected Filter	m_filterTemplate Template filter
protected Data	m_incrementalData Data object to reuse when processing incrementally
protected boolean	m_isReset True if we've been reset
protected java.util.concurrent.atomic.AtomicInteger	m_setCount Keeps track of the number of train/test batches processed
protected boolean	m_streaming True if we're streaming
protected Filter	m_streamingFilter Used when processing streaming data
protected boolean	m_stringAttsPresent True if string attributes are present in streaming case
protected java.util.Map<java.lang.Integer,Instances>	m_waitingTestData Map of waiting test sets when batch filtering

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
Filter()

Method Summary

Modifier and Type	Method and Description
protected void	checkPendingStreaming() Check to see if there are any pending instances to output from the filter
Filter	getFilter() Get the filter.
java.util.List<java.lang.String>	getIncomingConnectionTypes() Get a list of incoming connection types that this step can accept.
java.util.List<java.lang.String>	getOutgoingConnectionTypes() Get a list of outgoing connection types that this step can produce.
java.lang.Class	getWrappedAlgorithmClass() Get the class of the wrapped algorithm
Instances	outputStructureForConnectionType(java.lang.String connectionName) If possible, get the output structure for the named connection type as a header-only set of instances.
protected void	processBatch(Instances batch, java.lang.String conType, Filter filterToUse, java.lang.Integer setNum, java.lang.Integer maxSetNum) Process a batch of instances with a supplied filter
protected void	processFirstBatch(Instances batch, java.lang.String conType, java.lang.Integer setNum, java.lang.Integer maxSetNum) Processes the first batch of instances via the filter
void	processIncoming(Data data) Process an incoming data payload (if the step accepts incoming connections)
protected void	processStreaming(Data data) Process an instance
protected void	processSubsequentBatch(Instances batch, java.lang.String conType, java.lang.Integer setNum, java.lang.Integer maxSetNum) Processes batches of instances that occur after the first batch
void	setFilter(Filter filter) Set the filter.
void	setWrappedAlgorithm(java.lang.Object algo) Set the wrapped algorithm (filter)
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, 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_filterTemplate

protected Filter m_filterTemplate

Template filter

m_streamingFilter

protected Filter m_streamingFilter

Used when processing streaming data

m_isReset

protected boolean m_isReset

True if we've been reset

m_streaming

protected boolean m_streaming

True if we're streaming

m_stringAttsPresent

protected boolean m_stringAttsPresent

True if string attributes are present in streaming case

m_filterMap

protected java.util.Map<java.lang.Integer,Filter> m_filterMap

Map of filters that have processed the first batch

m_waitingTestData

protected java.util.Map<java.lang.Integer,Instances> m_waitingTestData

Map of waiting test sets when batch filtering

m_incrementalData

protected Data m_incrementalData

Data object to reuse when processing incrementally

m_setCount

protected java.util.concurrent.atomic.AtomicInteger m_setCount

Keeps track of the number of train/test batches processed

Constructor Detail

Filter

public Filter()

Method Detail

getWrappedAlgorithmClass

public java.lang.Class getWrappedAlgorithmClass()

Get the class of the wrapped algorithm

Specified by:

getWrappedAlgorithmClass in class WekaAlgorithmWrapper

Returns:

the class of the wrapped algorithm

setWrappedAlgorithm

public void setWrappedAlgorithm(java.lang.Object algo)

Set the wrapped algorithm (filter)

Overrides:

setWrappedAlgorithm in class WekaAlgorithmWrapper

Parameters:

algo - the algorithm to wrap

setFilter

@ProgrammaticProperty
public void setFilter(Filter filter)

Set the filter. Calls setWrappedAlgorithm()

Parameters:

filter - the filter to use

getFilter

public Filter getFilter()

Get the filter. Convenience method that calls getWrappedAlgorithm()

Returns:

the filter

getIncomingConnectionTypes

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

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.

Returns:

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

getOutgoingConnectionTypes

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

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.

Returns:

a list of outgoing connections that this step can produce

stepInit

public void stepInit()
              throws WekaException

Initialize the step.

Throws:

WekaException - if a problem occurs during initialization

processIncoming

public void processIncoming(Data data)
                     throws WekaException

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

processFirstBatch

protected void processFirstBatch(Instances batch,
                                 java.lang.String conType,
                                 java.lang.Integer setNum,
                                 java.lang.Integer maxSetNum)
                          throws WekaException

Processes the first batch of instances via the filter

Parameters:

batch - the batch of instances process

conType - the connection type

setNum - the set number of this batch

maxSetNum - the maximum set number

Throws:

WekaException - if a problem occurs

processSubsequentBatch

protected void processSubsequentBatch(Instances batch,
                                      java.lang.String conType,
                                      java.lang.Integer setNum,
                                      java.lang.Integer maxSetNum)
                               throws WekaException

Processes batches of instances that occur after the first batch

Parameters:

batch - the batch of instances to process

conType - the connection type

setNum - the set number of this batch

maxSetNum - the maximum set number

Throws:

WekaException - if a problem occurs

processBatch

protected void processBatch(Instances batch,
                            java.lang.String conType,
                            Filter filterToUse,
                            java.lang.Integer setNum,
                            java.lang.Integer maxSetNum)
                     throws WekaException

Process a batch of instances with a supplied filter

Parameters:

batch - the batch to process

conType - the connection type

filterToUse - the filter to apply

setNum - the set number

maxSetNum - the maximum set number

Throws:

WekaException - if a problem occurs

processStreaming

protected void processStreaming(Data data)
                         throws WekaException

Process an instance

Parameters:

data - the Data object containing the instance

Throws:

WekaException - if a problem occurs

checkPendingStreaming

protected void checkPendingStreaming()
                              throws WekaException

Check to see if there are any pending instances to output from the filter

Throws:

WekaException - if a problem occurs

outputStructureForConnectionType

public Instances outputStructureForConnectionType(java.lang.String connectionName)
                                           throws WekaException

If possible, get the output structure for the named connection type as a header-only set of instances. Can return null if the specified connection type is not representable as Instances or cannot be determined at present.

Specified by:

outputStructureForConnectionType in interface Step

Overrides:

outputStructureForConnectionType in class BaseStep

Parameters:

connectionName - the name of the connection type to get the output structure for

Returns:

the output structure as a header-only Instances object

Throws:

WekaException - if a problem occurs