SADA: Semantic Adversarial Diagnostic Attacks for Autonomous Applications

TL;DR

This paper introduces SADA, a framework for semantic adversarial attacks on autonomous agents, using BBGAN to generate environment perturbations that cause agents to fail across multiple navigation tasks.

Contribution

The paper presents BBGAN, a novel method for semantic adversarial attacks that manipulate environment parameters to fool autonomous agents, extending beyond pixel-level perturbations.

Findings

BBGAN successfully generates environment scenarios that cause agent failures.

The approach applies to diverse autonomous navigation tasks.

Semantic attacks outperform pixel-level attacks in robustness.

Abstract

One major factor impeding more widespread adoption of deep neural networks (DNNs) is their lack of robustness, which is essential for safety-critical applications such as autonomous driving. This has motivated much recent work on adversarial attacks for DNNs, which mostly focus on pixel-level perturbations void of semantic meaning. In contrast, we present a general framework for adversarial attacks on trained agents, which covers semantic perturbations to the environment of the agent performing the task as well as pixel-level attacks. To do this, we re-frame the adversarial attack problem as learning a distribution of parameters that always fools the agent. In the semantic case, our proposed adversary (denoted as BBGAN) is trained to sample parameters that describe the environment with which the black-box agent interacts, such that the agent performs its dedicated task poorly in this environment. We apply BBGAN on three different tasks, primarily targeting aspects of autonomous navigation: object detection, self-driving, and autonomous UAV racing. On these tasks, BBGAN can generate failure cases that consistently fool a trained agent.

Figures

Tables

Table 1. Table 1: Cases of Generic Adversarial Attacks : variable substitutions that lead to known attacks.

Attack Variables	Pixel Adversarial Attack on Image Classifiers	Semantic Adversarial Attack on Object Detectors	Semantic Adversarial Attack on Autonomous Agents
Agent $𝐀$	K-class classifier $𝐂:{[0,1]}^n\to [l_1,l_2,\dots ,l_K]$ $l_j$ : the softmax value for class $j$	K-class object detector $𝐅:{[0,1]}^n\to ({ℝ}^{N\times K},{ℝ}^{N\times 4})$ $N$ : number of detected objects	self-driving policy agent $𝐀$ e.g. network to regress controls
Parameters $𝝁$	the pixels noise added on attacked image ${𝐱}_i$	parameters describing the scene e.g. camera pose, object , light	parameters involved in the simulation e.g. road shape , weather , camera
Environment ${𝐄}_{𝝁}$	dataset $\Phi$ containing all images and their true class label $\Phi ={\left\{({𝐱}_i,y_i)\right\}}_{i=1}^{\left|\Phi \right|}$	dataset $\Phi$ containing all images and their true class label	simulation environment partially described by $𝝁$ that $𝐀$ navigates in for a target
Observation ${𝐨}_t$	attacked image after added noise = ${𝐱}_i+𝝁$, where $𝐱,𝝁\in {ℝ}^n$	the rendered image using the scene parameters $𝝁$	sequence of rendered images $𝐀$ observes during the simulation episode
Agent actions ${𝐚}_t\left({𝐨}_t\right)$	predicted softmax vector of attacked image	predicted confidence of the true class label	steering command to move the car/UAV in the next step
Score $Q(𝐀,{𝐄}_{𝝁})$	the difference between true and predicted softmax	predicted confidence of the true class label	the average sum of rewards over five different episodes

Table 2. Table 2: Attack Fooling Rate (AFR) Comparison: AFR of adversarial samples generated on three safety-critical applications: YOLOV3 object detection, self-driving, and UAV racing. For detection, we report the average AFR performance across all 12 classes and highlight 3 specific ones. For autonomous driving, we compute the AFR for the three common tasks in CARLA. For UAV racing, we compute AFR for race tracks of varying complexity (3, 4, or 5 anchor points describe the track). We see that our BBGAN outperforms all the baselines, and with larger margins for higher dimensional tasks ( e.g. detection). Due to the expensive computations and sequential nature of the Bayesian baseline, we omit it for the two autonomous navigation applications. Best results are in bold .

	Object Detection				Autonomous Driving			UAV Track Generation
	Bicycle	Motorbike	Truck	12-class avg	Straight	One Curve	Navigation	3 anchors	4 anchors	5 anchors
Full Set	14.6%	32.5%	56.8%	37.1 %	10.6%	19.5%	46.3%	17.0%	23.5%	15.8%
Random	13.3%	38.8%	73.8%	45.7%	8.0%	18.0%	48.0%	22.0%	30.0%	16.0%
Multi-Class SVM	20.0%	45.6%	70.8%	45.8%	96.0%	100%	100%	24.0%	30.0%	14.0%
GP Regression	17.6%	43.6%	83.6%	45.26%	100%	100%	100%	74.0%	94.0%	44.0%
Gaussian	19.6%	40.4%	72.4%	47.0%	54.0%	30.0%	64.0%	49.3%	56.0%	28.7%
GMM10%	26.0%	48.4%	75.2%	49.0%	90.0%	72.0%	98.0%	57.0%	63.0%	33.0%
GMM50%	16.4%	46.8%	72.0%	47.8%	92.0%	68.0%	100%	54.0%	60.0%	40.0%
Bayesian	48.0%	52.0%	75.6%	56.1%	-	-	-	-	-	-
BBGAN (vanilla)	44.0%	45.2%	90.8%	74.5%	100%	98.0%	98.0%	42.0%	94.0%	86.0%
BBGAN (boost)	65.8%	82.0%	100%	80.5%	100%	100%	100%	86.0%	98.0%	92.0%

Table 3. Table 3: Special Cases of Generic Adversarial attacks: summarizing all the variable substitutions to get common adversarial attacks.

	Substitutions of Special Cases of Adversarial Attacks
Generic Attack Variables	Pixel Adversarial Attack on Image Classifiers	Semantic Adversarial Attack on Object Detectors	Semantic Adversarial Attack on Autonomous Agents.
Agent $𝐀$	K-class classifier $𝐂:{[0,1]}^n\to [l_1,l_2,\dots ,l_K]$ $l_j$ : the softmax value for class $j$	K-class object detector $𝐅:{[0,1]}^n\to ({ℝ}^{N\times K},{ℝ}^{N\times 4})$ $N$ : number of detected objects	self-driving policy agent $𝐀$ e.g. network to regress controls
Parameters $𝝁$	the pixels noise added on attacked image	some semantic parameters describing the scene e.g. camera pose, object , light	some semantic parameters involved in the simulation e.g. road shape , weather , camera
Parameters Size $d$	$n$: the image dimension $n=h\times w\times c$	number of semantic parameters parameterizing ${𝐄}_{𝝁}$	number of semantic parameters parameterizing ${𝐄}_{𝝁}$
Environment ${𝐄}_{𝝁}$	dataset $\Phi$ containing all images and their true class label $\Phi ={\left\{({𝐱}_i,y_i)\right\}}_{i=1}^{\left|\Phi \right|}$	dataset $\Phi$ containing all images and their true class label	simulation environment partially described by $𝝁$ that $𝐀$ navigates in to reach
Parameters Range $[{𝝁}_{\text{min}},{𝝁}_{\text{max}}]$	$[-{𝐱}_{\text{min}},1-{𝐱}_{\text{max}}]$ ${𝐱}_{\text{min}},{𝐱}_{\text{max}}$ are the min and max of each pixel value in the image $𝐱$	${[-1,1]}^d$	${[-1,1]}^d$
Environment States ${𝐬}_t$	static environment ${𝐬}_t=\Phi$	static environment ${𝐬}_t=\Phi$	the state describing the simulation at time step $t$ e.g. the new position of car
Observation ${𝐨}_t$	the attacked image after adding fooling noise	the rendered image using the scene parameters $𝝁$	the sequence of rendered images the $𝐀$ observe during the simulation episode
Episode Size $T$	1	1	$t_{\text{stop}}\in \{1,2,3,\dots T_{\text{max}}\}$ $T_{\text{max}}$ : max allowed time $t_{\text{stop}}$ : step when success reached
Time step $t$	1	1	time step where agent $𝐀$ has to decide on action ${𝐚}_t$ given what it has observed ${𝐨}_t$
Fooling Threshold $ϵ$	0	fixed small fraction of 1 e.g. = 0.3	fixed small fraction of 1 e.g. = 0.6
Observation ${𝐨}_t$	attacked image after added noise = ${𝐱}_i+𝝁$, where $𝐱,𝝁\in {ℝ}^n$	the rendered image using the scene parameters $𝝁$	sequence of rendered images $𝐀$ observes during the simulation episode
Agent Actions ${𝐚}_t\left({𝐨}_t\right)$	predicted softmax vector of attacked image	predicted confidence of the true class label	steering command to move the car/UAV in the next step
Reward Functions $R({𝐬}_t,{𝐚}_t)$	the difference between true and predicted softmax	predicted confidence of the true class label	1 : if success state reached 0: if success not reached
Score $Q(𝐀,{𝐄}_{𝝁})$	the difference between true and predicted softmax	predicted confidence of the true class label	the average sum of rewards over five different episodes

Table 4. Table 4: Fooling rate of adversarial attacks on different classes of the augmented Pascal3D dataset. We sample 250 parameters after the training phase of each model and sample a shape from the intended class. We then render an image according to these parameters and run the YOLOV3 detector to obtain a confidence score of the intended class. If this score Q ≤ ϵ = 0.3 𝑄 italic-ϵ 0.3 \mathit{Q}\leq\epsilon=0.3 , then we consider the attack successful. The fooling rate is then recorded for that model, while 𝝁 std subscript 𝝁 std \boldsymbol{\mu}_{\text{std}} (the mean of standard deviations of each parameter dimensions) is recorded for each model. We report the average over all classes. This metric represents how varied the samples from the attacking distribution are.

	Adversarial Attack Fooling Rate across Different Classes
	aeroplane	bench	bicycle	boat	bottle	bus	car	chair	diningtable	motorbike	train	truck	avg	${\mu }_{std}$
