An Expedient Mind: The Mechanism for Memory

AN EXPEDIENT MIND

Tartan Hen Publications : Home | more books | Contact : feedback@tartanhen.co.uk

Layer-2 - Introducing Memory

Continuity
Layer-2 begins its development with an enormous advantage. It is standing on the shoulders of layer-1. As layer-2 develops new abilities, layer-1 continues to operate as before. If any of the extra tricks, which evolve in layer-2, should falter, layer-1 will continue to provide a "backup" service. Layer-2 can also access and make use of all the information stored in layer-1.

Clocks
As any control systems engineer will confirm, all that is required to construct a clock, is a mechanism of delayed negative feedback.

A causes an increase in B.
B (after a suitable delay) causes a decrease in A.

These circumstances arise naturally in connected systems of all kinds. If the helmsman of a ship is half-asleep and does not correct steering errors until the ship has gone some distance off course, then the ship will oscillate from side to side of its true course. If a government delays and then over-corrects for inflation or deflation, the result is overshoot and oscillations between the two conditions. If A and B are chemical reactions then the result is again overshoot with the concentrations of the chemicals involved oscillating. It is actually quite difficult (again as control engineers will confirm) to eliminate unwanted oscillations in systems with complicated feedback controls. It is, therefore, scarcely surprising that there are oscillations within the chemistry of the brain. Pulses of chemicals will inevitably generate periodic nerve impulses. So, if we provided our system with a clock mechanism, we would be merely imitating something which often arises spontaneously in nature. Let us assume, therefore, that the system has a clock, or several clocks, and that these are available for the system to bend to its advantage.

The Segmentation of Time
Why are clocks important? When #Signals impinge on a #perception, the #perception analyses the #signal pattern and responds with a positive or a negative output #signal. (A negative #signal is one which has a magnitude less than some arbitary threshold level.) But that does not happen instantaneously. If we look closely and measure time accurately, we will find that the arrival times of those input #signals are staggered, if only by a very small amount. That must be the case. So if the apparatus of perception is to operate as we intend, there must be some kind of shutter mechanism which freezes input #signals, at one particular moment.
Fortunately, the existence of a clock, seems to provide us with exactly the right mechanism to create a shutter mechanism. At each tick of the clock, the input #signals are frozen and the #perception unit does its analysis on that frozen sample of #signals, until the next tick. In effect, the clock mechanism chops time into segments. All events, which occur within a single interval between successive ticks, are regarded as having happened simultaneously.

Data Transfer
Having frozen the input #signals of a #perception, which belong to one time interval, we need to be able to store the information carried by those #signals, before processing the #signals belonging to the next time interval. All we need is for one #perception, to output an exact copy of its input #signals, to another #perception. This arrangement is illustrated below.

FIG: P1 and P2 are #perceptions. The figure is in two parts (1) is the the condition which pertains at time T1 and (2) is the condition which holds at time T2, i.e. at the next tick of the clock. In (1) #perception P1 receives #signals which are recognised as "condition RED". At the next tick of the clock P1 hands on those #signals to P2, and receives a new set of #signals which is recognises as "condition BLUE". Meanwhile, P2 having received the #signals sent to it by P1, now recognises those #signals as "condition RED". So P2, at time T2, shows us the condition which P1 was in one tick of the clock previously. In effect P2 acts as a memory for P1. If a third #perception (not shown) is able, at every tick of the clock, to read the condition of both #perceptions (that is it receives #signals from both #perceptions simultaneously), that third perception will be able to perceive any change of circumstances which has occurred from one tick to the next.

Movement
If the system can recognise change, then it can also recognise movement (change from one location to an adjacent location). All that is required is a re-arrangement of #perceptions and their connections.

#States and the Memory #Trace
We can see readily enough, that the arrangement illustrated above can be repeated many times. If the second #perception hands on the original input #signals, without alteration, to another, and then another, and so on, then we would have a memory trace of what happened at time T1 and at all intervals since T1. A trace like that could stretch over many time intervals. So far I have been talking about one single #perception keeping a memory #trace of its own condition over several time intervals. Consider what we would have if several different #perceptions did the same trick, over the same time interval.

#Trace as a sequence of #States
The structure which I will now call "a #trace", is a memory store of the condition of a collection of the #perceptions stored in layer-1. A collection of that kind, which is the condition of these #perceptions at a single moment in time (as defined by the ticking clock), will be called "a #state". #States play an important role in the mechanism which will be developed later. Note, however, that we did not need to create a new structure to provide the system with #states. They are already there. All that was required to bring #states, into this story, was a different way of looking at what already exists. The diagram below illustrates the relationship between #perception, #state and #trace.

The #Trace as a Memory Store
Where is the advantage in having a #trace? The main advantage is that if the system detected some dangerous condition, the memory of that condition would remain available to it for some time afterwards. That would permit a more elaborate escape behaviour to be developed and continued, after the initial danger signal was detected. If you see a tiger approaching, you run. And you don't stop running, for a while at least, even if you leave the visible signs of that tiger behind.
The #trace can be developed one step at a time. A memory #trace which lasts for only one tick of the clock, is better than none at all. Two ticks would be better than one; three better than two; and so on.

Storage problems
There is, however, a snag. The system cannot keep on adding length to its memory #race without running out of memory space. Also, if it develops a very long memory #trace it may have trouble finding the relevant bit of memory among the rest of the stuff. So diminishing returns begin to take effect and the length of the #trace will be limited. As new information is added to the start of the #trace, the oldest bit of information will fall off the end. The #trace will resemble the vapour trail which extends behind a high flying aircraft. Constantly being created at the start and evaporating at the trailing edge. If the system is going to develop a better memory than that, then some additional mechanism will be needed.

