Single Shot Multibox Detection

:label:sec_ssd

In :numref:sec_bbox—:numref:sec_object-detection-dataset, we introduced bounding boxes, anchor boxes, multiscale object detection, and the dataset for object detection. Now we are ready to use such background knowledge to design an object detection model: single shot multibox detection (SSD) :cite:Liu.Anguelov.Erhan.ea.2016. This model is simple, fast, and widely used. Although this is just one of vast amounts of object detection models, some of the design principles and implementation details in this section are also applicable to other models.

Model

:numref:fig_ssd provides an overview of the design of single-shot multibox detection. This model mainly consists of a base network followed by several multiscale feature map blocks. The base network is for extracting features from the input image, so it can use a deep CNN. For example, the original single-shot multibox detection paper adopts a VGG network truncated before the classification layer :cite:Liu.Anguelov.Erhan.ea.2016, while ResNet has also been commonly used. Through our design we can make the base network output larger feature maps so as to generate more anchor boxes for detecting smaller objects. Subsequently, each multiscale feature map block reduces (e.g., by half) the height and width of the feature maps from the previous block, and enables each unit of the feature maps to increase its receptive field on the input image.

Recall the design of multiscale object detection through layerwise representations of images by deep neural networks in :numref:sec_multiscale-object-detection. Since multiscale feature maps closer to the top of :numref:fig_ssd are smaller but have larger receptive fields, they are suitable for detecting fewer but larger objects.

In a nutshell, via its base network and several multiscale feature map blocks, single-shot multibox detection generates a varying number of anchor boxes with different sizes, and detects varying-size objects by predicting classes and offsets of these anchor boxes (thus the bounding boxes); thus, this is a multiscale object detection model.

As a multiscale object detection model, single-shot multibox detection mainly consists of a base network followed by several multiscale feature map blocks. :label:fig_ssd

In the following, we will describe the implementation details of different blocks in :numref:fig_ssd. To begin with, we discuss how to implement the class and bounding box prediction.

Class Prediction Layer

Let the number of object classes be $q$. Then anchor boxes have $q+1$ classes, where class 0 is background. At some scale, suppose that the height and width of feature maps are $h$ and $w$, respectively. When $a$ anchor boxes are generated with each spatial position of these feature maps as their center, a total of $hwa$ anchor boxes need to be classified. This often makes classification with fully-connected layers infeasible due to likely heavy parameterization costs. Recall how we used channels of convolutional layers to predict classes in :numref:sec_nin. Single-shot multibox detection uses the same technique to reduce model complexity.

Specifically, the class prediction layer uses a convolutional layer without altering width or height of feature maps. In this way, there can be a one-to-one correspondence between outputs and inputs at the same spatial dimensions (width and height) of feature maps. More concretely, channels of the output feature maps at any spatial position ($x$, $y$) represent class predictions for all the anchor boxes centered on ($x$, $y$) of the input feature maps. To produce valid predictions, there must be $a(q+1)$ output channels, where for the same spatial position the output channel with index $i(q+1) + j$ represents the prediction of the class $j$ ($0 \leq j \leq q$) for the anchor box $i$ ($0 \leq i < a$).

Below we define such a class prediction layer, specifying $a$ and $q$ via arguments num_anchors and num_classes, respectively. This layer uses a $3\times3$ convolutional layer with a padding of 1. The width and height of the input and output of this convolutional layer remain unchanged.

```{.python .input} %matplotlib inline from d2l import mxnet as d2l from mxnet import autograd, gluon, image, init, np, npx from mxnet.gluon import nn

npx.set_np()

def cls_predictor(num_anchors, num_classes): return nn.Conv2D(num_anchors * (num_classes + 1), kernel_size=3, padding=1)

  2. ```{.python .input}
  3. #@tab pytorch
  4. %matplotlib inline
  5. from d2l import torch as d2l
  6. import torch
  7. import torchvision
  8. from torch import nn
  9. from torch.nn import functional as F
  11. def cls_predictor(num_inputs, num_anchors, num_classes):
  12.     return nn.Conv2d(num_inputs, num_anchors * (num_classes + 1),
  13.                      kernel_size=3, padding=1)

Bounding Box Prediction Layer

The design of the bounding box prediction layer is similar to that of the class prediction layer. The only difference lies in the number of outputs for each anchor box: here we need to predict four offsets rather than $q+1$ classes.

