Uncommon Descent Serving The Intelligent Design Community

Dawkins’ WEASEL: Proximity Search With or Without Locking?

Categories
Darwinism
Evolution
Informatics
Share
Facebook
Twitter/X
LinkedIn
Flipboard
Print
Email

On pp. 47-48 of THE BLIND WATCHMAKER, Richard Dawkins gives two runs of his WEASEL program (note that there were typos in both initial seeds — one had 27 characters, the other 29 whereas they should have 28; I’ve corrected that). Here are the two runs using the Courier typeface, which assigns equal width to each character (spaces are represented by asterisks):


WDL*MNLT*DTJBKWIRZREZLMQCO*P
WDLTMNLT*DTJBSWIRZREZLMQCO*P
MDLDMNLS*ITJISWHRZREZ*MECS*P
MELDINLS*IT*ISWPRKE*Z*WECSEL
METHINGS*IT*ISWLIKE*B*WECSEL
METHINKS*IT*IS*LIKE*I*WEASEL
METHINKS*IT*IS*LIKE*A*WEASEL

Y*YVMQKZPFJXWVHGLAWFVCHQXYPY
Y*YVMQKSPFTXWSHLIKEFV*HQYSPY
YETHINKSPITXISHLIKEFA*WQYSEY
METHINKS*IT*ISSLIKE*A*WEFSEY
METHINKS*IT*ISBLIKE*A*WEASES
METHINKS*IT*ISJLIKE*A*WEASEO
METHINKS*IT*IS*LIKE*A*WEASEP
METHINKS*IT*IS*LIKE*A*WEASEL

These runs are incomplete. The first, according to Dawkins, required 43 iterations to converge, the second 64 (Dawkins omitted the other iterates to save space).

As you can see, by using the Courier font, one can read up from the target sequence METHINKS*IT*IS*LIKE*A*WEASEL, as it were column by column, over each letter of the target sequence. From this it’s clear that once the right letter in the target sequence is latched on to, it locks on and never changes. In other words, in these examples of Dawkins’ WEASEL program as given in his book THE BLIND WATCHMAKER, it never happens (as far as we can tell) that some intermediate sequences achieves the corresponding letter in the target sequence, then loses it, and in the end regains it.

Thus, since Dawkins does not make explicit in THE BLIND WATCHMAKER just how his algorithm works, it is natural to conclude that it is a proximity search with locking (i.e., it locks on characters in the target sequence and never lets go).

Interestingly, when Dawkins did his 1987 BBC Horizons takeoff on his book, he ran the program in front of the film camera:

www.youtube.com/watch?v=5sUQIpFajsg (go to 6:15)

There you see that his WEASEL program does a proximity search without locking (letters in the target sequence appear, disappear, and then reappear).

That leads one to wonder whether the WEASEL program, as Dawkins had programmed and described it in his book, is the same as in the BBC Horizons documentary.

In any case, our chief programmer at the Evolutionary Informatics Lab (www.evoinfo.org) is expanding our WEASEL WARE software to model both these possibilities. Stay tuned.