Remembering what is Important
A simple stratagem which allows memory to be extended in a useful way, without being overwhelmed by storage requirements, is to store only what is important.

Question: How can a dumb machine recognise what is important?
Answer: It asks Layer-1 for its priority rating of these events.

It doesn't actually ask. It just processes the priority information along with the rest. If the current condition (or #state) of Layer-1 contains some #perception which has a very high priority rating, the system just records the whole of the current #trace. If you prefer, it takes a snap shot of the current condition and the sequence of events leading to that condition.

#Episodes, and Long Term Memory
If the system is going to do that, it will require somewhere to store the information. We can call this memory store "episodic memory". Every chunk of stuff stored there will be called "an #episode". So an #episode is just a chronological sequence of #states, leading up to one particular #state which contains some #perception of special importance.
What's the advantage? The advantage is considerable provided the system can match the contents of the current #trace with the content of one of these stored #episodes. If it can do that, then it can read the #episode and find out what happened on a previous occasion after that initial condition. In this way, it would acquire the ability to anticipate events, based on its memory of previous experience.

Three snags
(1) This mechanism works only for a few specially remembered episodes.
(2) It takes a certain amount of time to do the processing required.
(3) It requires the ability to compare and match the content of two #states, (and that is harder than it sounds)

Fortunately (1): layer-1 will continue to do its allotted task dealing with a whole range of cicumstances for which the episodic memory mechanism of layer-2 is ill-equipped.

Fortunately (2): there are techniques which can be used to speed up the search for #episodes which match the content of the current #trace. The technique of indexing will be familiar to anyone who has ever used an Internet search engine like Google. While a search is not actually in progress, Google scans the Internet and prepares index lists of very nearly everything it finds there. Every keyword is given an index entry showing all the websites, within which that keyword appears. When a user types in the keywords relevant to his or her search, Google then consults the index lists, and produces these on the screen in a matter of seconds. In effect, Google trades time. It spends time during off-line periods in order to save time during active periods. Our layer-2 mechanism for episodic memory can do the same. It can scan episodic memory, and prepare index lists for all high priority #perceptions. If one or more of these is then encountered in the current #trace, an episode which is similar can be found very quickly.

Fortunately (3): the basic elements of a matching procedure are already available within each #perception. This is the program which enables a #perception to match the input #signals, with its store of relationships which it is expected to find in the #signals. These snippets of program have evolved over a long period of time, from very simple beginnings (as with our simplified flagellate). In these circumstances the evolutionary process can afford to experiment and fail, with only the very occasional success, in developing ever more complicated routines. Since the routines are separated one from the other, (one per #perception) one can fail without disrupting the efficiency of the others. It has to be conceded, however, that the business of matching data structures (and each #perception is a data structure), is generallt recognised in computer science as a very hard problem indeed. For one thing, it is very unlikely that circumstances will ever repeat themselves exactly. Consider what happens when a friend walks into the room on two separate occasions. The friend may the same person, but do the shadows fall in exactly the same way on those two occasions. Is the clock on the mantlepiece pointing to the same time? And so on. These differences may be subtle, but unless we have a clear criterion which can be used to distinguish between significant and insignificant differences, and which we can pass on to that program, the program will not be able to tell the difference.
The problem of matching data structures is, as I have said, one which is well recognised by computer science. There are strategies which can be used to reduce these difficulties but none which will eliminate them altogether. The issue is one which will recur throughout this book. A great deal of what the system does, is dependent upon it being able to identify what is the same and what is different. Because the issue is rather difficult for non-mathematicians (and I include myself in that category), I have relegated further discussion of it, to an appendix which will appear in the addendum later. For the present, I will assume that the system will be able to match #perceptions, and in that way, recognise when events are repeating themselves.

Purging Episodic Memory
Although the storing of #episodes is restricted to just those which have a high priority events, there is still a problem concerning the burgeoning bulk of the episodic memory store. It cannot be allowed to grow indefinitely. There has to be a limit.
The easiest way to limit the size is to purge the store of its contents from time to time. Two way suggest themselves. Purge the store of its oldest #episodes and purge it of the #episodes which have seldom re-occurred. Everytime the re-occurrence of an #episode is recognised in the current #trace, that #episode will be refreshed in some way, giving it an updated time-stamp. At intervals #episodic memory can be purged of all #episodes with time-stamps older than some cut off point. The cut-off decision could also be linked to the priority level carried by a given #episode, so that very important #episodes might be preserved even when they become older than would normally result ini them beiing purged. That sounds to me, very like the way my own memory works. Things long ago usually become hazy, but very traumatic events stay sharp.

Off-line Processing
But now we have another problem. How can the system indulge in this kind of housekeeping activity, purging its episodic memory of memories which have not been found to be useful, and indexing the content of #episodes for rapid retrieval of #episodes which match the current #trace, if it is at the same time, trying to cope with the current #trace and trying to identify within it re-occurrences of previously experienced #episodes? It can't do that. It cannot do these two things at the same time. The answer has to be that the system must go into a dormant state, in order to process and tidy up its own memory store. It must, in computer terminology, go off-line ..... perchance to dream.

Tartan Hen Publications : Home | more books | Contact : feedback@tartanhen.co.uk