Front-Loading: I Do Not Think It Means What You Think
One of the ID creationists’ favorite words is “front-loading”. From
context, I gather that it means that the output of an algorithm is
inherent in the algorithm itself. In other words, if you write a
detailed program that calculates the square root of 16, then that’s
just a long-winded way of having it print “4”. You could have saved
yourself a lot of time by just having it print “4” in the first place.
Front-loading comes up in two arguments: 1) evolutionary algorithms do
not demonstrate that evolution works, because the solution is hidden
in the code, and 2) the fact that complex organs exist is evidence of
the unfolding of God’s an unspecified intelligent
designer’s plan; the appearance of limbs and organs in the fossil
record is part of the unfolding of God’s the
designer’s plan and was front-loaded at creation some
unspecified point in the distant past.
We can dismiss point (2) by pointing and laughing. For point (1), the
creationists are partly right: a deterministic computer program, when
given certain inputs, will always arrive at the same output. But their
error lies in confusing the description of the solution with
the solution itself.
The description of the solution is something like “The shortest route
from Washington to Baltimore”, while the solution itself is something
like “Get onto the Beltway, then turn onto Rte. 95 north and go 20
miles”. To a mathematician, the two may be equivalent, but in
practical terms, one is much more useful than the other.
So when ID creationists complain that evolutionary algorithms
“front-load” the solution into the problem, they’re complaining that
the algorithm arrives at a correct solution. Which is, you know, kinda
what it was supposed to do.
Likewise, Dijkstra’s algorithm does not contain the information “the shortest route from Washington to Baltimore.” Given certain inputs, it will produce that information, but one could hardly say that Dijkstra “front loaded” those directions into his work.
I think that the front-loading argument actually works against ID in the long run. If the simulation of evolution accurately reflects the real world, their argument amounts only to what you said above: the natural world is somehow magically front-loaded with all of the information required for all of evolutionary history to play out. I suppose that’s a perfectly fine philosophical position to take, but it does turn their argument into, “[Modern scientific theory] because God said so.” At least it keeps them from trying to derail [Modern scientific theory]. Appending “because God said so” is far less distasteful, IMO.
As you know doubt recall, there was a thread at PT a while back, concerning the use of GAs to solve graph problems (achieving minimal-length connectedness, IIRC). As I recall, the IDiots got thoroughly demolished, yet were still feebly protesting that the computer program was somehow magically front-loaded with the solutions to all such possible problems (which is what the f-ling claim amounts to).
Were that true, it would represent one hell of a data-compression ratio ;-).
Eamon Knight:
Actually, I don’t. As much as I’d like to read PT on a regular basis, there are only so many hours in the day (I’m lobbying for a 72-hour day, myself). Do you happen to have the URL handy?
I was going to say that in a sense, the solution to the problem is hidden in the (algorithm, input) tuple, just as a picture of a fractal is hidden in its generating equations (or, perhaps more poetically, the way a woman’s beauty is hidden in the girl’s face).
… sorry, got distracted thinking about beautiful women.
Anyway, I suspect that’s not what the IDists are claiming. Rather, from what I’ve seen, they tend to hint that the programmer worked out the solution in advance, then wrote obfuscated code (in the tradition of the IOCCC) that appears to use evolution, while doing strange and unconventional things in the background to produce a preordained result.
It’s tempting to say that they need this to be the case because they want life, the universe, and everything to be the execution of God’s plan. I.e., this argument serves the dual purpose of both beating on evolution, and also promoting teleology.
Summary article with further links: http://pandasthumb.org/archives/2006/09/genetic-algorit.html
This is a great post! It’s a point my brain always sort of hovered around when faced with creationist claims, but I could never really put it into words. Thanks for phrasing it so succinctly!
Creationists do tend to think in terms of “correct solutions” instead of thinking in terms of “biologically feasible solutions,” which is what natural selection actually produces.
Perky Skeptic:
Yeah, and that’s what makes evolutionary computing both exciting and dangerous: exciting because it tends to discover solutions that you never would have thought of in a million years, and dangerous because if there’s a way to cheat or game the system, it’ll find that as well.
Eamon Knight:
Thanks. It’s going to take me a while to go through all that.
This sort of thing always freaks me out. I do a lot of computer vision in my work, so I’m necessarily exposed to neural networks and other weird things. The first time I was introduced to NN computer vision, my jaw hit the floor when the paper essentially said, “Just pass in the buffer. Note that there are no arguments about the X or Y dimensions. All the neural network needs is the raw buffer. It will figure out the spatial relationships as it learns.”
WTF? We trust these things? How many computer programs are there out that produce correct output whose programmers can’t explain why? Head for the hills, kids.
Troublesome Frog:
Would it mean anything to you if I said I used to work for Azriel Rosenfeld?
Eamon Knight:
Thanks for the Panda’s Thumb reference. Looks like I was right about the IDists’ mischaracterization of evolutionary algorithms.
I was particularly amused by Sal Cordova’s comment that if you were to replace a random line from the fitness function with a string of characters, or even a random snippet of Fortran, then the code wouldn’t work anymore, even if it compiled. And Dave Thomas’s reply that yes, if every oxygen atom were suddenly replaced with a sulfur atom, living beings would stop working.
I was idly thinking about this some more.
Suppose you write a program to solve Travelling Salesman Problem by brute force exhaustive search (assume we have a fast machine and are very patient). The program is general purpose, with the node locations being a run-time input. I assume we all agree that such a program can solve any TSP of any size, limited only by memory and time?
Q1: Would any IDist want to claim the exact solutions to all possible TSPs were front-loaded into it? (For the sake of discussion, let’s assume the answer is “no”).
Now we write a GA program to “solve” (ie. produce good-enough, but not provably best, solutions) TSP, which takes the same input. Again, do we all agree it can handle any possible TSP, just as the previous one did? Do we agree that it will usually produce a good-enough solution faster than the exhaustive-search version? (Could you even tell which one was which, without being allowed to compare the solutions given by both to the same input?)
Q2: Would any IDists want to claim the good-enough solutions to all possible TSPs were front-loaded into it? What is the difference, if any, between the two cases?
I’m an engineer, not a CS geek. Have I missed something?
Eamon Knight ,
The demonstrated-on-this-site insurmountable willful ignorance of the IDiot?
Eamon Knight:
It might be instructive to look at the network-solving program that Sal Cordova wrote, the one that “evolves” the sum of integers from 1 to 500.
By Cordova’s own admission, the program is a very roundabout way of calculating the problem. Basically, it picks a random number, then adjusts it to minimize a function that happens to be equal to the desired solution.
However, his program does have #define N 500, so it’s not limited to just calculating the sum of integers from 1 to 500, but can solve the general class of problems of the form “sum of 1..N“.
In that sense, it’s been “front-loaded” with the solutions to all problems in that class. And by extension, a general conventional (non-genetic) TSP solver has been “front-loaded” with the solution to each specific TSP problem.
One big difference that struck me as I was reading this was, what if you were to change the problem somewhat? For instance, if you had a GA to solve TSP, and wanted to change it to find the longest path that goes through each city exactly once (so you could get more frequent-flyer miles, perhaps), in a sensibly-written program you’d only have to change a “<” to a “>”.
If you wanted to change Cordova’s program to “evolve” the product of 1..500, instead of the sum, you’d have to rip out major chunks of code and start from scratch.
The fact that theoretical CS is closer to math than to engineering, so that a proof for the existence of a solution for problem P is almost as good as an actual numeric solution? A computer scientist will happily produce an O(A(N,N)) algorithm for problem P and call P solvable.
Another thing to consider is an EA that has sum(x^2) as a fitness function with the number of genes dictating the dimensions. (I.e., one gene would be a simple parabola, two genes a 3D bowl centered around the origin, etc.) Constrain the fitness landscape such that genes are within the range, say, [-1,3] such that one “peak” is clearly higher than the others. If you run the EA many times the population won’t necessarily run up the best peak every time; sometimes by happenstance the better individuals will be nearer one of the inferior peaks thus pulling the rest of the population along with them. (Obviously depends on implementation parameters such as population size, mutation rate and scale, etc.)
So, how can the EA be “front-loaded” if some runs produce inferior results?
Mark:
Poor coding. Please submit a bug report.
arensb:
One of his books got me through my senior project in college. What did you do for him?
Troublesome Frog:
I used to be the head sysadmin at the Center for Automation Research, which he headed, and which contained the Computer Vision Lab.
I also co-wrote a paper with him. Please don’t judge it too harshly. It was principally a matter of “Azriel, your draft is
craptrivial. Let me rewrite it so you don’t embarrass yourself in print.”