Crowd Counting with Decomposed Uncertainty

TL;DR

This paper introduces a scalable neural network framework for crowd counting that quantifies decomposed uncertainty using bootstrap ensembles, enhancing prediction insights and achieving state-of-the-art results on benchmark datasets.

Contribution

The work presents a novel uncertainty quantification method for crowd counting using bootstrap ensembles, improving decision-making and prediction accuracy.

Findings

Provides additional insight into crowd counting uncertainty

Achieves state-of-the-art performance on benchmark datasets

Simple to implement and scalable approach

Abstract

Research in neural networks in the field of computer vision has achieved remarkable accuracy for point estimation. However, the uncertainty in the estimation is rarely addressed. Uncertainty quantification accompanied by point estimation can lead to a more informed decision, and even improve the prediction quality. In this work, we focus on uncertainty estimation in the domain of crowd counting. With increasing occurrences of heavily crowded events such as political rallies, protests, concerts, etc., automated crowd analysis is becoming an increasingly crucial task. The stakes can be very high in many of these real-world applications. We propose a scalable neural network framework with quantification of decomposed uncertainty using a bootstrap ensemble. We demonstrate that the proposed uncertainty quantification method provides additional insight to the crowd counting problem and is simple to implement. We also show that our proposed method exhibits the state of the art performances in many benchmark crowd counting datasets.

Tables

Table 1. Table 1: Ablation studies on bootstrap extension and adaptability on different architecture

	UCF-50	UCF-QNRF
Methods	MAE	MAE
DUBNet w/o DUB extension	258.4	120.9
DUBNet	243.8	105.6
CSRNet (Li et al 2018)	266.1	135.5
CSRNet + DUB extension	244.9	127.1
MCNN (?)	377.6	277.0
MCNN + DUB extension	359.4	254.6

Table 2. Table 2: Estimation errors on ShanghaiTech A/B, UCF-CC 50, and UCF-QNRF datasets

	ShanghaiTech A		ShanghaiTech B		UCF-CC 50		UCF-QNRF
Method	MAE	RMSE	MAE	RMSE	MAE	RMSE	MAE	RMSE
MCNN (?)	110.2	173.2	26.4	41.3	377.6	509.1	277	426
Cascaded-MTL (?)	101.3	152.4	20.0	31.1	322.8	397.9	252	514
Switch-CNN (?)	90.4	135.0	21.6	33.4	318.1	439.2	228	445
D-ConvNet (?)	73.5	112.3	18.7	26.0	288.4	404.7	-	-
L2R (?)	73.6	112.0	13.7	21.4	279.6	388.9	-	-
DensityNetwork (?)	-	-	-	-	-	-	132	191
CSRNet (?)	68.2	115.0	10.6	16.0	266.1	397.5	135.5	207.4
ic-CNN (?)	68.5	116.2	10.7	16.0	260.9	365.5	-	-
SANet (?)	67.0	104.5	8.4	13.6	258.4	334.9	-	-
SFCN (?)	64.8	107.5	7.6	13.0	214.2	318.2	102.0	171.4
CAN (?)	62.3	100.0	7.8	12.2	212.2	243.7	107	183
DUBNet (Ours)	64.6	106.8	7.7	12.5	243.8	329.3	105.6	180.5

Table 3. Table 3: Calibration results of estimated uncertainty

Dataset	Ground truth in 90% CI
ShanghaiTech A	0.907
ShanghaiTech B	0.915
UCF-QNRF	0.890

Table 4. Table 4: Zoom levels and predictions

	Left view	Front view	Right view	Total
Zoom	Est. count	Est. count	Est. count
Level 3	1121.5 $\pm$ 219.8	7390.6 $\pm$ 837.4	8894.6 $\pm$ 1702.5	17906.7 $\pm$ 2759.6
Level 4	2515.1 $\pm$ 204.9	9702.4 $\pm$ 944.0	14419.1 $\pm$ 2637.4	26636.6 $\pm$ 3786.3
Level 5	5358.9 $\pm$ 385.3	14444.2 $\pm$ 1220.8	25602.2 $\pm$ 4164.1	45405.3 $\pm$ 5770.2
Level 6	18985.1 $\pm$ 967.2	34130.1 $\pm$ 2914.3	48807.1 $\pm$ 9328.2	101922.3 $\pm$ 13209.7
Level 7	68482.5 $\pm$ 2636.8	69880.6 $\pm$ 5836.7	61582.8 $\pm$ 11294.3	199945.9 $\pm$ 19767.8

Table 5. Table 5: Predictions on CNN giga-pixel images

Left view	Front view	Right view	Total
Est. count	Est. count	Est. count
1202.7 $\pm$ 91.8	12408.9 $\pm$ 1178.3	34714.5 $\pm$ 6207.0	48326.1 $\pm$ 7477.1

Table 6. Table 6: Comparison on average predictive variance

	Variance
Method	Part A	Part B
Full-bootstrap ResNet frontend + Dilated backend	47.6	1.17
DUBNet (Ours)	45.8	1.02

Equations

$$\mathcal{L}(\theta )=\frac{1}{D}\sum _i\frac{1}{2{\sigma }^2}\Vert y_i-{\hat{y}}_i{\Vert }^2+\frac{1}{2}\log {\sigma }^2$$

