On object detection, segmentation, and model interpretation

This is part #10 of my notes on CS231n. The course is openly available, including the video lectures and assignments.

These notes are based on lecture 9: Detection, Segmentation, Visualization, and Understanding by Ehsan Adeli. I also cover feature inversion, adversarial examples, and style transfer from the course schedule, with their original papers linked below.

So far, we have used CNNs to predict one class for an image. Let's put two people and a bicycle in that image. Predicting “person” tells us something, but we still don't know where either person is, or that there is a bicycle.

We can ask for more structure in the output:

We can keep the feature extractor. What we need to change is the output and the loss that trains it.

Semantic segmentation: classify every pixel

Let's start with an image of shape $H\times W\times3$. For $C$ possible classes, we want a score tensor of shape $H\times W\times C$.

One idea is to classify a crop around every pixel. A crop gives us context: a grey pixel alone could be a road, a wall, or a bicycle. But adjacent crops contain almost the same pixels, so we repeat a lot of work.

Instead, run the convolutions once over the image and keep the spatial feature map. Apply a $1\times1$ convolution to turn each feature vector into $C$ class scores. This gives us a fully convolutional network, or FCN. Long et al., 2015

There is a problem: the pooling and strides that helped classification have reduced spatial resolution. We need to bring it back up.

We can split the network into an encoder that reduces resolution and a decoder that increases it again. In the decoder, interpolate then convolve, or use a learned transposed convolution. The latter applies the transpose of a convolution's linear operator; the lost detail does not come back automatically.

To preserve that detail, pass earlier feature maps into the decoder through skip connections. The decoder can now combine fine edges from early layers with object features from deeper layers.

After upsampling, apply softmax across classes at each pixel. We now have a classifier at every pixel, so we can average the same cross-entropy over the $M$ labelled pixels:

$$L_{\mathrm{seg}}=-\frac{1}{M}\sum_{i=1}^{M}\log p_{i,y_i}$$

Here $y_i$ is the true class of pixel $i$, and $p_{i,y_i}$ is the probability assigned to that class. Pixels marked “ignore” do not enter the sum.

If two labelled pixels receive correct-class probabilities $0.8$ and $0.25$, their average loss is:

$$-\frac{\log 0.8+\log 0.25}{2}\approx0.805$$

The second pixel contributes much more. Notice that none of this distinguishes one person from another: both receive the class “person”.

Object detection: predict a set of boxes

For one object, we can attach two heads to the same features: one predicts the class, the other predicts four box coordinates. A head is just a branch of the network with its own output and loss.

Now add a second object. We need another box, and perhaps a third for the bicycle. The number of outputs depends on the image. Their order should not matter either: listing the left person first or the right person first describes the same scene.

Before looking at architectures, we need a way to compare boxes.

Intersection over Union

For boxes $A$ and $B$, Intersection over Union is:

$$\operatorname{IoU}(A,B)=\frac{|A\cap B|}{|A\cup B|}$$

The vertical bars mean area. Identical boxes have IoU 1; boxes with no shared area have IoU 0.

Let's use corner coordinates $(x_{\min},y_{\min},x_{\max},y_{\max})$. Let $A=(0,0,4,4)$ and $B=(2,0,6,4)$. Each area is 16, and their overlap is $2\times4=8$:

$$\operatorname{IoU}(A,B)=\frac{8}{16+16-8}=\frac{1}{3}$$

Half of each box overlaps, but IoU is only one third. The denominator counts the entire union, not just one box.

We can apply the same operation to sets of mask pixels. For semantic segmentation, average the IoU of each class to get mean IoU. If most pixels are background, predicting background everywhere can give high pixel accuracy. The object classes still have zero IoU.

When is a detection correct?

A prediction needs the correct class and enough overlap with an annotated object. We choose an IoU threshold, then match detections to ground truth in descending confidence order. A normal ground-truth object can be matched once; another detection of that same object is a false positive.

Suppose a dataset contains three annotated bicycles. At IoU threshold 0.5, four predictions arrive in this order:

Precision is the fraction of retained predictions that are correct. Recall is the fraction of ground-truth objects found. Notice what the duplicate does: it lowers precision without finding another bicycle.

Lowering the confidence threshold includes more predictions. Plot precision against recall as we do this, then summarize that curve with Average Precision, or AP. AP uses interpolated precision at recall levels; we cannot just average the table's precision column. Average AP across classes to get mAP.

The COCO evaluator uses 101 recall levels and averages AP over ten IoU thresholds, from 0.50 to 0.95 in steps of 0.05. AP50 and AP75 fix the IoU threshold at the named value. The full evaluator also handles crowds, ignored regions, and detection limits.

From crops to shared features

