AI Masterpieces: But is it Art?

While there’s no doubt that the quality of the results in style transfer is outstanding, many were left with feelings that the technique left little room for the concept of art itself, even calling it “… more of a parlor trick than the next revolution in fine art.”

By Yaroslav Kuflinski, AI/ML Observer at Iflexion

It’s said that all that needs to happen for something to be considered art is for someone who identifies as an artist to declare it as such. But to most of us, art is created, not just declared and should be delivered with a healthy dose of creative human agency.

Regardless of definitions, most of us know art when we see it, don’t we? And what does it matter in any case? The short answer is that computer art has been challenging us to confront these questions for over 50 years—the role of the artist (and that of the machine) in the field of computer art has never been completely easy to resolve. As artists seek to exploit the latest technologies, so that part of the process has to be constantly re-evaluated.


Computer-generated art and its beginnings

Looking for its origin, you might peg the beginnings of computer art in the 1950s, when experimenters used “mechanical and analogue devices - like oscilloscopes - to painstakingly produce images that foreshadowed the work of the later digital pioneers”—check out A history of computer art for some fascinating background.

Movements take off when they are accessible to large numbers of people. Like a lot of digital pioneers, the computer artists of the late 20th century unfortunately suffered from the mismatch between the high compute needs of their activities and their scarcity and cost.


Towards generative art

All that was to change when commodity computers began to pack some real punch. And crucial to the advancement of computer art into the modern era was the Processing project, created in 2001 by Ryan Hopkins, Casy Reas, and Ben Fry. Processing is “… an open-source graphical library and integrated development environment (IDE/playground) built for the electronic arts, new media art and visual design communities with the purpose of teaching non-programmers the fundamentals of computer programming in a visual context.” To use Processing, you have to write code in a variation of the Java programming language that’s had some of its sharp corners smoothed off.

Processing opened the floodgates for thousands of people to explore computer art. Generative art—in which randomness plays a crucial role—became popular and accessible to anyone with a little curiosity, and not only to those with access to supercomputers. For a more detailed re-telling of the history of generative art, see Why love generative art?

An example of how a rich result can be achieved from very little programming is in Matt Pearson’s Wave Clock (2009) as described in his book Generative Art (Manning, 2011), which renders images like:


The exciting point here is that there is no way by inspection of the source code alone to predict the emergent complexity of the final piece. Whether or not it is pleasing, or even art at all, depends on the interactions between the programmer, the machine, and, ultimately, you the observer. Don’t rate it? Check out Generative art finds its prodigy for some seriously wonderful images from a Processing master—Manolo Gamboa Naon from Argentina—that might persuade you otherwise.

Here's a Processing reimagining of the famous early piece called Schotter and created by Georg Nees in the 1960s, alongside the original:


And here’s the Processing source code, which we’ve adapted very slightly from the original that was written by Jim Plaxco at Artsnova.

// Georg Nees Schotter Reproduction by Jim Plaxco,

int columns = 12;       // number of columns of squares
int rows = 22;          // number of rows of squares
int sqrsize=30;         // size of each square
float rndStep=.22;      // Rotation Increment in degrees
float randsum=0;        // Cumulative rotation value
int padding=2*sqrsize;  // margin area
float randval;          // random value for translation and rotation
float dampen=0.45;      // soften random effect for translation
void setup() {
  background(255);   // set background color to white
  stroke(0);         // set pen color to black
  smooth();          // use line smoothing 
  noFill();          // do not fill the squares with color
  rectMode(CENTER);  // use x,y value as the center of the square
  noLoop();          // execute draw() just one time
} // end of setup()
void draw() {
  for (int y=1; y <= rows; y++){
    randsum += (y*rndStep);  // Increment the random value
    for (int x=1; x <= columns; x++) {
      randval = random(-randsum,randsum);
      translate( padding + (x * sqrsize) - (.5*sqrsize) + (randval*dampen),
                padding + (y * sqrsize) - (.5*sqrsize) + (randval*dampen));
    } // end of x loop
  } // end of y loop
} // end of draw()

Even if you’re not a developer, it’s fairly evident that the program involves a setup function and a draw function, and that the draw function integrates some random elements with more structured patterns. The end result is that the orientation and position of the squares deviate from their natural grid positions more and more as you progress down the image. In passing, it’s also nice to note that it didn’t take much programming to recreate this famous work.

Recently, a large part of Processing has been ported to JavaScript by the p5.js team—they are building a library that has the goal of making your browser page a sketchpad for Processing-like art. p5.js is probably even more accessible to beginners than Processing itself, as JavaScript is (perhaps notoriously) much less picky about being rigorous with variable types, among other misdemeanors.

You can find Processing here—and if interested, create a sketch using the source code above and obtain your own reimagining of Schotter within a few minutes.

If you’re interested in p5.js—check it out here.


AI art and style transfer

If art nerds had become a little smug at the embarrassing amounts of processing power available to them for conventional computer art, they were in for a rude awakening when they began to explore how they could exploit modern AI techniques like neural networks and machine learning in their work. Fortunately, just about on time, the cloud happened, giving them access (cost considerations aside) to the required vast compute resources, which nowadays also includes banks of GPUs to power the neural networks.

In 2015, in a seminal paper, Gatys and friends showed the world how to transfer the style of one image to another using deep convolutional neural networks (CNNs). His algorithm centered around the idea of mathematical optimization—seeking to minimize the difference between a synthesized image, the content of a source image, and the stylistic features of a style-contributing image.

The images below, adapted from Gatys’ paper, vividly illustrate the idea.



Gatys’ work was a breakthrough in the field of deep learning, providing the first neural-network-based method for style transfer. However, it was computationally intensive, and further research led to techniques that paved the way for real-time style transfer, enabling it to be applied to video streams.

This idea of style transfer has been incorporated in several commercial products—such as Prisma—and Harish Narayanan uses Prisma as the basis a good long-form explanation of the technology here.

While there’s no doubt that the quality of the results in style transfer is outstanding, many were left with feelings that the technique left little room for the concept of art itself, even calling it “… more of a parlor trick than the next revolution in fine art.”