$$\text{Var}(y)\approx {\sigma }^2+\frac{1}{K}\sum _{k=1}^K{f}_{{\hat{\theta }}_k}(x{)}^{\top }{f}_{{\hat{\theta }}_k}(x)-\mathbb{E}(y{)}^{\top }\mathbb{E}(y)$$

$$[\hat{y},{\hat{\sigma }}^2]=f_{{\hat{\theta }}_k}(x).$$

$$\mathcal{L}(\theta )=\frac{1}{D}\sum _i\frac{1}{2{\hat{\sigma }}_i^2}\Vert y_i-{\hat{y}}_i{\Vert }^2+\frac{1}{2}\log {\hat{\sigma }}_i^2.$$

$$\mathcal{L}({\theta }_k)=\frac{1}{D_n}\sum _i\frac{1}{2\exp ({\hat{s}}_{n,i})}\Vert y_{n,i}-{\hat{y}}_{n,i}{\Vert }^2+\frac{1}{2}{\hat{s}}_{n,i}$$

$$\text{vspace}-0.8em\tilde{\mathcal{D}}={\left\{\left(Z_n,\hat{P}(Z_n)\right)\right\}}_{n=1,...,N}$$

$$p(\theta |\mathcal{D})=\frac{p(\mathcal{D}|\theta )p(\theta )}{p(\mathcal{D})}=\frac{\left({\prod }_{i=1}^{N}p(y_i|x_i,\theta )\right)p(\theta )}{p(\mathcal{D})}.$$

$$F(z)=\sum _{j=1}^J\delta (z-z_j)\times G_{{\sigma }_j}(z),\text{ with }{\sigma }_j=\beta {\bar{d}}_j$$

Full text

Introduction

The counting problem in computer vision is the estimation of the number of objects in a still image or video frame. It arises in many real-world applications including cell counting in microscopic images (?), monitoring crowds in surveillance systems (?), and counting the number of trees and crops in aerial images (?; ?). Recently, convolutional neural networks (CNN) have been shown to have successes in a wide range of tasks in computer vision, such as object detection, image recognition, face recognition, and image segmentation. Inspired by these successes, many CNN based crowd counting methods have been proposed. Along with density estimation techniques (?), CNN based approaches have shown outstanding performances over previous works that were relying on handcrafted feature extraction.

With increasing occurrences of heavily crowded events such as political rallies, protests, concerts, etc., automated crowd analysis is becoming an increasingly crucial task. The stakes can be very high in many of these real-world applications. Hence, we ask the following question:

*Can we deploy the existing CNN based crowd counting methods for crowd analysis in real-world applications?

One problem with existing CNN methods is that they only offer point estimates of counts (or density map) and do not address the uncertainty in the prediction, which can come from the model and also from data itself. When given a new unlabeled crowd image, how much can we trust the output of the model if it only provides a point estimate? Probabilistic interpretations of outputs of the predictive model via uncertainty quantification are very important. Uncertainty quantification accompanied by point estimation can lead to a more informed decision, and even improve the prediction quality. This can be crucial for the practitioners of these crowd counting methods. With the quantification of prediction confidence at hand, one can treat uncertain inputs and special cases explicitly. For instance, a crowd counting model might return a density map (or a count) with less confidence (i.e., high uncertainty) in some area of a given scene. In this case, the practitioner could decide to pass the image – or the specific part of the image that the model is uncertain about – to a human for validation.

While Bayesian methods provide a mathematically plausible framework to deal with uncertainty quantification, often the Bayesian methods for neural networks comes with a prohibitively computational cost. In this work, we propose a simple and scalable neural network framework using a bootstrap ensemble to quantify decomposed uncertainty for crowd counting. The key highlights of our work are:

• •

To the best of our knowledge, this work is the first to address uncertainty quantification of neural network predictions for crowd counting. Our method is shown to produce accurate estimated uncertainty.

• •

Our method decomposes uncertainties coming from the model and also from input data, which can be of independent interest for image analysis.

• •

Our proposed method achieves state-of-the-art level performances on multiple crowd counting benchmark datasets. The proposed architecture is more efficient than previously known state-of-the-art methods in terms of computational complexity.

• •

Our proposed uncertainty quantification framework is generic and independent of the architecture of an underlying network. Combined with its simplicity for implementation, we show the adaptability to other architecture.

Related Work

The previous literature on crowd counting problems can be categorized into three kinds of approaches depending on methodology: detection-based, regression-based and density-based methods.

Detection-based crowd counting is an approach to directly detect each of the target objects in a given image. A typical approach is to utilize object detectors (?; ?; ?) often using moving-windows (?). Then, the counts of targets in an image are automatically given as a byproduct of detection results. However, objects can be highly occluded in many crowded scenes and many target objects can be in drastically different scales, making detection much more challenging. These issues make detection-based approaches infeasible in dense crowd scenes.

Regression-based approaches (?; ?; ?; ?; ?) are proposed to remedy the occlusion problems which are obstacles for detection-based methods. Regression-based methods directly map input crowd images to scalar values of counts, hence bypassing explicit detection tasks. Particularly, a mapping between image features and the crowd count is learned. Typically the extracted features are used to generate low-level information, which is learned by a regression model. Hence, these methods leverage better feature extraction (if available) and regression algorithms for estimating counts (?; ?; ?; ?; ?). However, these regression-based methods mostly ignore the spatial information in the crowd images.

