heart.inference

Class InferenceAlgorithm

java.lang.Object

heart.inference.InferenceAlgorithm

Direct Known Subclasses:

DataDrivenInference, FixedOrderInference, GoalDrivenInference

public abstract class InferenceAlgorithm
extends java.lang.Object

Created by sbk on 20.03.15. This is an abstract class for inference algorithms used by HeaRTDroid inference engine. There are three obligatory methods that has to eb implemented, and these are: runRules(Table t) method that processes rules within a table, handles conflict set and so on, initStackForAttributes(heart.inference.InferenceAlgorithm.AttributeParameters) that prepares initial stack for a given attribute that should be processed to obtain the attribute value, initStackForTables(heart.inference.InferenceAlgorithm.TableParameters) that prepares initial stack for tables that should be processed. There are also two methods onPreExecute() and onPostExecute(), which defined actions which should be performed before and after inference. The original implementation performs locking and unlocking time in WorkingMemory object, and thus even while overriding this methods a super implementation should always be called first. The intentional use of Inference algorithm is new InferenceAlgorithm(...).start(...), which is similar to running Threads in Java.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	InferenceAlgorithm.AttributeParameters
static class	InferenceAlgorithm.TableParameters

Constructor Summary

Constructors

Constructor and Description
InferenceAlgorithm(WorkingMemory wm, XTTModel model, Configuration conf) The constructor that collect all the required information for the inference process to be executed.

Method Summary

Modifier and Type	Method and Description
Configuration	getConf()
XTTModel	getModel()
java.util.Stack<Table>	getTablesToFire()
WorkingMemory	getWm()
protected abstract java.util.Stack<Table>	initStackForAttributes(InferenceAlgorithm.AttributeParameters attributeParameters) The method creates an initial stack of Tables that should be processed by the runRules(Table t) method.
protected abstract java.util.Stack<Table>	initStackForTables(InferenceAlgorithm.TableParameters tableParameters) The method creates an initial stack of Tables that should be processed by the runRules(Table t) method This is only an initial state and it can be modified during the inference.
boolean	isTableStackEmpty() It checks if the table stack is empty
void	onPostExecute() This methods contains all operations that should be performed after inference process starts.
void	onPreExecute() This methods contains all operations that should be performed before inference process starts.
Table	peakTable() It returned first Table form the stack without removeing it.
Table	popTable() It removes the first Table from stack and returns it.
Table	pushTable(Table t) The method pushes Table given as a parameter to the stack.
protected void	runRules(Table table) The method that is called to perform inference.
void	setConf(Configuration conf)
void	setModel(XTTModel model)
void	setTablesToFire(java.util.Stack<Table> tablesToFire)
void	setWm(WorkingMemory wm)
void	start(InferenceAlgorithm.AttributeParameters ap) A method that executes all the inference methods in the following order: onPreExecute(), then initStackForAttributes(heart.inference.InferenceAlgorithm.AttributeParameters) i} is called to create the staring point for the algorithm, then, in a loop, runRules(Table t) until there are tables on the stack, and after the loop is finished onPostExecute()
void	start(InferenceAlgorithm.TableParameters tp) A method that executes all the inference methods in the following order: onPreExecute(), then initStackForTables(heart.inference.InferenceAlgorithm.TableParameters) is called to create the staring point for the algorithm, then, in a loop, runRules(Table t) until there are tables on the stack, and after the loop is finished onPostExecute()

Methods inherited from class java.lang.Object

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

Constructor Detail

InferenceAlgorithm

public InferenceAlgorithm(WorkingMemory wm,
                          XTTModel model,
                          Configuration conf)

The constructor that collect all the required information for the inference process to be executed.

Parameters:

wm - a WorkingMemory element from HeaRT inference engine

model - a XTTModel that will be used to infer data

conf - a Configuration object defining uncertainty handling mechanism, conflict set resolution, initial state and others.

Method Detail

onPreExecute

public void onPreExecute()

This methods contains all operations that should be performed before inference process starts. This includes locking time in Working memory component. If you override this methods make sure to call its super implementation.

onPostExecute

public void onPostExecute()

This methods contains all operations that should be performed after inference process starts. This includes unlocking time in Working memory component. If you override this methods make sure to call its super implementation.

pushTable

public Table pushTable(Table t)

The method pushes Table given as a parameter to the stack.

Parameters:

t - table to be pushed to the stack

Returns:

table that have been pushed to the stack or null in case of failure.

popTable

public Table popTable()

It removes the first Table from stack and returns it.

Returns:

first table form the stack

peakTable

public Table peakTable()

It returned first Table form the stack without removeing it.

Returns:

first table form the stack

isTableStackEmpty

public boolean isTableStackEmpty()

It checks if the table stack is empty

Returns:

true if empty, false in other cases

runRules

protected void runRules(Table table)
                 throws InferenceInterruptedException,
                        java.lang.UnsupportedOperationException

The method that is called to perform inference. This method should process all the rules within a Table given as a parameter. This method should not be called manually, but instead a or {@link #start(heart.inference.InferenceAlgorithm.AttributeParameters)} method should be used

Parameters:

table - an XTT2 table form the model which rules should be processed

Throws:

InferenceInterruptedException - the exception that should be thrown in order to stop processing current table and move to another table from the stack

java.lang.UnsupportedOperationException

initStackForAttributes

protected abstract java.util.Stack<Table> initStackForAttributes(InferenceAlgorithm.AttributeParameters attributeParameters)

The method creates an initial stack of Tables that should be processed by the runRules(Table t) method. This is only an initial state and it can be modified during the inference. However for some inference modes this initial stack will be the final.

Parameters:

attributeParameters - attributes names which values should be obtain in the inference process

Returns:

stack fo tables to be fired. This stack can be later modified during the inference process in runRules(Table t) method.

initStackForTables

protected abstract java.util.Stack<Table> initStackForTables(InferenceAlgorithm.TableParameters tableParameters)

The method creates an initial stack of Tables that should be processed by the runRules(Table t) method This is only an initial state and it can be modified during the inference. However for some inference modes this initial stack will be the final.

Parameters:

tableParameters - tables names that are the parameters to the inference engine. This could mean different things in different reasoning modes.

Returns:

stack fo tables to be fired. This stack can be later modified during the inference process in runRules(Table t) method.

start

public final void start(InferenceAlgorithm.AttributeParameters ap)

A method that executes all the inference methods in the following order: onPreExecute(), then initStackForAttributes(heart.inference.InferenceAlgorithm.AttributeParameters) i} is called to create the staring point for the algorithm, then, in a loop, runRules(Table t) until there are tables on the stack, and after the loop is finished onPostExecute()

Parameters:

ap - attributes names which values should be obtain in the inference process

start

public final void start(InferenceAlgorithm.TableParameters tp)

A method that executes all the inference methods in the following order: onPreExecute(), then initStackForTables(heart.inference.InferenceAlgorithm.TableParameters) is called to create the staring point for the algorithm, then, in a loop, runRules(Table t) until there are tables on the stack, and after the loop is finished onPostExecute()

Parameters:

tp - tables names that are the parameters to the inference engine. This could mean different things in different reasoning modes.

getWm

public WorkingMemory getWm()

setWm

public void setWm(WorkingMemory wm)

getModel

public XTTModel getModel()

setModel

public void setModel(XTTModel model)

getConf

public Configuration getConf()

setConf

public void setConf(Configuration conf)

getTablesToFire

public java.util.Stack<Table> getTablesToFire()

setTablesToFire

public void setTablesToFire(java.util.Stack<Table> tablesToFire)