Defense Against Adversarial Images using Web-Scale Nearest-Neighbor Search

TL;DR

This paper proposes a defense against adversarial images by projecting them onto the image manifold using web-scale nearest-neighbor search, showing effectiveness against attacks without database access.

Contribution

It introduces a novel defense method using large-scale nearest-neighbor search to project images onto the manifold, and develops attack strategies to evaluate its robustness.

Findings

Effective defense against non-access adversarial attacks

Large image database improves robustness and accuracy

Trade-off exists between robustness and accuracy

Abstract

A plethora of recent work has shown that convolutional networks are not robust to adversarial images: images that are created by perturbing a sample from the data distribution as to maximize the loss on the perturbed example. In this work, we hypothesize that adversarial perturbations move the image away from the image manifold in the sense that there exists no physical process that could have produced the adversarial image. This hypothesis suggests that a successful defense mechanism against adversarial images should aim to project the images back onto the image manifold. We study such defense mechanisms, which approximate the projection onto the unknown image manifold by a nearest-neighbor search against a web-scale image database containing tens of billions of images. Empirical evaluations of this defense strategy on ImageNet suggest that it is very effective in attack settings in which the adversary does not have access to the image database. We also propose two novel attack methods to break nearest-neighbor defenses, and demonstrate conditions under which nearest-neighbor defense fails. We perform a series of ablation experiments, which suggest that there is a trade-off between robustness and accuracy in our defenses, that a large image database (with hundreds of millions of images) is crucial to get good performance, and that careful construction the image database is important to be robust against attacks tailored to circumvent our defenses.

Figures

Tables

Table 1. Table 1 : ImageNet classification accuracies of a ResNet-50 using our nearest-neighbor defense with three different weighting strategies (UW, CBW-E, and CBW-D) on PGD adversarial ImageNet images with a normalized ℓ 2 subscript ℓ 2 \ell_{2} distance of 0.06 0.06 0.06 . Nearest-neighbor searches were performed on three image databases (rows) with K = 50 𝐾 50 K\!=\!50 . Accuracies using KNN defense on clean images are included for reference.

Image database	Clean			Gray box			Black box
	UW	CBW-E	CBW-D	UW	CBW-E	CBW-D	UW	CBW-E	CBW-D
IG-50B-All (conv_5_1-RMAC)	0.632	0.644	0.676	0.395	0.411	0.427	0.448	0.459	0.491
IG-1B-Targeted (conv_5_1)	0.659	0.664	0.681	0.415	0.429	0.462	0.568	0.574	0.587
IN-1.3M (conv_5_1)	0.472	0.469	0.471	0.285	0.286	0.286	0.311	0.312	0.312

Table 2. Table 2: ImageNet classification accuracies of ResNet-50 models using state-of-the-art defense strategies against the PGD attack, using a normalized ℓ 2 subscript ℓ 2 \ell_{2} distance of 0.06 0.06 0.06 . ∗ RA-CNN  [ 39 ] experiments were performed using a ResNet-18 model.

Defense	Clean	Gray box	Black box
No defense	0.761	0.038	0.046
Crop ensemble [10]	0.652	0.456	0.512
TV Minimization [10]	0.635	0.338	0.597
Image quilting [10]	0.414	0.379	0.618
Ensemble training [35]	–	–	0.051
ALP [16]	0.557	0.279	0.348
RA-CNN [39]∗	0.609	0.259	–
Our Results
IG-50B-All (conv_5_1-RMAC)	0.676	0.427	0.491
IG-1B-Targeted (conv_5_1)	0.681	0.462	0.587
YFCC-100M (conv_5_1)	0.613	0.309	0.395
IN-1.3M (conv_5_1)	0.471	0.286	0.312

Table 3. Table 3 : Feature vector details. All features are finally compressed to a dimensionality of 256 by a PCA done over 3M samples.

Feature Layer	Uncompressed Size	Pooled Size
conv_2_3	$256\times 56\times 56$	$256\times 7\times 7$
conv_3_4	$512\times 28\times 28$	$512\times 7\times 7$
conv_4_6	$1024\times 14\times 14$	$1024\times 4\times 4$
conv_5_1	$2048\times 7\times 7$	$2048\times 1\times 1$

Table 4. Table 4 : ImageNet classification accuracies of ResNet-50 on PGD-generated images with a normalized ℓ 2 subscript ℓ 2 \ell_{2} distance of 0.06 0.06 0.06 , using our nearest-neighbor defenses with three different image databases on both soft and hard combination techniques, with three different weighing strategies (UW, CBW-E and CBW-D), and K = 50 𝐾 50 K\!=\!50 . Accuracies on clean images are included for reference.