Density-based crowd counting, originally proposed in (?), preserves both the count and spatial distribution of the crowd, and have been shown effective at object counting in crowd scenes. In an object density map, the integral over any sub-region is the number of objects within the corresponding region in the image. Density-based methods are generally better at handling cases where objects are severely occluded by bypassing the hard detection of every object, while also maintaining some spatial information about the crowd. (?) proposes a method that learns a linear mapping between the image feature and the density map. (?) proposes learning a non-linear mapping using random forest regression. However, earlier approaches still depended on hand-crafted features.

Density-based crowd counting using CNN. In recent years, the CNN based methods with density targets have shown performances superior to the traditional methods based on handcrafted features (?; ?; ?). To address perspective issues, (?) leverages a multi-column network using convolution filters with different sizes in each column to generate the density map. As a different approach to address perspective issues, (?) proposes taking a pyramid of input patches into a network. (?) improves over (?) and uses a switching layer to classify the crowd into three classes depending on crowd density and to select one of 3 regressor networks for actual counting. (?) incorporates a multi-task objective, jointly estimating the density map and the total count by connecting fully convolutional networks and recurrent networks (LSTM). (?) uses global and local contexts to generate a high-quality density map. (?) introduces the dilated convolution to aggregate multi-scale contextual information and utilizes a much deeper architecture from VGG-16 (?). (?) proposes an encoder-decoder network with the encoder extracting multi-scale features with scale aggregation modules and the decoder generating density maps by using a set of transposed convolutions.

Limitations of the current state of the art: While density estimation and CNN based approaches have shown outstanding performances in the problems of crowd counting, less attention has been paid to assessing uncertainty in predictive outputs. Probabilistic interpretations via uncertainty quantification are important because (1) lack of understanding of model outputs may provide sub-optimal results and (2) neural networks are subject to overfitting, so making decisions based on point prediction alone may provide incorrect predictions with spuriously high confidence.

Uncertainty in Neural Networks

Much of the previous work on the Bayesian neural network studied uncertainty quantification founded on parametric Bayesian inference (?; ?). In this work, we consider a non-parametric bootstrap of functions.

Bootstrap ensemble

Bootstrap is a simple technique for producing a distribution over functions with theoretical guarantees (?). It is also general in terms of the class of models that we can accommodate. In its most common form, a bootstrap method takes as input a dataset $\mathcal{D}$ and a function $f_{\theta}$. We can transform the original dataset $\mathcal{D}$ into $K$ different datasets $\{\mathcal{D}_{k}\}_{k=1}^{K}$’s of cardinality equal to that of the original data $\mathcal{D}$ that is sampled uniformly with replacement.

Then we train $K$ different models. For each model $f_{\theta_{k}}$, we train the model on the dataset $\mathcal{D}_{k}$. So each of these models is trained on data from the same distribution but a different dataset. Then if we want to approximate sampling from the distribution of functions, we sample uniformly an integer $k$ from 1 to $K$ and use the corresponding function $f_{\theta_{k}}$.

In cases of using neural networks as base models $f_{\theta_{k}}$, bootstrap ensemble maintains a set of $K$ neural networks $\{f_{\theta_{k}}\}_{k=1}^{K}$ independently on $K$ different bootstrapped subsets of the data. It treats each network as independent samples from the weight distribution. In contrast to traditional Bayesian approaches discussed earlier, bootstrapping is a frequentist method, but with the use of the prior distribution, it could approximate the posterior in a simple manner. Also, it scales nicely to high-dimensional spaces, since it only requires point estimates of the weights. However, one major drawback is that computational load increase linearly with respect to the number of base models. In the following section, we discuss how to mitigate this issue and still maintain reasonable uncertainty estimates.

Measures of uncertainty

When we address uncertainty in predictive modeling, there are two major sources of uncertainty (?):

epistemic uncertainty is uncertainty due to our lack of knowledge; we are uncertain because we lack understanding. In terms of machine learning, this corresponds to a situation where our model parameters are poorly determined due to a lack of data, so our posterior over parameters is broad. 2. 2.

aleatoric uncertainty is due to genuine stochasticity in the data. In this situation, an uncertain prediction is the best possible prediction. This corresponds to noisy data; no matter how much data the model has seen, if there is inherent noise then the best prediction possible may be a high entropy one.

Note that whether we apply a Bayesian neural network framework or a bootstrap ensemble framework, the kind of uncertainty which is addressed by either of the methods is epistemic uncertainty only. Epistemic uncertainty is often called model uncertainty and it can be explained away given enough data (in theory as data size increases to infinity this uncertainty converges to zero). Addressing aleatoric uncertainty is also crucial for the crowd counting problem since many crowd images do possess inherent noise, occlusions, perspective distortions, etc. that regardless of how much data the model is trained on, there are certain aspects the model is not able to capture. Following (?), we incorporate both epistemic uncertainty and aleatoric uncertainty in a neural network for crowd counting. We discuss how we operationalize in a scalable manner in the following section.

Calibration of Predictive Uncertainty

Many methods for estimating predictive uncertainty often fail to capture the true distribution of the data (?). For example, a 95% posterior confidence interval may not contain the true outcome for 95% of the time. In such a case, the model is considered to be not calibrated (?). Bootstrap ensemble methods we consider in this work are also not immune to this issue. Hence, we address this by incorporating a technique recently introduced in (?), which calibrates any regression methods including neural networks. The proposed procedure is inspired by Platt scaling (?) which recalibrates the predictions of a pre-trained classifier in a post-processing step. (?) shows that the recalibration procedure applied to Bayesian models is guaranteed to produce calibrated uncertainty estimates given enough data.