```{.python .input} def bbox_predictor(num_anchors): return nn.Conv2D(num_anchors * 4, kernel_size=3, padding=1)

  2. ```{.python .input}
  3. #@tab pytorch
  4. def bbox_predictor(num_inputs, num_anchors):
  5.     return nn.Conv2d(num_inputs, num_anchors * 4, kernel_size=3, padding=1)

Concatenating Predictions for Multiple Scales

As we mentioned, single-shot multibox detection uses multiscale feature maps to generate anchor boxes and predict their classes and offsets. At different scales, the shapes of feature maps or the numbers of anchor boxes centered on the same unit may vary. Therefore, shapes of the prediction outputs at different scales may vary.

In the following example, we construct feature maps at two different scales, Y1 and Y2, for the same minibatch, where the height and width of Y2 are half of those of Y1. Let us take class prediction as an example. Suppose that 5 and 3 anchor boxes are generated for every unit in Y1 and Y2, respectively. Suppose further that the number of object classes is 10. For feature maps Y1 and Y2 the numbers of channels in the class prediction outputs are $5\times(10+1)=55$ and $3\times(10+1)=33$, respectively, where either output shape is (batch size, number of channels, height, width).

```{.python .input} def forward(x, block): block.initialize() return block(x)

Y1 = forward(np.zeros((2, 8, 20, 20)), cls_predictor(5, 10)) Y2 = forward(np.zeros((2, 16, 10, 10)), cls_predictor(3, 10)) Y1.shape, Y2.shape

  2. ```{.python .input}
  3. #@tab pytorch
  4. def forward(x, block):
  5.     return block(x)
  7. Y1 = forward(torch.zeros((2, 8, 20, 20)), cls_predictor(8, 5, 10))
  8. Y2 = forward(torch.zeros((2, 16, 10, 10)), cls_predictor(16, 3, 10))
  9. Y1.shape, Y2.shape

As we can see, except for the batch size dimension, the other three dimensions all have different sizes. To concatenate these two prediction outputs for more efficient computation, we will transform these tensors into a more consistent format.

Note that the channel dimension holds the predictions for anchor boxes with the same center. We first move this dimension to the innermost. Since the batch size remains the same for different scales, we can transform the prediction output into a two-dimensional tensor with shape (batch size, height $\times$ width $\times$ number of channels). Then we can concatenate such outputs at different scales along dimension 1.

```{.python .input} def flatten_pred(pred): return npx.batch_flatten(pred.transpose(0, 2, 3, 1))

def concat_preds(preds): return np.concatenate([flatten_pred(p) for p in preds], axis=1)

  2. ```{.python .input}
  3. #@tab pytorch
  4. def flatten_pred(pred):
  5.     return torch.flatten(pred.permute(0, 2, 3, 1), start_dim=1)
  7. def concat_preds(preds):
  8.     return torch.cat([flatten_pred(p) for p in preds], dim=1)

In this way, even though Y1 and Y2 have different sizes in channels, heights, and widths, we can still concatenate these two prediction outputs at two different scales for the same minibatch.

```{.python .input}

@tab all

concat_preds([Y1, Y2]).shape

  2. ### Downsampling Block
  4. In order to detect objects at multiple scales,
  5. we define the following downsampling block `down_sample_blk` that
  6. halves the height and width of input feature maps.
  7. In fact,
  8. this block applies the design of VGG blocks
  9. in :numref:`subsec_vgg-blocks`.
  10. More concretely,
  11. each downsampling block consists of 
  12. two $3\times3$ convolutional layers with padding of 1
  13. followed by a $2\times2$ maximum pooling layer with stride of 2.
  14. As we know, $3\times3$ convolutional layers with padding of 1 do not change the shape of feature maps.
  15. However, the subsequent $2\times2$ maximum pooling  reduces the height and width of input feature maps by half.
  16. For both input and output feature maps of this downsampling block,
  17. because $1\times 2+(3-1)+(3-1)=6$,
  18. each unit in the output
  19. has a $6\times6$ receptive field on the input.
  20. Therefore, the downsampling block enlarges the receptive field of each unit in its output feature maps.
  22. ```{.python .input}
  23. def down_sample_blk(num_channels):
  24.     blk = nn.Sequential()
  25.     for _ in range(2):
  26.         blk.add(nn.Conv2D(num_channels, kernel_size=3, padding=1),
  27.                 nn.BatchNorm(in_channels=num_channels),
  28.                 nn.Activation('relu'))
  29.     blk.add(nn.MaxPool2D(2))
  30.     return blk