Image database	Clean						Gray box						Black box
	Soft Combination			Hard Combination			Soft Combination			Hard Combination			Soft Combination			Hard Combination
	UW	CBW-E	CBW-D	UW	CBW-E	CBW-D	UW	CBW-E	CBW-D	UW	CBW-E	CBW-D	UW	CBW-E	CBW-D	UW	CBW-E	CBW-D
IG-50B-All (conv_5_1-RMAC)	0.632	0.644	0.676	0.637	0.642	0.649	0.395	0.411	0.427	0.402	0.403	0.414	0.448	0.459	0.491	0.457	0.462	0.473
IG-1B-Targeted (conv_5_1)	0.659	0.664	0.681	0.668	0.671	0.673	0.415	0.429	0.462	0.418	0.423	0.437	0.568	0.574	0.587	0.554	0.561	0.571
IN-1.3M (conv_5_1)	0.472	0.469	0.471	0.475	0.472	0.473	0.285	0.286	0.286	0.291	0.289	0.293	0.311	0.312	0.312	0.316	0.309	0.314

Equations

$${\mathbf{x}}^{\ast }=\underset{{\mathbf{x}}^{\prime }:\Delta (\mathbf{x},{\mathbf{x}}^{\prime })\le ϵ}{\mathrm{argmax}}L({\mathbf{x}}^{\prime },y;h).$$

$$\begin{gathered} {\mathbf{x}}^{(m)}={\mathbf{x}}^{(m-1)}+\epsilon \cdot \mathrm{sign}\left({\nabla }_{{\mathbf{x}}^{(m-1)}}L({\mathbf{x}}^{(m-1)},y)\right), \\ \text{where }{\mathbf{x}}_{\text{IFGSM}}^{\ast }={\mathbf{x}}^{(M)},\text{and }{\mathbf{x}}^{(0)}=\mathbf{x}. \end{gathered}$$

$$w=\left|\log C+\sum _{c=1}^C{s}_c\log s_c\right|.$$

$$w=\sum _{m=2}^{M+1}({\hat{s}}_1-{\hat{s}}_m{)}^P.$$

$$\mathbf{x}^{*}=\mathbf{x}+\varepsilon\cdot\operatorname{sign}\bigg{[}\nabla_{\mathbf{x}}L(h(\mathbf{x}),y)+\gamma\sum_{\mathbf{x}^{\prime}\in\widehat{\mathcal{D}}_{A,K}(\mathbf{x})}\nabla_{\mathbf{x}^{\prime}}L(h(\mathbf{x}^{\prime}),y)\bigg{]}.$$

$${\mathbf{x}}^{\ast }=\mathbf{x}+\epsilon \cdot \mathrm{sign}\left[\sum _{{\mathbf{x}}^{\prime }\in {\hat{\mathcal{D}}}_{A,K}(\mathbf{x})}{\nabla }_{{\mathbf{x}}^{\prime }}\Vert g({\mathbf{x}}^{\prime })-g(\mathbf{x}){\Vert }_2^2\right].$$

$${\mathbf{x}}_{\text{FGSM}}^{\ast }=\mathbf{x}+\epsilon \cdot \mathrm{sign}({\nabla }_{\mathbf{x}}L(\mathbf{x},y)),$$

