Neuro-Dynamics in a Modular Brain Structure

1. Introduction

This paper describes a modular structure for the E-Sense Artificial Intelligence system. The modules are complicated and algorithmic, but they can be distinguished by fairly basic neuronal functionality. The combined views can therefore increase the understanding in the system and it can be related to neuro-dynamics, with certain basic processes being repeated in different scenarios throughout. The paper elucidates further this biological grounding for the structures and shows how the modules complement each other. A general trait is converting signals into types [6]. This means that an ensemble of input values to a neuron, results in a more singular output that represents a more specific type. While type-based may seem obvious, this paper gives the biological context. The 3-level architecture of the E-Sense model is still essential. The lower database optimises over links, in terms of energy use. It is also like a Large Language Model (LLM) [17], where there are links for both next words and sequences. The middle-level contains an ontology of quite specific terms. There are 2 index layers and then a much fuller layer at the bottom, between it and the database. While all information in the database is merged together, the index terms in the ontology are more orthogonal. This is shown to be useful for separating merged data again, allowing content from single documents to be retrieved. Other middle-level functionality provides a coherence and semantic layer over all documents together. The upper level is more functional [4] and described using a new ordering algorithm. The functions are quite separate units, where a general architecture would need to mix and match them. The upper and lower levels combined may even realise the Kolmogorov-Shannon theory suggested in [3]. The system processes require multiple steps, but designs can also be looked at from a neuronal perspective, which helps to show similarities and differences. The design is largely orthogonal, which means that boolean decisions can be made more often and this removes a lot of the numbers and weights from the system. This results in a computationally simpler system, but with restricted capabilities. Therefore, algorithms are required to compensate for this.

The rest of this paper is organised as follows: section 2 describes some related work. Section 3 introduces the earlier concept-value network [6] and makes biological comparisons. Section 4 describes a search and query process and some of its unique characteristics. Section 5 looks at the ordinator [4] as functional, while Section 6 gives some test results. Finally, Section 7 gives some conclusions on the work.

2. Related Work

Semantics [19] describe meaningful relations between concepts. Ontologies [12] describe the relations between concepts in a very structured and formal way. The ontology of this model is not at that level, but instead, it provides a looser statistical clustering. It is internal and integrated as the middle level. The lower-level memory model uses a different statistical clustering, where the author supposes that this effect is covered in modern AI programs by Word Vectors [16], for example. Fully-connected neuron structures are central to some themes in the system, where this idea is quite common (for example, [1]). Semantic Maps [19] are now quite important and can be constructed for different levels, but possibly as transition layers, to map from holistic to distributed views, for example. In fact, there appears to be some comparisons with the research at Numenta [13], with regards to the overlap of patterns and also placement cells in neural patterns. The intersection of patterns is also very important. This is described further in section 5. The lower-level database stores next links for both tokens and sequences. It is thus an n-gram style of sequencing and quite like a Large Language Model [17] in that respect. The ontology can be used to guide the search, possibly a bit like a Retrieval Augmented Generation (RAG) system [14], but it is internal instead of external. While the current trend is for deep neural networks, some argue that the real brain uses a shallow hierarchy [20], primarily related to the cortical columns. A shallow hierarchy is probably more in keeping with this research as well. The type=based design suggested in section 3 tallies quite well with Yuste [22].

3. Type-Based Design