Proposed Method

Single network with $K$ output heads

Training and maintaining several independent neural networks is computationally expensive especially when each base network is a large and deep neural network. To remedy this issue, we adopt a single network framework that is scalable for generating bootstrap samples from a large and deep neural network (?; ?). The network consists of a shared architecture — for example, convolution layers — with $K$ bootstrapped heads branching off independently. Each head is trained only on its bootstrapped sub-sample of the data as described in Section Bootstrap ensemble. The shared network learns a joint feature representation across all the data, which can provide significant computational advantages at the cost of lower diversity between heads. This type of bootstrap can be trained efficiently in a single forward/backward pass; it can be thought of as a data-dependent dropout, where the dropout mask for each head is fixed for each data point (?).

Capturing epistemic uncertainty

To capture epistemic uncertainty in a neural network, we put a prior distribution over its weights, for example a Gaussian prior: $[\theta_{s},\theta_{1},...,\theta_{K}]\sim\mathcal{N}(0,\tilde{\sigma}^{2})$, where $\theta_{s}$ is the parameter of the shared network and $\theta_{1},...,\theta_{K}$ are the parameters of bootstrap heads $1,..,K$. Let $x$ be an image input and $y$ be a density output. Without loss of generality, we define our pixel-wise likelihood as a Gaussian with mean given by the model output: $p\left(y|f_{\theta}(x)\right)=\mathcal{N}\left(f_{\theta}(x),\sigma^{2}\right)$, with an observation noise variance $\sigma^{2}$.

For brevity of notations we overload the term $\theta_{k}=[\theta_{k},\theta_{s}]$ since $\theta_{s}$ is shared across all samples. For each iteration of training procedure, we sample the model parameter $\hat{\theta}_{k}\sim q(\theta)$ where $q(\theta)$ is a bootstrap distribution. In other words, at each iteration we randomly choose which head to use to predict an output $\hat{y}=f_{\hat{\theta}_{k}}(x)$. Then the objective is to minimize the loss (for a single image $x$) given by the negative log-likelihood:

[TABLE]

where $y_{i}$ is the $i$-th pixel of the output density $y$ corresponding to input $x$ and $D$ is the number of output pixels. Note that the observation noise $\sigma^{2}$ which captures how much noise we have in the outputs stays constant for all data points. Hence we can further drop the second term (since it does not depend on $\theta$), but for the sake of consistency with the following section where we discuss a heteroscedastic setting, we leave it as is. Now, epistemic uncertainty can be captured by the predictive variance, which can be approximated as:

[TABLE]

with approximated mean: $\mathbb{E}(y)\approx\frac{1}{K}\sum_{k=1}^{K}f_{\hat{\theta}_{k}}(x)$. Note that during training procedure we randomly select one output head but during test time we combine individual predictions from $K$ heads to compute the predictive mean and the variance.

Incorporating aleatoric uncertainty

In contrast to homoscedastic settings where we assume the observation noise $\sigma^{2}$ is constant for all inputs, heteroscedastic regression assumes that $\sigma^{2}$ can vary with input $x$ (?; ?). This change can be useful in cases where parts of the observation space might have higher noise levels than others (?). In crowd counting applications, it is often the case that images may come from different cameras and scenes. Also due to occlusion and perspective issues within a single image, it is often the case that observation noise can vary from one part of an image (or pixel) to another part (or pixel).

Following (?), the network outputs both the estimated density map $y$ and the noise variance $\sigma^{2}$. Therefore, in our bootstrap implementation of the network, the output layer has a total of $K+1$ nodes — $K$ nodes corresponding to an ensemble of density map predictions $y$ and an extra node corresponding to $\sigma^{2}$. Let $\theta_{\sigma}$ be the parameter corresponding to the output node of the noise variance $\sigma^{2}$. Now, as before, we overload the term $\theta_{k}=[\theta_{k},\theta_{s},\theta_{\sigma}]$ since $\theta_{\sigma}$ is shared across the bootstrap sampling. We draw a sample of model parameters from the approximate posterior given by bootstrap ensemble $\hat{\theta}_{k}\sim q(\theta)$. But this time as described above, we have two parallel outputs, the density map estimate $\hat{y}$ and the noise variance estimate $\hat{\sigma}^{2}$:

[TABLE]

Then, we have the following loss given input image $x$ which we want to minimize:

[TABLE]

Note that this loss contains two parts: the least square residual term which depends on the model uncertainty (epistemic uncertainty) and an aleatoric uncertainty regularization term. Now, if the model predicts $\hat{\sigma}^{2}$ to be too high, then the residual term will not have much effect on updating the weights – the second term will dominate the loss. Hence, the model can learn to ignore the noisy data, but is penalized for that. In practice, due to the numerical stability of predicting $\sigma^{2}$ which should be positive, we predict the log variance $s_{i}:=\log\sigma^{2}$ instead of $\sigma^{2}$ for the output (?).

Network architecture