Full Set	8.64%	35.2%	14.6%	33.4%	22.5%	53.1%	39.8%	44.1%	46.1%	32.5%	58.1%	56.8%	37.1 %	0.577
Random:	11.3%	42.7%	18.6%	41.8%	28.4%	65.7%	49.9%	55.3%	56.4%	40.3%	72.8%	70.8%	46.2%	0.584
Multi-Class SVM	12.0%	45.6%	20.0%	39.6%	26.0%	64.4%	49.6%	50.4%	53.6%	45.6%	72.0%	70.8%	45.8%	0.576
GP Regression	13.6%	15.6%	17.6%	41.2%	31.6%	71.6%	51.6%	48.0%	56.0%	43.6%	69.2%	83.6%	45.26%	0.492
Gaussian	11.2%	45.6%	19.6%	41.6%	31.2%	70.4%	48.0%	56.8%	55.6%	40.4%	71.2%	72.4%	47.0%	0.548
GMM10%	14.8%	45.2%	26.0%	42.8%	34.0%	67.2%	53.2%	56.4%	54.8%	48.4%	70.4%	75.2%	49.0%	0.567
GMM50%	12.0%	44.0%	16.4%	46.4%	33.2%	66.4%	51.6%	53.2%	58.4%	46.8%	73.6%	72%	47.8%	0.573
Bayesian	9.2%	42.0%	48.0%	68.8%	32.4%	91.6%	42.0%	75.6%	58.4%	52.0%	77.2%	75.6%	56.1%	0.540
BBGAN (ours)	13.2%	91.6%	44.0%	90.0%	54.4%	91.6%	81.6%	93.2%	99.2%	45.2%	99.2%	90.8%	74.5%	0.119
BBGAN (boost)	33%	82.4%	65.8%	78.8%	67.4%	100%	67.4%	100%	90.2%	82.0%	98.4%	100%	80.5%	0.100

Table 5. Table 5: Autonomous Driving (CARLA) and UAV Racing Track Generation (Sim4CV). Each method produces 50 samples and we show the fooling rate (FR) and the mean of the standard deviation per parameter. We set the fooling threshold to 0.6 and 0.7 for autonomous driving and racing track generation respectively.

	Straight		One Curve		Navigation		3 control points		4 control points		5 control points
	FR	${\mu }_{std}$	FR	${\mu }_{std}$	FR	${\mu }_{std}$	FR	${\mu }_{std}$	FR	${\mu }_{std}$	FR	${\mu }_{std}$
Full Set	10.6%	0.198	19.5%	0.596	46.3%	0.604	17.0%	0.607	23.5%	0.544	15.8%	0.578
Random	8.0%	0.194	18.0%	0.623	48.0%	0.572	22.0%	0.602	30.0%	0.550	16.0%	0.552
Multi-Class SVM	96.0%	0.089	100%	0.311	100%	0.517	24.0%	0.595	30.0%	0.510	14.0%	0.980
GP Regression	100%	0.014	100%	0.268	100%	0.700	74.0%	0.486	94.0%	0.492	44.0%	0.486
Gaussian	54.0%	0.087	30.0%	0.528	64.0%	0.439	49.3%	0.573	56.0%	0.448	28.7%	0.568
GMM10%	90.0%	0.131	72.0%	0.541	98.0%	0.571	57.0%	0.589	63.0%	0.460	33.0%	0.558
GMM50%	92.0%	0.122	68.0%	0.556	100%	0.559	54.0%	0.571	60.0%	0.478	40.0%	0.543
BBGAN (ours)	100%	0.048	98.0%	0.104	98.0%	0.137	42.0%	0.161	94.0%	0.134	86.0%	0.202
BBGAN (boost)	100%	0.014	100%	0.001	100%	0.058	86.0%	0.084	98.0%	0.030	92.0%	0.003

Table 6. Table 6: Case 1: view-point attack transferability: Attack Fooling Rate for sampled attacks on each scenario and transferred attacks from one scenario to another. Random attacks for each scenario are provided for reference.

original attacks			transferred attacks
scenario #	BBGAN	random	to scenario #	BBGAN	random
1	96.4%	70.4%	2	0.0%	26.0%
2	88.8%	26.0%	1	90.4%	70.4%
3	92.0%	53.2%	4	0.8%	10.4%
3	92.0%	53.2%	5	3.2%	13.2%
4	90.8%	10.4%	3	95.2%	53.2%
5	16.8%	13.2%	3	64.8%	53.2%

Table 7. Table 7: Case 2: occlusion attack transferability. Attack Fooling Rate for sampled attacks on each scenarios and also for transferred attacks from one scenario to another. Random attacks for each scenario are put for reference

original attacks			transferred attacks
scenario #	BBGAN	random	to scenario #	BBGAN	random
1	96.8%	58.0%	2	36.0%	32.4%
2	94.8%	32.4%	1	77.2%	58.0%
3	95.6%	52.0%	4	90.8%	37.2%
3	95.6%	52.0%	5	94.0%	39.6%
4	99.2%	37.2%	3	100.0%	52.0%
5	100.0%	39.6%	3	100.0%	52.0%

Equations

$${\mathbf{\mu }}^{\prime }\sim {\mathbf{P}}_{{\mathbf{\mu }}^{\prime }}\iff Q(\mathbf{A},{\mathbf{E}}_{{\mathbf{\mu }}^{\prime }})\le ϵ;{\mathbf{\mu }}^{\prime }\in [{\mathbf{\mu }}_{\text{min}},{\mathbf{\mu }}_{\text{max}}{]}^d$$

$$\underset{\mathbf{G}}{\mathrm{argmin}}{\mathbb{E}}_{\mathbf{\mu }\sim \mathbf{G}}[Q(\mathbf{A},{\mathbf{E}}_{\mathbf{\mu }})]$$

$$\text{s.t.}\{\mathbf{\mu }:\mathbf{\mu }\sim \mathbf{G}\}=\{{\mathbf{\mu }}^{\prime }:{\mathbf{\mu }}^{\prime }\sim {\mathbf{P}}_{{\mathbf{\mu }}^{\prime }}\}$$

$$\underset{{\mathbf{G}}_{\mathbf{x}}}{\min }\underset{{\mathbf{D}}_{\mathbf{x}}}{\max }{L}_{\text{GAN}}({\mathbf{G}}_{\mathbf{x}},{\mathbf{D}}_{\mathbf{x}},{\mathbf{P}}_X)=$$

$${\mathbb{E}}_{\mathbf{x}\sim p_x(\mathbf{x})}[\log {\mathbf{D}}_{\mathbf{x}}(\mathbf{x})]+{\mathbb{E}}_{\mathbf{z}\sim p_{\mathbf{z}}(\mathbf{z})}[\log (1-{\mathbf{D}}_{\mathbf{x}}({\mathbf{G}}_{\mathbf{x}}(\mathbf{z})))]$$

$$\underset{\mathbf{G}}{\mathrm{argmin}}{\mathbb{E}}_{\mathbf{\mu }\sim \mathbf{G}}[Q(\mathbf{A},{\mathbf{E}}_{\mathbf{\mu }})]$$

$$\text{s.t.}\{\mathbf{\mu }:\mathbf{\mu }\sim \mathbf{G}\}\subset \{{\mathbf{\mu }}^{\prime }:{\mathbf{\mu }}^{\prime }\sim {\mathbf{P}}_{{\mathbf{\mu }}^{\prime }}\}$$

$$\underset{{\mathbf{G}}_{\mathbf{\mu }}}{\min }\underset{{\mathbf{D}}_{\mathbf{\mu }}}{\max }{L}_{\text{BBGAN}}({\mathbf{G}}_{\mathbf{\mu }},{\mathbf{D}}_{\mathbf{\mu }},S_{{\mathbf{\mu }}^{\prime }})=$$

$${\mathbb{E}}_{\mathbf{\mu }\sim S_{{\mathbf{\mu }}^{\prime }}}[\log {\mathbf{D}}_{\mathbf{\mu }}(\mathbf{\mu })]+{\mathbb{E}}_{\mathbf{z}\sim p_{\mathbf{z}}(\mathbf{z})}[\log (1-\mathbf{D}(\mathbf{G}(z)))]$$

$$\underset{{\mathbf{G}}_{\mathbf{\mu }}}{\min }\underset{{\mathbf{D}}_{\mathbf{\mu }}}{\max }{L}_{\text{BBGAN}}({\mathbf{G}}_{\mathbf{\mu }},{\mathbf{D}}_{\mathbf{\mu }},S_{{\mathbf{\mu }}^{\prime }})=$$

$${\mathbb{E}}_{\mathbf{\mu }\sim S_{{\mathbf{\mu }}^{\prime }}}[\log {\mathbf{D}}_{\mathbf{\mu }}(\mathbf{\mu })]+{\mathbb{E}}_{\mathbf{z}\sim p_{\mathbf{z}}(\mathbf{z})}[\log (1-\mathbf{D}(\mathbf{G}(z)))]$$

$${\mathbf{\mu }}^{\prime }\sim {\mathbf{P}}_{{\mathbf{\mu }}^{\prime }}\iff Q(\mathbf{A},{\mathbf{E}}_{{\mathbf{\mu }}^{\prime }})\le ϵ;{\mathbf{\mu }}^{\prime }\in [{\mathbf{\mu }}_{\text{min}},{\mathbf{\mu }}_{\text{max}}{]}^d$$

$${\mathbf{\mu }}^{\ast }=\underset{\mathbf{\mu }}{\mathrm{argmin}}f(\mathbf{\mu })s.t.\mathbf{\mu }\in \Omega$$

