originally posted by: Phantom423
a reply to: ChaoticOrder
Adami's Markov Network Brains found here: adamilab.msu.edu...
might be an interesting way of sorting information contained in the gene because:
1. the set of hidden nodes act as memory to store information
2. unlike classic logic gates which are deterministic, the MNB uses a probabilistic logic gates containing arbitrary information.
The Hidden Markov model may be Turing complete because it has recurrent connections in the network which give it a sort of memory storage mechanism.
However I think it's actually a bit more complicated than just having a memory storage mechanism. Artificial neural networks typically take the same
amount of time to produce an answer every time because the calculations performed by each node are finite. However an arbitrary algorithm running on a
Turing machine could take any amount of time to execute, and the Halting problem tells us there is no universal algorithm to determine how long any
other algorithm will take to execute or if it will ever stop.
Humans generally take an indeterminate amount of time to solve a problem. If we think about the problem harder we can solve it more quickly and we
burn more energy doing it. Our brains work a bit like a computer which can dynamically increase its clock speed to run faster when necessary. The
frequency of our brain waves will shift and become more erratic when thinking intensely. It's worth asking the question, should we attempt to evolve
creatures which perform an unpredictable number of computations to produce an answer. The human brain does perform a finite number of computations at
every discrete moment in time but the number of steps required is unpredictable.
We're getting a bit beyond the realm of this discussion now though so let me get back on track. When it comes to neural networks and other similar
networks the thing we need to keep in mind is that they are best suited for solving certain types of problems, usually anything which requires feature
detection in a high dimensional data set. Even though it would be possible, no programmer would want to solve problems using only nodes in a network
because it would be a very inefficient and difficult way of creating algorithms. Instead they will just use a powerful Turing complete programming
language which allows them to solve it in a few lines of code and runs much faster.
The main reason artificial neural networks are so popular in the field of machine learning is because they're inspired by real neural networks and
they can be trained using well known algorithms. But what we're talking about here is when the training algorithm is a genetic algorithm, something
which doesn't search for the answer in a very specific mathematical way. So why restrict ourselves to these networking ideas when we can evolve pretty
much any system we want. I would argue that using a recurrent network isn't the most efficient way to solve many problems if memory is required. When
evolving virtual creatures we really need to consider the type of landscape they are evolving in.
They aren't evolving in a world with particle physics, they are evolving within the architecture of our computers, a world where everything is about
CPU instructions reading and writing digital information to RAM. Think about the first theoretical idea of a Universal Turing Machine, it's
essentially the same thing, just with infinite tape/memory and a little reading head which moves along the tape reading and writing to it based on
some rules. Our computers are the real world example of that theoretical machine without the infinite memory capacity but they work on that same basic
concept. I have thought about ways to evolve Turing-like machines by evolving some sort of instruction set.
I believe that has actually been done before, I remember reading something about it not too long ago. However I think the same problem would arise
with that approach, again it would be difficult and time consuming for a programmer to solve a problem if they were just working with machine
instructions. What we really want to aim for is something which allows the process of evolution to easily stumble upon solutions. By now you may have
already thought "why not just evolve algorithms using actual programming languages if that's an easy and efficient way to solve problems?". Well the
main reason is, a random combination of characters will rarely form valid code.
The vast majority of character combinations will contain syntax errors or some other error, so it would be difficult to evolve solutions using the
random nature of evolution since barely anything would work. This is another reason we tend to use things like artificial neural networks in these
systems, because regardless of how you put together the nodes, they will usually output some sort of answer, even if the answer is completely wrong.
So a key idea here is to use components which don't totally blow up when we put them together in the wrong way. The function unit system I have
described has that property and since the building blocks have useful functions it should be easy to produce solutions.
I want it to be easy to solve problems using these building blocks if all I had to create an algorithm were those building blocks, because then it
should be easier for the process of evolution to stumble upon solutions. I have even considered methods of allowing the process of evolution to
actually determine what the functions are, so the very building blocks the virtual agents are made out of would be subject to change. This is sort of
like allowing the system to decide its own search space which is pretty mind bending stuff, but I believe I have read something on this topic at least
once before, I just cannot remember what it was.
On the topic of probabilistic logic gates, a little bit of randomness is often a good thing because it encourages the use of general solutions which
can work under unexpected conditions. The human brain is prone to random events like particle decay and unexpected problems can occur like neuron
damage. Almost any machine learning model can benefit by injecting a little bit of entropy and unpredictability into the system. The way I plan to do
it in my simulation is to add a little bit of noise to the outputs, maybe also simulate failing and dead components. Another idea is to give the
function units direct access to an entropy pool (memory array full of random numbers).
edit on 31/7/2016 by ChaoticOrder because: (no reason