```{.python .input}

@tab pytorch

def downsample_blk(in_channels, out_channels): blk = [] for in range(2): blk.append(nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1)) blk.append(nn.BatchNorm2d(out_channels)) blk.append(nn.ReLU()) in_channels = out_channels blk.append(nn.MaxPool2d(2)) return nn.Sequential(*blk)

  2. In the following example, our constructed downsampling block changes the number of input channels and halves the height and width of the input feature maps.
  4. ```{.python .input}
  5. forward(np.zeros((2, 3, 20, 20)), down_sample_blk(10)).shape

```{.python .input}

@tab pytorch

forward(torch.zeros((2, 3, 20, 20)), down_sample_blk(3, 10)).shape

  2. ### Base Network Block
  4. The base network block is used to extract features from input images.
  5. For simplicity,
  6. we construct a small base network
  7. consisting of three downsampling blocks 
  8. that double the number of channels at each block.
  9. Given a $256\times256$ input image,
  10. this base network block outputs $32 \times 32$ feature maps ($256/2^3=32$).
  12. ```{.python .input}
  13. def base_net():
  14.     blk = nn.Sequential()
  15.     for num_filters in [16, 32, 64]:
  16.         blk.add(down_sample_blk(num_filters))
  17.     return blk
  19. forward(np.zeros((2, 3, 256, 256)), base_net()).shape

```{.python .input}

@tab pytorch

def base_net(): blk = [] num_filters = [3, 16, 32, 64] for i in range(len(num_filters) - 1): blk.append(down_sample_blk(num_filters[i], num_filters[i+1])) return nn.Sequential(*blk)

forward(torch.zeros((2, 3, 256, 256)), base_net()).shape

  2. ### The Complete Model
  5. The complete
  6. single shot multibox detection model
  7. consists of five blocks.
  8. The feature maps produced by each block
  9. are used for both
  10. (i) generating anchor boxes
  11. and (ii) predicting classes and offsets of these anchor boxes.
  12. Among these five blocks,
  13. the first one
  14. is the base network block,
  15. the second to the fourth are
  16. downsampling blocks,
  17. and the last block
  18. uses global maximum pooling
  19. to reduce both the height and width to 1.
  20. Technically,
  21. the second to the fifth blocks
  22. are all
  23. those
  24. multiscale feature map blocks
  25. in :numref:`fig_ssd`.
  27. ```{.python .input}
  28. def get_blk(i):
  29.     if i == 0:
  30.         blk = base_net()
  31.     elif i == 4:
  32.         blk = nn.GlobalMaxPool2D()
  33.     else:
  34.         blk = down_sample_blk(128)
  35.     return blk

```{.python .input}

@tab pytorch

def get_blk(i): if i == 0: blk = base_net() elif i == 1: blk = down_sample_blk(64, 128) elif i == 4: blk = nn.AdaptiveMaxPool2d((1,1)) else: blk = down_sample_blk(128, 128) return blk

  2. Now we define the forward propagation
  3. for each block.
  4. Different from 
  5. in image classification tasks,
  6. outputs here include
  7. (i) CNN feature maps `Y`,
  8. (ii) anchor boxes generated using `Y` at the current scale,
  9. and (iii) classes and offsets predicted (based on `Y`)
  10. for these anchor boxes.
  12. ```{.python .input}
  13. def blk_forward(X, blk, size, ratio, cls_predictor, bbox_predictor):
  14.     Y = blk(X)
  15.     anchors = d2l.multibox_prior(Y, sizes=size, ratios=ratio)
  16.     cls_preds = cls_predictor(Y)
  17.     bbox_preds = bbox_predictor(Y)
  18.     return (Y, anchors, cls_preds, bbox_preds)

