Examining the Impact of Blur on Recognition by Convolutional Networks
State-of-the-art algorithms for many semantic visual tasks are based on the use of convolutional neural networks. These networks are commonly trained, and evaluated, on large annotated datasets of artifact-free high-quality images. In this paper, we investigate the effect of one such artifact that is quite common in natural capture settings: optical blur. We show that standard network models, trained only on high-quality images, suffer a significant degradation in performance when applied to those degraded by blur due to defocus, or subject or camera motion. We investigate the extent to which this degradation is due to the mismatch between training and input image statistics. Specifically, we find that fine-tuning a pre-trained model with blurred images added to the training set allows it to regain much of the lost accuracy. We also show that there is a fair amount of generalization between different degrees and types of blur, which implies that a single network model can be used robustly for recognition when the nature of the blur in the input is unknown. We find that this robustness arises as a result of these models learning to generate blur invariant representations in their hidden layers. Our findings provide useful insights towards developing vision systems that can perform reliably on real world images affected by blur.
Recent years have seen tremendous progress in the development of computer vision algorithms for semantic tasks such as image classification [9, 12, 23], object detection [8, 19], and semantic segmentation [2, 16], with most modern state-of-the-art methods based on convolutional neural networks. These methods owe much of their success to the availability of large image datasets [3, 6] with ground truth data collected through human annotation. To build datasets at such scales, researchers have had to rely on images freely shared by regular users. But there is significant potential for a disparity between the low-level statistics of images a vision algorithm receives as training input, and publicly shared photographs. This is because users tend to upload photographs, often selected from among multiple trials of capturing the same object, that are high-quality and free of artifacts—e.g. saturation, distortions, and motion and defocus blur. This is a concern since modern methods are not only trained, but also evaluated, on these datasets.
In this paper, we concentrate on blur, since it is likely to affect images taken even with a high-quality camera, especially in a setting where the user is not concerned about image quality (e.g., when the image is being taken for a vision application, rather than for photography), or when the image is being captured automatically by a device or robot. We are also motivated by the recent findings showing that modern image classification methods exhibit significantly lower accuracies when evaluated on blurred images [5, 20, 17, 4].
Our first contribution is a systematic examination of the effect of blur on the performance of convolutional neural networks for image recognition. We confirm that introduction of even a moderate blur hurts performance of networks trained on sharp images, and find that the resulting unreliable predictions are accompanied by underlying high-entropy class distributions (e.g., see Fig. 1). This can allow vision systems using such networks to account for the low confidence of their predictions (and, say, ask the user to take another image).
Our second contribution is the insight we offer into the mechanism by which blur causes such degradation, and a practical recipe for combating it. We demonstrate that much of performance drop under blur is a consequence of models being trained only on sharp images, and not due to an intrinsic absence of information in blurry images, or to a deficiency in the networks’ architectures. By fine-tuning with a mix of blurry and sharp images for only three epochs, we find that a network trained only on sharp images is able to recover most of its lost accuracy on blurry images. Interestingly, a model fine-tuned with a fairly diverse range of blurs performs almost on par with a network trained and evaluated on a single blur type (which in-turn performs worse on other blurs). This demonstrates the ability of the network to learn a level of blur invariance.
Our third contribution is our finding that fine-tuning for blur partially generalizes across different types of blur—networks fine-tuned on images blurred with complex camera shake kernels significantly improve performance on defocus and subject motion-blurred images. Finally, in addition to image classification, we find that these observations also largely carry over to the task of semantic segmentation, where fine-tuning with blur is able to improve accuracy in both identifying and localizing objects in blurred images.
Broadly, our findings reinforce the fact that convolutional neural networks are resilient—when presented with an out-of-distribution input, they are able to signal a low-confidence in their predictions, and are quickly able to adapt when provided with additional training data, without any modification in architecture. Moreover, our experiments provide insight for designing vision systems that need to make reliable predictions in a practical, non-idealized, setting, by reasoning with images that may be potentially degraded by an unknown blur kernel.
2 Background & Related Work
Blur is a degradation in image quality caused by camera sensor pixels averaging light from overlapping regions in the scene, typically due to defocus or motion in the capture interval. Often, an observed blurry image can be well-modeled as a convolution of a latent sharp image (i.e., the image that would have been captured in the absence of blur), and a blur kernel or point-spread-function 111The effective blur kernel can sometimes vary spatially across the image, e.g., due to depth variations for defocus blur, or rotational or out-of-plane subject and camera motion blur. In this work, we concentrate only on spatially uniform blur for ease of analysis, but it may be appropriate to expect a mix of blur kernels acting on an image in some settings.. In the case of defocus blur, this kernel is an image of the lens aperture (typically a disk) scaled by a factor proportional to the distance of the imaged object from the focal plane. For motion blur, it is the projection of the moving object or camera’s trajectory during the exposure interval. Both kinds of blur kernels are “low-pass” filters, i.e., they lead to a loss or attenuation of high-frequency image detail. Camera shake kernels exhibit more variability than defocus blur, and typically correspond to arbitrary 2D motion trajectories [13, 1].
Reversing the effect of blur to obtain a sharp image from a blurred observation is an ill-posed inverse problem, especially when the blur is unknown. Graphics and vision researchers have made significant progress on this problem across the last decade [7, 13, 15, 28]—including with recent neural network-based methods [1, 21, 22, 26]. Nevertheless, image deblurring remains a challenging and computationally expensive task. However, our goal in this paper is different. Instead of processing blurred images to recover sharp photographs for human consumption, we seek to understand, and ameliorate, the effect of using these images as input to algorithms for recognition.
Nearly all state-of-the-art computer vision algorithms for semantic visual tasks rely on the use of convolutional neural networks [2, 8, 9, 12, 16, 19, 23]. Critical to their success is the ability to train on large annotated datasets, like Imagenet  and Pascal VOC —both of which contain photographs downloaded from the photo sharing website flickr.com. Therefore, these datasets contain images that users—amateurs and professional photographers alike—have chosen to upload, and are consequently of high-quality with few artifacts.
Since standard recognition benchmarks perform their evaluation on held-out portions of the same dataset, the reported performance of state-of-the-art algorithms can at best be interpreted to accurately characterize their expected accuracy on similar high-quality image data. Evaluation of standard neural network-based methods for image classification on images degraded by Gaussian blur in [5, 20] shows a significant drop in classification accuracy due to blur. In concurrent work , Zhou et al. also discuss loss in accuracy caused by various image degradations (including blur), and include preliminary experiments that suggest that this can be overcome to some extent by fine-tuning the initial layers (of Alexnet ) on degraded data. Recent work has also considered on the effect of blur on networks trained for face recognition [10, 17, 4], while Ullman et al.  contrasted the drop in the accuracy of computational recognition to that of humans. Finally, Szegedy et al.  found that carefully optimized small-magnitude perturbations could cause network models to produce erroneous estimates. In contrast, our focus is on errors due to a naturally prevalent form of image degradation—blur.
In this paper, we conduct a more thorough examination of the degradation caused by blur to the performance of modern convolutional neural network models, and the extent to which this degradation can be remedied and network models made robust in the presence of variability in the degree and type of unknown blur in an input image. We find, perhaps surprisingly, that there is a fair bit of generalization across certain blur types—training with moderate blur improves performance on severely blurred images, training with either defocus and camera motion blur kernels improves performance on the other, but that there is limited generalization from radially symmetric defocus blur to oriented one-dimensional motion kernels.
We show that while precise knowledge of the blur in an image is helpful (we see a slight improvement when using a model trained with only that blur kernel), recognition with unknown blur can be made almost as robust by using models trained with a diverse set of kernels. This is surprising since in the context of deblurring, blind deconvolution is a much harder problem than deconvolution with a known kernel. We find that models trained with different blurs achieve robustness to variability in blur by computing blur-invariant features representations in its internal hidden layers. We also demonstrate that even when the kernel is known, deblurring the input image using state of the art method and then using the original classifier trained on sharp images is in fact inferior to the mixed-tuning regime we propose.
Therefore, we find that convolutional neural networks can succeed despite degradations in image quality from blur. This is consistent with such networks having been used quite successfully for the classification of very low-quality images, albeit on smaller benchmarks—e.g., CIFAR-100  that contains extremely low-resolution images of size . In this context, recently Peng et al.  explored the potential of jointly training with high-resolution images to boost performance on low-resolution inputs. Our work also demonstrates the success of neural networks in the face of lower image quality, with joint training with images of varying quality, to deal with degradation due to optical blur for large-scale visual recognition.
3 Imagenet Classification on Blurred Images using Pre-trained Network Models
We begin by evaluating the performance of a popular convolutional neural network model—VGG-16222The supplementary material includes results on ResNet , which exhibits similar performance degradation with blur. —on blurred versions of the Imagenet  standard 2012 validation set. This model was trained on the Imagenet training set that comprised of largely sharp, high-quality images. We generate the blurred versions of the validation set by convolution with a range of different blur kernels.
Note that  resize their input to one or more pre-determined scales (to match their smaller side to the scale value), and then compute class probability distributions by feeding this resized image to their network model. Since Imagenet contains images of various sizes, rather than blur the original images directly, we first resize the image to a fixed scale (384 in our experiments) and then convolve the result with the blur kernel. This ensures that the effective blur for a chosen kernel is consistent across images, irrespective of their original size. We quantize the blurred intensities to form 8-bit images, and feed these into the classification networks at different scales.
We report the performance VGG-16 network  for a diverse set of blur kernels (see Fig. 2) in Table 1. We consider disk kernels of different radii (that have a constant value within their radius, and zero outside) to simulate defocus blur, and with horizontal and vertical box kernels of single pixel width and different lengths that correspond to motion blur (for uniform linear motion). To simulate camera shake blur, we use the code from  to generate a set of 100 random kernels as splines representing arbitrary motion trajectories, with intensity variation along the trajectory. We generate these splines using a set of six control points on a grid, and center these to yield blur kernels. We blur each image in the validation set with a different kernel—chosen deterministically across different test settings. For completeness, we also report results on blurring with Gaussian kernels of different standard deviations considered in . All kernels are normalized to be unit sum, i.e., they have a “DC value” of one.
We use the original network model provided by the authors of , who reported best performance by applying the network at two scales—256 and 512—-where at each scale, the network (which has a receptive field of ) was applied in a fully-convolutional way on all crops (with the network’s natural stride of 32). The log-probabilities from all crops from all scales were then averaged. We adopt a similar methodology, but also apply the network at different individual scales—128, 256, and 512—as well as the suggested combination of 256 and 512. To apply the network at the scale of 128, which is smaller than the network’s receptive field, we zero-pad the pool5 activations before passing them to the first fully connected layer.
Table 1 shows a clear drop in performance with increasing degrees of blur, for all types of blur kernels. Interestingly, this drop is steeper for bigger kernels in cases when the larger scale of 512 is included—by itself, or in combination with 256. Re-scaling to a larger size also increases the effective blur kernel size in the input to the network, and these results suggest that the benefits of robustness to object scale variation—the original motivation for multi-scale evaluation—are outweighed by the increasing effect of blur for larger kernels. However, going to the lowest scale of 128 hurts performance (except for the largest kernel considered in our evaluation: Gaussian ), likely because it causes a mis-match between object sizes seen during training (which was done with scales 256 and 512).
Figure 1 shows an example of the performance drop between sharp and blurred (with an defocus kernel) versions of an image. While the true class was correctly identified as most likely with high probability in the sharp image, it is relegated to sixth place in the blurred version. Note however that the class probabilities for even the most likely class are much lower, and the distribution is closer to uniform with high entropy. This phenomenon is not specific to this example—in Table 2, we report the average entropy (and cross-entropy) values of the predicted class distributions across the entire validation set, for sharp images, and two levels of defocus blur. Looking at the “Original” column of the table (which also includes results from fine-tuning the network discussed later in Sec. 4), we see that the drop in accuracy in Table. 1 is consistently accompanied by a significant increase in entropy. Therefore, while the model makes inaccurate predictions when used on unexpectedly low-quality images (compared to its training set), it does so with low-confidence.
4 Robustness to Blur with Fine-tuning
Next, we investigate how much of the performance degradation seen in the previous section is simply due to a lack of blurred image samples in the training data. Other plausible explanations for this degradation include the possibility of a deficiency in the network architectures themselves (and not just their parameter values), or that blurred images simply lack the required semantically discriminative information needed to make accurate predictions. We largely rule out these possibilities by showing that fine-tuning the original VGG-16 for a small number of epochs on different combinations of sharp and blurred images nearly closes the performance gap caused by blur. We also explore the extent to which recognition can be made robust to variations in the type and degree of blur, by including different sets of blur kernels during fine-tuning.
We begin with the weights in the pre-trained model, and then fine-tune with two epochs at a learning rate of followed by one epoch at , with a momentum value of and a batch-size of 128. We construct our training batches from the official Imagenet-2012 training set, shuffling the set at the beginning of each epoch. We blur each image in the batch with a different selected kernel (or do not blur it at all) based on the chosen blur distribution. We resize the blurred image to either a fixed scale or a randomly selected scale, and take a random crop.
The original model was trained at multiple scales in order to build some degree of invariance to object scale . However, as described in the previous section, image re-scaling interacts with blur. Therefore, most of our experiments involve re-scaling the blurred training images to a fixed scale, with only one setting involving multiple scales. We try to build object scale invariance, by considering different scales prior to the application of blur. Remember in our testing regime, a specific blur kernel is defined with respect to a fixed scale (of 384). So, we randomly re-scale training images to values around that scale (356, 384, and 410 in our experiments), and then apply blur. We then re-scale this blurred image to the target scale for the network by a factor equal to the ratio between the target training scale and the canonical blur scale (i.e., 384). This achieves variation in object scale, while ensuring that in all training examples that were blurred with the same selected kernel and fed to the network at the same post-blur scale, the effective size of the blur kernel is consistent.
4.1 Fine-tuning with Different Blur Distributions
We begin by fixing the network scale at 256 (which yielded the best overall performance in Table 1), and run multiple fine-tuning experiments with different combinations of sharp and blurred images. We consider different sets of defocus blur kernels, as well as camera shake kernels. For camera shake, we fine tune with a mix of sharp images (20%) and those blurred with one of 10k camera shake kernels that are separate from, but generated with the same parameters as, those used for validation.
Table 3 reports the performance of these different fine-tuned networks on different versions of the Imagenet validation set—including the original sharp images, and versions blurred by different blur kernels. We find that after fine-tuning with a diverse range of defocus blurs—specifically, a uniform mix of sharp images and those blurred with defocus blur of radii 2,4,6, and 8—the VGG-16 network begins to perform significantly better on images degraded by both defocus and camera-shake blur, e.g., increasing Top-5 accuracy on the radius-8 defocus blurred images from (for the original model) to . Moreover, this comes at negligible cost to performance on sharp images, for which accuracy drops by less than a third of a percentage point. Indeed, fine-tuning with a mix of sharp images and only moderate (radius 4) defocus blur even leads to a slight improvement in sharp image accuracy, suggesting that moderate blurring can act as a form of data augmentation.
We see similar results when fine-tuning and testing on camera-shake blur. Interestingly, there appears to be a fair amount of generalization between blur types, with fine-tuning on defocus and camera-shake kernels significantly improving performance on the other. We also see generalization across degrees of defocus blur. Including examples of radius-4 blur along with sharp images also improves performance on radius-8 blur, and vice-versa. Fine-tuning on camera shake kernels improves performance on horizontal linear motion blur. However, fine-tuning on defocus kernels (and sharp images) alone seems to lead to a slight drop in accuracy on uniform motion blur. This is likely because images blurred with oriented motion kernels present significantly different statistics than defocus blur, with high-frequency attenuation being only along one direction in the former, and radially uniform in the latter.
We also see that if one has a-priori knowledge of the blur present in the input, there is some marginal improvement from using a network trained with a larger fraction of examples of that blur. However, the improvement is lower than the drop in performance for other blurs dropped from training. The most extreme example of this is when fine-tuning with all images blurred by the radius-8 defocus kernel, which severely degrades performance on sharp images and all other kinds of blur kernels.
Therefore, training with a diverse set of possible blurs appears to be the right strategy (at least at our chosen scale and range of blurs), unless one has an accurate estimate of the blur affecting the input. Figure 1 includes the updated predicted class-distributions for our sharp and blurred example-pair from the model fine-tuned on the uniform defocus blur set. We see the network now identifies the correct class in both the sharp and blurred version of the image, and indeed produces very similar class distributions for both. In addition to identifying the correct class in the blurred image, the network makes this prediction with higher confidence. We report the average entropy of the class distributions from the fine-tuned model in Table 2. Fine-tuning not only improves the network’s accuracy on blurred images, but also systematically increases its confidence in these predictions. Figure 3 includes more examples of sharp and blurred images, and the ability of different network models to correctly determine their class labels.
4.2 Fine-tuning for Different Scales
Our decision to use a single scale of 256 to conduct the above fine-tuning experiments was based on the poorer performance of the original VGG-16 model at larger scales. However, a natural question is whether this trend continues to hold after fine-tuning. Therefore, we also fine-tune the model (beginning with the original weights) at a scale of 512, keeping the blur distribution fixed to the uniform setting (i.e., with a mix of sharp images and blurred with kernels of radii 2-8). We then evaluate this model on the validation set, applying it at the 512 scale, and compare its performance to the 256-scale version in Table 4.
While fine-tuning also significantly improves accuracy on blurred images at the 512 scale in comparison to the original model, these values are measurably lower than those of the model fine-tuned and applied at scale 256. Also, this improvement comes at a greater cost to performance on sharp images, with accuracy dropping by nearly three percentage points compared to the original model. Thus, the relative advantage of smaller scales persists even after fine-tuning.
Next, we consider applying the network at both the 256 and 512 scales—this is the setting that achieves the highest accuracy on the sharp images with the original model. We test two versions of this approach. In the first, we fine-tune a single model on images randomly resized to one of these two scales (as was done for training the original model). As shown in Table 4, this model does better than the 512 scale model on both sharp blurred images, and slightly worse than the 256 scale model on blurred images.
In the second case, we apply separate networks at each scale for classification—using the models fine-tuned at only their respective scales. This approach finally catches up to the 256 scale fine-tuned model on blurred images, and actually outperforms it by half a percentage point on sharp images. This is likely because for sharp images, both scales participate in classification, while on blurred images, the 512-scale model outputs higher-entropy distributions causing the average to revert to the output of the 256-scale model. While the per-scale fine-tuning strategy does have slightly better overall performance (when considering both sharp and blurred images), this marginal improvement is unlikely to justify the additional memory requirement of storing two versions of the model for most applications.
4.3 Blur Invariance in Network Features
The reliable performance of the fine-tuned model on a wide range of blur sizes suggests that the network learns to be invariant to blur. Does the network achieve this invariance early on, at the level of low-level image features in its initial layers, or at a more semantic level later in the network? We attempt to answer this question by looking at the similarity in activations of different layers of both the original and fine-tuned VGG models, when they are applied on the sharp and blurred versions of the same image.
Specifically, we consider the feature maps at the output of the five pooling layers in the VGG-16 network. We convert the feature vector at every location into a binary string representing whether the each feature channel had a positive or zero response. In Fig. 4, we visualize Hamming distances between corresponding binary strings produced from a sharp and blurred (by radius-8 defocus blur) versions of the same example image (at scale 256), for the original VGG-16 model and the model fine-tuned on a mix of sharp and blurred (defocus radius 2-8) images. We find that the original model produces different activations on the sharp and blurred inputs, at all layers. In contrast, the fine-tuned model is able to achieve a reasonable amount of blur invariance, with low distances between sharp and blurred activations at the fifth (and to a lesser extent the fourth) pooling layer. Note that the disparity in activations in the initial layers of the network remains high. We believe this may be because the initial layers have too small a receptive field to be able to reason about blur, or because blur invariance is easier to achieve at a higher semantic level.
4.4 Comparison to Explicit Deblurring
An alternative strategy to deal with blurred images is to explicitly deblur the input prior to recognition. This involves two steps—estimating the blur kernel, and deconvolution. Since kernel estimation is challenging, we measure the best-case performance of this strategy by applying a state-of-the-art deconvolution method  with the true blur kernel. Table 5 reports results for using the original VGG-16 model on sharp, blurred, and then deblurred images, for the D8 defocus kernel—on a subset of the validation images. We see that deblurring (with knowledge of the blur kernel) also improves recognition accuracy, allowing the use of models trained only on sharp images. However, this comes at significant computational expense— takes roughly 4 minutes per images on a modern GPU.
Table 5 also reports the performance of fine-tuned models applied directly on blurred images, on the same validation subset. We consider both the model fine-tuned on only on the D8 kernel—which corresponds to knowing that the blur at test time will be D8, and matches the knowledge in the deblurring results—as well as the one fine-tuned on a mix of defocus blurs (sharp & D2,4,6,8)—which is more appropriate when the input blur isn’t known. We find that incorporating robustness to blur directly in the recognition model performs as well or better, while avoiding the computational expense of deconvolution.
|Original||Original on||Original on||FT-Mix on||FT-D8 on|
|on Sharp||Blurred (D8)||Deblurred||Blurred (D8)||Blurred (D8)|
5 Semantic Segmentation on Blurred Images
Next, we examine the effect of blur on convolutional neural network-based approaches to category-level semantic segmentation. Semantic segmentation is an especially interesting task in this context since it relies more on low-level image detail—that is attenuated by blur—to localize objects precisely at the pixel level.
We perform our experiments using the method from  on the VOC2012 benchmark . This method learns a per-pixel classifier for object class on top of a feature-vector constructed from concatenated activations from multiple layers of VGG-16. This classifier is trained in conjunction with fine-tuning of the VGG-16 layers (the network is first pre-trained on ImageNet classification). We begin by evaluating the effect of blur on model weights made available by the authors of , that was trained on (largely sharp) images in the VOC training set and from the COCO segmentation database . We only consider different degrees of defocus blurs in this case, and use a similar methodology as before for generating blurred versions of the VOC2012 validation images, i.e., after resizing to a fixed scale of 384. However, since  uses anisotropic scaling to create the input (distorting the aspect-ratio) to its network, we perform scaling by matching the geometric mean, instead of the minimum, of width and height to 384.
Table 6 reports values of the standard mean Intersection-over-Union (mIOU) metric on sharp and blurred versions of the VOC validation set. In order to separately evaluate the degradation in boundary localization, we also report a version of this metric computed only at locations within a four pixel distance of class boundaries. Like for classification, we note that the pre-trained model suffers significant degradation in the presence of blur. However, this degradation appears to affect both general accuracy and localization. We see examples of this in Fig. 5 where in one instance, the model is able to identify object classes correctly in the blurred image, but performs a poorer segmentation between the classes and the background than in the sharp version. In the other example, the network produces a fairly high-quality segmentation of the foreground from the blurred image, but mis-identifies its class.
Next, we evaluate the effect of fine-tuning the model with a mix of sharp and blurred images. We fine-tune only on the VOC training set, for six epochs at a learning rate of , and two at a rate of . The performance of this fine-tuned model is also reported in Table. 6. Like for image classification, we find that performance on blurred images improves with fine-tuning. Moreover, this improvement is seen in both general accuracy, as well as in regions close to boundaries. In the first example in Fig. 5, we see that the fine-tuned network improves its ability to localize class boundaries on the blurred input, and is able to switch to the correct class label in the second input.
However, in contrast to classification, we find that the gap between sharp and blurred image performance remains larger after fine-tuning, and the improvements at a greater cost to sharp image performance. We believe this is due to the fact that this task is fundamentally more affected by blur. It requires identifying and separating objects, and the smearing of intensities across object boundaries due to blur makes this separation harder.
State-of-the-art network models trained on high-quality image datasets make unreliable, albeit low-confidence, predictions when they encounter blur in their inputs. In this work, we found that much of this unreliability is due to an inability to generalize from their sharp training sets, and that fine-tuning these models for a relatively small number of epochs with blurred training examples significantly improves their performance on blurry inputs. Moreover, we showed that standard architectures are able to deal with a diverse range of blurs, by learning to produce internal representations that are invariant to blur.
Our analysis provides insights for building and deploying vision systems in real-world settings where blur may be present. More broadly, we expect our findings to be relevant for other forms of imaging non-idealities beyond blur. In future work, we plan to explore un-supervised ways of achieving robustness to image artifacts—e.g., when we have access to examples of distorted natural images, but not to a precise model for the distortion.
This work was partially supported by the NSF under award no. RI:1409837.
-  A. Chakrabarti. A neural approach to blind motion deblurring. In Proc. ECCV, 2016.
-  L.-C. Chen, G. Papandreou, I. Kokkinos, K. Murphy, and A. L. Yuille. Deeplab: Semantic image segmentation with deep convolutional nets, atrous convolution, and fully connected CRFs. In Proc. CVPR, 2016.
-  J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A Large-Scale Hierarchical Image Database. In Proc. CVPR, 2009.
-  C. Ding and D. Tao. Trunk-branch ensemble convolutional neural networks for video-based face recognition. arXiv preprint arXiv:1607.05427, 2016.
-  S. Dodge and L. Karam. Understanding how image quality affects deep neural networks. In Proc. International Conference on Quality of Multimedia Experience, 2016.
-  M. Everingham, L. V. Gool, C. K. I. Williams, J. Winn, and A. Zisserman. The PASCAL Visual Object Classes (VOC) Challenge. IJCV, 2010.
-  R. Fergus, B. Singh, A. Hertzmann, S. T. Roweis, and W. T. Freeman. Removing camera shake from a single photograph. SIGGRAPH, 2006.
-  R. Girshick, J. Donahue, T. Darrell, and J. Malik. Rich feature hierarchies for accurate object detection and semantic segmentation. In Proc. CVPR, 2014.
-  K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In Proc. CVPR, 2016.
-  S. Karahan, M. K. Yildirim, K. Kirtac, F. S. Rende, G. Butun, and H. K. Ekenel. How image degradations affect deep CNN-based face recognition? arXiv:1608.05246, 2016.
-  A. Krizhevsky and G. Hinton. Learning multiple layers of features from tiny images. 2009.
-  A. Krizhevsky, I. Sutskever, and G. E. Hinton. Imagenet classification with deep convolutional neural networks. In Proc. NIPS, 2012.
-  A. Levin, Y. Weiss, F. Durand, and W. T. Freeman. Understanding and evaluating blind deconvolution algorithms. In Proc. CVPR, 2009.
-  T.-Y. Lin, M. Maire, S. Belongie, J. Hays, P. Perona, D. Ramanan, P. Dollár, and C. L. Zitnick. Microsoft COCO: Common objects in context. In Proc. ECCV, 2014.
-  T. Michaeli and M. Irani. Blind deblurring using internal patch recurrence. In Proc. ECCV. 2014.
-  M. Mostajabi, P. Yadollahpour, and G. Shakhnarovich. Feedforward semantic segmentation with zoom-out features. In Proc. CVPR, 2015.
-  S. J. Oh, R. Benenson, M. Fritz, and B. Schiele. Faceless person recognition: Privacy implications in social media. In European Conference on Computer Vision, 2016.
-  X. Peng, J. Hoffman, S. X. Yu, and K. Saenko. Fine-to-coarse knowledge transfer for low-res image classification. In Proc. ICIP, 2016.
-  S. Ren, K. He, R. Girshick, and J. Sun. Faster R-CNN: Towards real-time object detection with region proposal networks. In Proc. NIPS, 2015.
-  B. RichardWebster, S. E. Anthony, and W. J. Scheirer. Psyphy: A psychophysics driven evaluation framework for visual recognition. arXiv preprint arXiv:1611.06448, 2016.
-  C. J. Schuler, H. C. Burger, S. Harmeling, and B. Scholkopf. A machine learning approach for non-blind image deconvolution. In Proc. CVPR, 2013.
-  C. J. Schuler, M. Hirsch, S. Harmeling, and B. Schölkopf. Learning to deblur. PAMI, 2014.
-  K. Simonyan and A. Zisserman. Very deep convolutional networks for large-scale image recognition. In Proc. ICLR, 2015.
-  C. Szegedy, W. Zaremba, I. Sutskever, J. Bruna, D. Erhan, I. Goodfellow, and R. Fergus. Intriguing properties of neural networks. In Proc. CVPR, 2014.
-  S. Ullman, L. Assif, E. Fetaya, and D. Harari. Atoms of recognition in human and computer vision. PNAS, 2016.
-  L. Xu, J. S. Ren, C. Liu, and J. Jia. Deep convolutional neural network for image deconvolution. In Proc. NIPS, 2014.
-  Y. Zhou, S. Song, and N.-M. Cheung. On classification of distorted images with deep convolutional neural networks. arXiv preprint arXiv:1701.01924, 2017.
-  D. Zoran and Y. Weiss. From learning models of natural image patches to whole image restoration. In Proc. ICCV, 2011.
Supplementary Results on ResNet-51
We also report classification results on blurred images with the more recent ResNet  architecture in Table A, considering various levels of defocus blur. We use the pre-trained model weights provided by the authors, and apply the network on five crops with two different scale settings: 256, and a combination of 256 and 512. We find that while the absolute accuracies of the ResNet model are slightly higher—for both sharp and blurred images—than for VGG-16, there is a similar drop in accuracy with increasing blur. This confirms that the drop in accuracy due to blur is not peculiar to the VGG-16 architecture.