Roger Alsing Weblog

Genetic Programming: Evolution of Mona Lisa

[EDIT]
Added FAQ here: http://rogeralsing.com/2008/12/09/genetic-programming-mona-lisa-faq/
Added Gallery here: http://rogeralsing.com/2008/12/11/genetic-gallery/

This weekend I decided to play around a bit with genetic programming and put evolution to the test, the test of fine art :-)

I created a small program that keeps a string of DNA for polygon rendering. 
The procedure of the program is quite simple:

0) Setup a random DNA string  (application start)

1) Copy the current DNA sequence and mutate it slightly
2) Use the new DNA to render polygons onto a canvas
3) Compare the canvas to the source image
4) If the new painting looks more like the source image than the previous painting did, then overwrite the current DNA with the new DNA
5) repeat from 1

Now to the interesting part :-)

Could you paint a replica of the Mona Lisa using only 50 semi transparent polygons?

That is the challenge I decided to put my application up to.

The image below is the result of that test:
(The number below each image is the number of generations it took to reach that specific painting)

evolutionofmonalisa1

So what do you think?

[EDIT]
Added FAQ here: http://rogeralsing.com/2008/12/09/genetic-programming-mona-lisa-faq/
Added Gallery here: http://rogeralsing.com/2008/12/11/genetic-gallery/

Written by Roger Alsing

December 7, 2008 at 9:56 pm

Posted in .NET, Evolution

« I’m featured on EvolutionsTeori.se
Genetic Programming: Mona Lisa FAQ »

264 Responses