```{.python .input}

@tab pytorch

def blk_forward(X, blk, size, ratio, cls_predictor, bbox_predictor): Y = blk(X) anchors = d2l.multibox_prior(Y, sizes=size, ratios=ratio) cls_preds = cls_predictor(Y) bbox_preds = bbox_predictor(Y) return (Y, anchors, cls_preds, bbox_preds)

  2. Recall that 
  3. in :numref:`fig_ssd`
  4. a multiscale feature map block
  5. that is closer to the top
  6. is for detecting larger objects;
  7. thus, it needs to generate larger anchor boxes.
  8. In the above forward propagation,
  9. at each multiscale feature map block
  10. we pass in a list of two scale values
  11. via the `sizes` argument
  12. of the invoked `multibox_prior` function (described in :numref:`sec_anchor`).
  13. In the following,
  14. the interval between 0.2 and 1.05
  15. is split evenly
  16. into five sections to determine the
  17. smaller scale values at the five blocks: 0.2, 0.37, 0.54, 0.71, and 0.88.
  18. Then their larger scale values
  19. are given by
  20. $\sqrt{0.2 \times 0.37} = 0.272$, $\sqrt{0.37 \times 0.54} = 0.447$, and so on.
  22. ```{.python .input}
  23. #@tab all
  24. sizes = [[0.2, 0.272], [0.37, 0.447], [0.54, 0.619], [0.71, 0.79],
  25.          [0.88, 0.961]]
  26. ratios = [[1, 2, 0.5]] * 5
  27. num_anchors = len(sizes[0]) + len(ratios[0]) - 1

Now we can define the complete model TinySSD as follows.

```{.python .input} class TinySSD(nn.Block): def init(self, numclasses, **kwargs): super(TinySSD, self)._init(**kwargs) self.num_classes = num_classes for i in range(5):

  1.         # Equivalent to the assignment statement `self.blk_i = get_blk(i)`
  2.         setattr(self, f'blk_{i}', get_blk(i))
  3.         setattr(self, f'cls_{i}', cls_predictor(num_anchors, num_classes))
  4.         setattr(self, f'bbox_{i}', bbox_predictor(num_anchors))
  6. def forward(self, X):
  7.     anchors, cls_preds, bbox_preds = [None] * 5, [None] * 5, [None] * 5
  8.     for i in range(5):
  9.         # Here `getattr(self, 'blk_%d' % i)` accesses `self.blk_i`
  10.         X, anchors[i], cls_preds[i], bbox_preds[i] = blk_forward(
  11.             X, getattr(self, f'blk_{i}'), sizes[i], ratios[i],
  12.             getattr(self, f'cls_{i}'), getattr(self, f'bbox_{i}'))
  13.     anchors = np.concatenate(anchors, axis=1)
  14.     cls_preds = concat_preds(cls_preds)
  15.     cls_preds = cls_preds.reshape(
  16.         cls_preds.shape[0], -1, self.num_classes + 1)
  17.     bbox_preds = concat_preds(bbox_preds)
  18.     return anchors, cls_preds, bbox_preds
  2. ```{.python .input}
  3. #@tab pytorch
  4. class TinySSD(nn.Module):
  5.     def __init__(self, num_classes, **kwargs):
  6.         super(TinySSD, self).__init__(**kwargs)
  7.         self.num_classes = num_classes
  8.         idx_to_in_channels = [64, 128, 128, 128, 128]
  9.         for i in range(5):
  10.             # Equivalent to the assignment statement `self.blk_i = get_blk(i)`
  11.             setattr(self, f'blk_{i}', get_blk(i))
  12.             setattr(self, f'cls_{i}', cls_predictor(idx_to_in_channels[i],
  13.                                                     num_anchors, num_classes))
  14.             setattr(self, f'bbox_{i}', bbox_predictor(idx_to_in_channels[i],
  15.                                                       num_anchors))
  17.     def forward(self, X):
  18.         anchors, cls_preds, bbox_preds = [None] * 5, [None] * 5, [None] * 5
  19.         for i in range(5):
  20.             # Here `getattr(self, 'blk_%d' % i)` accesses `self.blk_i`
  21.             X, anchors[i], cls_preds[i], bbox_preds[i] = blk_forward(
  22.                 X, getattr(self, f'blk_{i}'), sizes[i], ratios[i],
  23.                 getattr(self, f'cls_{i}'), getattr(self, f'bbox_{i}'))
  24.         anchors = torch.cat(anchors, dim=1)
  25.         cls_preds = concat_preds(cls_preds)
  26.         cls_preds = cls_preds.reshape(
  27.             cls_preds.shape[0], -1, self.num_classes + 1)
  28.         bbox_preds = concat_preds(bbox_preds)
  29.         return anchors, cls_preds, bbox_preds

