- Good morning. So, it's 12:03 so, I want to get started. Welcome to Lecture 12, of CS-231N. Today we are going to talk about
Visualizing and Understanding convolutional networks. This is always a super fun lecture to give because we get to look a
lot of pretty pictures. So, it's, it's one of my favorites. As usual a couple administrative things. So, hopefully your projects
are all going well, because as a reminder your milestones are due on Canvas tonight. It is Canvas, right? Okay, so want to double check, yeah. Due on Canvas tonight, we are working on furiously grading your midterms. So, we'll hope to have those
midterms grades to you back by on grade scope this week. So, I know that was little confusion, you all got registration
email's for grade scope probably in the last week. Something like that, we start
couple of questions on piazo. So, we've decided to use grade
scope to grade the midterms. So, don't be confused, if you
get some emails about that. Another reminder is that assignment three was released last week on Friday. It will be due, a week from
this Friday, on the 26th. This is, an assignment three, is almost entirely brand new this year. So, it we apologize for taking
a little bit longer than expected to get it out. But I think it's super cool. A lot of that stuff, we'll
talk about in today's lecture. You'll actually be implementing
on your assignment. And for the assignment, you'll
get the choice of either Pi torch or tensure flow. To work through these different examples. So, we hope that's really
useful experience for you guys. We also saw a lot of activity on HyperQuest over the weekend. So that's, that's really awesome. The leader board went up yesterday. It seems like you guys are
really trying to battle it out to show off your deep learning neural network training skills. So that's super cool. And we because due to the high interest in HyperQuest and due to
the conflicts with the, with the Milestones submission time. We decided to extend the deadline for extra credit through Sunday. So, anyone who does at
least 12 runs on HyperQuest by Sunday will get little bit
of extra credit in the class. Also those of you who are,
at the top of leader board doing really well, will
get may be little bit extra, extra credit. So, I thanks for
participating we got lot of interest and that was really cool. Final reminder is about
the poster session. So, we have the poster
session will be on June 6th. That date is finalized, I think that, I don't
remember the exact time. But it is June 6th. So that, we have some questions about when exactly that poster session is for those of you who are traveling at the end of quarter
or starting internships or something like that. So, it will be June 6th. Any questions on the admin notes. No, totally clear. So, last time we talked. So, last time we had a pretty jam packed lecture, when we
talked about lot of different computer vision tasks, as a reminder. We talked about semantic segmentation which is this problem, where
you want to sign labels to every pixel in the input image. But does not differentiate the object instances in those images. We talked about classification
plus localization. Where in addition to a class label you also want to draw a box or perhaps several boxes in the image. Where the distinction here is that, in a classification
plus localization setup. You have some fix number of
objects that you are looking for So, we also saw that this type of paradigm can be applied to the things
like pose recognition. Where you want to regress to
different numbers of joints in the human body. We also talked about the object detection where you start with some fixed set of category labels
that you are interested in. Like dogs and cats. And then the task is
to draw a boxes around every instance of those objects that appear in the input image. And object detection
is really distinct from classification plus localization because with object
detection, we don't know ahead of time, how many object instances we're looking for in the image. And we saw that there's
this whole family of methods based on RCNN, Fast RCNN and faster RCNN, as well as the single
shot detection methods for addressing this problem
of object detection. Then finally we talked
pretty briefly about instance segmentation,
which is kind of combining aspects of a semantic
segmentation and object detection where the goal is to
detect all the instances of the categories we care about, as well as label the pixels
belonging to each instance. So, in this case, we
detected two dogs and one cat and for each of those instances we wanted to label all the pixels. So, these are we kind of
covered a lot last lecture but those are really interesting
and exciting problems that you guys might consider to using in parts of your projects. But today we are going to
shift gears a little bit and ask another question. Which is, what's really going on inside convolutional networks. We've seen by this point in the class how to train convolutional networks. How to stitch up different
types of architectures to attack different problems. But one question that you
might have had in your mind, is what exactly is going
on inside these networks? How did they do the things that they do? What kinds of features
are they looking for? And all this source of related questions. So, so far we've sort of seen ConvNets as a little bit of a black box. Where some input image of raw pixels is coming in on one side. It goes to the many layers of convulsion and pooling in different
sorts of transformations. And on the outside, we end up
with some set of class scores or some types of understandable
interpretable output. Such as class scores or
bounding box positions or labeled pixels or something like that. But the question is. What are all these other
layers in the middle doing? What kinds of things in the input image are they looking for? And can we try again intuition for. How ConvNets are working? What types of things in the
image they are looking for? And what kinds of techniques do we have for analyzing this
internals of the network? So, one relatively simple
thing is the first layer. So, we've seen, we've
talked about this before. But recalled that, the
first convolutional layer consists of a filters that, so, for example in AlexNet. The first convolutional layer consists of a number of convolutional filters. Each convolutional of filter
has shape 3 by 11 by 11. And these convolutional filters gets slid over the input image. We take inner products between
some chunk of the image. And the weights of the
convolutional filter. And that gives us our output of the at, at after that first
convolutional layer. So, in AlexNet then we
have 64 of these filters. But now in the first layer
because we are taking in a direct inner product
between the weights of the convolutional layer and the pixels of the image. We can get some since for what
these filters are looking for by simply visualizing the
learned weights of these filters as images themselves. So, for each of those
11 by 11 by 3 filters in AlexNet, we can just
visualize that filter as a little 11 by 11 image
with a three channels give you the red, green and blue values. And then because there
are 64 of these filters we just visualize 64
little 11 by 11 images. And we can repeat... So
we have shown here at the. So, these are filters taken
from the prechain models, in the pi torch model zoo. And we are looking at the
convolutional filters. The weights of the convolutional filters. at the first layer of AlexNet, ResNet-18, ResNet-101 and DenseNet-121. And you can see, kind
of what all these layers what this filters looking for. You see the lot of things
looking for oriented edges. Likes bars of light and dark. At various angles, in various
angles and various positions in the input, we can see opposing colors. Like this are green and pink. opposing colors or this orange
and blue opposing colors. So, this, this kind of
connects back to what we talked about with Hugh and Wiesel. All the way in the first lecture. That remember the human visual system is known to the detect
things like oriented edges. At the very early layers
of the human visual system. And it turns out of that
these convolutional networks tend to do something, somewhat similar. At their first convolutional
layers as well. And what's kind of interesting is that pretty much no matter what type
of architecture you hook up or whatever type of training
data you are train it on. You almost always get
the first layers of your. The first convolutional
weights of any pretty much any convolutional network
looking at images. Ends up looking something like this with oriented edges and opposing colors. Looking at that input image. But this really only, sorry
what was that question? Yes, these are showing the learned weights of the first convolutional layer. Oh, so that the question is. Why does visualizing the
weights of the filters? Tell you what the filter is looking for. So this intuition comes from
sort of template matching and inner products. That if you imagine you have
some, some template vector. And then you imagine you
compute a scaler output by taking inner product
between your template vector and some arbitrary piece of data. Then, the input which
maximizes that activation. Under a norm constraint on the input is exactly when those
two vectors match up. So, in that since that,
when, whenever you're taking inner products, the thing
causes an inner product to excite maximally is a copy of the thing you are
taking an inner product with. So, that, that's why we can
actually visualize these weights and that, why that shows us, what this first layer is looking for. So, for these networks
the first layers always was a convolutional layer. So, generally whenever
you are looking at image. Whenever you are thinking about image data and training convolutional networks, you generally put a convolutional layer at the first, at the first stop. Yeah, so the question is, can we do this same type of procedure in the middle open network. That's actually the next slide. So, good anticipation. So, if we do, if we draw this exact same visualization for the
intermediate convolutional layers. It's actually a lot less interpretable. So, this is, this is performing
exact same visualization. So, remember for this using
the tiny ConvNets demo network that's running on the course website whenever you go there. So, for that network, the first layer is 7 by
7 convulsion 16 filters. So, after the top visualizing
the first layer weights for this network just like
we saw in a previous slide. But now at the second layer weights. After we do a convulsion
then there's some relu and some other non-linearity perhaps. But the second convolutional layer, now receives the 16 channel input. And does 7 by 7 convulsion
with 20 convolutional filters. And we've actually, so the problem is that
you can't really visualize these directly as images. So, you can try, so, here if you this 16 by, so the input is
this has 16 dimensions in depth. And we have these convolutional filters, each convolutional filter is 7 by 7, and is extending along the full depth so has 16 elements. Then we've 20 such of these
convolutional filters, that are producing the output
planes of the next layer. But the problem here is that
we can't, looking at the, looking directly at the weights of these filters, doesn't
really tell us much. So, we, that's really done here is that, now for this single 16 by 7
by 7 convolutional filter. We can spread out those 167
by 7 planes of the filter into a 167 by 7 grayscale images. So, that's what we've done. Up here, which is these little
tiny gray scale images here show us what is, what are the weights in one of the convolutional
filters of the second layer. And now, because there are
20 outputs from this layer. Then this second convolutional
layer, has 2o such of these 16 by 16 or 16 by 7 by 7 filters. So if we visualize the weights of those convolutional filters as images, you can see that there are some kind of spacial structures here. But it doesn't really
give you good intuition for what they are looking at. Because these filters are not
looking, are not connected directly to the input image. Instead recall that the second
layer convolutional filters are connected to the
output of the first layer. So, this is giving visualization of, what type of activation
pattern after the first convulsion, would cause
the second layer convulsion to maximally activate. But, that's not very interpretable because we don't have a good sense for what those first layer
convulsions look like in terms of image pixels. So we'll need to develop some
slightly more fancy technique to get a sense for what is going on in the intermediate layers. Question in the back. Yeah. So the question is that for... all the visualization
on this on the previous slide. We've had the scale the weights
to the zero to 255 range. So in practice those
weights could be unbounded. They could have any range. But to get nice visualizations
we need to scale those. These visualizations also do not take in to account the bias is in these layers. So you should keep that in mind when and not take these
HEPS visualizations to, to literally. Now at the last layer remember when we looking at the last layer of convolutional network. We have these maybe 1000 class scores that are telling us what
are the predicted scores for each of the classes
in our training data set and immediately before the last layer we often have some fully connected layer. In the case of Alex net we have some 4096- dimensional
features representation of our image that then
gets fed into that final our final layer to predict
our final class scores. And one another, another kind of route for tackling the problem
of visual, visualizing and understanding ConvNets is to try to understand what's
happening at the last layer of a convolutional network. So what we can do is how to take some,
some data set of images run a bunch of, run a bunch of images through our trained convolutional network and recorded that 4096 dimensional vector for each of those images. And now go through and try to figure out and visualize that last
layer, that last hidden layer rather than those rather than
the first convolutional layer. So, one thing you might imagine is, is trying a nearest neighbor approach. So, remember, way back
in the second lecture we saw this graphic on the left where we, where we had a
nearest neighbor classifier. Where we were looking at
nearest neighbors in pixels space between CIFAR 10 images. And then when you look
at nearest neighbors in pixel space between CIFAR 10 images you see that you pull up images that looks quite similar
to the query image. So again on the left column
here is some CIFAR 10 image from the CIFAR 10 data set and then these, these next five columns are showing the nearest
neighbors in pixel space to those test set images. And so for example this white dog that you see here, it's nearest neighbors are in pixel space are these kinds of white blobby things that may, may or may not be dogs, but at least the raw pixels of the image are quite similar. So now we can do the same
type of visualization computing and visualizing
these nearest neighbor images. But rather than computing the nearest neighbors in pixel space, instead we can compute nearest neighbors in that 4096 dimensional feature space. Which is computed by the
convolutional network. So here on the right we see some examples. So this, this first column shows us some examples of images from the test set of image that... Of the image
net classification data set and now the, these
subsequent columns show us nearest neighbors to those test set images in the 4096, in the 4096th
dimensional features space computed by Alex net. And you can see here that
this is quite different from the pixel space nearest neighbors, because the pixels are
often quite different. between the image in
it's nearest neighbors and feature space. However, the semantic
content of those images tends to be similar in this feature space. So for example, if you
look at this second layer the query image is this elephant standing on the left side of the image with a screen grass behind him. and now one of these, one of these... it's third nearest
neighbor in the tough set is actually an elephant standing on the right side of the image. So this is really interesting. Because between this
elephant standing on the left and this element stand,
elephant standing on the right the pixels between those two images are almost entirely different. However, in the feature space which is learned by the network those two images and that
being very close to each other. Which means that somehow
this, this last their features is capturing some of those
semantic content of these images. That's really cool and really exciting and, and in general looking at these kind of nearest
neighbor visualizations is really quick and easy way to visualize something about what's going on here. Yes. So the question is that through the... the standard
supervised learning procedure for classific training,
classification network There's nothing in the loss encouraging these features
to be close together. So that, that's true. It just kind of a happy accident that they end up being
close to each other. Because we didn't tell the
network during training these features should be close. However there are sometimes
people do train networks using things called
either contrastive loss or a triplet loss. Which actually explicitly make... assumptions and constraints on the network such that those last their features end up having some metric
space interpretation. But Alex net at least was not
trained specifically for that. The question is, what is the nearest... What is this nearest neighbor thing have to do at the last layer? So we're taking this image we're running it through the network and then the, the second to last like the last hidden layer of the network is of 4096th dimensional vector. Because there's this, this is... This is there, there are
these fully connected layers at the end of the network. So we are doing is... We're writing down that
4096th dimensional vector for each of the images and then we are computing
nearest neighbors according to that 4096th
dimensional vector. Which is computed by,
computed by the network. Maybe, maybe we can chat offline. So another, another, another another angle that we might have for visualizing what's
going on in this last layer is by some concept of
dimensionality reduction. So those of you who have
taken CS229 for example you've seen something like PCA. Which let's you take some high
dimensional representation like these 4096th dimensional features and then compress it
down to two-dimensions. So then you can visualize that
feature space more directly. So, Principle Component Analysis or PCA is kind of one way to do that. But there's real another
really powerful algorithm called t-SNE. Standing for t-distributed
stochastic neighbor embeddings. Which is slightly more powerful method. Which is a non-linear
dimensionality reduction method that people in deep often
use for visualizing features. So here as an, just an
example of what t-SNE can do. This visualization here is, is showing a t-SNE dimensionality reduction
on the emnest data set. So, emnest remember is this date set of hand written digits
between zero and nine. Each image is a gray scale image 20... 28 by 28 gray scale image and now we're... So that Now we've, we've used t-SNE to take that 28 times 28
dimensional features space of the raw pixels for m-nest and now compress it
down to two- dimensions ans then visualize each
of those m-nest digits in this compress
two-dimensional representation and when you do, when you run t-SNE on the raw pixels and m-nest You can see these natural
clusters appearing. Which corresponds to the,
the digits of these m-nest of, of these m-nest data set. So now we can do a similar
type of visualization. Where we apply this t-SNE
dimensionality reduction technique to the features from the last layer of our trained image net classifier. So...To be a little bit more concrete here what we've done is that we take, a large set of images we run them off convolutional network. We record that final 4096th
dimensional feature vector for, from the last layer
of each of those images. Which gives us large collection of 4096th dimensional vectors. Now we apply t-SNE
dimensionality reduction to compute, sort of compress
that 4096the dimensional features space down into a
two-dimensional feature space and now we, layout a grid in that compressed two-dimensional feature space and visualize what types of images appear at each location in the grid in this two-dimensional feature space. So by doing this you get
some very close rough sense of what the geometry of this learned feature space looks like. So these images are
little bit hard to see. So I'd encourage you to check out the high resolution versions online. But at least maybe on
the left you can see that there's sort of one
cluster in the bottom here of, of green things, is a
different kind of flowers and there's other types of clusters for different types of dog breeds and another types of
animals and, and locations. So there's sort of
discontinuous semantic notion in this feature space. Which we can explore by looking through this t-SNE dimensionality reduction version of the, of the features. Is there question? Yeah. So the basic idea is that we're we, we have an image so now we end up with
three different pieces of information about each image. We have the pixels of the image. We have the 4096th dimensional vector. Then we use t-SNE to convert
the 4096th dimensional vector into a two-dimensional coordinate and then we take the
original pixels of the image and place that at the
two-dimensional coordinate corresponding to the
dimensionality reduced version of the 4096th dimensional feature. Yeah, little bit involved here. Question in the front. The question is Roughly how much variants do
these two-dimension explain? Well, I'm not sure of the exact number and I get little bit muddy when you're talking about t-SNE, because it's a non-linear dimensionality reduction technique. So, I'd have to look offline and I'm not sure of exactly
how much it explains. Question? Question is, can you do the same analysis of upper layers of the network? And yes, you can. But no, I don't have those
visualizations here. Sorry. Question? The question is,
Shouldn't we have overlaps of images once we do this
dimensionality reduction? And yes, of course, you would. So this is just kind of taking a, nearest neighbor in
our, in our regular grid and then picking an image
close to that grid point. So, so... they, yeah. this is not showing
you the kind of density in different parts of the feature space. So that's, that's another thing to look at and again at the link
you, there's a couple more visualizations of this nature that, that address that a little bit. Okay. So another, another thing that you can do for some of
these intermediate features is, so we talked a couple of slides ago that visualizing the weights
of these intermediate layers is not so interpretable. But actually visualizing
the activation maps of those intermediate layers is kind of interpretable in some cases. So for, so I, again an
example of Alex Net. Remember the, the conv5
layers of Alex Net. Gives us this 128 by... The for...The conv5 features for any image is now 128 by 13 by 13 dimensional tensor. But we can think of that as 128 different 13 by 132-D grids. So now we can actually go and visualize each of those 13 by 13 elements slices of the feature map as a grayscale image and this gives us some sense
for what types of things in the input are each of those features in that convolutional layer looking for. So this is a, a really
cool interactive tool by Jason Yasenski you can just download. So it's run, so I don't have the video, it has a video on his website. But it's running a convolutional network on the inputs stream of webcam and then visualizing in real time each of those slices of that
intermediate feature map give you a sense of what it's looking for and you can see that,
so here the input image is this, this picture up in, settings... of this picture of a person
in front of the camera and most of these intermediate features are kind of noisy, not much going on. But there's a, but there's
this one highlighted intermediate feature where that is also shown larger here that seems that it's activating on the portions of the feature map corresponding to the person's face. Which is really interesting and that kind of,
suggests that maybe this, this particular slice of the feature map of this layer of this particular network is maybe looking for human
faces or something like that. Which is kind of a nice, kind of a nice and cool finding. Question? The question is, Are the
black activations dead relu's? So you got to be... a little
careful with terminology. We usually say dead relu to mean something that's dead over
the entire training data set. Here I would say that it's a
relu, that, it's not active for this particular input. Question? The question is, If there's
no humans in image net how can it recognize a human face? There definitely are humans in image net I don't think it's, it's one of the cat... I don't think it's one of
the thousand categories for the classification challenge. But people definitely appear
in a lot of these images and that can be useful
signal for detecting other types of things. So that's actually kind of nice results because that shows that, it's
sort of can learn features that are useful for the
classification task at hand. That are even maybe a little bit different from the explicit classification task that we told it to perform. So it's actually really cool results. Okay, question? So at each layer in the
convolutional network our input image is of three,
it's like 3 by 224 by 224 and then it goes through
many stages of convolution. And then, it, after
each convolutional layer is some three dimensional
chunk of numbers. Which are the outputs from that layer of the convolutional network. And that into the entire three
dimensional chunk of numbers which are the output of the
previous convolutional layer, we call, we call, like
an activation volume and then one of those, one of those slices is a, it's an activation map. So the question is, If the image is K by K will the activation map be K by K? Not always because there
can be sub sampling due to pool, straight
convolution and pooling. But in general, the, the
size of each activation map will be linear in the
size of the input image. So another, another kind
of useful thing we can do for visualizing
intermediate features is... Visualizing what types of
patches from input images cause maximal activation in different, different features, different neurons. So what we've done here
is that, we pick... Maybe again the con five
layer from Alex Net? And remember each of
these activation volumes at the con, at the con
five in Alex net gives us a 128 by 13 by 13 chunk of numbers. Then we'll pick one of those 128 channels. Maybe channel 17 and now what we'll do is run many images through this convolutional network. And then, for each of those images record the con five features and then look at the... Right, so, then, then look at the, the... The parts of that 17th feature map that are maximally activated
over our data set of images. And now, because again this
is a convolutional layer each of those neurons in
the convolutional layer has some small receptive
field in the input. Each of those neurons is not
looking at the whole image. They're only looking at
the sub set of the image. Then what we'll do is,
is visualize the patches from the, from this
large data set of images corresponding to the maximal activations of that, of that feature,
of that particular feature in that particular layer. And then we can sorts these out, sort these patches by their activation at that, at that particular layer. So here is a, some examples from this... Network called a, fully... The network doesn't matter. But these are some visualizations of these kind of maximally
activating patches. So, each, each row gives... We've chosen one layer from or one neuron from one layer of a network and then each, and then,
the, they're sorted of these are the patches from
some large data set of images. That maximally activated this one neuron. And these can give you a sense
for what type of features these, these neurons might be looking for. So for example, this top row we see a lot of circly kinds
of things in the image. Some eyes, some, mostly eyes. But also this, kind of blue circly region. So then, maybe this,
this particular neuron in this particular layer of
this network is looking for kind of blue circly things in the input. Or maybe in the middle here we have neurons that are looking for text in different colors or, or maybe curving, curving edges of different colors and orientations. Yeah, so, I've been a little bit loose with terminology here. So, I'm saying that a
neuron is one scaler value in that con five activation map. But because it's convolutional, all the neurons in one channel are all using the same weights. So we've chosen one
channel and then, right? So, you get a lot of neurons
for each convolutional filter at any one layer. So, we, we could have been, so this patches could've
been drawn from anywhere in the image due to the
convolutional nature of the thing. And now at the bottom we also see some maximally activating patches for neurons from a higher up
layer in the same network. And now because they are coming
from higher in the network they have a larger receptive field. So, they're looking at larger
patches of the input image and we can also see
that they're looking for maybe larger structures
in the input image. So this, this second row is maybe looking, it seems to be looking for human, humans or maybe human faces. We have maybe something looking for... Parts of cameras or
different types of larger, larger, larger object like
type things, types of things. Another, another cool experiment we can do which comes from Zeiler
and Fergus ECCV 2014 paper. is this idea of an exclusion experiment. So, what we want to do is figure out which parts of the
input, of the input image cause the network to make
it's classification decision. So, what we'll do is,
we'll take our input image in this case an elephant and then we'll block
out some part of that, some region in that input image and just replace it with
the mean pixel value from the data set. And now, run that
occluded image throughout, through the network and then record what is the predicted probability
of this occluded image? And now slide this occluded
patch over every position in the input image and then
repeat the same process. And then draw this heat map showing, what was the predicted probability
output from the network as a function of where did, which part of the input
image did we occlude? And the idea is that if when we block out
some part of the image if that causes the network
score to change drastically. Then probably that part of the input image was really important for
the classification decision. So here we've shown... I've shown three different examples of... Of this occlusion type experiment. So, maybe this example of
a Go-kart at the bottom, you can see over here that when we, so here, red, the, the red corresponds
to a low probability and the white and yellow
corresponds to a high probability. So when we block out
the region of the image corresponding to this Go-kart in front. Then the predicted probability for the Go-kart class drops a lot. So that gives us some sense that the network is actually
caring a lot about these, these pixels in the input image in order to make it's
classification decision. Question? Yes, the question is that, what's going on in the background? So maybe if the image is a
little bit too small to tell but, there's, this is
actually a Go-kart track and there's a couple other
Go-karts in the background. So I think that, when
you're blocking out these other Go-karts in the background, that's also influencing the score or maybe like the horizon is there and maybe the horizon is an useful feature for detecting Go-karts, it's a little bit hard to tell sometimes. But this is a pretty cool visualization. Yeah, was there another question? So the question is, sorry, sorry, what was the first question? So, the, so the question... So for, for this example
we're taking one image and then masking all parts of one image. The second question
was, how is this useful? It's not, maybe, you don't
really take this information and then loop it directly
into the training process. Instead, this is a way, a tool for humans to understand, what types of computations these train networks are doing. So it's more for your understanding than for improving performance per se. So another, another related idea is this concept of a Saliency Map. Which is something that you
will see in your homeworks. So again, we have the same question of given an input image
of a dog in this case and the predicted class label of dog we want to know which
pixels in the input image are important for classification. We saw masking, is one way
to get at this question. But Saliency Maps are another, another, angle for attacking this problem. And the question is, and
one relatively simple idea from Karen Simonenian's
paper, a couple years ago. Is, this is just computing the gradient of the predicted class score with respect to the
pixels of the input image. And this will directly tell us in this sort of, first
order approximation sense. For each input, for each
pixel in the input image if we wiggle that pixel a little bit then how much will the
classification score for the class change? And this is another way
to get at this question of which pixels in the input
matter for the classification. And when we, and when we run for example Saliency,
where computer Saliency map for this dog, we see kind of a nice outline of a dog in the image. Which tells us that these
are probably the pixels of that, network is actually
looking at, for this image. And when we repeat this type of process for different images, we get some sense that the network is sort of
looking at the right regions. Which is somewhat comforting. Question? The question is, do
people use Saliency Maps for semantic segmentation?
The answer is yes. That actually was... Yeah, you guys are like really
on top of it this lecture. So that was another component,
again in Karen's paper. Where there's this idea
that maybe you can use these Saliency Maps to perform
semantic segmentation without direct, without any labeled data for the, for these, for these segments. So here they're using this
Grabcut Segmentation Algorithm which I don't really want
to get into the details of. But it's kind of an interactive
segmentation algorithm that you can use. So then when you combine this Saliency Map with this Grabcut Segmentation Algorithm then you can in fact,
sometimes segment out the object in the image. Which is really cool. However I'd like to point out that this is a little bit brittle and in general if you,
this will probably work much, much, much, worse than a network which did have access to
supervision and training time. So, I don't, I'm not sure
how, how practical this is. But it is pretty cool
that it works at all. But it probably works much
less than something trained explicitly to segment with supervision. So kind of another, another related idea is this idea of, of
guided back propagation. So again, we still want
to answer the question of for one particular, for
one particular image. Then now instead of
looking at the class score we want to know, we want to
pick some intermediate neuron in the network and ask again, which parts of the input image influence the score of that neuron, that internal neuron in the network. And, and then you could
imagine, again you could imagine computing a Saliency Map
for this again, right? That rather than computing the
gradient of the class scores with respect to the pixels of the image. You could compute the gradient
of some intermediate value in the network with respect
to the pixels of the image. And that would tell us again which parts, which
pixels in the input image influence that value of
that particular neuron. And that would be using
normal back propagation. But it turns out that
there is a slight tweak that we can do to this
back propagation procedure that ends up giving some
slightly cleaner images. So that's this idea of
guided back propagation that again comes from Zeiler
and Fergus's 2014 paper. And I don't really want to get
into the details too much here but, it, you just, it's
kind of weird tweak where you change the way
that you back propagate through relu non-linearities. And you sort of, only, only back propagate positive gradients through relu's and you do not back propagate negative gradients through the relu's. So you're no longer
computing the true gradient instead you're kind of only keeping track of positive influences on throughout the entire network. So maybe you should read
through these, these papers reference to your, if you
want a little bit more details about why that's a good idea. But empirically, when you
do guided back propagation as appose to regular back propagation. You tend to get much
cleaner, nicer images. that tells you, which part,
which pixel of the input image influence that particular neuron. So, again we were seeing
the same visualization we saw a few slides ago of the
maximally activating patches. But now, in addition to visualizing these maximally activating patches. We've also performed
guided back propagation, to tell us exactly which parts
of these patches influence the score of that neuron. So, remember for this example at the top, we saw that, we thought this neuron is may be looking for circly tight things, in the input patch because there're allot
of circly tight patches. Well, when we look at
guided back propagation We can see with that intuition
is somewhat confirmed because it is indeed the circly
parts of that input patch which are influencing
that, that neuron value. So, this is kind of a useful
to all for synthesizing. For understanding what these
different intermediates are looking for. But, one kind of interesting thing about guided back propagation or computing saliency maps. Is that there's always a
function of fixed input image, right, they're telling us
for a fixed input image, which pixel or which parts
of that input image influence the value of the neuron. Another question you might answer is is remove this reliance, on
that, on some input image. And then instead just ask
what type of input in general would cause this neuron to activate and we can answer this question using a technical Gradient ascent so, remember we always use Gradient decent to train our convolutional
networks by minimizing the loss. Instead now, we want to fix the, fix the weight of our trained
convolutional network and instead synthesizing image
by performing Gradient ascent on the pixels of the
image to try and maximize the score of some intermediate
neuron or of some class. So, in a process of Gradient ascent, we're no longer optimizing
over the weights of the network those weights remained fixed instead we're trying to change
pixels of some input image to cause this neuron,
or this neuron value, or this class score to
maximally, to be maximized but, instead but, in addition we need some regularization term so, remember we always a, we before seeing regularization terms to try to prevent the network weights from over fitting to the training data. Now, we need something kind of similar to prevent the pixels
of our generated image from over fitting to the peculiarities of that particular network. So, here we'll often incorporate
some regularization term that, we're kind of, we
want a generated image of two properties one, we wanted to maximally activate some, some score or some neuron value. But, we also wanted to
look like a natural image. we wanted to kind of have, the kind of statistics that we typically see in natural images. So, these regularization
term in the subjective is something to enforce a generated image to look relatively natural. And we'll see a couple
of different examples of regualizers as we go through. But, the general strategy for this is actually pretty simple and again informant allot
of things of this nature on your assignment three. But, what we'll do is start
with some initial image either initializing to zeros
or to uniform or noise. But, initialize your image in some way and I'll repeat where
you forward your image through 3D network and compute the score or, or neuron value
that you're interested. Now, back propagate to
compute the Gradient of that neuron score with respect
to the pixels of the image and then make a small Gradient ascent or Gradient ascent update to the pixels of the images itself. To try and maximize that score. And I'll repeat this
process over and over again, until you have a beautiful image. And, then we talked, we talked
about the image regularizer, well a very simple, a very
simple idea for image regularizer is simply to penalize L2
norm of a generated image This is not so semantically meaningful, it's just does something,
and this was one of the, one of the earliest
regularizer that we've seen in the literature for these
type of generating images type of papers. And, when you run this
on a trained network you can see that now we're
trying to generate images that maximize the dumble score in the upper left hand
corner here for example. And, then you can see that
the synthesized image, it been, it's little
bit hard to see may be but there're allot of
different dumble like shapes, all kind of super impose that different portions of the image. or if we try to generate an image for cups then we can may be see a
bunch of different cups all kind of super imposed the Dalmatian is pretty cool, because now we can see kind of this black and white spotted pattern that's kind of
characteristics of Dalmatians or for lemons we can see
these different kinds of yellow splotches in the image. And there's a couple
of more examples here, I think may be the goose is kind of cool or the kitfox are actually
may be looks like kitfox. Question? The question is, why are
these all rainbow colored and in general getting true colors out of this visualization is pretty tricky. Right, because any, any actual image will be bounded in the range zero to 255. So, it really should be some kind of constrained optimization problem But, if, for using this generic
methods for Gradient ascent then we, that's going to
be unconstrained problem. So, you may be use like projector
Gradient ascent algorithm or your rescaled image at the end. So, the colors that you
see in this visualizations, sometimes are you cannot
take them too seriously. Question? The question is what happens, if you let the thing loose and don't
put any regularizer on it. Well, then you tend to get
an image which maximize the score which is confidently classified as the class you wanted but, usually it doesn't
look like anything. It kind of look likes random noise. So, that's kind of an
interesting property in itself that will go into much more
detail in a future lecture. But, that's why, that
kind of doesn't help you so much for understanding what things the network is looking for. So, if we want to understand, why the network thing makes its decisions then it's kind of useful
to put regularizer on there to generate an
image to look more natural. A question in the back. Yeah, so the question
is that we see a lot of multi modality here, and
other ways to combat that. And actually yes, we'll see that, this is kind of first
step in the whole line of work in improving these visualizations. So, another, another kind
of, so then the angle here is a kind of to improve the regularizer to improve our visualized images. And there's a another
paper from Jason Yesenski and some of his collaborators where they added some additional
impressive regularizers. So, in addition to this
L2 norm constraint, in addition we also periodically
during optimization, and do some gauche and
blurring on the image, we're also clip some,. some small value, some small pixel values all the way to zero, we're
also clip some of the, some of the pixel values
of low Gradients to zero So, you can see this is kind of a projector Gradient ascent algorithm where it reach periodically
we're projecting our generated image onto some nicer set of images with some nicer properties. For example, special smoothness with respect to the gauchian blurring So, when you do this, you
tend to get much nicer images that are much clear to see. So, now these flamingos
look like flamingos the ground beetle is starting
to look more beetle like or this black swan maybe
looks like a black swan. These billiard tables actually
look kind of impressive now, where you can definitely see
this billiard table structure. So, you can see that once you
add in nicer regularizers, then the generated images become a bit, a little bit cleaner. And, now we can perform this procedure not only for the final class course, but also for these
intermediate neurons as well. So, instead of trying to
maximize our billiard table score for example instead we
can get maximize one of the neurons from
some intermediate layer Question. So, the question is what's
with the for example here, so those who remember
initializing our image randomly so, these four images would be different random
initialization of the input image. And again, we can use these
same type of procedure to visualize, to synthesis images which maximally activate
intermediate neurons of the network. And, then you can get a sense from some of these intermediate
neurons are looking for, so may be at layer four there's neuron that's kind of looking for spirally things or there's neuron that's may be looking for like chunks of caterpillars it's a little bit harder to tell. But, in generally as you
go larger up in the image then you can see that
the one, the obviously receptive fields of
these neurons are larger. So, you're looking at the
larger patches in the image. And they tend to be looking
for may be larger structures or more complex patterns
in the input image. That's pretty cool. And, then people have
really gone crazy with this and trying to, they basically
improve these visualization by keeping on extra features So, this was a cool paper kind of explicitly trying to address this multi modality, there's
someone asked question about a few minutes ago. So, here they were
trying to explicitly take a count, take this multi
modality into account in the optimization procedure where they did indeed,
I think see the initial, so they for each of the classes, you run a clustering algorithm to try to separate the
classes into different modes and then initialize with something that is close to one of those modes. And, then when you do that, you kind of account for
this multi modality. so for intuition, on the
right here these eight images are all of grocery stores. But, the top row, is
kind of close up pictures of produce on the shelf and those are labeled as grocery stores And the bottom row kind of shows people walking around grocery stores or at the checkout line
or something like that. And, those are also labeled
those as grocery store, but their visual appearance
is quiet different. So, a lot of these classes
and that being sort multi modal And, if you can take, and
if you explicitly take this more time mortality into account when generating images, then
you can get nicer results. And now, then when you look at some of their example, synthesis
images for classes, you can see like the
bell pepper, the card on, strawberries, jackolantern now they end up with some very beautifully
generated images. And now, I don't want to get to much into detail of the next slide. But, then you can even go crazier. and add an even stronger image prior and generate some very
beautiful images indeed So, these are all synthesized
images that are trying to maximize the class score
or some image in a class. But, the general idea is that rather than optimizing directly the pixels of the input image, instead they're trying to optimize the FC6 representation
of that image instead. And now they need to use some
feature inversion network and I don't want to get
into the details here. You should read the paper,
it's actually really cool But, the point is that, when you start adding additional priors towards modeling natural images and you can end generating
some quiet realistic images they gave you some sense of
what the network is looking for So, that's, that's sort of one cool thing that we can do with this
strategy, but this idea of trying to synthesis
images by using Gradients on image pixels, is
actually super powerful. And, another really cool
thing we can do with this, is this concept of fooling image So, what we can do is
pick some arbitrary image, and then try to maximize the,
so, say we take it picture of an elephant and then
we tell the network that we want to, change the image to maximize the score
of Koala bear instead So, then what we were
doing is trying to change that image of an elephant
to try and instead cause the network to classify as a Koala bear. And, what you might hope for is that, maybe that elephant was
sort of thought more thing into a Koala bear and
maybe he would sprout little cute ears or something like that. But, that's not what happens in practice, which is pretty surprising. Instead if you take this
picture of a elephant and tell them that, tell them that and try to change the
elephant image to instead cause it to be classified as a koala bear What you'll find is that, you is that this second image on the right actually is classified as koala bear but it looks the same to us. So that's pretty fishy
and pretty surprising. So also on the bottom we've
taken this picture of a boat. Schooner is the image in that class and then we told the network
to classified as an iPod. So now the second example looks just, still looks like a boat to us but the network thinks it's an iPod and the difference is in
pixels between these two images are basically nothing. And if you magnify those differences you don't really see any
iPod or Koala like features on these differences, they're just kind of like
random patterns of noise. So the question is what's going here? And like how can this possibly the case? Well, we'll have a guest
lecture from Ian Goodfellow in a week an half two weeks. And he's going to go in much more detail about this type of phenomenon and that will be really exciting. But I did want to mention it here because it is on your homework. Question? Yeah, so that's something, so the question is can we use
fooled images as training data and I think, Ian's going
to go in much more detail on all of these types of strategies. Because that's literally, that's really a whole lecture onto itself. Question? The question is why do we
care about any of this stuff? Basically... Okay, maybe that was a
mischaracterization, I am sorry. Yeah, the question is
what is have in the... understanding this intermediate neurons how does that help our understanding of the final classification. So this is actually, this
whole field of trying to visualize intermediates
is kind of in response to a common criticism of deep learning. So a common criticism of
deep learning is like, you've got this big black box network you trained it on gradient
ascent, you get a good number and that's great but we
don't trust the network because we don't understand as people why it's making the
decisions, that's it's making. So a lot of these type of
visualization techniques were developed to try and address that and try to understand as people why the network are making
their various classification, classification decisions a bit more. Because if you contrast, if you contrast a deep
convolutional neural network with other machine running techniques. Like linear models are much
easier to interpret in general because you can look at
the weights and kind of understand the interpretation
between how much each input feature effect the decision or
if you look at something like a random forest or decision tree. Some other machine learning models end up being a bit more interpretable just by their very nature
then this sort of black box convolutional networks. So a lot of this is sort of
in response to that criticism to say that, yes they are
these large complex models but they are still doing some
interesting and interpretable things under the hood. They are not just totally going out in randomly classifying things. They are doing something meaningful So another cool thing we can do with this gradient based optimization of images is this idea of DeepDream. So this was a really cool blog post that came out from
Google a year or two ago. And the idea is that, this is, so we talked
about scientific value, this is almost entirely for fun. So the point of this exercise is mostly to generate cool images. And aside, you also get
some sense for what features images are looking at. Or these networks are looking at. So we can do is, we take our input image we run it through the convolutional
network up to some layer and now we back propagate and set the gradient
of that, at that layer equal to the activation value. And now back propagate, back to the image and update the image and
repeat, repeat, repeat. So this has the interpretation
of trying to amplify existing features that were
detected by the network in this image. Right? Because whatever features
existed on that layer now we set the gradient
equal to the feature and we just tell the network to amplify whatever features you
already saw in that image. And by the way you can also
see this as trying to maximize the L2 norm of the features
at that layer of the image. And it turns... And when you do this the code ends up looking really simple. So your code for many of
your homework assignments will probably be about this complex or maybe even a little bit a less so. So the idea is that... But there's a couple of tricks here that you'll also see in your assignments. So one trick is to jitter the image before you compute your gradients. So rather than running the
exact image through the network instead you'll shift the
image over by two pixels and kind of wrap the other
two pixels over here. And this is a kind of regularizer to prevent each of these [mumbling] it regularizers a little bit to encourage a little bit of extra special
smoothness in the image. You also see they use L1
normalization of the gradients that's kind of a useful trick sometimes when doing this image generation problems. You also see them clipping the
pixel values once in a while. So again we talked about
images actually should be between zero to 2.55 so this is a kind of
projected gradients decent where we project on to the
space of actual valid images. But now when we do all this then we start, we might start
with some image of a sky and then we get really
cool results like this. So you can see that now we've taken these tiny features on the sky and they get amplified through
this, through this process. And we can see things like this different mutant animals start to pop up or these kind of spiral shapes pop up. Different kinds of houses and cars pop up. So that's all, that's
all pretty interesting. There's a couple patterns in particular that pop up all the time
that people have named. Right, so there's this Admiral
dog, that shows up allot. There's the pig snail, the camel bird this the dog fish. Right, so these are
kind of interesting, but actually this fact that
dog show up so much in these visualization,
actually does tell us something about the data on
which this network was trained. Right, because this is a
network that was trained for image net classification, image that have thousand categories. But 200 of those categories are dogs. So, so it's kind of not
surprising in a sense that when you do these
kind of visualizations then network ends up hallucinating
a lot of dog like stuff in the image often morphed
with other types of animals. When you do this other
layers of the network you get other types of results. So here we're taking one
of these lower layers in the network, the previous
example was relatively high up in the network and now again we have this
interpretation that lower layers maybe computing edges and
swirls and stuff like that and that's kind of borne out
when we running DeepDream at a lower layer. Or if you run this thing for a long time and maybe add in some
multiscale processing you can get some really,
really crazy images. Right, so here they're doing a
kind of multiscale processing where they start with a small image run DeepDream on the small
image then make it bigger and continue DeepDream on the larger image and kind of repeat with
this multiscale processing and then you can get, and then maybe after you
complete the final scale then you restart from the beginning and you just go wild on this thing. And you can get some really crazy images. So these examples were all from networks trained on image net There's another data set from
MIT called MIT Places Data set but instead of 1,000 categories of objects instead it's 200 different types of scenes like bedrooms and kitchens
like stuff like that. And now if we repeat
this DeepDream procedure using an network trained at MIT places. We get some really cool
visualization as well. So now instead of dogs,
slugs and admiral dogs and that's kind of stuff,
instead we often get these kind of roof shapes of these
kind of Japanese style building or these different types of
bridges or mountain ranges. They're like really, really
cool beautiful visualizations. So the code for DeepDream is
online, released by Google you can go check it out and
make your own beautiful pictures So there's another kind of... Sorry question? So the question is, what
are taking gradient of? So like I say, if you, because
like one over x squared on the gradient of that is x. So, if you send back
the volume of activation as the gradient, that's equivalent to max, that's equivalent to taking the
gradient with respect to the like one over x squared some... Some of the values. So it's equivalent to maximizing the norm of that of the features of that layer. But in practice many implementation you'll see not explicitly compute that instead of send gradient back. So another kind of useful,
another kind of useful thing we can do is this concept
of feature inversion. So this again gives us a
sense for what types of, what types of elements
of the image are captured at different layers of the network. So what we're going to
do now is we're going to take an image, run that
image through network record the feature value
for one of those images and now we're going to try
to reconstruct that image from its feature representation. And the question, and now based on the how much, how much like what that reconstructed image looks like that'll give us some sense
for what type of information about the image was captured
in that feature vector. So again, we can do this
with gradient ascent with some regularizer. Where now rather than
maximizing some score instead we want to minimize the distance between this catch feature vector. And between the computed
features of our generated image. To try and again synthesize
a new image that matches the feature back to
that we computed before. And another kind of regularizer
that you frequently see here is the total variation regularizer that you also see on your homework. So here with the total
variation regularizer is panelizing differences
between adjacent pixels on both of the left and
adjacent in left and right and adjacent top to bottom. To again try to encourage
special smoothness in the generated image. So now if we do this
idea of feature inversion so this visualization here on the left we're showing some original image. The elephants or the fruits at the left. And then we run that, we run the image through a VGG-16 network. Record the features of
that network at some layer and then try to synthesize
a new image that matches the recorded features of that layer. And this is, this kind of
give us a sense for what how much information is
stored in this images. In these features of different layers. So for example if we try
to reconstruct the image based on the relu2_2 features
from VGC's, from VGG-16. We see that the image gets
almost perfectly reconstructed. Which means that we're
not really throwing away much information about the raw
pixel values at that layer. But as we move up into the
deeper parts of the network and try to reconstruct
from relu4_3, relu5_1. We see that our reconstructed image now, we've kind of kept the general space, the general spatial
structure of the image. You can still tell that, that
it's a elephant or a banana or a, or an apple. But a lot of the low level details aren't exactly what the pixel values were and exactly what the colors were, exactly what the textures were. These are kind of low level details are kind of lost at these higher
layers of this network. So that gives us some sense that maybe as we move up through
the flairs of the network it's kind of throwing away
this low level information about the exact pixels of the image and instead is maybe trying
to keep around a little bit more semantic information,
it's a little bit invariant for small changes in color and
texture and things like that. So we're building towards
a style transfer here which is really cool. So in addition to
understand style transfer, in addition to feature inversion. We also need to talk
about a related problem called texture synthesis. So in texture synthesis, this
is kind of an old problem in computer graphics. Here the idea is that
we're given some input patch of texture. Something like these little scales here and now we want to build some model and then generate a larger
piece of that same texture. So for example, we might here
want to generate a large image containing many scales that
kind of look like input. And this is again a pretty old
problem in computer graphics. There are nearest neighbor
approaches to textual synthesis that work pretty well. So, there's no neural networks here. Instead, this kind of a simple algorithm where we march through the generated image one pixel at a time in scan line order. And then copy... And then look at a neighborhood
around the current pixel based on the pixels that
we've already generated and now compute a nearest
neighbor of that neighborhood in the patches of the input image and then copy over one
pixel from the input image. So, maybe you don't need to
understand the details here just the idea is that there's
a lot classical algorithms for texture synthesis,
it's a pretty old problem but you can do this without
neural networks basically. And when you run this kind of this kind of classical
texture synthesis algorithm it actually works reasonably
well for simple textures. But as we move to more complex textures these kinds of simple methods
of maybe copying pixels from the input patch directly tend not to work so well. So, in 2015, there was a really cool paper that tried to apply
neural network features to this problem of texture synthesis. And ended up framing it as kind of a gradient ascent procedure, kind of similar to the feature map, the various feature matching objectives that we've seen already. So, in order to perform
neural texture synthesis they use this concept of a gram matrix. So, what we're going to do, is we're going to take our input texture and in this case some pictures of rocks and then take that input texture and pass it through some
convolutional neural network and pull out convolutional features at some layer of the network. So, maybe then this
convolutional feature volume that we've talked about,
might be H by W by C or sorry, C by H by W at
that layer of the network. So, you can think of this
as an H by W spacial grid. And at each point of the grid, we have this C dimensional feature vector describing the rough
appearance of that image at that point. And now, we're going to
use this activation map to compute a descriptor of the
texture of this input image. So, what we're going to do is take, pick out two of these
different feature columns in the input volume. Each of these feature columns will be a C dimensional vector. And now take the outer product
between those two vectors to give us a C by C matrix. This C by C matrix now tells us something about the co-occurrence of the different features at
those two points in the image. Right, so, if an element,
if like element IJ in the C by C matrix is large that means both elements I and
J of those two input vectors were large and something like that. So, this somehow captures
some second order statistics about which features, in that feature map tend to activate to together
at different spacial volumes... At different spacial positions. And now we're going to
repeat this procedure using all different
pairs of feature vectors from all different points
in this H by W grid. Average them all out, and that gives us our C by C gram matrix. And this is then used a
descriptor to describe kind of the texture of that input image. So, what's interesting
about this gram matrix is that it has now thrown
away all spacial information that was in this feature volume. Because we've averaged over
all pairs of feature vectors at every point in the image. Instead, it's just
capturing the second order co-occurrence statistics between features. And this ends up being a
nice descriptor for texture. And by the way, this is
really efficient to compute. So, if you have a C by H by
W three dimensional tensure you can just reshape
it to see times H by W and take that times its own transpose and compute this all in one shot so it's super efficient. But you might be wondering why you don't use an actual covariance matrix or something like that instead
of this funny gram matrix and the answer is that using covariance... Using true covariance matrices also works but it's a little bit
more expensive to compute. So, in practice a lot of people just use this gram matrix descriptor. So then... Then there's this... Now once we have this sort of
neural descriptor of texture then we use a similar type
of gradient ascent procedure to synthesize a new image
that matches the texture of the original image. So, now this looks kind of
like the feature reconstruction that we saw a few slides ago. But instead, I'm trying to
reconstruct the whole feature map from the input image. Instead, we're just going
to try and reconstruct this gram matrix texture descriptor of the input image instead. So, in practice what this
looks like is that well... You'll download some pretrained model, like in feature inversion. Often, people will use
the VGG networks for this. You'll feed your... You'll
take your texture image, feed it through the VGG network, compute the gram matrix
and many different layers of this network. Then you'll initialize your new image from some random initialization and then it looks like
gradient ascent again. Just like for these other
methods that we've seen. So, you take that image, pass it through the same VGG network, Compute the gram matrix at various layers and now compute loss as the L2 norm between the gram matrices of your input texture
and your generated image. And then you back prop,
and compute pixel... A gradient of the pixels
on your generated image. And then make a gradient ascent step to update the pixels of
the image a little bit. And now, repeat this process many times, go forward, compute your gram matrices, compute your losses, back prop.. Gradient on the image and repeat. And once you do this, eventually
you'll end up generating a texture that matches your
input texture quite nicely. So, this was all from Nip's 2015 paper by a group in Germany. And they had some really cool
results for texture synthesis. So, here on the top, we're showing four
different input textures. And now, on the bottom, we're showing doing this texture synthesis approach by gram matrix matching. Using, by computing the gram
matrix at different layers at this pretrained convolutional network. So, you can see that, if we
use these very low layers in the convolutional network then we kind of match the general... We generally get splotches
of the right colors but the overall spacial structure doesn't get preserved so much. And now, as we move to large
down further in the image and you compute these gram
matrices at higher layers you see that they tend to
reconstruct larger patterns from the input image. For example, these whole rocks
or these whole cranberries. And now, this works pretty well that now we can synthesize
these new images that kind of match the
general spacial statistics of your inputs. But they are quite different pixel wise from the actual input itself. Question? So, the question is, where
do we compute the loss? And in practice, we
want to get good results typically people will
compute gram matrices at many different layers and then the final loss
will be a sum of all those potentially a weighted sum. But I think for this visualization, to try to pin point the
effect of the different layers I think these were doing reconstruction from just one layer. So, now something really... Then, then they had a
really brilliant idea kind of after this paper which is, what if we do this
texture synthesis approach but instead of using an image
like rocks or cranberries what if we set it equal
to a piece of artwork. So then, for example, if you... If you do the same texture
synthesis algorithm by maximizing gram
matrices, but instead of... But now we take, for example, Vincent Van Gogh's Starry night or the Muse by Picasso as our texture... As our input texture,
and then run this same texture synthesis algorithm. Then we can see our generated images tend to reconstruct interesting pieces from those pieces of artwork. And now, something really
interesting happens when you combine this
idea of texture synthesis by gram matrix matching with feature inversion
by feature matching. And then this brings us to
this really cool algorithm called style transfer. So, in style transfer, we're
going to take two images as input. One, we're going to take a content image that will guide like what
type of thing we want. What we generally want
our output to look like. Also, a style image that will tell us what is the general texture or style that we want our generated image to have and then we will jointly
do feature recon... We will generate a new image by minimizing the feature
reconstruction loss of the content image and the gram matrix
loss of the style image. And when we do these two things we a get a really cool image that kind of renders the content image
kind of in the artistic style of the style image. And now this is really cool. And you can get these
really beautiful figures. So again, what this kind of looks like is that you'll take your style
image and your content image pass them into your network
to compute your gram matrices and your features. Now, you'll initialize your output image with some random noise. Go forward, compute your losses go backward, compute your
gradients on the image and repeat this process over and over doing gradient ascent on the
pixels of your generated image. And after a few hundred iterations, generally you'll get a beautiful image. So, I have implementation of this online on my Gethub, that a
lot of people are using. And it's really cool. So, you can, this is kind of... Gives you a lot more control over the generated image
as compared to DeepDream. Right, so in DeepDream, you
don't have a lot of control about exactly what types of
things are going to happen coming out at the end. You just kind of pick different
layers of the networks maybe set different numbers of iterations and then dog slugs pop up everywhere. But with style transfer, you get a lot more fine grain control over what you want the
result to look like. Right, by now, picking
different style images with the same content image you can generate whole
different types of results which is really cool. Also, you can play around with
the hyper parameters here. Right, because we're doing
a joint reconstruct... We're minimizing this
feature reconstruction loss of the content image. And this gram matrix reconstruction
loss of the style image. If you trade off the constant, the waiting between those
two terms and the loss. Then you can get control
about how much we want to match the content versus how much we want to match the style. There's a lot of other hyper
parameters you can play with. For example, if you resize the style image before you compute the gram matrix that can give you some control over what the scale of features are that you want to reconstruct from the style image. So, you can see that here, we've done this same reconstruction the only difference is how
big was the style image before we computed the gram matrix. And this gives you another axis over which you can control these things. You can also actually do style transfer with multiple style images if you just match sort
of multiple gram matrices at the same time. And that's kind of a cool result. We also saw this multi-scale process... So, another cool thing you can do. We talked about this multi-scale
processing for DeepDream and saw how multi scale
processing in DeepDream can give you some really
cool resolution results. And you can do a similar type
of multi-scale processing in style transfer as well. So, then we can compute images like this. That a super high resolution,
this is I think a 4k image of our favorite school, like rendered in the
style of Starry night. But this is actually super
expensive to compute. I think this one took four GPU's. So, a little expensive. We can also other style,
other style images. And get some really cool results from the same content image. Again, at high resolution. Another fun thing you can do is you know, you can actually
do joint style transfer and DeepDream at the same time. So, now we'll have three
losses, the content loss the style loss and this... And this DeepDream loss that
tries to maximize the norm. And get something like this. So, now it's Van Gogh with the dog slug's coming out everywhere. [laughing] So, that's really cool. But there's kind of a problem with this style transfer for algorithms which is that they are pretty slow. Right, you need to produce... You need to compute a lot of
forward and backward passes through your pretrained network in order to complete these images. And especially for these high
resolution results that we saw in the previous slide. Each forward and backward
pass of a 4k image is going to take a lot of
compute and a lot of memory. And if you need to do several
hundred of those iterations generating these images could take many, like tons of minutes even on a powerful GPU. So, it's really not so
practical to apply these things in practice. The solution is to now,
train another neural network to do the style transfer for us. So, I had a paper about this last year and the idea is that we're
going to fix some style that we care about at the beginning. In this case, Starry night. And now rather than running a separate optimization procedure for each image that we want to synthesize instead we're going to train
a single feed forward network that can input the content image and then directly output
the stylized result. And now the way that we train this network is that we compute the same content and style losses during training
of our feed forward network and use that same gradient
to update the weights of the feed forward network. And now this thing takes
maybe a few hours to train but once it's trained, then in order to produce stylized images you just need to do a single forward pass through the trained network. So, I have a code for this online and you can see that it
ends up looking about... Relatively comparable
quality in some cases to this very slow optimization base method but now it runs in real time it's about a thousand times faster. So, here you can see, this is
like a demo of it running live off my webcam. So, this is not running
live right now obviously, but if you have a big GPU you can easily run four different styles in real time all simultaneously because it's so efficient. There was... There was
another group from Russia that had a very similar out... That had a very similar paper concurrently and their results are about as good. They also had this kind
of tweek on the algorithm. So, this feed forward
network that we're training ends up looking a lot like these... These segmentation models that we saw. So, these segmentation networks, for semantic segmentation
we're doing down sampling and then many, and then many layers then some up sampling [mumbling] With transposed convulsion in order to down sample an up sample
to be more efficient. The only difference is
that this final layer produces a three channel output for the RGB of that final image. And inside this network,
we have batch normalization in the various layers. But in this paper, they introduce... They swap out the batch normalization for something else called
instance normalization tends to give you much better results. So, one drawback of these
types of methods is that we're now training one new
style transfer network... For every... For style
that we want to apply. So that could be expensive if now you need to keep a lot of different trained networks around. So, there was a paper from
Google that just came... Pretty recently that addressed this by using one feed forward trained network to apply many different
styles to the input image. So now, they can train one network to apply many different
styles at test time using one trained network. So, here's it's going to
take the content images input as well as the identity of
the style you want to apply and then this is using one network to apply many different types of styles. And again, runs in real time. That same algorithm can also
do this kind of style blending in real time with one trained network. So now, once you trained this network on these four different styles you can actually specify
a blend of these styles to be applied at test
time which is really cool. So, these kinds of real
time style transfer methods are on various apps and
you can see these out in practice a lot now these days. So, kind of the summary
of what we've seen today is that we've talked about
many different methods for understanding CNN representations. We've talked about some of
these activation based methods like nearest neighbor,
dimensionality reduction, maximal patches, occlusion images to try to understand based
on the activation values of what the features are looking for. We also talked about a bunch
of gradient based methods where you can use gradients
to synthesize new images to understand your features
such as saliency maps class visualizations, fooling images, feature inversion. And we also had fun by seeing how a lot of these similar ideas can be applied to things like
Style Transfer and DeepDream to generate really cool images. So, next time, we'll talk
about unsupervised learning Autoencoders, Variational Autoencoders and generative adversarial networks so that should be a fun lecture.