Comments
Folks: Looks like much of the above is now debating on code and coding. One reminder, the latching and/or quasi-latching can be implemented explicitly or implicitly; as I have specifically pointed out ever since what is 346 - 7 in the previous thread. As a second, Joseph reminded us yesterday, at 264, that BW speaks in terms that the program marched forward inexorably, latching and ratcheting the slightest increments in proximity as it went. So, the letter-wise partitioning search interpretation is a very natural -- "simple" -- one; once we look at the published o/p circa 1986. On a third point, notice that the runs published in 1986 were 40+ and 60+, consistent with partitioned search a la Dembski-Marks [median runs length 98 generations] and presentation of good runs. By contrast we seem to be looking at 1,000+ gens here on the current Apollos coding, even with 5% mutation rates, for proximity search. Any ideas why, Apollos? [by not blocking the partitioned search by gens, A. makes it hard to compare, but we have a parallel case int eh EIL partitioned search example, which is consistent with the 1986 runs and the math of the median run length for partitioned search, 98.) A further note is the cluster of reversions captured in the proximity example just above:
Gen 600: meuainks it is like a weasel fit: 92% Gen 700: methinks it isrlike a wejrel fit: 89% Gen 800: methsnkr it is tike a weasel fit: 89% Gen 900: methineswit ts likeaa wequel fit: 78%
Observe, here, the overt instability of multiple letters and spaces, and how that is easily captured in a skipped-generation sample. This tends to reinforce the point that in Weasel 1986, the observed o/p latching pattern is real, not a mere artifact of sampling. It still seems to me that the most likely explanation of Weasel 1986 on balance of evidence is that implicit latching (or quasi-latching) was achieved by a combination of mutation rate and generation size working with a proximity reward filter. (It would be interesting to see the gen size and per letter mutation rate that makes that tend to happen.) For Apollos' partitioned search case, I suspect that if we were to divide by 10, and block by generations that way it would be consistent with 100 - 200 gens run [cf. the EIL case]. (That is the generation numbers I think reflect not blocking out as generations ands choosing best of generation. On that hyp, it may be that a generation size of 10 gives us all the advantages we would need.) So, if Pendulum's generation count report that appears at no 1 above is so: 2485, we see that Weasel 1987 is generally consistent with its being a proximity reward search that is sufficiently detuned not to implicitly latch. The fast-long pattern evident in the video would also make a lot of sense. Food for further thought all around. but, remember: the fundamental downfall of Weasel is that it implements targetted search that rewards mere proximity of non-functional strings. As such it is irrelevant to the issue of natural selection, which must work by rewarding differences in functionality. And, adding in a requirement of significant functionality before proximity is recognised will plainly cause generation time to achieve a rather modest increment of information in a Weasel-type program, plainly, will cause generation run length to explode combinatorially. GEM of TKIkairosfocus
March 25, 2009
March
03
Mar
25
25
2009
03:24 AM
3
03
24
AM
PDT
My apologies for the lack of columnar formatting in the output. Preformatted text tags work in the preview, but apparently not in the post itself. The output can be pasted into a text editor for a little more clarity.Apollos
March 25, 2009
March
03
Mar
25
25
2009
01:15 AM
1
01
15
AM
PDT
This is a proximity reward search. There is no latching of characters, but only 1 out of 500 progeny is selected for the next generation, according to its fitness. The same evaluation is used for target matching as the partition example. proximity example Gen 1: wapgbwjsgijiva x knpugbykgen fit: 17% Gen 100: mezhcnkszit is like a weasel fit: 89% Gen 200: methinkscit is like a ueasel fit: 92% Gen 300: qethinks iu iw yike a weasel fit: 85% Gen 400: uetognkssit is like b weasel fit: 82% Gen 500: methinksvit is uike a weasel fit: 92% Gen 600: meuainks it is like a weasel fit: 92% Gen 700: methinks it isrlike a wejrel fit: 89% Gen 800: methsnkr it is tike a weasel fit: 89% Gen 900: methineswit ts likeaa wequel fit: 78% Gen 1000: metzinxs it is like f wlaskl fit: 82% Gen 1100: methinks ir if likeqw wmasel fit: 82% Gen 1200: methi ks kt is fike a weasel fit: 89% Gen 1261: methinks it is like a weasel fit: 100% --- --- --- --- --- Target reached --- --- --- --- --- Generations: 1261 Total population: 630500 Iterations: 3.65545e+007 Run time: 1273ms --- --- --- --- --- Here a mutation rate of 5% and a population size of 500 were used. There is a notable difference in the numbers for Total population and Iterations compared to the partition search. The population total is a product of Generations and the population size. The iterations are extreme because two, 2-dimensional inner loops are required to traverse 500 strings for each generation. The source code footprint is only nominally larger than the previous example; however here the amount of data being exchanged in CPU registers is generally an order of magnitude higher or more, by casual observation.Apollos
March 25, 2009
March
03
Mar
25
25
2009
01:11 AM
1
01
11
AM
PDT
This is the partitioned search, to use terminology consistent with above comments. It latches and mutates in the evaluation loop. Almost no additional logic is required for latching, rather it is part of the fitness evaluation -- only characters that don't match the target are allowed to mutate. An additional segment of code is appended to the evaluation loop to provide a tendency toward character reversion. The source code is here: partitioned example Gen 1: urdfjedhdowenq xzktyqeykkpcu fit: 3% Gen 100: tvwgiijop ilei lpkssproqccyk fit: 14% Gen 200: nclhiwqxoembi lcko qriiysel fit: 35% Gen 300: yudhipihxacwis lnkp x yeaded fit: 42% Gen 400: ntohifknxmlmis llkk s deareb fit: 46% Gen 500: yjphidkhgbwzis sjke r keatee fit: 46% Gen 600: rcphixksqromis hike k weajel fit: 60% Gen 700: lrvhinksjjtsis hike c weasel fit: 71% Gen 800: edhinksjitrps gike weasel fit: 75% Gen 900: weihinksoiwqqs nikb a weasel fit: 71% Gen 1000: meahinksbiafis eike a weasel fit: 82% Gen 1100: mezhinkstiz is xike a weasel fit: 85% Gen 1200: medhinkscic fs dike a weasel fit: 82% Gen 1300: menhinks ii ps eike a weasel fit: 85% Gen 1400: mebhinks iz xs hike a weasel fit: 85% Gen 1500: methinks iq gs like a weasel fit: 92% Gen 1600: methinks it fs like a weasel fit: 96% Gen 1609: methinks it is like a weasel fit: 100% --- --- --- --- --- Target reached --- --- --- --- --- Generations: 1609 Total population: 1609 Iterations: 45052 Run time: 44ms --- --- --- --- --- Here a mutation rate of 5% was used. The population is always 1, since it's unnecessary to implement any sort of propagation. This algorithm requires more generations to reach the target, but a total population of no more than the number of generations. Also notable is the metric for iterations, which counts the number of loop iterations for the course of the program. Since only one inner loop is used, the number is relatively low.Apollos
March 25, 2009
March
03
Mar
25
25
2009
01:09 AM
1
01
09
AM
PDT
For any interested, I'm posting two different implementations of weasel-type programs. These posts will follow. I'm not making a point, I just thought some might want to see how these can be implemented, and the output generated. They are both one-method programs coded in C++. For brevity and clarity the programs employ no object abstractions, and use the minimum code necessary to produce weasel-like output (including metrics). The fitness functions are implicit in the body of the code, and an inverse Hamming value (of sorts) is used for target evaluation in both cases. I cherry-picked both outputs to get sample sizes between 1000 and 2000 generations.Apollos
March 25, 2009
March
03
Mar
25
25
2009
01:07 AM
1
01
07
AM
PDT
Meant to paste only the first sentence above -- picked up two columns copying from PDF.Sal Gal
March 24, 2009
March
03
Mar
24
24
2009
09:41 PM
9
09
41
PM
PDT
Dembski and Marks write,
Partitioned search [12] is a “divide and conquer” procedure best introduced by example. Partitioned search can be applied at different granularities.
This is intellectual dishonesty. Reference [12] is The Blind Watchmaker, of course. The sentence suggests that the term partitioned search comes from Dawkins. Nothing that follows indicates that the term is actually the invention of Dembski and Marks. Worse yet, I believe that at least one of the authors knew by August 2008 that the Weasel program implements a (1,n)-ES, not partitioned search. I see in retrospect that I was a fool in believing that the EvoInfo Lab would be a source of honest scholarship. I regret that I lent my name -- not that it's much of a name -- to the Lab. I do NOT regret that I corresponded with regents and administrators of Baylor University on behalf of academic freedom for Bob Marks. It certainly would have been an embarrassment for the institution to host pathetic propaganda like Weasel Ware, but the fact is that it is the right of tenured full professors to present as crackpots. (I understand that Marks had tested limits in various ways, but it should have sufficed for him to put the AAUP-approved disclaimer on his Web pages.) While I'm at this, I should say that I have seen no evidence whatsoever that tenure review goes differently for IDists than for other faculty with unorthodox views. Almost all tenure-probationary faculty have the sense to keep their heads down. I'm not saying that it is right that they should have to, but that the "Expelled: No Intelligence Allowed" propaganda depends entirely on selective presentation. Do not take my word for this -- check out The Tenure Track discussion board at the website of The Chronicle of Higher Education. The notion that untenured faculty other than IDists can express their views without fear of reprisal is sheer nonsense. Academia is not an ivory tower.Sal Gal
March 24, 2009
March
03
Mar
24
24
2009
09:38 PM
9
09
38
PM
PDT
hazel wrote:
No, you are not doing the same thing, I don’t think. You are comparing each child to the parent and making an immediate decision as to whether the child is more fit or not; and if so, making the child the new parent.
No, I am doing the exact same thing. (I have my source code in front of me.) I don't use the new string to generate the next child/mutant, but the "current string", which all the children in a generation derive from. Again, some pseudo-code for Proximity Search: 1) Get Mutated String from current string. 2) Check against the best. If the mutated child is better or equal to best, keep it. If not, get next mutated string, again based on the "current string" parent, not the best string. 3) At the end of this round, return the best string, which will become the new "current string" parent for the next generation. AtomAtom
March 24, 2009
March
03
Mar
24
24
2009
09:30 PM
9
09
30
PM
PDT
Arrgg. I meant "… then only at the end making the best child the new parent.”hazel
March 24, 2009
March
03
Mar
24
24
2009
07:54 PM
7
07
54
PM
PDT
Small correction: the next to last line in 282 should read "... then only at the end checking making the best child the new parent." Although there are some algorithms that allow the parent to survive if no child is better, Weasel is of the type where a child must replace the parent.hazel
March 24, 2009
March
03
Mar
24
24
2009
07:51 PM
7
07
51
PM
PDT
Atom, jerry, and Joseph: Zachriel has responded but can't post here. Atom, you write:
Zachriel is discarding the children as soon as he checks if they are better than the best (which is actaully almost identical to my implementation…I do the same thing),
Zachriel responds:
Okay, but that's not quite what you said before.
You write:
you have to evaluate the corrrectness of each letter on each child to get a fitness value, then compare the fitness values of the child strings to a current champion.
Zachriel responds:
Of course, because an evolutionary algorithm can only work with the total fitness, so it has to be converted into a simple scalar before comparison with competitors. That's what makes Weasel an evolutionary algorithm, and why Partition Search is not.
Jerry, you write:
If anyone want to see the Weasel generator that was created a couple years at Monash University in Australia follow the link I put up above and press demo at the bottom. It uses a latching function.
Zachriel responds:
Then it isn't an evolutionary algorithm, and it isn't Weasel.
Joseph, you write:
Anything that allows for a reversion is NOT an example of CUMULATIVE selection.
Zachriel responds:
Learn the 3-Step. Two steps forward, one step back, and you'll cross the dance floor!
David Kellogg
March 24, 2009
March
03
Mar
24
24
2009
07:30 PM
7
07
30
PM
PDT
Thanks Atom, and your response makes something clear that has not been clear at all. I see that you are doing something very different in the Partitioned search than you are in the Proximity search: in the Partitioned search you are just having one child per generation, while in the Proximity search you are having multiple children per generation. Of course, the first is simpler, but not because of the type of search you are using. We’re not comparing apples to apples here. My analysis was assuming that both types of searches had multiple children per generation, out of which the most fit child was picked to become the next parent. I am pretty certain that this is what everyone has been talking about in this thread, not the situation where there is only one child per generation. It is also clear that Dawkins in BWM was referring to the multiple children per generation situation, not the single child per generation situation, when he wrote,
The computer examines the mutant nonsense phrases, the ‘progeny’ of the original phrase, and chooses the one which, however slightly, most resembles the target phrase. In this instance the winning phrase of the next generation happened to be ...” [pp 47-48]
Note the plural “progeny”, the phrase “chooses the one”, and the phrase, “the winning phrase of the next generation.” It is clear that Dawkins was using the multi-child situation. Therefore, your partitioned search is not really doing what Weasel does, and furthermore, it is simpler, I repeat, not because Partitioned is simpler than Proximity, but rather because one-child per generation is simpler than multi-child per generation. I appreciate your replying with specifics, because it brought to light issues that I didn’t even know were part of the discussion. Also I see you write in a later post,
Zachriel is discarding the children as soon as he checks if they are better than the best (which is actaully almost identical to my implementation…I do the same thing)...
No, you are not doing the same thing, I don’t think. You are comparing each child to the parent and making an immediate decision as to whether the child is more fit or not; and if so, making the child the new parent. Zachriel is taking a population of children and finding the best of the children to replace the parent (as Dawkins does.) My understanding is that Zachriel does this by checking each child against the current best child, and then only at the end checking to see if the best child is more fit than the parent. He is not doing the same thing you are.hazel
March 24, 2009
March
03
Mar
24
24
2009
07:24 PM
7
07
24
PM
PDT
Below I offer a complete run I did of Zachriel's WEASEL. This was the second time I ran the program. I used a population of 50 children and a mutation rate of 5%. The rows show the best fit from each generation. Note what happens between generations 32 and 33. In generation 32, the best fit has an E where the E of LIKE should be. But in generation 33, the best fit includes a J in that space, and it doesn't become an E again for a long, long time.
1 .E....N..................... 2 .E....N........L............ 3 .E....N..I.....L............ 4 .E...ND..I..S..L..........E. 5 .ET..ND..I..SA.L.........FE. 6 .ET..ND.@I..SA.L.....@...FE. 7 .ET..ND.@I..SA.L.....@...FE. 8 .ET..ND.@I..SA.L.....@...FE. 9 .ET..ND.@I..SA.LI....@...FE. 10 .ET..ND.@I..SA.LI.B..@...SE. 11 .ET..ND.@I..IG.LI.B..@...SE. 12 .ET..ND.@IO.IG.LI.B..@...SE. 13 .ET..ND.@IO.IS.LI.B..@...SE. 14 .ET..NDK@IO.IS.LI.B..@.E.SE. 15 .ET..NDK@IO.IS.LIXB..@.EASE. 16 .ET.ENKK@IO.IS.LIXB..@TEASE. 17 .ET.ENKK@IO.IS.LIXB..@TEASE. 18 .ET.ENKK@IO.IS.LIXB@.@TEASE. 19 .ET.ENKK@IO.IS.LIXB@.@TEASE. 20 .ET.ENKK@IO.IS.LIXB@.@TEASE. 21 .ET.ENKK@IO.IS.LIXB@.@WEASE. 22 .ET.ENKK@IO.IS.LIXE@.@WEASE. 23 MET.ENKK@IO.IS.LIXE@.@WEASE. 24 MET.ENKK@IOBIS.LIXE@.@WEASE. 25 METLENKK@ILBIS.LIHE@.@WEASE. 26 METLENKK@ILBIS.LIHE@.@WEASE. 27 METLENKK@IYBISQLIHE@.@WEASE. 28 METLENKK@IYBISQLIHE@.@WEASE. 29 METLENKK@IYBISQLIHE@.@WEASE. 30 METLENKK@IYBISQLIHE@.@WEASE. 31 METLENKK@IYBISQLIHE@.@WEASE. 32 METLENKK@IYBISQLIHE@.@WEASE. 33 METLENKS@IY@ISQLIHJ@.@WEASE. 34 METLENKS@IY@ISQLIKJ@.@WEASE. 35 METLENKS@IY@ISQLIKJ@.@WEASE. 36 METLENKS@IY@ISQLIKJ@.@WEASE. 37 METLENKS@IT@ISQLIKJ@.@WEASET 38 METLENKS@IT@ISQLIKJ@.@WEASET 39 METLENKS@IT@ISQLIKJ@.@WEASET 40 METLINKS@IT@ISQLIKJ@.@WEASET 41 METLINKS@IT@ISQLIKJ@.@WEASET 42 METLINKS@IT@ISQLIKJ@.@WEASET 43 METLINKS@IT@ISQLIKJ@.@WEASET 44 METLINKS@IT@ISQLIKJ@.@WEASET 45 METLINKS@IT@ISQLIKJ@.@WEASET 46 METLINKS@IT@ISQLIKJ@.@WEASET 47 METLINKS@IT@ISQLIKJ@.@WEASET 48 METLINKS@IT@ISQLIKJ@.@WEASET 49 METLINKS@IT@IS@LIKJ@.@WEASET 50 METLINKS@IT@IS@LIKJ@.@WEASET 51 METHINKS@IT@IS@LIKJ@.@WEASET 52 METHINKS@IT@IS@LIKJ@.@WEASET 53 METHINKS@IT@IS@LIKJ@.@WEASET 54 METHINKS@IT@IS@LIKJ@.@WEASET 55 METHINKS@IT@IS@LIKJ@.@WEASEL 56 METHINKS@IT@IS@LIKJ@.@WEASEL 57 METHINKS@IT@IS@LIKC@.@WEASEL 58 METHINKS@IT@IS@LIKC@.@WEASEL 59 METHINKS@IT@IS@LIKC@.@WEASEL 60 METHINKS@IT@IS@LIKC@A@WEASEL 61 METHINKS@IT@IS@LIKC@A@WEASEL 62 METHINKS@IT@IS@LIKC@A@WEASEL 63 METHINKS@IT@IS@LIKC@A@WEASEL 64 METHINKS@IT@IS@LIKC@A@WEASEL 65 METHINKS@IT@IS@LIKC@A@WEASEL 66 METHINKS@IT@IS@LIKC@A@WEASEL 67 METHINKS@IT@IS@LIKF@A@WEASEL 68 METHINKS@IT@IS@LIKF@A@WEASEL 69 METHINKS@IT@IS@LIKF@A@WEASEL 70 METHINKS@IT@IS@LIKF@A@WEASEL 71 METHINKS@IT@IS@LIKF@A@WEASEL 72 METHINKS@IT@IS@LIKF@A@WEASEL 73 METHINKS@IT@IS@LIKF@A@WEASEL 74 METHINKS@IT@IS@LIKF@A@WEASEL 75 METHINKS@IT@IS@LIKF@A@WEASEL 76 METHINKS@IT@IS@LIKF@A@WEASEL 77 METHINKS@IT@IS@LIKF@A@WEASEL 78 METHINKS@IT@IS@LIKF@A@WEASEL 79 METHINKS@IT@IS@LIKF@A@WEASEL 80 METHINKS@IT@IS@LIKF@A@WEASEL 81 METHINKS@IT@IS@LIKF@A@WEASEL 82 METHINKS@IT@IS@LIKF@A@WEASEL 83 METHINKS@IT@IS@LIKF@A@WEASEL 84 METHINKS@IT@IS@LIKF@A@WEASEL 85 METHINKS@IT@IS@LIKF@A@WEASEL 86 METHINKS@IT@IS@LIKF@A@WEASEL 87 METHINKS@IT@IS@LIKF@A@WEASEL 88 METHINKS@IT@IS@LIKF@A@WEASEL 89 METHINKS@IT@IS@LIKF@A@WEASEL 90 METHINKS@IT@IS@LIKF@A@WEASEL 91 METHINKS@IT@IS@LIKP@A@WEASEL 92 METHINKS@IT@IS@LIKP@A@WEASEL 93 METHINKS@IT@IS@LIKP@A@WEASEL 94 METHINKS@IT@IS@LIKP@A@WEASEL 95 METHINKS@IT@IS@LIKP@A@WEASEL 96 METHINKS@IT@IS@LIKP@A@WEASEL 97 METHINKS@IT@IS@LIKP@A@WEASEL 98 METHINKS@IT@IS@LIKV@A@WEASEL 99 METHINKS@IT@IS@LIKV@A@WEASEL 100 METHINKS@IT@IS@LIKV@A@WEASEL 101 METHINKS@IT@IS@LIKC@A@WEASEL 102 METHINKS@IT@IS@LIKC@A@WEASEL 103 METHINKS@IT@IS@LIKC@A@WEASEL 104 METHINKS@IT@IS@LIKC@A@WEASEL 105 METHINKS@IT@IS@LIKC@A@WEASEL 106 METHINKS@IT@IS@LIKC@A@WEASEL 107 METHINKS@IT@IS@LIKC@A@WEASEL 108 METHINKS@IT@IS@LIKC@A@WEASEL 109 METHINKS@IT@IS@LIKC@A@WEASEL 110 METHINKS@IT@IS@LIKC@A@WEASEL 111 METHINKS@IT@IS@LIKC@A@WEASEL 112 METHINKS@IT@IS@LIKC@A@WEASEL 113 METHINKS@IT@IS@LIKC@A@WEASEL 114 METHINKS@IT@IS@LIKH@A@WEASEL 115 METHINKS@IT@IS@LIKH@A@WEASEL 116 METHINKS@IT@IS@LIKH@A@WEASEL 117 METHINKS@IT@IS@LIKH@A@WEASEL 118 METHINKS@IT@IS@LIKH@A@WEASEL 119 METHINKS@IT@IS@LIKH@A@WEASEL 120 METHINKS@IT@IS@LIKH@A@WEASEL 121 METHINKS@IT@IS@LIKH@A@WEASEL 122 METHINKS@IT@IS@LIKH@A@WEASEL 123 METHINKS@IT@IS@LIKH@A@WEASEL 124 METHINKS@IT@IS@LIKH@A@WEASEL 125 METHINKS@IT@IS@LIKH@A@WEASEL 126 METHINKS@IT@IS@LIKH@A@WEASEL 127 METHINKS@IT@IS@LIKH@A@WEASEL 128 METHINKS@IT@IS@LIKH@A@WEASEL 129 METHINKS@IT@IS@LIKH@A@WEASEL 130 METHINKS@IT@IS@LIKH@A@WEASEL 131 METHINKS@IT@IS@LIKH@A@WEASEL 132 METHINKS@IT@IS@LIKH@A@WEASEL 133 METHINKS@IT@IS@LIKH@A@WEASEL 134 METHINKS@IT@IS@LIKH@A@WEASEL 135 METHINKS@IT@IS@LIKH@A@WEASEL 136 METHINKS@IT@IS@LIKH@A@WEASEL 137 METHINKS@IT@IS@LIKH@A@WEASEL 138 METHINKS@IT@IS@LIKO@A@WEASEL 139 METHINKS@IT@IS@LIKO@A@WEASEL 140 METHINKS@IT@IS@LIKO@A@WEASEL 141 METHINKS@IT@IS@LIKO@A@WEASEL 142 METHINKS@IT@IS@LIKO@A@WEASEL 143 METHINKS@IT@IS@LIKO@A@WEASEL 144 METHINKS@IT@IS@LIKO@A@WEASEL 145 METHINKS@IT@IS@LIKO@A@WEASEL 146 METHINKS@IT@IS@LIKO@A@WEASEL 147 METHINKS@IT@IS@LIKO@A@WEASEL 148 METHINKS@IT@IS@LIKO@A@WEASEL 149 METHINKS@IT@IS@LIKO@A@WEASEL 150 METHINKS@IT@IS@LIKO@A@WEASEL 151 METHINKS@IT@IS@LIKO@A@WEASEL 152 METHINKS@IT@IS@LIKR@A@WEASEL 153 METHINKS@IT@IS@LIKR@A@WEASEL 154 METHINKS@IT@IS@LIKO@A@WEASEL 155 METHINKS@IT@IS@LIKO@A@WEASEL 156 METHINKS@IT@IS@LIKO@A@WEASEL 157 METHINKS@IT@IS@LIKO@A@WEASEL 158 METHINKS@IT@IS@LIKO@A@WEASEL 159 METHINKS@IT@IS@LIKO@A@WEASEL 160 METHINKS@IT@IS@LIKO@A@WEASEL 161 METHINKS@IT@IS@LIKO@A@WEASEL 162 METHINKS@IT@IS@LIKO@A@WEASEL 163 METHINKS@IT@IS@LIKO@A@WEASEL 164 METHINKS@IT@IS@LIKO@A@WEASEL 165 METHINKS@IT@IS@LIKO@A@WEASEL 166 METHINKS@IT@IS@LIKO@A@WEASEL 167 METHINKS@IT@IS@LIKO@A@WEASEL 168 METHINKS@IT@IS@LIKO@A@WEASEL 169 METHINKS@IT@IS@LIKO@A@WEASEL 170 METHINKS@IT@IS@LIKO@A@WEASEL 171 METHINKS@IT@IS@LIKO@A@WEASEL 172 METHINKS@IT@IS@LIKO@A@WEASEL 173 METHINKS@IT@IS@LIKO@A@WEASEL 174 METHINKS@IT@IS@LIKO@A@WEASEL 175 METHINKS@IT@IS@LIKO@A@WEASEL 176 METHINKS@IT@IS@LIKO@A@WEASEL 177 METHINKS@IT@IS@LIKO@A@WEASEL 178 METHINKS@IT@IS@LIKO@A@WEASEL 179 METHINKS@IT@IS@LIKO@A@WEASEL 180 METHINKS@IT@IS@LIKO@A@WEASEL 181 METHINKS@IT@IS@LIKO@A@WEASEL 182 METHINKS@IT@IS@LIKF@A@WEASEL 183 METHINKS@IT@IS@LIKF@A@WEASEL 184 METHINKS@IT@IS@LIKF@A@WEASEL 185 METHINKS@IT@IS@LIKF@A@WEASEL 186 METHINKS@IT@IS@LIKF@A@WEASEL 187 METHINKS@IT@IS@LIKI@A@WEASEL 188 METHINKS@IT@IS@LIKL@A@WEASEL 189 METHINKS@IT@IS@LIKL@A@WEASEL 190 METHINKS@IT@IS@LIKL@A@WEASEL 191 METHINKS@IT@IS@LIKC@A@WEASEL 192 METHINKS@IT@IS@LIKC@A@WEASEL 193 METHINKS@IT@IS@LIKC@A@WEASEL 194 METHINKS@IT@IS@LIKC@A@WEASEL 195 METHINKS@IT@IS@LIKC@A@WEASEL 196 METHINKS@IT@IS@LIKC@A@WEASEL 197 METHINKS@IT@IS@LIKC@A@WEASEL 198 METHINKS@IT@IS@LIKC@A@WEASEL 199 METHINKS@IT@IS@LIKC@A@WEASEL 200 METHINKS@IT@IS@LIKC@A@WEASEL 201 METHINKS@IT@IS@LIKC@A@WEASEL 202 METHINKS@IT@IS@LIKC@A@WEASEL 203 METHINKS@IT@IS@LIKC@A@WEASEL 204 METHINKS@IT@IS@LIKC@A@WEASEL 205 METHINKS@IT@IS@LIKC@A@WEASEL 206 METHINKS@IT@IS@LIKC@A@WEASEL 207 METHINKS@IT@IS@LIKC@A@WEASEL 208 METHINKS@IT@IS@LIKC@A@WEASEL 209 METHINKS@IT@IS@LIKC@A@WEASEL 210 METHINKS@IT@IS@LIKQ@A@WEASEL 211 METHINKS@IT@IS@LIKQ@A@WEASEL 212 METHINKS@IT@IS@LIKQ@A@WEASEL 213 METHINKS@IT@IS@LIKK@A@WEASEL 214 METHINKS@IT@IS@LIKK@A@WEASEL 215 METHINKS@IT@IS@LIKK@A@WEASEL 216 METHINKS@IT@IS@LIKK@A@WEASEL 217 METHINKS@IT@IS@LIKK@A@WEASEL 218 METHINKS@IT@IS@LIKK@A@WEASEL 219 METHINKS@IT@IS@LIKK@A@WEASEL 220 METHINKS@IT@IS@LIKK@A@WEASEL 221 METHINKS@IT@IS@LIKK@A@WEASEL 222 METHINKS@IT@IS@LIKK@A@WEASEL 223 METHINKS@IT@IS@LIKK@A@WEASEL 224 METHINKS@IT@IS@LIKK@A@WEASEL 225 METHINKS@IT@IS@LIKK@A@WEASEL 226 METHINKS@IT@IS@LIKK@A@WEASEL 227 METHINKS@IT@IS@LIKK@A@WEASEL 228 METHINKS@IT@IS@LIKK@A@WEASEL 229 METHINKS@IT@IS@LIKK@A@WEASEL 230 METHINKS@IT@IS@LIKK@A@WEASEL 231 METHINKS@IT@IS@LIKK@A@WEASEL 232 METHINKS@IT@IS@LIKM@A@WEASEL 233 METHINKS@IT@IS@LIKM@A@WEASEL 234 METHINKS@IT@IS@LIKM@A@WEASEL 235 METHINKS@IT@IS@LIKM@A@WEASEL 236 METHINKS@IT@IS@LIKM@A@WEASEL 237 METHINKS@IT@IS@LIKM@A@WEASEL 238 METHINKS@IT@IS@LIKM@A@WEASEL 239 METHINKS@IT@IS@LIKI@A@WEASEL 240 METHINKS@IT@IS@LIKI@A@WEASEL 241 METHINKS@IT@IS@LIKI@A@WEASEL 242 METHINKS@IT@IS@LIKI@A@WEASEL 243 METHINKS@IT@IS@LIKI@A@WEASEL 244 METHINKS@IT@IS@LIKI@A@WEASEL 245 METHINKS@IT@IS@LIKI@A@WEASEL 246 METHINKS@IT@IS@LIKI@A@WEASEL 247 METHINKS@IT@IS@LIKI@A@WEASEL 248 METHINKS@IT@IS@LIKC@A@WEASEL 249 METHINKS@IT@IS@LIKC@A@WEASEL 250 METHINKS@IT@IS@LIKC@A@WEASEL 251 METHINKS@IT@IS@LIKW@A@WEASEL 252 METHINKS@IT@IS@LIKW@A@WEASEL 253 METHINKS@IT@IS@LIKO@A@WEASEL 254 METHINKS@IT@IS@LIKO@A@WEASEL 255 METHINKS@IT@IS@LIKO@A@WEASEL 256 METHINKS@IT@IS@LIKO@A@WEASEL 257 METHINKS@IT@IS@LIKO@A@WEASEL 258 METHINKS@IT@IS@LIKO@A@WEASEL 259 METHINKS@IT@IS@LIKO@A@WEASEL 260 METHINKS@IT@IS@LIKO@A@WEASEL 261 METHINKS@IT@IS@LIKO@A@WEASEL 262 METHINKS@IT@IS@LIKO@A@WEASEL 263 METHINKS@IT@IS@LIKO@A@WEASEL 264 METHINKS@IT@IS@LIKO@A@WEASEL 265 METHINKS@IT@IS@LIKO@A@WEASEL 266 METHINKS@IT@IS@LIKO@A@WEASEL 267 METHINKS@IT@IS@LIKO@A@WEASEL 268 METHINKS@IT@IS@LIKO@A@WEASEL 269 METHINKS@IT@IS@LIKO@A@WEASEL 270 METHINKS@IT@IS@LIKO@A@WEASEL 271 METHINKS@IT@IS@LIKO@A@WEASEL 272 METHINKS@IT@IS@LIKO@A@WEASEL 273 METHINKS@IT@IS@LIKO@A@WEASEL 274 METHINKS@IT@IS@LIKO@A@WEASEL 275 METHINKS@IT@IS@LIKO@A@WEASEL 276 METHINKS@IT@IS@LIKO@A@WEASEL 277 METHINKS@IT@IS@LIKO@A@WEASEL 278 METHINKS@IT@IS@LIKO@A@WEASEL 279 METHINKS@IT@IS@LIKO@A@WEASEL 280 METHINKS@IT@IS@LIKO@A@WEASEL 281 METHINKS@IT@IS@LIKO@A@WEASEL 282 METHINKS@IT@IS@LIKO@A@WEASEL 283 METHINKS@IT@IS@LIKO@A@WEASEL 284 METHINKS@IT@IS@LIKO@A@WEASEL 285 METHINKS@IT@IS@LIKO@A@WEASEL 286 METHINKS@IT@IS@LIKO@A@WEASEL 287 METHINKS@IT@IS@LIKO@A@WEASEL 288 METHINKS@IT@IS@LIKO@A@WEASEL 289 METHINKS@IT@IS@LIKO@A@WEASEL 290 METHINKS@IT@IS@LIKO@A@WEASEL 291 METHINKS@IT@IS@LIKO@A@WEASEL 292 METHINKS@IT@IS@LIKO@A@WEASEL 293 METHINKS@IT@IS@LIKO@A@WEASEL 294 METHINKS@IT@IS@LIKE@A@WEASEL
David Kellogg
March 24, 2009
March
03
Mar
24
24
2009
07:21 PM
7
07
21
PM
PDT
Correction to last post: thinking about it some more, VBA uses extra lines for ending loops and incrementing, so you could count it different ways. Excluding that difference, his code becomes only slightly longer, the difference being negligable. Again, what is important is not how tightly we can compress our code, but which concept has the easier basic algorithm, which can be expressed in any language.Atom
March 24, 2009
March
03
Mar
24
24
2009
07:17 PM
7
07
17
PM
PDT
David Kellogg, Zachriel is discarding the children as soon as he checks if they are better than the best (which is actaully almost identical to my implementation...I do the same thing), but the idea is the same as my pseudo-code above: you have to evaluate the corrrectness of each letter on each child to get a fitness value, then compare the fitness values of the child strings to a current champion. Partitioned Search, on the other hand, only checks the correctness of each letter for one string. As the psuedo-code above shows, it is the simpler concept to implement. The relevant code for implementing a partitioned search is very small. My function for generating the next string in a Partitioned search, GenerateNextPartStep(), is eight lines of code with one call to GetRandomLetter(), a basic function that returns a random letter. If we exclude Zach's code for getting a random letter and mine, we see that his relevant code section is 16 lines roughly; this could be misleading, however, since we're comparing VBA to javascript. In any case, although we could both write shorter versions of code (I'm sure), naturally coding it the way we did, I see that Proximity Search is not any simpler than Partitioned Search, and in fact is somewhat more involved in coding. AtomAtom
March 24, 2009
March
03
Mar
24
24
2009
07:09 PM
7
07
09
PM
PDT
"there might be generations where in fact the best child is less than fit the parent. Is this a correct understanding?" That is certainly true in the Monash example. It gives the fitness function at each iteration and it regresses some times. It seems to be doing a random walk around a certain value but with a generally upward direction. It also seems to make rapid progress at first and then the latter steps seem to take the longest. This process while fun to watch and do has nothing to do with evolution. Methinks "methinks it is like a weasel" is Much Ado about Nothing.jerry
March 24, 2009
March
03
Mar
24
24
2009
07:07 PM
7
07
07
PM
PDT
If anyone want to see the Weasel generator that was created a couple years at Monash University in Australia follow the link I put up above and press demo at the bottom. It uses a latching function. Here is the link again http://vlab.infotech.monash.edu.au/simulations/evolution/richard-dawkin-weasel/ The lowest I got was 57 iterations and the highest was 123 in about 15 tries. You can then view each selected parent at each iteration. On one of the iterations it got to all but one letter and then took 25 tries before reaching the total phrase. You can enter any phrase you wish and see how long it takes. One could actually do a study and see how an added letter affects run time. Since the program only works with lower case letters when I put in a capital, the program went into an infinite loop because it could never match the letter. I assume all 28 letter space sequences will take the same amount of time. But somehow weasel seems like an appropriate word for Dawkins. There is a version like Dawkins model that has population size and mutation rates as inputs as well as other variable you can change. Follow link for weasel genetic algorithm.jerry
March 24, 2009
March
03
Mar
24
24
2009
06:53 PM
6
06
53
PM
PDT
hazel, Zachriel has tried (unsuccessfully) to post here. Without speaking for him, this is my interpretation. To this point:
The first set of data, 50, 5%, 1.3, means that on average 1.3 of the 50 children in a generation have a letter reversal, even though the best child of the 50 wouldn’t have a letter reversal.
The first part of that sentence is correct. I think the second part may or may not be correct. It could be the case that, under some conditions, depending on the population of children and the mutation rate, the best child had one correct letter revert but also had two incorrect letters mutate to correct ones. Probably not in most cases though. In most cases, the best child would not be among those with a letter reversion. It happens. In other words, reversion happens in the program -- it's trivial, and it's in fact harder to program it to prevent reversion. Selection for best fit, however, prevents such reversions from having much effect.David Kellogg
March 24, 2009
March
03
Mar
24
24
2009
06:45 PM
6
06
45
PM
PDT
to Joseph: When you climb a mountain, you occasionally go downhill before going up again. Just because you have an occasional reversal doesn't mean you aren't accumulating fitness in respect to the target. (And we're not talking about "traits" here, just letters in Weasel.) to David, for clarification: is the following a correct interpretation of what you are saying? The first set of data, 50, 5%, 1.3, means that on average 1.3 of the 50 children in a generation have a letter reversal, even though the best child of the 50 wouldn’t have a letter reversal. And Zachriel’s remark that “Trials with higher Letter Reverts also have Fitness Retreats,” means, I think, that in situations like the second one, 50, 10%, 19.1, there might be generations where in fact the best child is less than fit the parent. Is this a correct understanding? Thanks for the info.hazel
March 24, 2009
March
03
Mar
24
24
2009
06:34 PM
6
06
34
PM
PDT
hazel, Sorry for the delay. You guessed correct, I was tied up all day at work and didn't have an opportunity to respond. I will explain (in psuedo-code) the two implementations as I think it will answer a lot of your questions. Partitioned Search 1) Start with a random string the same length as the target. 2) For each letter in the string, check if it matches that position of the target. If so, do nothing. If not, mutate that letter. 3) Repeat until string matches target. (UI components needed: User specified target.) Proximity Reward Search 1) Begin with a random string the same length as the target. 2) Using the user set values for offspring, create an array of N progeny strings that are clones of the parent. 3) For each child, mutate letters using the number set by the user for "Mutation". 4) Pass each child string into a fitness function, comparing them against the target string. Using the distance from that target (checking each letter for correctness at that position), assign values to the strings. Retain the string with the lowest error value. 5) Repeat, using the best string as the new parent, until the best string has no errors. (UI components needed: User Specified target, Offspring number setting section, mutation number setting section.) So from my point of view, Partitioned Search was much easier to implement. I'm dealing with only one string vs. a community of strings, and a simple update at each step, rather than multiple mutations followed by a total comparison of the whole community of offspring. I hope that answers your questions. AtomAtom
March 24, 2009
March
03
Mar
24
24
2009
06:21 PM
6
06
21
PM
PDT
Anything that allows for a reversion is NOT an example of CUMULATIVE selection. Unreasonably high mutations rates goes against what Dawkins is talking about in TBW- slight changes, each an improvement. His point on CUMULATIVE selection is lost if traits (characters) can be found, lost, found again, only to have something else lost, etc.Joseph
March 24, 2009
March
03
Mar
24
24
2009
06:17 PM
6
06
17
PM
PDT
Atom (and kairosfocus, and hazel), Zachriel has written a simple non-latching WEASEL program that does not require an array. You can get the Excel file at http://www.zachriel.com/weasel/weasel.xls Take a look at the VBA code. It seems pretty simple. No latching, no array, just a few lines. Is your code simpler? Zachriel also finds that letters revert. Here is what he says in a post at AtBC:
Here is a quicky analysis of Letter Reverts (over 10 trials): Pop, Mut, Rev 50, 5%, 1.3 50, 10%, 19.1 25, 5%, 2.2 Trials with higher Letter Reverts also have Fitness Retreats. Interestingly, with Pop=25 Mut=10% , fitness rises, then bounces around 20-22. Reverts are *normal*.
David Kellogg
March 24, 2009
March
03
Mar
24
24
2009
05:49 PM
5
05
49
PM
PDT
My apologies for the gap in my posting but I can assure you it was not due to moderation or to my having fled the scene, I just found myself otherwise engaged for a while. As far as the WEASEL program is concerned it seems to me that, whatever the suspicions of some here, there is no evidence that Dawkins included latching. The appearance of latching can be explained just as easily as an artefact of the sampling in the printed runs. Even if he had included latching, though, would it have made much difference if the purpose was, as stated, simply to illustrate the advantage of cumulative selection over random searching in reaching a target? On the question of targets, the fact that WEASEL searches for a target phrase specified by the programmer is often urged as evidence that undermines its value as an illustration of evolution. Critics argue that evolution denies the influence of a Designer and that without one there can be no purpose and no targets; if it is just a question of blind chance and necessity how could creatures like ourselves have emerged? This misses the point that there is no requirement for an Intelligent Designer to set targets. Nature, in the form of the environment is quite capable of doing it without any help. Suppose, for example, a particular region begins to get slowly colder after a long period of balmy warmth. This sets a new target for the local flora and fauna of surviving in lower temperatures. Thus we might find animal physiology and morphology converging on solutions that aid heat conservation like a stockier build, surrounding the body core with a layer of fat and growing a much thicker coat of fur. Yes, you can argue that an omniscient Designer foresaw this possibility and 'frontloaded' a genetic 'toolkit' and stored it away in amongst the "junk" DNA against just such an eventuality. But this requires that the genetic software be conserved unchanged over millions or possibly billions of years. This is at least as unlikely as the evolutionary 'just so' stories are supposed to be by critics. On the other issue of the article by Ian Boyne let me reiterate that it was cited only to illustrate that kairosfocus proper name could easily be found in the media. I did not read the article in detail. I got the impression that it was something to do with Christianity but no really much more than that.Seversky
March 24, 2009
March
03
Mar
24
24
2009
05:35 PM
5
05
35
PM
PDT
to Atom: in 262 I wrote about four ways that a Proximity (non-latching) search would be simpler to implement than a Partitioned (latching) search, and I’d like to add a small comment about arrays here. But first let me say that I know you are busy, and that responding to me might be a fairly low priority for you. However, given that the subject of which is more natural and/or simpler has been the subject of quite a bit of discussion, and since you are the programmer of Weasel Ware (I gather), I would hope you would find time sometime in the next few days to respond to me. I feel like I have some good points, so I would very much like to hear your specific responses, either showing me where I am wrong, or perhaps agreeing with me in places. With that said, let’s talk about arrays. First, of course, every phrase (a 28 character string) is a one dimensional array, and both methods need those. I, however, had been thinking of the set of all the children of each generation (let’s say n = 100, for example.) I had been thinking that program would generate all 100 children, store those in a 28 x 100 array, and then go back and use the fitness function to decide which child is best, based on the highest number of correct letters. (Obviously, there would have to be some way of deciding among children with the same highest score, but that is an arbitrary feature not important for the discussion.) But now I see that such an array is not necessary, as you can check each child right after it is “born”, so to speak, against the current best child: if the new child is better, it becomes the new best child, and if not it is discarded and the next child is born. Therefore, if one was concerned solely with counting how many generations it took to reach the target, and one had no desire to save any historical data, one wouldn’t need anything but a few 1 x 28 arrays to store just a few strings: the target, the current parent, the current best child, and the current newborn child. No large arrays necessary at all. And none of things has anything to do with which kind of search you use, as far as I can see. So please consider this comment added to (and supplanting in places) the comment on arrays in post 262 above.hazel
March 24, 2009
March
03
Mar
24
24
2009
05:17 PM
5
05
17
PM
PDT
I have zero interest in the Weasel Program and haven't followed this thread except that there seems to be a controversy on whether once a letter is reached, is it maintained. Here is an analysis from a couple years ago that says the new string is maintained if it is a better fit than the current string. Thus, it could mean some letter went off but some other letter came on. http://vlab.infotech.monash.edu.au/simulations/evolution/richard-dawkin-weasel/ Here is a quote from the site "Note that this demo works slightly different than the model described by Dawkins in his book. We are grateful to Dr. W. R. Elsberry for pointing this out and for highlighting the differences. In the original model the letters do not become fixed. Instead, at each generation (i.e. step) a number of mutant strings are produced from the current copy by randomly changing some letters. The mutants are considered to be chosen for the next generation. The chosen string is the one that most resembles the target string. The results of the model presented here and of the original Dawkins model are essentially the same: at each step either a “better” string is produced or something quite similar to the current version is retained. As a usual consequence, current strings are replaced with new strings that have at least as many matches as the previous one. We have created a more elaborated version of the weasel – the genetic algorithm weasel. That version incorporates the selection process as it is described by Dawkins and extends his model with some features commonly found in genetic algorithms."jerry
March 24, 2009
March
03
Mar
24
24
2009
03:03 PM
3
03
03
PM
PDT
Which also raises the question about what I need to do to be taken off moderation?crater
March 24, 2009
March
03
Mar
24
24
2009
12:09 PM
12
12
09
PM
PDT
Severski et al — why the silence for days now?
I hope they haven't been put on moderation. I have enjoyed their contributions.crater
March 24, 2009
March
03
Mar
24
24
2009
12:09 PM
12
12
09
PM
PDT
kairosfocus, I can't speak for others, but I have been delayed by the moderators, to whom I have repeatedly appealed.David Kellogg
March 24, 2009
March
03
Mar
24
24
2009
11:39 AM
11
11
39
AM
PDT
kairosfocus @263
PS: Severski et al — why the silence for days now?
Probably, like me, they are all being moderated to the point that participation here is nearly impossible.
I think there are some serious things you [and your ilk at Anti Evo] need to account for above given the context for your enthusiastically cited dismissal of me.
The fact remains that your claim that Dawkins explicitly latched correct letters in his implementation of Weasel is completely unfounded, and refuted both by video evidence and Dawkins' own statements. When are you going to admit that you were wrong? JayMJayM
March 24, 2009
March
03
Mar
24
24
2009
11:25 AM
11
11
25
AM
PDT
PS: Severski et al -- why the silence for days now? I think there are some serious things you [and your ilk at Anti Evo] need to account for above given the context for your enthusiastically cited dismissal of me.kairosfocus
March 24, 2009
March
03
Mar
24
24
2009
11:09 AM
11
11
09
AM
PDT
1 2 3 4 5 … 12