We create a model instance and use it to perform forward propagation on a minibatch of $256 \times 256$ images X.

As shown earlier in this section, the first block outputs $32 \times 32$ feature maps. Recall that the second to fourth downsampling blocks halve the height and width and the fifth block uses global pooling. Since 4 anchor boxes are generated for each unit along spatial dimensions of feature maps, at all the five scales a total of $(32^2 + 16^2 + 8^2 + 4^2 + 1)\times 4 = 5444$ anchor boxes are generated for each image.

```{.python .input} net = TinySSD(num_classes=1) net.initialize() X = np.zeros((32, 3, 256, 256)) anchors, cls_preds, bbox_preds = net(X)

print(‘output anchors:’, anchors.shape) print(‘output class preds:’, cls_preds.shape) print(‘output bbox preds:’, bbox_preds.shape)

  2. ```{.python .input}
  3. #@tab pytorch
  4. net = TinySSD(num_classes=1)
  5. X = torch.zeros((32, 3, 256, 256))
  6. anchors, cls_preds, bbox_preds = net(X)
  8. print('output anchors:', anchors.shape)
  9. print('output class preds:', cls_preds.shape)
  10. print('output bbox preds:', bbox_preds.shape)

Training

Now we will explain how to train the single shot multibox detection model for object detection.

Reading the Dataset and Initializing the Model

To begin with, let us read the banana detection dataset described in :numref:sec_object-detection-dataset.

```{.python .input}

@tab all

batchsize = 32 train_iter, = d2l.load_data_bananas(batch_size)

  2. There is only one class in the banana detection dataset. After defining the model,
  3. we need to initialize its parameters and define
  4. the optimization algorithm.
  6. ```{.python .input}
  7. device, net = d2l.try_gpu(), TinySSD(num_classes=1)
  8. net.initialize(init=init.Xavier(), ctx=device)
  9. trainer = gluon.Trainer(net.collect_params(), 'sgd',
  10.                         {'learning_rate': 0.2, 'wd': 5e-4})

```{.python .input}

@tab pytorch

device, net = d2l.try_gpu(), TinySSD(num_classes=1) trainer = torch.optim.SGD(net.parameters(), lr=0.2, weight_decay=5e-4)

  2. ### Defining Loss and Evaluation Functions
  4. Object detection has two types of losses.
  5. The first loss concerns classes of anchor boxes:
  6. its computation
  7. can simply reuse 
  8. the cross-entropy loss function
  9. that we used for image classification.
  10. The second loss
  11. concerns offsets of positive (non-background) anchor boxes:
  12. this is a regression problem.
  13. For this regression problem,
  14. however,
  15. here we do not use the squared loss
  16. described in :numref:`subsec_normal_distribution_and_squared_loss`.
  17. Instead,
  18. we use the $L_1$ norm loss,
  19. the absolute value of the difference between
  20. the prediction and the ground-truth.
  21. The mask variable `bbox_masks` filters out
  22. negative anchor boxes and illegal (padded)
  23. anchor boxes in the loss calculation.
  24. In the end, we sum up
  25. the anchor box class loss
  26. and the anchor box offset loss
  27. to obtain the loss function for the model.
  29. ```{.python .input}
  30. cls_loss = gluon.loss.SoftmaxCrossEntropyLoss()
  31. bbox_loss = gluon.loss.L1Loss()
  33. def calc_loss(cls_preds, cls_labels, bbox_preds, bbox_labels, bbox_masks):
  34.     cls = cls_loss(cls_preds, cls_labels)
  35.     bbox = bbox_loss(bbox_preds * bbox_masks, bbox_labels * bbox_masks)
  36.     return cls + bbox

```{.python .input}

@tab pytorch

cls_loss = nn.CrossEntropyLoss(reduction=’none’) bbox_loss = nn.L1Loss(reduction=’none’)

def calc_loss(cls_preds, cls_labels, bbox_preds, bbox_labels, bbox_masks): batch_size, num_classes = cls_preds.shape[0], cls_preds.shape[2] cls = cls_loss(cls_preds.reshape(-1, num_classes), cls_labels.reshape(-1)).reshape(batch_size, -1).mean(dim=1) bbox = bbox_loss(bbox_preds bbox_masks, bbox_labels bbox_masks).mean(dim=1) return cls + bbox

  2. We can use accuracy to evaluate the classification results.
  3. Due to the used $L_1$ norm loss for the offsets,
  4. we use the *mean absolute error* to evaluate the
  5. predicted bounding boxes.
  6. These prediction results are obtained 
  7. from the generated anchor boxes and the
  8. predicted offsets for them.
  10. ```{.python .input}
  11. def cls_eval(cls_preds, cls_labels):
  12.     # Because the class prediction results are on the final dimension,
  13.     # `argmax` needs to specify this dimension
  14.     return float((cls_preds.argmax(axis=-1).astype(
  15.         cls_labels.dtype) == cls_labels).sum())
  17. def bbox_eval(bbox_preds, bbox_labels, bbox_masks):
  18.     return float((np.abs((bbox_labels - bbox_preds) * bbox_masks)).sum())