It seems very obvious that a signal from a neuron is of some type, but these types may be more consistent than first thought, they might synchronise themselves over the whole network and they might even represent physical concepts. In the context of a neuronal network [6], features may be the wiring, where the actual length of the connection is important, because it is related to firing rates and synchronization. Concepts are then neuron groups that link features and concept instances are firing events from those groups. Features therefore, become the static horizontal framework of the neural system and concepts are vertically interconnected combinations of these. The related paper [7] proposed that the biological brain likes to convert diverse input into more singular types. A step back from a neuronal network therefore, is a single neuron that clusters its input nodes. It could be thought that nodes clustered by another node must have something in common, or in a more chaotic structure, there will be sets of branches that typically fire together. They may share a common ‘type’ to fire together. Thus, there is a horizontal association in tree structures that is based more on firing rates and provides similarity across those local clusters. The ontology structure described in section 4, is made of 3 layers, each made from an ensemble-tree unit. The ensemble is only used for constructing the tree, which tries to convert the ensemble content into more type-based clusters. The transposition from ensemble to tree uses each cluster as a row for the frequency grid [9] process. Then to transpose from tree to the next layer ensemble, all tree nodes at one branch level are placed into an ensemble cluster, when transposing to the next tree will filter this further. In the biological brain, the axons are aligned perpendicular to the dendrites [22], so that they can cover as many dendritic inputs as possible and also join with other neurons, with the minimum number of connections [22]. Thus, the axon signal is vertical and instance-based, but signals collected by dendrites from different axons are more horizontal and type-based. Test results in [4] showed that converting node clusters (branches) to new nodes does produce values at nodes that are more typed.

4. Search and Query Process

As with any information system, there needs to be a process for retrieving the information. When documents are added to the lower-level database, they are all merged together. An entry in the database represents a single symbol or word from any document and only contains a list of ‘next’ symbols or words, also from any document. The database is not weighted and so the only way to bias a next symbol is through a n-gram sequence. Sequences in the database can also be recognised through noted start and end symbols, that then provide sequences through the n-gram key sets. There is a particular problem at inflection points, such as encountering ‘and’ or ‘or’ in a sequence. Sometimes, the sequence after the inflection point is not consistent with the one before it. A Unit-Merge Memory [5] has been added to try to recognise sequences through auto-associative methods. The unit-merge network is currently designed for binary input, but it can work with integer input as well and it does help with reliability. Auto-associative networks have a capacity problem and the Unit Memory does use a lot of memory to store all of the integer representations, but it does not have to store every sequence. One possibility is to store only sequences with inflection points, to help to determine what comes after the point. Thus, a rote retrieval of full documents is not really part of the model, but that is not really what the human brain does naturally. As with LLMs, next sequences can also be predicted, not just next symbols. Either can be hashed and stored as a list of next keys.

4.1. De-Merging Stored Content

When documents are added to the database therefore, they are tokenised into sentences and then individual words. The words are added for each full sequence, with start and end tokens to indicate the boundaries. For each document then, an ontology is created that is 3 levels of ensemble plus tree, called a ‘unit of work’ [4]. The first level is quite verbose and stores the most data. The next two levels are much smaller and almost like indexes to the lower level. The ontology in the top level therefore, has very few terms, but they are key and direct the search to specific content. They are also quite orthogonal. A query process can make use of this to ask for content about one topic, for example, where the top two levels will select appropriate lower-level constructs and finally query the database itself. In fact, the query process is from tree to tree only, while the associated ensemble is used only to construct the trees. But what is interesting is that the query process can return content that is mostly from a single document. Most of a small document can be retrieved, even if the sequences are not all in the correct order. This may be quite an original process. It may be that the RAG process for an LLM has been converted into an internal ontology, for example.

4.2. Creating Coherence and Semantic Maps

The ontology is therefore quite specific and not very descriptive. A user would get some meaning from it, but would find it difficult to understand the database content from it. The lower ontology level stores the most information and it really needs to be used when retrieving database content. The ensemble clusters are not used as part of information retrieval, but in the lower ontology level, a new coherence layer can be created that is more useful. The trees in the lower level can return their values as a flat list and these can be processed by a basic reinforcement count, to produce a more coherent set of clusters to the trees. The frequency grid algorithm produces the ensemble clusters, but it can sometimes join separate ones and make them a bit disjoint. A basic reinforcement count can be used to separate these again, where in this case, the counting mechanism [8] is used. This separates the unit of work clusters back into smaller but more coherent ones. After using the counting mechanism, the symbols in each cluster would mostly be from a single sequence and the split cluster set is still mostly from the same source document. The full search process can therefore be, three tree layers and then the coherence layer. With this structure, or maybe for agglomerative clustering in general, the clusters do not really know about each other. The process of splitting gives them some association, when they then know about each other. If the split is also inhibitory, for example, then this might suggest a negative resolution process, where what gets left is the solution.