Subscribe to comments with RSS.

  1. Any chance of source? This is REALLY cool.

    BBQNinja

    December 8, 2008 at 12:20 am

  2. Very cool, I have been thinking about doing the same thing actually (but not using polygons, by using sort of line creatures).

    What algorithm / library did you use for image comparison?

    I have been pretty much obsessed with evolution stuff this past 1-2 years, read all Dawkins’s books. I Can really recommend the selfish gene, and the blind watchmaker, and ancestors tale, plus Genome by Matt Ridley was great, really interesting how DNA really can be viewed as a hard drive littered with remains neutralized viruses and other self serving copying processes.

    If I ever did PhD research it would be in evolution simulation :)

    Torkel

    December 8, 2008 at 6:15 am

  3. …interesting. If the representation of the polygons was small enough, you’ve probably got a new compression algorithm.

    Andy Dwelly

    December 8, 2008 at 10:42 am

  4. Very nice! That’s a vectorizer and image compressor in one. Even with scalable compression level, just add another 20 polygons.

    I guess you have to trade time, though :-)

    Same request: source would be nice – a toy to play with on christmas :-)

    Searle

    December 8, 2008 at 10:47 am

  5. Wow, your phenotype–genotype mapping seems particuarly effective for this sort of thing!

    Dare I ask, what is it?

    Andy

    December 8, 2008 at 10:53 am

  6. particularly, even!

    Andy

    December 8, 2008 at 10:53 am

  7. I like this! Any chance of seeing the evolution as a video?

    One thing that puzzles me, why aren’t there 50 polygons in the initial images?

    Malcolm

    December 8, 2008 at 10:58 am

  8. This is awesome.

    Veera

    December 8, 2008 at 11:05 am

  9. Pretty impressive. However, you said the DNA sequence was randomly created… why is the first screen black, instead of showing randomly placed triangles?

    Luis Antón

    December 8, 2008 at 11:06 am

  10. It’s not really a genetic algorithm that produced the picture, but a stochastic hill-climber. No recombination is done, the population size is one, so the genotype-phenotype mapping is not really important. Also it seems step 0 was not executed, as others already pointed out.

    And finally, looking at the number of steps it did take to produce that drawing, the convergence speed is not very impressive.

    Johannes

    December 8, 2008 at 11:59 am

  11. How long does it take to generate the final result?

    Do the number of points in the polygons change overtime? If it does, how do you take that in account in your DNA sequence?

    Saiyine

    December 8, 2008 at 12:13 pm

  12. That’s very cool. How did you do the selection? Was it automated somehow, or did you manually compare each image to decide whether to keep/discard it?

    Lance

    December 8, 2008 at 12:45 pm

  13. I am curious about your fitness function. How, for example, did you decide that 466 looks more like the Mona Lisa than 372?

    kc

    December 8, 2008 at 1:04 pm

  14. very very cool.

    would love to see the source too :)

    shaun

    December 8, 2008 at 1:05 pm

  15. I’ve implemented genetic algorithms before but only for optimization. Neat application of it!
    Unfortunately, seems like it takes an exponential number of iterations to get finer and finer details.

    Jon Lee

    December 8, 2008 at 1:11 pm

  16. Fantastic! Any chance you’ll be releasing the source?

    Maarten

    December 8, 2008 at 1:11 pm

  17. Very cool. If I understand correctly, the last image is comprised of only 50 polygons?

    programmer

    December 8, 2008 at 1:32 pm

  18. Maybe they were randomly placed black triangles initially?

    Adam

    December 8, 2008 at 1:32 pm

  19. At almost 1 million evolutions, how long did this take?

    d

    December 8, 2008 at 1:35 pm

  20. nice, but i also wonder why there aren’t 50 polygons in the first pictures…

    chris

    December 8, 2008 at 1:40 pm

  21. Seems to me the real magic is in two words: “mutate slightly.” That is the part of the code I would like to see :)

    Tristan

    December 8, 2008 at 1:44 pm

  22. Beautiful! I second Andy’s query about the genotype/phenotype mapping, and would also like to see what you’re doing for mutation.

    Lee Spector

    December 8, 2008 at 1:51 pm

  23. As always you pull of another cool test! :-)

    Andreas Håkansson

    December 8, 2008 at 1:53 pm

  24. Cool! What compression ratio do you get from the DNA compared to the original source image?

    Mike

    December 8, 2008 at 1:54 pm

  25. Brilliant idea!

    As per the people asking about the algorithm, I’m curious of algorithm. I imagine the genes have 50 phenotypes, each one being 3 points and 4 colours (RGBA). To show the ‘construction’ of the image, you just draw all of the phenotypes in (a random) order?

    The fitness function sounds like it’d be fun. Objective image comparison is hard to create and might fall apart at higher image sizes. :) Are you using line tracing or something like that?

    David B

    December 8, 2008 at 1:57 pm

  26. Some more information would be cool. How long did it run? How did you compare the picture to the actual Mona Lisa?
    You had a population of one, i feel that that might be best in this case, but i do not see why exactly.

    Jasper

    December 8, 2008 at 2:03 pm

  27. Wow! I am impressed. Of course you left out a number of important details in your description. For starters you state the in step 3 you “Compare the canvas to the source image”. Does that mean a simple pixel by pixel comparison, luminance averaging within a fixed or titrating grid, facial recognition, or what? As always the fitness function(s) are at the heart of a GA/GP but you give no clue.

    Also you took 900K generations to get there but you never mentioned your population size, rate of crossover, mutation, etc. Basically, I’d love to know as much about the algorithms you used as you’d be willing to share. A look at the code would be best although I agree with Andy Dwelly that if the the storage size was significantly less than MPG4, etc. (and the calculation effort was small enough!) you might have an interesting and marketable compression algorithm. In that case I’d work hard to get it patented and to market ASP.

    Again, great work and thanks for sharing….

    Louis Berman

    December 8, 2008 at 2:06 pm

  28. One explanation could be, that one of the mutation possibilities is adding a new polygon to the generating DNA string.

    Max

    December 8, 2008 at 2:06 pm

  29. Luis: I’m guessing many of the polygons were initially degenerate in some way?

    Paul

    December 8, 2008 at 2:20 pm

  30. Excellent! I once started a somewhat related project with mutating polygons nearing a likeness to a face. Here’s a results gallery: http://blogoscoped.com/archive/2007-10-09-n18.html

    Philipp Lenssen

    December 8, 2008 at 2:44 pm

  31. [...] Alsing played around with genetic programming and came up with a program that overlays 50 semi-transparent polygons. In each step, the originally random polygon DNA is slightly mutated. Then, it is compared to the [...]

    Google Adsense Tips & News » Blog Archive » Polygons Evolving Into Mona Lisa

    December 8, 2008 at 2:48 pm

  32. @Luis: probably because it starts off with DNA being initialized to a blank slate (even though it’s not stated in the steps) and then generates the random polygons. So in this case, the black screen was a closer match then random polygons.

    Anon

    December 8, 2008 at 2:56 pm

  33. This is seriously impressive. How long did it take to reach that final image? What algorithm did you use to compare the images?

    Is it really Genetic Programming though? From your description it sounds more like some other kind of evolutionary algorithm. It would be interesting to run it again with a larger (>1) population and cross-over. I’d imagine it would converge much quicker.

    Dan

    December 8, 2008 at 3:06 pm

  34. Very nice example of genetic programming. Would it be possible to have more details on the algorithm?

    Stephanea

    December 8, 2008 at 3:19 pm

  35. I would say it is using Genetic Algorithm and if the algorithm is correct it sounds like single individual elitist GA. The easiest fitness function would be to do a per-pixel RGB comparison and optimising for lowest possible fitness value.

    It might fall somewhat under the GP category if the number of points in the polygons is variable. The easiest approach would probably be to use triangles with each triangle represented as 3 positions and RGBA-components.

    Going to try this out using Covariance Matrix Adaptation Evolution Strategies once I have more free time. This might actually result in a fast enough optimisation to make this a viable method for vectorising and compressing images with high complexity.

    Johan Hägg

    December 8, 2008 at 3:34 pm

  36. @Dan: The algorithm as describes sounds like a simple form of simulated annealing without a probability of accepting worse matches with a probability > 0 and no cooloff. Another algorith that could work is MCMC (Markov chain Monte Carlo), which is usually used with bayesian statistics and probabilities, but can easily applied as a generic optimizqation algorithm.

    Kalle

    December 8, 2008 at 3:40 pm

  37. Source, please? Otherwise, I’m going to end up wasting time rolling my own instead of working.

    John Leavitt

    December 8, 2008 at 3:42 pm

  38. I doubt this is GP. Probably a GA.

    swaits

    December 8, 2008 at 4:01 pm

  39. [...] Programming: Evolution of Mona Lisa submitted by leppie to programming [link] [55 [...]

    Genetic Programming: Evolution of Mona Lisa - The WebZappr

    December 8, 2008 at 4:01 pm

  40. Compression through GA search is not a new idea. I have tried something similar to this myself a while ago.
    This implementation works better because of the alpha-blended polygons though.

    Alex

    December 8, 2008 at 4:02 pm

  41. Show me the code.

    silveira

    December 8, 2008 at 4:12 pm

  42. The comparison function could be as simple as the quadratic error, sum(square(pxy – qxy)). The used it in fractal image compression. (Note the applications of this to fractal image compression? ;))

    It’s interesting how one can get close to the target in the presence of a fitness function. There’s, however, a drawback to the algorithm that’s not immediately apparent. The approach is entirely greedy and with this limited population of (two) images at each generation you won’t be able to take the image through depression points. You don’t notice this, because your tools (polygons) are coarse grained and hence the goal is not a very fine picture to begin with.

    In any case, impressive.

    Mihai

    December 8, 2008 at 4:16 pm

  43. Wow, that’s great!

    Matto

    December 8, 2008 at 4:16 pm

  44. Dude, any chance of posting this up on youtube as a proper video/animation?

    Not sure about how effective this is as a genetic algorithm, but you could have a real gem of a video effect here!

    Martin

    December 8, 2008 at 4:18 pm

  45. Nice! I would be interested in more detail:

    What limit did you put on the maximum degree for each poly? Did you considered limiting the total number of vertices rather than the number of polygons? How does varying the poly limit affect the final image? (ie what is the limit of convergence for different poly counts?)

    What did your mutation function look like – shift-vertex, add-vertex, tweak-color, tweak-alpha, what else? What relative-occurrence-probabilities did you use?

    Do you use edge-crossing-detection to ‘untwist’ the poly, or just ignore cross-overs? Do you limit new-vertex locations, ie midpoint-offset, or just use random-in-canvas? Did you consider a vertex-pruning mutator? Have you got any statistics on result-acceptance rates for different mutators? How do these rates change at different stages of convergence?

    What do you do when you hit the max number of polys – drop the least-fit, or just stop creating new ones? If drop, how did you determine least-fit?

    What color space did you use, RGB/LSV/? What measure did you use for image-comparison (sum of absolute pixel-differences?)? Have you considered using variable-resolution comparison to speed things up (ie start with a lo-res image and increase resolution as fitness increases)?

    Is it possible to calculate per-poly best-fit alphas as part of the image comparison? If so, can we do the same for each color channel?

    It sounds like you used population-1, ie random-walk search. Any idea what a valid crossover operator would look like – something like polygon-swapping with alpha adjustment?

    Have you tried using smart/directed mutators – ie, pick one poly to mutate, cache the image-and-difference for everything-but, then try a set of mutations on the poly and use the one which increases the fitness the most?

    Have you investigated how changing some of the parameters affects convergence speed in terms of either generations or overall computation time?

    For fun – what about using this alg to morph from one image to another?

    Hugh Bothwell

    December 8, 2008 at 4:20 pm

  46. Very nicely done.

    Kevin

    December 8, 2008 at 4:23 pm

  47. Could you please publish the result of the test as an SVG? That would be really interesting ;-)

    (Sorry for my bad english)

    NoMoKeTo

    December 8, 2008 at 4:26 pm

  49. The representation of triangles needs
    3 vertices each having X and Y coordinates, plus the color (R,G,B), so 9 numbers per triangle, times 50, i.e. 450 numbers. This could be 1800 bytes if they all were single precision floats,
    or we could do integer arithmetic, with say 16-bit
    X/Y coordinates, and 24-bit color, i.e. 19 bytes per triangle, or 950 bytes total.

    Przemek Klosowski

    December 8, 2008 at 4:40 pm

  50. I would be curious to see this where every corner of a triangle has a different color and interpolate the polygon colors to create a gradient. You might be able to get a more faithful representation that way and possibly be able to reduce the amount of polygons.

    mempko

    December 8, 2008 at 4:48 pm

  51. To silveira: I do not have the code right here but I can sketch the approach: the gene size was variable, encoding a variable number of rectangles with a colour. The aprroach described in this page has a fixed number of arbitrary polygons and the colour combination function is some type of blending. I think the variable number of polygons is a better feature but this experiment shows that having general polygons instead of rectangles and specially blending colours (which makes the fitness function change more smoothly) is a good improvement. I wasn’t trying to solve exactly the same problem though.

    You can do a google search on ‘genetic algorithms image compression’ and you’ll see a few hits on the subject.

    Alex

    December 8, 2008 at 4:57 pm

  52. Having now made a movie out of it myself, it is a lot easier to see what is going on.

    I think it would be interesting to place some limitations on the evolution:

    1) each polygon is limited to up to n-sides, or
    2) the total number of vertices is limited to some number.

    Or both.

    Also, I too would like to know more about your fitness algorithm. I would’ve thought that some regions would’ve gained fidelity (detail) more quickly than others, but it seems — from the samples you’ve provided — that detail sort of emerges together.

    Martin

    December 8, 2008 at 4:59 pm

  53. Source or it didn’t happen :P

    Eric Anderson

    December 8, 2008 at 5:02 pm

  54. Very nice; You should generalize it and apply it to other images as a way of converting from raster to vector formats.

    Leif902

    December 8, 2008 at 5:13 pm

  55. LHOOCube.

    BobR

    December 8, 2008 at 5:14 pm

  56. Hmmmm…. I don’t think this is a true test of Evolution, though… The algorithm always had access to the original “Design” of Mona Lisa to compare itself with. The process and theory of evolution states that there is no Designer and that things happened randomly (uncoordinated). So, for me, evolution requires MORE faith than believing in God or an intelligent Designer.

    Thinking Out Loud

    December 8, 2008 at 5:21 pm

  57. Source Code or it Didnt Happen!

    Ian

    December 8, 2008 at 5:30 pm

  58. Adding to the chorus of people wanting to see this rendered as a movie!

    Andy Baio

    December 8, 2008 at 5:34 pm

  59. Post the source or gtfo

    Robert

    December 8, 2008 at 5:39 pm

  60. OK OK , I Will try to make a movie out of this.

    I’ll even to make a new run and output SVG or some other vector format out of the images :-)

    Also, the polygons are 3-x points large, so they are not only triangles but can be big complex polygons.
    (Saw a few comments about triangles in here)

    And I’ll blog about the various aspects on this topic as soon as the kids go to bed.

    Roger Alsing

    December 8, 2008 at 5:41 pm

  61. Could you post the code? It would be interesting to see it. Especially the code used to compare to the original and estimate the match.

    My understanding is that that is where the magic really happens and the most difficult thing to design.

    Robb Greathouse

    December 8, 2008 at 6:05 pm

  62. [...] Genetic Programming: Evolution of Mona Lisa – programming AI [...]

    uglychart.com: a blog about stocks » Blog Archive » links for December 8th

    December 8, 2008 at 7:01 pm

  63. source or no dice.
    provided that, very nice.

    franco

    December 8, 2008 at 7:07 pm

  64. About that first black image. I would guess its the first generation and selecting a strand with all initial values as zero is just as good as a random starting strand.

    Basically you need something to compare the next generation with and a black screen works? =)

    Andreas Håkansson

    December 8, 2008 at 7:36 pm

  65. Once again you manage to both impress and inspire! Extremely nice and interesting. I guess this was all done in ‘M’ :)

    Johan Lindfors

    December 8, 2008 at 7:51 pm

  66. Nice! I can’t say I understand how you did this but it is very cool, bravo.

    realistic bird

    December 8, 2008 at 8:04 pm

  67. This is thoroughly awesome. It really is.
    Just curious – how long did the computation take ?

    Just curious

    December 8, 2008 at 8:21 pm

  68. I wouldn’t call this a genetic algorithm because you are not keeping multiple candidates at each iteration nor breeding them (that is, swapping DNA from multiple candidates). This is simply a straightforward hill climbing algorithm. Not that the method impacts on the results.

    If it took about 1M iterations to get to your result with hill climbing, I would expect you could do much much better with a genetic algorithm provided you were smart about how DNA got swapped. If it was swapped spatially, somehow, then you could get a result where a candidate which was good at the face bred with a candidate which was good at the background and you got a candidate which was good at both.

    Which isn’t to say that such an approach might not take more computation over all, keeping around and breeding multiple candidates takes time.

    Nick

    December 8, 2008 at 8:43 pm

  69. [...] in Art, Daily life, Software, Technology at 12:57 pm by LeisureGuy Take a look—fewer than 1 million [...]

    Extremely cool: genetic programming evolves picture of Mona Lisa « Later On

    December 8, 2008 at 8:58 pm

  70. I agree with everybody else here:

    1. Cool stuff

    2. What’s the fitness function?

    3. What’s the mutation operator?

    Julian Togelius

    December 8, 2008 at 8:58 pm

  71. Hey, instead of so narrowly directing the evolution, you could do something more like real life, by coupling a facial recognition program to the fitness testing. See what kinds of ugly mugshots you get coming out!

    Rich

    December 8, 2008 at 9:21 pm

  72. [...] coolt är inte det här?! Genetic Programming: Evolution of Mona Lisa « Roger Alsing Weblog Blogged with the Flock [...]

    ILLUZIVE - Personal » Blog Archive » Genetic Programming: Evolution of Mona Lisa « Roger Alsing Weblog

    December 8, 2008 at 10:09 pm

  73. It’s not evolution it’s inteligent design …

    kaiser

    December 8, 2008 at 10:10 pm

  74. excellent :D

    rip

    December 8, 2008 at 10:18 pm

  75. This is really cool, dunno about applications but really surprising how good it looks with only 50 polys…

    PsySal

    December 8, 2008 at 10:18 pm

  76. also would like to see/use the source ;)

    TimT

    December 8, 2008 at 10:23 pm

  77. I will release the source tomorrow, I just have to clean it up so I don’t have to feel too ashamed of the actual code quiality.

    (Threading it so that it wont lock up your computer etc)

    The app is written in C# 3 using .NET framework 3.5.
    So thats the requirements for using/compiling it.

    Just so you know :-)

    Im off to bed.

    Roger Alsing

    December 8, 2008 at 10:28 pm

  78. source or more information, please? (in particular, i’m interested in how you compared particular states with the actual mona lisa)

    and, like others said, this isn’t really genetic programming (as there is only a population of 1), is it? more like a genetic algorithm?

    v_krishna

    December 8, 2008 at 10:33 pm

  79. it is realy impressive, but i would also like to know more details about the algorithm. I think it would be also interesting to let fight several runs of the same test to find better result with same number of polygons (or simillar with less number).
    I also vote for canvas version here ;)
    And maybe we can all try to optimise the algorithm

    noname

    December 8, 2008 at 10:48 pm

  80. and i would also like to see simillar test but with more limitations (3 sides – triangles only for example).

    noname

    December 8, 2008 at 10:50 pm

  81. Man, you are really a genius. That is a way too great.

    Fester

    December 9, 2008 at 12:42 am

  82. Fascinating stuff! Would love more details!

    Benjamin Smith

    December 9, 2008 at 12:46 am

  83. @Kalle, sounds closer to Evolution Strategies, particularly the (1+1) variant.

    Dan

    December 9, 2008 at 1:15 am

  84. [...] This is a nice approach to computer generated art. Roger Alsing wrote a programme that pushed around fifty translucent polygons using a Darwinian selective algorithm until they started looking like the Mona Lisa.  I think you’ll agree that the sixty images are quite instructive. Here’s his discussion followed by a link to the images. [...]

    The World’s Most Famous Painting : LikeItHateIt

    December 9, 2008 at 2:38 am

  85. Interesting, but it isn’t evolution. You just showed intelligent design. You had an end result that you compared your program to. So you had an ultimate goal in mind. You didn’t really do it “randomly” though. So thanks for showing designs have designers. :)

    David Goscinski

    December 9, 2008 at 3:39 am

  86. Incredible! As a programmer of genetic algorithms myself I must tip my hat to your ingenuity. For even I, with no 3D programming experience could write something to combine 50 semi transparent polygons, however the ingenuity of thought, the stroke of brilliance to apply such a seemingly impossible task to such simple constraints, that! is true genius.

    *tips hat*

    Krylen

    December 9, 2008 at 3:55 am

  87. [...] Alsing] wanted to try out some genetic programming, so he created a simple test problem: Could you render the Mona Lisa using just 50 semitransparent polygons? The program starts with a random DNA sequence. It then mutates and compares itself to the original [...]

    Genetic programming - Hack a Day

    December 9, 2008 at 4:00 am

  88. Just to echo a lot of other people, I’d really love to see the source. I’ve been fascinated by genetic algorithms ever since I first heard of them eight years ago, and I’ve long wanted to experiment with them myself, but the initial hurdle of coming up with a GA framework on my own has proved to be too much. If you could provide the source for this project (say, under the GNU GPL), that’d be a great starting point for me and many others. I’d start by evolving a different image, and then from there, who knows what I’d do?

    Thanks a lot.

    cydeweys

    December 9, 2008 at 4:15 am

  89. I’m impressed.

    prfx

    December 9, 2008 at 4:24 am

  90. While I find this very interesting (and, frankly, cool), I hardly think this could be used for a new image compression algorithm — at least not in any practical manner.

    First, it’s likely to be hugely costly in terms of memory and computation in order to do so (almost 1M generations, not to mention an unknown population size). It’s probably also quite likely that the polygons evolved in the process are non-trivial. What you’re really looking at is the building of an SVG. Therefore, it’s possible that this could be used either by itself or perhaps in tandem with an existing algorithm to convert raster images to vector representations.

    I’m skeptical as to whether there’s any commercial viability to such code. If I’m proven wrong, then kudos! But not every project is meant to be commercialized.

    Good work!

    AE

    December 9, 2008 at 4:48 am

  92. [...] 通过不断的杂交、变异并与原作比较确定适应度，经过904314代后，终于得到了一个满意的结果。 来源：http://rogeralsing.com/2008/12/07/genetic-programming-evolution-of-mona-lisa/ [...]

    Matrix67: My Blog » Blog Archive » 强大的遗传算法：用50个半透明多边形重现蒙娜丽莎

    December 9, 2008 at 5:18 am

  93. Then is life designed?

    huyichen

    December 9, 2008 at 5:23 am

  94. I’m wondering if the 50 polygons are particularly suited to rendering a face. Might 50 polygons have a harder time rendering “scream?” Would 50 polygons be really good at rendering a picasso?

    Karl

    December 9, 2008 at 6:40 am

  95. For all those people who want the code, why don’t you just follow the procedure that’s explained at the top of the page?

    If you can’t do that by yourself, then what the heck are you going to do with code except get confused?

    MrE

    December 9, 2008 at 6:52 am

  96. http://opensource.arc.nasa.gov/project/javagenes/

    Nasa has had an open sourced genetic framework up for about 5 years now.

    might be a good starting point for you genetic developers out there.

    jeremiah

    December 9, 2008 at 6:53 am

  97. Sorry but I think you are not using a genetic algorithm at all like Johannes and Johan mentioned. Please change the title and description to refelect this since you are misleading other people.

    Alto

    December 9, 2008 at 6:55 am

  98. For MrE

    Why don’t you write the code based on the procedure and then explain it to us such that we won’t get confused with your code

    Daniel Duder

    December 9, 2008 at 7:10 am

  99. Are you sure this is GP or GA? Unless some of your polygons are being drawn off the canvas, I’m not quite following. Since the image is slowly converging by *adding* polygons and not mutating their positions, it looks like hill climbing to me.

    echelon

    December 9, 2008 at 7:14 am

  100. Damn. I did this same thing a year and half ago. Didn’t think there would be a Wired article about it.

    Bummed

    December 9, 2008 at 7:21 am

  101. > So what do you think?

    Spontaneous reaction: Oh wow.

    Dred Poirate Nanicoar

    December 9, 2008 at 7:32 am

  102. Very cool. I agree with previous posters though: this is a hill climber, not an EA.
    I’m guessing a hill climber is likely to work well in the given fitness landscape. Depends on the fitness function of course, but it would likely have no local maxima, making a hill climber more effective.

    Still: Seeing Mona Lisa slowly appearing like that is really cool.

    kroll

    December 9, 2008 at 7:55 am

  103. It is interesting to note, that 10^6 generations is equivalent for example 57*10^3 years of evolutions of drozofila. So: how complex structure may be evolved by this short time…

    kakaz

    December 9, 2008 at 8:28 am

  104. Eerie and very cool!

    Gods1Child

    December 9, 2008 at 8:35 am

  105. Really cool, nice work Roger!

    Jan

    December 9, 2008 at 8:48 am

  106. Kakaz: Because each iteration happens immediately after the other.. no need to wait for the old generation to “reproduce”.

    Itay

    December 9, 2008 at 8:53 am

  107. Is nothing sacred ?

    Sodding cubists !@#

    psycho sparky

    December 9, 2008 at 8:54 am

  108. That is a phenomenal piece of work, colour me very impressed, am very much looking forward to the source tomorrow – or should that be today?

    Irregular Activity

    December 9, 2008 at 9:00 am

  109. Every mention of evolution shouldn’t turn into a god vs. science debate, but I’m going to fuel the fire anyway. To those saying that this is no proof of evolution: true, the algorithm did have access to the ‘finished product’. However, the final form provided to the algorithm (AFAIK) is a raster image, not the polygons from which it is formed by the algorithm. In the same way, the final form dictated by evolution is survival, but the method to obtain that isn’t completely specified.

    amoe

    December 9, 2008 at 9:15 am

  110. [...] 100k generations he got a picture of… see for yourself. [...]

    Evolution Proof

    December 9, 2008 at 9:16 am

  111. Yes I agree it’s not a genetic algorithm, but I think the convergence rate is fine. Why is that an issue? He’s come up with a good, 50-polygon approximation with a “population size” of 1 and less than a million iterations. This is a reasonable amount of work compared to the true GAs I’ve seen with populations of thousands and needing thousands of iterations. But, more to the point, why optimize a one-shot calculation? That would be premature …

    To the ID straw-clutchers, this is not evidence that mankind evolved through ID. Evolution is not purely random; it occurs within an epigenetic landscape which includes (at least) the fixed laws of physics and chemistry. This calculation uses an epigenetic landscape of the Mona Lisa.

    A good example to demonstrate true evolution to the non-believers would be to have a million people rate the output of the algorithm and evolve it using their opinions. Then the output would still be “designed”, but by a million people rather than one all-powerful “designer”.

    Now create a statistical approximation of the ratings you got, and use that instead of people to rate the pictures. I bet you’d get a picture out which was aesthetically pleasing but had no designer. That’d be a nail in the coffin for those who believe ID because they don’t understand evolution :)

    Eddie

    December 9, 2008 at 9:39 am

  112. [...] el blog de Roger Alsing se recoge esta semana un experimento curioso realizado por el autor: generar la Mona Lisa a partir [...]

    Geeko! » Dibuja la Mona Lisa con 50 polígonos

    December 9, 2008 at 9:39 am

  113. In your face, creationists.

    Vincent

    December 9, 2008 at 9:56 am

  114. [...] Roger Alsing, creador de un programa genético ha estado jugando con su aplicación y ha creado a la Mona Lisa con sólo 50 polígonos semitransparentes: [...]

    La Mona Lisa dibujada con 50 polígonos | ..: Cristian Eslava | Diseño Gráfico / Web | Maquetación | Formación :..

    December 9, 2008 at 9:59 am

  115. How about creating three sets of polygons, each set for one channel in YCbCr -color space. They could still be alpha blended in this stage.

    ik

    December 9, 2008 at 10:00 am

  116. appler의 생각…

    Genetic Programming: Evolution of Mona Lisa « Roger Alsing Weblog 멋지다. 내가 일하는 쪽에도 적용할 대상이 많지 않을까….

    appler's me2DAY

    December 9, 2008 at 10:15 am

  117. Could the same algorithm be easily converted to use gradient meshes?

    Weird

    December 9, 2008 at 10:43 am

  118. [...] After just under 1 million iterations, you’d be surprised how good it gets. [...]

    Creative Computation | Genetic Algorithm Paints Mona Lisa

    December 9, 2008 at 10:46 am

  119. Wow, this is certenly impressive. Admited, I personaly won’t ever need somthing like that then again screw practical use! It is just cool ;).
    I too can’t wait to have a look at the source (even so I’ll have a hard time to run it w/o windows) but I doubt it will take long and this algorithm is ported to a few other languages :)

    Well done!

    Licenser

    December 9, 2008 at 10:55 am

  120. What about using it as morphing tool just by changing the goal?

    vokimon

    December 9, 2008 at 11:00 am

  121. It doesn’t really have much to do with nature’s evolution when you set up a specific goal, and discard everything that doesn’t take you one step closer to it. This is a misconception that many people on both sides seem to have.

    Evolutionist

    December 9, 2008 at 11:01 am

  122. This could offer an interesting approach to image compression or even more importantly raster to vector conversion.

    Nick Begich III

    December 9, 2008 at 11:29 am

  123. very impressive. Do you use 50 polygons at the start? , it seems as though the algorithm adds them progressively.

    Gearoid

    December 9, 2008 at 11:36 am

  124. An etch-a-sketch picture is ONE polygon with a huge number of sides. I’ve seen TV interviews with artists who can produce superb quality pictures just using this child’s toy, so it’s quite surprising that this code needs 50x as many polygons for the Mona Lisa.

    As previous comments have said, you should try to limiting the number of sides or vertexes to make this impressive.

    Pete Austin

    December 9, 2008 at 11:50 am

  125. “I have been pretty much obsessed with evolution stuff this past 1-2 years, read all Dawkins’s books. I Can really recommend the selfish gene, and the blind watchmaker, and ancestors tale, plus Genome by Matt Ridley was great, really interesting how DNA really can be viewed as a hard drive littered with remains neutralized viruses and other self serving copying processes.”

    Problem with these two guys is that they write nicely, but have very little actual knowledge of what they’re talking about. Neither has any background in genetics – let alone modern genetics (genomics/postgenomics) – that goes beyond undergrad level. Ridley is a passable zoologist, while Dawkins just writes nicely, but is not even a biologist at all and has fscked up the meaning of “gene” throughly and beyond redemption, thank you very much NOT: when Dawkins says “gene”, it may be anything between a single allele and a multigene complex like the bacterial flagellum and its chemical “rotary motor”.

    If they were correct, how come life ever progressed beyond protists? The price you pay for multicellularism is death, and that’s where it is hard to argue for “selfishness”. Sexual reproduction, as far as can be told, evolved not coincident with terminal mortality.

    The present example brings the point across rather nicely: no single “DNA sequence” benefits from being too “selfish”. They have to tread the middle gound between resource-hogging but replicating abundantly, and evolving but dying out for lack of replication carefully.

    Try Nature Reviews Genetics – there, you’ll find the real hardcore stuff. Dawkins and Ridley are, from a philosophical perspective, rather annoying logical positivists, with all weaknesses for their theories this implies: they only tell you what fits. That there are counterexamples galore, they’ll never tell you.

    Eike

    December 9, 2008 at 12:00 pm

  126. Hm. I like that.

    @Evolutionist:

    Anthropomorphized “goal”: reproduction and survival (micro and macro). Fitness algorithm: reproduction and survival. Generation production: reproducing and surviving, or the opposite.

    How “much” does it have to do with “nature’s evolution” before it has *something* to do with it? And what’s your point, anyway? It’s still G(evolutionary)P–which is all that’s claimed.

    Caligula

    December 9, 2008 at 12:08 pm

  127. So survival is no longer a specific goal, Evolutionist?

    ibsteve2u

    December 9, 2008 at 12:09 pm

  128. “It doesn’t really have much to do with nature’s evolution when you set up a specific goal, and discard everything that doesn’t take you one step closer to it. This is a misconception that many people on both sides seem to have.”

    Indeed. You can only assume temporary local optima; the “global optimum” is a misconception that smacks of ID, the pareidolia of the intelligent observer.

    “Un dimanche après-midi à l’Île de la Grande Jatte” might be a better work to start with. But nonwithstanding, you’d need an optimization against locally differing *variables*.

    You might *not* need randomness except in the “mutation” and as a starting condition however. The oldest biogenic stromatolites are more than half as old as this planet itself, so the first *nonrandom structures* created *by organisms* must be older.

    (Dawkin’s one *really* great idea was the extended phenotype. For anything else, refer to current peer-reviewed journals.)

    Eike

    December 9, 2008 at 12:26 pm

  129. For those interested in genetic algorithms, I have a program (in C++) which encodes words into a Boggle grid. The source is freely available to view and play with. It is also written using templates so you can modify it easily to work on other genetic optimization problems.

    Look for the “Inverse Boggle Encoder” at http://professorguy.com/ideas

    The Professor

    December 9, 2008 at 12:34 pm

  130. [...] the exact algorithm that is being used, but Roger Alsing shows some interesting results in his post Genetic Programming: Evolution of Mona Lisa. I don’t think it is the classic Genetic Programming as per Koza, but the results are really [...]

    Evolving Art with Nature Inspired Algorithms

    December 9, 2008 at 12:36 pm

  131. Marvelous!

    Are the polygons always convex? Looking at the samples I don’t see any that aren’t.

    BearOfNH

    December 9, 2008 at 12:38 pm

  132. Evolutionist: The goal and discard is simply substituting for the “fittest” criterion of Nature’s “survival of the fittest”. However, earlier criticism is correct to some degree – this is a very limited version of “genetic programming”.

    TaraLi

    December 9, 2008 at 12:42 pm

  133. I agree with Evolutionist – this is goal-directed evolution (more like – egads – intelligent design). A truly evolutionary algorithm would compare each picture and the LAST picture against a shifting set of environmental conditions. The order emerges from that process over time.

    However, as a demonstration that a randomised process can produce a highly non-random outcome, its certainly nice. As others have identified, the exact cirteria for accepting or rejecting each picture as closer than the last is critical. As ecological modelers say – the devils in the assumptions.

    Another evolutionist

    December 9, 2008 at 12:59 pm

  134. Guys, since no sources, it was just a “CorelDraw!” So do not bother. :-P

    Some geek around

    December 9, 2008 at 1:14 pm

  135. *sigh* As someone with a degree in AI, (and written GAs that did vaguely the reverse… sought a set of transparent rectangles to best classify images) I’ve got to apologize for all the misguided, and even downright stupid comments that have been posted.

    Your description was perfectly adequate to code an equivalent. I’m not at all surprised by the result, though it is a wonderful demonstration.

    It’s a shame people keep trying to read complexity into the algorithm, rather than appreciating it’s sheer simplicity. I hope this becomes a textbook example.

    Finally, All GA’s are “hill climbers”, (variants of simulated annealing) just with different randomizing functions and population sets. Just because you only evolved one code doesn’t make it any less a GA. There might have been efficiencies in using a thousand parallel codes and cross-breeding, but it’s mathematically the same thing.

    Kudos to you.

    Jeremy

    December 9, 2008 at 1:22 pm

  136. I would love to see the source code and make it trully genetic. We have here a climbing hill solution for 1.000.000 individuals. What would be the result for a 1000 generations of 1000 individuals with true genetic algorithm? What will it be with 10 generations of 100.000 individuals each? Looks funny to try.

    Eduard

    December 9, 2008 at 1:23 pm

  137. [...] Alsing recently wrote an evolutionary algorithm that recreated the Mona Lisa out of only 50 semi transparent polygons. The results are an impressive testimony to the power of such an approach (the final image being [...]

    neonascent » Blog Archive » Evolution of Mona Lisa

    December 9, 2008 at 2:08 pm

  138. My favourite is iiteration 0004333.jpg

    urodacus

    December 9, 2008 at 2:11 pm

  139. Genetic Programming: Evolution of Mona Lisa…

    Genetic Programming in practice. A developer makes a simple application which “evolves” the Mona Lisa from an arrangement of 50 transparent polygons….

    pligg.com

    December 9, 2008 at 4:44 pm

  140. [...] Posted in DSL, Evolution, Life, Random « Genetic Programming: Evolution of Mona Lisa [...]

    Genetic Programming: Mona Lisa FAQ « Roger Alsing Weblog

    December 9, 2008 at 6:10 pm

  141. Comments have been locked.

    Please see the Mona Lisa FAQ post instead.
    http://rogeralsing.com/2008/12/07/genetic-programming-evolution-of-mona-lisa/

    Roger Alsing

    December 9, 2008 at 7:35 pm

  142. [...] “4841035901″; google_ad_width = 336; google_ad_height = 280; Fantastic experiment and write up by Roger Alsing. Using an evolutionary algorithm, Roger wrote a programme that would attempt to paint the Mona Lisa [...]

    Evolving the Mona Lisa by natural selection | Cow's Blog

    December 9, 2008 at 8:46 pm

  143. [...] Je kan genetische algoritmes ook gebruiken om de Mona Lisa te schilderen. [...]

    Geweldig nutteloze AI | GeekSpeak

    December 9, 2008 at 8:52 pm

  144. [...] navegando pela internet, topei com um post entitulado “Genetic Programming: Evolution of the Mona Lisa” que reacendeu meu interesse pelo assunto. Basicamente, o autor mostra como, usando apenas 50 [...]

    /dev/Kico » Blog Archive » Programação Genética: recriando a Mona Lisa com apenas 50 poligonos!

    December 9, 2008 at 9:47 pm

  145. [...] Genetic Programming: Evolution of Mona Lisa [...]

    BloGals » Archive du blog » Programmation Génétique - Genetic Programming

    December 9, 2008 at 10:00 pm

  146. [...] The basic ideas are so simple that web versions (explanation and discussion) have been popping up. posted by DU (55 comments total) 20 users marked this as a favorite That Mona Lisa thing [...]

    What Good Is Half A Machine? | MetaFilter

    December 9, 2008 at 10:49 pm

  147. [...] “generations” to finally achieve the desired result, but usually you end up with simply spectacular [...]

    P3naeus monod0n » Blog Archive » I, For One, Welcome Our New Software Overlords.

    December 9, 2008 at 10:55 pm

  148. [...] Genetic Programming: Evolution of Mona Lisa This weekend I decided to play around a bit with genetic programming and put evolution to the test, the test of fine [...] [...]

    Top Posts « WordPress.com

    December 10, 2008 at 12:08 am

  149. [...] Genetic Programming: Evolution of Mona Lisa [EDIT] Added FAQ here: http://rogeralsing.com/2008/12/09/genetic-programming-mona-lisa-faq/ This weekend I decided to [...] [...]

    Top Posts « WordPress.com

    December 10, 2008 at 12:25 am

  150. [...] Genetic Programming: Evolution of Mona Lisa « Roger Alsing Weblog (tags: programming graphics art images algorithms math ai algorithm evolution) [...]

    links for 2008-12-09

    December 10, 2008 at 12:33 am

  151. [...] process 904,314 times until he ended up with a 50 polygon image that looks just like the Mona Lisa. Genetic Programming: Evolution Of The Mona Lisa (Via [...]

    Genetic Programming: Evolution Of The Mona Lisa | The Current Buzz - Tech

    December 10, 2008 at 2:01 am

  152. [...] the procedure is quite simple: The procedure of the program is quite [...]

    Hypnotizing Rabbit » Blog Archive » Genetic programming and the Mona Lisa

    December 10, 2008 at 3:29 am

  153. [...] Mona Lisa as 50 semitransparent polygons. [...]

    Shorter Than Ever | Lycanthropia

    December 10, 2008 at 4:58 am

  154. [...] at the image in which is the result of that test here (it might take a longer time to load on the main site due to the large size of the [...]

    Evolution of Mankind Art - Evolution of Mona Lisa Through Genetic Programming

    December 10, 2008 at 5:39 am

  155. [...] Alsing] wanted to try out some genetic programming, so he created a simple test problem: Could you render the Mona Lisa using just 50 semitransparent polygons? The program starts with a random DNA sequence. It then mutates and compares itself to the original [...]

    Querystring » Genetic programming

    December 10, 2008 at 6:45 am

  156. [...] art: Could you paint a replica of the Mona Lisa using only 50 semi transparent polygons?” – Apparently one can. Be sure to read the follow-up FAQ too. Spread the [...]

    Bram.us » The Evolution of the Mona Lisa - Genetic Programming

    December 10, 2008 at 9:37 am

  157. [...] simple process and how to create your own genetically programmed polygon rendered portrait, try this. Verizon Satellite TVGet your regular fix – subscribe to the About:Blank RSS [...]

    The Mona Lisa recreated using 50 transparent polygons… | About Colon Blank :: The Procrastinators Wet Dream!

    December 10, 2008 at 9:51 am

  158. [...] 遗传算法与蒙娜丽莎 By ryanchen 这几天我订阅的几个网站都在转载同一个消息：某人利用遗传算法，只用５０个半透明的多边形就重现了达芬奇名画《蒙娜丽莎》（http://rogeralsing.com/2008/12/07/genetic-programming-evolution-of-mona-lisa/）。 [...]

    遗传算法与蒙娜丽莎 « Ryanchen’s Weblog

    December 10, 2008 at 10:37 am

  159. [...] Roger Asling wrote a program that draws polygons which are verified to a reference image. Loop after loop the result gets closer to that image. In this test he used an image of the Mona Lisa, the digital render is made with only 50 semi transparent polygons. It took 904314 iterations to get the final image. [...]

    Evolution of Mona Lisa – today and tomorrow

    December 10, 2008 at 10:38 am

  160. [...] this is the most amazing thing i have ever seen. seriously. how awesome is this? very. Genetic Programming: Evolution of Mona Lisa Roger Alsing Weblog __________________ You must defeat the FIA to stand a [...]

    Genetic Programming - The Prophecy Forums

    December 10, 2008 at 10:46 am

  161. [...] Roger Alsing zaprezentował ciekawy eksperyment, w którym ewolucję kształtów populacji 50 półprzezroczystych wielokątów wzmacniano tak, by za najlepsze uchodziły te tworzące wizerunek Mony Lisy. Osiągnięty efekt jednoznacznie przywodzi na myśl oryginał. [...]

    Free Gadget News » Algorytmy ewolucyjne w obrazkach

    December 10, 2008 at 12:21 pm

  162. [...] Go on, play with it yourself here and see how it is done (you can use your own pictures too!), and the explanation (source code coming soon too) is here. [...]

    Another Evolutionary Painting « Gems Sty

    December 10, 2008 at 1:31 pm

  163. [...] Genetic Programming: Evolution of Mona Lisa « Roger Alsing Weblog. [...]

    Genetic Programming: Evolution of Mona Lisa « Roger Alsing Weblog :: MezzoMondo

    December 10, 2008 at 1:58 pm

  164. [...] December 10, 2008 · No Comments This is amazing: The Mona Lisa recreated using just 50 semi-transparent polygons. [...]

    Genetric Programming Recreates Mona Lisa « MRod says:

    December 10, 2008 at 2:27 pm

  165. [...] I ran into this blog post of Roger Alsing were he shows a very nice application of genetic algorithms to an Art application. He set out to approximate the Mona Lisa painting using 50 transparent polygons. And his solutions looks quite accurate. It looks very nice and seems to approach the original nicely: http://rogeralsing.com/2008/12/07/genetic-programming-evolution-of-mona-lisa/ [...]

    leipies-bloggy » Blog Archive » Genetic search and Art

    December 10, 2008 at 2:32 pm

  166. [...] Eine andere Interessante Anwendung eines genetischen Algorithmus findet sich hier. 50 Polygone mutieren in Position, Form, Farbe und Transparenz (?), bis am Ende (nach 904.314 [...]

    Auto(-)evolution « allzutaegliches

    December 10, 2008 at 3:31 pm

  167. [...] Genetic Programming: Evolution of Mona Lisa (Via Presurfer ) & (Via Boingboing) Compartilhe: [...]

    A evolução da Monalisa | ArrobaZona.com | Sua zona de fragmentos digitais

    December 10, 2008 at 4:09 pm

  168. [...] Mona Lisa “painted” using just 50 semi-transparent polygons. Filed under: uncategorized   |   Tags: bunch of [...]

    Bunch of links - #5 « PICDIT

    December 10, 2008 at 6:22 pm

  169. [...] re-implementation using and JS of the Mona Lisa genetic programming experiment featured on Boing Boing this week. Upload your own image and self-select the most useful [...]

    Image Evolution using Javascript and `canvas` | Phil Nelson Writes Here

    December 10, 2008 at 8:14 pm

  170. [...] the Mona Lisa Yesterday a link to a guy who had created a pretty good replica of the Mona Lisa out of semi-transparent, colored polygons using an ev… made the rounds on the [...]

    Evolving the Mona Lisa « The Maas:Media

    December 10, 2008 at 9:08 pm

  172. [...] a bit of fun, I decided to re-implement Roger Alsing’s approximation of the Mona Lisa in Ruby (my language of [...]

    Coding is like gardening… with less mud » Genetic Algorithms: Approximating Fine Art

    December 11, 2008 at 12:44 am

  173. [...] Algorithms in Perl Inspired by recent genetic algorithms floating around, I decided to try my hand at implementing one in perl. I’d thought [...]

    Genetic Algorithms in Perl « Dabbler

    December 11, 2008 at 1:20 am

  174. [...] Alsing is a clever fellow. Mike S. sent along this link to Robert’s blog entry about his genetic program to render a passable picture of the Mona [...]

    Extremely Late Renaissance » Mona Lisa Underdrawn

    December 11, 2008 at 1:49 am

  175. [...] the Mona Lisa By twistedone151 This is really cool: Genetic Programming: Evolution of Mona Lisa. Roger Alsing used a genetic algorithm program to produce a replica of the Mona Lisa that uses just [...]

    Evolving the Mona Lisa « Twisted One 151’s Weblog

    December 11, 2008 at 3:12 am

  176. [...] now a configurable web app for the semi-transparent vectors evolution approach mentioned earlier. Using Firefox (among other browsers, but not Internet Explorer – the page [...]

    Google Adsense Tips & News » Blog Archive » Polygons Evolving Into Your Custom Picture

    December 11, 2008 at 6:10 am

  177. [...] on hold until the start of the next term. However, while surfing on the internet I stumbled on this cool project and it gave me some ideas for a new project so stay [...]

    Wordpress Update | Rhinosphere

    December 11, 2008 at 6:12 am

  178. [...] Roger Alsing : Genetic Programming: Evolution of Mona Lisa No Comments, Comment or [...]

    A single snowflake in the fractal explosion of technology

    December 11, 2008 at 9:27 am

  179. [...] Genetic Programming: Evolution of Mona Lisa « Roger Alsing Weblog (tags: art cool science programming graphics ai evolution math artificialintelligence algorithm machine-learning) Filed Under: del.icio.us linksTagged: [...]

    links for 2008-12-11 : Eggplantia5

    December 11, 2008 at 12:01 pm

  180. [...] guy named Roger Alsing wrote a little program that evolves a Mona Lisa from 50 polygons! I created a small program that keeps a string of DNA for polygon rendering. The [...]

    jon abad dot com · I’m told that I am the internet.

    December 11, 2008 at 2:58 pm

  181. [...] עם 50 פוליגונים שמתפתחים כמו דנ”א. הוא דיי הצליח תוך קצת פחות ממיליון דורות של מוטציות. הבעיה היחידה היא שהוא כיוון למונה [...]

    The Less Interesting Times » Blog Archive » 11/12/2K8 והרי החדשות

    December 11, 2008 at 5:23 pm

  182. [...] Genetic Programming: Evolution of Mona Lisa « Roger Alsing Weblog. [...]

    Navigator Technology » Blog Archive » Genetic Programming: Evolution of Mona Lisa

    December 11, 2008 at 9:16 pm

  184. [...] Menschen scheinen viel zu viel Zeit zu haben. Roger Alsing zum Beispiel. Denn der hat sich tatsächlich die Mühe gemacht, einen evolutionsalgorithmus zu schreiben, mit dem man anhand von 50 Polygonen in einer etliche [...]

    Mona Lisa aus Polygonen in 900.000 Schritten : Netzfischer.EU

    December 11, 2008 at 10:16 pm

  185. [...] Evolución de la Mona Lisa Genética Genetic Programming (Wikipedia en [...]

    ZihuAztlan » Blog Archive » La Mona Lisa mediante Programación Genética

    December 12, 2008 at 12:05 am

  186. [...] Genetic Programming: Evolution of Mona Lisa « Roger Alsing Weblog (tags: programming genetic-algorithms algorithms cs machine-learning) [...]

    links for 2008-12-11 | chrisgrice.com

    December 12, 2008 at 1:30 am

  187. [...] Mona Lisa painted with 50 [...]

    Friday Procrastination: Link Love : OUPblog

    December 12, 2008 at 1:33 pm

  188. [...] Genetic Programming: Evolution of Mona Lisa « Roger Alsing Weblog Could you paint a replica of the Mona Lisa using only 50 semi transparent polygons? (tags: programming graphics evolution) [...]

    links for 2008-12-12 | /dev/random

    December 12, 2008 at 6:00 pm

  189. [...] Genetic Programming: Evolution of Mona Lisa « Roger Alsing Weblog Could you paint a replica of the Mona Lisa using only 50 semi transparent polygons? (tags: programming graphics evolution) [...]

    links for 2008-12-12 « Mike’s Blog

    December 12, 2008 at 10:02 pm

  190. [...] a comment » Since I posted my evolving Mona Lisa post I have received allot of questions and comments regarding the [...]

    Evolutionary misconceptions « Roger Alsing Weblog

    December 12, 2008 at 10:48 pm

  191. [...] Genetic Programming: Evolution of Mona Lisa « Roger Alsing Weblog. [...]

    Evolution of Mona Lisa « Adam Kapler

    December 12, 2008 at 10:53 pm

  192. [...] this incredible demonstration of evolution (of a [...]

    Even more totally awesome stuff « Circadian Rhythms

    December 12, 2008 at 11:26 pm

  193. [...] Genetic Programming: Evolution of Mona Lisa – Using a simple DNA algorithm and 50 polygons, the author creates an amazing replica of the Mona Lisa. The images of the progress are way cool. [...]

    Friday Links #29 | Blue Onion Software *

    December 12, 2008 at 11:55 pm

  194. [...] more than a cool toy, but it is still really cool! This is made using a simple application by Roger Alsing that starts with a blank slate and then adds some random polygons to it. The result is compared to [...]

    calltoreason.org » My photo rendered using polygons

    December 13, 2008 at 12:32 am

  195. [...] Genetic Programming: Evolution of Mona Lisa – "Could you paint a replica of the Mona Lisa using only 50 semi transparent polygons?" [...]

    piece 0 plastic - the revolution will be blogged » ruff linkage 200850

    December 13, 2008 at 7:51 am

  196. [...] Genetic Programming: Evolution of Mona Lisa « Roger Alsing Weblog No Comments Leave a Commenttrackback addressThere was an error with your comment, please try again. name (必需)email (will not be published) (必需)url [...]

    » Genetic Programming: Evolution of Mona Lisa « Roger Alsing Weblog mulei.info 老木，一路向西

    December 13, 2008 at 1:18 pm

  198. [...] O trabalho mostrou que é possível recriar o quadro do Leonardo Davinci usando apenas 50 polígonos semitransparentes. O melhor resultado foi obtido através de 904.314 gerações. fonte [...]

    Mona lisa remake | Mundo Gump

    December 13, 2008 at 3:47 pm

  199. [...] By danbystrom As you are all probably already familiar with, Roger Alsing got this really really cool idea earlier this [...]

    Besserwisser blog « My Blog

    December 13, 2008 at 4:38 pm

  200. [...] to actually implementing one. A recent flurry of blog posts and forum chatter about them – such as this program for evolving the Mona Lisa as a vector image, or this one which breeds vehicles, rekindled my [...]

    Modulo Errors » Blog Archive » Genetic Algorithms with Processing

    December 13, 2008 at 7:28 pm

  201. [...] MVC Content Management System (Adam Kinney’s interview with the team)  – Roger Alsing uses Genetic Program to shape 50 polygons into the Mona Lisa – Justin Needham and Matthew Straub use Windows CE to build a system that can predict the path of [...]

    This week on C9: Oxite, Mona Lisa, Pool hacks, and Coding4Fun Gifts | This Week On Channel 9 | Channel 9

    December 13, 2008 at 7:35 pm

  202. [...] MVC Content Management System (Adam Kinney’s interview with the team)  – Roger Alsing uses Genetic Program to shape 50 polygons into the Mona Lisa – Justin Needham and Matthew Straub use Windows CE to build a system that can predict the path of [...]

    This week on C9: Oxite, Mona Lisa, Pool hacks, and Coding4Fun Gifts | Games Money

    December 13, 2008 at 9:01 pm

  203. [...] Genetic Programming: Evolution of Mona Lisa [EDIT] Added FAQ here: http://rogeralsing.com/2008/12/09/genetic-programming-mona-lisa-faq/ Added Gallery here: [...] [...]

    Top Posts « WordPress.com

    December 14, 2008 at 12:18 am

  204. [...] now a configurable web app for the semi-transparent vectors evolution approach mentioned earlier. Using Firefox (among other browsers, but not Internet Explorer – the page [...]

    All about link building.

    December 14, 2008 at 5:35 am

  205. [...] About a week ago, Roger Alsing generated a whole new wave of interest in evolutionary algorithms, and genetic programming, when he posted an article describing how he had use an evolutionary approach to produce a remarkable copy of the Mona Lisa usi…. [...]

    Matthew Lynch vs Rationality » Blog Archive » Fun with Genetic Algorithms

    December 14, 2008 at 3:42 pm

  206. [...] Alsing hat letzte Woche ein cooles Programm in seinem Blog vorgestellt, welches mittels durchsichtigen Polygonen ein vorgegebenes Bild nachzeichnet. Die [...]

    blueblog » Blog Archive » genetische Evolution von Bildern

    December 14, 2008 at 4:31 pm

  207. [...] of a followup to earlier posts Drawing Hexmaps and Saving PNG from PyGame. A recent comment from Roger Aisling on the second of those posts asked about drawing with opacity in the Python Image Library (PIL). A [...]

    Living Code » Blog Archive » Drawing with opacity

    December 14, 2008 at 6:46 pm

  208. [...] @ 20:42 As you are all probably already familiar with, Roger Alsing got this really really cool idea earlier this [...]

    Besserwisser post on EvoLisa « Dan Byström’s Weblog

    December 14, 2008 at 6:48 pm

  209. [...] with Parallel Programming, Genetic Programming is getting quite a bit of coverage of late. I love this little .Net example. Make sure you grab the source code from [...]

    Microsoft NZ MSDN Blog : MSDN Flash Christmas Special

    December 14, 2008 at 8:01 pm

  210. [...] with Parallel Programming, Genetic Programming is getting quite a bit of coverage of late. I love this little .Net example. Make sure you grab the source code from [...]

    Nigel Parker's Outside Line : MSDN Flash Christmas Special

    December 14, 2008 at 8:02 pm

  211. [...] MVC Content Management System (Adam Kinney’s interview with the team)  – Roger Alsing uses Genetic Program to shape 50 polygons into the Mona Lisa – Justin Needham and Matthew Straub use Windows CE to build a system that can predict the path of [...]

    This week on C9: Oxite, Mona Lisa, Pool hacks, and Coding4Fun Gifts | CHARGED's Digital Lifestyle at Work or Play

    December 14, 2008 at 9:30 pm

  212. [...] Ned, I came across Roger Alsing’s very cool genetic vectorizer: a little app which takes a photograph and “evolves” a small set of overlapping [...]

    Hugh’s ramblings » Blog Archive » Genetic Vectorizer

    December 14, 2008 at 10:48 pm

  215. [...] Filed under: Programming — danbystrom @ 13:57 Follow-up on Improving performance… and Genetic Programming: Evolution of Mona Lisa. I just tested that I can optimize this [...]

    Optimizing away « Dan Byström’s Weblog

    December 16, 2008 at 12:00 pm

  216. die Evolution der Mona Lisa…

    Roger Alsing hat hier ein sehr schönes Programm entworfen um auf Basis von genetischen Algorithmen Bilder zu erstellen. Auch wenn der Grundgedanke nicht so kompliziert ist, erstmal muß man darauf kommen. Außerdem ergeben sich sehr schöne Bilder.
    Le…

    Alt Gr

    December 16, 2008 at 1:54 pm

  217. [...] know Leonardo Da Vinci was brilliant and all that, but I’m pretty sure this would have blown his mind: This weekend I decided to play around a bit with genetic programming and put evolution to the [...]

    turn that shit UP » Blog Archive » Genetic Programming: Evolution of Mona Lisa « Roger Alsing Weblog

    December 16, 2008 at 9:00 pm

  218. [...] Alsing has used this simple approach to create a likeness of the famous Mona Lisa thats scarily [...]

    kierandelaney.net » Blog Archive » Building The Mona Lisa

    December 17, 2008 at 1:18 pm

  219. [...] olvastam a genetikus algoritmusról, ami érdekes, persze honnan jött a tipp, codinghorrorról, persze. Teljesen új [...]

    rhapsodhy.hu » about wealth and taste

    December 17, 2008 at 8:26 pm

  220. [...] Alsing] wanted to try out some genetic programming, so he created a simple test problem: Could you render the Mona Lisa using just 50 semitransparent polygons? The program starts with a random DNA sequence. It then mutates and compares itself to the original [...]

    Free of All » Blog Archive » Genetic programming

    December 18, 2008 at 1:54 am

  221. survival of the fittest…

    the last days I often looked at the pictures on Roger Alsings page. This is a very fascinating way to recreate a picture, so I tried to do it my own way. This was my first attempt to create a Mona Lisa like Roger’s
    I hope you can see the smile….

    Alt Gr

    December 18, 2008 at 8:31 am

  222. [...] The original blog entry from the Roger Alsing Weblog. TrackBack URI for this entry is http://www.tweakandgeek.com/podcast/wp-trackback.php?p=116 [...]

    Tweak and Geek » Blog Archive » TG#16.5: Mona Lisa Evolution

    December 18, 2008 at 2:40 pm

  223. [...] results of algorithmically evolving the Mona Lisa (There’s also software, but it doesn’t work on my [...]

    Interesting stuff for December 2008 « The Outer Hoard

    December 19, 2008 at 10:04 am

  224. [...] die Mona Lisa mit nur 50 halbtransparenten Polygonen zeichnen? Mit dieser Fragestellung entwickelte Roger Alsing sein Tool, bei dem solche Ergebnisse, nach 571266 Generationen, 2,5 Stunden  Laufzeit und 119 [...]

    blog@kde» Blogarchiv » Genetische Programmierung: Evolution der Mona Lisa

    December 19, 2008 at 1:19 pm

  225. [...] Genetic Programming: Evolution of Mona Lisa (download) Roger Alsing evolves fine art. [...]

    Quirky Sunday Links

    December 21, 2008 at 4:50 pm

  226. [...] ejemplo de resolución de este tipo de problemas lo encontramos en la reciente implementación por Roger Alsing de un algoritmo genético para aproximar una imagen utilizando un número pequeño de polígonos [...]

    Pinceladas de evolución | la ciudadela

    December 21, 2008 at 10:45 pm

  227. [...] across this interesting image evolution project on AlteredQualia yesterday. This project takes Roger Alsing’s example of image evolution using polygon rendering and re-implements it in JavaScript. I decided to run my own test against my [...]

    Complicated Algorithm, Neat Images | Slaptijack

    December 22, 2008 at 4:46 pm

  228. [...] Genetic Programming: Evolution of Mona Lisa [...]

    The Evolution of Mona Lisa | Nature Notes from Harold Stiver

    December 24, 2008 at 11:01 am

  229. [...] Više pogledajte na njegovom blogu. [...]

    Evolucija Mona Lise

    December 26, 2008 at 10:50 am

  230. [...] recent popular example of genetic programming is the production of the Mona Lisa using random polygons. My program should almost be able to handle this. I don’t allow for a “modify [...]

    Evolving Genetic Algorithms in Lisp | So Jake Says

    December 29, 2008 at 4:01 am

  231. [...] Watch an evolution algorithm paint the mona lisa. [...]

    Kangaroo sequences, cocaininated bees and stupid robots « It’s Alive!!

    December 30, 2008 at 2:51 am

  232. [...] cool is it trying to reproduce a picture using evolutionary computing as an approach. Roger Alsing implemented it, showed it to the world, and got slashdotted for it. Receiving an increase of 120000 [...]

    » Blog Archive » Evolutionary Computing

    December 30, 2008 at 10:54 pm

  233. [...] one’s made the rounds, but just in case: the Mona Lisa with 50 semi-transparent polygons, evolved (sort-of). Here’s a little eye candy (two links). Plus, panoramas [...]

    Real-Time Rendering » Blog Archive » This, That, and the Other

    January 7, 2009 at 4:09 am

  234. [...] few weeks ago, the geek-o-sphere was abuzz with a picture of the Mona Lisa drawn by fifty overlapping translucent polygons… I thought it was a neat hack, and forgot all about it until last [...]

    West Karana » The Evolution of Ebony

    January 7, 2009 at 12:32 pm

  235. [...] This is a very cool little hack by Roger Alsing that, draws polygons randomly, then creates a mutation of the previous image.  It then decides which one is closer to the final image and destroys the least similar.  It keeps making mutations of the better (of the two) images, until it comes out with a final product.  You can download a binary for the application here: Click. [...]

    Genetic Program Creates Image of Mona Lisa at The Tech Record

    January 7, 2009 at 3:04 pm

  236. [...] mid-December I read a blog with a brilliant little piece of genetic programming, wherein a set of pseudo-DNA is used to generate an image out of a set of, at maximum, fifty [...]

    Lousy Canuck » Python Evolution - part 1

    January 11, 2009 at 9:12 pm

  237. [...] those that looked more like it. After about 900,000 generations, the program came up with a good re-creation of the Mona Lisa. He then released source code and binaries and posted some other results people sent in. permanent [...]

    The World of Stuff - Blog Archive - We are the champions

    January 12, 2009 at 5:11 am

  238. [...] Genetic Programming: Evolution of Mona Lisa, [...]

    dholm.com » Blog Archive » Tumblelog: 090112

    January 12, 2009 at 9:31 am

  240. [...] warning deluxe. By chance I came across Genetic Programming – The evolution of Mona Lisa by Roger Alsing today while browsing around randomly. He has done genetic programming in what seem to be a way that [...]

    Me made out of Genetic Programming! | Oscar and Friends

    January 14, 2009 at 11:20 pm

  241. [...] my thesis I’m reading about Genetic Programming and I just ran into something cool. This guy made a program that tries to remake the Mona Lisa using only 50 polygons. It mutates the [...]

    C Hees . info » Mona Lisa with Genetic Programming

    January 15, 2009 at 12:49 pm

  242. [...] Evolving the Mona Lisa. How well can you approximate Leonard da Vinci’s Mona Lisa using only 50 polygons? [...]

    New Adventures in Software » Practical Evolutionary Computation: An Introduction

    January 20, 2009 at 12:13 am

  243. [...] is a video of Roger Alsing’s EvoLisa project evolving an image of the Mona Lisa using random [...]

    Brian Low » EvoLisa Video

    January 27, 2009 at 3:29 am

  244. [...] is a Haskell port of the EvoLisa program which can be found here: http://rogeralsing.com/2008/12/07/genetic-programming-evolution-of-mona-lisa [Genetic Programming: Evolution of Mona Lisa - Roger Alsing Weblog]. The original source code (C#) [...]

    Hevolisa « e7ektroblog

    January 31, 2009 at 9:39 pm

  245. [...] Alsing氏が以前公開した、モナリザの絵をプログラムで複写したプロジェクトがベースになっているのですが、Image [...]

    STNDE | Image evolution | Javascriptで画像マイニング

    February 6, 2009 at 5:29 pm

  246. [...] Design, Programming A couple of weeks ago Roger Alsing made a genetic algorithm that manages to draw La Joconde using a disturbingly low number of translucent polygons. Very impressive but it reminds me of an [...]

    The evolution of a media player « Subjects Keeping Me Awake

    February 8, 2009 at 12:31 am

  247. [...] of the Image evolution page mentioned above, which is constantly updated, I found a link to the original creator of this idea. When I found some links inside the comments to his article which led me to the c# source code of [...]

    Evolving vectorization - Westhoffswelt - Welcome to the real world

    February 11, 2009 at 10:11 pm

  248. [...] Roger Alsing’s idea is to start with a random pile of polygons. Random mutations are applied to the polygons. The result is compared to the Mona Lisa source image, and mutations resulting in improvements are kept. Over many generations, the evolved image begins to resemble the Mona Lisa. [...]

    oranchak.com » Blog Archive » Simulated evolution parlor tricks

    February 13, 2009 at 2:23 pm

  249. [...] GA and ART, evolving Mona-Lisa [...]

    Genetic Algorithms.., A Primer « The Green Destiny

    February 16, 2009 at 9:50 am

  251. [...] Genetic Programming: Evolution of Mona Lisa [...]

    Today’s Mindboggler: 1000:1 compression ratios? « OpticalFlow

    February 20, 2009 at 4:18 am

  252. [...] of the application of genetic programming that paints out a Mona Lisa painting (Referring to Roger Alsing Weblog – Genetic Programming: Evolution of Mona Lisa). I nearly forgot about this topic for more than one year since I graduated and that blog reminds [...]

    Genetic Algorithm Part I « Eager to Code, Enjoy to Debug ~ Embark into Each Stage with Your Heart

    February 27, 2009 at 2:49 pm

  253. [...] far more interested in research like this: http://rogeralsing.com/2008/12/07/genetic-programming-evolution-of-mona-lisa/ recently. portraiture, representation, and a slight glitch aesthetic [...]

    c.onscio.us/ly :: Grrr

    March 5, 2009 at 11:29 am

  254. [...] a comment » When I first posted the “Evolution of Mona Lisa” post, there were a few questions raised regarding how well an evolutionary approach to image [...]

    Evolutionary Compression « Roger Alsing Weblog

    March 10, 2009 at 5:43 pm

  255. [...] The video below presents the evolution of the Mona Lisa’s painting as it moves along. The original post also provides other [...]

    LCS and GBML » Blog Archive » Evolution of Mona Lisa

    March 24, 2009 at 4:44 pm

  256. [...] first version duplicated the EvoLisa experiment pretty closely, and I found you could get some pretty high-fidelity representations of the target [...]

    Lousy Canuck » Python Picture Evolution part 2, finally

    April 1, 2009 at 10:06 pm

  257. [...] Элсинг (Roger Alsing) учредил конкурс по воссозданию портрета Моны Лизы с помощью всего пятиде…. Предварительно он написал небольшую программу, [...]

    Russian Coding 4 Fun : Мона Лиза у меня неплохо получилась

    April 6, 2009 at 4:22 pm

  258. [...] too long ago genetic algorithms were all the rage on the internets (see original here: genetic programming: evolution of mona lisa). I was keenly aware of genetic algorithms since I first learned of them in grad school and have [...]

    lbrandy.com » Blog Archive » Genetic Algorithms: Evolving Human Faces

    April 20, 2009 at 1:27 pm

  259. [...] seeing Roger Alsing’s evolution of the Mona Lisa, I was inspired to try to reproduce it using the Watchmaker Framework. I didn’t follow [...]

    New Adventures in Software » Watchmaker 0.6.0 - Evolutionary Computation for Java

    April 26, 2009 at 9:46 pm

  260. [...] with genetic algorithms in a class I took at Tufts and I’ve been increasingly curious since the “evolving Mona Lisa” code got out on the [...]

    {5} Setfive - Talking to the World » Blog Archive » Monkeys and shakespeare: genetic algorithms with Jenes

    April 30, 2009 at 8:16 am

  261. [...] Speaking of geeky art stuff, there’s this bit of work that made the rounds a couple of months ago:  Polygonal Mona Lisa; Genetic Programming [...]

    Hodgepodge « Tish Tosh Tesh

    May 9, 2009 at 1:23 pm

  262. [...] [upmod] [downmod] Genetic Programming: Evolution of Mona Lisa « Roger Alsing Weblog (rogeralsing.com) 2 points posted 5 months, 1 week ago by SixSixSix tags algorithms [...]

    Tagz | "Genetic Programming: Evolution of Mona Lisa « Roger Alsing Weblog" | Comments

    May 16, 2009 at 4:57 pm

  263. [...] are solved by computers learning, a la genetic algorithms in the case of Roger Alsing’s EvoLisa program or neural nets in the case of GNU Backgammon. But even in these arenas, computers are [...]

    Logic Nest · The Consequences of Trusting Computers

    May 29, 2009 at 5:39 pm

  264. [...] Now, programmer Roger Alsing has written an evolving program to “paint” Mona Lisa using just 50 polygons. “Huh?” you may say. Well, let’s let Alsing explain the steps his program [...]

    mental_floss Blog » Evolving Mona Lisa

    June 22, 2009 at 2:57 pm


Comments are closed.