$${\mathbf{\mu }}_N^{\text{best}}\in S_{{\mathbf{\mu }}^{\ast }}=\{{\mathbf{\mu }}^{\ast }\},asN\to \infty$$

$${\mathbf{\mu }}^{\ast }=$$

$$s.t.\mathbf{\mu }\in [{\mathbf{\mu }}_{\text{min}},{\mathbf{\mu }}_{\text{max}}]$$

$$Q(\mathbf{A},{\mathbf{E}}_{{\mathbf{\mu }}^{\ast }})\le ϵ;{\mathbf{\mu }}^{\ast }\in [{\mathbf{\mu }}_{\text{min}},{\mathbf{\mu }}_{\text{max}}{]}^d$$

$$S_{{\mathbf{\mu }}^{\ast }}=\{{\mathbf{\mu }}^{\ast }\}=\{{\mathbf{\mu }}^{\prime }:{\mathbf{\mu }}^{\prime }\sim {\mathbf{P}}_{{\mathbf{\mu }}^{\prime }}\}$$

$$\text{as}N\to \infty ,S_{{\mathbf{\mu }}^{\prime }}\to \{{\mathbf{\mu }}^{\prime }:{\mathbf{\mu }}^{\prime }\sim {\mathbf{P}}_{{\mathbf{\mu }}^{\prime }}\}$$

$$\underset{{\mathbf{G}}_{\mathbf{\mu }}}{\mathrm{argmin}}{\mathbb{E}}_{\mathbf{\mu }\sim \mathbf{G}}[Q(\mathbf{A},{\mathbf{E}}_{\mathbf{\mu }})]$$

$$\text{s.t.}\{\mathbf{\mu }:\mathbf{\mu }\sim {\mathbf{G}}_{\mathbf{\mu }}\}=\{{\mathbf{\mu }}^{\prime }:{\mathbf{\mu }}^{\prime }\sim {\mathbf{P}}_{{\mathbf{\mu }}^{\prime }}\}$$

$$l_{y_i}\le l_j,{\mathbf{x}}_i+\mathbf{\mu }\in [0,1{]}^n$$

$$\max \mathbf{C}(\mathbf{x})\le \underset{j\ne y}{\max }\mathbf{C}({\mathbf{x}}^{\prime }),{\mathbf{x}}^{\prime }\in [0,1{]}^n$$

$$\displaystyle\leavevmode\resizebox{422.77661pt}{}{ $\underset{\mathbf{x^{\prime}}\in[0,1]^{n}}{\min}\mathit{d}(\mathbf{x},\mathbf{x^{\prime}})~{}~{}\text{s.t.}~{}~{}\operatorname*{arg\,max}~{}\mathbf{C}(\mathbf{x})\neq\operatorname*{arg\,max}~{}\mathbf{C}(\mathbf{x^{\prime}})$}$$

$${\Omega }_0=\{{\mathbf{\mu }}_j\sim \text{Uniform}({\mathbf{\mu }}_{\text{min}},{\mathbf{\mu }}_{\text{max}}){\}}_{j=1}^N$$

$${\Omega }_k={\Omega }_{k-1}\cup \{{\mathbf{\mu }}_j\sim {\mathbf{G}}_{k-1}{\}}_{j=1}^{\lfloor \beta N\rfloor }$$

$${\mathbb{E}}_{{\mathbf{\mu }}_k\sim {\mathbf{G}}_k}[Q(\mathbf{A},{\mathbf{E}}_{{\mathbf{\mu }}_k})]\le {\mathbb{E}}_{{\mathbf{\mu }}_{k-1}\sim {\mathbf{G}}_{k-1}}[Q(\mathbf{A},{\mathbf{E}}_{{\mathbf{\mu }}_{k-1}})]$$

$$\underset{\mathbf{G}}{\mathrm{argmin}}{\mathbb{E}}_{\mathbf{\mu }\sim \mathbf{G}}[Q(\mathbf{A},{\mathbf{E}}_{\mathbf{\mu }})]$$

$$\text{s.t.}\{\mathbf{\mu }:\mathbf{\mu }\sim \mathbf{G}\}\subset \{{\mathbf{\mu }}^{\prime }:{\mathbf{\mu }}^{\prime }\sim {\mathbf{P}}_{{\mathbf{\mu }}^{\prime }}\}$$

$$\left|S_{\mathbf{\mu }}^k\right|=\lfloor \beta N\rfloor ,\forall k\in \{1,2,3,...\}$$

$$Q(S_{\mathbf{\mu }}^k)<Q({\mathbf{G}}_{k-1})$$

$${\mathbb{E}}_{{\mathbf{\mu }}_k\sim {\mathbf{G}}_k}[Q(\mathbf{A},{\mathbf{E}}_{{\mathbf{\mu }}_k})]=Q(S_{\mathbf{\mu }}^k)$$

$$Q(S_{\mathbf{\mu }}^k)\le Q({\mathbf{G}}_{k-1})$$

Full text

Introduction

As a result of recent advances in machine learning and computer vision, deep neural networks (DNNs) are now interleaved with many aspects of our daily lives. DNNs suggest news articles to read and movies to watch, automatically edit our photos and videos, and translate between hundreds of languages. They are also bound to disrupt transportation with autonomous driving slowly becoming a reality. While there are already impressive demos and some successful deployments, safety concerns for boundary conditions persist. While current models work very well on average, they struggle with robustness in certain cases.

Recent work in the adversarial attack literature shows how sensitive DNNs are to input noise. These attacks usually utilize the information about the network structure to perform gradient updates in order to derive targeted perturbations (coined white-box attacks). These perturbations are injected into the input image at the pixel-level, so as to either confuse the network or enforce a specific behavior (?; ?; ?; ?).

In practice, such pixel attacks are less likely to naturally occur than semantic attacks which include changes in camera viewpoint, lighting conditions, street layouts, etc. The literature on semantic attacks is much sparser, since they are much more subtle and difficult to analyze (?; ?). Yet, this type of attack is critical to understand/diagnose failure cases that might occur in the real-world. While it is very difficult to investigate semantic attacks on real data, we can leverage simulation as a proxy that can unearth useful insights transferable to the real-world. Figure 1 shows an example of an object misclassified by the YOLOV3 detector (?) applied to a rendered image from a virtual environment, an autonomous UAV racing (?) failure case in a recently developed general purpose simulator (Sim4CV (?)), and an autonomous driving failure case in a popular driving simulator (CARLA (?)). These failures arise from adversarial attacks on the semantic parameters of the environment.

In this work, we consider environments that are adequately photo-realistic and parameterized by a compact set of variables that have direct semantic meaning (e.g. camera viewpoint, lighting/weather conditions, road layout, etc. ). Since the generation process of these environments from their parameters is quite complicated and in general non-differentiable, we treat it as a black-box function that can be queried but not back-propagated through. We seek to learn an adversary that can produce fooling parameters to construct an environment where the agent (which is also a black-box) fails in its task. Unlike most adversarial attacks that generate sparse instances of failure, our proposed adversary provides a more comprehensive view on how an agent can fail; we learn the distribution of fooling parameters for a particular agent and task and then sample from it. Since Generative Adversarial Networks (GANs (?; ?)) have emerged as a promising family of unsupervised learning techniques that can model high-dimensional distributions, we model our adversary as a GAN, denoted as black-box GAN (BBGAN).

Contributions. (1) We formalize adversarial attacks in a more general setup to include both semantic and conventional pixel attacks. (2) We propose BBGAN in order to learn the underlying distribution of semantic adversarial attacks and show promising results on three different safety-critical applications used in autonomous navigation.

Related Work

Pixel-level Adversarial Attacks

Szegedy et al. formulate attacking neural networks as an optimization problem (?). Their method produces a minimal perturbation of the image pixels that fools a trained classifier (incorrect predictions). Several works followed the same approach but with different formulations, such as Fast Gradient Sign Method (FGSM) (?) and Projected Gradient Descent (?). A comprehensive study of different ways to fool networks with minimal pixel perturbation can be found in the paper (?). Most efforts use the gradients of the function to optimize the input, which might be difficult to obtain in some cases (?). However, all of these methods are limited to pixel perturbations to fool trained agents, while we consider more general cases of attacks, e.g. changes in camera viewpoint to fool a detector or change in weather conditions to fool a self-driving car. Furthermore, we are interested in the distribution of the semantic parameters that fool the agent, more so than individual fooling examples.

Semantic Attacks beyond Pixels

Beyond pixel perturbations, several recent works perform attacks on the object/camera pose to fool a classifier (?; ?; ?). Other works proposed attacks on 3D point clouds using Point-Net (?), and on 3D meshes using differentiable functions that describe the scene (?). Inspired by these excellent works, we extend semantic attacks by using readily available virtual environments with plausible 3D setups to systematically test trained agents. In fact, our formulation includes attacks not only on static agents like object detectors, but also agents that interact with dynamic environments, such as self-driving agents. To the best of our knowledge, this is the first work to introduce adversarial attacks in CARLA(?), a standard autonomous navigation benchmark.

Adversarial Attacks and Reinforcement Learning

Our generic formulation of adversarial attacks is naturally inspired by RL, in which agents can choose from multiple actions and receive partial rewards as they proceed in their task (?). In RL, the agent is subject to training in order to achieve a goal in the environment; the environment can be dynamic to train a more robust agent (?; ?; ?). However, in adversarial attacks, the agent is usually fixed and the adversary is the subject of the optimization in order to fool the agent. We formulate adversarial attacks in a general setup where the environment rewards an agent for some task. An adversary outside the environment is tasked to fool the agent by modifying the environment and receiving a score after each episode.

Methodology

Generalizing Adversarial Attacks