The network architecture is composed of three major components: (1) convolutional layers as the front-end for feature extraction, (2) a dilated convolutional for the back-end which uses dilated kernels to deliver larger reception fields and to replace pooling operations, and (3) the bootstrap ensemble output layer. For the front end, we use ResNet-50 (?) as backbone. Note that ResNet-50 is much deeper than VGG-16 but ResNet-50 (3.8B FLOPs) has much lower complexity than VGG-16 (15.3B FLOPs). For discussion on dilated convolution, we refer the readers to (?). For the output layer, we use the $K$ bootstrap ensemble heads for $\hat{y}$ and another output for $\hat{\sigma^{2}}$. Each output head in the bootstrap ensemble is a fully connected layer. We call our network DUBNet where “DUB” stands for decomposed uncertainty using bootstrap ensemble. The details of the architecture are shown in Figure 1.

Training procedure

We initialize the front-end layers (the first 10 convolutional layers) in our model with the corresponding part of a pre-trained ResNet-50 (?). For the rest of the parameters, we initialize with a Gaussian distribution with mean 0 and standard deviation 0.01. Given a training dataset of input images $X=\{x_{1},...,x_{N}\}$ and corresponding ground truth density maps $Y=\{y_{1},...,y_{N}\}$, at each iteration, we sample uniformly at random $k\in\{1,...,K\}$ to choose an output head $k$ and predict $[\hat{y}_{n},\hat{s}_{n}]=f_{\hat{\theta}_{k}}(x_{n})$ for $n$-th image as discussed in the previous sections. Algorithm 1 presents a single-image batch training procedure. $\hat{y}_{n,i}$ and $\hat{s}_{n,i}$ are the $i$-th pixel of the estimated density map and the log variance respectively corresponding to input image $x_{n}$. $D_{n}$ is the number of output pixels of $y_{n}$. Due to pooling operations, the number of output pixels is the same as the number of input pixels. Adam optimizer (?) with a learning rate of $10^{-5}$ is applied to train the model.

Recalibration of Predictive Uncertainty

Once we have a trained model $f_{\hat{\theta}}$, we compute the mean prediction $\mu(x_{n})=\frac{1}{K}\sum_{k}f_{\hat{\theta}_{k}}(x_{n})$ for an input image $x_{n}$. Note that $\mu(x_{n})$ is a density map. We sum over all pixels in $\mu(x_{n})$ to compute the predicted mean count $\bar{C}_{n}$. Similarly, using the (pixel-wise) predictive variance in Eq.(1), we compute the predictive standard deviation in counts $\bar{\sigma}_{n}$ by summing over all pixels. Then we construct a standardized residual $Z_{n}=(C_{n}-\bar{C}_{n})/\bar{\sigma}_{n}$ where $C_{n}$ is the ground-truth count for image $x_{n}$ and construct a quantile target $\hat{P}(Z_{n})$ which is the proportion of data whose standardized residual is below $Z_{n}$. Then using each pair $(Z_{n},\hat{P}(Z_{n}))$, we fit an isotonic regression model $\mathcal{R}$. The recalibration procedure is summarized in Algorithm 2.

Note that the recalibration dataset $\tilde{\mathcal{D}}$ is constructed using a validation data (non-training data) and the model $\mathcal{R}$ is fitted on this dataset. Once $\mathcal{R}$ is learned, for a given quantile $p$, (e.g. 0.95 and 0.05 for 90% confidence interval) one can easily find $Z^{p}\in\mathbb{R}$ such that $\mathcal{R}(Z^{p})\approx p$ (since $\mathcal{R}$ is a monotone function). When using at a test time where we only have $\bar{C}_{n}$ and $\bar{\sigma}_{n}$, we can construct a confidence bound by computing $\bar{C}_{n}+\bar{\sigma}_{n}Z^{p}$.

Experiments

In this section, we first introduce datasets and experiment details. We give the evaluation results and perform comparisons between the proposed method with recent state-of-the-art methods. For all experiments, we used $K=10$ heads for DUBNet. We follow the standard procedure to generate the ground truth density map using Gaussian kernels.

Evaluation metrics

For crowd counting evaluation, the count estimation error is measured by two metrics, Mean Absolute Error (MAE) and Root Mean Squared Error (RMSE), which are commonly used for quantitative comparison in previous works. They are defined as follows:

[TABLE]

where $N$ is the number of test samples, $C_{n}$ is the true crowd count for the $n$-th image sample and $\hat{C}_{n}$ is the corresponding estimated count. $C_{n}$ and $\hat{C}_{n}$ are given by the integration over the ground truth density map $\sum_{i}y_{n,i}$ and over an estimated density map $\sum_{i}\hat{y}_{n,i}$ respectively, where $i$ is the $i$-th pixel in output images. Note that during test time we use predictive mean over $K$ bootstrap outputs as $\hat{y}$.

Ablation study

We performed ablation studies on UCF-CC 50 and UCF-QNRF datasets to validate the efficacy of our proposed method. We first compare our proposed architecture DUBNet with its variant which does not have a bootstrap ensemble output and an aleatoric uncertainty output; hence has a single fully connected layer in the output layer. We call this variant ”DUBNet w/o DUB extension.”

To test the adaptability of our framework to other architecture, we applied the DUB extension to CSRNet (?) with branching outputs and an aleatoric uncertainty output. We also applied the same extension to MCNN (?). We compare with the vanilla CSRNet and MCNN respectively. The results in Table 1 show that our proposed framework combining both aleatoric and epistemic uncertainty contributes significantly to performance on the evaluation data, and can be applied to other architecture.

