On Firefox here, the "Save Local Population" option seems to crash. Any idea why that might be happening? (Amazing site btw - every time it pops up I end up spending much too long with it).
As internet distractions go, the original was one of the most memorable I ever came across. A friend and I used to leave them running over lunch and see who was winning when we got back.
Thanks for the fun :-)
It seems to always get into a rut where one design lucks out and dominates generation after generation, with no mutations producing anything even close to working. Like, the top ten don't change after hundreds of generations. Maybe this is just an attribute of genetic algorithms. They quickly zero in on something kind of good, and then get stuck at this local maxima. Or maybe I need to just play around with the Mutation Rate and Mutation Size settings.
In general, one should keep the mutation rate really low to allow the population slowly change over time. High mutation rate will lead to local optima quickly but also very hard to get out. Low mutation rate will require significant more generations but in general result in better adaptation.
Note my use of the term "heuristic" and not "algorithm." There is not a correct number. The correct approach is to fiddle with the parameters; record good populations; occasionally restart from scratch... we call this "hyperparameter tuning" to make ourselves feel better about the process.
It seems like more should change than just the shape. I'd wager that a slower car with more power may be less likely to get stuck in ruts. But it seems that the power and speed don't vary, just (barely, after a few generations) the shape.
Edit, I scrolled down and it covers the genome:
• Shape (8 genes, 1 per vertex)
• Wheel size (2 genes, 1 per wheel)
• Wheel position (2 genes, 1 per wheel)
• Wheel density (2 genes, 1 per wheel) darker wheels mean denser wheels
• Chassis density (1 gene) darker body means denser chassis
It basically lands on a two-wheeled medium-bodied shape and doesn't seem to make much progress after that. Power and speed would be interesting variations.
What happens in an evolutionary algorithm depends on what you write it for. This is a fun toy, but what it does specifically is explore a very limited simulation of evolution by natural selection. Metaheuristics aimed at optimization have a lot of techniques aimed at not stalling out on a prematurely converged design, as well as improving other desirable properties of the population, at the expense of any pretense of fidelity to real-world evolution processes.
This is why I said it needed crossover and got downvoted into oblivion :) turns out it at least tries to have crossover, so maybe the genome doesn't translate to crossover doing anything relevant.
I wasn't fooling. Think about it for a second, if your process involves a lot of crossover that means large sections of working genome will be passed on. If the ONLY mechanism for changing anything is mutation, then mostly you're just breaking what works.
That's what you're describing, so I'd look at how the genome is constructed to understand why it's not doing more.
this is fun, even though the speed controls aren't super intuitive. You can press "Surprise" to speed things up and go through a bunch of iterations quickly.
The mutation rate (likelihood that g changes) and mutation size (Δg) are fun hyperparameters to tweak while watching the population evolve over time.
It would be interesting to see a gene for "compliance" so the cars could have some kind of suspension. EVerything more or less evolved into a sort of tron-bike shape for most of the runs I tried.
> EVerything more or less evolved into a sort of tron-bike shape for most of the runs I tried.
I ran it in the background for a very high mutation rate for a long time and it managed to come up with something very different---a little wheel attached to a big wheel, which bounces around and goes over all the obstacles.
...and apparently all the suspension parameters stripped out for some bizarre reason.
The physics simulation clearly uses inelastic collisions, which is wildly unrealistic and why so many otherwise passable 'cars' don't pass the course. Also seems to use a very low coefficient of friction - most of my cars couldn't make it up a two-segement slope.
This html5 version has also been around for longer than a decade already. It's what inspired me to take a class on Genetic Algorithms and Evolutionary Computing in university back then.
The simulation that these cars are driving in has no third dimension for the vehicle to fall over into (or where to put another pair of wheels). So, like a traditional four-wheeled car, these vehicles do not tip over at 0 velocity. I think that property is enough to qualify their behaviour as more similar to four-wheeled cars than motorbikes.
Reminds me of a phenomenal Android app called Cell Lab where you could create all kinds of multi- or single-celled organisms to live in a petri dish. You could crank up the radiation levels to let things mutate and evolve if so desired.
Interesting. Is there a way to do this in a 3d physics based simulation environment. It would be cool to see if a genetic algorithm could be used to discover new aerodynamic configurations for drones/other platforms in simulation.
I don't know enough about genetic algorithms to say for certain. Anyone have any reference materials for someone that's just started looking into this?
Not exactly what you're asking but Topology Optimization is now a standard feature of the big CAD packages. It allows the designer to express various constraints and goals, then a combination of gradient methods and genetical algorithms are used to find an optimized part. Example: https://www.solidworks.com/media/topology-optimization
It’s the simulation and fitness function that are difficul not the genetic algorithm really.
I’ve done a bunch of playing around with NEAT, a variant of GA using NNs, for various things. Typically for GA stuff though you have a genome, aka some set of instructions for an individual, a fitness function for scoring them, and then you generate new individuals from those genomes for the next population.
I love the NEAT algorithm. I did version of it for my senior project in high school, and have done a few iterations since, mostly with bugs that eat food and avoid predators. I'm about due for another round.
Reminds me dirt bike on Apple Macintosh -- you could edit pretty much every aspect of your dirt bike. Would be fun to make a car/bike game where you play against the GA. https://www.youtube.com/watch?v=siiho5IVAdg
might go much faster if it recorded a set of states where ancestors died shortly after and then test all the new candidates against those states.
The new candidate might actually survive because its prior history kept it from ever getting into that particular death state, but I think biasing towards designs that don't immediately die in those hard cases is good anyways, since given a long enough run it would likely encounter a similar state.
One could co-evolve the test case collection by simulating only the best candidates according to the test cases, and then retaining test cases based on a running score for how well they predicted the actual performance.
It references Box2D as the physics engine, but it seems to be a JavaScript port of Box2D. I'm unfamiliar with the JavaScript ports, but if it is a copy of one of the existing ports, the port should be referenced instead.
Btw, how much AI goes into designing the exterior of a car (panels, lights, windows, grill) ? Can they just drag a slider for "How much muscle do you want" from "Yes" to "Beige" ?
Very little. It's heavily computer aided, but the overall design is largely done by humans with some marginal input by engineers for annoying realities like aerodynamics and sensors.
I don’t think they use generative AI much in automotive design today, but you can play with stable diffusion and embeddings and make a slider for muscle cars in the textual weights.
Looks like their shape is always defined by eight triangles. The page doesn't say what the genome defines about those triangles (only that there are eight vertices in the genome), but if it's just random angles and distances, it'd kind of make sense that they start as random spiky shapes.
I don't know why they stay that way. My first thought would be that it might be beneficial for the shape to be relatively low for stability, but with the shape between the wheels being concave for clearance. That doesn't quite seem to happen, except for the concave clearance to an extent.
Maybe the rest of the shape doesn't really matter for the simulation, so there's no selective pressure towards not having a spiky shape.
Both runs I did the cars looked like a child drawing a car from Mad Max.
My best guess is sort of adjacent to yours: a lot of cars flip on the initial drop and I think the spikes are helping them land right side up. Overfitting T=[0,1]
A big spike sticking out the top could change the center of mass and the moment of inertia. Both of those could affect how the car handles even if the spike never touches anything.
Oh, and they can affect the mass. If the grip of the wheels takes into account the normal force, extra weight may help with traction.
Hmm, and a 4th thing: some cars have a spike sticking out back behind the back wheels. These spikes sometimes function like wheelie bars, which are used on drag racers to prevent the car from flipping if the front end lifts off the ground. The wheelie bar kind of braces it but also lifts the traction wheels off the ground so they stop rotating it at the wrong moment.
This isn't genetic algorithm, though. It's mutation.
To do it with a serious model of a genetic algorithm, you need crossover, not mutation. It's fun, but this is sort of a lottery of randomized cars with some capacity for copying winning ones over to successive runs.
Still runs in the browser thanks to Ruffle:
https://peteshadbolt.co.uk/posts/ga/