Extending attacks to general agents. In this work, we generalize the adversarial attack setup beyond pixel perturbations. Our more general setup (refer to Figure 2) includes semantic attacks, e.g. perturbing the camera pose or lighting conditions of the environment that generates observations (e.g. pixels in 2D images). An environment $\mathbf{E}_{\boldsymbol{\mu}}$ is parametrized by $\boldsymbol{\mu}\in[\boldsymbol{\mu}_{\text{min}},\boldsymbol{\mu}_{\text{max}}]^{d}$. It has an internal state $\mathbf{s}_{t}$ and produces observations $\mathbf{o}_{t}\in\mathbb{R}^{n}$ at each time step $t\in\{1,\ldots,T\}$. The environment interacts with a trained agent $\mathbf{A}$, which gets $\mathbf{o}_{t}$ from $\mathbf{E}_{\boldsymbol{\mu}}$ and produces actions $\mathbf{a}_{t}$. At each time step $t$ and after the agent performs $\mathbf{a}_{t}$, the internal state of the environment is updated: $\mathbf{s}_{t+1}=\mathbf{E}_{\boldsymbol{\mu}}(\mathbf{s}_{t},\mathbf{a}_{t})$. The environment rewards the agent with $r_{t}=\mathit{R(\mathbf{s}_{t},\mathbf{a}_{t})}$, for some reward function $\mathit{R}$. We define the episode score $\mathit{Q}(\mathbf{A},\mathbf{E}_{\boldsymbol{\mu}})=\sum_{t=1}^{T}r_{t}$ of all intermediate rewards. The goal of $\mathbf{A}$ is to complete a task by maximizing $\mathit{Q}$. The adversary $\mathbf{G}$ attacks the agent $\mathbf{A}$ by modifying the environment $\mathbf{E}_{\boldsymbol{\mu}}$ through its parameters $\boldsymbol{\mu}$ without access to $\mathbf{A}$ and $\mathbf{E}_{\boldsymbol{\mu}}$.

Distribution of Adversarial Attacks. We define $\mathbf{P}_{\boldsymbol{\mu^{\prime}}}$ to be the fooling distribution of semantic parameters $\boldsymbol{\mu^{\prime}}$ representing the environments $\mathbf{E}_{\boldsymbol{\mu}^{\prime}}$, which fool the agent $\mathbf{A}$.

[TABLE]

Here, $\epsilon$ is a task-specific threshold to determine success and failure of the agent $\mathbf{A}$. The distribution $\mathbf{P}_{\boldsymbol{\mu^{\prime}}}$ covers all samples that result in failure of $\mathbf{A}$. Its PDF is unstructured and depends on the complexity of the agent. We seek an adversary $\mathbf{G}$ that learns $\mathbf{P}_{\boldsymbol{\mu^{\prime}}}$, so it can be used to comprehensively analyze the weaknesses of $\mathbf{A}$. Unlike the common practice of finding adversarial examples (e.g. individual images), we address the attacks distribution-wise in a compact semantic parameter space. We denote our analysis technique as Semantic Adversarial Diagnostic Attack (SADA). Semantic because of the nature of the environment parameters and diagnostic because a fooling distribution is sought. We show later how this distribution can be used to reveal agents’ failure modes. We propose to optimize the following objective for the adversary $\mathbf{G}$ to achieve this challenging goal:

[TABLE]

Algorithm 1 describes a general setup for $\mathbf{G}$ to learn to generate fooling parameters. It also includes a mechanism for evaluating $\mathbf{G}$ in the black-box environment $\mathbf{E}_{\boldsymbol{\mu}}$ for $L$ iterations after training it to attack the agent $\mathbf{A}$. An attack is considered a fooling attack, if parameter $\boldsymbol{\mu}$ sampled from $\mathbf{G}$ achieves an episode score $\mathit{Q}(\mathbf{A},\mathbf{E}_{\boldsymbol{\mu}})\leq\epsilon$. Consequently, the Attack Fooling Rate (AFR) is defined as the rate at which samples from $\mathbf{G}$ are fooling attacks. In addition to AFR, the algorithm returns the set $S_{\boldsymbol{\mu^{\prime}}}$ of adversarial examples that can be used to diagnose the agent. The equality constraint in Eq (2) is very strict to include all fooling parameters $\boldsymbol{\mu^{\prime}}$ of the fooling distribution. It acts as a perceptuality metric in our generalized attack to prevent unrealistic attacks. Next, we relax this equality constraint to leverage recent advances in GANs for learning an estimate of the distribution $\mathbf{P}_{\boldsymbol{\mu^{\prime}}}$.

Black-Box Generative Adversarial Network

Generative Adversarial Networks (GANs) are a promising family of unsupervised techniques that can model complex domains, e.g. natural images (?; ?; ?). GANs consist of a discriminator $\mathbf{D}_{\mathbf{x}}$ and a generator $\mathbf{G}_{\mathbf{x}}$ that are adversarially trained to optimize the loss $\mathbf{\mathit{L}}_{GAN}(\mathbf{G}_{\mathbf{x}},\mathbf{D}_{\mathbf{x}},\mathbf{P}_{X})$, where $\mathbf{P}_{X}$ is the distribution of images in domain X and $\mathbf{z}\in\mathbb{R}^{c}$ is a latent random Gaussian vector.

[TABLE]

$\mathbf{D}_{\mathbf{x}}$ tries to determine if a given sample (e.g. image $\mathbf{x}$) is real (exists in the training dataset) or fake (generated by $\mathbf{G}_{\mathbf{x}}$). On the other hand, $\mathbf{G_{\mathbf{x}}}$ tries to generate samples that fool $\mathbf{D_{\mathbf{x}}}$ (e.g. misclassification). Both networks are proven to converge when $\mathbf{G_{\mathbf{x}}}$ can reliably produce the underlying distribution of the real samples (?).

We propose to learn the fooling distribution $\mathbf{P}_{\boldsymbol{\mu^{\prime}}}$ using a GAN setup, which we denote as black-box GAN (BBGAN). We follow a similar GAN objective but replace the image domain $\mathbf{x}$ by the semantic environment parameter $\boldsymbol{\mu}$. However, since we do not have direct access to $\mathbf{P}_{\boldsymbol{\mu^{\prime}}}$, we propose a module called the inducer, which is tasked to produce the induced set $S_{\boldsymbol{\mu^{\prime}}}$ that belongs to $\mathbf{P}_{\boldsymbol{\mu^{\prime}}}$. In essence, the inducer tries to choose a parameter set which represents the fooling distribution to be learnt by the BBGAN as well as possible. In practice, the inducer selects the best fooling parameters (based on the $Q$ scores of the agent under these parameters) from a set of randomly sampled parameters in order to construct this induced set. Thus, this setup relaxes Eq (2) to:

[TABLE]

So, the final BBGAN loss becomes:

[TABLE]

Here, $\mathbf{G}_{\boldsymbol{\mu}}$ is the generator acting as the adversary, and $\mathbf{z}\in\mathbb{R}^{m}$ is a random variable sampled from a normal distribution. A simple inducer can be just a filter that takes a uniformly sampled set $\Omega=\{\boldsymbol{\mu}_{i}\sim\text{Uni}([\boldsymbol{\mu}_{\text{min}},\boldsymbol{\mu}_{\text{max}}])\}_{i=1}^{i=N}$ and suggests the lowest $\mathit{Q}$-scoring $\boldsymbol{\mu}_{i}$ that satisfies the condition $\mathit{Q}(\boldsymbol{\mu}_{i})\leq\epsilon$. The selected samples constitute the induced set $S_{\boldsymbol{\mu^{\prime}}}$. The BBGAN treats the induced set as a training set, so the samples in $S_{\boldsymbol{\mu^{\prime}}}$ act as virtual samples from the fooling distribution $\mathbf{P}_{\boldsymbol{\mu^{\prime}}}$ that we want to learn. As the induced set size $S_{\boldsymbol{\mu^{\prime}}}$ increases, the BBGAN learns more of $\mathbf{P}_{\boldsymbol{\mu^{\prime}}}$. As $|S_{\boldsymbol{\mu^{\prime}}}|\rightarrow\infty,$ any sample from $S_{\boldsymbol{\mu^{\prime}}}$ is a sample of $\mathbf{P}_{\boldsymbol{\mu^{\prime}}}$ and the BBGAN in Eq (5) satisfies the strict condition in Eq (2). Consequently, sampling from $\mathbf{G}_{\boldsymbol{\mu}}$ would consistently fool agent $\mathbf{A}$. We show an empirical proof for this in the supplement and show how we consistently fool three different agents by samples from $\mathbf{G}_{\boldsymbol{\mu}}$ in the experiments. The number of samples needed for $S_{\boldsymbol{\mu^{\prime}}}$ to be representative of $\mathbf{P}_{\boldsymbol{\mu^{\prime}}}$ depends on the dimensionality $d$ of $\boldsymbol{\mu}$. Because of the black-box and stochastic nature of $\mathbf{E}_{\boldsymbol{\mu}}$ and $\mathbf{A}$ (similar to other RL environments), we follow the random sampling scheme common in RL (?) instead of deterministic gradient estimation. In the experiments, we compare our method against baselines that use different approaches to solve Eq (2).

Special Cases of Adversarial Attacks

One can show that the generic adversarial attack framework detailed above includes well-known types of attacks as special cases, summarized in Table 1. In fact, the general setup allows for static agents (e.g. classifiers and detectors) as well as dynamic agents (e.g. an autonomous agent acting in a dynamic environment). It also covers pixel-wise image perturbations, as well as, semantic attacks that try to fool the agent in a more realistic scenario. The generic attack also allows for a more flexible way to define the attack success based on an application-specific threshold $\epsilon$ and the agent score $\mathit{Q}$. In the supplement, we provide more details on the inclusiveness of our generic setup and how it covers original pixel-level adversarial attack objectives.

Applications

Object Detection