A Semantic Map [19] can then be generated from the coherence layer. It is typically only 3 levels deep, but this was a construction decision. Concept Trees [11] are the selected structure and they have a simple rule that a child node may not have a larger count than its parent. When that happens, the child node is converted into a new base tree node and a link between its original position and the new base tree is added. For one thing, when adding arbitrary sequences, there is no clear start or end from the original source and so something that can suggest start nodes is useful, which would be the concept tree base nodes. As these have the largest counts, they are also likely to be the most important nodes. However, the final construct is a lot of small trees with many links between them and so there are many entry points into the semantic map. At the moment there is limited applicability, but it is used during the search to retrieve possibilities that are not directly in the query. For example, looking at the next level to what the query matches with.

5. Function Mapping

An Ordinator algorithm has been created that can accurately index and construct an arbitrary ordering, again over lines of text [4]. This could be used to re-construct the same ordering when the text is retrieved again, or even different text that matches sufficiently well. The construction process is very autonomous, where a query result is fed back to produce a new similar result and combining these, filters out index terms and features, and gives them relative positions. Thus, this ordering does not have to strictly follow the rote order in the database, but could be more arbitrary. Full text content can be retrieved from only a few query terms, because adding new terms from feedback provides a sufficient amount overall. The index terms are the more popular text words and features are only made from these terms, but they can repeat in different features. The structure has been simplified slightly from the original design [4] to be only the index terms and related features. This does, in fact, give the 2-layer structure suggested in earlier papers, but the second layer is clusters of nodes from the first layer. Another structure part stores the relative ordering, which is done for each index term separately.

The ordering is currently used to place lines of text, but it is supposed to represent the functional aspect of the model. It is imagined that it will store different types of information, including calculations or activities. The structure was associated with heavy-tailed connectivity [15,18] for each relative position, which is known to be winner-takes-all. This is usually associated with spiking events. Thus, when one pattern is firing, the others would not fire. Tests show that similar text sequences produce similar ordinator content and so there will be consistency here. Indexing the functions would also be useful and a semantic layer can also give a more holistic view. To do this, the features in all ordinators can be processed by a frequency grid, to produce a new set of clusters that have a shared meaning. In this semantic layer, each ordinator can then be represented by a set of semantic clusters. The sets for each function will therefore overlap where the semantic clusters share function values. The holistic to distributed view might again add knowledge, because it helps to categorise and compare the functions. However, ordinators may need to be combined, to satisfy the semantic layer in a general sense.

5.1. Orthogonal and Overlapping Sequences

A theory combining the complexity and entropy theories from the famous researchers Kolmogorov and Shannon, was described in [3], section 5.1. Kolmogorov-like complexity was used to describe sequences that could lead to each Shannon-like function. The sequences would be optimised, so as to get from A to B in the minimum number of steps. This could simply be for information retrieval, for example. The process would not have to be stigmergic [2] however, which was the original idea. In the E-Sense model, database sequences can be retrieved with some ordering from previous and next links, but the links are probably permanent. This database optimisation can largely satisfy the Kolmogorov complexity requirement and the sequential aspect to the theory. The database is closer to the perceived connection with the nervous system and the links produce an ordering that is closer to rote learning, or how the data was entered. Thus, these optimised sequences fit well with more mechanical tasks, such as getting from A to B. With the ordinator functions, there is an idea of entropy, because feedback can continue until there is no change. If the function was then executed, it would repeat and return a result that could be measured. To be consistent with the original design, a function might trigger another one, as part of a schedule or sequence. While the ordering has been proven, the rest is still a work to do. The following Figure 1 is a schematic to show the main data structures and transitions that occur over the whole E-Sense system.