```{.python .input}

@tab pytorch

def cls_eval(cls_preds, cls_labels):

  1. # Because the class prediction results are on the final dimension,
  2. # `argmax` needs to specify this dimension
  3. return float((cls_preds.argmax(dim=-1).type(
  4.     cls_labels.dtype) == cls_labels).sum())

def bbox_eval(bbox_preds, bbox_labels, bbox_masks): return float((torch.abs((bbox_labels - bbox_preds) * bbox_masks)).sum())

  2. ### Training the Model
  4. When training the model,
  5. we need to generate multiscale anchor boxes (`anchors`)
  6. and predict their classes (`cls_preds`) and offsets (`bbox_preds`) in the forward propagation.
  7. Then we label the classes (`cls_labels`) and offsets (`bbox_labels`) of such generated anchor boxes
  8. based on the label information `Y`.
  9. Finally, we calculate the loss function
  10. using the predicted and labeled values
  11. of the classes and offsets.
  12. For concise implementations,
  13. evaluation of the test dataset is omitted here.
  15. ```{.python .input}
  16. num_epochs, timer = 20, d2l.Timer()
  17. animator = d2l.Animator(xlabel='epoch', xlim=[1, num_epochs],
  18.                         legend=['class error', 'bbox mae'])
  19. for epoch in range(num_epochs):
  20.     # Sum of training accuracy, no. of examples in sum of training accuracy,
  21.     # Sum of absolute error, no. of examples in sum of absolute error
  22.     metric = d2l.Accumulator(4)
  23.     for features, target in train_iter:
  24.         timer.start()
  25.         X = features.as_in_ctx(device)
  26.         Y = target.as_in_ctx(device)
  27.         with autograd.record():
  28.             # Generate multiscale anchor boxes and predict their classes and
  29.             # offsets
  30.             anchors, cls_preds, bbox_preds = net(X)
  31.             # Label the classes and offsets of these anchor boxes
  32.             bbox_labels, bbox_masks, cls_labels = d2l.multibox_target(anchors,
  33.                                                                       Y)
  34.             # Calculate the loss function using the predicted and labeled
  35.             # values of the classes and offsets
  36.             l = calc_loss(cls_preds, cls_labels, bbox_preds, bbox_labels,
  37.                           bbox_masks)
  38.         l.backward()
  39.         trainer.step(batch_size)
  40.         metric.add(cls_eval(cls_preds, cls_labels), cls_labels.size,
  41.                    bbox_eval(bbox_preds, bbox_labels, bbox_masks),
  42.                    bbox_labels.size)
  43.     cls_err, bbox_mae = 1 - metric[0] / metric[1], metric[2] / metric[3]
  44.     animator.add(epoch + 1, (cls_err, bbox_mae))
  45. print(f'class err {cls_err:.2e}, bbox mae {bbox_mae:.2e}')
  46. print(f'{len(train_iter._dataset) / timer.stop():.1f} examples/sec on '
  47.       f'{str(device)}')

