org.aika.lattice

Class AndNode

java.lang.Object

org.aika.AbstractNode<Provider<T>>

org.aika.lattice.Node<AndNode,NodeActivation<AndNode>>

org.aika.lattice.AndNode

All Implemented Interfaces:

Comparable<Node>, Writable

public class AndNode
extends Node<AndNode,NodeActivation<AndNode>>

The InputNode and the AndNode classes together form a pattern lattice, containing all possible substructures of any given conjunction. For example if we have the conjunction ABCD where A, B, C, D are the inputs, then the pattern lattice will contain the nodes ABCD, ABC, ABD, ACD, BCD, AB, AC, AD, BC, BD, CD, A, B, C, D. The pattern lattice is organized in layers, where each layer only contains conjunctions/patterns of the same size. These layers are connected through refinements. For example the and-node ABD on layer 3 is connected to the and-node ABCD on layer 4 via the refinement C.

Author:

Lukas Molzberger

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	AndNode.Refinement

Nested classes/interfaces inherited from class org.aika.lattice.Node

Node.RidVisited, Node.ThreadState<T extends Node,A extends NodeActivation<T>>

Field Summary

Fields

Modifier and Type	Field and Description
static int	MAX_AND_NODE_SIZE
static int	MAX_NODES
static int	MAX_RID_RANGE
int	numberOfPositionsNotify

Fields inherited from class org.aika.lattice.Node

BEGIN_COMP, END_COMP, endRequired, frequency, frequencyHasChanged, instanceSum, isDiscovered, isQueued, level, lock, MAX_NODE, MAX_RID, MIN_NODE, nOffset, nullHypFreq, numberOfNeuronRefs, oldNullHypFreq, queueId, RID_COMP, ridRequired, sizeSum, threads, visitedCounter

Fields inherited from class org.aika.AbstractNode

lastUsedDocumentId, provider

Constructor Summary

Constructors

Constructor and Description
AndNode()
AndNode(Model m, int level, SortedMap<AndNode.Refinement,Provider<? extends Node>> parents)

Method Summary

Modifier and Type	Method and Description
static void	addNextLevelActivation(Document doc, NodeActivation<AndNode> act, NodeActivation<AndNode> secondAct, Provider<AndNode> pnlp, InterprNode conflict)
void	changeNumberOfNeuronRefs(int threadId, long v, int d)
void	cleanup(Model m)
static SortedMap<AndNode.Refinement,Provider<? extends Node>>	computeNextLevelParents(Model m, int threadId, Node pa, AndNode.Refinement ref, boolean discoverPatterns)
int	computeNotify(double x)
void	computeNullHyp(Model m)
double	computeSynapseWeightSum(Integer offset, INeuron n)
protected NodeActivation<AndNode>	createActivation(Document doc, NodeActivation.Key ak, boolean isTrainingAct)
static AndNode	createNextLevelNode(Model m, int threadId, Node n, AndNode.Refinement ref, boolean discoverPatterns)
void	deleteActivation(Document doc, NodeActivation act)
void	discover(Document doc, NodeActivation<AndNode> act, TrainConfig trainConfig)
boolean	isAllowedOption(int threadId, InterprNode n, NodeActivation<?> act, long v)
boolean	isCovered(int threadId, Integer offset, long v)
boolean	isExpandable()
String	logicToString()
static Collection<NodeActivation<?>>	prepareInputActs(NodeActivation<?> firstAct, NodeActivation<?> secondAct)
void	propagateAddedActivation(Document doc, NodeActivation act, InterprNode removedConflict) Propagate an activation to the next node or the next neuron that is depending on the current node.
void	propagateRemovedActivation(Document doc, NodeActivation act)
void	readFields(DataInput in, Model m) Deserialize the fields of this object from in.
void	updateWeight(Document doc, TrainConfig trainConfig, long v)
String	weightsToString()
void	write(DataOutput out) Serialize the fields of this object to out.

Methods inherited from class org.aika.lattice.Node

addActivationAndPropagate, clearActivations, clearActivations, clearActivations, compareTo, count, getActivations, getFirstActivation, getNeuronLabel, getThreadState, isPublic, isRequired, processChanges, readNode, register, removeActivationAndPropagate, toString, unregister

Methods inherited from class org.aika.AbstractNode

reactivate, read, suspend

Methods inherited from class java.lang.Object

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

Field Detail

MAX_AND_NODE_SIZE

public static int MAX_AND_NODE_SIZE

MAX_NODES

public static int MAX_NODES

MAX_RID_RANGE

public static int MAX_RID_RANGE

numberOfPositionsNotify

