Inceptionism: Going Deeper into Neural Networks
Posted by Alexander Mordvintsev, Software Engineer,
Christopher Olah, Software Engineering Intern and Mike Tyka,
Software Engineer
Artificial
Neural Networks have spurred remarkable recent progress in
image classification and speech
recognition. But even though these are very useful tools based
on well-known mathematical methods, we actually understand
surprisingly little of why certain models work and others don’t. So
let’s take a look at some simple techniques for peeking inside
these networks.
We train an artificial neural network by showing it millions of
training examples and gradually
adjusting the network parameters until it gives the
classifications we want. The network typically consists of 10-30
stacked layers of artificial neurons. Each image is fed into the
input layer, which then talks to the next layer, until eventually
the “output” layer is reached. The network’s “answer” comes from
this final output layer.
One of the challenges of neural networks is understanding what
exactly goes on at each layer. We know that after training, each
layer progressively extracts higher and higher-level features of
the image, until the final layer essentially makes a decision on
what the image shows. For example, the first layer maybe looks for
edges or corners. Intermediate layers interpret the basic features
to look for overall shapes or components, like a door or a leaf.
The final few layers assemble those into complete
interpretations—these neurons activate in response to very complex
things such as entire buildings or trees.
One way to visualize what goes on is to turn the network upside
down and ask it to enhance an input image in such a way as to
elicit a particular interpretation. Say you want to know what sort
of image would result in “Banana.” Start with an image full of
random noise, then gradually tweak the image towards what the
neural net considers a banana (see related work in [1], [2], [3], [4]). By itself, that
doesn’t work very well, but it does if we impose a prior constraint
that the image should have similar statistics to natural images,
such as neighboring pixels needing to be correlated.
So here’s one surprise: neural networks that were trained to
discriminate between different kinds of images have quite a bit of
the information needed to
generate images too. Check out
some more examples across different classes:
Why is this important? Well, we train networks by simply showing
them many examples of what we want them to learn, hoping they
extract the essence of the matter at hand (e.g., a fork needs a
handle and 2-4 tines), and learn to ignore what doesn’t matter (a
fork can be any shape, size, color or orientation). But how do you
check that the network has correctly learned the right features? It
can help to visualize the network’s representation of a fork.
Indeed, in some cases, this reveals that the neural net isn’t quite
looking for the thing we thought it was. For example, here’s what
one neural net we designed thought dumbbells looked like:
There are dumbbells in there alright, but it seems no picture of a
dumbbell is complete without a muscular weightlifter there to lift
them. In this case, the network failed to completely distill the
essence of a dumbbell. Maybe it’s never been shown a dumbbell
without an arm holding it. Visualization can help us correct these
kinds of training mishaps.
Instead of exactly prescribing which feature we want the network to
amplify, we can also let the network make that decision. In this
case we simply feed the network an arbitrary image or photo and let
the network analyze the picture. We then pick a layer and ask the
network to enhance whatever it detected. Each layer of the network
deals with features at a different level of abstraction, so the
complexity of features we generate depends on which layer we choose
to enhance. For example, lower layers tend to produce strokes or
simple ornament-like patterns, because those layers are sensitive
to basic features such as edges and their orientations.
|
Left: Original photo by
Zachi Evenor. Right: processed by Günther Noack, Software
Engineer |
|
Left: Original painting by Georges
Seurat. Right: processed images by Matthew McNaughton, Software
Engineer |
If we choose higher-level layers, which identify more sophisticated
features in images, complex features or even whole objects tend to
emerge. Again, we just start with an existing image and give it to
our neural net. We ask the network: “Whatever you see there, I want
more of it!” This creates a feedback loop: if a cloud looks a
little bit like a bird, the network will make it look more like a
bird. This in turn will make the network recognize the bird even
more strongly on the next pass and so forth, until a highly
detailed bird appears, seemingly out of nowhere.
The results are intriguing—even a relatively simple neural network
can be used to over-interpret an image, just like as children we
enjoyed watching clouds and interpreting the random shapes. This
network was trained mostly on images of animals, so naturally it
tends to interpret shapes as animals. But because the data is
stored at such a high abstraction, the results are an interesting
remix of these learned features.
Of course, we can do more than cloud watching with this technique.
We can apply it to any kind of image. The results vary quite a bit
with the kind of image, because the features that are entered bias
the network towards certain interpretations. For example, horizon
lines tend to get filled with towers and pagodas. Rocks and trees
turn into buildings. Birds and insects appear in images of
leaves.
|
The original image influences what kind of objects form in
the processed image. |
This technique gives us a qualitative sense of the level of
abstraction that a particular layer has achieved in its
understanding of images. We call this technique “Inceptionism” in
reference to the
neural net architecture
used. See our
Inceptionism gallery
for more pairs of images and their processed results, plus some
cool video animations.
We must go deeper: Iterations
If we apply the algorithm iteratively on its own outputs and apply
some zooming after each iteration, we get an endless stream of new
impressions, exploring the set of things the network knows about.
We can even start this process from a random-noise image, so that
the result becomes purely the result of the neural network, as seen
in the following images:
The techniques presented here help us understand and visualize how
neural networks are able to carry out difficult classification
tasks, improve network architecture, and check what the network has
learned during training. It also makes us wonder whether neural
networks could become a tool for artists—a new way to remix visual
concepts—or perhaps even shed a little light on the roots of the
creative process in general.