Object detection is one of the core perception tasks commonly used in autonomous navigation. Based on its suitability for autonomous applications, we choose the very fast, state-of-the-art YOLOv3 object detector (?) as the agent in our SADA framework. We use the open-source software Blender to construct a scene based on freely available 3D scenes and CAD models. We pick an urban scene with an open area to allow for different rendering setups. The scene includes one object of interest as well as a camera and main light source directed toward the center of the object. The light is a fixed strength spotlight located at a fixed distance from the object. The material of each object is semi-metallic, which is common for the classes under consideration. The 3D collection consists of 100 shapes of 12 object classes (aeroplane, bench, bicycle, boat, bottle, bus, car, chair, dining table, motorbike, train, truck) from Pascal-3D (?) and ShapeNet (?). At each iteration, one shape from the intended class is randomly picked and placed in the middle of the scene. The rendered image is then passed to YOLOV3 for detection. For the environment parameters, we use eight parameters that have shown to affect detection performance and frequently occur in real setups (refer to Figure 4).

Self-Driving

There is a lot of recent work in autonomous driving especially in the fields of robotics and computer vision (?; ?). In general, complete driving systems are very complex and difficult to analyze or simulate. By learning the underlying distribution of failure cases, our work provides a safe way to analyze the robustness of such a complete system. While our analysis is done in simulation only, we would like to highlight that sim-to-real transfer is a very active research field nowadays (?; ?). We use an autonomous driving agent (based on CIL (?)), which was trained on the environment $\mathbf{E}_{\mu}$ with default parameters. The driving-policy was trained end-to-end to predict car controls given an input image and is conditioned on high-level commands (e.g. turn right at the next intersection). The environment used is CARLA driving simulator (?), the most realistic open-source urban driving simulator currently available. We consider the three common tasks of driving in a straight line, completing one turn, and navigating between two random points. The score is measured as the average success of five pairs of start and end positions. Since experiments are time-consuming, we restrict ourselves to three parameters, two of which pertain to the mounted camera viewpoint and the third controls the appearance of the environment by changing the weather setting (e.g. ’clear noon’, ’clear sunset’, ’cloudy after rain’, etc.). As such, we construct an environment by randomly perturbing the position and rotation of the default camera along the z-axis and around the pitch axis respectively, and by picking one of the weather conditions. Intuitively, this helps measure the robustness of the driving policy to the camera position (e.g. deploying the same policy in a different vehicle) and to environmental conditions.

UAV Racing

In recent years, UAV (unmanned aerial vehicle) racing has emerged as a new sport where pilots compete in navigating small UAVs through race courses at high speeds. Since this is a very interesting research problem, it has also been picked up by the robotics and vision communities (?). We use a fixed agent to autonomously fly through each course and measure its success as percentage of gates passed (?). If the next gate was not reached within 10 seconds, we reset the agent at the last gate. We also record the time needed to complete the course. The agent uses a perception network that produces waypoints from image input and a PID controller to produce low-level controls. We use the general-purpose simulator for computer vision applications, Sim4CV (?). Here, we change the geometry of the race course environment rather than its appearance. We define three different race track templates with 3-5 2D anchor points, respectively. These points describe a second order B-spline and are perturbed to generate various race tracks populated by uniformly spaced gates. Please refer to the supplement for more details.

Experiments

BBGAN

Training. To learn the fooling distribution $\mathbf{P}_{\boldsymbol{\mu^{\prime}}}$, we train the BBGAN using a vanilla GAN model (?). Both, the generator $\mathbf{G}$ and the discriminator $\mathbf{D}$ consist of a MLP with 2 layers. We train the GAN following convention, but since we do not have access to the true distribution that we want to learn (i.e. real samples), we induce the set by randomly sampling $N$ parameter vector samples $\boldsymbol{\mu}$, and then picking the $s$ worst among them (according to the score $Q$). For object detection, we use $N=20000$ image renderings for each class (a total of 240K images). Due to the computational cost, our dataset for the autonomous navigation tasks comprises only $N=1000$ samples. For instance, to compute one data point in autonomous driving, we need to run a complete episode that requires 15 minutes. The induced set size is always fixed to be $s=100$.

Boosting. We use a boosting strategy to improve the performance of our BBGAN. Our boosting strategy simply utilizes the samples generated by the previous stage adversary $\mathbf{G}_{k-1}$ in inducing the training set for the current stage adversary $\mathbf{G}_{k}$. This is done by adding the generated samples to $\Omega$ before training $\mathbf{G}_{k}$. The intuition here is that the main computational burden in training the BBGAN is not the GAN training itself, but computing the agent episodes, each of which can take multiple hours for the case of self-driving. For more details, including the algorithm, a mathematical justification and more experimental results please refer to the supplement.

Testing, Evaluation, and Baselines

To highlight the merits of BBGAN, we seek to compare it against baseline methods, which also aim to estimate the fooling distribution $\mathbf{P}_{\boldsymbol{\mu^{\prime}}}$. In this comparative study, each method produces $M$ fooling/adversarial samples (250 for object detection and 100 for self-driving and UAV racing) based on its estimate of $\mathbf{P}_{\boldsymbol{\mu^{\prime}}}$. Then, the attack fooling rate (AFR) for each method is computed as the percentage of the $M$ adversarial samples that fooled the agent. To determine whether the agent is fooled, we use a fooling rate threshold $\epsilon=0.3$ (?), $\epsilon=0.6$, and $\epsilon=0.7$ for object detection, self-driving, and UAV racing, respectively. In the following, we briefly explain the baselines. Random. We uniformly sample random parameters $\boldsymbol{\mu}$ within an admissible range that is application dependent.

Gaussian Mixture Model (GMM). We fit a full covariance GMM of varying Gaussian components to estimate the distribution of the samples in the induced set $S_{\boldsymbol{\mu^{\prime}}}$. The variants are denoted as Gaussian (one component), GMM10% and GMM50% (number of components as percentage of the samples in the induced set).

Bayesian. We use the Expected Improvement (EI) Bayesian Optimization algorithm (?) to minimize the score $\mathit{Q}$ for the agent. The optimizer runs for 104 steps and it tends to gradually sample more around the global minimum of the function. We use the last $N=1000$ samples to generate the induced set $S_{\boldsymbol{\mu^{\prime}}}$ and then learn a GMM with different Gaussian components. Finally, we sample $M$ parameter vectors from the GMMs and report results for the best model.

Multi-Class SVM. We bin the score $Q$ into 5 equally sized bins and train a multi-class SVM classifier on the complete set $\Omega$ to predict the correct bin. We then randomly sample parameter vectors $\boldsymbol{\mu}$, classify them, and sort them by the predicted score. We pick $M$ samples with the lowest $Q$ score.

Gaussian Process Regression. Similar to the SVM case, we train a Gaussian Process Regressor (?) with an exponential kernel to regress the scores $Q$ from the corresponding $\boldsymbol{\mu}$ parameters that generated the environment on the dataset $\Omega$.

Results

Table 2 summarizes the AFR results for the aforementioned baselines and our BBGAN approach across all three applications. For object detection, we show 3 out of 12 classes and report the average across all classes. For autonomous driving, we report the results on all three driving tasks. For UAV racing, we report the results for three different track types, parameterized by an increasing number of 2D anchor points (3, 4 and 5) representing $\boldsymbol{\mu}$. Our results show that we consistently outperform the baselines, even the ones that were trained on the complete set $\Omega$ rather than the smaller induced set $S_{\boldsymbol{\mu^{\prime}}}$, such as the multi-class SVM and the GP regressor. While some baselines perform well on the autonomous driving application where $\boldsymbol{\mu}$ consists of only 3 parameters, our approach outperforms them by a large margin on the tasks with higher dimensional $\boldsymbol{\mu}$ (e.g. object detection and UAV racing with 5-anchor tracks). Our boosting strategy is very effective and improves results even further with diminishing returns for setups where the vanilla BBGAN already achieves a very high or even the maximum success rate.

To detect and prevent mode collapse, a GAN phenomenon where the generator collapses to generate a single point, we do the following. (1) We visualize the Nearest Neighbor (NN) of the generated parameters in the training set as in Figure 7. (2) We visualize the distributions of the generated samples and ensure their variety as in Figure 6. (3) We measure the average standard deviation per parameter dimension to make sure it is not zero. (4) We visualize the images/tracks created by these parameters as in Figure 5.

Analysis

Diagnosis. The usefulness of SADA lies in that it is not only an attacking scheme using BBGAN, but also serves as a diagnosis tool to assess the systematic failures of agents. We perform diagnostic studies (refer to Figure 6) to identify cases of systematic failure for the YOLOv3 detector.

Transferability. To demonstrate the transferability of the fooling parameter distribution to the real-world, we photograph toy models using a standard mobile phone camera and use office desk lights analogous the light source of the virtual environment. We orient the camera and the lighting source according to the fooling distribution learned from the virtual world. In Figure 6, we show a real-world photo of the toy car and the corresponding rendered virtual-world image, both of which are similarly fooled with the same erroneous class label. Please refer to the supplement for a similar analysis of other classes, the transfer of attacks between different CAD models and the effect of occlusion on detection.

Nearest Neighbor Visualization. In Figure 7, we visualize the NN in the parameter space for four different generated samples by our BBGAN. We see that the generated and the NN in training are different for the 4 samples with $L_{2}$ norm differences of (0.76,0.60,0.81,0.56) and (378,162,99,174) in parameter space and in image space respectively (all range from -1 to 1). This shows that our BBGAN can generate novel examples that fool the trained agent.

Insights and Future Work

Object Detection with YOLOV3. For most objects, top-rear or top-front views of the object tend to fool the YOLOV3 detector. The color of the object does not play a significant role in fooling the detector, but usually colors that are closer to the background color tend to be preferred by the BBGAN samples.

Self-Driving. Weather is the least important parameter for fooling the driving policy indicating that the policy was trained to be insensitive to this factor. Interestingly, the learned policy is very sensitive to slight perturbations in the camera pose (height and pitch), indicating a systemic weakness that should be ratified with more robust training.

