[
Lists Home |
Date Index |
Thread Index
]
Title: Message
Hi
Folks,
Many thanks for the
excellent replies! I am in the process of digesting all your
suggestions.
Here are some
immediate responses:
Jeff Rafter asked
about the goal of this thread. Good question Jeff! I have both a
short-term goal and a long-term goal:
Short-term goal:
understand and get practical experience with growing systems from the
bottom-up. In fact, I am attempting to transform my whole mental
process away from approaching problems exclusively using a top-down
approach, to a bottom-up approach. That is, change my
programming and problem-solving approach from top-down to
bottom-up.
Long-term goal:
apply the principles of bottom-up systems (i.e., Complex Systems) to large-scale
information systems.
Tom Passin suggested
that I look at genetic algorithms. Good suggestion Tom! Although I
am by no means an expert at genetic algorithms, I have some knowledge of the
topic. Unlike genetic algorithms, where a fitness function is determined a
priori, I am seeking ways that the Pickers can improve their fitness on their
own. In fact, in my Vineyard System they already do just that -
Pickers with low metabolisms and high vision endure, Pickers with high
metabolisms and low vision die away.
...
After sending out my
message yesterday, some other thoughts occurred to me:
USEFUL
MUTATIONS
Here are some
mutations that would enhance a Picker's longevity:
1. Enhanced vision:
each Picker is born with a limited vision, between 1 to 6. If a mutation
were to occur in which a Picker's vision is enhanced then that would give
the Picker an advantage over other Pickers, since he is better able to see lots
with large quantities of ripe grapes.
2. Enhanced
movement: currently each Picker's movement is restricted to - left, right, up,
down. If a mutation were to occur in which a Picker could move diagonally
then that would also give the Picker an advantage.
UNTAPPED
CODE
Perhaps someone with
a biology background could answer my question. Is it true that in Nature
the genes already provide the "code" that would be used in a mutation?
That is, if we think of a gene as "code", then when a mutation occurs that
untapped code gets activated. Is that the way mutations work in
Nature?
If that is the case,
then the analogous process in the Vineyard System would be to put into my
stylesheet a bunch of template rules, which ordinarily aren't used. It's
only when a mutation occurs do these template rules start to get
used. What are your thoughts? What kind of mutation would
cause a template rule to suddenly kick in? /Roger
Hi
Folks,
I am interested in
hearing your thoughts on evolving information by mutating XML
elements.
First, some
relevant (and interesting) background information from a book I am reading
[1].
"Where does
diversity come from? In 1983, microbiologist Julian Adams discovered a
clue when he brewed up a soup of cloned E. coli bacteria. He purified
the broth until he had a perfectly homogeneous pool of identical
creatures. He put this soup of clones into a specially constructed
chemostat that provided a uniform environment for them - every E. coli bug had
the same temperature and nutrient bath. Then he let the soup of
identical bugs replicate and ferment. At the end of 400 generations, the
E. coli bacteria had bred new strains of itself with slightly different
genes. Out of a starting point in a constant featureless environment,
life spontaneously diversified."
"A surprised Adams
dissected the genes of the variants (they weren't new species) to find out
what happened. One of the original bugs had undergone a mutation that
caused it to excrete acetate, an organic chemical. A second bug
experienced a mutation that allowed it to make use of the acetate excreted
from the first. Suddenly a symbiotic codependence of acetate maker and
acetate eater had emerged from the uniformity, and the pool diverged into an
ecology."
Cool,
aye?
Now let me relate
this to XML. I have created an XSLT stylesheet which processes
Pickers on a Vineyard. Each Picker makes a decision on where
to move based purely upon local information - a Picker will move to the
nearest lot containing the maximum grapes. After a Picker moves to a lot
it eats some of the grapes on the lot, and stores the remainder. Each
Picker operates independently, using local information. My XSLT
stylesheet simply provides an implementation to carry out these local
decisions. The state of this "Vineyard System" is captured in an XML
document.
I run my
stylesheet over and over (creating hundreds of generations of the Vineyard
System). I have a separate stylesheet which pictorially displays the
state of the Vineyard (i.e., pictorially displays the XML document).
Watching the behavior of the Pickers is fascinating!
I'd like to take
the next step. I would like to introduce small mutations in the Vineyard
System. Currently my Vineyard System is comprised of a bunch
of "cloned" Pickers, i.e., the Vineyard System is a "perfectly
homogeneous pool of identical creatures".
Here is an example
of a Picker:
<picker
id="203">
<location tract-ref="34" lot-ref="9"/>
<grape-wealth>25</grape-wealth>
<metabolism>4</metabolism>
<vision>6</vision>
</picker>
Notes:
1. metabolism =
the number of units of grapes that the Picker must eat each step of the
system, to maintain bodily health.
2. vision = the
number of lots that the Picker can see. Example, a vision of 6 means
that the Picker can see grapes that are 6 lots distant, left, right, up, or
down.
3. grape-wealth =
the number of units of grapes that the Picker has stored, after meeting his
metabolic requirements.
Here is an example
of a lot:
<lot
tract-num"34" lot-num="9">
<grape>
<quantity>4</quantity>
<capacity>5</capacity>
</grape>
</lot>
Notes:
1. capacity = the
maximum amount of grapes that the lot can hold.
2, quantity = the
number of units of ripe grapes currently on the lot.
The Vineyard is
simply a bunch of these lots and Pickers:
<vineyard>
<lot ..>...</lot>
<lot ..>...</lot>
<picker ...>...</picker>
<lot ..>...</lot>
<picker ...>...</picker>
<picker ...>...</picker>
...
</vineyard>
With each step of
the Vineyard System (one run of the stylesheet) this Vineyard.xml document
changes.
Now that you've
seen the way that I store the state of the Vineyard System (Vineyard.xml), and
I've given you some intuition on how my stylesheet operates, do you have
suggestions on how to introduce mutations in the Vineyard System? I
can imagine mutations occurring by means of the stylesheet periodically
generating random, new elements with random data. For
example:
<vineyard>
<lot ..>...</lot>
<lot ..>...</lot>
<picker ...>...</picker>
<lot ..>...</lot>
<fjkele>30fkopcd0</fjkele>
<picker ...>...</picker>
<picker ...>...</picker>
...
</vineyard>
We see the
Vineyard System has mutated to include a new element, <fjkele>, which
has new data, 30fkopcd0. What kind of mutation would be required so that
Pickers can start using this new element and data? Does the stylesheet
need to undergo a mutation? This seems very complicated (especially
trying to mutate a stylesheet). There must be a simpler way to introduce
mutations. What are your thoughts?
Oddly enough, this
book that I am reading is helping me to appreciate the importance of
errors! Here's another interesting paragraph from the
book:
"Error keeps the
glue of coevolutionary relationships from binding too tightly into runaway
spiral deaths, and therefore error keeps a coevolutionary system afloat and
moving forward. Honor thy errors."
I think that this
topic is incredibly fascinating. Hopefully some of you will
share my excitement. /Roger
[1] Out of Control
- The New Biology of Machines, Social Systems, and the Economic World by Kevin
Kelly
| 