Running a classifier on every possible crop is expensive. There are many positions, sizes, and aspect ratios to try.

R-CNN reduces the search to region proposals: boxes that might contain objects. Resize each proposed crop, run it through a CNN, then classify its features and adjust the box.

But overlapping crops still repeat the CNN's work. Fast R-CNN moves that computation before the crop: run the image through the CNN once, then extract each region from the shared feature map. We train its class and box heads together. Girshick, 2015

The proposed regions still have different sizes. Divide each one into a fixed grid and max-pool within each bin. Now every region has the same feature size and can feed the same head. This operation is RoI pooling, where RoI means region of interest.

We can also learn where to place the proposals. Faster R-CNN adds a Region Proposal Network, or RPN, to the shared features. At each feature-map location, place reference boxes of several sizes and aspect ratios. These are the anchors. The RPN predicts an objectness score and four box corrections for each anchor. Ren et al., 2015

Notice the two paths from the shared feature map. One proposes boxes. The other supplies the features inside those boxes. Objectness first asks whether there is an object; the class head then asks which class it belongs to. The box head makes a second correction to its location.

These are the two stages: propose regions, then classify and refine them. We only ran the image backbone once.

What does a box head learn?

For a reference box with centre $(x_a,y_a)$ and dimensions $(w_a,h_a)$, we can express the target box as relative changes:

$$\begin{aligned} t_x&=(x-x_a)/w_a & t_y&=(y-y_a)/h_a\\ t_w&=\log(w/w_a) & t_h&=\log(h/h_a) \end{aligned}$$

We divide position changes by the reference size and take the log of size ratios. The same target can now mean “move right by half a box width” for a small or a large object. This is R-CNN's box regression, in Appendix C.

If the reference is centred at $(10,10)$ with size $(4,4)$, and the target is centred at $(12,9)$ with size $(8,4)$, the targets are:

$$(t_x,t_y,t_w,t_h)=(0.5,-0.25,\log2,0)$$

To decode, $x=x_a+w_at_x$ and $w=w_a e^{t_w}$, with the same operations for $y$ and $h$.

To train the region heads, add the class loss and the box loss:

$$L=-\log p_y+\lambda\,\mathbf{1}_{y\ne\mathrm{bg}}L_{\mathrm{box}}$$

Here $p_y$ is the true-class probability and $\lambda$ balances the terms. The indicator turns the box loss off for background: there is no target object box to regress. Fast R-CNN sums smooth L1 over the four box-offset errors. For each error $r$:

$$\ell(r)=\begin{cases} \frac12r^2 & |r|<1\\ |r|-\frac12 & \text{otherwise} \end{cases}$$

It is quadratic near zero and linear for larger errors.

One-stage detectors

What if we predict the final classes and boxes at each image location, and remove the second stage?

The original YOLO divides the image into a grid. Assign each object to the cell containing its centre, then train that cell to predict boxes, confidence values, and class probabilities. The grid gives us a fixed output tensor for images with different numbers of objects. In this version of YOLO, confidence combines object presence with box overlap. Redmon et al., 2015

Dense prediction creates a training problem: most candidates are easy background. Their combined loss can overwhelm the smaller number of useful examples.

We can reduce the easy examples' contribution by multiplying cross-entropy by a factor that shrinks as the prediction improves. This is focal loss, introduced with RetinaNet. Omitting its optional class-balancing weight:

$$L_{\mathrm{focal}}=-(1-p_t)^\gamma\log p_t$$

Here $p_t$ is the probability of the correct binary label and $\gamma\geq0$ controls the effect. At $\gamma=0$, this is cross-entropy. At $\gamma=2$, a correct-label probability of 0.8 multiplies cross-entropy by 0.04; a probability of 0.2 multiplies it by 0.64. The hard example keeps much more of its contribution. Lin et al., 2017

Removing duplicates

Many nearby candidates can predict the same object. To remove duplicates, keep the highest-scoring box, remove lower-scoring boxes that overlap it above an IoU threshold, then repeat with the remaining boxes. This is non-maximum suppression, or NMS, commonly applied separately for each class. The Torchvision operation follows this rule.

For three person detections, suppose the scores are 0.9, 0.8, and 0.7. The first two overlap at IoU 0.85, while the third is elsewhere. With NMS threshold 0.5, keep the first and third.

Two real people can overlap too, so NMS can remove a correct detection. Could we train the network to produce one prediction per object in the first place?

DETR: prediction as a set

DETR passes image features and positional information through a Transformer encoder. Its decoder starts with a fixed set of learned object queries. Each query produces a class and a box; unused queries predict “no object”. Carion et al., 2020