UAV Autonomous Navigation. We observe that the UAV fails if the track has very sharp turns. This makes intuitive sense and the results that were produced by our BBGAN consistently produce such tracks. While the tracks that are only parameterized by three control points can not achieve sharp turns, our BBGAN is still able to make the UAV agent fail by placing the racing gates very close to each other, thereby increasing the probability of hitting them.

Future Work. Our work can be extended to other AI agents to test their semantic vulnerability to such attacks. This can be used to establish more interpretable deep models and allow for safety-tests for AI models before deployment in real world safety-critical applications.

Acknowledgments

This work was supported by the King Abdullah University of Science and Technology (KAUST) Office of Sponsored Research under Award No. RGC/3/3570-01-01.

Appendix A Empirical Justification for BBGAN

We want to show that as the size of the induced set $|S_{\boldsymbol{\mu^{\prime}}}|\rightarrow\infty$, learning an adversary according to the BBGAN objective in Eq (6) converges to the fooling distribution of semantic parameters $\mathbf{P}_{\boldsymbol{\mu^{\prime}}}$ defined in Eq (7).

[TABLE]

[TABLE]

Here, the agent $\mathbf{A}$ interacts with the environment $\mathbf{E}_{\boldsymbol{\mu}}$ and receives a score $\mathit{Q}$ for a given parameter $\boldsymbol{\mu}$. The fooling threshold is $\epsilon$.

Empirical Proof

We use the definition of Exhaustive Search (Algorithm 3.1) from the Audet and Hare book on derivative-free and black box optimization (?). In this algorithm, we try to optimize an objective $\mathit{f}:\mathbb{R}^{d}\rightarrow\mathbb{R}$ defined on a closed continuous global set $\Omega$ by densely sampling a countable subset $\mathit{S}=\{\boldsymbol{\mu}_{1},\boldsymbol{\mu}_{2},...,\boldsymbol{\mu}_{N}\}\subset\Omega$. Theorem 3.1 (?) states that as long as the exhaustive search continues infinitely from the set $\mathit{S}$, the global solutions of $\mathit{f}$ can be reached. Let’s assume the global solutions $\boldsymbol{\mu}^{*}$ of $\mathit{f}$ exists and defined as follows.

[TABLE]

Let’s denote the best solution reached up to the sample $\boldsymbol{\mu}_{N}$ to be $\boldsymbol{\mu}_{N}^{\text{best}}$ . If the set $S_{\boldsymbol{\mu}^{*}}$ is the set of all global solutions $\boldsymbol{\mu}^{*}$, then Theorem 3.1 (?) states that

[TABLE]

Now let $\mathit{f}(\boldsymbol{\mu})=\max(0,~{}\mathit{Q}(\mathbf{E}_{\boldsymbol{\mu}},\mathbf{A})-\epsilon)$ and let $\Omega=[\boldsymbol{\mu}_{\text{min}},\boldsymbol{\mu}_{\text{max}}]$, then the global solutions of the optimization:

[TABLE]

satisfy the two conditions in Eq (7) as follows.

[TABLE]

Hence, the set of all global solutions includes all the points in the fooling distribution:

[TABLE]

Therefore, as the sampling set size $|\mathit{S}|\rightarrow\infty$, all the points $\boldsymbol{\mu}$ that lead to $\mathit{Q}(\mathbf{E}_{\boldsymbol{\mu}},\mathbf{A})\leq\epsilon$, achieve the minimum objective in Eq (10) of zero and the set of best observed values $|\{\boldsymbol{\mu}_{N}^{\text{best}}\}|\rightarrow\infty$. This set is what we refer to as the induced set $S_{\boldsymbol{\mu^{\prime}}}$. From Eq (9) and Eq (12), we can infer that the induced set will include all fooling parameters as follows.

[TABLE]

Finally if the set $S_{\boldsymbol{\mu^{\prime}}}$ has converged to the distribution $\mathbf{P}_{\boldsymbol{\mu^{\prime}}}$ and we use $S_{\boldsymbol{\mu^{\prime}}}$ to train the BBGAN in Eq (6), then according to proposition 2 from the original GAN paper by Goodfellow et al. (?), the adversary $\mathbf{G}_{\boldsymbol{\mu}}$ has learnt the distribution $\mathbf{P}_{\boldsymbol{\mu^{\prime}}}$ and hence satisfies the following equation:

[TABLE]

This concludes our empirical proof for our BBGAN.

Appendix B Special Cases of Generic Adversarial attacks:

In Table 3, we summarize the substitutions in the generic adversarial attack to get different special cases of adversarial attacks. In summary, the generic adversarial attack allows for static agents (like classifiers and detectors) and dynamic agents (like an autonomous agent acting in a dynamic environment). It also covers the direct attack case of pixel perturbation on images to attack classifiers, as well as semantic attacks that try to fool the agent in a more realistic scenario (e.g. camera direction to fool a detector). The generic attack also allows for a more flexible way to define the attack success based on an application-specific threshold $\epsilon$ and the agent score $\mathit{Q}$. In the following we provide detailed explanation and mathematical meaning of the substitutions.

Pixel Adversarial Attack on Image Classifiers

Probably the most popular adversarial attack in the literature is a pixel-level perturbation to fool an image classifier. This attack can be thought of as a special case of our general formulation. In this case, the agent $\mathbf{A}$ is a classifier $\mathbf{C}:[0,1]^{n}\rightarrow[l_{1},l_{2},...,l_{K}]$ and the environment $\mathbf{E}_{\boldsymbol{\mu}}$ is a dataset containing the set $\Phi$ of all images in the classification dataset along with their respective ground truth labels, i.e. $\{(\mathbf{x}_{i},y_{i})\}_{i=1}^{|\Phi|}$ and $y_{i}\in\{1,\ldots,K\}$. The softmax value of the true class is given by $l_{y_{i}}=\max\mathbf{C}(\mathbf{x}_{i})$. Parameter $\boldsymbol{\mu}$ defines the fooling noise to be added to the images (i.e. $d=n$). The observation is simply an image from $\Phi$ with noise added: $\mathbf{o_{t}}=\mathbf{x}_{i}+\boldsymbol{\mu}$ for some $i\in\{1,2,..,|\Phi|\}$. In classification, the environment is static with $T=1$. To ensure the resulting image is in the admissible range, the noise added $\boldsymbol{\mu}$ should fall in the range $[-\mathbf{x}_{i,\text{min}},1-\mathbf{x}_{i,\text{max}}]$, where $\mathbf{x}_{i,\text{min}},\mathbf{x}_{i,\text{max}}$ are the min and max pixel value for the image $\mathbf{x}_{i}$. The sole action $\mathbf{a}_{1}$ is simply the softmax score of the highest scoring class label predicted by $\mathbf{C}$ that is not the true class $y_{i}$. Formally, $\mathbf{a}_{1}=\max_{j\neq y_{i}}\mathbf{C}(\mathbf{x}_{i}+\boldsymbol{\mu})=l_{j}$. The reward function is $\mathit{R}(\mathbf{s}_{1},\mathbf{a}_{1})=\mathit{Q}(\mathbf{C},\Phi)=\max(l_{y_{i}}-l_{j},0)$. Here, $\epsilon=0$ for the classifier fooling to occur , which means fooling occurs if $l_{y_{i}}-l_{j}\leq 0$. Using these substitutions in the hard constraint in Eq (7) translates to the following constraints on the perturbed image.

[TABLE]

For a single image attack, we can rewrite Eq (15) as follows:

[TABLE]

We observe that the constraints in Eq (16) become the following constraints of the original adversarial pixel attack formulation on a classifier $\mathbf{C}$.

[TABLE]

Semantic Adversarial Attack on Object Detectors

Extending adversarial attacks from classifiers to object detectors is straight-forward. We follow previous work (?) in defining the object detector as a function $\mathbf{F}:[0,1]^{n}\rightarrow(\mathbb{R}^{N\times K},\mathbb{R}^{N\times 4})$, which takes an $n$-dimensional image as input and outputs $N$ detected objects. Each detected object has a probability distribution over $K$ class labels and a 4-dimensional bounding box for the detected object. We take the top $J$ proposals according to their confidence and discard the others. Analyzing the detector in our general setup is similar to the classifier case. The environment $\mathbf{E}_{\boldsymbol{\mu}}$ is static (i.e. $T=1$), and it contains all images with ground truth detections. For simplicity, we consider one object of interest per image (indexed by $i$). The observation in this case is a rendered image of an instance of object class $i$, where the environment parameter $\boldsymbol{\mu}$ determines the 3D scene and how the image is rendered (e.g. the camera position/viewpoint, lighting directions, textures, etc. .). Here, the observation is defined as the rendering function $\mathbf{o}_{1}:[\boldsymbol{\mu}_{\text{min}},\boldsymbol{\mu}_{\text{max}}]^{d}\rightarrow\mathbb{R}^{n}$. We use Blender (?) to render the 3D scene containing the object and to determine its ground truth bounding box location in the rendered image. The action $\mathbf{a}_{1}$ by the agent/detector is simply the highest confidence score $l_{i}$ corresponding to class $i$ from the top $J$ detected boxes in $\mathbf{o}_{1}$. The final score of $\mathbf{F}$ is $\mathit{Q}(\mathbf{F},\mathbf{E}_{\boldsymbol{\mu}})=l_{i}$. The attack on $\mathbf{F}$ is considered successful, if $l_{i}\leq\epsilon$.

Semantic Adversarial Attack on Autonomous Agents