Performance comparisons

We evaluate our method on four publicly available crowd counting datasets: ShanghaiTech (?), UCF-CC 50 (?), and UCF-QNRF (?). For all datasets, we generate ground truth density maps with fixed spread Gaussian kernel. We compare our method with previously published work. In each table, the previous work which provided code or have been validated by a third party other than the original authors have been listed above our method. For completeness, we also list the recent work (without code or validation by a third party) below our method and include the numbers reported by the original authors. We highlight the best two performances in each metric.

ShanghaiTech. The ShanghaiTech dataset (?) contains 1198 annotated images with a total of 330,165 persons. This dataset consists of two parts: Part A which contains 482 images and Part B which contains 716 images. Part A is randomly collected from the Internet and contains mostly highly congested scenes. Part B contains images captured from street views with relatively sparse crowd scenes. We use the training and testing splits provided by the authors: 300 images for training and 182 images for testing in Part A; 400 images for training and 316 images for testing in Part B.

UCF-CC 50. The UCF-CC 50 dataset (?) is a small dataset which contains only 50 annotated crowd images. However, the challenging aspect of this dataset is that there is a large variation in crowd counts which range from 94 to 4543. Along with this variation, the limited number of images makes it a challenging dataset for the crowd counting tasks. Since training and test data split is not provided, as done in the previous literature (?; ?), We use 5-fold cross-validation to evaluate the performance of the proposed method.

UCF-QNRF. The UCF-QNRF dataset was recently introduced by (?). It is currently the largest crowd dataset which contains 1,535 images with dense crowds with many of them being high-resolution images. Approximately 1.25 million people were annotated with dot annotations These images come with a wider variety of scenes and contains the most diverse set of viewpoints, densities, and lighting variations. The ground truth counts of the images in the dataset range from 49 to 12,865. Meanwhile, the median and the mean counts are 425 and 815.4, respectively. The training dataset contains 1,201 images, with which we train our model. Some of the images are so high-resolution that we faced memory issues in GPU while training. Hence, we down-sampled images that contain more than 3 million pixels. Then, we test our model on the remaining 334 images in the test dataset.

Results

The results in Table 2 show that our proposed method is within the top two performers (highlighted in bold) for almost all the benchmark datasets we consider. One thing to note is that our uncertainty quantification framework is not limited to the proposed architecture, but is potentially adaptable to the other state of art architecture (as shown in the ablation study).

Estimated uncertainty validation

Estimated uncertainty is meaningful if it can capture the true distribution of the data. As mentioned earlier in the paper, we can validate whether the estimated uncertainty is well-calibrated or not by checking whether the estimated $p$ quantile confidence interval (CI) contains the true outcome $p$ fraction of the time. Table 3 shows the fraction of test data in each dataset whose ground truth falls in 90% CI.111UCF-CC 50 dataset is not included since the uncertainty recalibration is difficult to perform due to the limited data size. The results suggest that our estimated uncertainty is accurate.

Discussion on estimated uncertainty

Figure 2 visualize the samples along with estimated density maps and their epistemic and aleatoric uncertainty from test evaluations on the ShanghaiTech data and the UCF-QNRF data. The results demonstrate that the model is generally less confident (i.e. higher epistemic uncertainty) in dense crowd regions of the images, which is natural. There appears to be a certain level of a positive correlation between epistemic and aleatoric uncertainty which is expected – since the common issues in crowd images such as occlusion and perspective issues are typically correlated with higher crowd density, this can cause both epistemic and aleatoric uncertainty to be higher. But, we also observe a notable difference in the estimated measures of uncertainty in the samples. We observe that aleatoric uncertainty is more prominent in areas where the image itself has more noise (for example, lighting glare in the second image in Figure 2) and occlusions (right side along the horizontal centerline in the first image in Figure 2). We can observe that even in very crowded scenes, when occlusions and noise are less prominent, the estimated aleatoric uncertainty can be low – for example, the stadium image (the third image in Figure 2) shows very low aleatoric uncertainty over the entire image since there are rarely occlusions or perspective issues due to the stadium seating configuration.

Conclusion

In this paper, we present a scalable and effective framework that can incorporate uncertainty quantification in prediction for crowd counting. The main component of the framework is combining shared convolutional layers and bootstrap ensembles to quantify uncertainty which is decomposed into epistemic and aleatoric uncertainty. Our proposed framework is generic, independent of the architecture choices, and also easily adaptable to other CNN based crowd counting methods. The extensive experiments demonstrate that the proposed method, DUBNet, has the state-of-the-art level performance on all benchmark datasets considered, and produces calibrated and meaningful uncertainty estimates.

Appendix A CNN giga-pixel imagery for the 2017 U.S. Presidential inauguration

Earlier in the paper, we raised a question of how much we can trust predictions of a model, especially when we do not have labels or ground truth to verify the accuracy of the predictions. Now with uncertainty estimates at hand, we can present crowd counting predictions on new real world data. In the supplementary material, we show our results on CNN (Cable News Network) giga-pixel images which contains ultra high resolution (64,000 $\times$ 64,000 pixels) crowd images.