The queries attend to image features through cross-attention and interact through self-attention. We can think of each query as a slot available to predict an object. Training decides how those slots are used.

For each training image, compute a cost for every predicted/true pair. Then find the lowest-cost one-to-one assignment with Hungarian matching.

For two objects and two predictions, imagine these combined class-and-box costs:

Matching person to prediction 1 and bicycle to prediction 2 costs $1+2=3$. Swapping them costs $4+3=7$. The first assignment wins. If there were extra slots, they would learn “no object”.

Once we have the assignment, train every slot with classification loss and the matched objects with box loss. The original box loss combines L1 coordinate error with generalized IoU. Notice the order: matching chooses which target belongs to each prediction, then backpropagation improves those predictions. Training this way lets the original DETR produce its set without NMS. Matching and training losses

Why generalized IoU? Ordinary IoU stays zero when two boxes are disjoint. GIoU also measures the unused area in the smallest enclosing box, so separated boxes can still receive a localization signal.

Instance and panoptic segmentation

Return to our two people. Semantic segmentation gives both the same pixel label. Detection separates them, but a rectangle includes background. We want a separate pixel mask for each person.

Add a third branch to Faster R-CNN: for each region, predict a small binary mask for each class. We now have Mask R-CNN. For foreground regions, train only the mask for the true class with binary cross-entropy. The class head handles which class it is; the mask branch learns which pixels belong to it. He et al., 2017

For a mask, rounding a region's coordinates can shift the boundary by several image pixels. Replace RoI pooling with RoIAlign: keep the fractional coordinates and sample features with bilinear interpolation. Resize the predicted mask into the output box.

That separates countable things such as people and cars. To label the rest of the scene as well, include stuff classes such as road and sky. Each pixel gets one class and, for a thing, an instance identity. This is panoptic segmentation, and its final regions do not overlap. Kirillov et al., 2018

In our scene, this means person 1, person 2, bicycle 1, road, and sky. Mask AP evaluates scored instance masks. Panoptic Quality combines their overlap quality with missed and extra segments. For one class:

$$\mathrm{PQ}=\frac{\sum_{(p,g)\in\mathrm{TP}}\operatorname{IoU}(p,g)}{|\mathrm{TP}|+\frac12|\mathrm{FP}|+\frac12|\mathrm{FN}|}$$

$\mathrm{TP}$ contains matched predicted/true segment pairs $(p,g)$ with IoU above 0.5. $\mathrm{FP}$ counts unmatched predictions; $\mathrm{FN}$ counts missed true segments. The bars count elements. Dataset rules handle void regions separately.

What has the model learned?

We have been changing the output to ask more of the network. Let's now keep a trained network and look at what its features respond to.

We can view first-layer filters directly, or collect image patches that strongly activate a channel. We can also make an input that activates it: start with an image, compute the activation's gradient with respect to the pixels, then change the pixels to increase it. Keep the network weights fixed.

This is activation maximization:

$$x^*=\arg\max_x\left[a(x)-\lambda R(x)\right]$$

Here $a(x)$ is the activation we want to increase. We subtract $\lambda R(x)$ to penalize extreme pixels or rapid changes between neighbours. Change this regularizer and we change which activating image the optimization finds. Olah, Mordvintsev, and Schubert

Saliency: sensitivity to the input

For an existing image $x$, we can ask a more local question: which pixels can change the class score $s_c(x)$ most if we move them a little? Compute the gradient with respect to each pixel and take its largest magnitude across colour channels:

$$S_{ij}=\max_k\left|\frac{\partial s_c}{\partial x_{ijk}}\right|$$

Here $i,j$ are pixel coordinates and $k$ indexes colour channels. Displaying $S$ gives us a basic saliency map.

For a small input change $\delta$, the score changes approximately by:

$$s_c(x+\delta)\approx s_c(x)+\nabla_xs_c(x)^T\delta$$

This measures local sensitivity. A region can matter even if its gradient is small, for example when the model's response is flat around the current input. Simonyan et al., 2014

CAM and Grad-CAM

Suppose a classifier averages each final feature map $A_k$ over space, then uses a linear classifier with weights $w_{ck}$ for class $c$.

Take those same classifier weights and use them to sum the feature maps before spatial averaging:

$$M_c(i,j)=\sum_k w_{ck}A_k(i,j)$$

Averaging $M_c$ over space recovers the class score, apart from its bias. But now we can see where each contribution came from. This is Class Activation Mapping, or CAM. Zhou et al., 2016

For a network without that pooling-and-linear-classifier structure, we need another way to weight its feature maps. Grad-CAM computes the score gradient at a chosen convolutional layer and averages it over space:

$$\alpha_k^c=\frac{1}{HW}\sum_{i,j}\frac{\partial s_c}{\partial A_k(i,j)}$$ $$M_c(i,j)=\operatorname{ReLU}\left(\sum_k\alpha_k^c A_k(i,j)\right)$$

Here $H,W$ are the feature-map dimensions. Each $\alpha_k^c$ becomes the weight for channel $k$. Sum the weighted maps, keep positive contributions with ReLU, then upsample for display. Selvaraju et al., 2017

A heatmap can look right without explaining the learned model. One useful check is to randomize the weights or training labels and compare the maps. Some methods still produce similar-looking results, as Sanity Checks for Saliency Maps shows.

Feature inversion

Now take the features of a particular image and try to reconstruct that image from them. This is feature inversion.

Let $\phi_\ell(x)$ be the features at layer $\ell$, and let $x_0$ be our reference image. Start from noise and optimize:

$$\begin{aligned} L_{\mathrm{inv}}(x)&=\|\phi_\ell(x)-\phi_\ell(x_0)\|_2^2+\lambda R(x)\\ x^*&=\arg\min_x L_{\mathrm{inv}}(x) \end{aligned}$$

At every step, run the reconstruction through the same fixed network and compare its features with the reference. Backpropagate that difference to the reconstructed pixels. If several images fit, the representation does not tell us which one was the original; the regularizer helps choose one. Mahendran and Vedaldi, 2015

We can repeat this at different layers to see how much image detail each representation preserves.

Adversarial examples

We can also optimize the input to make the model wrong, while restricting how much we change it.

For fixed parameters $\theta$, true label $y$, and classification loss $L$, the Fast Gradient Sign Method, or FGSM, makes one step that increases the loss:

$$\begin{aligned} \delta&=\epsilon\,\operatorname{sign}(\nabla_x L(\theta,x,y))\\ x_{\mathrm{adv}}&=\operatorname{clip}(x+\delta) \end{aligned}$$

The clip operation keeps valid pixel values. $\epsilon$ limits the change per input coordinate, in the same units as the input. Each pixel moves in the direction that increases the linearized loss. Goodfellow et al., 2015

For a two-value input $x=(0.4,0.6)$, gradient $(2,-3)$, and $\epsilon=0.01$, we get $(0.41,0.59)$. The first-order loss change is:

$$2(0.01)+(-3)(-0.01)=0.05$$

Notice how both coordinates increase the loss even though one moves up and the other down. These contributions can add across many dimensions. We chose the perturbation using the model's gradient; small random noise would not necessarily do the same. Whether it changes the predicted class, or is visible to a person, depends on the image, model, and $\epsilon$.

DeepDream and style transfer

Let's change what we optimize the image for.

In DeepDream, start with an image and increase selected internal activations. A weak pattern becomes stronger, activates the feature more, and gets amplified again. Choosing a different layer changes which structures emerge. The network stays fixed throughout. Mordvintsev, Olah, and Tyka, 2015

For neural style transfer, give the optimization two images: one whose content we want to keep and another whose style we want to use. Compare content through feature activations. For style, compare how feature channels activate together. Gatys et al., 2015

Flatten a layer's spatial positions into $N$ columns, giving a feature matrix $F\in\mathbb{R}^{C\times N}$. Its Gram matrix is:

$$G=FF^T,\qquad G_{ij}=\sum_{n=1}^{N}F_{in}F_{jn}$$

An entry measures how two channels activate together across positions. Summing over positions removes their exact arrangement from this comparison.

For two channels and two positions:

$$F=\begin{bmatrix}1&2\\3&0\end{bmatrix},\qquad G=\begin{bmatrix}5&3\\3&9\end{bmatrix}$$

Swap the two columns of $F$: the Gram matrix stays the same. We kept the feature correlations but changed where they occurred. This is why a Gram comparison can describe texture without preserving the whole scene layout.

For generated image $x$, content image $c$, and style image $s$, the objective has the form:

$$\begin{aligned} L(x)={}&\alpha\|\phi_{\ell_c}(x)-\phi_{\ell_c}(c)\|_2^2\\ &+\beta\sum_\ell w_\ell\|G_\ell(x)-G_\ell(s)\|_F^2 \end{aligned}$$

$\ell_c$ selects a content layer. $w_\ell$ weights style layers, with normalization factors absorbed into it. $\alpha,\beta$ balance content and style; $\|\cdot\|_F^2$ sums squared matrix entries. Gradients change $x$ while the feature network stays fixed.

We are still using backpropagation, just with a different variable to update. The same fixed network can reconstruct an image, make an adversarial input, or transfer a texture depending on the loss we differentiate through.

Next, video understanding adds time: recognizing what changes across a sequence, rather than only what appears in one image.