Node (aika 0.9 API)

java.lang.Object
- org.aika.AbstractNode<Provider<T>>
- - org.aika.lattice.Node<T,A>

All Implemented Interfaces:

Comparable<Node>, Writable

Direct Known Subclasses:

AndNode, InputNode, OrNode
```
public abstract class Node<T extends Node,A extends NodeActivation<T>>
extends AbstractNode<Provider<T>>
implements Comparable<Node>
```
The Node class is the abstract class for all the boolean logic nodes underneath the neural network layer. These nodes form a boolean representation for all the neurons of the neural network. Whenever changes occur to the synapse weights in the neural layer, then the structure of the boolean representation needs to be adjusted. Several neurons, however, might share common substructures in this boolean representation. 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 class OrNode is a disjunction of either input-nodes or and-nodes. The or-node is connected with one of the neurons.

Each logic node has a set of activations. The activations are stored in the thread local data structure ThreadState.

Author:

Lukas Molzberger

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Node.RidVisited` Aika extensively uses graph coloring techniques.
`static class`	`Node.ThreadState<T extends Node,A extends NodeActivation<T>>` The `ThreadState` is a thread local data structure containing the activations of a single document for a specific logic node.

Field Summary

Fields
Modifier and Type	Field and Description
`static Comparator<NodeActivation.Key>`	`BEGIN_COMP`
`static Comparator<NodeActivation.Key>`	`END_COMP`
`boolean`	`endRequired`
`int`	`frequency`
`boolean`	`frequencyHasChanged`
`int`	`instanceSum`
`boolean`	`isDiscovered`
`boolean`	`isQueued`
`int`	`level`
`ReadWriteLock`	`lock`
`static Node`	`MAX_NODE`
`static int`	`MAX_RID`
`static Node`	`MIN_NODE`
`int`	`nOffset`
`double`	`nullHypFreq`
`int`	`numberOfNeuronRefs`
`double`	`oldNullHypFreq`
`long`	`queueId`
`static Comparator<NodeActivation.Key>`	`RID_COMP`
`boolean`	`ridRequired`
`int`	`sizeSum`
`Node.ThreadState<T,A>[]`	`threads`
`static long`	`visitedCounter`

Fields inherited from class org.aika.AbstractNode
lastUsedDocumentId, provider

Constructor Summary

Constructors
Modifier Constructor and Description

protected Node()

Node(Model m, int level)

Constructors
Modifier	Constructor and Description
`protected`	`Node()`
	`Node(Model m, int level)`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`static <T extends Node,A extends NodeActivation<T>> void`	`addActivationAndPropagate(Document doc, NodeActivation.Key<T> ak, Collection<NodeActivation<?>> inputActs)` Add a new activation to this logic node and further propagate this activation through the network.
`abstract void`	`changeNumberOfNeuronRefs(int threadId, long v, int d)`
`abstract void`	`cleanup(Model m)`
`void`	`clearActivations(Document doc)`
`void`	`clearActivations(int threadId)`
`void`	`clearActivations(Model m)`
`int`	`compareTo(Node n)`
`abstract void`	`computeNullHyp(Model m)`
`abstract double`	`computeSynapseWeightSum(Integer offset, INeuron n)`
`void`	`count(int threadId)`
`abstract void`	`discover(Document doc, NodeActivation<T> act, TrainConfig trainConfig)`
`Collection<A>`	`getActivations(Document doc)`
`A`	`getFirstActivation(Document doc)`
`String`	`getNeuronLabel()`
`Node.ThreadState<T,A>`	`getThreadState(int threadId, boolean create)`
`abstract boolean`	`isAllowedOption(int threadId, InterprNode n, NodeActivation<?> act, long v)`
`boolean`	`isCovered(int threadId, Integer offset, long v)`
`abstract boolean`	`isExpandable()`
`boolean`	`isPublic()`
`boolean`	`isRequired()`
`abstract String`	`logicToString()`
`void`	`processChanges(Document doc)` Process all added or removed activation for this logic node.
`abstract void`	`propagateAddedActivation(Document doc, A act, InterprNode conflict)` Propagate an activation to the next node or the next neuron that is depending on the current node.
`abstract void`	`propagateRemovedActivation(Document doc, NodeActivation act)`
`void`	`readFields(DataInput in, Model m)` Deserialize the fields of this object from `in`.
`static Node`	`readNode(DataInput in, Provider p)`
`void`	`register(A act, Document doc)`
`static <T extends Node,A extends NodeActivation<T>> void`	`removeActivationAndPropagate(Document doc, A act, Collection<NodeActivation<?>> inputActs)`
`String`	`toString()`
`void`	`unregister(A act, Document doc)`
`String`	`weightsToString()`
`void`	`write(DataOutput out)` Serialize the fields of this object to `out`.

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_RID
```
public static int MAX_RID
```

MIN_NODE
```
public static final Node MIN_NODE
```

MAX_NODE
```
public static final Node MAX_NODE
```

level
```
public int level
```

frequency
```
public volatile int frequency
```

nullHypFreq
```
public volatile double nullHypFreq
```

oldNullHypFreq
```
public volatile double oldNullHypFreq
```

isDiscovered
```
public boolean isDiscovered
```

endRequired
```
public boolean endRequired
```

ridRequired
```
public boolean ridRequired
```

numberOfNeuronRefs
```
public volatile int numberOfNeuronRefs
```

frequencyHasChanged

public volatile boolean frequencyHasChanged

nOffset
```
public volatile int nOffset
```

sizeSum
```
public volatile int sizeSum
```

instanceSum
```
public volatile int instanceSum
```

lock
```
public ReadWriteLock lock
```

isQueued
```
public boolean isQueued
```

queueId
```
public long queueId
```

visitedCounter
```
public static long visitedCounter
```

threads

public Node.ThreadState<T extends Node,A extends NodeActivation<T>>[] threads

BEGIN_COMP

public static final Comparator<NodeActivation.Key> BEGIN_COMP

END_COMP

public static final Comparator<NodeActivation.Key> END_COMP

RID_COMP

public static final Comparator<NodeActivation.Key> RID_COMP

Constructor Detail

Node
```
protected Node()
```

Node

public Node(Model m,
            int level)

Method Detail

getThreadState

public Node.ThreadState<T,A> getThreadState(int threadId,
                                            boolean create)

propagateAddedActivation

public abstract void propagateAddedActivation(Document doc,
                                              A act,
                                              InterprNode conflict)

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

Parameters:: doc -; act -; conflict -

propagateRemovedActivation

public abstract void propagateRemovedActivation(Document doc,
                                                NodeActivation act)

isAllowedOption

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

cleanup

public abstract void cleanup(Model m)

computeSynapseWeightSum

public abstract double computeSynapseWeightSum(Integer offset,
                                               INeuron n)

logicToString

public abstract String logicToString()

discover

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

computeNullHyp

public abstract void computeNullHyp(Model m)

isExpandable

public abstract boolean isExpandable()

changeNumberOfNeuronRefs

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

count
```
public void count(int threadId)
```

register

public void register(A act,
                     Document doc)

unregister

public void unregister(A act,
                       Document doc)

processChanges
```
public void processChanges(Document doc)
```
Process all added or removed activation for this logic node.

Parameters:

doc -

addActivationAndPropagate

public static <T extends Node,A extends NodeActivation<T>> void addActivationAndPropagate(Document doc,
                                                                                          NodeActivation.Key<T> ak,
                                                                                          Collection<NodeActivation<?>> inputActs)

Add a new activation to this logic node and further propagate this activation through the network. This activation, however, will not be added immediately. This method only adds a request to the activations queue in the document. The activation will be added when the method Node.processChanges(Document doc) is called.

Parameters:: doc -; ak -; inputActs -

removeActivationAndPropagate

public static <T extends Node,A extends NodeActivation<T>> void removeActivationAndPropagate(Document doc,
                                                                                             A act,
                                                                                             Collection<NodeActivation<?>> inputActs)

getActivations

public Collection<A> getActivations(Document doc)

getFirstActivation

public A getFirstActivation(Document doc)

clearActivations

public void clearActivations(Document doc)

clearActivations

public void clearActivations(int threadId)

clearActivations

public void clearActivations(Model m)

isPublic
```
public boolean isPublic()
```

isCovered

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

Throws:: Node.ThreadState.RidOutOfRange

isRequired
```
public boolean isRequired()
```

getNeuronLabel
```
public String getNeuronLabel()
```

toString
```
public String toString()
```
Overrides:

toString in class Object

weightsToString
```
public String weightsToString()
```

compareTo
```
public int compareTo(Node n)
```
Specified by:

compareTo in interface Comparable<Node>

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

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

Parameters:

in - DataInput to deseriablize this object from.

Throws:

IOException

readNode

public static Node readNode(DataInput in,
                            Provider p)
                     throws IOException

Throws:: IOException

Class Node<T extends Node,A extends NodeActivation<T>>

Nested Class Summary

Field Summary

Fields inherited from class org.aika.AbstractNode

Constructor Summary

Method Summary

Methods inherited from class org.aika.AbstractNode

Methods inherited from class java.lang.Object

Field Detail

MAX_RID

MIN_NODE

MAX_NODE

level

frequency

nullHypFreq

oldNullHypFreq

isDiscovered

endRequired

ridRequired

numberOfNeuronRefs

frequencyHasChanged

nOffset

sizeSum

instanceSum

lock

isQueued

queueId

visitedCounter

threads

BEGIN_COMP

END_COMP

RID_COMP

Constructor Detail

Node

Node

Method Detail

getThreadState

propagateAddedActivation

propagateRemovedActivation

isAllowedOption

cleanup

computeSynapseWeightSum

logicToString

discover

computeNullHyp

isExpandable

changeNumberOfNeuronRefs

count

register

unregister

processChanges

addActivationAndPropagate

removeActivationAndPropagate

getActivations

getFirstActivation

clearActivations

clearActivations

clearActivations

isPublic

isCovered

isRequired

getNeuronLabel

toString

weightsToString

compareTo

write

readFields

readNode