CNN released the giga-pixel images of the 2017 U.S. Presidential inauguration (?). The CNN giga-pixel images consist of the photos taken from 6 different viewing directions: left, front, right, up, back and down views as shown in Figure 3. Each viewing direction contains 15,625 (125 $\times$ 125) patches of 500 $\times$ 500 pixel images, which means that each viewing direction contains a total of approximately $3.9\times 10^{9}$ pixels (3.9 giga-pixels). Additionally, the zoomed out versions (with 7 different zoom levels) of the images are also included. However, in fact they are stitched images of the original high resolution images (not additional photos).

To the best of our knowledge, this is the largest high resolution crowd image dataset from a single event. We present crowd counting prediction results on these giga-pixel images using our proposed method, DUBNet. Clearly, the dataset does not contain the ground truth labels or aggregated counts. Hence, merely performing a point estimation of counts (or density maps) on these images is not sufficient. In the evaluations on the benchmark datasets we presented in the paper, DUBNet not only demonstrates the state of art performance in terms of counting accuracy but also presents an insightful uncertainty measures for its prediction. With this uncertainty estimates at hand, we can perform predictions and measure how confident we are in our predictions.

We observe that the majority of the crowd are captured in the three views: left, front and fright views. Hence, we present the results from these three views. We use a network that was trained on the UCF-QNRF dataset for prediction.

Note that while the method attempts to predict the count of the people present in the images, this is “not” about estimating a total number of attendees at the inauguration. We acknowledge that even if we could count accurately every person present in the image, that estimated number of people would be still smaller than the actual number of people who attended the inauguration since there are parts of the event that the giga-pixel images are not able to capture. For example, in Figure 5, a significant portion of the crowd is blocked from the view by the white temporary structure on which the camera operators are standing. We do not attempt any inference on what is not seen in the images.

While one could simply apply DUBNet (or any other neural network based crowd counting method) directly to the giga-pixel images with each single direction image collage being a one large image input, it would not be a good practice. That is because it is highly likely to encounter a memory issue due to the large size and also because the trained network has not seen a person in such a larger scale (for example, consider the pixel sizes of cameramen on the bottom left region of Figure 6). One can pass each image with a fixed zoom level as input to the network. The results using a different zoom level (but fixed throughout prediction) are shown in Table 4. The estimated counts are provided with the 90% confidence interval. Note that since the ground-truth density or counts do not exist, we used the calibration method validated on UCF-QNRF test dataset.222In order to compute an accurate estimate of confidence intervals, perhaps this is the minimal portion that a practitioner can provide labeled data if available. However, for the sake of completeness of our presentation without any ground truth labels provided, we proceed this way.

We observe that the estimated counts monotonically increase with the zoom level, which is expected, since the higher the zoom level (higher resolution) is the larger the number of pixels is. Furthermore, since output pixel values were trained to be non-negative (since the prediction output is a density map), it is highly likely that as zoom level increases, the counts will lead to a higher positive bias if we do not use any masking to filter areas that are not regions of interest (ROI). Consider Figure 6 for example. The majority of the images patches in this viewing direction may not include any person at all. ROI does not have to be a precise topology over crowd regions but rather rectangular partition that include at least a few people (not just body parts) would suffice. Clearly, the total estimated count for zoom level 7 is an overestimation — for example, one can easily point out that predicting more than 68,000 people in Figure 6 seems too high even at a first glance. Also, the estimated crowd counts for zoom level 3 seem too low. Then, does the right zoom level exist somewhere between 3 and 7? The answer is no. Table 4 shows that there is no single zoom level which works best for all viewing directions.

Therefore, we adaptively choose a zoom level given a region of an image. To be consistent with the training data (UCF-QNRF), we require each image patch size to be large enough (i.e. zoomed out enough) to have at least 20 people for a given region. Of course, we do not have the ground truth counts. Hence we use predicted counts to adjust the zoom level. If the threshold is not satisfied according to the predicted count, we zoom out, i.e. zoom level decreases and the image patch containing the region of interest grows. If the threshold is satisfied, then we use the lowest predictive variance to decide which zoom level for the region is optimal. By iteratively following the procedure, we form partitions over an image and report predicted counts (predicted density map) per each partition. The sample results are shown in Figures 4, 5, and 6. Each colored square in an image collage represents a sample partition chosen for particular regions. Their corresponding predictive density maps and uncertainty estimates are shown in each subplot.

We acknowledge the prediction on first sample partition (1) in Figure 4 is very challenging and perhaps the predicted count is an underestimation. However, we used zoom level 7 (the highest resolution) for this partition and can’t improve further. However, most of other partitions demonstrate plausible density outputs and count estimates. Table 5 report the aggregated count results over the partitions for each viewing direction with the corresponding confidence intervals. Again, in this analysis, we only report on what our method predicted based on what it sees and do not make any inference on what is not seen on the images.

Appendix B Discussions on Bayesian neural network

In this section we discuss the Bayesian neural network methods, and the justification for the use of bootstrap ensemble to approximate the posterior in this work. Let $\mathcal{D}=\{(\bm{x}_{i},\bm{y}_{i})\}^{N}_{i=1}$ be a collection of realizations of i.i.d random variables, where $\bm{x}_{i}$ is an image, $\bm{y}_{i}$ is a corresponding density map, and $N$ denotes the sample size. In Bayesian neural network framework, rather than thinking of the weights of the network as fixed parameters to be optimized over, it treats them as random variables, and so we place a prior distribution $p(\theta)$ over the weights of the network $\theta\in\theta$. This results in the posterior distribution