6. Testing the System

The E-Sense program [4] is being written in Java. It is still not an ‘intelligent’ system, but it is possible to run tests and measure results. The lower-level database can be populated with text and sequences, read from documents. Both ensembles and trees are used to store the information in the structures. The middle-level ontology is constructed using transitions between these two structures that also converts the data from sequence-based clusters to types. While the ensemble-to-tree conversion is used to construct the ontology, it is not required for retrieving the data, when the trees can be used by themselves. At least, this is the case for the top 2 ontology layers, where the structure is more like an index. The ontology lower-level is much fuller, but still less populated than the database. During construction, the Frequency Grid [9] is used to generate the ensemble clusters. The lower-level ensemble would only be about 50% consistent with individual sequences. The clusters that are produced are only about 50% consistent with a single sequence from the database and would tend to overlap or include, information from 2 or more sequences. Some cohesion equations were suggested in [8], including a counting mechanism. While the author guesses that a basic reinforcement count may do just as well, applying the counting mechanism to the lower-level trees produced a new set of clusters that were much more cohesive and likely to be 90% consistent with individual sequences. When performing data retrieval therefore, this new coherence layer is used instead of the ensemble.

A query process can start with only one or two terms, and these could be selected from the top-level index nodes in the ontology, for example. As the query moves down the levels, it adds more information from the trees and coherence layer at the bottom. This may even be a bit like an internal RAG process. The database also stores previous and next links to sequences and so sequences not matched with the query can still be retrieved and also put into some type of order through these links. All data is merged in the database and so the query process needs to de-merge it to recognise separate documents. For the ‘Fox and Crow’ story [21], for example, it was able to successfully retrieve only the lines for this story, from a database that also contained the ‘Fox and Stork’ and ‘Fox and Grape’ stories. It was actually able to retrieve all 36 lines, even if some were not ordered correctly. It also did this for the other 2 stories and so the process can naturally de-merge data in the database, using only the ontology as a guide. The upper-level functions have also been tested separately, where similar content will produce a similar Ordinator. There are also common or shared features and ones specific to a function, where a mix-and-match approach could produce new compound functions that may be useful generically, as was described in section 5.

7. Conclusions

This paper gives a modular and dynamic view of the E-Sense AI system, describing where data transitions and the types of structures and algorithms that are used. The same basic concepts appear to repeat, but maybe in different contexts. Key concepts include distributed or holistic, separate or merged, tokenised or vectorised. This allows the complicated-looking system to be described in terms of simpler neuronal functionality. One general trend is to transition from scene-based sets to more specific types. This generates understanding by showing where the disparate scenes are the same. As the structures develop (move upwards in the design) there seems to be a transition from individual tokens to vectors, probably indicating an increase in complexity. To transform the data, the lowest levels prefer token-related processing, but when the clusters become the unit, the frequency grid takes over. Each document is added to the middle ontology level in turn, helping to keep the descriptions separate, even in shared structures. The semantic layers are more holistic and thus provide a contrast to the distributed descriptions. As the amount of data grows however, it is likely that the ontology will begin to share distinct links between documents. The lower database data is all merged into the same token sets, but there is no restriction what sequences get retrieved. Merged data is more economical, but higher-level functions require separation to use it accurately. The upper functional level joins with the ontology level through another semantic layer, which also indexes the functions. The functions are very orthogonal, each typically with a unique set of features, but to use them in a general sense may require combining them through the semantic layer. The lower level data therefore, is closer to sensory data, and would be used unaltered, more like rote learning. The functional data requires a deeper description, so that it can be adapted and re-used. The system is thus quite dynamic, even in a general sense, because the same basic processes are repeated in slightly different scenarios. This can produce the juxtapositions that allow the system to transition and also generates understanding.