The semantic adversarial attack of an autonomous agent can also be represented in the general formulation of Algorithm 1 in the paper. Here, $\mathbf{A}$ corresponds to the navigation policy, which interacts with a parametrized environment $\mathbf{E}_{\boldsymbol{\mu}}$. The environment parameter $\boldsymbol{\mu}\in\mathbb{R}^{d}$ comprises $d$ variables describing the weather/road conditions, camera pose, environment layout etc. . In this case, an observation $\mathbf{o}_{t}$ is an image as seen from the camera view of the agent at time $t$. The action $\mathbf{a}_{t}$ produced by the navigation policy is the set of control commands (e.g. gas and steering for a car or throttle, pitch, roll and yaw for a UAV). The reward function $\mathit{R}(\mathbf{s}_{t},\mathbf{a}_{t})$ measures if the agent successfully completes its task (e.g. $1$ if it safely reaches the target position at time $t$ and [math] otherwise). The episode ends when either the agent completes its task or the maximum number of iterations $T$ is exceeded. Since the reward is binary, the $\mathit{Q}$ score is the average reward over a certain number of runs (five in our case). This leads to a fractional score $0\leq\mathit{Q}\leq 1$.

Appendix C Boosting Strategy for BBGAN

Intuition for Boosting

Inspired by the classical Adaboost meta-algorithm (?), we use a boosting strategy to improve the performance of our BBGAN trained in Section 5 of our paper with results reported in Table 1. The boosting strategy of BBGAN is simply utilizing the information learned from one BBGAN by another BBGAN in a sequential manner. The intuition is that the main computational burden in training the BBGAN is not the GAN training but computing the agent $\mathbf{A}$ episodes (which can take multiple hours per episode in the case of the self-driving experiments).

Description of Boosting for BBGANs

We propose to utilize the generator to generate samples that can be used by the next BBGAN. We start by creating the set $\Omega_{0}$ of the first stage adversary $\mathbf{G}_{0}$. We then simply add the generated parameters $\boldsymbol{\mu}$ along with their computed scores $\mathit{Q}$ to the training data of the next stage BBGAN (i.e. BBGAN-1). We start the next stage by inducing a new induced set $S_{\boldsymbol{\mu^{\prime}}}^{1}$ (that may include part or all the previous stage induced set $S_{\boldsymbol{\mu^{\prime}}}^{0}$). However, the aim is to put more emphasis on samples that were generated in the previous stage. Hence, the inducer in the next stage can just randomly sample N points, compute their $\mathit{Q}$ scores and add $\beta*N$ generated samples from BBGAN-0 to the $N$ random samples. The entire set is then sorted based on the $\mathit{Q}$ scores, where the lowest-scoring $s_{1}$ points that satisfy Eq (7) are picked as the induced set $S_{\boldsymbol{\mu^{\prime}}}^{1},~{}s_{1}=\left|S_{\boldsymbol{\mu^{\prime}}}^{1}\right|$. The BBGAN-1 is then trained according to Eq (6). Here $\beta$ is the boosting rate of our boosting strategy which dictates how much emphasis is put on the previous stage (exploitation ratio) when training the next stage. The whole boosting strategy can be repeated more than once. The global set $\Omega$ of all $N$ sampled points and the update rule from one stage to another is described by the following two equations:

[TABLE]

[TABLE]

These global sets $\Omega_{k}$ constitute the basis from which the inducer produces the induced sets $S_{\boldsymbol{\mu^{\prime}}}^{k}$. The adversary $\mathbf{G}_{k}$ of boosting stage $k$ uses this induced set when training according to the BBGAN objective in Eq (6). Algorithm 2 summarizes the boosting meta-algorithm for BBGAN.

Empirical proof for BBGAN Boosting

Here we want to show the effectiveness of boosting (Algorithm 2) on improving the performance of BBGAN from one stage to another. Explicitly, we want to show that the following statement holds, under some conditions.

[TABLE]

This statement says that the expected score $\mathit{Q}$ of the sampled parameters $\boldsymbol{\mu}_{k}$ from the adversary $\mathbf{G}_{k}$ of stage $(k)$ BBGAN is bounded above by the score of the previous stage , which indicates iterative improvement of the fooling adversary $\mathbf{G}_{k}$ by lowering the score of the agent $\mathbf{A}$ and hence achieving a better objective at the following realxation of Eq (12).

[TABLE]

**Proof of Eq (20) .

**Let’s start by sampling random $N$ points as our initial $\Omega_{0}$ set as in Eq (18) and then learn BBGAN of the first stage and continue boosting as in Algorithm 2. Assume the following assumption holds,

[TABLE]

then by comparing the average score $\mathit{Q}$ of the entire global set $\Omega_{k}$ at stage $k$ (denoted simply as $\mathit{Q}(\Omega_{k}))$) with the average score of the added boosting samples from the previous stage $~{}\{\boldsymbol{\mu}_{j}\sim\mathbf{G}_{k-1}\}_{j=1}^{\lfloor\beta N\rfloor}$ as in Eq (19) (denoted simply as $\mathit{Q}(\mathbf{G}_{k-1})$) , two possibilities emerge:

1. Exploration possibility: $\mathit{Q}(\Omega_{k}))\leq\mathit{Q}(\mathbf{G}_{k-1})$ .

This possibility indicates that there is at least one new sample in the global set $\Omega_{k}$ that are not inherited from the previous stage adversary $\mathbf{G}_{k-1}$, which is strictly better then $\mathbf{G}_{k-1}$ samples with strictly lower $\mathit{Q}$ score. If the assumption in Eq (22)holds, then the induced set $S_{\boldsymbol{\mu}}^{k}$ will include at least one new parameter that is not inherited from previous stage and hence the average score of the induced set will be less than that of the generated by previous stage.

[TABLE]

However since the BBGAN of stage $k$ uses the induced set $S_{\boldsymbol{\mu}}^{k}$ for training , we expect the samples to be correlated: $\mathbf{G}_{k}\sim S_{\boldsymbol{\mu}}^{k}$, and the scores to be similar as follows:

[TABLE]

Substituting Eq (24) in Eq (23) results in the inequality

which makes the less strict inequality Eq (20)holds.

2. Exploitation possibility: $\mathit{Q}(\Omega_{k}))>\mathit{Q}(\mathbf{G}_{k-1})$ .

In this scenario, we don’t know for sure whether there is a new sample in $\Omega_{k}$ that is better than the inherited samples, but in the worst case scenario we will get no new sample with lower score. In either case, the assumption in Eq (22) ensures that the new induced set $S_{\boldsymbol{\mu}}^{k}$ is exactly the inherited samples from $\mathbf{G}_{k-1}$ and the following holds.

[TABLE]

Using the same argument as in Eq (24), we deduce that in this exploitation scenario Eq (20) is still satisfied. Hence, we prove that Eq (20) holds given the assumption in Eq (22).

Experimental Details for Boosting

We note that low $\beta$ values do not affect the training of our BBGAN since the induced set will generally be the same. Hence, we use $\beta=0.5$, a high boosting rate. For practical reasons (computing 50% of the training data per boosting stage is expensive) we just compute 10% of the generated data and repeat it 5 times. This helps to stabilize the BBGAN training and forces it to focus more on samples that have low scores without having to evaluate the score function on 50% of the training data.

Appendix D Detailed Results

Tables 4 and 5 show the detailed results for all three applications.

Appendix E Nearest Neighbor Visualization

In Figure 8, Figure 9 and Figure 10 we visualize the NN in the parameter space for four different generated samples by our BBGAN. We see that the generated and the NN in training are different for the 4 samples with $L_{2}$ norm differences in the caption of each figure. All pixels and parameters range from -1 to 1. This shows that our BBGAN can generate novel examples that fool the trained agent.

Appendix F Qualitative Examples

Figure F shows some qualitative examples for each of the 12 object classes. These images were rendered according to parameters generated by BBGAN which fooled the detector.

Appendix G Qualitative Comparison

Figure13 shows a qualitative comparison between samples of the BBGAN distribution and different baselines distributions in the YOLOYV3 attacks experiments.

Baselines

BBGAN. To learn the fooling distribution $\mathbf{P}_{\boldsymbol{\mu^{\prime}}}$, we train the BBGAN as described in Methodology Section. For this, we use a vanilla GAN model (?). We use a simple MLP with 2 layers for the Generator $\mathbf{G}$ and Discriminator $\mathbf{D}$. We train the GAN following convention, but since we do not have access to the true distribution that we want to learn (i.e. real samples), we induce the set by randomly sampling $N$ parameter vector samples $\boldsymbol{\mu}$, and then picking the $s$ worst among them (according to $Q$ score). For object detection, we use $N=20000$ image renderings for each class (a total of 240K images), as described in the Application Section. Due to the computational cost, our dataset for the autonomous navigation tasks comprises only $N=1000$ samples. For instance, to compute one data point in autonomous driving, we need to run a complete episode that requires 15 minutes. The induced set size $s$ is always fixed to be 100.

Random. We uniformly sample random parameters $\boldsymbol{\mu}$.

Gaussian Mixture Model (GMM). We fit a full covariance GMM of varying Gaussian components to estimate the distribution of the samples in the induced set $S_{\boldsymbol{\mu^{\prime}}}$. The variants are denoted as Gaussian (one component), GMM10% and GMM50% (number of components as percentage of the samples in the induced set).

Bayesian. We use the Expected Improvement (EI) Bayesian Optimization algorithm (?) to minimize the score $\mathit{Q}$ for the agent. The optimizer runs for 104 steps and it tends to gradually sample more around the global minimum of the function. So, we use the last $N=1000$ samples to generate the induced set $S_{\boldsymbol{\mu^{\prime}}}$ and then learn a GMM on that with different Gaussian components. Finally, we sample $M$ parameter vectors from the GMMs and report results for the best model.

Multi-Class SVM. We bin the score $Q$ into 5 equally sized bins and train a multi-class SVM classifier on the complete set $\Omega$ to predict the correct bin. We then randomly sample parameter vectors $\boldsymbol{\mu}$, classify them, and sort them by the predicted score. We pick $M$ samples with the lowest $Q$ score.