[TABLE]

While this formalization is simple, the learning is often challenging because calculating the posterior $p(\theta|\mathcal{D})$ requires an integration with respect to the entire parameter space $\Theta$ for which a closed form often does not exist. (?) proposed a Laplace approximation of the posterior. (?) introduced the Hamiltonian Monte Carlo, a Markov Chain Monte Carlo (MCMC) sampling approach using Hamiltonian dynamics, to learn Bayesian neural networks. This yields a principled set of posterior samples without direct calculation of the posterior but it is computationally prohibitive. Another Bayesian method is variational inference (?; ?; ?; ?) which approximates the posterior distribution by a tractable variational distribution $q_{\eta}(\theta)$ indexed by a variational parameter $\eta$. The optimal variational distribution is the closest distribution to the posterior among the pre-determined family $Q=\{q_{\eta}(\theta)\}$. The closeness is often measured by the Kullback-Leibler (KL) divergence between $q_{\eta}(\theta)$ and $p(\theta|\mathcal{D})$. While these Bayesian neural networks are the state of art at estimating predictive uncertainty, these require significant modifications to the training procedure and are computationally expensive compared to standard (non-Bayesian) neural networks

(?) proposed using Monte Carlo dropout to estimate predictive uncertainty by using dropout at test time. There has been work on approximate Bayesian interpretation of dropout (?; ?; ?). Specifically, (?) showed that Monte Carlo dropout is equivalent to a variational approximation in a Bayesian neural network. With this justification, they proposed a method to estimate predictive uncertainty through variational distribution. Monte Carlo dropout is relatively simple to implement leading to its popularity in practice. Interestingly, dropout may also be interpreted as ensemble model combination (?) where the predictions are averaged over an ensemble of neural networks. The ensemble interpretation seems more plausible particularly in the scenario where the dropout rates are not tuned based on the training data, since any sensible approximation to the true Bayesian posterior distribution has to depend on the training data. This interpretation motivates the investigation of ensembles as an alternative solution for estimating predictive uncertainty. Despite the simplicity of dropout implementation, we were not able to produce satisfying confidence interval for our crowd counting problem. Hence we consider a simple non-parametric bootstrap of functions which we discuss in Section Bootstrap ensemble.

Appendix C Ground truth generation

We generate the ground truth density maps by blurring the head annotations provided by the data. This blurring is done by applying a Gaussian kernel (which normalize to 1) to each of the heads in a given image. We use geometry-adaptive kernels (?) to vary the spread parameters of Gaussian depending on local crowd density. The geometry-adaptive kernel is given by:

[TABLE]

For each targeted object $z_{j}$ in the ground truth $\delta$, we use $\bar{d}_{j}$ to indicate the average distance of $k$ nearest neighbors. To generate the density map, we convolve $\delta(z-z_{j})$ with a Gaussian kernel with parameter $\sigma_{j}$ (standard deviation), where $z$ is the position of pixel in the image.

Appendix D Comparison on variability

Note that we do not have the ground truth uncertainty to evaluate the predictive uncertainty other than testing whether predictive uncertainty satisfies the definition of confidence interval discussed in Section Calibration of Predictive Uncertainty. While we recalibrate the estimated uncertainty, we perform a sanity check on the amount of variability of our proposed method before recalibration is applied. We compare our proposed framework with a full bootstrap ensemble, i.e. an ensemble of $K$ independent neural networks. Although hypothetically $K$ bootstrap ensembles can lead to $K$ identical models in the worst cases, due to the nature of highly non-linear objective in neural network parameter optimization along with random initialization, we should not be worried about this degenerate case. Note that the architectural setting of DUBNet has a minimal bootstrapping with each output head only branching out at the end of the network architecture, which achieves computational gains but could potentially limit this variability. Hence, we compare our method with a full bootstrap ensemble model which contains the $K$ full-size independent neural networks with each neural network being trained independently. We compute the average of estimated predictive variance on ShanghaiTech Part A and Part B test datasets. In Table 6, we report the predictive variance which is the sum of epistemic and aleatoric uncertainties before recalibration is applied. we observe that DUBNet shows slightly lower variance than the full bootstrap model, which is expected since the amount of the shared portion of the architecture is much higher for DUBNet. However, surprisingly the difference in variance is not much given the contrasting network sizes between the full bootstrap model and DUBNet. Most importantly, with recalibration procedure at hand, we can correct (amplify or shrink) the predictive variance to a suitable amount. Hence, the post-calibrated uncertainty for these two models are almost identical given the same validation dataset and the test dataset.

Appendix E Note on Inference Runtime

We tested the inference runtime of DUBNet compared to the DUBNet without the DUB extension (i.e., single branch 1-1 connected layer) to see how much computational increase the proposed bootstrap extension causes. The first set of tests were performed on a CPU with 2.3GHz quad-core Intel Core i5 (8GB RAM). Nvidia P100 GPU was used for the second set of the tests. Each test was performed on ShanghaiTech Part A test dataset. The test showed that the average additional cost is very minimal, with 2% increase on CPU and 0.5% increase on GPU (almost negligible). This makes sense since the output heads only cover the last layer. Also, note that for training since we sample one output node per epoch and update the weights accordingly, there is no additional computation cost per epoch. Hence, this supports our claim that the proposed method is a very efficient way of producing uncertainty estimate.