```{.python .input}

@tab pytorch

num_epochs, timer = 20, d2l.Timer() animator = d2l.Animator(xlabel=’epoch’, xlim=[1, num_epochs], legend=[‘class error’, ‘bbox mae’]) net = net.to(device) for epoch in range(num_epochs):

  1. # Sum of training accuracy, no. of examples in sum of training accuracy,
  2. # Sum of absolute error, no. of examples in sum of absolute error
  3. metric = d2l.Accumulator(4)
  4. net.train()
  5. for features, target in train_iter:
  6.     timer.start()
  7.     trainer.zero_grad()
  8.     X, Y = features.to(device), target.to(device)
  9.     # Generate multiscale anchor boxes and predict their classes and
  10.     # offsets
  11.     anchors, cls_preds, bbox_preds = net(X)
  12.     # Label the classes and offsets of these anchor boxes
  13.     bbox_labels, bbox_masks, cls_labels = d2l.multibox_target(anchors, Y)
  14.     # Calculate the loss function using the predicted and labeled values
  15.     # of the classes and offsets
  16.     l = calc_loss(cls_preds, cls_labels, bbox_preds, bbox_labels,
  17.                   bbox_masks)
  18.     l.mean().backward()
  19.     trainer.step()
  20.     metric.add(cls_eval(cls_preds, cls_labels), cls_labels.numel(),
  21.                bbox_eval(bbox_preds, bbox_labels, bbox_masks),
  22.                bbox_labels.numel())
  23. cls_err, bbox_mae = 1 - metric[0] / metric[1], metric[2] / metric[3]
  24. animator.add(epoch + 1, (cls_err, bbox_mae))

print(f’class err {cls_err:.2e}, bbox mae {bbox_mae:.2e}’) print(f’{len(train_iter.dataset) / timer.stop():.1f} examples/sec on ‘ f’{str(device)}’)

  2. ## Prediction
  4. During prediction, 
  5. the goal is to detect all the objects of interest
  6. on the image.
  7. Below
  8. we read and resize a test image,
  9. converting it to
  10. a four-dimensional tensor that is 
  11. required by convolutional layers.
  13. ```{.python .input}
  14. img = image.imread('../img/banana.jpg')
  15. feature = image.imresize(img, 256, 256).astype('float32')
  16. X = np.expand_dims(feature.transpose(2, 0, 1), axis=0)

```{.python .input}

@tab pytorch

X = torchvision.io.read_image(‘../img/banana.jpg’).unsqueeze(0).float() img = X.squeeze(0).permute(1, 2, 0).long()

  2. Using the `multibox_detection` function below,
  3. the predicted bounding boxes
  4. are obtained 
  5. from the anchor boxes and their predicted offsets.
  6. Then non-maximum suppression is used 
  7. to remove similar predicted bounding boxes.
  9. ```{.python .input}
  10. def predict(X):
  11.     anchors, cls_preds, bbox_preds = net(X.as_in_ctx(device))
  12.     cls_probs = npx.softmax(cls_preds).transpose(0, 2, 1)
  13.     output = d2l.multibox_detection(cls_probs, bbox_preds, anchors)
  14.     idx = [i for i, row in enumerate(output[0]) if row[0] != -1]
  15.     return output[0, idx]
  17. output = predict(X)

```{.python .input}

@tab pytorch

def predict(X): net.eval() anchors, cls_preds, bbox_preds = net(X.to(device)) cls_probs = F.softmax(cls_preds, dim=2).permute(0, 2, 1) output = d2l.multibox_detection(cls_probs, bbox_preds, anchors) idx = [i for i, row in enumerate(output[0]) if row[0] != -1] return output[0, idx]

output = predict(X)

  2. Finally, we display
  3. all the predicted bounding boxes with 
  4. confidence 0.9 or above
  5. as the output.
  7. ```{.python .input}
  8. def display(img, output, threshold):
  9.     d2l.set_figsize((5, 5))
  10.     fig = d2l.plt.imshow(img.asnumpy())
  11.     for row in output:
  12.         score = float(row[1])
  13.         if score < threshold:
  14.             continue
  15.         h, w = img.shape[0:2]
  16.         bbox = [row[2:6] * np.array((w, h, w, h), ctx=row.ctx)]
  17.         d2l.show_bboxes(fig.axes, bbox, '%.2f' % score, 'w')
  19. display(img, output, threshold=0.9)