$$\begin{gathered} {\mathbf{x}}^{(m)}={\mathbf{x}}^{(m-1)}+\epsilon \cdot \mathrm{sign}({\nabla }_{{\mathbf{x}}^{(m-1)}}L({\mathbf{x}}^{(m-1)},y), \\ \text{where }{\mathbf{x}}_{\text{IFGSM}}^{\ast }={\mathbf{x}}^{(M)},\text{and }{\mathbf{x}}^{(0)}=\mathbf{x} \end{gathered}$$

$$\mathbf{x}^{*}_{\textsf{CW-Lp}}=\min_{\mathbf{x}^{\prime}}\big{[}\lVert\mathbf{x}-\mathbf{x}^{\prime}\rVert_{p}^{2}+\lambda_{f}\max(-\kappa,Z(\mathbf{x}^{\prime})_{h(\mathbf{x})}\\ -\max\{Z(\mathbf{x}^{\prime})_{k}:k\neq h(\mathbf{x})\})\big{]}$$

Full text

1 Introduction

A range of recent studies has demonstrated that many modern machine-learning models are not robust to adversarial examples: examples that are intentionally designed to be misclassified by the models, whilst being nearly indistinguishable from regular examples in terms of some distance measure. Whilst adversarial examples have been constructed against speech recognition [3] and text classification [5] systems, most recent work on creating adversarial examples has focused on computer vision [2, 9, 17, 19, 21, 32], in which adversarial images are often perceptually indistinguishable from real images. Such adversarial images have successfully fooled systems for image classification [32], object detection [38], and semantic segmentation [6]. In practice, adversarial images are constructed by maximizing the loss of the machine-learning model (such as a convolutional network) with respect to the input image, starting from a “clean” image. This maximization creates an adversarial perturbation of the original image; the perturbation is generally constrained or regularized to have a small $\ell_{p}$-norm in order for the adversarial image to be perceptually (nearly) indistinguishable from the original.

Because of the way they are constructed, many adversarial images are different from natural images in that there exists no physical process by which the images could have been generated. Hence, if we view the set of all possible natural images111For simplicity, we ignore synthetic images such as drawings. as samples from a manifold that is embedded in image space, many adversarial perturbations may be considered as transformations that take a sample from the image manifold and move it away from that manifold. This hypothesis suggests an obvious approach for implementing defenses that aim to increase the robustness of machine-learning models against “off-manifold” adversarial images [24, 39]: viz., projecting the adversarial images onto the image manifold before using them as input into the model.

As the true image manifold is unknown, in this paper, we develop defenses that approximate the image manifold using a massive database of tens of billions of web images. Specifically, we approximate the projection of an adversarial example onto the image manifold by the finding nearest neighbors in the image database. Next, we classify the “projection” of the adversarial example, i.e., the identified nearest neighbor(s), rather than the adversarial example itself. Using modern techniques for distributed approximate nearest-neighbor search to make this strategy practical, we demonstrate the potential of our approach in ImageNet classification experiments. Our contributions are:

We demonstrate the feasibility of web-scale nearest-neighbor search as a defense mechanism against a variety of adversarial attacks in both gray-box and black-box attack settings, on an image database of an unprecedented scale ($\sim 50$ billion images). We achieve robustness comparable to prior state-of-the-art techniques in gray-box and black-box attack settings in which the adversary is unaware of the defense strategy. 2. 2.

To analyze the performance of our defenses in white-box settings in which the adversary has full knowledge of the defense technique used, we develop two novel attack strategies designed to break our nearest-neighbor defenses. Our experiments with these attacks show that our defenses break in pure white-box settings, but remain effective in attack settings in which the adversary has access to a comparatively small image database and the defense uses a web-scale image database, even when architecture and model parameters are available to the adversary.

We also conduct a range of ablation studies, which show that: (1) nearest-neighbor predictions based on earlier layers in a convolutional network are more robust to adversarial attacks and (2) the way in which the image database for nearest-neighbor search is constructed substantially influences the robustness of the resulting defense.

2 Related Work

After the initial discovery of adversarial examples [32], several adversarial attacks have been proposed that can change model predictions by altering the image using a perturbation with small $\ell_{2}$ or $\ell_{\infty}$ norm [2, 9, 17, 19, 21]. In particular, [19] proposed a general formulation of the fast gradient-sign method based on projected gradient descent (PGD), which is currently considered the strongest attack.

A variety of defense techniques have been studied that aim to increase adversarial robustness222See https://www.robust-ml.org/defenses/ for details.. Adversarial training [9, 12, 16, 17] refers to techniques that train the network with adversarial examples added to the training set. Defensive distillation [25, 22] tries to increase robustness to adversarial attacks by training models using model distillation. Input-transformation defenses try to remove adversarial perturbations from input images via JPEG compression, total variation minimization, or image quilting [4, 10]. Certifiable defense approaches [29, 27] aim to guarantee robustness under particular attack settings. Other studies have used out-of-distribution detection approaches to detect adversarial examples [18]. Akin to our approach, PixelDefend [30] and Defense-GAN [28] project adversarial images back onto the image manifold, but they do so using parametric density models rather than a non-parametric one.

Our work is most closely related to the nearest-neighbor defenses of [24, 39]. [39] augments the convolutional network with an off-the-shelf image retrieval system to mitigate the adverse effect of “off-manifold” adversarial examples, and uses local mixup to increase robustness to “on-manifold” adversarial examples. In particular, inputs are projected onto the feature-space convex hull formed by the retrieved neighbors using trainable projection weights; the feature-producing convolutional network and the projection weights are trained jointly. In contrast to [39], our approach does not involve alternative training procedures and we do not treat on-manifold adversarial images separately [8].

3 Problem Setup

We consider multi-class image classification of images $\mathbf{x}\in[0,1]^{H\times W}$ into one of $C$ classes. We assume we are given a labeled training set with $N$ examples, $\mathcal{D}=\left\{(\mathbf{x}_{1},y_{1}),...,(\mathbf{x}_{N},y_{N})\right\}$ with labels $y\in\mathbb{Z}_{C}$. Training a classification model amounts to selecting a hypothesis $h(\mathbf{x})\rightarrow\mathbb{Z}_{C}$ from some hypothesis set $\mathcal{H}$. The hypothesis set ${\mathcal{H}}$ is the set of all possible parameter values for a convolutional network architecture (such as a ResNet), and the hypothesis $h(\mathbf{x})$ is selected using empirical risk minimization: specifically, we minimize the sum of a loss function $L(\mathbf{x}_{n},y_{n};h)$ over all examples in $\mathcal{D}$ (we omit $h$ where it is obvious from the context). Throughout the paper, we choose $L(\cdot,\cdot;\cdot)$ to be the multi-class logistic loss.

3.1 Attack Model

Given the selected hypothesis (i.e., the model) $h\in\mathcal{H}$, the adversary aims to find an adversarial version $\mathbf{x}^{*}$ of a real example $\mathbf{x}$ for which: (1) $\mathbf{x}^{*}$ is similar to $\mathbf{x}$ under some distance measure and (2) the loss $L(h(\mathbf{x}^{*}),y)$ is large, i.e., the example $\mathbf{x}^{*}$ is likely to be misclassified. In this paper, we measure similarity between $\mathbf{x}^{*}$ and $\mathbf{x}$ by the normalized $\ell_{2}$ distance333Other choices for measuring similarity include the $\ell_{\infty}$ metric [37]., given by $\Delta(\mathbf{x},\mathbf{x}^{*})\!=\!\frac{\lVert\mathbf{x}-\mathbf{x}^{*}\rVert_{2}}{\lVert\mathbf{x}\rVert_{2}}$. Hence, the adversary’s goal is to find for some similarity threshold $\epsilon$:

[TABLE]

Adversarial attacks can be separated into three categories: (1) white-box attacks, where the adversary has access to both the model $h$ and the defense mechanism; (2) black-box attacks, where the adversary has no access to $h$ nor the defense mechanism; and (3) gray-box attacks in which the adversary has no direct access to $h$ but has partial information of the components that went into the construction of $h$, such as the training data $\mathcal{D}$, the hypothesis set $\mathcal{H}$, or a superset of the hypothesis set $\mathcal{H}$. While robustness against white-box adversarial attacks is desirable since it is the strongest notion of security [23], in real-world settings, we are often interested in robustness against gray-box attacks because it is rare for an adversary to have complete information (cf. white-box) or no information whatsoever (cf. black-box) on the model it is attacking [13].

3.2 Adversarial Attack Methods

The Iterative Fast Gradient Sign Method (I-FGSM) [17] generates adversarial examples by iteratively applying the following update for $m\!=\!\{1,...,M\}$ steps:

[TABLE]

When the model is available to the attacker (white-box setting), the attack can be run using the true gradient $\nabla_{\mathbf{x}}L(h(\mathbf{x}),y)$, however, in gray-box and black-box settings, the attacker has access to a surrogate gradient $\nabla_{\mathbf{x}}L(h^{\prime}(\mathbf{x}),y)$, which in practice, has been shown to be effective as well. The Projected Gradient Descent (PGD) [19] attack generalizes the I-FGSM attack by: (1) clipping the gradients to project them on the constraints formed by the similarity threshold and (2) including random restarts in the optimization process. Throughout the paper, we employ the PGD attack in our experiments because recent benchmark competitions suggest it is currently the strongest attack method.

In the appendix, we also show results with Fast Gradient Sign Method (FGSM) [9] and Carlini-Wagner’s $\ell_{p}$ (CW-Lp) [2] attack methods. For all the attack methods, we use the implementation of [10] and enforce that the image remains within $[0,1]^{H\times W}$ by clipping pixel values to lie between [math] and $1$.

4 Adversarial Defenses via Nearest Neighbors

The underlying assumption of our defense is that adversarial perturbations move the input image away from the image manifold. The goal of our defense is to project the images back onto the image manifold before classifying them. As the true image manifold is unknown, we use a sample approximation comprising a database of billions of natural images. When constructing this database, the images may be selected in a weakly-supervised fashion to match the target task, for instance, by including only images that are associated with labels or hashtags that are relevant to that task [20]. To “project” an image on the image manifold, we identify its $K$ nearest neighbors from the database by measuring Euclidean distances in some feature space. Modern implementations of approximate nearest neighbor search allow us to do this in milliseconds even when the database contains billions of images [14]. Next, we classify the “projected” adversarial example by classifying its nearest neighbors using our classification model and combining the resulting predictions. In practice, we pre-compute the classifications for all images in the image database and store them in a key-value map [7] to make prediction efficient.

We combine predictions by taking a weighted average of the softmax probability vector of all the nearest neighbors444In preliminary experiments, we also tried averaging “hard” rather than “soft” predictions but we did not find that to work better in practice.. The final class prediction is the $\arg\max$ of this average vector. We study three strategies for weighting the importance of each of the $K$ predictions in the overall average:

Uniform weighting (UW) assigns the same weight ($w\!=\!1/K$) to each of the predictions in the average.

We also experimented with two confidence-based weighting schemes that take into account the “confidence” that the classification model has in its prediction for a particular neighbor. This is important because, empirically, we observe that “spurious” neighbors exist that do not correspond to any of the classes under consideration, as displayed in Figure 2 (center row, fourth retrieved image). The entropy of the softmax distribution for such neighbors is very high, suggesting we should reduce their contribution to the overall average. We study two measures for compute the weight, $w$, associated with a neighbor: (1) an entropy-based measure, CBW-E(ntropy); and (2) a measure for diversity among the top-scoring classes, CBW-D(iversity).

CBW-E measures the entropy gap between a class prediction and the entropy of a uniform prediction. Hence, for softmax vector $\mathbf{s}$ over $C$ classes ($\forall c\in\{1,\dots,C\}:s_{c}\in[0,1]$ and $\sum_{c\in\{1,\dots,C\}}s_{c}=1$), the weight $w$ is given by:

[TABLE]

CBW-D computes $w$ as a function of the difference between the maximum value of the softmax distribution and the next top $M$ values. Specifically, let $\mathbf{\hat{s}}$ be the sorted (in descending order) version of the softmax vector $\mathbf{s}$. The weight $w$ is defined as:

[TABLE]

We tuned $M$ and $P$ using cross-validation in preliminary experiments, and set $M\!=\!20$ and $P\!=\!3$ in all experiments that we present in the paper.

5 Experiments: Gray and Black-Box Settings

To evaluate the effectiveness of our defense strategy, we performed a series of image-classification experiments on the ImageNet dataset. Following [16], we assume an adversary that uses the state-of-the-art PGD adversarial attack method (see Section 3.2) with $10$ iterations. In the appendix, we also present results obtained using other attack methods.

5.1 Experimental Setup

To perform image classification, we use ResNet-18 and ResNet-50 models [11] that were trained on the ImageNet training set. We consider two different attack settings: (1) a gray-box attack setting in which the model used to generate the adversarial images is the same as the image-classification model, viz. the ResNet-50; and (2) a black-box attack setting in which the adversarial images are generated using the ResNet-18 model and the prediction model is ResNet-50 (following [10]). We experiment with a number of different implementations of the nearest-neighbor search defense strategy by varying: (1) the image database that is queried by the defense and (2) the features that are used as basis for the nearest-neighbor search.

Image database. We experiment with three different web-scale image databases as the basis for our nearest-neighbor defense.

• •

IG-$N$-$\star$ refers to a database of $N$ public images with associated hashtags that is collected from a social media website, where $\star$ can take two different values. Specifically, IG-$N$-All comprises images that were selected at random. Following [20], IG-$N$-Targeted contains exclusively images that were tagged with at least one $1,500$ hashtags that match one of the $1,000$ classes in the ImageNet-1K benchmark. The $1,500$ hashtags were obtained by canonicalizing all synonyms corresponding to the synsets, which is why the dataset contains more hashtags than classes. Our largest database contains $N\!=$ 50 billion images.

• •

YFCC-100M is a publicly available dataset of 100 million Flickr images with associated meta-data [33].

• •

IN-1.3M refers to the training split of the publicly ImageNet-1K dataset of approximately 1.28M images.

Features. We constructed feature representations for the images in each of these image databases were constructed by: (1) computing pre-ReLU activations from the conv_2_3, conv_3_4, conv_4_6, or conv_5_1 layer of a ResNet-50 trained on ImageNet-1K and (2) reducing these feature representations to 256 dimensions using a spatial average pooling followed by PCA. For our largest database of 50 billion images, we used a feature representation that requires less storage: following [20], we use conv_5_1-RMAC features that were obtained by using conv_5_1 features from a ResNet-50 model followed by R-MAC pooling [34], bit quantization, and dimensionality reduction (see the appendix for details).

5.2 Results

Table 4 presents the classification accuracy of a ResNet-50 using our defense strategy on PGD adversarial ImageNet images with a normalized $\ell_{2}$ dissimilarity of $0.06$; the table presents results in both the gray-box and the black-box settings. The table presents results for both the uniform weighting (UW) and the confidence-based weighting (CBW-E and CBW-D) strategies, performing nearest-neighbor search in three different image databases using a value of $K\!=\!50$. The results presented in the table demonstrate the potential of large-scale nearest neighbors as a defense strategy: our best model achieves a top-1 accuracy of $46.2\%$ in the gray-box and of $58.7\%$ in the black-box setting. The results also show that CBW-D weighting consistently outperforms the other weighting schemes, and that the use of web-scale IG-$N$-* databases with billions of images leads to substantially more effective defenses than using the ImageNet training set.

Motivated by its strong performance in our initial experiments, we use the CBW-D strategy for all the ablation studies and analyses that we perform below.

How does the choice of $K$ influence the effectiveness of the defense?

The robustness555Recent work also proposed a nearest-neighbors algorithm that is claimed to be robust under adversarial perturbations [36]. We do not study that algorithm here because it does not scale to web-scale image datasets. of nearest-neighbor algorithms depends critically on the number of nearest neighbors, $K$ [36]. Motivated by this observation, we empirically analyze the effect of $K$ on the effectiveness of our defense. Figure 3 presents the classification accuracy of a ResNet-50 with CBW-D using conv_5_1 features as a function $K$; results are presented on two different databases, viz., IG-100M-Targeted (dashed lines) and IG-1B-Targeted (solid lines). The results in the figure reveal increasing $K$ appears to have a positive effect on classification accuracy for both databases, although the accuracy appears to saturate at $K\!=\!50$. Therefore, we use $K\!=\!50$ in the remainder of our experiments. The figure also shows that defenses based on the larger image database (1B images) consistently outperform those based on the smaller database (100M images).

How does the choice of features influence the effectiveness of the defense?

Figure 4 presents classification accuracies obtained using CBW-D defenses based on four different feature representations of the images in the IG-1B-Targeted database. The results presented in the figure show that using “later” features for the nearest-neighbor search generally provide better accuracies, but that “earlier” features are more robust (i.e., deteriorate less) in the perturbation norm regime we investigated. Earlier features presumably provide better robustness because they are less affected by the adversarial perturbation in the image, which induces only a small perturbation in those features. The downside of using early features is that they are more susceptible to non-semantic variations between the images, which is why the use of later features leads to higher classification accuracies. Motivated by these results, we use conv_5_1 features in the remainder of our experiments.

How does nearest-neighbor index size influence the effectiveness of the defense?

Next, we measured the effectiveness of our defense strategy as a function of the size of the image database used for nearest-neighbor searches. Figure 5 presents the effect of the image database size ($N$) on the classification accuracy for different attack strengths; experiments were performed on the IG-$N$-Targeted database. In line with earlier work [20, 31], the results suggest a log-linear relation between accuracy and database size: each time the database size is doubled, the classification accuracy increases by a fixed number of percentage points. This result appears to be consistent across a range of magnitudes of the adversarial perturbation.

How does selection of images in the index influence the effectiveness of the defense?

In Figure 5, we also investigate how important it is that the images in the database used for the CBW-D defense are semantically related to the (adversarial) images being classified, by comparing defenses based on the IG-$N$-All and IG-$N$-Targeted databases for varying index sizes. The results reveal that there is a positive effect of “engineering” the defense image database to match the task at hand: defenses based on IG-$N$-Targeted outperforms those based on IG-$N$-All by a margin of $1\%\!-\!4\%$ at the same database size.

5.3 Comparison with State-of-the-Art Defenses

In Table 2, we compare the effectiveness of our nearest-neighbor defense with that of other state-of-the-art defense strategies. Specifically, the table displays the classification accuracy on adversarial ImageNet images produced with PGD, using a normalized $\ell_{2}$ distance of $0.06$. The results in the table show that, despite its simplicity, our defense strategy is at least as effective as alternative approaches (including approaches that require re-training of the network). To the best of our knowledge, our defense strategy even outperforms the current state-of-the-art In the gray-box setting. In the black-box setting, image quilting [10] performs slightly better than our nearest-neighbor defense. Interestingly, image quilting is also a nearest-neighbor approach but it operates at the image patch level rather than at the image level.

6 Experiments: White-Box Setting

So far, we have benchmarked our adversarial defense technique against PGD attacks that are unaware of our defense strategies, i.e., we have considered gray-box and black-box attack settings. However, in real-world attack settings, we may expect adversaries to be aware of defense mechanism and tailor their attacks to circumvent the defenses. In this section, we study such a white-box setting by designing adversarial attacks that try to circumvent nearest-neighbor defenses, and we study the effectiveness of these novel attacks against our defense strategy.

6.1 Defense-Aware Attacks

We develop two defense-aware attacks in which the adversary uses nearest-neighbor search on a web-scale image database to simulate the defense. Whilst this “attack database” may be identical to the “defense database”, it is likely that the databases are not exactly the same in practice (if only, because the defender can randomize its defense database). We develop two defense-aware attacks:

Nearest-neighbor prediction attack (PGD-PR). Given an attack database $\widehat{\mathcal{D}}_{A}$ and a function $g(\mathbf{x})$ that the attacker uses to compute a feature representation for example $\mathbf{x}$, we first compute the corresponding set of $K$ nearest neighbors, $\widehat{\mathcal{D}}_{A,K}(g(\mathbf{x}))$. Subsequently, we add an extra loss term that maximizes the loss between those $K$ nearest neighbors and the model prediction when constructing the adversarial sample $\mathbf{x}^{*}$. Specifically, we perform PGD-like updates:

[TABLE]

Herein, the hyperparameter $\gamma$ trade off the loss suffered on the sample itself with the loss suffered on its nearest neighbors. We set $\gamma\!=\!0.05$ and $K\!=\!50$ in our paper. We perform an iterative PGD-like update using this objective function, where we fix the neighbor set beforehand.

Nearest-neighbor feature-space attack (PGD-FS). In contrast to the previous attack, this attack targets the feature space used for nearest-neighbor retrieval. Specifically, it attacks the feature extractor $g(\mathbf{x})$ directly by producing the adversarial sample $\mathbf{x}^{*}$ via PGD-like updates:

[TABLE]

6.2 Experiments

We perform experiments in which we evaluate the effectiveness of the PGD, the PGD-PR, and the PGD-FS attack. In all attacks, we follow [16] and set the number of attack iterations to $10$, we set $K\!=\!50$, and use conv_5_1 features to implement $g(\cdot)$.

We assume a pure white-box setting in which the adversary uses the defense image database (IG-1B-Targeted) as its attack database, and has access to both the ResNet-50 classification model and the feature-generating function $g(\cdot)$. Figure 6(a) shows the accuracy of a ResNet-50 using the CBW-D defense as a function of the attack strength for all three attacks. The results show that in this pure white-box setting, CBW-D only provides limited robustness against defense-aware attacks.

We perform ablation experiments for the PGD-FS attack to investigate the effect of: (1) the size of the attack image database and (2) the amount of overlap between the attack and defense databases. These ablation experiments emulate a gray-box attack scenario in which the attacker only has partial access to the image database used by the defender.

Effect of index size. We construct the attack databases of varying size by randomly selecting a subset from the 500M images in the defense index, and measure the accuracy of our models under PGD-FS attacks using these attack databases. Figure 6(b) displays accuracy as a function of attack database size, showing that the performance of our defense degrades as the size of attack database increases.

Effect of attack and defense index overlap. We fix the size of the defense and attack databases to 500M images, but we vary the percentage of images that is present in both databases. Figure 6(c) shows the accuracy of our models under PGD-FS attacks as a function of the intersection percentage. We observe that the accuracy of our defense degrades rapidly as the overlap between the attack and the defense database grows. However, our nearest-neighbor defense is effective when in the overlap between both databases is limited.

The experimental results show that nearest-neighbor defense strategies can be effective even when the adversary is aware of the defense strategy and adapts its attack accordingly, provided that the defender can perform some kind of “data obfuscation”. Such security-by-obfuscation is insecure in true white-box attack scenarios, but in real-world attack settings, it may be be practical because it is difficult for the adversary to obtain the same set of hundreds of millions of images that the defender has access to.

7 Discussion and Future Work

In this study, we have explored the feasibility of using defense strategies web-scale nearest-neighbor search to provide image-classification systems robustness against adversarial attacks. Our experiments show that, whilst such defenses are not effective in pure white-box attack scenarios, they do perform competitively in realistic gray-box settings in which the adversary knows the defense strategy used but cannot access the exact web-scale image database.

Qualitative analyses of the nearest neighbors of adversarial images show that the model predictions for these neighbors images are generally closely related to the true label of the adversarial image, even if the prediction is incorrect. On ImageNet, the prediction errors are often “fine-grained” [1]: for example, changing the label golden retriever into labrador. As a result, we believe that studies such as ours tend to overestimate the success rate of the adversary: if, for example, an attacker aims to perturb an objectionable image so that it can pass as benign, it often cannot get away with fine-grained changes to the model prediction. Randomly choosing a target class has been explored previously [1] and is a more realistic attack setting, since this attack setting is more likely to perturb predictions to a class that is semantically unrelated.

Our results provide the following avenues for future research. Specifically, they suggest that varying the depth of the network that constructs features for the nearest-neighbor search trades off adversarial robustness for accuracy on clean images: “early” features are more robust to attacks but work less well on clean images. This suggests future work should explore combinations of either features or nearest neighbors [24] at different depths. Future work should also investigate approaches that decrease the similarity between the feature-producing model and the image-classification model used in our approach, as well as train these networks using adversarial-training approaches such as adversarial logit pairing [16]. Other directions for future work include developing better strategies for selecting images to use in the image database, e.g., using supervision from hashtags or text queries associated with the images.

Acknowledgements. We thank Matthijs Douze, Jeff Johnson, Viswanath Sivakumar, Hervé Jegou, and Jake Zhao for many helpful discussions and code support, and Anish Athalye and Shibani Santurkar for their comments on an earlier draft of this paper.

Appendix A: Adversarial Attack Methods

Fast Gradient Sign Method (FGSM) [9] is one of the earliest attack techniques that has been demonstrated to successfully produce adversarial samples. The FGSM attack produces adversarial samples using the update rule:

[TABLE]

where $\mathbf{x}$ is the unperturbed input. When the model is available to the attacker (white-box setting), the attack can be run using the true gradient $\nabla_{\mathbf{x}}L(h(\mathbf{x}),y)$, however, in gray-box and black-box settings, the attacker may habe access to a surrogate gradient $\nabla_{\mathbf{x}}L(h^{\prime}(\mathbf{x}),y)$, which in practice, has been shown to be effective as well. A stronger version of this attack is the Iterative Fast Gradient Sign Method (I-FGSM) [17], where the adversarial input is generated by iteratively applying the FGS update over $m=\{1,...,M\}$ steps, following:

[TABLE]

A general version of the I-FGSM attack is the Projected Gradient Descent (PGD) [19] attack, which clips the gradients to project them back to the feasible image domain, and also includes random restarts in the optimization process. We use this attack over the I-FGSM attack due to its stronger nature. The FGSM, I-FGSM, and PGD attacks approximately minimize the Chebyshev distance between the input $\mathbf{x}$ and the generated adversarial sample $\mathbf{x}^{*}$. Carlini-Wagner’s $\ell_{p}$ (CW-Lp) attack attempts to find a solution to an unconstrained optimization problem that jointly penalizes a differentiable surrogate for the model accuracy along with a distance measure for regularization, such as the $\ell_{2}$ or $\ell_{\infty}$ distance.

[TABLE]

Herein, $\kappa$ denotes a margin parameter, and the parameter $\lambda_{f}$ relatively weighs the losses from the distance penalty and accuracy surrogate (hinge loss of predicting an incorrect class). The most common values for $p$ are $p\!=\!2$ and $p\!=\!\infty$; we use the implementation of [10] to implement FGSM, IFGSM, PGD, and CW-L2. For all the above attacks, we enforce that the image remains within $[0,1]^{d}$ by clipping values.

Appendix B: Feature Construction

To evaluate the trade-off between robustness and accuracy of neural network features at different depths (layers), we use features extracted from different layers of ResNet-50 models [11] as the basis for retrieving nearest neighbors. Since layers are very high-dimensional, we reduce the final dimensionality of the feature vectors to 256 by performing a spatial average pooling followed by PCA (see Table 3 for a complete description). We found that spatial average pooling step helps in increasing accuracy as well as the computational efficiency of PCA.

The features are extracted using the PyTorch [26] framework; we use the SciPy [15] implemention of online PCA for dimensionality reduction. The PCA was computed on 3 million randomly selected samplesfor the IG and YFCC datasets, and on the complete training set for ImageNet.

For nearest-neighbor matching, we construct a pipeline using the GPU implementation of the FAISS [14] library; we refer the readers to the original paper for more details about billion-scale fast similarity search.

Appendix C: Hard versus Soft

   Combination of Predictions

As discussed in the main paper, we evaluate both hard and soft prediction combinations, as described below:

Soft Combination (SC): We return the weighted average of the softmax probability vector of all the nearest neighbors. The predicted class is then the $\arg\max$ of this average vector. This corresponds to a “soft” combination of the model predictions over the data manifold.

Hard Combination (HC): In this case, each nearest neighbor votes for its “hard” predicted class with some weight. The final prediction is then taken as the most commonly predicted class.

In Table 4, we present the results of both these approaches with uniform weighing (UW) and confidence-based weighing (CBW). These results were obtained using the same experimental setup as described in the main paper.

Appendix D: Results with FGSM and CWL-2

Below, we present results that measure the effectiveness of our defense strategy against the FGSM and CWL-2 attacks. All experiments follow the same experimental setup as described in the main paper (but use a different attack method).

Effect of Number of Neighbors, $K$.

Figures 7 and 8 describe the effect of varying $K$ under FGSM and CWL-2 attacks. We observe similar trends as for the PGD attacks.

Effect of Image Database Size.

Figure 9 and 10 describe the effect of varying the index size under FGSM and CWL-2 attacks. We observe similar trends as for the PGD attacks.

Effect of Feature Space.

Figure 11 and 12 present classification accuracies obtained using CBW-D defenses based on four different feature representations of the images in the IG-1B-Targeted database, for the FGSM and CWL-2 attacks respectively. We observe a similar trend as in the case of PGD attacks.