Gaussian Process Regression. Similar to the SVM case, we train a Gaussian Process Regressor (?) with an exponential kernel to regress $Q$ scores from the corresponding $\boldsymbol{\mu}$ parameters that generated the environment on the dataset $\Omega$.

Appendix H Training data

In the following we show some examples of the training data for each of the applications.

Object Detection

Object detection is one of the core perception tasks commonly used in autonomous navigation. Its goal is to determine the bounding box and class label of objects in an image. You Only Look Once (YOLO) object detectors popularized a single-stage approach, in which the detector observes the entire image and regresses the boundaries of the bounding boxes and the classes directly (?). This trades off the accuracy of the detector for speed, making real-time object detection possible.

Agent. Based on its suitability for autonomous applications, we choose the very fast, state-of-the-art YOLOv3 object detector (?) as the agent in our SADA framework. It achieves a competitive mAP score on the MS-COCO detection benchmark and it can run in real-time (?).

Environment. We use Blender open source software to construct a scene based on freely available 3D scenes and CAD models . The scene was picked to be an urban scene with an open area to allow for different rendering setups. The scene includes one object of interest, one camera, and one main light source all directed toward the center of the object. The light is a fixed strength spotlight located at a fixed distance from the object. The material of each object is semi-metallic, which is common for the classes under consideration. The 3D collection consists of 100 shapes of 12 object classes (aeroplane, bench, bicycle, boat, bottle, bus, car, chair, dining table, motorbike, train, truck) from Pascal-3D (?) and ShapeNet (?). At each iteration, one shape from the intended class is randomly picked and placed in the middle of the scene. Then, the Blender rendered image is passed to YOLOV3 for detection. Please refer to Figure H for some sample images of the object detection dataset.

Environment parameters. We use eight parameters that have shown to affect detection performance and frequently occur in real setups (refer to Figure 17). The object is centered in the virtual scene, and the camera circles around the object keeping the object in the center of the rendered image. The parameters were normalized to $[-1,1]^{8}$ before using them for learning and testing.

Self-Driving

There is a lot of recent work in autonomous driving especially in the fields of robotics and computer vision (?; ?). In general, complete driving systems are very complex and difficult to analyze or simulate. By learning the underlying distribution of failure cases, our work provides a safe way to analyze the robustness of such a complete system. While our analysis is done in simulation only, we would like to highlight that sim-to-real transfer is a very active research field nowadays (?; ?).

Agent. We use an autonomous driving agent (based on CIL (?)), which was trained on the environment $\mathbf{E}_{\mu}$ with default parameters. The driving-policy was trained end-to-end to predict car controls given an input image and is conditioned on high-level commands (e.g. turn right at the next intersection) in order to facilitate autonomous navigation.

Environment. We use the recent CARLA driving simulator (?), the most realistic open-source urban driving simulator currently available. We consider the three common tasks of driving in a straight line, completing one turn, and navigating between two random points. The score is measured as the average success of five pairs of start and end positions. Figure 14 shows some images of the CARLA (?) simulation environment used for the self-driving car experiments.

Environment parameters. Since experiments are time-consuming, we restrict ourselves to three parameters, two of which pertain to the mounted camera viewpoint and the third controls the appearance of the environment by changing the weather setting (e.g. ’clear noon’, ’clear sunset’, ’cloudy after rain’, etc.). As such, we construct an environment by randomly perturbing the position and rotation of the default camera along the z-axis and around the pitch axis respectively, and by picking one of the weather conditions. Intuitively, this helps measure the robustness of the driving policy to the camera position (e.g. deploying the same policy in a different vehicle) and to environmental conditions. Figure 15 visualizes the distribution of the training data.

UAV Racing

In recent years, UAV (unmanned aerial vehicle) racing has emerged as a new sport where pilots compete in navigating small UAVs through race courses at high speeds. Since this is a very interesting research problem, it has also been picked up by the robotics and vision communities (?).

Agent. We use a fixed agent to autonomously fly through each course and measure its success as percentage of gates passed (?). If the next gate was not reached within 10 seconds, we reset the agent at the last gate. We also record the time needed to complete the course. The agent uses a perception network that produces waypoints from image input and a PID controller to produce low-level controls.

Environment. We use the general-purpose simulator for computer vision applications, Sim4CV (?). Sim4CV is not only versatile but also photo-realistic and provides a suitable environment for UAV racing. Figure 16 shows some images of the Sim4CV simulator used for the UAV racing application.

Environment parameters. We change the geometry of the race course environment. We define three different race track templates with 3-5 2D anchor points, respectively. These points describe a second order B-spline and are perturbed to generate various race tracks populated by uniformly spaced gates. Figures H, H and H show some samples from the UAV datasets.

Appendix I Analysis

Diagnosis

To identify weaknesses and cases that results in systematic failure for the YOLOv3 detector, we fix some semantic parameters and attack the others. We conduct two different case studies. The first one involves the camera view-point and light direction; these have the largest impact in determining the pixel values of the final image. The second case study examines occlusion, which is one of the most common causes of detection failure. In both cases, we focus on two classes that are relevant in the autonomous driving application: cars and motorbikes. Since we have several 3D models for each class, we include the effect of model shapes in the analysis. We use roughly sampled models with homogeneous texturing (obtained from the training in SectionH) as well as detailed fully-textured models. This also has the nice side-effect to show how well our insights transfer to more realistic renderings and ultimately the real world. In total, we consider five different scenarios per case. Scenario 1: simple car, Scenario 2: detailed car, Scenario 3: simple motorbike, Scenario 4: detailed motorbike 1, Scenario 5: detailed motorbike 2. We use these scenarios for both cases.

Case 1: View point. We restrict the number of parameters to 4 ($\phi_{\text{cam}},\theta_{\text{cam}},\phi_{\text{light}},\phi_{\text{light}}$), and fix the object class and RGB colors (pure blue). Figures 20, 21, 22, 23 and 24 show qualitative results for samples generated by learning a BBGAN on each scenario in the view-point case. Figures 18 and 19 visualize the learned distribution in scenario 3 and scenario 5 and some examples of transferability to real world.

Case 2: Occlusion. Since occlusion plays an important role in object misdetection, we introduce an occlusion experiment. Here, we investigate how occlusion (e.g. by a pole) can result in failure of a detector (e.g. from which view point). Therefore, we include the camera viewpoint angles ($\phi_{\text{cam}},\theta_{\text{cam}}$) and introduce a third parameter to control horizontal shift of a pole that covers 15% of the rendered image and moves from one end to another. The pole keeps a fixed distance to the camera and is placed between the camera and the object. Figures 25, 26, 27, 28 and 29 show qualitative results for samples generated by learning a BBGAN on each scenario in the occlusion case.

Transferability

**Across Shape Variations.

We use the same scenarios as above to construct transferability experiments. The goal is to validate generalization capabilities of the learned fooling distribution from one scenario to another. Also, it shows what role the model shape plays with regard to the strength of the learned attacks. Tables 6 and 7 show the transferability of the adversarial attacks for Case 1 and Case 2. We see that most attacks transfer to new scenarios that are similar, indicating the generalization of the learned fooling distribution. However, the attacks that were learned on more detailed CAD models transfer better to generic less detailed models (e.g. PASCAL3D(?) and ShapeNet(?**) models).

To validate generalization capabilities of the learned fooling distribution, we learn this distribution from samples taken from one setup and then test it on another. Table 6 shows that adversarial distributions learned from detailed textured models transfer better (i.e. maintain similar AFR after transferring to the new setup) than those learned from rough ones from Pascal3D (?) and ModelNet (?). This observation is consistent with that of (?).

**Virtual to Real World.

**To demonstrate the transferability of the fooling parameter distribution to the real world, we photograph a toy motorbike, similar to the 3D model we are attacking. We use a mobile phone camera and an office spotlight to replace the light source in the virtual environment. The photos are taken under different camera views and lighting directions (uniform sampling). We also take photos based on samples from the distribution learned by the BBGAN. We apply the YOLOv3 detector on these images and observe the confidence score for the ‘motorbike’ class of interest. On the samples generated from the BBGAN distribution, the attack fooling rate is 21% compared to only 4.3% when picking a random viewpoint. In Figures 18 and 19, we visualize the fooling distribution generated by our BBGAN and provide some corresponding real-world images.

Visualization. In Figures 18 and 19, we visualize of the fooling distribution generated by our BBGAN in the two previous experiments (SectionI). We also include some real-world images captured according to the parameters generated by the BBGAN.

Appendix J Insights Gained by BBGAN Experiments

Object Detection with YOLOV3

In our YOLOV3 experiments, we consistently found that for most objects top rear or top front views of the object are fooling the YOLOV3 detector. Furthermore, the light angle which will result in highest reflection off the surface of the object also results in higher fooling rates for the detector. The color of the object does not play a big role in fooling the detector, but usually colors that are closer to the background color tend to be preferred by the BBGAN samples (as shown in the qualitative examples). From the analysis in SectionI of transferability of these attacks, we note that attacks on more detailed CAD shapes and models transfer better to less detailed shapes, but the opposite is not true.

Self-driving cars

In our experiments we found that weather is the least important parameter for determining success. This is probably due to the fact that the driving policy was trained on multiple weather conditions. This allows for some generalization and robustness to changing weather conditions. However, the driving policy was trained with a fixed camera. We observe, that the driving policy is very sensitive to slight perturbations of the camera pose (height and pitch).

UAV Autonomous Navigation

We observe that the UAV fails if the track has very sharp turns. This makes intuitive sense and the results that were produced by our BBGAN consistently produce such tracks. For the tracks that are only parameterized by three control points it is difficult to achieve sharp turns. However, our BBGAN is still able to make the UAV agent fail by placing the racing gates very close to each other, thereby increasing the probability of hitting them.