public volatile int numberOfPositionsNotify

Constructor Detail

AndNode

public AndNode()

AndNode

public AndNode(Model m,
               int level,
               SortedMap<AndNode.Refinement,Provider<? extends Node>> parents)

Method Detail

isAllowedOption

public boolean isAllowedOption(int threadId,
                               InterprNode n,
                               NodeActivation<?> act,
                               long v)

Specified by:

isAllowedOption in class Node<AndNode,NodeActivation<AndNode>>

propagateAddedActivation

public void propagateAddedActivation(Document doc,
                                     NodeActivation act,
                                     InterprNode removedConflict)

Description copied from class: Node

Propagate an activation to the next node or the next neuron that is depending on the current node.

Specified by:

propagateAddedActivation in class Node<AndNode,NodeActivation<AndNode>>

propagateRemovedActivation

public void propagateRemovedActivation(Document doc,
                                       NodeActivation act)

Specified by:

propagateRemovedActivation in class Node<AndNode,NodeActivation<AndNode>>

computeNullHyp

public void computeNullHyp(Model m)

Specified by:

computeNullHyp in class Node<AndNode,NodeActivation<AndNode>>

updateWeight

public void updateWeight(Document doc,
                         TrainConfig trainConfig,
                         long v)

computeNotify

public int computeNotify(double x)

cleanup

public void cleanup(Model m)

Specified by:

cleanup in class Node<AndNode,NodeActivation<AndNode>>

discover

public void discover(Document doc,
                     NodeActivation<AndNode> act,
                     TrainConfig trainConfig)

Specified by:

discover in class Node<AndNode,NodeActivation<AndNode>>

isExpandable

public boolean isExpandable()

Specified by:

isExpandable in class Node<AndNode,NodeActivation<AndNode>>

createNextLevelNode

public static AndNode createNextLevelNode(Model m,
                                          int threadId,
                                          Node n,
                                          AndNode.Refinement ref,
                                          boolean discoverPatterns)

addNextLevelActivation

public static void addNextLevelActivation(Document doc,
                                          NodeActivation<AndNode> act,
                                          NodeActivation<AndNode> secondAct,
                                          Provider<AndNode> pnlp,
                                          InterprNode conflict)

changeNumberOfNeuronRefs

public void changeNumberOfNeuronRefs(int threadId,
                                     long v,
                                     int d)

Specified by:

changeNumberOfNeuronRefs in class Node<AndNode,NodeActivation<AndNode>>

prepareInputActs

public static Collection<NodeActivation<?>> prepareInputActs(NodeActivation<?> firstAct,
                                                             NodeActivation<?> secondAct)

computeNextLevelParents

public static SortedMap<AndNode.Refinement,Provider<? extends Node>> computeNextLevelParents(Model m,
                                                                                             int threadId,
                                                                                             Node pa,
                                                                                             AndNode.Refinement ref,
                                                                                             boolean discoverPatterns)

isCovered

public boolean isCovered(int threadId,
                         Integer offset,
                         long v)
                  throws Node.ThreadState.RidOutOfRange

Overrides:

isCovered in class Node<AndNode,NodeActivation<AndNode>>

Throws:

Node.ThreadState.RidOutOfRange

computeSynapseWeightSum

public double computeSynapseWeightSum(Integer offset,
                                      INeuron n)

Specified by:

computeSynapseWeightSum in class Node<AndNode,NodeActivation<AndNode>>

createActivation

protected NodeActivation<AndNode> createActivation(Document doc,
                                                   NodeActivation.Key ak,
                                                   boolean isTrainingAct)

deleteActivation

public void deleteActivation(Document doc,
                             NodeActivation act)

logicToString

public String logicToString()

Specified by:

logicToString in class Node<AndNode,NodeActivation<AndNode>>

weightsToString

public String weightsToString()

Overrides:

weightsToString in class Node<AndNode,NodeActivation<AndNode>>

write

public void write(DataOutput out)
           throws IOException

Description copied from interface: Writable

Serialize the fields of this object to out.

Specified by:

write in interface Writable

Overrides:

write in class Node<AndNode,NodeActivation<AndNode>>

Parameters:

out - DataOuput to serialize this object into.

Throws:

IOException

readFields

public void readFields(DataInput in,
                       Model m)
                throws IOException

Description copied from interface: Writable

Deserialize the fields of this object from in.

For efficiency, implementations should attempt to re-use storage in the existing object where possible.

Specified by:

readFields in interface Writable

Overrides:

readFields in class Node<AndNode,NodeActivation<AndNode>>

Parameters:

in - DataInput to deseriablize this object from.

Throws:

IOException