Back

CiTRuS - final version

The following is the final version of the CiTRuS model - my extension of the popular CTRNN. CiTRuS augments the CTRNN equation so that single nodes can perform multiplication and latching. Latching allows a node to be frozen at its current value indefinitely, or quickly brought to a value determined by its current inputs, thus allowing it to act as an eraseable memory. This is achieved by making the node's rate of change, analogous to the CTRNN time constant parameter, a variable that is determined by a new set of node inputs through a sigmoid function. Multiplication is implemented by a new type of weight which takes two node outputs and sends the weighted product as input to another node. This is analogous to "sigma-pi" networks.

There are two CiTRuS variants. The first is used when the number of nodes is fixed in advanced and we wish to have a fully connected network topology. The second is for when we wish to evolve the number of nodes and the network topology.

Deriving CiTRuS from CTRNN

To implement latching we note that the reciprocal of the time constant is easier to deal with than the time constant itself, since a time constant of infinity (zero rate of change) is a valid property for a node to have, but zero (infinitely fast change) is not. Therefore we take the reciprocal and call it "g", which has a value of zero for very slow change and infinity for infinitely fast change. Now we can have nodes with variable time "constants" by having a function determine the current value, under the influence of a new set of inputs. Each node therefore needs two sets of inputs, one to determine the value of g and another set to determine the normal node input. We make the g function a sigmoidal one so that we can easily constrain the value to be within valid bounds, in particular we must avoid negative values. At this stage we have a CTRNN with variable time "constants". To see what this model looks like in equations imagine setting all phi parameters in fully connected CiTRuS below to zero, all a_i to one and all b_i to zero. This allows latching since, if the input to the g function drives the value to zero, the node state becomes frozen. If the g function input changes to make g large, the node state rapidly comes to an equilibrium value determined by its current ordinary inputs.

Multiplication is performed by a new type of weight, whose magnitude is denoted by phi below, which takes two node outputs and sends the weighted product to the input of another node. The weight can send the value as input to either a node's g function or to its ordinary input term. Thus multiplication is restricted to be applied only to two node outputs at a time. There is no way to get the product of three or more node outputs directly, but by chaining several mutliplies together using reactive (fast responding) intermediate nodes, this limitation can be circumvented.

Fully Connected CiTRuS

As with CTRNN there is a single equation applied to all nodes, the only difference being that each node has different parameter values. N is the number of nodes in the network. For increased readability the equation has been broken into six parts.

$\frac{1}{g_i(I_i^g)}\frac{dy_i}{dt} = -y_i + I_i$
y_i, the state of node i, performs a leaky integration of an input term I_i (this I means all inputs to the node, not sensory input to the controller), with a decay rate set by function g_i and a second input term I_i^g. As will be seen from the definition of g below, the output of the g function is never negative.

$I_i = \sum_{j=1}^N{w_{ij}z_j}+\sum_{j=1}^N{\sum_{k=j}^{N}{\phi_{ijk}z_jz_k}}$
Input I_i is a weighted sum of all node outputs z_j, and of the product of all node pairs z_jz_k. To avoid the redundant case where z₁z₂ is treated as distinct from z₂z₁, we only sum over k starting from j.

$I_i^g = \sum_{j=1}^N{w^g_{ij}z_j}+\sum_{j=1}^N{\sum_{k=j}^{N}{\phi^g_{ijk}z_jz_k}}$
Input I_i^g is a weighted sum of all node outputs z_j, and of the product of all node pairs z_jz_k.

$z_i = (a_i-b_i)\sigma(y_i+c_i)+b_i$
z_i, the output of node i, is a linear mapping of the sigmoid of the node state, y_i. Note that we could for convenience introduce a gain term (d_i) to multiply y_i+c_i before applying the sigmoid, but this is exactly equivalent to a corresponding rescaling of all node input weights.

$g_i(I^g_i) = (a^g_i-b^g_i)\sigma(I^g_i+c^g_i)+b^g_i$
The rate function, g_i, outputs a linear mapping of the sigmoid of input term I_i^g (where a_i and b_i must be positive or zero). Similarly to above we could introduce a gain (d_i^g), but this would not give a true extra degree of freedom.

$\sigma(x) = \frac{1}{1 + e^{-x}}$
The sigmoid function is the standard one, outputting a value between 0 and 1 regardless of the input.

Note that the number of w weights in a network of N nodes will be 2N² and the number of phi weights will be N³+N² (by the formula for an arithmetic series). The total number of parameters will be N³ + 3N² + 6N, compared to N² +2N for CTRNN.

Variable Topology CiTRuS

The equations for variable topology CiTRuS are essentially the same as for fully connected CiTRuS, except that we can dispense with w weights. This is because we can simulate a w weight using a phi weight where one of the nodes has a fixed output. The fixed output node need not be updated in a simulator and could be recognised as such since it would have no inputs. The only issues associated with simulating w weights using phi weight are related to implementation details and can be safely ignored at this stage. We therefore modify the two equations describing the I input terms as follows.

$I_i = \sum_j{\phi_{j}z_{j1}z_{j2}}$
$I_i^g = \sum_j{\phi^g_{j}z_{j1}z_{j2}}$

The subscripting system used here is different from that of the fully connected model, and is intended to be as concise as possible. All phi weights are assumed to be numbered globally rather than relative to their parent node. The summation over j is here intended to implicitly mean over all values where phi weight j inputs to I_i (or I_i^g respectively). j1 and j2 evaluate to the subscript of the two nodes inputting to phi weight j. Topologically we have N nodes and M phi weights. Each phi weight is connected to three (not neccessarily unique) nodes, two as input and one as output. The output maybe to the receiving node's I or I^g term.

This completes the definition of the CiTRuS model. The type of mutation operators suitable for this type of network will be treated separately.