```{.python .input}

@tab pytorch

def display(img, output, threshold): d2l.set_figsize((5, 5)) fig = d2l.plt.imshow(img) for row in output: score = float(row[1]) if score < threshold: continue h, w = img.shape[0:2] bbox = [row[2:6] * torch.tensor((w, h, w, h), device=row.device)] d2l.show_bboxes(fig.axes, bbox, ‘%.2f’ % score, ‘w’)

display(img, output.cpu(), threshold=0.9)

  2. ## Summary
  4. * Single shot multibox detection is a multiscale object detection model. Via its base network and several multiscale feature map blocks, single-shot multibox detection generates a varying number of anchor boxes with different sizes, and detects varying-size objects by predicting classes and offsets of these anchor boxes (thus the bounding boxes).
  5. * When training the single-shot multibox detection model, the loss function is calculated based on the predicted and labeled values of the anchor box classes and offsets.
  9. ## Exercises
  11. 1. Can you improve the single-shot multibox detection by improving the loss function? For example, replace $L_1$ norm loss with smooth $L_1$ norm loss for the predicted offsets. This loss function uses a square function around zero for smoothness, which is controlled by the hyperparameter $\sigma$:
  13. $$
  14. f(x) =
  15.     \begin{cases}
  16.     (\sigma x)^2/2,& \text{if }|x| < 1/\sigma^2\\
  17.     |x|-0.5/\sigma^2,& \text{otherwise}
  18.     \end{cases}
  19. $$
  21. When $\sigma$ is very large, this loss is similar to the $L_1$ norm loss. When its value is smaller, the loss function is smoother.
  23. ```{.python .input}
  24. sigmas = [10, 1, 0.5]
  25. lines = ['-', '--', '-.']
  26. x = np.arange(-2, 2, 0.1)
  27. d2l.set_figsize()
  29. for l, s in zip(lines, sigmas):
  30.     y = npx.smooth_l1(x, scalar=s)
  31.     d2l.plt.plot(x.asnumpy(), y.asnumpy(), l, label='sigma=%.1f' % s)
  32. d2l.plt.legend();

```{.python .input}

@tab pytorch

def smooth_l1(data, scalar): out = [] for i in data: if abs(i) < 1 / (scalar 2): out.append(((scalar * i) 2) / 2) else: out.append(abs(i) - 0.5 / (scalar ** 2)) return torch.tensor(out)

sigmas = [10, 1, 0.5] lines = [‘-‘, ‘—‘, ‘-.’] x = torch.arange(-2, 2, 0.1) d2l.set_figsize()

for l, s in zip(lines, sigmas): y = smooth_l1(x, scalar=s) d2l.plt.plot(x, y, l, label=’sigma=%.1f’ % s) d2l.plt.legend();

  2. Besides, in the experiment we used cross-entropy loss for class prediction:
  3. denoting by $p_j$ the predicted probability for the ground-truth class $j$, the cross-entropy loss is $-\log p_j$. We can also use the focal loss
  4. :cite:`Lin.Goyal.Girshick.ea.2017`: given hyperparameters $\gamma > 0$
  5. and $\alpha > 0$, this loss is defined as:
  7. $$ - \alpha (1-p_j)^{\gamma} \log p_j.$$
  9. As we can see, increasing $\gamma$
  10. can effectively reduce the relative loss
  11. for well-classified examples (e.g., $p_j > 0.5$)
  12. so the training
  13. can focus more on those difficult examples that are misclassified.
  15. ```{.python .input}
  16. def focal_loss(gamma, x):
  17.     return -(1 - x) ** gamma * np.log(x)
  19. x = np.arange(0.01, 1, 0.01)
  20. for l, gamma in zip(lines, [0, 1, 5]):
  21.     y = d2l.plt.plot(x.asnumpy(), focal_loss(gamma, x).asnumpy(), l,
  22.                      label='gamma=%.1f' % gamma)
  23. d2l.plt.legend();

```{.python .input}

@tab pytorch

def focal_loss(gamma, x): return -(1 - x) * gamma torch.log(x)

x = torch.arange(0.01, 1, 0.01) for l, gamma in zip(lines, [0, 1, 5]): y = d2l.plt.plot(x, focal_loss(gamma, x), l, label=’gamma=%.1f’ % gamma) d2l.plt.legend(); ```

  1. Due to space limitations, we have omitted some implementation details of the single shot multibox detection model in this section. Can you further improve the model in the following aspects:
    1. When an object is much smaller compared with the image, the model could resize the input image bigger.
    2. There are typically a vast number of negative anchor boxes. To make the class distribution more balanced, we could downsample negative anchor boxes.
    3. In the loss function, assign different weight hyperparameters to the class loss and the offset loss.
    4. Use other methods to evaluate the object detection model, such as those in the single shot multibox detection paper :cite:Liu.Anguelov.Erhan.ea.2016.

:begin_tab:mxnet Discussions :end_tab:

:begin_tab:pytorch Discussions :end_tab: