turducken: an artificial world for studying interscale artificial evolution
Post on 22-Feb-2018
221 Views
Preview:
TRANSCRIPT
-
7/24/2019 Turducken: An artificial world for studying inter scale artificial evolution
1/14
Turducken: An artificial world for studying inter-scale
artificial evolution
Erik Pukinskis
4/17/2007
The goal of this project is to design an ALife system that has a good chance of
supporting open-ended evolution and to do so as simply as possible. This will
hopefully lead to better understanding of what open-ended evolution is and how it
happens. This paper presents a detailed specification of a system which was designed
in order to support tighly coupled multi-scale evolutionary activity and encourage its
emergence.
Background
Previous work, presented in my seminar paperIncreasing Complexity in Artificial
Life Systems,explored several definitions of complexity and ALife research that made
some claims about complexity. It also made four guesses about ways to create ALife
systems that would increase in complexity over time:
1. Use intrinsic fitness and replication functions
2. Create an artificial physics with forces of different strengths
3. Choose the scale of the world in the replication carefully. Replication should
happen on a super-atomic scale (>= 1 order of magnitude larger than atoms)
and the world should be at least 3 (?) orders of magnitude larger than the scale
of replication.
4. Creatures should be built of component systems
The current work, then, tries to put some of these into practice. As it turns out, its
very difficult to define complexity and to work with it experimentally, so Im
focusing on a less abstract goal: an create an ALife system that supports tightly
coupled evolutionary activity at multiple scales, where large scale structures are built
out of the smaller scale structures. An example of this in biology is cells and
organisms. Cells are evolving within organisms, and organisms are evolving their
composition of cells. The holy grail of this project would be to see larger scaleactivity emerge from small: organisms evolving out of a population of cells.
The method being employed is to specify a candidate model in pictures and words,
and then engage in thought experiments about how it would play out, how much
computational power would be required, and its potential for meeting the goal of
multi-scale evolution. This has led to a design specification for an ALife system
which can now be built and experimented with.
Choice points in the design process
Just as important as the specification itself are the motivations behind its properties.
Almost all properties of the model present a tradeoffs between richness andsimplicity. I constantly fought a desire to make the model more and more like the
-
7/24/2019 Turducken: An artificial world for studying inter scale artificial evolution
2/14
physical substrate of the biological world: molecules with complex interactions
emerging from their structure. But the goal is not to replicate the natural world, but to
replicate its properties of complexity and evolutionary activity across scales, and so
made great effort to get the model down to the bear bones that would meet my goal.
There were four major insights that came out of the design process.Physics with multi-scale forces is not important
While it does seem true that some of the complexity that happens at a small scale
(cellular and below) seems to arise from the fact that the physics at that scale is so
varied, the fact that there is such complexity above the cellular level, and indeed much
complexity in structures built entirely of cells, it seems like it would be reasonable to
start with something like cells as the bottom of the pyramid.
That is as deep as the analogy gets something like. The point is not to duplicate
their behavior, but rather to create objects that might play a vaguely similar role in
larger-scale structures.Intrinsicness is a continuum
Another one of the major insights that arose from considering a wide range of
possible designs is that intrinsicness of fitness and replication is not a binary property.
A purely extrinsic replication, for example, would simply pull organisms out of a
world, copy them, and place them back in the world, based on an external clock. A
slightly more intrinsic replication scenario would be to put a button in the world that
organisms could push that would replicate them. Then, the hand of god would come
and create a copy. More intrinsic still would be if body parts could be duplicated with
a supernatural machine, but that organisms needed to use their own power to assemble
them. This continuum continues all the way to the point where the entire replication
process takes place in the world, and is subject to all the same selective pressures that
the organisms themselves are.
This insight led me to place several buttons in the environment that allow fairly
limited replication to occur for free. In Turducken, this is basically manifested in the
COPY actuator, which nodes can use to copy a range of classifiers from their
memories into other nodes. This means you can get a simple node that self-replicates
for free. But larger structures require a more complex process which is the subject
of most of the rest of the paper.
The nice thing about having a largely intrinsic replication process like this is thatfitness and replication functions can be entirely done away with. Whether an organism
survives and propagates depends only on whether the organism survives and
propagates. With typical classifier systems, replication and fitness are handled
extrinsically by functions crafted by the developer.
Why is this important? Because intrinsic fitness and replication are an absolute
requirement for organisms to emerge into fitness and replication niches created by
other populations of organisms, and this is a key requirement for multi-scale
organisms. In the real world, a cells fitness is determined by the structure of the
organism, and an organisms fitness is determined by the structure of the cell, both of
which are constantly evolving. Intrinsic fitness and replication give us a fighting
-
7/24/2019 Turducken: An artificial world for studying inter scale artificial evolution
3/14
chance at replicating this phenomena.
Information is impetus for growth
A third major insight came from looking at Hollands classifier systems (Booker,
Goldberg, Holland, 1989). Classifier systems are collections of input-output rules.
They are presented encoded information from an external source, and the informationis matched against the entire body of rules. If the information matches any rules input
pattern, that rule either activates some kind of actuator, or puts out another message
for the other classifiers to consume. The classifiers that get the most work are selected
for by an external fitness function and are allowed to remain in the system, and are
also used to create mutated copies. Classifier systems are a fertile medium, in that
they seem to be able to implement almost anything. Long chains of classifiers can
emerge, with classifiers deeper in the chains consuming more and more refined
information. This suggests a kind of open-ended complexity, with more and more
abstract information being used.
Indeed, this might be a good incentive for organisms growing large in the real world.
In order to be able to process information on larger and larger scales, organisms
would need to grow larger and more complex. It is because of this insight that drove
me to base Turduckens information processing capabilities on classifier systems.
Departure from classifier systems
Early work on this project focused on creating an artificial physics that could support
multi-scale evolution. However in the light of my personal discovery of classifier
systems, I was faced with a choice: do I abandon the artificial physics and start
working entirely in classifier systems? Or should I integrate some of the key
properties of classifier systems into my artificial physics? I ended up choosing thelatter mostly for one particular reason:
Classifier systems have a distinct, independent inside and outside. The inside is
controlled by a genetic algorithm, and the outside is controlled by a third party,
although it might be influenced by the behavior of the classifier system, as mitigated
by the classifier systems body, which is off in the black box of the environment. In
contrast, what I wanted for Turducken was a situation in which life processes
provided the environments for each other and apply selective pressures to each other.
This kind of happens in classifier systems, but in the end the fitness depends on an
external process. In essence, by embodying classifiers in the way I do, I allow them to
mutually define their own fitness landscapes.
The Model
This model is named Turducken, after the kitchy practice of stuffing a turkey with a
chicken and then jamming the entire thing into a duck and roasting it. It is hoped that
the model outlined here will yield a similarly satisfying nesting of organisms, albeit a
nesting of a very different kind.
Turducken is a virtual world populated primarily with nodes (Figure 1), atomic
particles which float around in a soup. Nodes have no real boundaries or substance, in
that two nodes can occupy the same location and can easily pass through one another.
-
7/24/2019 Turducken: An artificial world for studying inter scale artificial evolution
4/14
Figure 1: A single node
One strategy employed in Turducken to provide an incentive for organisms to exploit
niches at multiple scales is to create an information-rich environment which is made
up of organisms themselves. It oes this by embodying properties similar to one of the
simplest-possible information environments that has been proven to support
evolutionary activity: John Hollands classifier system. (FIXME: Citation)
In a typical classifier system, information comes from the outside in the form of
character strings representing sensory input. These strings are then broadcast to a
set of classifiers, which have two parts: a pattern that may or may not match some
sensory input, and an actuator that emits some output signal or broadcasts another
message back to the classifier set.For example, a light detector might generate a string: 11111 that represents a bright
light. A classifier with the pattern 1???? would match that string, and emit an output
signal for the organism to close its eyes. Another classifier that matches strings that
look like 1?1?1 might broadcast another message 10001 back to the classifier set,
which would, also activate the first classifier, causing the eye close actuator to be
activated again.
Turducken creates a similar situation, with some small but important modifications.
First, messages come not from the outside world, but from the nodes themselves. This
allows life to truly provide a foundation for life, and ensure that nodes responding to
messages from other life forms intrinsic to the world are selected for, instead of nodes
that respond well to some extrinsic input. The simplest form of broadcasting is simply
for a node to emit a string (Figure 2) that reaches all nodes in its local area, with a
probability inversely proportional to distance.
Figure 2: Message source
These simple nodes then provide a backdrop for bootstrapping more complex
behaviors. Nodes with movement classifiers (Figure 3) listen for messages of a certain
form, and then move in response to matches. A node could have several classifiers all
pertaining to different directions of movement (up, down, left right).
-
7/24/2019 Turducken: An artificial world for studying inter scale artificial evolution
5/14
Figure 3: Message-driven movement rule
Classifier systems can yield complicated structures of dependency, with chains of
classifiers feeding into each other, but in order to have tightly-coupled classifiers,
each classifier needs to encode information about the other classifiers to which it is
coupled. This makes it harder to have tight-coupling across scales, because both thelarge and small scale must be aware of each other.
This is why Turducken includes a concept of space, motion and several other
constraints that are hard-coded outside of the classifiers. These constraints create an
environment in which classifiers can be coupled, even in exclusively ways, without
having to encode this coupling in their input/output patterns. As described, nodes have
position and motion, but a third property of these classifier bodies is bonds. (Figure
4)
Figure 4: Three bonded nodes
Nodes can bond with other nodes by using the BOND actuator. This actuator
essentially offers a bond conditionally on matching a certain message pattern. So a
node which offers a ???? bond will match any other bond-offering node, whereas a
node offering a 1011 bond will only match generalizations of that string.
The bonding process is shown in Figure 5. Any two nodes in close proximity withmatching bonds offered automatically bond together. Both nodes can then break the
bond with a corresponding BREAK actuator.
Figure 5: The mechanism for node bonding (steps 1-4) and bond breaking (step 5).
Once nodes have been bonded together, they can move as a group with a rubber-
-
7/24/2019 Turducken: An artificial world for studying inter scale artificial evolution
6/14
band effect. One node can move, and the others will be dragged behind it. (Figure 6)
In addition, bonded nodes can send private messages to one another via a MESSAGE
actuator. (Figure 7)
Figure 6: Movement of bonded nodes.
Figure 7: Private communication between bonded nodes.
Detailed specifications for the different actuators and their diagramatic representations
follow:
MOVE(x, y)
Causes the node to try to move x steps horizontally and y steps vertically. The node
may or may not actually move, depending on the stress on its bonds.
The only new actuator used here is the COPY actuator, which erases all of the
classifiers in a bonded node and then copies a subset of the current nodes classifiers
over it.
The next step is to describe how the behavior of the + node might be implemented in a
turducken structure. Ideally, the structure would have some generic set of machinery
and then a string of nodes that contained the actual instructions carried out by +.
BOND(bond_id, pattern, message)
Where bond_id is a number to use as a label for the bond, pattern is the pattern that
-
7/24/2019 Turducken: An artificial world for studying inter scale artificial evolution
7/14
needs to be matched by the other node which is offering a bond, and message is the
message to broadcast when the bond is formed. If the bond_id is left blank, a bond
will be formed with no ID, and if the message is left blank, no message will be
broadcasted
BCAST(message)Broadcasts messages to nearby nodes. The message strength would fall-off at
longer distances, meaning the probability of reception would decrease. Therefore a
large array of nodes could reliably hear fainter messages.
MSG(bond_id, message)
Sends a message to the single node that is connected on bond_id.
COPY(first_classifier, last_classifier, bond_id)
Copies the invoking nodes classifiers to the node connected on bond_id. Only in the
numerical range provided are copied.
BREAK(bond_id)
Breaks the bond with the given bond_id.
Intrinsic Fitness and Replication
There are many ways to self-replicate, and parasites often exploit highly creative
reproductive niches, but a good starting point for self-replication is to break the
process down into three tasks: describing the activity of building an organism,
describing the mechanism by which a blueprint is decoded into that activity, and
describing the mechanism by which the blueprint gets copied.
Lets start by examining a mechanism by which structures in Turducken might be
built.
Self-Replication
A simple self-replicating structure in Turducken is complicated enough that it needs
to be looked at in parts. To do this, we will assume temporarily that we already have a
nettwork of nodes (represented by the + node) which can carry out a sequence of
actions. Later on well describe how the + node could be implemented. Figure 8
details the steps that would be required to build the simplest multi-node structure.
Despite the fact that the target structure is relatively simple (A-B), quite a few stepsare required, and a good bit of overhead. It turns out, it would be relatively simple to
write up a set of classifiers for a node that would do what + does. It would be a lot of
classifiers, but it would be doable. However, we couldnt simply work those out and
be done, because it that approach wouldnt really work for large-scale objects. Youd
have to have millions of classifiers in one node, and nodes are meant to be simple,
largely atomic information processors. In order to have a large-scale replication
process we need to be able to store the blueprints in a chain of nodes.
The next step is therefore to describe how the behavior of the + node might be
implemented with a structure that reads a chain of nodes.
-
7/24/2019 Turducken: An artificial world for studying inter scale artificial evolution
8/14
Figure 8: Structure building with a god node (the +).
First + Implementation
My first crack at this was to a string of command nodes (A,B,C) and then a sort of
playhead node (~) which would tell a command node to write an instruction to the +
node and then send a message to + to tell it to carry out the command. The ~ and the
command node would then work together to move the + and the ~ on to the next
command node.
This entire process is depicted in figure 9. The system depicted will wait for a
message to come from nearby, because this is sometimes required by the specification
for +. Advancing to the next step without waiting for a message simply requires
adding the actions from ~s [P create] classifier to its [START create] classifier.
The classifiers required for this behavior are shown below:
A and B:
1. M -> COPY(6,7,2)
MSG(2,N)
2. Q -> MSG(2,T)
MSG(0,S)3. S -> BOND(1,R,V)
-
7/24/2019 Turducken: An artificial world for studying inter scale artificial evolution
9/14
-> BOND(2,U,W)
4. V -> BREAK(1)
5. W -> BREAK(2)
6. N -> [do something* create]
BCAST(P) [or let the structure being built broadcast P create]
7. T -> BOND( ,U)
~:
1. START -> MSG(0,M)
2. P -> BOND(1,R)
MSG(0,Q)
3. W -> MSG(1,M)
Note that classifier 6 in the command node could be anything. Its simply whatever
action + is supposed to carry out at that moment. This classifier is the only one that
varies from node A to B to C, and is really the blueprint information.
Figure 9: Initial implementation of + node with genetic chain
There are a few known bugs with this implemention. Classifier 3 in ~ waits for the
W message, signifying one of the bonds in step 7 being made, but really it should
wait for the V message too. This could be done trivially with an extra classifier and
a way to store state. State storage is described in section FIXME below.In addition, ~s bond to node A is bond 0, but when it bonds to node B it has to use a
-
7/24/2019 Turducken: An artificial world for studying inter scale artificial evolution
10/14
new bond: bond 1. That means the classifiers that worked with A will no longer work.
This could probably be fixed by breaking the bond with A before forming the bond
with B.
This still has no mechanism for copying the A-B-C chain, which would need to be
automated somehow. A mechanism for this is described in the Copying theblueprint section below. The real problem, though, is that this setup is awfully
complicated, and it requires a LOT of procedural information to be duplicated and
stored in the A-B-C chain. Ideally that chain would contain only the raw instructions
to be carried out by +. A structure that is much closer to this level is described in the
following section.
Second + Implementation
Figure 10: Second + implementation
After thinking through the initial implementation of +, it seemed like the same
behavior could be accomplished much more simply. My second strategy was to have
the A-B-C nodes just send an encoded command to the + node and have the + nodedecode it and carry it out. This process, depicted in figure 10 required fewer nodes,
however it requires + to have a large number of classifiers for decoding the
commands. Below are the classifiers required for processing the A-B-C sequence,
along with a sample of a few of the decoding classifiers:
A,B,C, etc:
1. P -> MSG(0,[encoded command create])
MSG(1,N)
BREAK(0)
2. N -> BOND(0,M,P)
-
7/24/2019 Turducken: An artificial world for studying inter scale artificial evolution
11/14
+:
1. Q -> BOND( ,M)
MOVE?,? -> MOVE(\1,\2)
BOND?,?,? -> BOND(\1,\2,\3)
BCAST? -> BCAST(\1)
etc
Note that Ive introduced a new feature here in the classifiers, which is the actual
content of blocks of ?s can be referenced in the actuator part of the classifier with an
escaped number.
More ?s would likely have to be used to be able to use longer messages. Or perhaps a
* operator should be introduced so that ?* would match a string of any length.
State
In order to have the + node wait for a certain message before proceeding, we need
some way to store state. This is pretty trivial, but it requires two nodes. (Figure 11)The first node contains both states of the second node, and the second node essentially
asks the first node to rewrite it in order to change state.
Figure 11: Storing state
Waiting for messages with the second implementation
Our original implementation of + described how the + could have an instruction that
would wait for a message before it executed. This doesnt automatically work in the
new system, because we need a way to prevent the message from having an effect
until that piece of the genetic code is activated. This is why we needed a way to
store state, and the mechanism described for storing state provides us with our
solution.
Figure 12 depicts a node tuple (S and B) which has an ON state and an OFF state, andonly responds to a message when in the ON state. The ON state responds to a
message, and the OFF state doesnt. The mechanism pictured is basically the same as
the one in figure 10, except with a few extra classifiers for changing state.
This situation still has a few bugs. Likely, the mechanism should change the state
back to OFF after advancing to the next node (C, not pictured). However, it can
change the state to off in just the same way it changed it to ON, by S copying Bs new
state onto it. There is no need to belabor the process.
-
7/24/2019 Turducken: An artificial world for studying inter scale artificial evolution
12/14
Figure 12: Second + implementation, with waiting
Copying the blueprint
The last big unexplained component of a self-reproducing Turducken structure is the
replication of the genetic code, in this case, the A-B-C- chain of nodes. Figure 13
depicts a piece of a rather buggy replication process, but its a starting point. The X
node grabs a free floating node and programs it to try to bond to A. X then tells A to
bond to the free floating node (now programmed as Y) and A does so. A then copies
its code onto Y, turning it into a clone, while X releases A and swings around to bind
to B. A essentially tells B that X is ready for it and B offers a bond to X.
There are several bugs in this process. First, it fails to copy the S (state) nodes, usedfor waiting in during the construction process, which are described above. This is a
tricky issue, but perhaps it could be solved by having the state nodes be part of the
chain, rather than offshoots of it. The second major bug in this copying process is that
it doesnt really describe how the copied nodes come to be bonded to each other.
Obviously in the next few (unpictured) steps X would have to tell the new Y node and
the A node to bond to each other.
The trouble with all of that is that it just puts a lot of complexity into the A-B-C
nodes. And that just seems less than ideal from the perspective of a computer
scientist. But if it works, and its enough to get the process of adaptation started,
maybe its fine.
-
7/24/2019 Turducken: An artificial world for studying inter scale artificial evolution
13/14
Figure 13: Copying the blueprint
Conclusion
The same major criticisms of this project remain from the beginning of the quarter.
Its based on intuition. Theres no data to prove anything. Theres not even really avery good argument about why it ought to work. In fact, I myself have little
confidence that it will work. But it is a much more detailed picture of my intentions
than I had three and a half months ago. And most usefully it allows me to see flaws in
my thinking I couldnt really see before.
And it provides a platform on which to actually test some of my hypotheses. So thats
progress. Still, bugs remain in the self-replication process described here. And its not
clear that any kind of evolutionary activity would happen in a population of these,
especially given that theres no energy being transacted, only information, which
doesnt leave a lot of incentive to evolve.
-
7/24/2019 Turducken: An artificial world for studying inter scale artificial evolution
14/14
Still, parasites could easily be introduced that would attack these larger structures, and
that might provide enough selective pressure to evolve competetive mechanisms that
would then provide a medium for further competition. Id certainly like to give it a
try.
ReferencesLB Booker, DE Goldberg, JH Holland (1989) Classifier systems and genetic
algorithms. Artificial intelligence [0004-3702 create] Booker yr:1989 vol:40 iss:1-3
pg:235
top related