Add files using upload-large-folder tool

parse/train/HJWGdbbCW/HJWGdbbCW.md

@@ -0,0 +1,299 @@
+# REINFORCEMENT AND IMITATION LEARNING FOR DIVERSE VISUOMOTOR SKILLS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We propose a general deep reinforcement learning method and apply it to robot manipulation tasks. Our approach leverages demonstration data to assist a reinforcement learning agent in learning to solve a wide range of tasks, mainly previously unsolved. We train visuomotor policies end-to-end to learn a direct mapping from RGB camera inputs to joint velocities. Our experiments indicate that our reinforcement and imitation approach can solve contact-rich robot manipulation tasks that neither the state-of-the-art reinforcement nor imitation learning method can solve alone. We also illustrate that these policies achieved zero-shot sim2real transfer by training with large visual and dynamics variations.
+
+# 1 INTRODUCTION
+
+Recent advances in deep reinforcement learning (RL) have performed very well in several challenging domains such as video games (Mnih et al., 2015) and Go (Silver et al., 2016). For robotics, RL in combination with powerful function approximators provides a general framework for designing sophisticated controllers that would be hard to handcraft otherwise. Yet, despite significant leaps in other domains the application of deep RL to control and robotic manipulation has proven challenging. While there have been successful demonstrations of deep RL for manipulation (e.g. Nair et al. 2017; Popov et al. 2017) and also noteworthy applications on real robotic hardware (e.g. Levine et al. 2015; Yahya et al. 2016) there have been very few examples of learned controllers for sophisticated tasks even in simulation.
+
+Robotics exhibits several unique challenges. These include the need to rely on multi-modal and partial observations from noisy sensors, such as cameras. At the same time, realistic tasks often come with a large degree of variation (visual appearance, position, shapes, etc.) posing significant generalization challenges. Training on real robotics hardware can be daunting due to constraints on the amount of training data that can be collected in reasonable time. This is typically much less than the millions of frames needed by modern algorithms. Safety considerations also play an important role, as well as the difficulty of accessing information about the state of the environment (like the position of an object) e.g. to define a reward. Even in simulation when perfect state information and large amounts of training data are available, exploration can be a significant challenge. This is partly due to the often high-dimensional and continuous action space, but also due to the difficulty of designing suitable reward functions.
+
+In this paper, we present a general deep reinforcement learning method that addresses these issues and that can solve a wide range of robot arm manipulation tasks directly from pixels, most of which have not been solved previously. Our key insight is 1) to reduce the difficulty of exploration in continuous domains by leveraging a handful of human demonstrations; 2) several techniques to stabilize the learning of complex manipulation policies from vision; and 3) to improve generalization by increasing the diversity of the training conditions. As a result, the trained policies work well under significant variations of system dynamics, object appearances, task lengths, etc. We ground these policies in the real world, demonstrating zero-shot transfer from simulation to real hardware.
+
+We develop a new method to combine imitation learning with reinforcement learning. Our method requires only a small number of human demonstrations to dramatically simplify the exploration problem. It uses demonstration data in two ways: first, it uses a hybrid reward that combines sparse environment reward with imitation reward based on Generative Adversarial Imitation Learning (Ho & Ermon, 2016), which produces more robust controllers; second, it uses demonstration as a curriculum to initiate training episodes along demonstration trajectories, which facilitates the agent to reach new states and solve longer tasks. As a result, it solves dexterous manipulation tasks that neither the state-of-the-art reinforcement learning nor imitation learning method can solve alone.
+
+![](images/3da1dcf2a407228cf883b16987f42fe9cbfef255dde0766f2788e3e98e48d9b5.jpg)  
+Figure 1: Our proposal of a principled robot learning pipeline. We used 3D motion controllers to collect human demonstrations of a task. Our reinforcement and imitation learning model leveraged these demonstrations to facilitate learning in a simulated physical engine. We then performed sim2real transfer to deploy the learned visuomotor policy to a real robot.
+
+Previous RL-based robot manipulation policies (Nair et al., 2017; Popov et al., 2017) largely rely on low-level states as input, or use severely limited action spaces that ignore the arm and instead learn Cartesian control of a simple gripper. This limits the ability of these methods to represent and solve more complex tasks (e.g., manipulating arbitrary 3D objects) and to deploy in real environments where the privileged state information is unavailable. Our method learns an end-to-end visuomotor policy that maps RGB camera observations to joint space control over the full 9-DoF arm (6 arm joints plus 3 actuated fingers).
+
+To sidestep the constraints of training on real hardware we embrace the sim2real paradigm which has recently shown promising results (James et al., 2017; Rusu et al., 2016a). Through the use of a physics engine and high-throughput RL algorithms, we can simulate parallel copies of a robot arm to perform millions of complex physical interactions in a contact-rich environment while eliminating the practical concerns of robot safety and system reset. Furthermore, we can, during training, exploit privileged information about the true system state with several new techniques, including learning policy and value in separate modalities, an object-centric GAIL discriminator, and auxiliary tasks for visual modules. These techniques stabilize and speed up policy learning from pixels.
+
+Finally, we diversify training conditions such as visual appearance as well as e.g. the size and shape of objects. This improves both generalization with respect to different task conditions as well as transfer from simulation to reality.
+
+To demonstrate our method, we use the same model and the same algorithm for visuomotor control of six diverse robot arm manipulation tasks. Combining reinforcement and imitation, our policies solve the tasks that the state-of-the-art reinforcement and imitation learning cannot solve and outperform human demonstrations. Our approach sheds light on a principled deep visuomotor learning pipeline illustrated in Fig. 1, from collecting real-world human demonstration to learning in simulation, and back to real-world deployment via sim2real policy transfer.
+
+# 2 RELATED WORK
+
+Reinforcement learning methods have been extensively used with low-dimensional policy representations such as movement primitives to solve a variety of control problems both in simulation and in reality. Three classes of RL algorithms are currently dominant for continuous control problems: guided policy search methods (GPS; Levine & Koltun 2013), value-based methods such as the deterministic policy gradient (DPG; Silver et al. 2014; Lillicrap et al. 2016; Heess et al. 2015) or the normalized advantage function (NAF; Gu et al. 2016b) algorithm, and trust-region based policy gradient algorithms such as trust region policy optimization (TRPO) and proximal policy optimization (PPO). TRPO (Schulman et al., 2015) and PPO (Schulman et al., 2017) hold appeal due to their robustness to hyper-parameter settings as well as their scalability (Heess et al., 2017) but the lack of sample efficiency makes them unsuitable for training directly on robotics hardware.
+
+GPS (Levine & Koltun, 2013) has been used e.g. by Levine et al. (2015) and Yahya et al. (2016) to learn visuomotor policies directly on a real robotics hardware after a network pretraining phase. Gupta et al. (2016) and Kumar et al. (2016) use GPS for learning controllers for robotic hand models. Value-based methods have been employed, e.g. by Gu et al. (2016a) who use NAF to learn a door opening task directly on a robot while Popov et al. (2017) demonstrate how to solve a stacking problem efficiently using a distributed variant of DPG.
+
+The idea of using large-scale data collection for training visuomotor controllers has been the focus of Levine et al. (2016) and Pinto & Gupta (2015) who train a convolutional network to predict grasp success for diverse sets of objects using a large dataset with 10s or 100s of thousands of grasp attempts collected from multiple robots in a self-supervised setting.
+
+An alternative strategy for dealing with the data demand is to train in simulation and transfer the learned controller to real hardware, or to augment real-world training with synthetic data. Rusu et al. (2016b) learn simple visuomotor policies for a Jaco robot arm and transfer to reality using progressive networks (Rusu et al. 2016a). Viereck et al. (2017) minimize the reality gap by relying on depth. Tobin et al. (2017) use visual variations to learn robust object detectors that can transfer to reality; James et al. (2017) combine randomization with supervised learning. Bousmalis et al. (2017) augments the training with simulated data to learn grasp prediction of diverse shapes.
+
+Suitable cost functions and exploration strategies for control problems are challenging to design, so demonstrations have long played an important role. Demonstrations can be used to initialize policies, design cost functions, guide exploration, augment the training data, or a combination of these. Cost functions can be derived from demonstrations either via tracking objectives (e.g. Gupta et al. 2016) or, via inverse RL (e.g. Boularias et al. 2011; Finn et al. 2016), or, as in our case, via adversarial learning (Ho & Ermon, 2016). When expert actions or expert policies are available, behavioral cloning or DAgger can be used (Rahmatizadeh et al. 2017; James et al. 2017; Duan et al. 2017). Alternatively, expert trajectories can be used as additional training data for off-policy algorithms such as DPG (e.g. Vecerik et al. 2017). Most of these methods require observation and/or action spaces to be aligned between robot and demonstrations. Recently, methods for third person imitation have been proposed (e.g. Sermanet et al. 2017; Liu et al. 2017; Finn et al. 2017).
+
+Concurrently with our work several papers have presented results on manipulation tasks. Rajeswaran et al. (2017); Nair et al. (2017) both use human demonstrations to aid exploration. Nair et al. (2017) extends the DDPGfD algorithm (Vecerik et al., 2017) to learn a block stacking task on a position-controlled arm in simulation. Rajeswaran et al. (2017) use the demonstrations with a form of behavioral cloning and data augmentation to learn several complex manipulation tasks. In both cases, controllers observe a low-dimensional state space representation and the methods inherently require aligned state and action spaces with the demonstrations. Pinto et al. (2017) and Peng et al. (2017) address the transfer from simulation to reality, focusing on randomizing visual appearance and robot dynamics respectively. Peng et al. transfer a block-pushing policy operating from state features to a 7-DoF position controlled Fetch robotics arm. Pinto et al. consider different tasks using visual input with end-effector position control.
+
+# 3 MODEL
+
+Our goal is to learn a deep visuomotor policy for robot manipulation tasks. The policy takes both an RGB camera observation and a proprioceptive feature that describes the joint positions and angular velocities. These two sensory modalities are also available on the real robot, enabling us to perform zero-shot policy transfer once trained in simulation. Fig. 2 provides an overview of our model. The deep visuomotor policy encodes the pixel observation with a convolutional network (CNN) and the proprioceptive feature with a multilayer perceptron (MLP). The features from these two modules are concatenated and passed to a recurrent LSTM layer before producing the joint velocities. The whole network is trained end-to-end. We start with a brief review of the basics of generative adversarial imitation learning (GAIL) and proximal policy optimization (PPO). Our model extends upon these two methods for visuomotor skills.
+
+![](images/1631fa6f9bf52330c1120085322dc3e3cd32e7871d2a6cfc35443316773b4738.jpg)  
+Figure 2: Model overview. The core of our model is the deep visuomotor policy, which takes the camera observation and the proprioceptive feature as input and produces the next joint velocities.
+
+# 3.1 BACKGROUND: GAIL AND PPO
+
+Imitation learning $\left( \operatorname { I L } \right)$ is the problem of learning a behavior policy by mimicking a set of demonstrations. Here we assume that human demonstration is provided as a dataset of state-action pairs $\mathcal { D } = \{ ( s _ { i } , a _ { i } ) \} _ { i = 1 \ldots N }$ . Traditional $\mathrm { I L }$ methods cast it as a supervised learning problem, i.e., behavior cloning. These methods use maximum likelihood to train a parameterized policy $\pi _ { \theta } : { \mathcal { S } }  A$ , where $s$ is the state space and $\mathcal { A }$ is the action space, such that $\begin{array} { r } { \theta ^ { * } = \arg \operatorname* { m a x } _ { \theta } \sum _ { N } \log \pi _ { \theta } ( a _ { i } | s _ { i } ) } \end{array}$ . The behavior cloning approach works effectively in cases when the demonstrations abound (Ross et al., 2011). However, as robot demonstrations can be costly and time-consuming, we are in favor of a method that can learn from a handful of demonstrations. GAIL (Ho & Ermon, 2016) makes a more efficient use of demonstration data by allowing the agent to interact with the environment and learn from its own experiences. Similar to Generative Adversarial Networks (Goodfellow et al., 2014), GAIL has two networks, a policy network $\pi _ { \theta } : { \mathcal { S } }  A$ and a discriminator network $D _ { \psi } : \mathcal { S } \times \mathcal { A }  [ 0 , 1 ]$ . GAIL uses a similar min-max objective function as in GANs:
+
+$$
+\operatorname* { m i n } _ { \psi } \theta \operatorname* { m a x } _ { \psi } \mathbb { E } _ { \pi _ { E } } [ \log D _ { \psi } ( s , a ) ] + \mathbb { E } _ { \pi _ { \theta } } [ \log ( 1 - D _ { \psi } ( s , a ) ) ] ,
+$$
+
+where $\pi _ { E }$ denotes the expert policy that generated the demonstration trajectories. This learning objective encourages the policy $\pi _ { \theta }$ to have an occupancy measure close to the expert policy $\pi _ { E }$ .
+
+In practice, we train $\pi _ { \theta }$ with policy gradient methods to maximize the discounted sum of the reward function $r _ { g a i l } ( s _ { t } , a _ { t } ) = - \log ( 1 - D _ { \psi } ( s _ { t } , a _ { t } ) )$ , clipped by a max value of 10. In continuous domains, trust region methods greatly stabilize policy training. The original GAIL model uses TRPO (Schulman et al., 2015) in the policy update steps. Recently, PPO (Schulman et al., 2017) is proposed as a simple and scalable approximation to TRPO. PPO only relies on the first-order gradients and can be easily implemented with recurrent networks in a distributed setting (Heess et al., 2017). The key idea of PPO is to use the Kullback-Leibler (KL) divergence to dynamically change the coefficient of a regularization term, where the coefficient is adapted based on whether the previous policy update step violates the KL constraint. We use distributed PPO to perform data collection and synchronous gradient updates across many workers in parallel. We trained all our policies with 256 CPU workers, which brings a significant speedup in wall-clock time.
+
+# 3.2 REINFORCEMENT AND IMITATION LEARNING MODEL
+
+# 3.2.1 HYBRID IL/RL REWARD
+
+A common approach to guiding exploration is by engineering a shaping reward. Although reward shaping sometimes provides informative guidance for policy search, it has the well-known drawback of producing suboptimal behaviors $\mathrm { N g }$ et al., 1999). Hence, we use sparse piecewise constant rewards in this work. Training agents in continuous domains under sparse rewards is particularly challenging. Inspired by reward augmentation introduced in Li et al. 2017 and Merel et al. 2017, we design a hybrid reward function to mix the imitation reward $r _ { g a i l }$ with the sparse task reward $r _ { t a s k }$ :
+
+$$
+r ( s _ { t } , a _ { t } ) = \lambda r _ { g a i l } ( s _ { t } , a _ { t } ) + ( 1 - \lambda ) r _ { t a s k } ( s _ { t } , a _ { t } ) \quad \lambda \in [ 0 , 1 ] .
+$$
+
+Maximizing this hybrid reward can be interpreted as simultaneous reinforcement and imitation learning, where the imitation reward encourages the policy to generate trajectories closer to demonstration trajectories, and the task reward encourages the policy to achieve high returns in the task. Setting $\lambda$ to either 0 or 1 reduces this method to the standard RL or GAIL setups. Our experiments suggest that with a balanced contribution of these two rewards, the agents can solve tasks that neither GAIL nor RL can solve alone. Further, the final agents achieved higher returns than the human demonstrations owing to the exposure to task rewards.
+
+# 3.2.2 LEVERAGING PHYSICAL STATES IN SIMULATION
+
+The use of simulated system provides us access to the underlying physical states. Even though such privileged information is unavailable on a real system, we can take advantage of it when training the policy in simulation. We propose four techniques to leverage the physical states in simulation to stabilize and accelerate learning, including demonstration curriculum, learning value from states, building object-centric discriminator, and auxiliary tasks.
+
+Demonstration as a curriculum. The problem of exploration in continuous domains is exacerbated by the long duration of realistic tasks. Previous work indicates that shaping the distribution of start states towards states where the optimal policy tends to visit can greatly improve policy learning (Kakade & Langford, 2002; Popov et al., 2017). We alter the start state distribution with demonstration states. We build a curriculum that contains clusters of states in different stages of a task. For instance, we define three clusters for the pouring task, including reaching the mug, grasping the mug, and pouring. For a training episode, with probability $\epsilon$ we start it from a random initial state, and with probability $1 - \epsilon$ we uniformly select a cluster and reset the episode to a demonstration state from the cluster. This is possible as our simulated system is fully characterized by the physical states.
+
+Learning value functions from states. PPO uses a learnable value function $V _ { \phi }$ to estimate the advantage for policy gradient. During training, each PPO worker executes the policy for $K$ steps and uses the discounted sum of rewards and the value as an advantage function estimator $\hat { A } _ { t } \overset { \cdot } { = }$ $\begin{array} { r } { \sum _ { i = 1 } ^ { K } \gamma ^ { i - 1 } r _ { t + i } + \gamma ^ { K - 1 } V _ { \phi } ( s _ { t + K } ) - V _ { \phi } ( s _ { t } ) , } \end{array}$ , where $\gamma$ is the discount factor. As the policy gradient relies on the value function to reduce variance, it is beneficial to accelerate learning of the value function. Rather than using pixel inputs as the policy network, we take advantage of the low-level physical states (e.g., the position and velocity of the 3D objects and the robot arm) to train the value $V _ { \phi }$ with a smaller multilayer perceptron. We find that training the policy and value in two different modalities stabilizes training and reduces oscillation in the agent’s performance. This technique has also been adopted by a concurrent work by Pinto et al. 2017.
+
+Object-centric discriminator. Similar to the value function, the GAIL discriminator leverages the physical states to construct task-specific features as its input. In manipulation tasks, we find that object-centric representations (e.g., absolute and relative positions of the objects) provide the salient and relevant signals to the discriminator. The states of the robot arm, on the contrary, tend to make the discriminator too strong and stagnate the training of the policy. Inspired by information hiding strategies used in locomotion domains (Heess et al., 2016; Merel et al., 2017), our discriminator only takes the object-centric features as input while masking out arm-related information.
+
+State prediction auxiliary tasks. Auxiliary tasks have been shown effective in improving the learning efficiency and the final performance of deep RL methods (Jaderberg et al., 2016). To facilitate learning visuomotor policies, we add a state prediction layer on the top of the CNN module to predict the locations of objects from the camera observation. We use a fully-connected layer to regress the 3D coordinates of objects in the task. We train this auxiliary task by minimizing the $\ell _ { 2 }$ loss between the predicted and ground-truth object locations.
+
+# 3.2.3 SIM2REAL POLICY TRANSFER
+
+Policy transfer is shown to a real-world Kinova Jaco robot arm. The simulation was manually aligned to generally match the visuals and dynamics: a Kinect camera was visually calibrated to match the position and orientation of the simulated camera, and the simulation’s dynamics parameters were manually adjusted to match the dynamics of the real arm. Instead of using professional calibration equipment, our approach to sim2real policy transfer relies on domain randomization of camera position and orientation (Tobin et al., 2017; James et al., 2017). in contrast, we do not create intermediate position goals using object position information in reality, but rather train an end-to-end, pixels to velocities, feedback control policy. In addition, to alleviate the issues caused by latency on the real robot, we also fine-tune our policies while subjecting them to action dropping. Detailed descriptions are available in Appendix B.
+
+# 4 EXPERIMENTS
+
+Here we demonstrate that our proposed approach offers a general framework to visuomotor policy learning. We evaluate the performance of our model in six manipulation tasks illustrated in Fig. 3. We provide more qualitative results in this video.
+
+# 4.1 ENVIRONMENT SETUP
+
+We use a Kinova Jaco arm that has 9 degrees of freedom, including six arm joints and three actuated fingers. The robot arm interacts with a diverse set of objects on a tabletop. The visuomotor policy controls the robot using joint velocity commands. Our policy produces 9-dimensional continuous velocities in the range of $[ - 1 , 1 ]$ at $2 0 \mathrm { H z }$ . The proprioceptive features consist of the positions and angular velocities of the arm joints and the fingers. We use a positioned camera to collect real-time RGB observations. The proprioceptive features and the camera observations are available in both simulation and real environments. Thus, it enables policy transfer.
+
+We use the MuJoCo physics simulator (Todorov et al., 2012) as our training platform. We use a large variety of objects, from basic geometric shapes to procedurally generated 3D objects as ensembles of primitive shapes. We increase the diversity of objects by randomizing various physical properties, including dimension, color, mass, friction, etc. We used a 3D motion controller called SpaceNavigator, which allows us to operate the robot arm with a position controller, to collect 30 episodes of demonstration for each task and recorded the observations, actions, and physical states into a dataset. As each episode takes less than a minute to complete, demonstrating each task can be done within half an hour.
+
+# 4.2 ROBOT ARM MANIPULATION TASKS
+
+Fig. 3 shows visualizations of the six manipulation tasks in our experiments. The first column shows the six tasks in simulated environments, and the second column shows the real-world setup of the block lifting and stacking tasks. We see obvious visual discrepancies of the same task in simulation and reality. These six tasks exhibit learning challenges to varying degrees. The first three tasks use simple colored blocks, which allows us to easily construct the tasks for a real robot. We study sim2real policy transfer with the block lifting and stacking tasks in Sec. 4.4.
+
+Block lifting. The goal is to grasp and lift a randomized block, allowing us to evaluate the model’s robustness. We vary several random factors, including the robot arm dynamics (friction and armature), lighting conditions, camera poses, background colors, as well as the properties of the block. Each episode starts with a new configuration with these random factors uniformly drawn from a preset range.
+
+Block stacking. The goal is to stack one block on top of the other block. Together with the block lifting task, this is evaluated in sim2real transfer experiments.
+
+Clearing blocks. This task aims at clearing the tabletop that has two blocks. One strategy to do this task using a single arm is to stack the blocks and pick up both together. This task requires longer time and a more dexterous controller, introducing a significant challenge for exploration.
+
+The next three tasks involve a large variety of procedurally generated 3D shapes, making them difficult to recreate in real environments. We use them to examine the model’s ability to generalize across object variations in long and complex tasks.
+
+![](images/500c4e82d7c70a53a90aba7e6097cefcf2952fcef850a953da75af3119384acf.jpg)  
+Figure 3: Visualizations of the six manipulation tasks in our experiments. The left column shows RGB images of all six tasks in the simulated environments. These images correspond to the actual pixel observations as input to the visuomotor policies. The right column shows the two tasks with color blocks on the real robot.
+
+Clearing tabletop. In this task, the goal is to clear the tabletop that has a box and a toy car. One strategy is to grasp the toy, put it into the box, and lift the box. Both the box and the toy car are randomly generated for each episode.
+
+Pouring liquid. Modeling and reasoning about deformable objects and fluids is a long-standing challenge in the robotics community (Schenck & Fox, 2017). We design a pouring task where we use many small spheres to simulate liquid. The goal is to pour the “liquid” from one mug to the other container. This task is particularly challenging due to the dexterity required. Even trained humans struggled to demonstrate the task with our 3D motion controller.
+
+Order fulfillment. In this task, we randomly place a variable number of procedurally generated toy planes and cars on the table. The goal is to place all the planes into the green box and all the cars into the red box. This task requires the policy to generalize at an abstract level. It needs to recognize the object categories, perform successful grasps on diverse shapes, and handle tasks with variable lengths.
+
+# 4.3 QUANTITATIVE EVALUATION
+
+Our full model can solve all six tasks, with only occasional failures, using the same policy network, the same training algorithm, and a fixed set of hyperparameters. On the contrary, neither reinforcement nor imitation alone can solve all tasks. We compare the full model with three baseline methods, where we evaluate degenerated versions of our model, which correspond to RL, GAIL, and RL w/o demonstration curriculum. These baselines use the same setup as the full model, except that we set $\lambda = 0$ for RL and $\lambda = 1$ for GAIL, while our model uses a balanced contribution of the hybrid reward, where $\lambda = 0 . 5$ . In the third baseline, all the training episodes start from random initial states rather than resetting to demonstration states. This corresponds to a standard RL setup.
+
+We report the mean episode returns as a function of the number of training iterations in Fig. 4. Our full model achieves the highest returns in all six tasks. The only case where the baseline model is on par with the full model is the block lifting task, in which both the RL baseline and the full model achieved similar levels of performance. We hypothesize that this is due to the short length of the lifting task, where random exploration in RL is likely to reach the goal states without the aid of GAIL.
+
+![](images/f42db9c29d42cf74a7da404a6d76c2b791f22b99a1f70b41c8fa2f490e715488.jpg)  
+Figure 4: Learning efficiency of our reinforcement and imitation model against baselines. The plots are averaged over 5 runs with different random seeds. All the policies use the same network architecture and the same hyperparameters (except $\lambda$ ).
+
+![](images/44c129be75f9308aefc493276536f020f20acf69c3de0ed33d53b3c232e1476a.jpg)  
+Figure 5: Model analysis in the stacking task. On the left we investigate the impact on performance by removing each individual component from the full model. On the right we investigate the model’s sensitivity to the hyperparameter $\lambda$ that moderates the contribution of reinforcement and imitation.
+
+In the other five tasks, the full model outperforms both the reinforcement learning and imitation learning baselines by a large margin, demonstrating the effectiveness of combining reinforcement and imitation for learning complex tasks. Comparing the two variants of RL with and without using demonstration as a curriculum, we see a pronounced effect of altering the start state distribution. We see that RL from scratch leads to a very slow learning progress; while initiating episodes along demonstration trajectories enables the agent to train on states from different stages of a task. As a result, it greatly reduces the burden of exploration and improves the learning efficiency. We also report the mean episode returns of human demonstrations in these figures. While demonstrations using the 3D motion controller are imperfect, especially for pouring (see video), the trained agents can surpass them via interacting with the environment.
+
+Two findings are noteworthy. First, the RL agent learns faster than the full model in the table clearing task, but the full model eventually outperforms. This is because the full model discovers a novel strategy, different from the strategy demonstrated by human operators (see video). In this case, imitation gave contradictory signals but eventually, reinforcement learning guided the policy towards a better strategy. Second, pouring liquid is the only task where GAIL outperforms its RL counterpart. Imitation can effectively shape the agent’s behaviors towards the demonstration trajectories (Wang et al., 2017). This is a viable solution for the pouring task, where a controller that generates similar-looking behaviors can complete the task. In contact-rich domains, however, a controller learned solely from dozens of demonstrations would struggle to handle complex object dynamics and to infer the true task goal. We hypothesize that this is why the baseline RL agent outperforms the GAIL agent in the other five tasks.
+
+We further perform an ablation study in the block stacking task to understand the impacts of different components of our model. In Fig. 5a, we trained our agents with a number of configurations, each with a single modification to the full model. We see that the final performances of the experiments cluster into two groups: agents that learn to stack (with average returns greater than 400) and agents that only learn to lift (with average returns between 200 and 300). These results indicate that the hybrid RL/IL reward, learning value function from states, and object-centric discriminator play an integral role in learning good policies. Using sole RL or GAIL reward, learning value function on pixels, or no information hiding for discriminator input (no discriminator mask) all result in inferior performances. In contrast, the optional components include the recurrent policy core (LSTM), the use of state prediction auxiliary tasks, and whether to include actions in discriminator input. We then examine the model’s sensitivity to the $\lambda$ values in Eq. 2. We see in Fig. 5b that, our model works well with a broad range of $\lambda$ values from 0.3 to 0.7 that provide a balanced mix of the RL and GAIL rewards.
+
+# 4.4 SIM2REAL POLICY TRANSFER RESULTS
+
+To assess the robustness of the simulation-trained policy, we evaluate zero-shot transfer (no additional training) on a real Jaco arm. Given a real-world set up that mirrored the simulated domain to a large extent, including camera positions and robot kinematics and approximate object size and color, we ran the trained network policy and counted the number of successful trials for both the lifting and stacking tasks. Although the sim and real domains were similar, there was still a sizable reality gap that made zero-shot transfer challenging. For example, the objects were non-rigid foam blocks which deformed and bounced unpredictably. The arm position was randomly initialized and the target block(s) placed in a number of repeatable start configurations for each task. The zero-shot transfer of the lifting policy had a success rate of $6 4 \%$ over 25 trials (split between 5 block configurations). The stacking policy had a success rate of $3 5 \%$ over 20 trials (split between 2 block configurations). $8 0 \%$ of the stacking trajectories, however, contain successful lifting behavior. Qualitatively, the policies are notably robust even on failed attempts — rather than exhibiting “open-loop” behaviors such as attempting to stack a non-existent block, the policy repeatedly chases the block to get a successful grasp before trying to stack (see video). For more detailed descriptions of the sim2real results, refer to Appendix B.
+
+# 5 CONCLUSION
+
+We have shown that combining reinforcement and imitation learning considerably improves the agents’ ability to solve challenging dexterous manipulation tasks from pixels. Our proposed method sheds light on the three stages of a principled pipeline for robot skill learning: first, we collected a small amount of demonstration data to simplify the exploration problem; second, we relied on physical simulation to perform large-scale distributed robot training; and third, we performed sim2real transfer for real-world deployment. In future work, we seek to improve the sample efficiency of the learning method and to leverage real-world experience to close the reality gap for policy transfer.
+
+# REFERENCES
+
+Abdeslam Boularias, Jens Kober, and Jan Peters. Relative entropy inverse reinforcement learning. In JMLR Workshop and Conference Proceedings Volume 15: AISTATS 2011, pp. 182–189, Cambridge, MA, USA, April 2011. MIT Press.
+
+Konstantinos Bousmalis, Alex Irpan, Paul Wohlhart, Yunfei Bai, Matthew Kelcey, Mrinal Kalakrishnan, Laura Downs, Julian Ibarz, Peter Pastor, Kurt Konolige, Sergey Levine, and Vincent Vanhoucke. Using Simulation and Domain Adaptation to Improve Efficiency of Deep Robotic Grasping. ArXiv e-prints, 2017.
+
+Yan Duan, Marcin Andrychowicz, Bradly C. Stadie, Jonathan Ho, Jonas Schneider, Ilya Sutskever, Pieter Abbeel, and Wojciech Zaremba. One-shot imitation learning. CoRR, abs/1703.07326, 2017. URL http://arxiv.org/abs/1703.07326.
+
+Chelsea Finn, Sergey Levine, and Pieter Abbeel. Guided cost learning: Deep inverse optimal control via policy optimization. In Proceedings of the 33nd International Conference on Machine Learning, ICML 2016, New York City, NY, USA, June 19-24, 2016, pp. 49–58, 2016. URL http://jmlr.org/proceedings/papers/v48/finn16.html.
+
+Chelsea Finn, Tianhe Yu, Tianhao Zhang, Pieter Abbeel, and Sergey Levine. One-Shot Visual Imitation Learning via Meta-Learning. ArXiv e-prints, 2017.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014.
+
+Shixiang Gu, Ethan Holly, Timothy P. Lillicrap, and Sergey Levine. Deep reinforcement learning for robotic manipulation. CoRR, abs/1610.00633, 2016a.
+
+Shixiang Gu, Tim Lillicrap, Ilya Sutskever, and Sergey Levine. Continuous deep q-learning with model-based acceleration. In International Conference on Machine Learning (ICML), 2016b.
+
+Abhishek Gupta, Clemens Eppner, Sergey Levine, and Pieter Abbeel. Learning dexterous manipulation for a soft robotic hand from human demonstration. CoRR, abs/1603.06348, 2016.
+
+Nicolas Heess, Gregory Wayne, David Silver, Tim Lillicrap, Tom Erez, and Yuval Tassa. Learning continuous control policies by stochastic value gradients. In Advances in Neural Information Processing Systems (NIPS), pp. 2926–2934, 2015.
+
+Nicolas Heess, Greg Wayne, Yuval Tassa, Timothy Lillicrap, Martin Riedmiller, and David Silver. Learning and transfer of modulated locomotor controllers. arXiv preprint arXiv:1610.05182, 2016.
+
+Nicolas Heess, Srinivasan Sriram, Jay Lemmon, Josh Merel, Greg Wayne, Yuval Tassa, Tom Erez, Ziyu Wang, Ali Eslami, Martin Riedmiller, et al. Emergence of locomotion behaviours in rich environments. arXiv preprint arXiv:1707.02286, 2017.
+
+Jonathan Ho and Stefano Ermon. Generative adversarial imitation learning. In Advances in Neural Information Processing Systems, pp. 4565–4573, 2016.
+
+Max Jaderberg, Volodymyr Mnih, Wojciech Marian Czarnecki, Tom Schaul, Joel Z Leibo, David Silver, and Koray Kavukcuoglu. Reinforcement learning with unsupervised auxiliary tasks. arXiv preprint arXiv:1611.05397, 2016.
+
+Stephen James, Andrew J. Davison, and Edward Johns. Transferring end-to-end visuomotor control from simulation to real world for a multi-stage task. CoRR, abs/1707.02267, 2017.
+
+Sham Kakade and John Langford. Approximately optimal approximate reinforcement learning. In ICML, 2002.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Vikash Kumar, Abhishek Gupta, Emanuel Todorov, and Sergey Levine. Learning dexterous manipulation policies from experience and imitation. CoRR, abs/1611.05095, 2016. URL http: //arxiv.org/abs/1611.05095.
+
+Sergey Levine and Vladlen Koltun. Guided policy search. In International Conference on Machine Learning (ICML), pp. 1–9, 2013.
+
+Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. CoRR, abs/1504.00702, 2015.
+
+Sergey Levine, Peter Pastor, Alex Krizhevsky, and Deirdre Quillen. Learning hand-eye coordination for robotic grasping with deep learning and large-scale data collection. CoRR, abs/1603.02199, 2016.
+
+Yunzhu Li, Jiaming Song, and Stefano Ermon. Inferring the latent structure of human decisionmaking from raw visual inputs. arXiv preprint arXiv:1703.08840, 2017.
+
+Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. International Conference on Learning Representations (ICLR), 2016.
+
+Yuxuan Liu, Abhishek Gupta, Pieter Abbeel, and Sergey Levine. Imitation from observation: Learning to imitate behaviors from raw video via context translation. CoRR, abs/1707.03374, 2017.
+
+Josh Merel, Yuval Tassa, Dhruva TB, Sriram Srinivasan, Jay Lemmon, Ziyu Wang, Greg Wayne, and Nicolas Heess. Learning human behaviors from motion capture by adversarial imitation. CoRR, abs/1707.02201, 2017.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015.
+
+Ashvin Nair, Bob McGrew, Marcin Andrychowicz, Wojciech Zaremba, and Pieter Abbeel. Overcoming exploration in reinforcement learning with demonstrations. CoRR, abs/1709.10089, 2017.
+
+Andrew Y Ng, Daishi Harada, and Stuart J Russell. Policy invariance under reward transformations: Theory and application to reward shaping. In ICML, pp. 278–287, 1999.
+
+Xue Bin Peng, Marcin Andrychowicz, Wojciech Zaremba, and Pieter Abbeel. Sim-to-Real Transfer of Robotic Control with Dynamics Randomization. ArXiv e-prints, October 2017.
+
+Lerrel Pinto and Abhinav Gupta. Supersizing self-supervision: Learning to grasp from 50k tries and 700 robot hours. CoRR, abs/1509.06825, 2015. URL http://arxiv.org/abs/1509. 06825.
+
+Lerrel Pinto, Marcin Andrychowicz, Peter Welinder, Wojciech Zaremba, and Pieter Abbeel. Asymmetric Actor Critic for Image-Based Robot Learning. ArXiv e-prints, 2017.
+
+Ivaylo Popov, Nicolas Heess, Timothy P. Lillicrap, Roland Hafner, Gabriel Barth-Maron, Matej Vecerik, Thomas Lampe, Yuval Tassa, Tom Erez, and Martin A. Riedmiller. Data-efficient deep reinforcement learning for dexterous manipulation. CoRR, abs/1704.03073, 2017.
+
+Rouhollah Rahmatizadeh, Pooya Abolghasemi, Ladislau Bol¨ oni, and Sergey Levine. Vision-based ¨ multi-task manipulation for inexpensive robots using end-to-end learning from demonstration. CoRR, abs/1707.02920, 2017. URL http://arxiv.org/abs/1707.02920.
+
+Aravind Rajeswaran, Vikash Kumar, Abhishek Gupta, John Schulman, Emanuel Todorov, and Sergey Levine. Learning complex dexterous manipulation with deep reinforcement learning and demonstrations. CoRR, abs/1709.10087, 2017.
+
+Stephane Ross, Geoffrey J Gordon, and Drew Bagnell. A reduction of imitation learning and struc- ´ tured prediction to no-regret online learning. In International Conference on Artificial Intelligence and Statistics, pp. 627–635, 2011.
+
+Andrei Rusu, Neil Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. arXiv preprint arXiv:1606.04671, 2016a.
+
+Andrei Rusu, Matej Vecerik, Thomas Rothorl, Nicolas Heess, Razvan Pascanu, and Raia Hadsell.¨ Sim-to-real robot learning from pixels with progressive nets. CoRR, abs/1610.04286, 2016b.
+
+Connor Schenck and Dieter Fox. Reasoning about liquids via closed-loop simulation. arXiv preprint arXiv:1703.01656, 2017.
+
+John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In Proceedings of the 32nd International Conference on Machine Learning (ICML-15), pp. 1889–1897, 2015.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
+
+Pierre Sermanet, Corey Lynch, Jasmine Hsu, and Sergey Levine. Time-contrastive networks: Selfsupervised learning from multi-view observation. CoRR, abs/1704.06888, 2017.
+
+David Silver, Guy Lever, Nicolas Heess, Thomas Degris, Daan Wierstra, and Martin Riedmiller. Deterministic policy gradient algorithms. In International Conference on Machine Learning (ICML), 2014.
+
+David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016.
+
+Joshua Tobin, Rachel Fong, Alex Ray, Jonas Schneider, Wojciech Zaremba, and Pieter Abbeel. Domain randomization for transferring deep neural networks from simulation to the real world. CoRR, abs/1703.06907, 2017.
+
+Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp. 5026– 5033. IEEE, 2012.
+
+Matej Vecerik, Todd Hester, Jonathan Scholz, Fumin Wang, Olivier Pietquin, Bilal Piot, Nicolas Heess, Thomas Rothorl, Thomas Lampe, and Martin A. Riedmiller. Leveraging demon- ¨ strations for deep reinforcement learning on robotics problems with sparse rewards. CoRR, abs/1707.08817, 2017.
+
+Ulrich Viereck, Andreas ten Pas, Kate Saenko, and Robert Platt. Learning a visuomotor controller for real world robotic grasping using easily simulated depth images. CoRR, abs/1706.04652, 2017.
+
+Ziyu Wang, Josh Merel, Scott E. Reed, Greg Wayne, Nando de Freitas, and Nicolas Heess. Robust imitation of diverse behaviors. NIPS, abs/1707.02747, 2017.
+
+Ali Yahya, Adrian Li, Mrinal Kalakrishnan, Yevgen Chebotar, and Sergey Levine. Collective robot reinforcement learning with distributed asynchronous guided policy search. CoRR, abs/1610.00673, 2016. URL http://arxiv.org/abs/1610.00673.
+
+# A EXPERIMENT DETAILS
+
+The policy network takes the pixel observation and the proprioceptive feature as input. The pixel observation is an RGB image of size $6 4 \times 6 4 \times 3$ . We used the Kinect for Xbox One camera in the real environment. The proprioceptive feature describes the joint positions and velocities of the Kinova Jaco arm. Each joint position is represented as the sin and cos of the angle of the joint in joint coordinates. Each joint velocity is represented as the scalar angular velocity. This results in a 24-dimensional proprioceptive feature that contains the positions (12-d) and velocities (6-d) of the six arm joints and the positions (6-d) of the three fingers. We exclude the finger velocities due to the noisy sensory readings on the real robot.
+
+We used Adam (Kingma & Ba, 2014) to train the neural network parameters. We set the learning rate of policy and value to $1 0 ^ { - 4 }$ and $1 0 ^ { - 3 }$ respectively, and $1 0 ^ { - 4 }$ for both the discriminator and the auxiliary tasks. The pixel observation is encoded by a two-layer convoluational network. We use 2 convolutional layers followed by a fully-connected layer with 128 hidden units. The first convolutional layer has $1 6 8 \times 8$ filters with stride 4 and the second $3 2 4 \times 4$ filters with stride 2. We add a recurrent layer of 100 LSTM units before the policy and value outputs. The policy output is the mean and the standard deviation of a conditional Gaussian distribution over the 9-dimensional joint velocities. The initial policy standard deviation is set to $\exp ( - 3 )$ for the clearing table with blocks task and $\exp ( - 1 )$ for the other five tasks. The auxiliary head of the policy contains a separate 3-layer MLP sitting on top of the convolutional network. The first two layers of the MLP has 200 and 100 hidden units respectively, while the third layer predicts the auxiliary outputs. Finally, the discriminator is a simple three-layer MLP of 100 and 64 hidden units for the first two layers with the third layer producing log probabilities. The networks use tanh nonlinearities.
+
+We trained the visuomotor policies using the distributed PPO algorithm (Heess et al., 2017) with synchronous gradient updates from 256 CPU workers. Each worker runs the policy to complete an entire episode before the parameter updates are computed. We set a constant episode length for each task based on its difficulty, with the longest being 1000 time steps (50 seconds) for the clearing table with blocks and order fulfillment tasks. We set $K = 5 0$ as the number of time steps for computing $K$ -step returns and truncated backpropagation through time to train the LSTM units. After a worker collects a batch of data points, it performs 50 parameter updates for the policy and value networks, 5 for the discriminator and 5 for the auxiliary prediction network.
+
+# B SIM2REAL DETAILS
+
+To better facilitate sim2real transfer, we lower the frequency at which we sample the observations. Pixel observations are only observed at the rate of $5 \mathrm { H z }$ despite the fact that our controller runs at $2 0 \mathrm { H z }$ . Similarly, the proprioceptive features are observed at a rate of $1 0 \mathrm { H z }$ . In addition to observation delays, we also apply domain variations. Gaussian noise (of standard deviation 0.01) are added proprioceptive features. Uniform integers noise in the range of $[ - 5 , 5 ]$ are added to each pixel independently. Pixels of values outside the range of $[ 0 , 2 5 5 ]$ are clipped. We also vary randomly the shade of grey on the Jaco arm, the color of the table top, as well as the location and orientation of the light source (see Fig. 6).
+
+In the case of block lifting, we vary in addition the dynamics of the arm. Specifically, we dynamically change the friction, damping, armature, and gain parameters of the robot arm in simulation to further robustify the agent’s performance.
+
+# B.1 ACTION DROPPING
+
+Our analysis indicates that, on the real robot, there is often a delay in the execution of actions. The amount of delay also varies significantly. This has an adverse effect on the performance of our agent on the physical robot since our agents’ performance depends on the timely execution of their actions. To better facilitate the transfer to the real robot, we fine-tune our trained agent in simulation while subjecting them to a random chance of dropping actions. Specifically, each action emitted by the agent has a $5 0 \%$ chance of being executed immediately in which case the action is flagged as the last executed action. If the current action is not executed, the last executed action will then be executed.
+
+![](images/6321f7405a110f1a781e4aefa1233f51f25d6f8eddd6d6a79a9b9948ef2629cc.jpg)  
+Figure 6: Tiles show the representative range of diversity seen in the domain-randomized variations of the colors, lighting, background, etc.
+
+Table 1: Block Lifting success rate from different positions. (LL, LR, UL, UR, and C represents the positions of lower left, lower right, upper left, upper right, and center respectively.)   
+
+<table><tr><td></td><td>LL</td><td>LR</td><td>UL</td><td>UR</td><td>C</td><td>All</td></tr><tr><td>No Action Dropping</td><td>2/5</td><td>2/5</td><td>1/5</td><td>3/5</td><td>4/5</td><td>12/25</td></tr><tr><td>Action Dropping</td><td>4/5</td><td>4/5</td><td>4/5</td><td>0/5</td><td>4/5</td><td>16/25</td></tr></table>
+
+Using the above procedure, we fine-tune our agents on both block lifting and block stacking for a further 2 million iterations.
+
+To demonstrate the effectiveness of action dropping, we compare our agent on the real robot over the task of block lifting. Without action dropping, the baseline agent lifts $4 \bar { 8 } \%$ percent of the time. After fine-tuning using action dropping, our agent succeeded $6 4 \%$ percent of the time. For the complete set of results, please see Table 1 and Table 2.
+
+# C TASK DETAILS
+
+We use a fixed episode length for each task, which is determined by the amount of time a skilled human demonstrator can complete the task. An episode terminates when a maximum number of agent steps are performed. The robot arm operates at a control frequency of $2 0 \mathrm { H z }$ , which means each time step takes 0.05 second.
+
+We segment into a sequence of stages that represent an agent’s progress in a task. For instance, the block stacking task can be characterized by three stages, including reaching the block, lifting the block and stacking the block. We define functions on the underlying physical state to determine the stage of a state. This way, we can cluster demonstration states according to their corresponding stages. These clusters are used to reset training episodes in our demonstration as a curriculum technique proposed in Sec. 3.2.2. The definition of stages also gives rise to a convenient way of specifying the reward functions without hand-engineering a shaping reward. We define a piecewise constant reward function for each task, where we assign the same constant reward to all the states that belong to the same stage. We detail the stages, reward functions, auxiliary tasks, and objectcentric features for the six tasks in our experiments.
+
+Block lifting. Each episode lasts 100 time steps. We define three stages and their rewards (in parentheses) to be initial (0), reaching the block (0.125) and lifting the block (1.0). The auxiliary task is to predict the 3D coordinates of the color block. The object-centric feature consists of the relative position between the gripper and the block.
+
+Block stacking. Each episode lasts 500 time steps. We define four stages and their rewards to be initial (0), reaching the orange block (0.125), lifting the orange block (0.25), and stacking the orange block onto the pink block (1.0). The auxiliary task is to predict the 3D coordinates of the two blocks.
+
+Table 2: Success rate of the block stacking agent from different starting positions. Left and Right indicates the position of the support block upon initialization.   
+
+<table><tr><td></td><td>Left</td><td>Right</td><td>All</td></tr><tr><td>Stacking Success Rate</td><td>5/10</td><td>2/10</td><td>7/20</td></tr><tr><td>Lifting Success Rate</td><td>9/10</td><td>7/10</td><td>16/20</td></tr></table>
+
+The object-centric feature consists of the relative positions between the gripper and the two blocks respectively.
+
+Clearing table with blocks. Each episode lasts 1000 time steps. We define five stages and their rewards to be initial (0), reaching the orange block (0.125), lifting the orange block (0.25), stacking the orange block onto the pink block (1.0), and lifting both blocks off the ground (2.0). The auxiliary task is to predict the 3D coordinates of the two blocks. The object-centric feature consists of the 3D positions of the two blocks as well as the relative positions between the gripper and the two blocks respectively.
+
+Clearing table with a box. Each episode lasts 500 time steps. We define five stages and their rewards to be initial (0), reaching the toy (0.125), grasping the toy (0.25), putting the toy into the box (1.0), and lifting the box (2.0). The auxiliary task is to predict the 3D coordinates of the toy and the box. The object-centric feature consists of the 3D positions of the toy and the box as well as the relative positions between the gripper and these two objects respectively.
+
+Pouring liquid. Each episode lasts 500 time steps. We define three stages and their rewards to be initial (0), grasping the mug (0.05), pouring $\left( 0 . 1 N \right)$ , where $N$ is the number of small spheres in the other container. The auxiliary task is to predict the 3D coordinates of the mug. The object-centric feature consists of the 3D positions of the mug, the relative position between the gripper and the mug, and the relative position between the mug and the container.
+
+Order fulfillment. Each episode lasts 1000 time steps. The number of objects varies from 1 to 4 across episodes. We define five stages that correspond to the number of toys in the boxes. The immediate reward corresponds to the number of toys placed in the correct boxes (number of toy planes in the green box and toy cars in the red box). To handle the variable number of objects, we only represent the objects nearest to the gripper for the auxiliary task and the object-centric feature. The auxiliary task is to predict the 3D coordinates of the nearest plane and the nearest car to the gripper. The object-centric feature consists of the relative positions from the gripper to these two nearest objects.

parse/train/HJWGdbbCW/HJWGdbbCW_content_list.json

@@ -0,0 +1,1689 @@
+[
+    {
+        "type": "text",
+        "text": "REINFORCEMENT AND IMITATION LEARNING FOR DIVERSE VISUOMOTOR SKILLS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            774,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose a general deep reinforcement learning method and apply it to robot manipulation tasks. Our approach leverages demonstration data to assist a reinforcement learning agent in learning to solve a wide range of tasks, mainly previously unsolved. We train visuomotor policies end-to-end to learn a direct mapping from RGB camera inputs to joint velocities. Our experiments indicate that our reinforcement and imitation approach can solve contact-rich robot manipulation tasks that neither the state-of-the-art reinforcement nor imitation learning method can solve alone. We also illustrate that these policies achieved zero-shot sim2real transfer by training with large visual and dynamics variations. ",
+        "bbox": [
+            233,
+            268,
+            764,
+            393
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            424,
+            336,
+            440
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent advances in deep reinforcement learning (RL) have performed very well in several challenging domains such as video games (Mnih et al., 2015) and Go (Silver et al., 2016). For robotics, RL in combination with powerful function approximators provides a general framework for designing sophisticated controllers that would be hard to handcraft otherwise. Yet, despite significant leaps in other domains the application of deep RL to control and robotic manipulation has proven challenging. While there have been successful demonstrations of deep RL for manipulation (e.g. Nair et al. 2017; Popov et al. 2017) and also noteworthy applications on real robotic hardware (e.g. Levine et al. 2015; Yahya et al. 2016) there have been very few examples of learned controllers for sophisticated tasks even in simulation. ",
+        "bbox": [
+            174,
+            457,
+            825,
+            582
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Robotics exhibits several unique challenges. These include the need to rely on multi-modal and partial observations from noisy sensors, such as cameras. At the same time, realistic tasks often come with a large degree of variation (visual appearance, position, shapes, etc.) posing significant generalization challenges. Training on real robotics hardware can be daunting due to constraints on the amount of training data that can be collected in reasonable time. This is typically much less than the millions of frames needed by modern algorithms. Safety considerations also play an important role, as well as the difficulty of accessing information about the state of the environment (like the position of an object) e.g. to define a reward. Even in simulation when perfect state information and large amounts of training data are available, exploration can be a significant challenge. This is partly due to the often high-dimensional and continuous action space, but also due to the difficulty of designing suitable reward functions. ",
+        "bbox": [
+            174,
+            589,
+            825,
+            742
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we present a general deep reinforcement learning method that addresses these issues and that can solve a wide range of robot arm manipulation tasks directly from pixels, most of which have not been solved previously. Our key insight is 1) to reduce the difficulty of exploration in continuous domains by leveraging a handful of human demonstrations; 2) several techniques to stabilize the learning of complex manipulation policies from vision; and 3) to improve generalization by increasing the diversity of the training conditions. As a result, the trained policies work well under significant variations of system dynamics, object appearances, task lengths, etc. We ground these policies in the real world, demonstrating zero-shot transfer from simulation to real hardware. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            861
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We develop a new method to combine imitation learning with reinforcement learning. Our method requires only a small number of human demonstrations to dramatically simplify the exploration problem. It uses demonstration data in two ways: first, it uses a hybrid reward that combines sparse environment reward with imitation reward based on Generative Adversarial Imitation Learning (Ho & Ermon, 2016), which produces more robust controllers; second, it uses demonstration as a curriculum to initiate training episodes along demonstration trajectories, which facilitates the agent to reach new states and solve longer tasks. As a result, it solves dexterous manipulation tasks that neither the state-of-the-art reinforcement learning nor imitation learning method can solve alone. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/3da1dcf2a407228cf883b16987f42fe9cbfef255dde0766f2788e3e98e48d9b5.jpg",
+        "image_caption": [
+            "Figure 1: Our proposal of a principled robot learning pipeline. We used 3D motion controllers to collect human demonstrations of a task. Our reinforcement and imitation learning model leveraged these demonstrations to facilitate learning in a simulated physical engine. We then performed sim2real transfer to deploy the learned visuomotor policy to a real robot. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            97,
+            808,
+            248
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            351,
+            823,
+            406
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Previous RL-based robot manipulation policies (Nair et al., 2017; Popov et al., 2017) largely rely on low-level states as input, or use severely limited action spaces that ignore the arm and instead learn Cartesian control of a simple gripper. This limits the ability of these methods to represent and solve more complex tasks (e.g., manipulating arbitrary 3D objects) and to deploy in real environments where the privileged state information is unavailable. Our method learns an end-to-end visuomotor policy that maps RGB camera observations to joint space control over the full 9-DoF arm (6 arm joints plus 3 actuated fingers). ",
+        "bbox": [
+            174,
+            414,
+            825,
+            511
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To sidestep the constraints of training on real hardware we embrace the sim2real paradigm which has recently shown promising results (James et al., 2017; Rusu et al., 2016a). Through the use of a physics engine and high-throughput RL algorithms, we can simulate parallel copies of a robot arm to perform millions of complex physical interactions in a contact-rich environment while eliminating the practical concerns of robot safety and system reset. Furthermore, we can, during training, exploit privileged information about the true system state with several new techniques, including learning policy and value in separate modalities, an object-centric GAIL discriminator, and auxiliary tasks for visual modules. These techniques stabilize and speed up policy learning from pixels. ",
+        "bbox": [
+            174,
+            518,
+            825,
+            630
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Finally, we diversify training conditions such as visual appearance as well as e.g. the size and shape of objects. This improves both generalization with respect to different task conditions as well as transfer from simulation to reality. ",
+        "bbox": [
+            174,
+            637,
+            825,
+            679
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate our method, we use the same model and the same algorithm for visuomotor control of six diverse robot arm manipulation tasks. Combining reinforcement and imitation, our policies solve the tasks that the state-of-the-art reinforcement and imitation learning cannot solve and outperform human demonstrations. Our approach sheds light on a principled deep visuomotor learning pipeline illustrated in Fig. 1, from collecting real-world human demonstration to learning in simulation, and back to real-world deployment via sim2real policy transfer. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            770
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            792,
+            341,
+            809
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement learning methods have been extensively used with low-dimensional policy representations such as movement primitives to solve a variety of control problems both in simulation and in reality. Three classes of RL algorithms are currently dominant for continuous control problems: guided policy search methods (GPS; Levine & Koltun 2013), value-based methods such as the deterministic policy gradient (DPG; Silver et al. 2014; Lillicrap et al. 2016; Heess et al. 2015) or the normalized advantage function (NAF; Gu et al. 2016b) algorithm, and trust-region based policy gradient algorithms such as trust region policy optimization (TRPO) and proximal policy optimization (PPO). TRPO (Schulman et al., 2015) and PPO (Schulman et al., 2017) hold appeal due to their robustness to hyper-parameter settings as well as their scalability (Heess et al., 2017) but the lack of sample efficiency makes them unsuitable for training directly on robotics hardware. ",
+        "bbox": [
+            174,
+            825,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "GPS (Levine & Koltun, 2013) has been used e.g. by Levine et al. (2015) and Yahya et al. (2016) to learn visuomotor policies directly on a real robotics hardware after a network pretraining phase. Gupta et al. (2016) and Kumar et al. (2016) use GPS for learning controllers for robotic hand models. Value-based methods have been employed, e.g. by Gu et al. (2016a) who use NAF to learn a door opening task directly on a robot while Popov et al. (2017) demonstrate how to solve a stacking problem efficiently using a distributed variant of DPG. ",
+        "bbox": [
+            174,
+            152,
+            823,
+            236
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The idea of using large-scale data collection for training visuomotor controllers has been the focus of Levine et al. (2016) and Pinto & Gupta (2015) who train a convolutional network to predict grasp success for diverse sets of objects using a large dataset with 10s or 100s of thousands of grasp attempts collected from multiple robots in a self-supervised setting. ",
+        "bbox": [
+            174,
+            243,
+            825,
+            299
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "An alternative strategy for dealing with the data demand is to train in simulation and transfer the learned controller to real hardware, or to augment real-world training with synthetic data. Rusu et al. (2016b) learn simple visuomotor policies for a Jaco robot arm and transfer to reality using progressive networks (Rusu et al. 2016a). Viereck et al. (2017) minimize the reality gap by relying on depth. Tobin et al. (2017) use visual variations to learn robust object detectors that can transfer to reality; James et al. (2017) combine randomization with supervised learning. Bousmalis et al. (2017) augments the training with simulated data to learn grasp prediction of diverse shapes. ",
+        "bbox": [
+            174,
+            306,
+            825,
+            404
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Suitable cost functions and exploration strategies for control problems are challenging to design, so demonstrations have long played an important role. Demonstrations can be used to initialize policies, design cost functions, guide exploration, augment the training data, or a combination of these. Cost functions can be derived from demonstrations either via tracking objectives (e.g. Gupta et al. 2016) or, via inverse RL (e.g. Boularias et al. 2011; Finn et al. 2016), or, as in our case, via adversarial learning (Ho & Ermon, 2016). When expert actions or expert policies are available, behavioral cloning or DAgger can be used (Rahmatizadeh et al. 2017; James et al. 2017; Duan et al. 2017). Alternatively, expert trajectories can be used as additional training data for off-policy algorithms such as DPG (e.g. Vecerik et al. 2017). Most of these methods require observation and/or action spaces to be aligned between robot and demonstrations. Recently, methods for third person imitation have been proposed (e.g. Sermanet et al. 2017; Liu et al. 2017; Finn et al. 2017). ",
+        "bbox": [
+            174,
+            410,
+            825,
+            563
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Concurrently with our work several papers have presented results on manipulation tasks. Rajeswaran et al. (2017); Nair et al. (2017) both use human demonstrations to aid exploration. Nair et al. (2017) extends the DDPGfD algorithm (Vecerik et al., 2017) to learn a block stacking task on a position-controlled arm in simulation. Rajeswaran et al. (2017) use the demonstrations with a form of behavioral cloning and data augmentation to learn several complex manipulation tasks. In both cases, controllers observe a low-dimensional state space representation and the methods inherently require aligned state and action spaces with the demonstrations. Pinto et al. (2017) and Peng et al. (2017) address the transfer from simulation to reality, focusing on randomizing visual appearance and robot dynamics respectively. Peng et al. transfer a block-pushing policy operating from state features to a 7-DoF position controlled Fetch robotics arm. Pinto et al. consider different tasks using visual input with end-effector position control. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            723
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            750,
+            267,
+            765
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our goal is to learn a deep visuomotor policy for robot manipulation tasks. The policy takes both an RGB camera observation and a proprioceptive feature that describes the joint positions and angular velocities. These two sensory modalities are also available on the real robot, enabling us to perform zero-shot policy transfer once trained in simulation. Fig. 2 provides an overview of our model. The deep visuomotor policy encodes the pixel observation with a convolutional network (CNN) and the proprioceptive feature with a multilayer perceptron (MLP). The features from these two modules are concatenated and passed to a recurrent LSTM layer before producing the joint velocities. The whole network is trained end-to-end. We start with a brief review of the basics of generative adversarial imitation learning (GAIL) and proximal policy optimization (PPO). Our model extends upon these two methods for visuomotor skills. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/1631fa6f9bf52330c1120085322dc3e3cd32e7871d2a6cfc35443316773b4738.jpg",
+        "image_caption": [
+            "Figure 2: Model overview. The core of our model is the deep visuomotor policy, which takes the camera observation and the proprioceptive feature as input and produces the next joint velocities. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            102,
+            823,
+            281
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 BACKGROUND: GAIL AND PPO ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            357,
+            437,
+            371
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Imitation learning $\\left( \\operatorname { I L } \\right)$ is the problem of learning a behavior policy by mimicking a set of demonstrations. Here we assume that human demonstration is provided as a dataset of state-action pairs $\\mathcal { D } = \\{ ( s _ { i } , a _ { i } ) \\} _ { i = 1 \\ldots N }$ . Traditional $\\mathrm { I L }$ methods cast it as a supervised learning problem, i.e., behavior cloning. These methods use maximum likelihood to train a parameterized policy $\\pi _ { \\theta } : { \\mathcal { S } }  A$ , where $s$ is the state space and $\\mathcal { A }$ is the action space, such that $\\begin{array} { r } { \\theta ^ { * } = \\arg \\operatorname* { m a x } _ { \\theta } \\sum _ { N } \\log \\pi _ { \\theta } ( a _ { i } | s _ { i } ) } \\end{array}$ . The behavior cloning approach works effectively in cases when the demonstrations abound (Ross et al., 2011). However, as robot demonstrations can be costly and time-consuming, we are in favor of a method that can learn from a handful of demonstrations. GAIL (Ho & Ermon, 2016) makes a more efficient use of demonstration data by allowing the agent to interact with the environment and learn from its own experiences. Similar to Generative Adversarial Networks (Goodfellow et al., 2014), GAIL has two networks, a policy network $\\pi _ { \\theta } : { \\mathcal { S } }  A$ and a discriminator network $D _ { \\psi } : \\mathcal { S } \\times \\mathcal { A }  [ 0 , 1 ]$ . GAIL uses a similar min-max objective function as in GANs: ",
+        "bbox": [
+            173,
+            383,
+            825,
+            551
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9c4f8866da7ee59654d286273a583adf6d8943ddf467cd570a7d215ca21a7ec9.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\psi } \\theta \\operatorname* { m a x } _ { \\psi } \\mathbb { E } _ { \\pi _ { E } } [ \\log D _ { \\psi } ( s , a ) ] + \\mathbb { E } _ { \\pi _ { \\theta } } [ \\log ( 1 - D _ { \\psi } ( s , a ) ) ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            305,
+            559,
+            686,
+            584
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\pi _ { E }$ denotes the expert policy that generated the demonstration trajectories. This learning objective encourages the policy $\\pi _ { \\theta }$ to have an occupancy measure close to the expert policy $\\pi _ { E }$ . ",
+        "bbox": [
+            173,
+            593,
+            823,
+            622
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In practice, we train $\\pi _ { \\theta }$ with policy gradient methods to maximize the discounted sum of the reward function $r _ { g a i l } ( s _ { t } , a _ { t } ) = - \\log ( 1 - D _ { \\psi } ( s _ { t } , a _ { t } ) )$ , clipped by a max value of 10. In continuous domains, trust region methods greatly stabilize policy training. The original GAIL model uses TRPO (Schulman et al., 2015) in the policy update steps. Recently, PPO (Schulman et al., 2017) is proposed as a simple and scalable approximation to TRPO. PPO only relies on the first-order gradients and can be easily implemented with recurrent networks in a distributed setting (Heess et al., 2017). The key idea of PPO is to use the Kullback-Leibler (KL) divergence to dynamically change the coefficient of a regularization term, where the coefficient is adapted based on whether the previous policy update step violates the KL constraint. We use distributed PPO to perform data collection and synchronous gradient updates across many workers in parallel. We trained all our policies with 256 CPU workers, which brings a significant speedup in wall-clock time. ",
+        "bbox": [
+            173,
+            628,
+            825,
+            781
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 REINFORCEMENT AND IMITATION LEARNING MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            801,
+            584,
+            815
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2.1 HYBRID IL/RL REWARD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            828,
+            400,
+            843
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A common approach to guiding exploration is by engineering a shaping reward. Although reward shaping sometimes provides informative guidance for policy search, it has the well-known drawback of producing suboptimal behaviors $\\mathrm { N g }$ et al., 1999). Hence, we use sparse piecewise constant rewards in this work. Training agents in continuous domains under sparse rewards is particularly challenging. Inspired by reward augmentation introduced in Li et al. 2017 and Merel et al. 2017, we design a hybrid reward function to mix the imitation reward $r _ { g a i l }$ with the sparse task reward $r _ { t a s k }$ : ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            119
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b09e15623db4471ab802155e90a36c22662af4905306191d0f28a746ce0b836e.jpg",
+        "text": "$$\nr ( s _ { t } , a _ { t } ) = \\lambda r _ { g a i l } ( s _ { t } , a _ { t } ) + ( 1 - \\lambda ) r _ { t a s k } ( s _ { t } , a _ { t } ) \\quad \\lambda \\in [ 0 , 1 ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            127,
+            700,
+            145
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Maximizing this hybrid reward can be interpreted as simultaneous reinforcement and imitation learning, where the imitation reward encourages the policy to generate trajectories closer to demonstration trajectories, and the task reward encourages the policy to achieve high returns in the task. Setting $\\lambda$ to either 0 or 1 reduces this method to the standard RL or GAIL setups. Our experiments suggest that with a balanced contribution of these two rewards, the agents can solve tasks that neither GAIL nor RL can solve alone. Further, the final agents achieved higher returns than the human demonstrations owing to the exposure to task rewards. ",
+        "bbox": [
+            174,
+            151,
+            825,
+            250
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2.2 LEVERAGING PHYSICAL STATES IN SIMULATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            267,
+            568,
+            281
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The use of simulated system provides us access to the underlying physical states. Even though such privileged information is unavailable on a real system, we can take advantage of it when training the policy in simulation. We propose four techniques to leverage the physical states in simulation to stabilize and accelerate learning, including demonstration curriculum, learning value from states, building object-centric discriminator, and auxiliary tasks. ",
+        "bbox": [
+            174,
+            291,
+            825,
+            361
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Demonstration as a curriculum. The problem of exploration in continuous domains is exacerbated by the long duration of realistic tasks. Previous work indicates that shaping the distribution of start states towards states where the optimal policy tends to visit can greatly improve policy learning (Kakade & Langford, 2002; Popov et al., 2017). We alter the start state distribution with demonstration states. We build a curriculum that contains clusters of states in different stages of a task. For instance, we define three clusters for the pouring task, including reaching the mug, grasping the mug, and pouring. For a training episode, with probability $\\epsilon$ we start it from a random initial state, and with probability $1 - \\epsilon$ we uniformly select a cluster and reset the episode to a demonstration state from the cluster. This is possible as our simulated system is fully characterized by the physical states. ",
+        "bbox": [
+            174,
+            368,
+            825,
+            507
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Learning value functions from states. PPO uses a learnable value function $V _ { \\phi }$ to estimate the advantage for policy gradient. During training, each PPO worker executes the policy for $K$ steps and uses the discounted sum of rewards and the value as an advantage function estimator $\\hat { A } _ { t } \\overset { \\cdot } { = }$ $\\begin{array} { r } { \\sum _ { i = 1 } ^ { K } \\gamma ^ { i - 1 } r _ { t + i } + \\gamma ^ { K - 1 } V _ { \\phi } ( s _ { t + K } ) - V _ { \\phi } ( s _ { t } ) , } \\end{array}$ , where $\\gamma$ is the discount factor. As the policy gradient relies on the value function to reduce variance, it is beneficial to accelerate learning of the value function. Rather than using pixel inputs as the policy network, we take advantage of the low-level physical states (e.g., the position and velocity of the 3D objects and the robot arm) to train the value $V _ { \\phi }$ with a smaller multilayer perceptron. We find that training the policy and value in two different modalities stabilizes training and reduces oscillation in the agent’s performance. This technique has also been adopted by a concurrent work by Pinto et al. 2017. ",
+        "bbox": [
+            173,
+            513,
+            825,
+            659
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Object-centric discriminator. Similar to the value function, the GAIL discriminator leverages the physical states to construct task-specific features as its input. In manipulation tasks, we find that object-centric representations (e.g., absolute and relative positions of the objects) provide the salient and relevant signals to the discriminator. The states of the robot arm, on the contrary, tend to make the discriminator too strong and stagnate the training of the policy. Inspired by information hiding strategies used in locomotion domains (Heess et al., 2016; Merel et al., 2017), our discriminator only takes the object-centric features as input while masking out arm-related information. ",
+        "bbox": [
+            174,
+            665,
+            825,
+            762
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "State prediction auxiliary tasks. Auxiliary tasks have been shown effective in improving the learning efficiency and the final performance of deep RL methods (Jaderberg et al., 2016). To facilitate learning visuomotor policies, we add a state prediction layer on the top of the CNN module to predict the locations of objects from the camera observation. We use a fully-connected layer to regress the 3D coordinates of objects in the task. We train this auxiliary task by minimizing the $\\ell _ { 2 }$ loss between the predicted and ground-truth object locations. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            853
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2.3 SIM2REAL POLICY TRANSFER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            871,
+            441,
+            885
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Policy transfer is shown to a real-world Kinova Jaco robot arm. The simulation was manually aligned to generally match the visuals and dynamics: a Kinect camera was visually calibrated to match the position and orientation of the simulated camera, and the simulation’s dynamics parameters were manually adjusted to match the dynamics of the real arm. Instead of using professional calibration equipment, our approach to sim2real policy transfer relies on domain randomization of camera position and orientation (Tobin et al., 2017; James et al., 2017). in contrast, we do not create intermediate position goals using object position information in reality, but rather train an end-to-end, pixels to velocities, feedback control policy. In addition, to alleviate the issues caused by latency on the real robot, we also fine-tune our policies while subjecting them to action dropping. Detailed descriptions are available in Appendix B. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            239,
+            326,
+            256
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here we demonstrate that our proposed approach offers a general framework to visuomotor policy learning. We evaluate the performance of our model in six manipulation tasks illustrated in Fig. 3. We provide more qualitative results in this video. ",
+        "bbox": [
+            176,
+            273,
+            825,
+            315
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 ENVIRONMENT SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            337,
+            370,
+            352
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We use a Kinova Jaco arm that has 9 degrees of freedom, including six arm joints and three actuated fingers. The robot arm interacts with a diverse set of objects on a tabletop. The visuomotor policy controls the robot using joint velocity commands. Our policy produces 9-dimensional continuous velocities in the range of $[ - 1 , 1 ]$ at $2 0 \\mathrm { H z }$ . The proprioceptive features consist of the positions and angular velocities of the arm joints and the fingers. We use a positioned camera to collect real-time RGB observations. The proprioceptive features and the camera observations are available in both simulation and real environments. Thus, it enables policy transfer. ",
+        "bbox": [
+            174,
+            364,
+            823,
+            462
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We use the MuJoCo physics simulator (Todorov et al., 2012) as our training platform. We use a large variety of objects, from basic geometric shapes to procedurally generated 3D objects as ensembles of primitive shapes. We increase the diversity of objects by randomizing various physical properties, including dimension, color, mass, friction, etc. We used a 3D motion controller called SpaceNavigator, which allows us to operate the robot arm with a position controller, to collect 30 episodes of demonstration for each task and recorded the observations, actions, and physical states into a dataset. As each episode takes less than a minute to complete, demonstrating each task can be done within half an hour. ",
+        "bbox": [
+            174,
+            469,
+            825,
+            580
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 ROBOT ARM MANIPULATION TASKS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            602,
+            465,
+            616
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Fig. 3 shows visualizations of the six manipulation tasks in our experiments. The first column shows the six tasks in simulated environments, and the second column shows the real-world setup of the block lifting and stacking tasks. We see obvious visual discrepancies of the same task in simulation and reality. These six tasks exhibit learning challenges to varying degrees. The first three tasks use simple colored blocks, which allows us to easily construct the tasks for a real robot. We study sim2real policy transfer with the block lifting and stacking tasks in Sec. 4.4. ",
+        "bbox": [
+            174,
+            630,
+            823,
+            713
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Block lifting. The goal is to grasp and lift a randomized block, allowing us to evaluate the model’s robustness. We vary several random factors, including the robot arm dynamics (friction and armature), lighting conditions, camera poses, background colors, as well as the properties of the block. Each episode starts with a new configuration with these random factors uniformly drawn from a preset range. ",
+        "bbox": [
+            174,
+            720,
+            823,
+            790
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Block stacking. The goal is to stack one block on top of the other block. Together with the block lifting task, this is evaluated in sim2real transfer experiments. ",
+        "bbox": [
+            174,
+            797,
+            821,
+            825
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Clearing blocks. This task aims at clearing the tabletop that has two blocks. One strategy to do this task using a single arm is to stack the blocks and pick up both together. This task requires longer time and a more dexterous controller, introducing a significant challenge for exploration. ",
+        "bbox": [
+            176,
+            833,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The next three tasks involve a large variety of procedurally generated 3D shapes, making them difficult to recreate in real environments. We use them to examine the model’s ability to generalize across object variations in long and complex tasks. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/500c4e82d7c70a53a90aba7e6097cefcf2952fcef850a953da75af3119384acf.jpg",
+        "image_caption": [
+            "Figure 3: Visualizations of the six manipulation tasks in our experiments. The left column shows RGB images of all six tasks in the simulated environments. These images correspond to the actual pixel observations as input to the visuomotor policies. The right column shows the two tasks with color blocks on the real robot. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            102,
+            823,
+            390
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Clearing tabletop. In this task, the goal is to clear the tabletop that has a box and a toy car. One strategy is to grasp the toy, put it into the box, and lift the box. Both the box and the toy car are randomly generated for each episode. ",
+        "bbox": [
+            176,
+            489,
+            821,
+            531
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Pouring liquid. Modeling and reasoning about deformable objects and fluids is a long-standing challenge in the robotics community (Schenck & Fox, 2017). We design a pouring task where we use many small spheres to simulate liquid. The goal is to pour the “liquid” from one mug to the other container. This task is particularly challenging due to the dexterity required. Even trained humans struggled to demonstrate the task with our 3D motion controller. ",
+        "bbox": [
+            174,
+            539,
+            825,
+            608
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Order fulfillment. In this task, we randomly place a variable number of procedurally generated toy planes and cars on the table. The goal is to place all the planes into the green box and all the cars into the red box. This task requires the policy to generalize at an abstract level. It needs to recognize the object categories, perform successful grasps on diverse shapes, and handle tasks with variable lengths. ",
+        "bbox": [
+            174,
+            616,
+            825,
+            685
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 QUANTITATIVE EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            708,
+            415,
+            722
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our full model can solve all six tasks, with only occasional failures, using the same policy network, the same training algorithm, and a fixed set of hyperparameters. On the contrary, neither reinforcement nor imitation alone can solve all tasks. We compare the full model with three baseline methods, where we evaluate degenerated versions of our model, which correspond to RL, GAIL, and RL w/o demonstration curriculum. These baselines use the same setup as the full model, except that we set $\\lambda = 0$ for RL and $\\lambda = 1$ for GAIL, while our model uses a balanced contribution of the hybrid reward, where $\\lambda = 0 . 5$ . In the third baseline, all the training episodes start from random initial states rather than resetting to demonstration states. This corresponds to a standard RL setup. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            847
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We report the mean episode returns as a function of the number of training iterations in Fig. 4. Our full model achieves the highest returns in all six tasks. The only case where the baseline model is on par with the full model is the block lifting task, in which both the RL baseline and the full model achieved similar levels of performance. We hypothesize that this is due to the short length of the lifting task, where random exploration in RL is likely to reach the goal states without the aid of GAIL. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/f42db9c29d42cf74a7da404a6d76c2b791f22b99a1f70b41c8fa2f490e715488.jpg",
+        "image_caption": [
+            "Figure 4: Learning efficiency of our reinforcement and imitation model against baselines. The plots are averaged over 5 runs with different random seeds. All the policies use the same network architecture and the same hyperparameters (except $\\lambda$ ). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            101,
+            818,
+            392
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/44c129be75f9308aefc493276536f020f20acf69c3de0ed33d53b3c232e1476a.jpg",
+        "image_caption": [
+            "Figure 5: Model analysis in the stacking task. On the left we investigate the impact on performance by removing each individual component from the full model. On the right we investigate the model’s sensitivity to the hyperparameter $\\lambda$ that moderates the contribution of reinforcement and imitation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            460,
+            818,
+            666
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In the other five tasks, the full model outperforms both the reinforcement learning and imitation learning baselines by a large margin, demonstrating the effectiveness of combining reinforcement and imitation for learning complex tasks. Comparing the two variants of RL with and without using demonstration as a curriculum, we see a pronounced effect of altering the start state distribution. We see that RL from scratch leads to a very slow learning progress; while initiating episodes along demonstration trajectories enables the agent to train on states from different stages of a task. As a result, it greatly reduces the burden of exploration and improves the learning efficiency. We also report the mean episode returns of human demonstrations in these figures. While demonstrations using the 3D motion controller are imperfect, especially for pouring (see video), the trained agents can surpass them via interacting with the environment. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Two findings are noteworthy. First, the RL agent learns faster than the full model in the table clearing task, but the full model eventually outperforms. This is because the full model discovers a novel strategy, different from the strategy demonstrated by human operators (see video). In this case, imitation gave contradictory signals but eventually, reinforcement learning guided the policy towards a better strategy. Second, pouring liquid is the only task where GAIL outperforms its RL counterpart. Imitation can effectively shape the agent’s behaviors towards the demonstration trajectories (Wang et al., 2017). This is a viable solution for the pouring task, where a controller that generates similar-looking behaviors can complete the task. In contact-rich domains, however, a controller learned solely from dozens of demonstrations would struggle to handle complex object dynamics and to infer the true task goal. We hypothesize that this is why the baseline RL agent outperforms the GAIL agent in the other five tasks. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            228
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We further perform an ablation study in the block stacking task to understand the impacts of different components of our model. In Fig. 5a, we trained our agents with a number of configurations, each with a single modification to the full model. We see that the final performances of the experiments cluster into two groups: agents that learn to stack (with average returns greater than 400) and agents that only learn to lift (with average returns between 200 and 300). These results indicate that the hybrid RL/IL reward, learning value function from states, and object-centric discriminator play an integral role in learning good policies. Using sole RL or GAIL reward, learning value function on pixels, or no information hiding for discriminator input (no discriminator mask) all result in inferior performances. In contrast, the optional components include the recurrent policy core (LSTM), the use of state prediction auxiliary tasks, and whether to include actions in discriminator input. We then examine the model’s sensitivity to the $\\lambda$ values in Eq. 2. We see in Fig. 5b that, our model works well with a broad range of $\\lambda$ values from 0.3 to 0.7 that provide a balanced mix of the RL and GAIL rewards. ",
+        "bbox": [
+            174,
+            236,
+            825,
+            415
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4 SIM2REAL POLICY TRANSFER RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            438,
+            495,
+            452
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To assess the robustness of the simulation-trained policy, we evaluate zero-shot transfer (no additional training) on a real Jaco arm. Given a real-world set up that mirrored the simulated domain to a large extent, including camera positions and robot kinematics and approximate object size and color, we ran the trained network policy and counted the number of successful trials for both the lifting and stacking tasks. Although the sim and real domains were similar, there was still a sizable reality gap that made zero-shot transfer challenging. For example, the objects were non-rigid foam blocks which deformed and bounced unpredictably. The arm position was randomly initialized and the target block(s) placed in a number of repeatable start configurations for each task. The zero-shot transfer of the lifting policy had a success rate of $6 4 \\%$ over 25 trials (split between 5 block configurations). The stacking policy had a success rate of $3 5 \\%$ over 20 trials (split between 2 block configurations). $8 0 \\%$ of the stacking trajectories, however, contain successful lifting behavior. Qualitatively, the policies are notably robust even on failed attempts — rather than exhibiting “open-loop” behaviors such as attempting to stack a non-existent block, the policy repeatedly chases the block to get a successful grasp before trying to stack (see video). For more detailed descriptions of the sim2real results, refer to Appendix B. ",
+        "bbox": [
+            174,
+            465,
+            825,
+            672
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            698,
+            318,
+            714
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have shown that combining reinforcement and imitation learning considerably improves the agents’ ability to solve challenging dexterous manipulation tasks from pixels. Our proposed method sheds light on the three stages of a principled pipeline for robot skill learning: first, we collected a small amount of demonstration data to simplify the exploration problem; second, we relied on physical simulation to perform large-scale distributed robot training; and third, we performed sim2real transfer for real-world deployment. In future work, we seek to improve the sample efficiency of the learning method and to leverage real-world experience to close the reality gap for policy transfer. ",
+        "bbox": [
+            174,
+            733,
+            825,
+            830
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            856,
+            285,
+            871
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Abdeslam Boularias, Jens Kober, and Jan Peters. Relative entropy inverse reinforcement learning. In JMLR Workshop and Conference Proceedings Volume 15: AISTATS 2011, pp. 182–189, Cambridge, MA, USA, April 2011. MIT Press. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Konstantinos Bousmalis, Alex Irpan, Paul Wohlhart, Yunfei Bai, Matthew Kelcey, Mrinal Kalakrishnan, Laura Downs, Julian Ibarz, Peter Pastor, Kurt Konolige, Sergey Levine, and Vincent Vanhoucke. Using Simulation and Domain Adaptation to Improve Efficiency of Deep Robotic Grasping. ArXiv e-prints, 2017. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yan Duan, Marcin Andrychowicz, Bradly C. Stadie, Jonathan Ho, Jonas Schneider, Ilya Sutskever, Pieter Abbeel, and Wojciech Zaremba. One-shot imitation learning. CoRR, abs/1703.07326, 2017. URL http://arxiv.org/abs/1703.07326. ",
+        "bbox": [
+            178,
+            169,
+            821,
+            212
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn, Sergey Levine, and Pieter Abbeel. Guided cost learning: Deep inverse optimal control via policy optimization. In Proceedings of the 33nd International Conference on Machine Learning, ICML 2016, New York City, NY, USA, June 19-24, 2016, pp. 49–58, 2016. URL http://jmlr.org/proceedings/papers/v48/finn16.html. ",
+        "bbox": [
+            178,
+            219,
+            821,
+            277
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn, Tianhe Yu, Tianhao Zhang, Pieter Abbeel, and Sergey Levine. One-Shot Visual Imitation Learning via Meta-Learning. ArXiv e-prints, 2017. ",
+        "bbox": [
+            173,
+            285,
+            823,
+            314
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014. ",
+        "bbox": [
+            174,
+            321,
+            823,
+            366
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shixiang Gu, Ethan Holly, Timothy P. Lillicrap, and Sergey Levine. Deep reinforcement learning for robotic manipulation. CoRR, abs/1610.00633, 2016a. ",
+        "bbox": [
+            174,
+            375,
+            823,
+            404
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shixiang Gu, Tim Lillicrap, Ilya Sutskever, and Sergey Levine. Continuous deep q-learning with model-based acceleration. In International Conference on Machine Learning (ICML), 2016b. ",
+        "bbox": [
+            174,
+            411,
+            823,
+            441
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Abhishek Gupta, Clemens Eppner, Sergey Levine, and Pieter Abbeel. Learning dexterous manipulation for a soft robotic hand from human demonstration. CoRR, abs/1603.06348, 2016. ",
+        "bbox": [
+            173,
+            449,
+            823,
+            479
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Heess, Gregory Wayne, David Silver, Tim Lillicrap, Tom Erez, and Yuval Tassa. Learning continuous control policies by stochastic value gradients. In Advances in Neural Information Processing Systems (NIPS), pp. 2926–2934, 2015. ",
+        "bbox": [
+            173,
+            487,
+            823,
+            530
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Heess, Greg Wayne, Yuval Tassa, Timothy Lillicrap, Martin Riedmiller, and David Silver. Learning and transfer of modulated locomotor controllers. arXiv preprint arXiv:1610.05182, 2016. ",
+        "bbox": [
+            174,
+            537,
+            823,
+            582
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Heess, Srinivasan Sriram, Jay Lemmon, Josh Merel, Greg Wayne, Yuval Tassa, Tom Erez, Ziyu Wang, Ali Eslami, Martin Riedmiller, et al. Emergence of locomotion behaviours in rich environments. arXiv preprint arXiv:1707.02286, 2017. ",
+        "bbox": [
+            174,
+            589,
+            823,
+            633
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Ho and Stefano Ermon. Generative adversarial imitation learning. In Advances in Neural Information Processing Systems, pp. 4565–4573, 2016. ",
+        "bbox": [
+            171,
+            641,
+            825,
+            671
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Max Jaderberg, Volodymyr Mnih, Wojciech Marian Czarnecki, Tom Schaul, Joel Z Leibo, David Silver, and Koray Kavukcuoglu. Reinforcement learning with unsupervised auxiliary tasks. arXiv preprint arXiv:1611.05397, 2016. ",
+        "bbox": [
+            176,
+            679,
+            823,
+            722
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stephen James, Andrew J. Davison, and Edward Johns. Transferring end-to-end visuomotor control from simulation to real world for a multi-stage task. CoRR, abs/1707.02267, 2017. ",
+        "bbox": [
+            171,
+            731,
+            823,
+            760
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sham Kakade and John Langford. Approximately optimal approximate reinforcement learning. In ICML, 2002. ",
+        "bbox": [
+            173,
+            768,
+            825,
+            797
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            171,
+            806,
+            823,
+            835
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Vikash Kumar, Abhishek Gupta, Emanuel Todorov, and Sergey Levine. Learning dexterous manipulation policies from experience and imitation. CoRR, abs/1611.05095, 2016. URL http: //arxiv.org/abs/1611.05095. ",
+        "bbox": [
+            173,
+            843,
+            821,
+            887
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Levine and Vladlen Koltun. Guided policy search. In International Conference on Machine Learning (ICML), pp. 1–9, 2013. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. CoRR, abs/1504.00702, 2015. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Levine, Peter Pastor, Alex Krizhevsky, and Deirdre Quillen. Learning hand-eye coordination for robotic grasping with deep learning and large-scale data collection. CoRR, abs/1603.02199, 2016. ",
+        "bbox": [
+            176,
+            142,
+            821,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yunzhu Li, Jiaming Song, and Stefano Ermon. Inferring the latent structure of human decisionmaking from raw visual inputs. arXiv preprint arXiv:1703.08840, 2017. ",
+        "bbox": [
+            173,
+            194,
+            821,
+            223
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. International Conference on Learning Representations (ICLR), 2016. ",
+        "bbox": [
+            174,
+            232,
+            823,
+            275
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuxuan Liu, Abhishek Gupta, Pieter Abbeel, and Sergey Levine. Imitation from observation: Learning to imitate behaviors from raw video via context translation. CoRR, abs/1707.03374, 2017. ",
+        "bbox": [
+            173,
+            284,
+            821,
+            314
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Josh Merel, Yuval Tassa, Dhruva TB, Sriram Srinivasan, Jay Lemmon, Ziyu Wang, Greg Wayne, and Nicolas Heess. Learning human behaviors from motion capture by adversarial imitation. CoRR, abs/1707.02201, 2017. ",
+        "bbox": [
+            173,
+            323,
+            825,
+            366
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015. ",
+        "bbox": [
+            174,
+            375,
+            821,
+            419
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ashvin Nair, Bob McGrew, Marcin Andrychowicz, Wojciech Zaremba, and Pieter Abbeel. Overcoming exploration in reinforcement learning with demonstrations. CoRR, abs/1709.10089, 2017. ",
+        "bbox": [
+            171,
+            428,
+            823,
+            457
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew Y Ng, Daishi Harada, and Stuart J Russell. Policy invariance under reward transformations: Theory and application to reward shaping. In ICML, pp. 278–287, 1999. ",
+        "bbox": [
+            173,
+            465,
+            823,
+            496
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xue Bin Peng, Marcin Andrychowicz, Wojciech Zaremba, and Pieter Abbeel. Sim-to-Real Transfer of Robotic Control with Dynamics Randomization. ArXiv e-prints, October 2017. ",
+        "bbox": [
+            171,
+            503,
+            823,
+            534
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lerrel Pinto and Abhinav Gupta. Supersizing self-supervision: Learning to grasp from 50k tries and 700 robot hours. CoRR, abs/1509.06825, 2015. URL http://arxiv.org/abs/1509. 06825. ",
+        "bbox": [
+            174,
+            542,
+            823,
+            585
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lerrel Pinto, Marcin Andrychowicz, Peter Welinder, Wojciech Zaremba, and Pieter Abbeel. Asymmetric Actor Critic for Image-Based Robot Learning. ArXiv e-prints, 2017. ",
+        "bbox": [
+            173,
+            594,
+            820,
+            625
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ivaylo Popov, Nicolas Heess, Timothy P. Lillicrap, Roland Hafner, Gabriel Barth-Maron, Matej Vecerik, Thomas Lampe, Yuval Tassa, Tom Erez, and Martin A. Riedmiller. Data-efficient deep reinforcement learning for dexterous manipulation. CoRR, abs/1704.03073, 2017. ",
+        "bbox": [
+            174,
+            633,
+            825,
+            676
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rouhollah Rahmatizadeh, Pooya Abolghasemi, Ladislau Bol¨ oni, and Sergey Levine. Vision-based ¨ multi-task manipulation for inexpensive robots using end-to-end learning from demonstration. CoRR, abs/1707.02920, 2017. URL http://arxiv.org/abs/1707.02920. ",
+        "bbox": [
+            173,
+            685,
+            825,
+            729
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aravind Rajeswaran, Vikash Kumar, Abhishek Gupta, John Schulman, Emanuel Todorov, and Sergey Levine. Learning complex dexterous manipulation with deep reinforcement learning and demonstrations. CoRR, abs/1709.10087, 2017. ",
+        "bbox": [
+            173,
+            738,
+            825,
+            781
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stephane Ross, Geoffrey J Gordon, and Drew Bagnell. A reduction of imitation learning and struc- ´ tured prediction to no-regret online learning. In International Conference on Artificial Intelligence and Statistics, pp. 627–635, 2011. ",
+        "bbox": [
+            173,
+            790,
+            823,
+            833
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrei Rusu, Neil Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. arXiv preprint arXiv:1606.04671, 2016a. ",
+        "bbox": [
+            173,
+            843,
+            823,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrei Rusu, Matej Vecerik, Thomas Rothorl, Nicolas Heess, Razvan Pascanu, and Raia Hadsell.¨ Sim-to-real robot learning from pixels with progressive nets. CoRR, abs/1610.04286, 2016b. ",
+        "bbox": [
+            173,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Connor Schenck and Dieter Fox. Reasoning about liquids via closed-loop simulation. arXiv preprint arXiv:1703.01656, 2017. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In Proceedings of the 32nd International Conference on Machine Learning (ICML-15), pp. 1889–1897, 2015. ",
+        "bbox": [
+            174,
+            140,
+            823,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017. ",
+        "bbox": [
+            171,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Pierre Sermanet, Corey Lynch, Jasmine Hsu, and Sergey Levine. Time-contrastive networks: Selfsupervised learning from multi-view observation. CoRR, abs/1704.06888, 2017. ",
+        "bbox": [
+            171,
+            229,
+            823,
+            260
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Guy Lever, Nicolas Heess, Thomas Degris, Daan Wierstra, and Martin Riedmiller. Deterministic policy gradient algorithms. In International Conference on Machine Learning (ICML), 2014. ",
+        "bbox": [
+            176,
+            267,
+            823,
+            310
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016. ",
+        "bbox": [
+            173,
+            319,
+            826,
+            363
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Joshua Tobin, Rachel Fong, Alex Ray, Jonas Schneider, Wojciech Zaremba, and Pieter Abbeel. Domain randomization for transferring deep neural networks from simulation to the real world. CoRR, abs/1703.06907, 2017. ",
+        "bbox": [
+            174,
+            371,
+            825,
+            414
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp. 5026– 5033. IEEE, 2012. ",
+        "bbox": [
+            174,
+            422,
+            825,
+            465
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matej Vecerik, Todd Hester, Jonathan Scholz, Fumin Wang, Olivier Pietquin, Bilal Piot, Nicolas Heess, Thomas Rothorl, Thomas Lampe, and Martin A. Riedmiller. Leveraging demon- ¨ strations for deep reinforcement learning on robotics problems with sparse rewards. CoRR, abs/1707.08817, 2017. ",
+        "bbox": [
+            173,
+            473,
+            825,
+            531
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ulrich Viereck, Andreas ten Pas, Kate Saenko, and Robert Platt. Learning a visuomotor controller for real world robotic grasping using easily simulated depth images. CoRR, abs/1706.04652, 2017. ",
+        "bbox": [
+            174,
+            539,
+            823,
+            582
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ziyu Wang, Josh Merel, Scott E. Reed, Greg Wayne, Nando de Freitas, and Nicolas Heess. Robust imitation of diverse behaviors. NIPS, abs/1707.02747, 2017. ",
+        "bbox": [
+            169,
+            592,
+            825,
+            621
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ali Yahya, Adrian Li, Mrinal Kalakrishnan, Yevgen Chebotar, and Sergey Levine. Collective robot reinforcement learning with distributed asynchronous guided policy search. CoRR, abs/1610.00673, 2016. URL http://arxiv.org/abs/1610.00673. ",
+        "bbox": [
+            176,
+            628,
+            823,
+            672
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A EXPERIMENT DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            400,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The policy network takes the pixel observation and the proprioceptive feature as input. The pixel observation is an RGB image of size $6 4 \\times 6 4 \\times 3$ . We used the Kinect for Xbox One camera in the real environment. The proprioceptive feature describes the joint positions and velocities of the Kinova Jaco arm. Each joint position is represented as the sin and cos of the angle of the joint in joint coordinates. Each joint velocity is represented as the scalar angular velocity. This results in a 24-dimensional proprioceptive feature that contains the positions (12-d) and velocities (6-d) of the six arm joints and the positions (6-d) of the three fingers. We exclude the finger velocities due to the noisy sensory readings on the real robot. ",
+        "bbox": [
+            174,
+            136,
+            825,
+            248
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We used Adam (Kingma & Ba, 2014) to train the neural network parameters. We set the learning rate of policy and value to $1 0 ^ { - 4 }$ and $1 0 ^ { - 3 }$ respectively, and $1 0 ^ { - 4 }$ for both the discriminator and the auxiliary tasks. The pixel observation is encoded by a two-layer convoluational network. We use 2 convolutional layers followed by a fully-connected layer with 128 hidden units. The first convolutional layer has $1 6 8 \\times 8$ filters with stride 4 and the second $3 2 4 \\times 4$ filters with stride 2. We add a recurrent layer of 100 LSTM units before the policy and value outputs. The policy output is the mean and the standard deviation of a conditional Gaussian distribution over the 9-dimensional joint velocities. The initial policy standard deviation is set to $\\exp ( - 3 )$ for the clearing table with blocks task and $\\exp ( - 1 )$ for the other five tasks. The auxiliary head of the policy contains a separate 3-layer MLP sitting on top of the convolutional network. The first two layers of the MLP has 200 and 100 hidden units respectively, while the third layer predicts the auxiliary outputs. Finally, the discriminator is a simple three-layer MLP of 100 and 64 hidden units for the first two layers with the third layer producing log probabilities. The networks use tanh nonlinearities. ",
+        "bbox": [
+            174,
+            255,
+            825,
+            435
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We trained the visuomotor policies using the distributed PPO algorithm (Heess et al., 2017) with synchronous gradient updates from 256 CPU workers. Each worker runs the policy to complete an entire episode before the parameter updates are computed. We set a constant episode length for each task based on its difficulty, with the longest being 1000 time steps (50 seconds) for the clearing table with blocks and order fulfillment tasks. We set $K = 5 0$ as the number of time steps for computing $K$ -step returns and truncated backpropagation through time to train the LSTM units. After a worker collects a batch of data points, it performs 50 parameter updates for the policy and value networks, 5 for the discriminator and 5 for the auxiliary prediction network. ",
+        "bbox": [
+            174,
+            443,
+            825,
+            554
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B SIM2REAL DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            579,
+            379,
+            595
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "To better facilitate sim2real transfer, we lower the frequency at which we sample the observations. Pixel observations are only observed at the rate of $5 \\mathrm { H z }$ despite the fact that our controller runs at $2 0 \\mathrm { H z }$ . Similarly, the proprioceptive features are observed at a rate of $1 0 \\mathrm { H z }$ . In addition to observation delays, we also apply domain variations. Gaussian noise (of standard deviation 0.01) are added proprioceptive features. Uniform integers noise in the range of $[ - 5 , 5 ]$ are added to each pixel independently. Pixels of values outside the range of $[ 0 , 2 5 5 ]$ are clipped. We also vary randomly the shade of grey on the Jaco arm, the color of the table top, as well as the location and orientation of the light source (see Fig. 6). ",
+        "bbox": [
+            174,
+            614,
+            825,
+            727
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In the case of block lifting, we vary in addition the dynamics of the arm. Specifically, we dynamically change the friction, damping, armature, and gain parameters of the robot arm in simulation to further robustify the agent’s performance. ",
+        "bbox": [
+            176,
+            733,
+            825,
+            775
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B.1 ACTION DROPPING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            797,
+            351,
+            813
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Our analysis indicates that, on the real robot, there is often a delay in the execution of actions. The amount of delay also varies significantly. This has an adverse effect on the performance of our agent on the physical robot since our agents’ performance depends on the timely execution of their actions. To better facilitate the transfer to the real robot, we fine-tune our trained agent in simulation while subjecting them to a random chance of dropping actions. Specifically, each action emitted by the agent has a $5 0 \\%$ chance of being executed immediately in which case the action is flagged as the last executed action. If the current action is not executed, the last executed action will then be executed. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            922
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/6321f7405a110f1a781e4aefa1233f51f25d6f8eddd6d6a79a9b9948ef2629cc.jpg",
+        "image_caption": [
+            "Figure 6: Tiles show the representative range of diversity seen in the domain-randomized variations of the colors, lighting, background, etc. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            241,
+            102,
+            754,
+            273
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/74f8c76861f4f55307395f1a005b80e8e656c8902effef018ae6aadf19328052.jpg",
+        "table_caption": [
+            "Table 1: Block Lifting success rate from different positions. (LL, LR, UL, UR, and C represents the positions of lower left, lower right, upper left, upper right, and center respectively.) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>LL</td><td>LR</td><td>UL</td><td>UR</td><td>C</td><td>All</td></tr><tr><td>No Action Dropping</td><td>2/5</td><td>2/5</td><td>1/5</td><td>3/5</td><td>4/5</td><td>12/25</td></tr><tr><td>Action Dropping</td><td>4/5</td><td>4/5</td><td>4/5</td><td>0/5</td><td>4/5</td><td>16/25</td></tr></table>",
+        "bbox": [
+            285,
+            378,
+            710,
+            426
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Using the above procedure, we fine-tune our agents on both block lifting and block stacking for a further 2 million iterations. ",
+        "bbox": [
+            174,
+            460,
+            823,
+            488
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate the effectiveness of action dropping, we compare our agent on the real robot over the task of block lifting. Without action dropping, the baseline agent lifts $4 \\bar { 8 } \\%$ percent of the time. After fine-tuning using action dropping, our agent succeeded $6 4 \\%$ percent of the time. For the complete set of results, please see Table 1 and Table 2. ",
+        "bbox": [
+            174,
+            496,
+            825,
+            551
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C TASK DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            575,
+            333,
+            592
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We use a fixed episode length for each task, which is determined by the amount of time a skilled human demonstrator can complete the task. An episode terminates when a maximum number of agent steps are performed. The robot arm operates at a control frequency of $2 0 \\mathrm { H z }$ , which means each time step takes 0.05 second. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            665
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We segment into a sequence of stages that represent an agent’s progress in a task. For instance, the block stacking task can be characterized by three stages, including reaching the block, lifting the block and stacking the block. We define functions on the underlying physical state to determine the stage of a state. This way, we can cluster demonstration states according to their corresponding stages. These clusters are used to reset training episodes in our demonstration as a curriculum technique proposed in Sec. 3.2.2. The definition of stages also gives rise to a convenient way of specifying the reward functions without hand-engineering a shaping reward. We define a piecewise constant reward function for each task, where we assign the same constant reward to all the states that belong to the same stage. We detail the stages, reward functions, auxiliary tasks, and objectcentric features for the six tasks in our experiments. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            811
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Block lifting. Each episode lasts 100 time steps. We define three stages and their rewards (in parentheses) to be initial (0), reaching the block (0.125) and lifting the block (1.0). The auxiliary task is to predict the 3D coordinates of the color block. The object-centric feature consists of the relative position between the gripper and the block. ",
+        "bbox": [
+            174,
+            819,
+            825,
+            875
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Block stacking. Each episode lasts 500 time steps. We define four stages and their rewards to be initial (0), reaching the orange block (0.125), lifting the orange block (0.25), and stacking the orange block onto the pink block (1.0). The auxiliary task is to predict the 3D coordinates of the two blocks. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/91a05cd9679b5ed3014f064699a70fe787179e7b932afeaf799a793c6a7f86da.jpg",
+        "table_caption": [
+            "Table 2: Success rate of the block stacking agent from different starting positions. Left and Right indicates the position of the support block upon initialization. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Left</td><td>Right</td><td>All</td></tr><tr><td>Stacking Success Rate</td><td>5/10</td><td>2/10</td><td>7/20</td></tr><tr><td>Lifting Success Rate</td><td>9/10</td><td>7/10</td><td>16/20</td></tr></table>",
+        "bbox": [
+            331,
+            147,
+            665,
+            193
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The object-centric feature consists of the relative positions between the gripper and the two blocks respectively. ",
+        "bbox": [
+            174,
+            223,
+            825,
+            252
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Clearing table with blocks. Each episode lasts 1000 time steps. We define five stages and their rewards to be initial (0), reaching the orange block (0.125), lifting the orange block (0.25), stacking the orange block onto the pink block (1.0), and lifting both blocks off the ground (2.0). The auxiliary task is to predict the 3D coordinates of the two blocks. The object-centric feature consists of the 3D positions of the two blocks as well as the relative positions between the gripper and the two blocks respectively. ",
+        "bbox": [
+            174,
+            258,
+            825,
+            343
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Clearing table with a box. Each episode lasts 500 time steps. We define five stages and their rewards to be initial (0), reaching the toy (0.125), grasping the toy (0.25), putting the toy into the box (1.0), and lifting the box (2.0). The auxiliary task is to predict the 3D coordinates of the toy and the box. The object-centric feature consists of the 3D positions of the toy and the box as well as the relative positions between the gripper and these two objects respectively. ",
+        "bbox": [
+            173,
+            349,
+            825,
+            420
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Pouring liquid. Each episode lasts 500 time steps. We define three stages and their rewards to be initial (0), grasping the mug (0.05), pouring $\\left( 0 . 1 N \\right)$ , where $N$ is the number of small spheres in the other container. The auxiliary task is to predict the 3D coordinates of the mug. The object-centric feature consists of the 3D positions of the mug, the relative position between the gripper and the mug, and the relative position between the mug and the container. ",
+        "bbox": [
+            173,
+            426,
+            825,
+            497
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Order fulfillment. Each episode lasts 1000 time steps. The number of objects varies from 1 to 4 across episodes. We define five stages that correspond to the number of toys in the boxes. The immediate reward corresponds to the number of toys placed in the correct boxes (number of toy planes in the green box and toy cars in the red box). To handle the variable number of objects, we only represent the objects nearest to the gripper for the auxiliary task and the object-centric feature. The auxiliary task is to predict the 3D coordinates of the nearest plane and the nearest car to the gripper. The object-centric feature consists of the relative positions from the gripper to these two nearest objects. ",
+        "bbox": [
+            173,
+            503,
+            825,
+            616
+        ],
+        "page_idx": 14
+    }
+]

parse/train/Sys6GJqxl/Sys6GJqxl.md

@@ -0,0 +1,317 @@
+# DELVING INTO TRANSFERABLE ADVERSARIAL EXAMPLES AND BLACK-BOX ATTACKS
+
+Yanpei Liu∗, Xinyun Chen∗ Shanghai Jiao Tong University
+
+Chang Liu, Dawn Song University of the California, Berkeley
+
+# ABSTRACT
+
+An intriguing property of deep neural networks is the existence of adversarial examples, which can transfer among different architectures. These transferable adversarial examples may severely hinder deep neural network-based applications. Previous works mostly study the transferability using small scale datasets. In this work, we are the first to conduct an extensive study of the transferability over large models and a large scale dataset, and we are also the first to study the transferability of targeted adversarial examples with their target labels. We study both non-targeted and targeted adversarial examples, and show that while transferable non-targeted adversarial examples are easy to find, targeted adversarial examples generated using existing approaches almost never transfer with their target labels. Therefore, we propose novel ensemble-based approaches to generating transferable adversarial examples. Using such approaches, we observe a large proportion of targeted adversarial examples that are able to transfer with their target labels for the first time. We also present some geometric studies to help understanding the transferable adversarial examples. Finally, we show that the adversarial examples generated using ensemble-based approaches can successfully attack Clarifai.com, which is a black-box image classification system.
+
+# 1 INTRODUCTION
+
+Recent research has demonstrated that for a deep architecture, it is easy to generate adversarial examples, which are close to the original ones but are misclassified by the deep architecture (Szegedy et al. (2013); Goodfellow et al. (2014)). The existence of such adversarial examples may have severe consequences, which hinders vision-understanding-based applications, such as autonomous driving. Most of these studies require explicit knowledge of the underlying models. It remains an open question how to efficiently find adversarial examples for a black-box model.
+
+Several works have demonstrated that some adversarial examples generated for one model may also be misclassified by another model. Such a property is referred to as transferability, which can be leveraged to perform black-box attacks. This property has been exploited by constructing a substitute of the black-box model, and generating adversarial instances against the substitute to attack the black-box system (Papernot et al. (2016a;b)). However, so far, transferability is mostly examined over small datasets, such as MNIST (LeCun et al. (1998)) and CIFAR-10 (Krizhevsky & Hinton (2009)). It has yet to be better understood transferability over large scale datasets, such as ImageNet (Russakovsky et al. (2015)).
+
+In this work, we are the first to conduct an extensive study of the transferability of different adversarial instance generation strategies applied to different state-of-the-art models trained over a large scale dataset. In particular, we study two types of adversarial examples: (1) non-targeted adversarial examples, which can be misclassified by a network, regardless of what the misclassified labels may be; and (2) targeted adversarial examples, which can be classified by a network as a target label. We examine several existing approaches searching for adversarial examples based on a single model. While non-targeted adversarial examples are more likely to transfer, we observe few targeted adversarial examples that are able to transfer with their target labels.
+
+We further propose a novel strategy to generate transferable adversarial images using an ensemble of multiple models. In our evaluation, we observe that this new strategy can generate non-targeted adversarial instances with better transferability than other methods examined in this work. Also, for the first time, we observe a large proportion of targeted adversarial examples that are able to transfer with their target labels.
+
+We study geometric properties of the models in our evaluation. In particular, we show that the gradient directions of different models are orthogonal to each other. We also show that decision boundaries of different models align well with each other, which partially illustrates why adversarial examples can transfer.
+
+Last, we study whether generated adversarial images can attack Clarifai.com, a commercial company providing state-of-the-art image classification services. We have no knowledge about the training dataset and the types of models used by Clarifai.com; meanwhile, the label set of Clarifai.com is quite different from ImageNet’s. We show that even in this case, both non-targeted and targeted adversarial images transfer to Clarifai.com. This is the first work documenting the success of generating both non-targeted and targeted adversarial examples for a black-box state-of-the-art online image classification system, whose model and training dataset are unknown to the attacker.
+
+Contributions and organization. We summarize our main contributions as follows:
+
+• For ImageNet models, we show that while existing approaches are effective to generate non-targeted transferable adversarial examples (Section 3), only few targeted adversarial examples generated by existing methods can transfer (Section 4).   
+• We propose novel ensemble-based approaches to generate adversarial examples (Section 5). Our approaches enable a large portion of targeted adversarial examples to transfer among multiple models for the first time.   
+We are the first to present that targeted adversarial examples generated for models trained on ImageNet can transfer to a black-box system, i.e., Clarifai.com, whose model, training data, and label set is unknown to us (Section 7). In particular, Clarifai.com’s label set is very different from ImageNet’s.   
+• We conduct the first analysis of geometric properties for large models trained over ImageNet (Section 6), and the results reveal several interesting findings, such as the gradient directions of different models are orthogonal to each other.
+
+In the following, we first discuss related work, and then present the background knowledge and experiment setup in Section 2. Then we present each of our experiments and conclusions in the corresponding section as mentioned above.
+
+Related work. Transferability of adversarial examples was first examined by Szegedy et al. (2013), which studied the transferability (1) between different models trained over the same dataset; and (2) between the same or different model trained over disjoint subsets of a dataset; However, Szegedy et al. (2013) only studied MNIST.
+
+The study of transferability was followed by Goodfellow et al. (2014), which attributed the phenomenon of transferability to the reason that the adversarial perturbation is highly aligned with the weight vector of the model. Again, this hypothesis was tested using MNIST and CIFAR-10 datasets. We show that this is not the case for models trained over ImageNet.
+
+Papernot et al. (2016a;b) examined constructing a substitute model to attack a black-box target model. To train the substitute model, they developed a technique that synthesizes a training set and annotates it by querying the target model for labels. They demonstrate that using this approach, black-box attacks are feasible towards machine learning services hosted by Amazon, Google, and MetaMind. Further, Papernot et al. (2016a) studied the transferability between deep neural networks and other models such as decision tree, kNN, etc.
+
+Our work differs from Papernot et al. (2016a;b) in three aspects. First, in these works, only the model and the training process are a black box, but the training set and the test set are controlled by the attacker; in contrast, we attack Clarifai.com, whose model, training data, training process, and even the test label set are unknown to the attacker. Second, the datasets studied in these works are small scale, i.e., MNIST and GTSRB (Stallkamp et al. (2012)); in our work, we study the transferability over larger models and a larger dataset, i.e., ImageNet. Third, to attack black-box machine learning systems, we do not query the systems for constructing the substitute model ourselves.
+
+In a concurrent and independent work, Moosavi-Dezfooli et al. (2016) showed the existence of a universal perturbation for each model, which can transfer across different images. They also show that the adversarial images generated using these universal perturbations can transfer across different models on ImageNet. However, they only examine the non-targeted transferability, while our work studies both non-targeted and targeted transferability over ImageNet.
+
+# 2 ADVERSARIAL DEEP LEARNING AND TRANSFERABILITY
+
+# 2.1 THE ADVERSARIAL DEEP LEARNING PROBLEM
+
+We assume a classifier $f _ { \boldsymbol { \theta } } ( \boldsymbol { x } )$ outputs a category (or a label) as the prediction. Given an original image $x$ , with ground truth label $y$ , the adversarial deep learning problem is to seek for adversarial examples for the classifier $f _ { \boldsymbol { \theta } } ( \boldsymbol { x } )$ . Specifically, we consider two classes of adversarial examples. A non-targeted adversarial example $x ^ { \star }$ is an instance that is close to $x$ , in which case $x ^ { \star }$ should have the same ground truth as $x$ , while $f _ { \theta } ( x ^ { \star } ) \neq y$ . For the problem to be non-trivial, we assume $f _ { \boldsymbol { \theta } } ( x ) = y$ without loss of generality. A targeted adversarial example $x ^ { \star }$ is close to $x$ and satisfies $f _ { \theta } ( x ^ { \star } ) = y ^ { \star }$ , where $y ^ { \star }$ is a target label specified by the adversary, and $y ^ { \star } \ne y$ .
+
+# 2.2 APPROACHES FOR GENERATING ADVERSARIAL EXAMPLES
+
+In this work, we consider three classes of approaches for generating adversarial examples: optimization-based approaches, fast gradient approaches, and fast gradient sign approaches. Each class has non-targeted and targeted versions respectively.
+
+# 2.2.1 APPROACHES FOR GENERATING NON-TARGETED ADVERSARIAL EXAMPLES
+
+Formally, given an image $x$ with ground truth $y = f _ { \boldsymbol { \theta } } ( \boldsymbol { x } )$ , searching for a non-targeted adversarial example can be modeled as searching for an instance $x ^ { \star }$ to satisfy the following constraints:
+
+$$
+\begin{array} { r } { f _ { \theta } ( x ^ { \star } ) \neq y } \\ { d ( x , x ^ { \star } ) \leq B } \end{array}
+$$
+
+where $d ( \cdot , \cdot )$ is a metric to quantify the distance between an original image and its adversarial counterpart, and $B$ , called distortion, is an upper bound placed on this distance. Without loss of generality, we consider model $f$ is composed of a network $J _ { \theta } ( x )$ , which outputs the probability for each category, so that $f$ outputs the category with the highest probability.
+
+Optimization-based approach. One approach is to approximate the solution to the following optimization problem:
+
+$$
+\begin{array} { r } { \mathbf { a r g m i n } _ { x ^ { \star } } \lambda d ( x , x ^ { \star } ) - \ell ( \mathbf { 1 } _ { y } , J _ { \theta } ( x ^ { \star } ) ) } \end{array}
+$$
+
+where ${ \bf 1 } _ { y }$ is the one-hot encoding of the ground truth label $y , \ell$ is a loss function to measure the distance between the prediction and the ground truth, and $\lambda$ is a constant to balance constraints (2) and (1), which is empirically determined. Here, loss function $\ell$ is used to approximate constraint (1), and its choice can affect the effectiveness of searching for an adversarial example. In this work, we choose $\ell ( u , v ) = \log { ( 1 - u \cdot v ) }$ , which is shown to be effective by Carlini & Wagner (2016).
+
+Fast gradient sign (FGS). Goodfellow et al. (2014) proposed the fast gradient sign (FGS) method so that the gradient needs be computed only once to generate an adversarial example. FGS can be used to generate adversarial images to meet the $L _ { \infty }$ norm bound. Formally, non-targeted adversarial examples are constructed as
+
+$$
+\boldsymbol { x } ^ { \star } \gets \mathrm { c l i p } ( \boldsymbol { x } + B \mathbf { s g n } ( \nabla _ { \boldsymbol { x } } \ell ( \mathbf { 1 } _ { \boldsymbol { y } } , J _ { \boldsymbol { \theta } } ( \boldsymbol { x } ) ) ) )
+$$
+
+Here, $\operatorname { c l i p } ( x )$ is used to clip each dimension of $x$ to the range of pixel values, i.e., $[ 0 , 2 5 5 ]$ in this work. We make a slight variation to choose $\ell ( u , v ) = \log { ( 1 - u \cdot v ) }$ , which is the same as used in the optimization-based approach.
+
+Fast gradient (FG). The fast gradient approach (FG) is similar to FGS, but instead of moving along the gradient sign direction, FG moves along the gradient direction. In particular, we have
+
+$$
+x ^ { \star } \gets \mathrm { c l i p } ( x + B \frac { \nabla _ { x } \ell ( \mathbf { 1 } _ { y } , J _ { \theta } ( x ) ) } { | | \nabla _ { x } \ell ( \mathbf { 1 } _ { y } , J _ { \theta } ( x ) ) | | } )
+$$
+
+Here, we assume the distance metric in constraint (2), $d ( x , x ^ { \star } ) = | | x - x ^ { \star } | |$ is a norm of $x - x ^ { \star }$ The term sgn(∇x\`) in FGS is replaced by ∇x\`||∇ \`|| to meet this distance constraint.
+
+We call both FGS and FG fast gradient-based approaches.
+
+# 2.2.2 APPROACHES FOR GENERATING TARGETED ADVERSARIAL EXAMPLES
+
+A targeted adversarial image $x ^ { \star }$ is similar to a non-targeted one, but constraint (1) is replaced by
+
+$$
+f _ { \theta } ( x ^ { \star } ) = y ^ { \star }
+$$
+
+where $y ^ { \star }$ is the target label given by the adversary. For the optimization-based approach, we approximate the solution by solving the following dual objective:
+
+$$
+\begin{array} { r } { \mathbf { a r g m i n } _ { x ^ { \star } } \lambda d ( x , x ^ { \star } ) + \ell ^ { \prime } ( \mathbf { 1 } _ { y ^ { \star } } , J _ { \theta } ( x ^ { \star } ) ) } \end{array}
+$$
+
+In this work, we choose the standard cross entropy loss $\ell ^ { \prime } ( u , v ) = - \sum _ { i } u _ { i } \log v _ { i } .$
+
+For FGS and FG, we construct adversarial examples as follows:
+
+$$
+\begin{array} { r l } & { x ^ { \star }  \mathrm { c l i p } ( x - B \mathbf { s g n } ( \nabla _ { x } \ell ^ { \prime } ( \mathbf { 1 } _ { y ^ { \star } } , J _ { \theta } ( x ) ) ) ) } \\ & { \quad x ^ { \star }  \mathrm { c l i p } ( x - B \frac { \nabla _ { x } \ell ^ { \prime } ( \mathbf { 1 } _ { y ^ { \star } } , J _ { \theta } ( x ) ) } { \vert \vert \nabla _ { x } \ell ^ { \prime } ( \mathbf { 1 } _ { y ^ { \star } } , J _ { \theta } ( x ) ) \vert \vert } ) } \end{array}
+$$
+
+where $\ell ^ { \prime }$ is the same as the one used for the optimization-based approach.
+
+# 2.3 EVALUATION METHODOLOGY
+
+For the rest of the paper, we focus on examining the transferability among state-of-the-art models trained over ImageNet (Russakovsky et al. (2015)). In this section, we detail the models to be examined, the dataset to be evaluated, and the measurements to be used.
+
+Models. We examine five networks, ResNet-50, ResNet-101, ResNet-152 (He et al. $( 2 0 1 5 ) ) ^ { 1 }$ , GoogLeNet (Szegedy et al. (2014))2, and VGG-16 (Simonyan & Zisserman (2014))3. We retrieve the pre-trained models for each network online. The performance of these models on the ILSVRC 2012 (Russakovsky et al. (2015)) validation set can be found in our online technical report: Liu et al. (2016). We choose these models to study the transferability between homogeneous architectures (i.e., ResNet models) and heterogeneous architectures.
+
+Dataset. It is less meaningful to examine the transferability of an adversarial image between two models which cannot classify the original image correctly. Therefore, from the ILSVRC 2012 validation set, we randomly choose 100 images, which can be classified correctly by all five models in our examination. These 100 images form our test set. To perform targeted attacks, we manually choose a target label for each image, so that its semantics is far from the ground truth. The images and target labels in our evaluation can be found on website4.
+
+Measuring transferability. Given two models, we measure the non-targeted transferability by computing the percentage of the adversarial examples generated for one model that can be classified correctly for the other. We refer to this percentage as accuracy. A lower accuracy means better non-targeted transferability. We measure the targeted transferability by computing the percentage of the adversarial examples generated for one model that are classified as the target label by the other model. We refer to this percentage as matching rate. A higher matching rate means better targeted transferability. For clarity, the reported results are only based on top-1 accuracy. Top-5 accuracy’s counterparts can be found in our online technical report: Liu et al. (2016).
+
+Distortion. Besides transferability, another important factor is the distortion between adversarial images and the original ones. We measure the distortion by root mean square deviation, i.e., RMSD, which is computed as $d ( x ^ { \star } , x ) = \sqrt { \textstyle \sum _ { i } ( x _ { i } ^ { \star } - x _ { i } ) ^ { 2 } / N }$ , where $x ^ { \star }$ and $x$ are the vector representations of an adversarial image and the original one respectively, $N$ is the dimensionality of $x$ and $x ^ { \star }$ , and $x _ { i }$ denotes the pixel value of the $i$ -th dimension of $x$ , within range [0, 255], and similar for $x _ { i } ^ { \star }$ .
+
+# 3 NON-TARGETED ADVERSARIAL EXAMPLES
+
+In this section, we examine different approaches for generating non-targeted adversarial images.
+
+# 3.1 OPTIMIZATION-BASED APPROACH
+
+To apply the optimization-based approach for a single model, we initialize $x ^ { \star }$ to be $x$ and use Adam Optimizer (Kingma & Ba (2014)) to optimize Objective (3) . We find that we can tune the RMSD by adjusting the learning rate of Adam and $\lambda$ . We find that, for each model, we can use a small learning rate to generate adversarial images with small RMSD, i.e. $< 2$ , with any $\lambda$ . In fact, we find that when initializing $x ^ { \star }$ with $x$ , Adam Optimizer will search for an adversarial example around $x$ , even when we set $\lambda$ to be 0, i.e., not restricting the distance between $x ^ { \star }$ and $x$ . Therefore, we set $\lambda$ to be 0 for all experiments using optimization-based approaches throughout the paper. Although these adversarial examples with small distortions can successfully fool the target model, however, they cannot transfer well to other models (details can be found in our online technical report: Liu et al. (2016)).
+
+We increase the learning rate to allow the optimization algorithm to search for adversarial images with larger distortion. In particular, we set the learning rate to be 4. We run Adam Optimizer for 100 iterations to generate the adversarial images. We observe that the loss converges after 100 iterations. An alternative optimization-based approach leading to similar results can be found in our online technical report: Liu et al. (2016).
+
+Non-targeted adversarial examples transfer. We generate non-targeted adversarial examples on one network, but evaluate them on another, and Table 1 Panel A presents the results. From the table, we can observe that
+
+• The diagonal contains all 0 values. This says that all adversarial images generated for one model can mislead the same model.   
+• A large proportion of non-targeted adversarial images generated for one model using the optimization-based approach can transfer to another.   
+• Although the three ResNet models share similar architectures which differ only in the hyperparameters, adversarial examples generated against a ResNet model do not necessarily transfer to another ResNet model better than other non-ResNet models. For example, the adversarial examples generated for VGG-16 have lower accuracy on ResNet-50 than those generated for ResNet-152 or ResNet-101.
+
+# 3.2 FAST GRADIENT-BASED APPROACHES
+
+We then examine the effectiveness of fast gradient-based approaches. A good property of fast gradient-based approaches is that all generated adversarial examples lie in a 1-D subspace. Therefore, we can easily approximate the minimal distortion in this subspace of transferable adversarial examples between two models. In the following, we first control the RMSD to study fast gradientbased approaches’ effectiveness. Second, we study the transferable minimal distortions of fast gradient-based approaches.
+
+# 3.2.1 EFFECTIVENESS AND TRANSFERABILITY OF THE FAST GRADIENT-BASED APPROACHES
+
+Since the distortion $B$ and the RMSD of the generated adversarial images are highly correlated, we can choose this hyperparameter $B$ to generate adversarial images with a given RMSD. In Table 1
+
+Panel A: Optimization-based approach   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>RMSD</td><td rowspan=1 colspan=1>ResNet-152</td><td rowspan=1 colspan=1>ResNet-101</td><td rowspan=1 colspan=1>ResNet-50</td><td rowspan=1 colspan=1>VGG-16</td><td rowspan=1 colspan=1>GoogLeNet</td></tr><tr><td rowspan=1 colspan=1>ResNet-152</td><td rowspan=1 colspan=1>22.83</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>13%</td><td rowspan=1 colspan=1>18%</td><td rowspan=1 colspan=1>19%</td><td rowspan=1 colspan=1>11%</td></tr><tr><td rowspan=1 colspan=1>ResNet-101</td><td rowspan=1 colspan=1>23.81</td><td rowspan=1 colspan=1>19%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>21%</td><td rowspan=1 colspan=1>21%</td><td rowspan=1 colspan=1>12%</td></tr><tr><td rowspan=1 colspan=1>ResNet-50</td><td rowspan=1 colspan=1>22.86</td><td rowspan=1 colspan=1>23%</td><td rowspan=1 colspan=1>20%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>21%</td><td rowspan=1 colspan=1>18%</td></tr><tr><td rowspan=1 colspan=1>VGG-16</td><td rowspan=1 colspan=1>22.51</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>17%</td><td rowspan=1 colspan=1>17%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>5%</td></tr><tr><td rowspan=1 colspan=1>GoogLeNet</td><td rowspan=1 colspan=1>22.58</td><td rowspan=1 colspan=1>39%</td><td rowspan=1 colspan=1>38%</td><td rowspan=1 colspan=1>34%</td><td rowspan=1 colspan=1>19%</td><td rowspan=1 colspan=1>0%</td></tr></table>
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>RMSD</td><td rowspan=1 colspan=1>ResNet-152</td><td rowspan=1 colspan=1>ResNet-101</td><td rowspan=1 colspan=1>ResNet-50</td><td rowspan=1 colspan=1>VGG-16</td><td rowspan=1 colspan=1>GoogLeNet</td></tr><tr><td rowspan=1 colspan=1>ResNet-152</td><td rowspan=1 colspan=1>23.45</td><td rowspan=1 colspan=1>4%</td><td rowspan=1 colspan=1>13%</td><td rowspan=1 colspan=1>13%</td><td rowspan=1 colspan=1>20%</td><td rowspan=1 colspan=1>12%</td></tr><tr><td rowspan=1 colspan=1>ResNet-101</td><td rowspan=1 colspan=1>23.49</td><td rowspan=1 colspan=1>19%</td><td rowspan=1 colspan=1>4%</td><td rowspan=1 colspan=1>11%</td><td rowspan=1 colspan=1>23%</td><td rowspan=1 colspan=1>13%</td></tr><tr><td rowspan=1 colspan=1>ResNet-50</td><td rowspan=1 colspan=1>23.49</td><td rowspan=1 colspan=1>25%</td><td rowspan=1 colspan=1>19%</td><td rowspan=1 colspan=1>5%</td><td rowspan=1 colspan=1>25%</td><td rowspan=1 colspan=1>14%</td></tr><tr><td rowspan=1 colspan=1>VGG-16</td><td rowspan=1 colspan=1>23.73</td><td rowspan=1 colspan=1>20%</td><td rowspan=1 colspan=1>16%</td><td rowspan=1 colspan=1>15%</td><td rowspan=1 colspan=1>1%</td><td rowspan=1 colspan=1>7%</td></tr><tr><td rowspan=1 colspan=1>GoogLeNet</td><td rowspan=1 colspan=1>23.45</td><td rowspan=1 colspan=1>25%</td><td rowspan=1 colspan=1>25%</td><td rowspan=1 colspan=1>17%</td><td rowspan=1 colspan=1>19%</td><td rowspan=1 colspan=1>1%</td></tr></table>
+
+Panel B: Fast gradient approach
+
+Table 1: Transferability of non-targeted adversarial images generated between pairs of models. The first column indicates the average RMSD of all adversarial images generated for the model in the corresponding row. The cell $( i , j )$ indicates the accuracy of the adversarial images generated for model $i$ (row) evaluated over model $j$ (column). Results of top-5 accuracy can be found in our online technical report: Liu et al. (2016).
+
+Panel B, we generate adversarial images using FG such that the average RMSD is almost the same as those generated using the optimization-based approach. We observe that the diagonal values in the table are all positive, which means that FG cannot fully mislead the models. A potential reason is that, FG can be viewed as approximating the optimization, but is tailored for speed over accuracy.
+
+On the other hand, the values of non-diagonal cells in the table, which correspond to the accuracies of adversarial images generated for one model but evaluated on another, are comparable with or less than their counterparts in the optimization-based approach. This shows that non-targeted adversarial examples generated by FG exhibit transferability as well.
+
+We also evaluate FGS, but the transferability of the generated images is worse than the ones generated using either FG or optimization-based approaches. The results can be found in our online technical report: Liu et al. (2016). It shows that when RMSD is around 23, the accuracies of the adversarial images generated by FGS is greater than their counterparts for FG. We hypothesize the reason why transferability of FGS is worse to this fact.
+
+# .2.2 ADVERSARIAL IMAGES WITH MINIMAL TRANSFERABLE RMSD
+
+For an image $x$ and two models $M _ { 1 } , M _ { 2 }$ , we can approximate the minimal distortion $B$ along a direction $\delta$ , such that $x _ { B } = x + B \delta$ generated for $M _ { 1 }$ is adversarial for both $M _ { 1 }$ and $M _ { 2 }$ . Here $\delta$ is the direction, i.e., $\mathbf { s g n } ( \nabla _ { x } \ell )$ for FGS, and $\nabla _ { x } \ell / | | \nabla _ { x } \ell | |$ for FG.
+
+We refer to the minimal transferable RMSD from $M _ { 1 }$ to $M _ { 2 }$ using $F G$ (or $F G S _ { \prime }$ ) as the RMSD of a transferable adversarial example $x _ { B }$ with the minimal transferable distortion $B$ from $M _ { 1 }$ to $M _ { 2 }$ using FG (or FGS). The minimal transferable RMSD can illustrate the tradeoff between distortion and transferability.
+
+In the following, we approximate the minimal transferable RMSD through a linear search by sampling $B$ every 0.1 step. We choose the linear-search method rather than binary-search method to determine the minimal transferable RMSD because the adversarial images generated from an original image may come from multiple intervals. The experiment can be found in our online technical report: Liu et al. (2016).
+
+Minimal transferable RMSD using FG and FGS. Figure 1 plots the cumulative distribution function (CDF) of the minimal transferable RMSD from VGG-16 to ResNet-152 using non-targeted FG (Figure 1a) and FGS (Figure 1b). From the figures, we observe that both FG and FGS can find $100 \%$ transferable adversarial images with RMSD less than 80.91 and 86.56 respectively. Further, the FG method can generate transferable attacks with smaller RMSD than FGS. A potential reason is that while FGS minimizes the distortion’s $L _ { \infty }$ norm, FG minimizes its $L _ { 2 }$ norm, which is proportional to RMSD.
+
+![](images/422f10d6f00b19986ff6b8489f70b61e28e946370f55e76be067929c7ddb650d.jpg)  
+Figure 1: The CDF of the minimal transferable RMSD from VGG-16 to ResNet-152 using FG (a) and FGS (b). The green line labels the median minimal transferable RMSD, while the red line labels the minimal transferable RMSD to reach $90 \%$ percentage.
+
+Table 2: The matching rate of targeted adversarial images generated using the optimization-based approach. The first column indicates the average RMSD of the generated adversarial images. Cell $( i , j )$ indicates that matching rate of the targeted adversarial images generated for model $i$ (row) when evaluated on model $j$ (column). The top-5 results can be found in our online technical report: Liu et al. (2016).   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>RMSD</td><td rowspan=1 colspan=1>ResNet-152</td><td rowspan=1 colspan=1>ResNet-101</td><td rowspan=1 colspan=1>ResNet-50</td><td rowspan=1 colspan=1>VGG-16</td><td rowspan=1 colspan=1>GoogLeNet</td></tr><tr><td rowspan=1 colspan=1>ResNet-152</td><td rowspan=1 colspan=1>23.13</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>2%</td><td rowspan=1 colspan=1>1%</td><td rowspan=1 colspan=1>1%</td><td rowspan=1 colspan=1>1%</td></tr><tr><td rowspan=1 colspan=1>ResNet-101</td><td rowspan=1 colspan=1>23.16</td><td rowspan=1 colspan=1>3%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>3%</td><td rowspan=1 colspan=1>2%</td><td rowspan=1 colspan=1>1%</td></tr><tr><td rowspan=1 colspan=1>ResNet-50</td><td rowspan=1 colspan=1>23.06</td><td rowspan=1 colspan=1>4%</td><td rowspan=1 colspan=1>2%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>1%</td><td rowspan=1 colspan=1>1%</td></tr><tr><td rowspan=1 colspan=1>VGG-16</td><td rowspan=1 colspan=1>23.59</td><td rowspan=1 colspan=1>2%</td><td rowspan=1 colspan=1>1%</td><td rowspan=1 colspan=1>2%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>1%</td></tr><tr><td rowspan=1 colspan=1>GoogLeNet</td><td rowspan=1 colspan=1>22.87</td><td rowspan=1 colspan=1>1%</td><td rowspan=1 colspan=1>1%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>1%</td><td rowspan=1 colspan=1>100%</td></tr></table>
+
+# 3.3 COMPARISON WITH RANDOM PERTURBATIONS
+
+We also evaluate the test accuracy when we add a Gaussian noise to the 100 images in our test set. The concrete results can be found in our online technical report: Liu et al. (2016), where we show the conclusion that the “transferability” of this approach is significantly worse than either optimization-based approaches or fast gradient-based approaches.
+
+# 4 TARGETED ADVERSARIAL EXAMPLES
+
+In this section, we examine the transferability of targeted adversarial images. Table 2 presents the results for using optimization-based approach. We observe that (1) the prediction of targeted adversarial images can match the target labels when evaluated on the same model that is used to generate the adversarial examples; but (2) the targeted adversarial images can be rarely predicted as the target labels by a different model. We call the latter that the target labels do not transfer. Even when we increase the distortion, we still do not observe improvements on making target label transfer. Some results can be found in our online technical report: Liu et al. (2016). Even if we compute the matching rate based on top-5 accuracy, the highest matching rate is only $10 \%$ . The results can be found in our online technical report: Liu et al. (2016).
+
+We also examine the targeted adversarial images generated by fast gradient-based approaches, and we observe that the target labels do not transfer as well. The results can be found in our online technical report: Liu et al. (2016). In fact, most targeted adversarial images cannot mislead the model, for which the adversarial images are generated, to predict the target labels, regardless of how large the distortion is used. We attribute it to the fact that the fast gradient-based approaches only search for attacks in a 1-D subspace. In this subspace, the total possible predictions may contain a small subset of all labels, which usually does not contain the target label. In Section 6, we study decision boundaries regarding this issue.
+
+We also evaluate the matching rate of images added with Gaussian noise, as described in Section 3.3. However, we observe that the matching rate of any of the 5 models is $0 \%$ . Therefore, we conclude that by adding Gaussian noise, the attacker cannot generate successful targeted adversarial examples at all, let alone targeted transferability.
+
+# 5 ENSEMBLE-BASED APPROACHES
+
+We hypothesize that if an adversarial image remains adversarial for multiple models, then it is more likely to transfer to other models as well. We develop techniques to generate adversarial images for multiple models. The basic idea is to generate adversarial images for the ensemble of the models. Formally, given $k$ white-box models with softmax outputs being $J _ { 1 } , . . . , J _ { k }$ , an original image $x$ , and its ground truth $y$ , the ensemble-based approach solves the following optimization problem (for targeted attack):
+
+$$
+\operatorname { a r g m i n } _ { x \star } - \log \big ( ( \sum _ { i = 1 } ^ { k } \alpha _ { i } J _ { i } ( x ^ { \star } ) ) \cdot \mathbf { 1 } _ { y ^ { \star } } \big ) + \lambda d ( x , x ^ { \star } )
+$$
+
+where $y ^ { \star }$ is the target label specified by the adversary, $\sum \alpha _ { i } J _ { i } ( x ^ { \star } )$ is the ensemble model, and $\alpha _ { i }$ are the ensemble weights, $\textstyle \sum _ { i = 1 } ^ { k } \alpha _ { i } = 1$ . Note that (6) is the targeted objective. The non-targeted counterpart can be derived similarly. In doing so, we hope the generated adversarial images remain adversarial for an additional black-box model $J _ { k + 1 }$ .
+
+We evaluate the effectiveness of the ensemble-based approach. For each of the five models, we treat it as the black-box model to attack, and generate adversarial images for the ensemble of the rest four, which is considered as white-box. We evaluate the generated adversarial images over all five models. Throughout the rest of the paper, we refer to the approaches evaluated in Section 3 and 4 as the approaches using a single model, and to the ensemble-based approaches discussed in this section as the approaches using an ensemble model.
+
+Optimization-based approach. We use Adam to optimize the objective (6) with equal ensemble weights across all models in the ensemble to generate targeted adversarial examples. In particular, we set the learning rate of Adam to be 8 for each model. In each iteration, we compute the Adam update for each model, sum up the four updates, and add the aggregation onto the image. We run 100 iterations of updates, and we observe that the loss converges after 100 iterations. By doing so, for the first time, we observe a large proportion of the targeted adversarial images whose target labels can transfer. The results are presented in Table 3. We observe that not all targeted adversarial images can be misclassified to the target labels by the models used in the ensemble. This suggests that while searching for an adversarial example for the ensemble model, there is no direct supervision to mislead any individual model in the ensemble to predict the target label. Further, from the diagonal numbers of the table, we observe that the transferability to ResNet models is better than to VGG-16 or GoogLeNet, when adversarial examples are generated against all models except the target model.
+
+We also evaluate non-targeted adversarial images generated by the ensemble-based approach. We observe that the generated adversarial images have almost perfect transferability. We use the same procedure as for the targeted version, except the objective to generate the adversarial images. We evaluate the generated adversarial images over all models. The results are presented in Table 4. The generated adversarial images all have RMSDs around 17, which are lower than 22 to 23 of the optimization-based approach using a single model (See Table 1 for comparison). When the adversarial images are evaluated over models which are not used to generate the attack, the accuracy is no greater than $6 \%$ . For a reference, the corresponding accuracies for all approaches evaluated in Section 3 using one single model are at least $12 \%$ . Our experiments demonstrate that the ensemblebased approaches can generate almost perfectly transferable adversarial images.
+
+Fast gradient-based approach. The results for non-targeted fast gradient-based approaches applied to the ensemble can be found in our online technical report: Liu et al. (2016). We observe that the diagonal values are not zero, which is the same as we observed in the results for FG and
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>RMSD</td><td rowspan=1 colspan=1>ResNet-152</td><td rowspan=1 colspan=1>ResNet-101</td><td rowspan=1 colspan=1>ResNet-50</td><td rowspan=1 colspan=1>VGG-16</td><td rowspan=1 colspan=1>GoogLeNet</td></tr><tr><td rowspan=1 colspan=1>-ResNet-152</td><td rowspan=1 colspan=1>30.68</td><td rowspan=1 colspan=1>38%</td><td rowspan=1 colspan=1>76%</td><td rowspan=1 colspan=1>70%</td><td rowspan=1 colspan=1>97%</td><td rowspan=1 colspan=1>76%</td></tr><tr><td rowspan=1 colspan=1>-ResNet-101</td><td rowspan=1 colspan=1>30.76</td><td rowspan=1 colspan=1>75%</td><td rowspan=1 colspan=1>43%</td><td rowspan=1 colspan=1>69%</td><td rowspan=1 colspan=1>98%</td><td rowspan=1 colspan=1>73%</td></tr><tr><td rowspan=1 colspan=1>-ResNet-50</td><td rowspan=1 colspan=1>30.26</td><td rowspan=1 colspan=1>84%</td><td rowspan=1 colspan=1>81%</td><td rowspan=1 colspan=1>46%</td><td rowspan=1 colspan=1>99%</td><td rowspan=1 colspan=1>77%</td></tr><tr><td rowspan=1 colspan=1>-VGG-16</td><td rowspan=1 colspan=1>31.13</td><td rowspan=1 colspan=1>74%</td><td rowspan=1 colspan=1>78%</td><td rowspan=1 colspan=1>68%</td><td rowspan=1 colspan=1>24%</td><td rowspan=1 colspan=1>63%</td></tr><tr><td rowspan=1 colspan=1>-GoogLeNet</td><td rowspan=1 colspan=1>29.70</td><td rowspan=1 colspan=1>90%</td><td rowspan=1 colspan=1>87%</td><td rowspan=1 colspan=1>83%</td><td rowspan=1 colspan=1>99%</td><td rowspan=1 colspan=1>11%</td></tr></table>
+
+Table 3: The matching rate of targeted adversarial images generated using the optimization-based approach. The first column indicates the average RMSD of the generated adversarial images. Cell $( i , j )$ indicates that percentage of the targeted adversarial images generated for the ensemble of the four models except model $i$ (row) is predicted as the target label by model $j$ (column). In each row, the minus sign “−” indicates that the model of the row is not used when generating the attacks. Results of top-5 matching rate can be found in our online technical report: Liu et al. (2016).
+
+Table 4: Accuracy of non-targeted adversarial images generated using the optimization-based approach. The first column indicates the average RMSD of the generated adversarial images. Cell $\bar { ( } i , j )$ corresponds to the accuracy of the attack generated using four models except model $i$ (row) when evaluated over model $j$ (column). In each row, the minus sign “−” indicates that the model of the row is not used when generating the attacks. Results of top-5 accuracy can be found in our online technical report: Liu et al. (2016).   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>RMSD</td><td rowspan=1 colspan=1>ResNet-152</td><td rowspan=1 colspan=1>ResNet-101</td><td rowspan=1 colspan=1>ResNet-50</td><td rowspan=1 colspan=1>VGG-16</td><td rowspan=1 colspan=1>GoogLeNet</td></tr><tr><td rowspan=1 colspan=1>-ResNet-152</td><td rowspan=1 colspan=1>17.17</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>0%</td></tr><tr><td rowspan=1 colspan=1>-ResNet-101</td><td rowspan=1 colspan=1>17.25</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>1%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>0%</td></tr><tr><td rowspan=1 colspan=1>-ResNet-50</td><td rowspan=1 colspan=1>17.25</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>2%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>0%</td></tr><tr><td rowspan=1 colspan=1>-VGG-16</td><td rowspan=1 colspan=1>17.80</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>6%</td><td rowspan=1 colspan=1>0%</td></tr><tr><td rowspan=1 colspan=1>-GoogLeNet</td><td rowspan=1 colspan=1>17.41</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>5%</td></tr></table>
+
+FGS applied to a single model. We hypothesize a potential reason is that the gradient directions of different models in the ensemble are orthogonal to each other, as we will illustrate in Section 6. In this case, the gradient direction of the ensemble is almost orthogonal to the one of each model in the ensemble. Therefore searching along this direction may require large distortion to reach adversarial examples.
+
+For targeted adversarial examples generated using FG and FGS based on an ensemble model, their transferability is no better than the ones generated using a single model. The results can be found in our online technical report: Liu et al. (2016). We hypothesize the same reason to explain this: there are only few possible target labels in total in the 1-D subspace.
+
+# 6 GEOMETRIC PROPERTIES OF DIFFERENT MODELS
+
+In this section, we show some geometric properties of the models to try to better understand transferable adversarial examples. Prior works also try to understand the geometic properties of adversarial examples theoretically (Fawzi et al. (2016)) or empirically (Goodfellow et al. (2014)). In this work, we examine large models trained over a large dataset with 1000 labels, whose geometric properties are never examined before. This allows us to make new observations to better understand the models and their adversarial examples.
+
+The gradient directions of different models in our evaluation are almost orthogonal to each other. We study whether the adversarial directions of different models align with each other. We calculate cosine value of the angle between gradient directions of different models, and the results can be found in our online technical report: Liu et al. (2016). We observe that all non-diagonal values are close to 0, which indicates that for most images, their gradient directions with respect to different models are orthogonal to each other.
+
+Decision boundaries of the non-targeted approaches using a single model. We study the decision boundary of different models to understand why adversarial examples transfer. We choose two normalized orthogonal directions $\delta _ { 1 } , \delta _ { 2 }$ , one being the gradient direction of VGG-16 and the other being randomly chosen. Each point $( u , v )$ in this 2-D plane corresponds to the image $x + u \delta _ { 1 } + v \delta _ { 2 }$ , where $x$ is the pixel value vector of the original image. For each model, we plot the label of the image corresponding to each point, and get Figure 3 using the image in Figure 2.
+
+![](images/27c4d2952213ff375ebcd9b1e14f8daf41bbf8494608a59f73f27f3b02c8f666.jpg)  
+Figure 2: The example image to study the decision boundary. Its ID in ILSVRC 2012 validation set is 49443, and its ground truth label is “anemone fish.”
+
+![](images/53ca6a7451be317d8123c2ddab3107233619e27cdc5de469e3e71e5c26a5196e.jpg)  
+Figure 3: Decision regions of different models. We pick the same two directions for all plots: one is the gradient direction of VGG-16 $\mathbf { \bar { X } }$ -axis), and the other is a random orthogonal direction (y-axis). Each point in the span plane shows the predicted label of the image generated by adding a noise to the original image (e.g., the origin corresponds to the predicted label of the original image). The units of both axises are 1 pixel values. All sub-figure plots the regions on the span plane using the same color for the same label. The image is in Figure 2.
+
+We can observe that for all models, the region that each model can predict the image correctly is limited to the central area. Also, along the gradient direction, the classifiers are soon misled. One interesting finding is that along this gradient direction, the first misclassified label for the three ResNet models (corresponding to the light green region) is the label “orange”. A more detailed study can be found in our online technical report: Liu et al. (2016). When we look at the zoomout figures, however, the labels of images that are far away from the original one are different for different models, even among ResNet models.
+
+On the other hand, in Table 5, we show the total number of regions in each plane. In fact, for each plane, there are at most 21 different regions in all planes. Compared with the 1,000 total categories in ImageNet, this is only $2 . 1 \%$ of all categories. That means, for all other $9 7 . 9 \%$ labels, no targeted adversarial example exists in each plane. Such a phenomenon partially explains why fast gradientbased approaches can hardly find targeted adversarial images.
+
+Further, in Figure 4, we draw the decision boundaries of all models on the same plane as described above. We can observe that
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>VGG-16</td><td rowspan=1 colspan=1>ResNet-50</td><td rowspan=1 colspan=1>ResNet-101</td><td rowspan=1 colspan=1>ResNet-152</td><td rowspan=1 colspan=1>GoogLeNet</td></tr><tr><td rowspan=1 colspan=1>#oflabels</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>21</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>21</td></tr></table>
+
+Table 5: The number of all possible predicted labels for each model in the same plane described in Figure 3.
+
+![](images/05c61d41b67a160eb809a601179a1bbfdb834ea54056d39fa6c2af97f2f429c1.jpg)  
+Figure 4: The decision boundary to separate the region within which all points are classified as the ground truth label (encircled by each closed curve) from others. The plane is the same one described in Figure 3. The origin of the coordinate plane corresponds to the original image. The units of both axises are 1 pixel values.
+
+![](images/b3a6cc0e689124a69d00a525719744fef7d87ee7a80949cc9358ee3722444e9d.jpg)  
+Figure 5: The decision boundary to separate the region within which all points are classified as the target label (encircled by each closed curve) from others. The plane is spanned by the targeted adversarial direction and a random orthogonal direction. The targeted adversarial direction is computed as the difference between the original image in Figure 2 and the adversarial image generated by the optimization-based approach for an ensemble. The ensemble contains all models except ResNet101. The origin of the coordinate plane corresponds to the original image. The units of both axises are 1 pixel values.
+
+• The boundaries align with each other very well. This partially explains why non-targeted adversarial images can transfer among models. The boundary diameters along the gradient direction is less than the ones along the random direction. A potential reason is that moving a variable along its gradient direction can change the loss function (i.e., the probability of the ground truth label) significantly. Therefore along the gradient direction it will take fewer steps to move out of the ground truth region than a random direction.   
+• An interesting finding is that even though we move left along the x-axis, which is equivalent to maximizing the ground truth’s prediction probability, it also reaches the boundary much sooner than moving along a random direction. We attribute this to the non-linearity of the loss function: when the distortion is larger, the gradient direction also changes dramatically. In this case, moving along the original gradient direction no longer increases the probability to predict the ground truth label (details can be found in our online technical report: Liu et al. (2016)).   
+• As for VGG-16 model, there is a small hole within the region corresponding to the ground truth. This may partially explain why non-targeted adversarial images with small distortion exist, but do not transfer well. This hole does not exist in other models’ decision planes. In this case, non-targeted adversarial images in this hole do not transfer.
+
+Decision boundaries of the targeted ensemble-based approaches. In addition, we choose the targeted adversarial direction of the ensemble of all models except ResNet-101 and a random orthogonal direction, and we plot decision boundaries on the plane spanned by these two direction vectors in Figure 5. We observe that the regions of images, which are predicted as the target label, align well for the four models in the ensemble. However, for the model not used to generate the adversarial image, i.e., ResNet-101, it also has a non-empty region such that the prediction is successfully misled to the target label, although the area is much smaller. Meanwhile, the region within each closed curve of the models almost has the same center.
+
+Clarifai.com is a commercial company providing state-of-the-art image classification services. We have no knowledge about the dataset and types of models used behind Clarifai.com, except that we have black-box access to the services. The labels returned from Clarifai.com are also different from the categories in ILSVRC 2012. We submit all 100 original images to Clarifai.com and the returned labels are correct based on a subjective measure.
+
+We also submit 400 adversarial images in total, where 200 of them are targeted adversarial examples, and the rest 200 are non-targeted ones. As for the 200 targeted adversarial images, 100 of them are generated using the optimization-based approach based on VGG-16 (the same ones evaluated in Table 2), and the rest 100 are generated using the optimization-based approach based on an ensemble of all models except ResNet-152 (the same ones evaluated in Table 3). The 200 nontargeted adversarial examples are generated similarly (the same ones evaluated in Table 1 and 4).
+
+For non-targeted adversarial examples, we observe that for both the ones generated using VGG-16 and those generated using the ensemble, most of them can transfer to Clarifai.com.
+
+More importantly, a large proportion of our targeted adversarial examples are misclassified by Clarifai.com as well. We observe that $5 7 \%$ of the targeted adversarial examples generated using VGG-16, and $7 6 \%$ of the ones generated using the ensemble can mislead Clarifai.com to predict labels irrelevant to the ground truth.
+
+Further, our experiment shows that for targeted adversarial examples, $1 8 \%$ of those generated using the ensemble model can be predicted as labels close to the target label by Clarifai.com. The corresponding number for the targeted adversarial examples generated using VGG-16 is $2 \%$ . Considering that in the case of attacking Clarifai.com, the labels given by the target model are different from those given by our models, it is fairly surprising to see that when using the ensemble-based approach, there is still a considerable proportion of our targeted adversarial examples that can mislead this black-box model to make predictions semantically similar to our target labels. All these numbers are computed based on a subjective measure, and we include some examples in Table 6. More examples can be found in our online technical report: Liu et al. (2016).
+
+<table><tr><td rowspan=1 colspan=1>originalimage</td><td rowspan=1 colspan=1>truelabel</td><td rowspan=1 colspan=1>Clarifai.comresults oforiginal image</td><td rowspan=1 colspan=1>targetlabel</td><td rowspan=1 colspan=1>targetedadversarialexample</td><td rowspan=1 colspan=1>Clarifai.comresultsof targetedadversarial example</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>viaduct</td><td rowspan=1 colspan=1>bridge,sight,arch,river,sky</td><td rowspan=1 colspan=1>windowscreen</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>window,wall,old,decoration,design</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>hip, rosehip,rosehip</td><td rowspan=1 colspan=1>fruit,fall,food,little,wildlife</td><td rowspan=1 colspan=1>stupa,tope</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Buddha,gold,temple,celebration,artistic</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>dogsled,dogsled,dogsleigh</td><td rowspan=1 colspan=1> group together,four,sledge,sled,enjoyment</td><td rowspan=1 colspan=1>hip, rosehip,rosehip</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>cherry,branch,fruit,food,season</td></tr></table>
+
+Table 6: Original images and adversarial images evaluated over Clarifai.com. For labels returned from Clarifai.com, we sort the labels firstly by rareness: how many times a label appears in the Clarifai.com results for all adversarial images and original images, and secondly by confidence. Only top 5 labels are provided.   
+
+<table><tr><td rowspan=1 colspan=1>pug,pug-dog</td><td rowspan=1 colspan=1>pug,friendship,adorable,purebred,sit</td><td rowspan=1 colspan=1>sea lion</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>sea seal,ocean,head,sea,cute</td></tr><tr><td rowspan=1 colspan=1>OldEnglishsheep-dog，bobtail</td><td rowspan=1 colspan=1>poodle,retriever,loyalty,sit,two</td><td rowspan=1 colspan=1>abaya</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>veil,spirituality,religion,people,illustration</td></tr><tr><td rowspan=1 colspan=1>maillot,tank suit</td><td rowspan=1 colspan=1>beach,woman,adult,wear,portrait</td><td rowspan=1 colspan=1>amphib-ian,amphibi-ousvehicle</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>transportationsystem,vehicle,man,print,retro</td></tr><tr><td rowspan=1 colspan=1>patas,hussarmonkey,Erythro-cebuspatas</td><td rowspan=1 colspan=1>primate,monkey,safari,sit,looking</td><td rowspan=1 colspan=1>bee eater</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>ornithology,avian,beak,wing,feather</td></tr></table>
+
+# 8 CONCLUSION
+
+In this work, we are the first to conduct an extensive study of the transferability of both non-targeted and targeted adversarial examples generated using different approaches over large models and a large scale dataset. Our results confirm that the transferability for non-targeted adversarial examples are prominent even for large models and a large scale dataset. On the other hand, we find that it is hard to use existing approaches to generate targeted adversarial examples whose target labels can transfer. We develop novel ensemble-based approaches, and demonstrate that they can generate transferable targeted adversarial examples with a high success rate. Meanwhile, these new approaches exhibit better performance on generating non-targeted transferable adversarial examples than previous work. We also show that both non-targeted and targeted adversarial examples generated using our new approaches can successfully attack Clarifai.com, which is a black-box image classification system. Furthermore, we study some geometric properties to better understand the transferable adversarial examples.
+
+# ACKNOWLEDGMENTS
+
+This material is in part based upon work supported by the National Science Foundation under Grant No. TWC-1409915. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the National Science Foundation.
+
+# REFERENCES
+
+Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. arXiv preprint arXiv:1608.04644, 2016.
+
+Alhussein Fawzi, Seyed-Mohsen Moosavi-Dezfooli, and Pascal Frossard. Robustness of classifiers: from adversarial to random noise. In Advances in Neural Information Processing Systems, pp. 1624–1632, 2016.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. arXiv preprint arXiv:1512.03385, 2015.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2014. URL http://arxiv.org/abs/1412.6980.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. arXiv preprint arXiv:1611.02770, 2016.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, Omar Fawzi, and Pascal Frossard. Universal adversarial perturbations. arXiv preprint arXiv:1610.08401, 2016.
+
+Nicolas Papernot, Patrick McDaniel, and Ian Goodfellow. Transferability in machine learning: from phenomena to black-box attacks using adversarial samples. arXiv preprint arXiv:1605.07277, 2016a.
+
+Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against deep learning systems using adversarial examples. arXiv preprint arXiv:1602.02697, 2016b.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. ImageNet Large Scale Visual Recognition Challenge. International Journal of Computer Vision (IJCV), 115(3):211–252, 2015. doi: 10.1007/s11263-015-0816-y.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. CoRR, abs/1409.1556, 2014. URL http://arxiv.org/abs/1409.1556.
+
+J. Stallkamp, M. Schlipsing, J. Salmen, and C. Igel. Man vs. computer: Benchmarking machine learning algorithms for traffic sign recognition. Neural Networks, (0):–, 2012. ISSN 0893-6080. doi: 10.1016/j.neunet.2012.02.016. URL http://www.sciencedirect.com/science/ article/pii/S0893608012000457.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013.
+
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott E. Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. CoRR, abs/1409.4842, 2014. URL http://arxiv.org/abs/1409.4842.

parse/train/Sys6GJqxl/Sys6GJqxl_content_list.json

@@ -0,0 +1,1677 @@
+[
+    {
+        "type": "text",
+        "text": "DELVING INTO TRANSFERABLE ADVERSARIAL EXAMPLES AND BLACK-BOX ATTACKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yanpei Liu∗, Xinyun Chen∗ Shanghai Jiao Tong University ",
+        "bbox": [
+            184,
+            170,
+            385,
+            199
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Chang Liu, Dawn Song University of the California, Berkeley ",
+        "bbox": [
+            485,
+            170,
+            732,
+            199
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "An intriguing property of deep neural networks is the existence of adversarial examples, which can transfer among different architectures. These transferable adversarial examples may severely hinder deep neural network-based applications. Previous works mostly study the transferability using small scale datasets. In this work, we are the first to conduct an extensive study of the transferability over large models and a large scale dataset, and we are also the first to study the transferability of targeted adversarial examples with their target labels. We study both non-targeted and targeted adversarial examples, and show that while transferable non-targeted adversarial examples are easy to find, targeted adversarial examples generated using existing approaches almost never transfer with their target labels. Therefore, we propose novel ensemble-based approaches to generating transferable adversarial examples. Using such approaches, we observe a large proportion of targeted adversarial examples that are able to transfer with their target labels for the first time. We also present some geometric studies to help understanding the transferable adversarial examples. Finally, we show that the adversarial examples generated using ensemble-based approaches can successfully attack Clarifai.com, which is a black-box image classification system. ",
+        "bbox": [
+            233,
+            268,
+            764,
+            505
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            539,
+            336,
+            555
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent research has demonstrated that for a deep architecture, it is easy to generate adversarial examples, which are close to the original ones but are misclassified by the deep architecture (Szegedy et al. (2013); Goodfellow et al. (2014)). The existence of such adversarial examples may have severe consequences, which hinders vision-understanding-based applications, such as autonomous driving. Most of these studies require explicit knowledge of the underlying models. It remains an open question how to efficiently find adversarial examples for a black-box model. ",
+        "bbox": [
+            174,
+            574,
+            823,
+            657
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Several works have demonstrated that some adversarial examples generated for one model may also be misclassified by another model. Such a property is referred to as transferability, which can be leveraged to perform black-box attacks. This property has been exploited by constructing a substitute of the black-box model, and generating adversarial instances against the substitute to attack the black-box system (Papernot et al. (2016a;b)). However, so far, transferability is mostly examined over small datasets, such as MNIST (LeCun et al. (1998)) and CIFAR-10 (Krizhevsky & Hinton (2009)). It has yet to be better understood transferability over large scale datasets, such as ImageNet (Russakovsky et al. (2015)). ",
+        "bbox": [
+            174,
+            664,
+            825,
+            775
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we are the first to conduct an extensive study of the transferability of different adversarial instance generation strategies applied to different state-of-the-art models trained over a large scale dataset. In particular, we study two types of adversarial examples: (1) non-targeted adversarial examples, which can be misclassified by a network, regardless of what the misclassified labels may be; and (2) targeted adversarial examples, which can be classified by a network as a target label. We examine several existing approaches searching for adversarial examples based on a single model. While non-targeted adversarial examples are more likely to transfer, we observe few targeted adversarial examples that are able to transfer with their target labels. ",
+        "bbox": [
+            174,
+            782,
+            823,
+            893
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We further propose a novel strategy to generate transferable adversarial images using an ensemble of multiple models. In our evaluation, we observe that this new strategy can generate non-targeted adversarial instances with better transferability than other methods examined in this work. Also, for the first time, we observe a large proportion of targeted adversarial examples that are able to transfer with their target labels. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We study geometric properties of the models in our evaluation. In particular, we show that the gradient directions of different models are orthogonal to each other. We also show that decision boundaries of different models align well with each other, which partially illustrates why adversarial examples can transfer. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            236
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Last, we study whether generated adversarial images can attack Clarifai.com, a commercial company providing state-of-the-art image classification services. We have no knowledge about the training dataset and the types of models used by Clarifai.com; meanwhile, the label set of Clarifai.com is quite different from ImageNet’s. We show that even in this case, both non-targeted and targeted adversarial images transfer to Clarifai.com. This is the first work documenting the success of generating both non-targeted and targeted adversarial examples for a black-box state-of-the-art online image classification system, whose model and training dataset are unknown to the attacker. ",
+        "bbox": [
+            174,
+            243,
+            825,
+            340
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Contributions and organization. We summarize our main contributions as follows: ",
+        "bbox": [
+            176,
+            356,
+            736,
+            371
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• For ImageNet models, we show that while existing approaches are effective to generate non-targeted transferable adversarial examples (Section 3), only few targeted adversarial examples generated by existing methods can transfer (Section 4).   \n• We propose novel ensemble-based approaches to generate adversarial examples (Section 5). Our approaches enable a large portion of targeted adversarial examples to transfer among multiple models for the first time.   \nWe are the first to present that targeted adversarial examples generated for models trained on ImageNet can transfer to a black-box system, i.e., Clarifai.com, whose model, training data, and label set is unknown to us (Section 7). In particular, Clarifai.com’s label set is very different from ImageNet’s.   \n• We conduct the first analysis of geometric properties for large models trained over ImageNet (Section 6), and the results reveal several interesting findings, such as the gradient directions of different models are orthogonal to each other. ",
+        "bbox": [
+            215,
+            383,
+            825,
+            580
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the following, we first discuss related work, and then present the background knowledge and experiment setup in Section 2. Then we present each of our experiments and conclusions in the corresponding section as mentioned above. ",
+        "bbox": [
+            176,
+            593,
+            821,
+            635
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Related work. Transferability of adversarial examples was first examined by Szegedy et al. (2013), which studied the transferability (1) between different models trained over the same dataset; and (2) between the same or different model trained over disjoint subsets of a dataset; However, Szegedy et al. (2013) only studied MNIST. ",
+        "bbox": [
+            174,
+            651,
+            823,
+            707
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The study of transferability was followed by Goodfellow et al. (2014), which attributed the phenomenon of transferability to the reason that the adversarial perturbation is highly aligned with the weight vector of the model. Again, this hypothesis was tested using MNIST and CIFAR-10 datasets. We show that this is not the case for models trained over ImageNet. ",
+        "bbox": [
+            176,
+            714,
+            823,
+            770
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Papernot et al. (2016a;b) examined constructing a substitute model to attack a black-box target model. To train the substitute model, they developed a technique that synthesizes a training set and annotates it by querying the target model for labels. They demonstrate that using this approach, black-box attacks are feasible towards machine learning services hosted by Amazon, Google, and MetaMind. Further, Papernot et al. (2016a) studied the transferability between deep neural networks and other models such as decision tree, kNN, etc. ",
+        "bbox": [
+            174,
+            777,
+            825,
+            861
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our work differs from Papernot et al. (2016a;b) in three aspects. First, in these works, only the model and the training process are a black box, but the training set and the test set are controlled by the attacker; in contrast, we attack Clarifai.com, whose model, training data, training process, and even the test label set are unknown to the attacker. Second, the datasets studied in these works are small scale, i.e., MNIST and GTSRB (Stallkamp et al. (2012)); in our work, we study the transferability over larger models and a larger dataset, i.e., ImageNet. Third, to attack black-box machine learning systems, we do not query the systems for constructing the substitute model ourselves. ",
+        "bbox": [
+            176,
+            867,
+            823,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In a concurrent and independent work, Moosavi-Dezfooli et al. (2016) showed the existence of a universal perturbation for each model, which can transfer across different images. They also show that the adversarial images generated using these universal perturbations can transfer across different models on ImageNet. However, they only examine the non-targeted transferability, while our work studies both non-targeted and targeted transferability over ImageNet. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            222
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 ADVERSARIAL DEEP LEARNING AND TRANSFERABILITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            242,
+            678,
+            258
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 THE ADVERSARIAL DEEP LEARNING PROBLEM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            275,
+            537,
+            287
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We assume a classifier $f _ { \\boldsymbol { \\theta } } ( \\boldsymbol { x } )$ outputs a category (or a label) as the prediction. Given an original image $x$ , with ground truth label $y$ , the adversarial deep learning problem is to seek for adversarial examples for the classifier $f _ { \\boldsymbol { \\theta } } ( \\boldsymbol { x } )$ . Specifically, we consider two classes of adversarial examples. A non-targeted adversarial example $x ^ { \\star }$ is an instance that is close to $x$ , in which case $x ^ { \\star }$ should have the same ground truth as $x$ , while $f _ { \\theta } ( x ^ { \\star } ) \\neq y$ . For the problem to be non-trivial, we assume $f _ { \\boldsymbol { \\theta } } ( x ) = y$ without loss of generality. A targeted adversarial example $x ^ { \\star }$ is close to $x$ and satisfies $f _ { \\theta } ( x ^ { \\star } ) = y ^ { \\star }$ , where $y ^ { \\star }$ is a target label specified by the adversary, and $y ^ { \\star } \\ne y$ . ",
+        "bbox": [
+            173,
+            299,
+            825,
+            397
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 APPROACHES FOR GENERATING ADVERSARIAL EXAMPLES",
+        "text_level": 1,
+        "bbox": [
+            173,
+            415,
+            619,
+            428
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this work, we consider three classes of approaches for generating adversarial examples: optimization-based approaches, fast gradient approaches, and fast gradient sign approaches. Each class has non-targeted and targeted versions respectively. ",
+        "bbox": [
+            174,
+            439,
+            823,
+            482
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2.1 APPROACHES FOR GENERATING NON-TARGETED ADVERSARIAL EXAMPLES",
+        "text_level": 1,
+        "bbox": [
+            173,
+            497,
+            748,
+            511
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Formally, given an image $x$ with ground truth $y = f _ { \\boldsymbol { \\theta } } ( \\boldsymbol { x } )$ , searching for a non-targeted adversarial example can be modeled as searching for an instance $x ^ { \\star }$ to satisfy the following constraints: ",
+        "bbox": [
+            173,
+            521,
+            830,
+            550
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/522d43776650accc56c39ed9bde9e7438291848777232cbda09760a8f2b37dd5.jpg",
+        "text": "$$\n\\begin{array} { r } { f _ { \\theta } ( x ^ { \\star } ) \\neq y } \\\\ { d ( x , x ^ { \\star } ) \\leq B } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            436,
+            554,
+            531,
+            593
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $d ( \\cdot , \\cdot )$ is a metric to quantify the distance between an original image and its adversarial counterpart, and $B$ , called distortion, is an upper bound placed on this distance. Without loss of generality, we consider model $f$ is composed of a network $J _ { \\theta } ( x )$ , which outputs the probability for each category, so that $f$ outputs the category with the highest probability. ",
+        "bbox": [
+            174,
+            595,
+            823,
+            652
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Optimization-based approach. One approach is to approximate the solution to the following optimization problem: ",
+        "bbox": [
+            173,
+            666,
+            823,
+            694
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d44c0999f2574e8d8af9428d5610ac2a9461ab942c04c16b2d4c3b7bcbc55034.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { a r g m i n } _ { x ^ { \\star } } \\lambda d ( x , x ^ { \\star } ) - \\ell ( \\mathbf { 1 } _ { y } , J _ { \\theta } ( x ^ { \\star } ) ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            693,
+            624,
+            710
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where ${ \\bf 1 } _ { y }$ is the one-hot encoding of the ground truth label $y , \\ell$ is a loss function to measure the distance between the prediction and the ground truth, and $\\lambda$ is a constant to balance constraints (2) and (1), which is empirically determined. Here, loss function $\\ell$ is used to approximate constraint (1), and its choice can affect the effectiveness of searching for an adversarial example. In this work, we choose $\\ell ( u , v ) = \\log { ( 1 - u \\cdot v ) }$ , which is shown to be effective by Carlini & Wagner (2016). ",
+        "bbox": [
+            174,
+            713,
+            825,
+            784
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Fast gradient sign (FGS). Goodfellow et al. (2014) proposed the fast gradient sign (FGS) method so that the gradient needs be computed only once to generate an adversarial example. FGS can be used to generate adversarial images to meet the $L _ { \\infty }$ norm bound. Formally, non-targeted adversarial examples are constructed as ",
+        "bbox": [
+            173,
+            796,
+            825,
+            853
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cf69b931d61d63ec428c5de492f0cb9995e07864e42313d5a52491aa90407901.jpg",
+        "text": "$$\n\\boldsymbol { x } ^ { \\star } \\gets \\mathrm { c l i p } ( \\boldsymbol { x } + B \\mathbf { s g n } ( \\nabla _ { \\boldsymbol { x } } \\ell ( \\mathbf { 1 } _ { \\boldsymbol { y } } , J _ { \\boldsymbol { \\theta } } ( \\boldsymbol { x } ) ) ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            859,
+            633,
+            877
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, $\\operatorname { c l i p } ( x )$ is used to clip each dimension of $x$ to the range of pixel values, i.e., $[ 0 , 2 5 5 ]$ in this work. We make a slight variation to choose $\\ell ( u , v ) = \\log { ( 1 - u \\cdot v ) }$ , which is the same as used in the optimization-based approach. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Fast gradient (FG). The fast gradient approach (FG) is similar to FGS, but instead of moving along the gradient sign direction, FG moves along the gradient direction. In particular, we have ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e080819525a4269f5cb39aa6dbb9b0ed251e881adf03d78969dd0dce252d72ac.jpg",
+        "text": "$$\nx ^ { \\star } \\gets \\mathrm { c l i p } ( x + B \\frac { \\nabla _ { x } \\ell ( \\mathbf { 1 } _ { y } , J _ { \\theta } ( x ) ) } { | | \\nabla _ { x } \\ell ( \\mathbf { 1 } _ { y } , J _ { \\theta } ( x ) ) | | } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            133,
+            629,
+            167
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here, we assume the distance metric in constraint (2), $d ( x , x ^ { \\star } ) = | | x - x ^ { \\star } | |$ is a norm of $x - x ^ { \\star }$ The term sgn(∇x\\`) in FGS is replaced by ∇x\\`||∇ \\`|| to meet this distance constraint. ",
+        "bbox": [
+            174,
+            169,
+            818,
+            203
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We call both FGS and FG fast gradient-based approaches. ",
+        "bbox": [
+            173,
+            208,
+            558,
+            223
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2.2 APPROACHES FOR GENERATING TARGETED ADVERSARIAL EXAMPLES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            238,
+            712,
+            252
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A targeted adversarial image $x ^ { \\star }$ is similar to a non-targeted one, but constraint (1) is replaced by ",
+        "bbox": [
+            173,
+            261,
+            803,
+            276
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f982fef3bcac6177d836eacf2a13cdf205aa35e6010812f8fa06d90c89b8d1b3.jpg",
+        "text": "$$\nf _ { \\theta } ( x ^ { \\star } ) = y ^ { \\star }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            439,
+            279,
+            526,
+            295
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $y ^ { \\star }$ is the target label given by the adversary. For the optimization-based approach, we approximate the solution by solving the following dual objective: ",
+        "bbox": [
+            176,
+            296,
+            821,
+            324
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/446a650524833dc183c55e7b56b02a832624e1035e1734aa6d031d0df5bea19c.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { a r g m i n } _ { x ^ { \\star } } \\lambda d ( x , x ^ { \\star } ) + \\ell ^ { \\prime } ( \\mathbf { 1 } _ { y ^ { \\star } } , J _ { \\theta } ( x ^ { \\star } ) ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            325,
+            629,
+            343
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this work, we choose the standard cross entropy loss $\\ell ^ { \\prime } ( u , v ) = - \\sum _ { i } u _ { i } \\log v _ { i } .$ ",
+        "bbox": [
+            174,
+            344,
+            700,
+            368
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For FGS and FG, we construct adversarial examples as follows: ",
+        "bbox": [
+            174,
+            373,
+            591,
+            388
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a1887630fc76b5a33fe3cc990d50bdf003055e01ecec0a305f8e2d4e6d38a26c.jpg",
+        "text": "$$\n\\begin{array} { r l } & { x ^ { \\star }  \\mathrm { c l i p } ( x - B \\mathbf { s g n } ( \\nabla _ { x } \\ell ^ { \\prime } ( \\mathbf { 1 } _ { y ^ { \\star } } , J _ { \\theta } ( x ) ) ) ) } \\\\ & { \\quad x ^ { \\star }  \\mathrm { c l i p } ( x - B \\frac { \\nabla _ { x } \\ell ^ { \\prime } ( \\mathbf { 1 } _ { y ^ { \\star } } , J _ { \\theta } ( x ) ) } { \\vert \\vert \\nabla _ { x } \\ell ^ { \\prime } ( \\mathbf { 1 } _ { y ^ { \\star } } , J _ { \\theta } ( x ) ) \\vert \\vert } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            388,
+            607,
+            443
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\ell ^ { \\prime }$ is the same as the one used for the optimization-based approach. ",
+        "bbox": [
+            173,
+            443,
+            655,
+            457
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 EVALUATION METHODOLOGY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            473,
+            423,
+            487
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For the rest of the paper, we focus on examining the transferability among state-of-the-art models trained over ImageNet (Russakovsky et al. (2015)). In this section, we detail the models to be examined, the dataset to be evaluated, and the measurements to be used. ",
+        "bbox": [
+            174,
+            498,
+            823,
+            540
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Models. We examine five networks, ResNet-50, ResNet-101, ResNet-152 (He et al. $( 2 0 1 5 ) ) ^ { 1 }$ , GoogLeNet (Szegedy et al. (2014))2, and VGG-16 (Simonyan & Zisserman (2014))3. We retrieve the pre-trained models for each network online. The performance of these models on the ILSVRC 2012 (Russakovsky et al. (2015)) validation set can be found in our online technical report: Liu et al. (2016). We choose these models to study the transferability between homogeneous architectures (i.e., ResNet models) and heterogeneous architectures. ",
+        "bbox": [
+            173,
+            554,
+            825,
+            638
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Dataset. It is less meaningful to examine the transferability of an adversarial image between two models which cannot classify the original image correctly. Therefore, from the ILSVRC 2012 validation set, we randomly choose 100 images, which can be classified correctly by all five models in our examination. These 100 images form our test set. To perform targeted attacks, we manually choose a target label for each image, so that its semantics is far from the ground truth. The images and target labels in our evaluation can be found on website4. ",
+        "bbox": [
+            173,
+            654,
+            825,
+            737
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Measuring transferability. Given two models, we measure the non-targeted transferability by computing the percentage of the adversarial examples generated for one model that can be classified correctly for the other. We refer to this percentage as accuracy. A lower accuracy means better non-targeted transferability. We measure the targeted transferability by computing the percentage of the adversarial examples generated for one model that are classified as the target label by the other model. We refer to this percentage as matching rate. A higher matching rate means better targeted transferability. For clarity, the reported results are only based on top-1 accuracy. Top-5 accuracy’s counterparts can be found in our online technical report: Liu et al. (2016). ",
+        "bbox": [
+            173,
+            751,
+            825,
+            863
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Distortion. Besides transferability, another important factor is the distortion between adversarial images and the original ones. We measure the distortion by root mean square deviation, i.e., RMSD, which is computed as $d ( x ^ { \\star } , x ) = \\sqrt { \\textstyle \\sum _ { i } ( x _ { i } ^ { \\star } - x _ { i } ) ^ { 2 } / N }$ , where $x ^ { \\star }$ and $x$ are the vector representations of an adversarial image and the original one respectively, $N$ is the dimensionality of $x$ and $x ^ { \\star }$ , and $x _ { i }$ denotes the pixel value of the $i$ -th dimension of $x$ , within range [0, 255], and similar for $x _ { i } ^ { \\star }$ . ",
+        "bbox": [
+            174,
+            103,
+            825,
+            175
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 NON-TARGETED ADVERSARIAL EXAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            196,
+            566,
+            212
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we examine different approaches for generating non-targeted adversarial images. ",
+        "bbox": [
+            171,
+            227,
+            802,
+            242
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 OPTIMIZATION-BASED APPROACH",
+        "text_level": 1,
+        "bbox": [
+            176,
+            260,
+            449,
+            273
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To apply the optimization-based approach for a single model, we initialize $x ^ { \\star }$ to be $x$ and use Adam Optimizer (Kingma & Ba (2014)) to optimize Objective (3) . We find that we can tune the RMSD by adjusting the learning rate of Adam and $\\lambda$ . We find that, for each model, we can use a small learning rate to generate adversarial images with small RMSD, i.e. $< 2$ , with any $\\lambda$ . In fact, we find that when initializing $x ^ { \\star }$ with $x$ , Adam Optimizer will search for an adversarial example around $x$ , even when we set $\\lambda$ to be 0, i.e., not restricting the distance between $x ^ { \\star }$ and $x$ . Therefore, we set $\\lambda$ to be 0 for all experiments using optimization-based approaches throughout the paper. Although these adversarial examples with small distortions can successfully fool the target model, however, they cannot transfer well to other models (details can be found in our online technical report: Liu et al. (2016)). ",
+        "bbox": [
+            173,
+            286,
+            825,
+            425
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We increase the learning rate to allow the optimization algorithm to search for adversarial images with larger distortion. In particular, we set the learning rate to be 4. We run Adam Optimizer for 100 iterations to generate the adversarial images. We observe that the loss converges after 100 iterations. An alternative optimization-based approach leading to similar results can be found in our online technical report: Liu et al. (2016). ",
+        "bbox": [
+            174,
+            433,
+            825,
+            502
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Non-targeted adversarial examples transfer. We generate non-targeted adversarial examples on one network, but evaluate them on another, and Table 1 Panel A presents the results. From the table, we can observe that ",
+        "bbox": [
+            176,
+            517,
+            823,
+            559
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• The diagonal contains all 0 values. This says that all adversarial images generated for one model can mislead the same model.   \n• A large proportion of non-targeted adversarial images generated for one model using the optimization-based approach can transfer to another.   \n• Although the three ResNet models share similar architectures which differ only in the hyperparameters, adversarial examples generated against a ResNet model do not necessarily transfer to another ResNet model better than other non-ResNet models. For example, the adversarial examples generated for VGG-16 have lower accuracy on ResNet-50 than those generated for ResNet-152 or ResNet-101. ",
+        "bbox": [
+            215,
+            571,
+            825,
+            708
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 FAST GRADIENT-BASED APPROACHES",
+        "text_level": 1,
+        "bbox": [
+            178,
+            732,
+            473,
+            746
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We then examine the effectiveness of fast gradient-based approaches. A good property of fast gradient-based approaches is that all generated adversarial examples lie in a 1-D subspace. Therefore, we can easily approximate the minimal distortion in this subspace of transferable adversarial examples between two models. In the following, we first control the RMSD to study fast gradientbased approaches’ effectiveness. Second, we study the transferable minimal distortions of fast gradient-based approaches. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            842
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2.1 EFFECTIVENESS AND TRANSFERABILITY OF THE FAST GRADIENT-BASED APPROACHES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            858,
+            730,
+            885
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Since the distortion $B$ and the RMSD of the generated adversarial images are highly correlated, we can choose this hyperparameter $B$ to generate adversarial images with a given RMSD. In Table 1 ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/b3e62aad33b323bdfbf1ec7cc7541f68ed8704ef8f7d2b81b2394305a2fcf633.jpg",
+        "table_caption": [
+            "Panel A: Optimization-based approach "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>RMSD</td><td rowspan=1 colspan=1>ResNet-152</td><td rowspan=1 colspan=1>ResNet-101</td><td rowspan=1 colspan=1>ResNet-50</td><td rowspan=1 colspan=1>VGG-16</td><td rowspan=1 colspan=1>GoogLeNet</td></tr><tr><td rowspan=1 colspan=1>ResNet-152</td><td rowspan=1 colspan=1>22.83</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>13%</td><td rowspan=1 colspan=1>18%</td><td rowspan=1 colspan=1>19%</td><td rowspan=1 colspan=1>11%</td></tr><tr><td rowspan=1 colspan=1>ResNet-101</td><td rowspan=1 colspan=1>23.81</td><td rowspan=1 colspan=1>19%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>21%</td><td rowspan=1 colspan=1>21%</td><td rowspan=1 colspan=1>12%</td></tr><tr><td rowspan=1 colspan=1>ResNet-50</td><td rowspan=1 colspan=1>22.86</td><td rowspan=1 colspan=1>23%</td><td rowspan=1 colspan=1>20%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>21%</td><td rowspan=1 colspan=1>18%</td></tr><tr><td rowspan=1 colspan=1>VGG-16</td><td rowspan=1 colspan=1>22.51</td><td rowspan=1 colspan=1>22%</td><td rowspan=1 colspan=1>17%</td><td rowspan=1 colspan=1>17%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>5%</td></tr><tr><td rowspan=1 colspan=1>GoogLeNet</td><td rowspan=1 colspan=1>22.58</td><td rowspan=1 colspan=1>39%</td><td rowspan=1 colspan=1>38%</td><td rowspan=1 colspan=1>34%</td><td rowspan=1 colspan=1>19%</td><td rowspan=1 colspan=1>0%</td></tr></table>",
+        "bbox": [
+            207,
+            101,
+            790,
+            189
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/d4596d0b44e2f6f824fc48bc04d6bca49b1db70ef8147ffa2c78d4c1f0af0561.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Panel B: Fast gradient approach "
+        ],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>RMSD</td><td rowspan=1 colspan=1>ResNet-152</td><td rowspan=1 colspan=1>ResNet-101</td><td rowspan=1 colspan=1>ResNet-50</td><td rowspan=1 colspan=1>VGG-16</td><td rowspan=1 colspan=1>GoogLeNet</td></tr><tr><td rowspan=1 colspan=1>ResNet-152</td><td rowspan=1 colspan=1>23.45</td><td rowspan=1 colspan=1>4%</td><td rowspan=1 colspan=1>13%</td><td rowspan=1 colspan=1>13%</td><td rowspan=1 colspan=1>20%</td><td rowspan=1 colspan=1>12%</td></tr><tr><td rowspan=1 colspan=1>ResNet-101</td><td rowspan=1 colspan=1>23.49</td><td rowspan=1 colspan=1>19%</td><td rowspan=1 colspan=1>4%</td><td rowspan=1 colspan=1>11%</td><td rowspan=1 colspan=1>23%</td><td rowspan=1 colspan=1>13%</td></tr><tr><td rowspan=1 colspan=1>ResNet-50</td><td rowspan=1 colspan=1>23.49</td><td rowspan=1 colspan=1>25%</td><td rowspan=1 colspan=1>19%</td><td rowspan=1 colspan=1>5%</td><td rowspan=1 colspan=1>25%</td><td rowspan=1 colspan=1>14%</td></tr><tr><td rowspan=1 colspan=1>VGG-16</td><td rowspan=1 colspan=1>23.73</td><td rowspan=1 colspan=1>20%</td><td rowspan=1 colspan=1>16%</td><td rowspan=1 colspan=1>15%</td><td rowspan=1 colspan=1>1%</td><td rowspan=1 colspan=1>7%</td></tr><tr><td rowspan=1 colspan=1>GoogLeNet</td><td rowspan=1 colspan=1>23.45</td><td rowspan=1 colspan=1>25%</td><td rowspan=1 colspan=1>25%</td><td rowspan=1 colspan=1>17%</td><td rowspan=1 colspan=1>19%</td><td rowspan=1 colspan=1>1%</td></tr></table>",
+        "bbox": [
+            207,
+            215,
+            790,
+            303
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Transferability of non-targeted adversarial images generated between pairs of models. The first column indicates the average RMSD of all adversarial images generated for the model in the corresponding row. The cell $( i , j )$ indicates the accuracy of the adversarial images generated for model $i$ (row) evaluated over model $j$ (column). Results of top-5 accuracy can be found in our online technical report: Liu et al. (2016). ",
+        "bbox": [
+            173,
+            327,
+            825,
+            397
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Panel B, we generate adversarial images using FG such that the average RMSD is almost the same as those generated using the optimization-based approach. We observe that the diagonal values in the table are all positive, which means that FG cannot fully mislead the models. A potential reason is that, FG can be viewed as approximating the optimization, but is tailored for speed over accuracy. ",
+        "bbox": [
+            174,
+            428,
+            825,
+            484
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, the values of non-diagonal cells in the table, which correspond to the accuracies of adversarial images generated for one model but evaluated on another, are comparable with or less than their counterparts in the optimization-based approach. This shows that non-targeted adversarial examples generated by FG exhibit transferability as well. ",
+        "bbox": [
+            174,
+            491,
+            825,
+            546
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We also evaluate FGS, but the transferability of the generated images is worse than the ones generated using either FG or optimization-based approaches. The results can be found in our online technical report: Liu et al. (2016). It shows that when RMSD is around 23, the accuracies of the adversarial images generated by FGS is greater than their counterparts for FG. We hypothesize the reason why transferability of FGS is worse to this fact. ",
+        "bbox": [
+            174,
+            553,
+            825,
+            623
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": ".2.2 ADVERSARIAL IMAGES WITH MINIMAL TRANSFERABLE RMSD ",
+        "text_level": 1,
+        "bbox": [
+            187,
+            642,
+            661,
+            655
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For an image $x$ and two models $M _ { 1 } , M _ { 2 }$ , we can approximate the minimal distortion $B$ along a direction $\\delta$ , such that $x _ { B } = x + B \\delta$ generated for $M _ { 1 }$ is adversarial for both $M _ { 1 }$ and $M _ { 2 }$ . Here $\\delta$ is the direction, i.e., $\\mathbf { s g n } ( \\nabla _ { x } \\ell )$ for FGS, and $\\nabla _ { x } \\ell / | | \\nabla _ { x } \\ell | |$ for FG. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            710
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We refer to the minimal transferable RMSD from $M _ { 1 }$ to $M _ { 2 }$ using $F G$ (or $F G S _ { \\prime }$ ) as the RMSD of a transferable adversarial example $x _ { B }$ with the minimal transferable distortion $B$ from $M _ { 1 }$ to $M _ { 2 }$ using FG (or FGS). The minimal transferable RMSD can illustrate the tradeoff between distortion and transferability. ",
+        "bbox": [
+            174,
+            715,
+            825,
+            772
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the following, we approximate the minimal transferable RMSD through a linear search by sampling $B$ every 0.1 step. We choose the linear-search method rather than binary-search method to determine the minimal transferable RMSD because the adversarial images generated from an original image may come from multiple intervals. The experiment can be found in our online technical report: Liu et al. (2016). ",
+        "bbox": [
+            174,
+            779,
+            823,
+            849
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Minimal transferable RMSD using FG and FGS. Figure 1 plots the cumulative distribution function (CDF) of the minimal transferable RMSD from VGG-16 to ResNet-152 using non-targeted FG (Figure 1a) and FGS (Figure 1b). From the figures, we observe that both FG and FGS can find $100 \\%$ transferable adversarial images with RMSD less than 80.91 and 86.56 respectively. Further, the FG method can generate transferable attacks with smaller RMSD than FGS. A potential reason is that while FGS minimizes the distortion’s $L _ { \\infty }$ norm, FG minimizes its $L _ { 2 }$ norm, which is proportional to RMSD. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/422f10d6f00b19986ff6b8489f70b61e28e946370f55e76be067929c7ddb650d.jpg",
+        "image_caption": [
+            "Figure 1: The CDF of the minimal transferable RMSD from VGG-16 to ResNet-152 using FG (a) and FGS (b). The green line labels the median minimal transferable RMSD, while the red line labels the minimal transferable RMSD to reach $90 \\%$ percentage. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            220,
+            99,
+            779,
+            256
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/57351d35ab92eb5ca126634e29bfe8cf05b02b8cf4758349f6796a745810e508.jpg",
+        "table_caption": [
+            "Table 2: The matching rate of targeted adversarial images generated using the optimization-based approach. The first column indicates the average RMSD of the generated adversarial images. Cell $( i , j )$ indicates that matching rate of the targeted adversarial images generated for model $i$ (row) when evaluated on model $j$ (column). The top-5 results can be found in our online technical report: Liu et al. (2016). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>RMSD</td><td rowspan=1 colspan=1>ResNet-152</td><td rowspan=1 colspan=1>ResNet-101</td><td rowspan=1 colspan=1>ResNet-50</td><td rowspan=1 colspan=1>VGG-16</td><td rowspan=1 colspan=1>GoogLeNet</td></tr><tr><td rowspan=1 colspan=1>ResNet-152</td><td rowspan=1 colspan=1>23.13</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>2%</td><td rowspan=1 colspan=1>1%</td><td rowspan=1 colspan=1>1%</td><td rowspan=1 colspan=1>1%</td></tr><tr><td rowspan=1 colspan=1>ResNet-101</td><td rowspan=1 colspan=1>23.16</td><td rowspan=1 colspan=1>3%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>3%</td><td rowspan=1 colspan=1>2%</td><td rowspan=1 colspan=1>1%</td></tr><tr><td rowspan=1 colspan=1>ResNet-50</td><td rowspan=1 colspan=1>23.06</td><td rowspan=1 colspan=1>4%</td><td rowspan=1 colspan=1>2%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>1%</td><td rowspan=1 colspan=1>1%</td></tr><tr><td rowspan=1 colspan=1>VGG-16</td><td rowspan=1 colspan=1>23.59</td><td rowspan=1 colspan=1>2%</td><td rowspan=1 colspan=1>1%</td><td rowspan=1 colspan=1>2%</td><td rowspan=1 colspan=1>100%</td><td rowspan=1 colspan=1>1%</td></tr><tr><td rowspan=1 colspan=1>GoogLeNet</td><td rowspan=1 colspan=1>22.87</td><td rowspan=1 colspan=1>1%</td><td rowspan=1 colspan=1>1%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>1%</td><td rowspan=1 colspan=1>100%</td></tr></table>",
+        "bbox": [
+            209,
+            325,
+            787,
+            415
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            522,
+            825,
+            565
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.3 COMPARISON WITH RANDOM PERTURBATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            585,
+            535,
+            598
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also evaluate the test accuracy when we add a Gaussian noise to the 100 images in our test set. The concrete results can be found in our online technical report: Liu et al. (2016), where we show the conclusion that the “transferability” of this approach is significantly worse than either optimization-based approaches or fast gradient-based approaches. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            667
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 TARGETED ADVERSARIAL EXAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            689,
+            522,
+            705
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we examine the transferability of targeted adversarial images. Table 2 presents the results for using optimization-based approach. We observe that (1) the prediction of targeted adversarial images can match the target labels when evaluated on the same model that is used to generate the adversarial examples; but (2) the targeted adversarial images can be rarely predicted as the target labels by a different model. We call the latter that the target labels do not transfer. Even when we increase the distortion, we still do not observe improvements on making target label transfer. Some results can be found in our online technical report: Liu et al. (2016). Even if we compute the matching rate based on top-5 accuracy, the highest matching rate is only $10 \\%$ . The results can be found in our online technical report: Liu et al. (2016). ",
+        "bbox": [
+            173,
+            722,
+            825,
+            847
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also examine the targeted adversarial images generated by fast gradient-based approaches, and we observe that the target labels do not transfer as well. The results can be found in our online technical report: Liu et al. (2016). In fact, most targeted adversarial images cannot mislead the model, for which the adversarial images are generated, to predict the target labels, regardless of how large the distortion is used. We attribute it to the fact that the fast gradient-based approaches only search for attacks in a 1-D subspace. In this subspace, the total possible predictions may contain a small subset of all labels, which usually does not contain the target label. In Section 6, we study decision boundaries regarding this issue. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We also evaluate the matching rate of images added with Gaussian noise, as described in Section 3.3. However, we observe that the matching rate of any of the 5 models is $0 \\%$ . Therefore, we conclude that by adding Gaussian noise, the attacker cannot generate successful targeted adversarial examples at all, let alone targeted transferability. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            208
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 ENSEMBLE-BASED APPROACHES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            229,
+            475,
+            244
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We hypothesize that if an adversarial image remains adversarial for multiple models, then it is more likely to transfer to other models as well. We develop techniques to generate adversarial images for multiple models. The basic idea is to generate adversarial images for the ensemble of the models. Formally, given $k$ white-box models with softmax outputs being $J _ { 1 } , . . . , J _ { k }$ , an original image $x$ , and its ground truth $y$ , the ensemble-based approach solves the following optimization problem (for targeted attack): ",
+        "bbox": [
+            174,
+            260,
+            825,
+            343
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ad3334f7bf56a87943927275a01a7bdc62b08da4144a74c6f38f3f3d85e19bac.jpg",
+        "text": "$$\n\\operatorname { a r g m i n } _ { x \\star } - \\log \\big ( ( \\sum _ { i = 1 } ^ { k } \\alpha _ { i } J _ { i } ( x ^ { \\star } ) ) \\cdot \\mathbf { 1 } _ { y ^ { \\star } } \\big ) + \\lambda d ( x , x ^ { \\star } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            321,
+            342,
+            676,
+            386
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $y ^ { \\star }$ is the target label specified by the adversary, $\\sum \\alpha _ { i } J _ { i } ( x ^ { \\star } )$ is the ensemble model, and $\\alpha _ { i }$ are the ensemble weights, $\\textstyle \\sum _ { i = 1 } ^ { k } \\alpha _ { i } = 1$ . Note that (6) is the targeted objective. The non-targeted counterpart can be derived similarly. In doing so, we hope the generated adversarial images remain adversarial for an additional black-box model $J _ { k + 1 }$ . ",
+        "bbox": [
+            174,
+            387,
+            825,
+            448
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the effectiveness of the ensemble-based approach. For each of the five models, we treat it as the black-box model to attack, and generate adversarial images for the ensemble of the rest four, which is considered as white-box. We evaluate the generated adversarial images over all five models. Throughout the rest of the paper, we refer to the approaches evaluated in Section 3 and 4 as the approaches using a single model, and to the ensemble-based approaches discussed in this section as the approaches using an ensemble model. ",
+        "bbox": [
+            173,
+            454,
+            825,
+            537
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Optimization-based approach. We use Adam to optimize the objective (6) with equal ensemble weights across all models in the ensemble to generate targeted adversarial examples. In particular, we set the learning rate of Adam to be 8 for each model. In each iteration, we compute the Adam update for each model, sum up the four updates, and add the aggregation onto the image. We run 100 iterations of updates, and we observe that the loss converges after 100 iterations. By doing so, for the first time, we observe a large proportion of the targeted adversarial images whose target labels can transfer. The results are presented in Table 3. We observe that not all targeted adversarial images can be misclassified to the target labels by the models used in the ensemble. This suggests that while searching for an adversarial example for the ensemble model, there is no direct supervision to mislead any individual model in the ensemble to predict the target label. Further, from the diagonal numbers of the table, we observe that the transferability to ResNet models is better than to VGG-16 or GoogLeNet, when adversarial examples are generated against all models except the target model. ",
+        "bbox": [
+            173,
+            553,
+            825,
+            720
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We also evaluate non-targeted adversarial images generated by the ensemble-based approach. We observe that the generated adversarial images have almost perfect transferability. We use the same procedure as for the targeted version, except the objective to generate the adversarial images. We evaluate the generated adversarial images over all models. The results are presented in Table 4. The generated adversarial images all have RMSDs around 17, which are lower than 22 to 23 of the optimization-based approach using a single model (See Table 1 for comparison). When the adversarial images are evaluated over models which are not used to generate the attack, the accuracy is no greater than $6 \\%$ . For a reference, the corresponding accuracies for all approaches evaluated in Section 3 using one single model are at least $12 \\%$ . Our experiments demonstrate that the ensemblebased approaches can generate almost perfectly transferable adversarial images. ",
+        "bbox": [
+            174,
+            727,
+            825,
+            866
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Fast gradient-based approach. The results for non-targeted fast gradient-based approaches applied to the ensemble can be found in our online technical report: Liu et al. (2016). We observe that the diagonal values are not zero, which is the same as we observed in the results for FG and ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/6e7b077340273c15cb1c60ac24f2022fbddebcf2db572a123043329699a053f7.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>RMSD</td><td rowspan=1 colspan=1>ResNet-152</td><td rowspan=1 colspan=1>ResNet-101</td><td rowspan=1 colspan=1>ResNet-50</td><td rowspan=1 colspan=1>VGG-16</td><td rowspan=1 colspan=1>GoogLeNet</td></tr><tr><td rowspan=1 colspan=1>-ResNet-152</td><td rowspan=1 colspan=1>30.68</td><td rowspan=1 colspan=1>38%</td><td rowspan=1 colspan=1>76%</td><td rowspan=1 colspan=1>70%</td><td rowspan=1 colspan=1>97%</td><td rowspan=1 colspan=1>76%</td></tr><tr><td rowspan=1 colspan=1>-ResNet-101</td><td rowspan=1 colspan=1>30.76</td><td rowspan=1 colspan=1>75%</td><td rowspan=1 colspan=1>43%</td><td rowspan=1 colspan=1>69%</td><td rowspan=1 colspan=1>98%</td><td rowspan=1 colspan=1>73%</td></tr><tr><td rowspan=1 colspan=1>-ResNet-50</td><td rowspan=1 colspan=1>30.26</td><td rowspan=1 colspan=1>84%</td><td rowspan=1 colspan=1>81%</td><td rowspan=1 colspan=1>46%</td><td rowspan=1 colspan=1>99%</td><td rowspan=1 colspan=1>77%</td></tr><tr><td rowspan=1 colspan=1>-VGG-16</td><td rowspan=1 colspan=1>31.13</td><td rowspan=1 colspan=1>74%</td><td rowspan=1 colspan=1>78%</td><td rowspan=1 colspan=1>68%</td><td rowspan=1 colspan=1>24%</td><td rowspan=1 colspan=1>63%</td></tr><tr><td rowspan=1 colspan=1>-GoogLeNet</td><td rowspan=1 colspan=1>29.70</td><td rowspan=1 colspan=1>90%</td><td rowspan=1 colspan=1>87%</td><td rowspan=1 colspan=1>83%</td><td rowspan=1 colspan=1>99%</td><td rowspan=1 colspan=1>11%</td></tr></table>",
+        "bbox": [
+            204,
+            101,
+            794,
+            189
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 3: The matching rate of targeted adversarial images generated using the optimization-based approach. The first column indicates the average RMSD of the generated adversarial images. Cell $( i , j )$ indicates that percentage of the targeted adversarial images generated for the ensemble of the four models except model $i$ (row) is predicted as the target label by model $j$ (column). In each row, the minus sign “−” indicates that the model of the row is not used when generating the attacks. Results of top-5 matching rate can be found in our online technical report: Liu et al. (2016). ",
+        "bbox": [
+            173,
+            199,
+            825,
+            285
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/bfb1941749e173fb395c6d57f9a50a5592ff711e84a6f403d6816dabce496bd2.jpg",
+        "table_caption": [
+            "Table 4: Accuracy of non-targeted adversarial images generated using the optimization-based approach. The first column indicates the average RMSD of the generated adversarial images. Cell $\\bar { ( } i , j )$ corresponds to the accuracy of the attack generated using four models except model $i$ (row) when evaluated over model $j$ (column). In each row, the minus sign “−” indicates that the model of the row is not used when generating the attacks. Results of top-5 accuracy can be found in our online technical report: Liu et al. (2016). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>RMSD</td><td rowspan=1 colspan=1>ResNet-152</td><td rowspan=1 colspan=1>ResNet-101</td><td rowspan=1 colspan=1>ResNet-50</td><td rowspan=1 colspan=1>VGG-16</td><td rowspan=1 colspan=1>GoogLeNet</td></tr><tr><td rowspan=1 colspan=1>-ResNet-152</td><td rowspan=1 colspan=1>17.17</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>0%</td></tr><tr><td rowspan=1 colspan=1>-ResNet-101</td><td rowspan=1 colspan=1>17.25</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>1%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>0%</td></tr><tr><td rowspan=1 colspan=1>-ResNet-50</td><td rowspan=1 colspan=1>17.25</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>2%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>0%</td></tr><tr><td rowspan=1 colspan=1>-VGG-16</td><td rowspan=1 colspan=1>17.80</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>6%</td><td rowspan=1 colspan=1>0%</td></tr><tr><td rowspan=1 colspan=1>-GoogLeNet</td><td rowspan=1 colspan=1>17.41</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>0%</td><td rowspan=1 colspan=1>5%</td></tr></table>",
+        "bbox": [
+            204,
+            299,
+            794,
+            387
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "FGS applied to a single model. We hypothesize a potential reason is that the gradient directions of different models in the ensemble are orthogonal to each other, as we will illustrate in Section 6. In this case, the gradient direction of the ensemble is almost orthogonal to the one of each model in the ensemble. Therefore searching along this direction may require large distortion to reach adversarial examples. ",
+        "bbox": [
+            174,
+            508,
+            825,
+            579
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For targeted adversarial examples generated using FG and FGS based on an ensemble model, their transferability is no better than the ones generated using a single model. The results can be found in our online technical report: Liu et al. (2016). We hypothesize the same reason to explain this: there are only few possible target labels in total in the 1-D subspace. ",
+        "bbox": [
+            174,
+            585,
+            825,
+            642
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 GEOMETRIC PROPERTIES OF DIFFERENT MODELS",
+        "text_level": 1,
+        "bbox": [
+            173,
+            664,
+            620,
+            680
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this section, we show some geometric properties of the models to try to better understand transferable adversarial examples. Prior works also try to understand the geometic properties of adversarial examples theoretically (Fawzi et al. (2016)) or empirically (Goodfellow et al. (2014)). In this work, we examine large models trained over a large dataset with 1000 labels, whose geometric properties are never examined before. This allows us to make new observations to better understand the models and their adversarial examples. ",
+        "bbox": [
+            174,
+            695,
+            825,
+            780
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The gradient directions of different models in our evaluation are almost orthogonal to each other. We study whether the adversarial directions of different models align with each other. We calculate cosine value of the angle between gradient directions of different models, and the results can be found in our online technical report: Liu et al. (2016). We observe that all non-diagonal values are close to 0, which indicates that for most images, their gradient directions with respect to different models are orthogonal to each other. ",
+        "bbox": [
+            174,
+            795,
+            825,
+            878
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Decision boundaries of the non-targeted approaches using a single model. We study the decision boundary of different models to understand why adversarial examples transfer. We choose two normalized orthogonal directions $\\delta _ { 1 } , \\delta _ { 2 }$ , one being the gradient direction of VGG-16 and the other being randomly chosen. Each point $( u , v )$ in this 2-D plane corresponds to the image $x + u \\delta _ { 1 } + v \\delta _ { 2 }$ , where $x$ is the pixel value vector of the original image. For each model, we plot the label of the image corresponding to each point, and get Figure 3 using the image in Figure 2. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/27c4d2952213ff375ebcd9b1e14f8daf41bbf8494608a59f73f27f3b02c8f666.jpg",
+        "image_caption": [
+            "Figure 2: The example image to study the decision boundary. Its ID in ILSVRC 2012 validation set is 49443, and its ground truth label is “anemone fish.” "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            424,
+            101,
+            573,
+            217
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/53ca6a7451be317d8123c2ddab3107233619e27cdc5de469e3e71e5c26a5196e.jpg",
+        "image_caption": [
+            "Figure 3: Decision regions of different models. We pick the same two directions for all plots: one is the gradient direction of VGG-16 $\\mathbf { \\bar { X } }$ -axis), and the other is a random orthogonal direction (y-axis). Each point in the span plane shows the predicted label of the image generated by adding a noise to the original image (e.g., the origin corresponds to the predicted label of the original image). The units of both axises are 1 pixel values. All sub-figure plots the regions on the span plane using the same color for the same label. The image is in Figure 2. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            281,
+            830,
+            502
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            651,
+            825,
+            707
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We can observe that for all models, the region that each model can predict the image correctly is limited to the central area. Also, along the gradient direction, the classifiers are soon misled. One interesting finding is that along this gradient direction, the first misclassified label for the three ResNet models (corresponding to the light green region) is the label “orange”. A more detailed study can be found in our online technical report: Liu et al. (2016). When we look at the zoomout figures, however, the labels of images that are far away from the original one are different for different models, even among ResNet models. ",
+        "bbox": [
+            174,
+            714,
+            825,
+            811
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, in Table 5, we show the total number of regions in each plane. In fact, for each plane, there are at most 21 different regions in all planes. Compared with the 1,000 total categories in ImageNet, this is only $2 . 1 \\%$ of all categories. That means, for all other $9 7 . 9 \\%$ labels, no targeted adversarial example exists in each plane. Such a phenomenon partially explains why fast gradientbased approaches can hardly find targeted adversarial images. ",
+        "bbox": [
+            174,
+            819,
+            825,
+            888
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Further, in Figure 4, we draw the decision boundaries of all models on the same plane as described above. We can observe that ",
+        "bbox": [
+            174,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/adff4d14292889778aad321b3feea0a4ff308dbaad1eef79d58ea4aaed28ddbd.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>VGG-16</td><td rowspan=1 colspan=1>ResNet-50</td><td rowspan=1 colspan=1>ResNet-101</td><td rowspan=1 colspan=1>ResNet-152</td><td rowspan=1 colspan=1>GoogLeNet</td></tr><tr><td rowspan=1 colspan=1>#oflabels</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>21</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>21</td></tr></table>",
+        "bbox": [
+            217,
+            101,
+            774,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Table 5: The number of all possible predicted labels for each model in the same plane described in Figure 3. ",
+        "bbox": [
+            176,
+            143,
+            818,
+            157
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/05c61d41b67a160eb809a601179a1bbfdb834ea54056d39fa6c2af97f2f429c1.jpg",
+        "image_caption": [
+            "Figure 4: The decision boundary to separate the region within which all points are classified as the ground truth label (encircled by each closed curve) from others. The plane is the same one described in Figure 3. The origin of the coordinate plane corresponds to the original image. The units of both axises are 1 pixel values. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            198,
+            431,
+            328
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/b3a6cc0e689124a69d00a525719744fef7d87ee7a80949cc9358ee3722444e9d.jpg",
+        "image_caption": [
+            "Figure 5: The decision boundary to separate the region within which all points are classified as the target label (encircled by each closed curve) from others. The plane is spanned by the targeted adversarial direction and a random orthogonal direction. The targeted adversarial direction is computed as the difference between the original image in Figure 2 and the adversarial image generated by the optimization-based approach for an ensemble. The ensemble contains all models except ResNet101. The origin of the coordinate plane corresponds to the original image. The units of both axises are 1 pixel values. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            522,
+            175,
+            743,
+            299
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "• The boundaries align with each other very well. This partially explains why non-targeted adversarial images can transfer among models. The boundary diameters along the gradient direction is less than the ones along the random direction. A potential reason is that moving a variable along its gradient direction can change the loss function (i.e., the probability of the ground truth label) significantly. Therefore along the gradient direction it will take fewer steps to move out of the ground truth region than a random direction.   \n• An interesting finding is that even though we move left along the x-axis, which is equivalent to maximizing the ground truth’s prediction probability, it also reaches the boundary much sooner than moving along a random direction. We attribute this to the non-linearity of the loss function: when the distortion is larger, the gradient direction also changes dramatically. In this case, moving along the original gradient direction no longer increases the probability to predict the ground truth label (details can be found in our online technical report: Liu et al. (2016)).   \n• As for VGG-16 model, there is a small hole within the region corresponding to the ground truth. This may partially explain why non-targeted adversarial images with small distortion exist, but do not transfer well. This hole does not exist in other models’ decision planes. In this case, non-targeted adversarial images in this hole do not transfer. ",
+        "bbox": [
+            212,
+            529,
+            825,
+            796
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Decision boundaries of the targeted ensemble-based approaches. In addition, we choose the targeted adversarial direction of the ensemble of all models except ResNet-101 and a random orthogonal direction, and we plot decision boundaries on the plane spanned by these two direction vectors in Figure 5. We observe that the regions of images, which are predicted as the target label, align well for the four models in the ensemble. However, for the model not used to generate the adversarial image, i.e., ResNet-101, it also has a non-empty region such that the prediction is successfully misled to the target label, although the area is much smaller. Meanwhile, the region within each closed curve of the models almost has the same center. ",
+        "bbox": [
+            173,
+            813,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Clarifai.com is a commercial company providing state-of-the-art image classification services. We have no knowledge about the dataset and types of models used behind Clarifai.com, except that we have black-box access to the services. The labels returned from Clarifai.com are also different from the categories in ILSVRC 2012. We submit all 100 original images to Clarifai.com and the returned labels are correct based on a subjective measure. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            203
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We also submit 400 adversarial images in total, where 200 of them are targeted adversarial examples, and the rest 200 are non-targeted ones. As for the 200 targeted adversarial images, 100 of them are generated using the optimization-based approach based on VGG-16 (the same ones evaluated in Table 2), and the rest 100 are generated using the optimization-based approach based on an ensemble of all models except ResNet-152 (the same ones evaluated in Table 3). The 200 nontargeted adversarial examples are generated similarly (the same ones evaluated in Table 1 and 4). ",
+        "bbox": [
+            174,
+            210,
+            825,
+            294
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For non-targeted adversarial examples, we observe that for both the ones generated using VGG-16 and those generated using the ensemble, most of them can transfer to Clarifai.com. ",
+        "bbox": [
+            173,
+            301,
+            821,
+            329
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "More importantly, a large proportion of our targeted adversarial examples are misclassified by Clarifai.com as well. We observe that $5 7 \\%$ of the targeted adversarial examples generated using VGG-16, and $7 6 \\%$ of the ones generated using the ensemble can mislead Clarifai.com to predict labels irrelevant to the ground truth. ",
+        "bbox": [
+            174,
+            335,
+            825,
+            392
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Further, our experiment shows that for targeted adversarial examples, $1 8 \\%$ of those generated using the ensemble model can be predicted as labels close to the target label by Clarifai.com. The corresponding number for the targeted adversarial examples generated using VGG-16 is $2 \\%$ . Considering that in the case of attacking Clarifai.com, the labels given by the target model are different from those given by our models, it is fairly surprising to see that when using the ensemble-based approach, there is still a considerable proportion of our targeted adversarial examples that can mislead this black-box model to make predictions semantically similar to our target labels. All these numbers are computed based on a subjective measure, and we include some examples in Table 6. More examples can be found in our online technical report: Liu et al. (2016). ",
+        "bbox": [
+            173,
+            398,
+            825,
+            523
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/9fff528d8fe52594427b7ef1c2698d8e2fd3792e063927ad887870e3211d2ca6.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>originalimage</td><td rowspan=1 colspan=1>truelabel</td><td rowspan=1 colspan=1>Clarifai.comresults oforiginal image</td><td rowspan=1 colspan=1>targetlabel</td><td rowspan=1 colspan=1>targetedadversarialexample</td><td rowspan=1 colspan=1>Clarifai.comresultsof targetedadversarial example</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>viaduct</td><td rowspan=1 colspan=1>bridge,sight,arch,river,sky</td><td rowspan=1 colspan=1>windowscreen</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>window,wall,old,decoration,design</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>hip, rosehip,rosehip</td><td rowspan=1 colspan=1>fruit,fall,food,little,wildlife</td><td rowspan=1 colspan=1>stupa,tope</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Buddha,gold,temple,celebration,artistic</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>dogsled,dogsled,dogsleigh</td><td rowspan=1 colspan=1> group together,four,sledge,sled,enjoyment</td><td rowspan=1 colspan=1>hip, rosehip,rosehip</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>cherry,branch,fruit,food,season</td></tr></table>",
+        "bbox": [
+            173,
+            536,
+            856,
+            843
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/8d8f18c4c1768fe5d9e7dfa5a899aec272ebf0ce2d23e32090c21628b4d4c2b8.jpg",
+        "table_caption": [
+            "Table 6: Original images and adversarial images evaluated over Clarifai.com. For labels returned from Clarifai.com, we sort the labels firstly by rareness: how many times a label appears in the Clarifai.com results for all adversarial images and original images, and secondly by confidence. Only top 5 labels are provided. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>pug,pug-dog</td><td rowspan=1 colspan=1>pug,friendship,adorable,purebred,sit</td><td rowspan=1 colspan=1>sea lion</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>sea seal,ocean,head,sea,cute</td></tr><tr><td rowspan=1 colspan=1>OldEnglishsheep-dog，bobtail</td><td rowspan=1 colspan=1>poodle,retriever,loyalty,sit,two</td><td rowspan=1 colspan=1>abaya</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>veil,spirituality,religion,people,illustration</td></tr><tr><td rowspan=1 colspan=1>maillot,tank suit</td><td rowspan=1 colspan=1>beach,woman,adult,wear,portrait</td><td rowspan=1 colspan=1>amphib-ian,amphibi-ousvehicle</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>transportationsystem,vehicle,man,print,retro</td></tr><tr><td rowspan=1 colspan=1>patas,hussarmonkey,Erythro-cebuspatas</td><td rowspan=1 colspan=1>primate,monkey,safari,sit,looking</td><td rowspan=1 colspan=1>bee eater</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>ornithology,avian,beak,wing,feather</td></tr></table>",
+        "bbox": [
+            173,
+            114,
+            856,
+            463
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "8 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            556,
+            318,
+            571
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In this work, we are the first to conduct an extensive study of the transferability of both non-targeted and targeted adversarial examples generated using different approaches over large models and a large scale dataset. Our results confirm that the transferability for non-targeted adversarial examples are prominent even for large models and a large scale dataset. On the other hand, we find that it is hard to use existing approaches to generate targeted adversarial examples whose target labels can transfer. We develop novel ensemble-based approaches, and demonstrate that they can generate transferable targeted adversarial examples with a high success rate. Meanwhile, these new approaches exhibit better performance on generating non-targeted transferable adversarial examples than previous work. We also show that both non-targeted and targeted adversarial examples generated using our new approaches can successfully attack Clarifai.com, which is a black-box image classification system. Furthermore, we study some geometric properties to better understand the transferable adversarial examples. ",
+        "bbox": [
+            174,
+            588,
+            825,
+            753
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            771,
+            326,
+            784
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "This material is in part based upon work supported by the National Science Foundation under Grant No. TWC-1409915. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the National Science Foundation. ",
+        "bbox": [
+            174,
+            795,
+            825,
+            851
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            872,
+            285,
+            887
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. arXiv preprint arXiv:1608.04644, 2016. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Alhussein Fawzi, Seyed-Mohsen Moosavi-Dezfooli, and Pascal Frossard. Robustness of classifiers: from adversarial to random noise. In Advances in Neural Information Processing Systems, pp. 1624–1632, 2016. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. arXiv preprint arXiv:1512.03385, 2015. ",
+        "bbox": [
+            173,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2014. URL http://arxiv.org/abs/1412.6980. ",
+        "bbox": [
+            173,
+            231,
+            823,
+            260
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            171,
+            268,
+            823,
+            285
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            173,
+            291,
+            823,
+            321
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. arXiv preprint arXiv:1611.02770, 2016. ",
+        "bbox": [
+            173,
+            329,
+            823,
+            359
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, Omar Fawzi, and Pascal Frossard. Universal adversarial perturbations. arXiv preprint arXiv:1610.08401, 2016. ",
+        "bbox": [
+            171,
+            367,
+            825,
+            397
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, and Ian Goodfellow. Transferability in machine learning: from phenomena to black-box attacks using adversarial samples. arXiv preprint arXiv:1605.07277, 2016a. ",
+        "bbox": [
+            176,
+            405,
+            825,
+            448
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against deep learning systems using adversarial examples. arXiv preprint arXiv:1602.02697, 2016b. ",
+        "bbox": [
+            174,
+            457,
+            823,
+            500
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. ImageNet Large Scale Visual Recognition Challenge. International Journal of Computer Vision (IJCV), 115(3):211��252, 2015. doi: 10.1007/s11263-015-0816-y. ",
+        "bbox": [
+            173,
+            508,
+            826,
+            564
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. CoRR, abs/1409.1556, 2014. URL http://arxiv.org/abs/1409.1556. ",
+        "bbox": [
+            173,
+            574,
+            823,
+            603
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "J. Stallkamp, M. Schlipsing, J. Salmen, and C. Igel. Man vs. computer: Benchmarking machine learning algorithms for traffic sign recognition. Neural Networks, (0):–, 2012. ISSN 0893-6080. doi: 10.1016/j.neunet.2012.02.016. URL http://www.sciencedirect.com/science/ article/pii/S0893608012000457. ",
+        "bbox": [
+            173,
+            611,
+            825,
+            667
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013. ",
+        "bbox": [
+            169,
+            676,
+            823,
+            707
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott E. Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. CoRR, abs/1409.4842, 2014. URL http://arxiv.org/abs/1409.4842. ",
+        "bbox": [
+            176,
+            714,
+            823,
+            758
+        ],
+        "page_idx": 13
+    }
+]

parse/train/zQTezqCCtNx/zQTezqCCtNx.md

@@ -0,0 +1,356 @@
+# IMPROVING ADVERSARIAL ROBUSTNESS V I A CHANNEL-WISE ACTIVATION SUPPRESSING
+
+Yang Bai1∗ Yuyuan $\mathbf { Z e n g ^ { 2 , 5 * } }$ Yong Jiang1,2,5 Shu-Tao $\mathbf { X _ { i a } } ^ { \mathbf { \bullet } , 2 , 5 \dagger }$ Xingjun $\mathbf { M a ^ { 4 } }$ Yisen Wang3†
+
+1Tsinghua Berkeley Shenzhen Institute, Tsinghua University, China   
+2Tsinghua Shenzhen International Graduate School, Tsinghua University, China   
+3Key Lab. of Machine Perception (MoE), School of EECS, Peking University, Beijing, China   
+4School of Information Technology, Deakin University, Geelong, VIC, Australia   
+$^ 5 \mathrm { P C L }$ Research Center of Networks and Communications, Peng Cheng Laboratory, Shenzhen, China
+
+# ABSTRACT
+
+The study of adversarial examples and their activation has attracted significant attention for secure and robust learning with deep neural networks (DNNs). Different from existing works, in this paper, we highlight two new characteristics of adversarial examples from the channel-wise activation perspective: 1) the activation magnitudes of adversarial examples are higher than that of natural examples; and 2) the channels are activated more uniformly by adversarial examples than natural examples. We find that the state-of-the-art defense adversarial training has addressed the first issue of high activation magnitudes via training on adversarial examples, while the second issue of uniform activation remains. This motivates us to suppress redundant activation from being activated by adversarial perturbations via a Channel-wise Activation Suppressing (CAS) strategy. We show that CAS can train a model that inherently suppresses adversarial activation, and can be easily applied to existing defense methods to further improve their robustness. Our work provides a simple but generic training strategy for robustifying the intermediate layer activation of DNNs. Code is available at https://github.com/bymavis/CAS_ICLR2021.
+
+# 1 INTRODUCTION
+
+Deep neural networks (DNNs) have become standard models for solving real-world complex problems, such as image classification (He et al., 2016), speech recognition (Wang et al., 2017), and natural language processing (Devlin et al., 2019). DNNs can approximate extremely complex functions through a series of linear (e.g. convolution) and non-linear (e.g. ReLU activation) operations. Despite their superb learning capabilities, DNNs have been found to be vulnerable to adversarial examples (or attacks) (Szegedy et al., 2014; Goodfellow et al., 2015), where small perturbations on the input can easily subvert the model’s prediction. Adversarial examples can transfer across different models (Liu et al., 2017; Wu et al., 2020a; Wang et al., 2021) and remain destructive even in the physical world (Kurakin et al., 2016; Duan et al., 2020), raising safety concerns in autonomous driving (Eykholt et al., 2018) and medical diagnosis (Ma et al., 2021).
+
+Existing defense methods against adversarial examples include input denoising (Liao et al., 2018; Bai et al., 2019), defensive distillation (Papernot et al., 2016), gradient regularization (Gu & Rigazio, 2014), model compression (Das et al., 2018) and adversarial training (Goodfellow et al., 2015; Madry et al., 2018; Wang et al., 2019), amongst which adversarial training has demonstrated the most reliable robustness (Athalye et al., 2019; Croce & Hein, 2020b). Adversarial training is a data augmentation technique that trains DNNs on adversarial rather than natural examples. In adversarial training, natural examples are augmented (or perturbed) with the worst-case perturbations found within a small $L _ { p }$ -norm ball around them. This augmentation has been shown to effectively smooth out the loss landscape around the natural examples, and force the network to focus more on the pixels that are most relevant to the class. Apart from these interpretations, it is still not well understood, from the activation perspective, how small input perturbations accumulate across intermediate layers to subvert the final output, and how adversarial training can help mitigate such an accumulation. The study of intermediate layer activation has thus become crucial for developing more in-depth understanding and robust DNNs.
+
+In this paper, we show that, if studied from a channel-wise perspective, strong connections between certain characteristics of intermediate activation and adversarial robustness can be established. Our channel-wise analysis is motivated by the fact that different convolution filters (or channels) learn different patterns, which when combined together, describe a specific type of object. Here, adversarial examples are investigated from a new perspective of channels in activation. Different from the existing activation works assuming different channels are of equal importance, we focus on the relationship between channels. Intuitively, different channels of an intermediate layer contribute differently to the class prediction, thus have different levels of vulnerabilities (or robustness) to adversarial perturbations. Given an intermediate DNN layer, we first apply global average pooling (GAP) to obtain the channel-wise activation, based on which, we show that the activation magnitudes of adversarial examples are higher than that of natural examples. This means that adversarial perturbations generally have the signal-boosting effect on channels. We also find that the channels are activated more uniformly by adversarial examples than that by natural examples. In other words, some redundant (or low contributing) channels that are not activated by natural examples, yet are activated by adversarial examples. We show that adversarial training can effectively address the high magnitude problem, yet fails to address the uniform channel activation problem, that is, some redundant and low contributing channels are still activated. This to some extent explains why adversarial training works but its performance is not satisfactory.
+
+Therefore, we propose a new training strategy named Channel-wise Activation Suppressing (CAS), which adaptively learns (with an auxiliary classifier) the importance of different channels to class prediction, and leverages the learned channel importance to adjust the channels dynamically. The robustness of existing state-of-the-art adversarial training methods can be consistently improved if applied with our CAS training strategy. Our key contributions are summarized as follows:
+
+• We identify, from a channel-wise activation perspective, two connections between DNN activation and adversarial robustness: 1) the activation of adversarial examples are of higher magnitudes than that of natural examples; and 2) the channels are activated more uniformly by adversarial examples than that by natural examples. Adversarial training only addresses the first issue of high activation magnitudes, yet fails to address the second issue of uniform channel activation.   
+• We propose a novel training strategy to train robust DNN intermediate layers via Channelwise Activation Suppressing (CAS). In the training phase, CAS suppresses redundant channels dynamically by reweighting the channels based on their contributions to the class prediction. CAS is a generic intermediate-layer robustification technique that can be applied to any DNNs along with existing defense methods.   
+• We empirically show that our CAS training strategy can consistently improve the robustness of current state-of-the-art adversarial training methods. It is generic, effective, and can be easily incorporated into many existing defense methods. We also provide a complete analysis on the benefit of channel-wise activation suppressing to adversarial robustness.
+
+# 2 RELATED WORK
+
+Adversarial Defense. Many adversarial defense techniques have been proposed since the discovery of adversarial examples. Among them, many were found to have caused obfuscated gradients and can be circumvented by Back Pass Differentiable Approximation (BPDA), Expectation over Transformation (EOT) or Reparameterization (Athalye et al., 2019). Adversarial training (AT) has been demonstrated to be the most effective defense (Madry et al., 2018; Wang et al., 2019; 2020b), which solves the following min-max optimization problem:
+
+$$
+\operatorname* { m i n } _ { \theta } \operatorname* { m a x } _ { { \pmb x } ^ { \prime } \in \mathcal { B } _ { \epsilon } ( { \pmb x } ) } { \mathcal L } ( { \mathcal F } ( { \pmb x } ^ { \prime } , \theta ) , y ) ,
+$$
+
+where, $\mathcal { F }$ is a DNN model with parameters $\theta , \boldsymbol { x }$ is a natural example with class label $y , \ x ^ { \prime }$ is the adversarial example within the $L _ { p }$ -norm ball $\mathfrak { B } _ { \epsilon } ( \pmb { x } ) = \{ \pmb { x } ^ { \prime } : \parallel \pmb { x } ^ { \prime } - \pmb { x } \parallel _ { p } \leq \epsilon \}$ centered at $_ { \textbf { \em x } }$ , $\mathcal { F } ( \pmb { x } ^ { \prime } , \theta )$ is the output of the network, and $\mathcal { L }$ is the classification loss (e.g. the cross-entropy loss). The inner maximization problem is dependent on the adversarial examples $\mathbf { x } ^ { \prime }$ generated within the $\epsilon$ -ball, while the outer minimization problem optimizes model parameters under the worst-case perturbations found by the inner maximization. There are other variants of adversarial training with some new objective function or regularization. For example, TRADES (Zhang et al., 2019) optimized a trade-off objective of adversarial robustness and accuracy. MART (Wang et al., 2020c) applied a distinctive emphasis on misclassified versus correctly classified examples. AWP (Wu et al., 2020b) incorporated the regularization on the weight loss landscape. However, apart from these improvements, it is still not well understood how adversarial training can help produce stateof-the-art robustness from the activation perspective.
+
+Activation Perspective of Adversarial Robustness. Some previous works have investigated the adversarial robustness from the architecture perspective, such as skip connection (Wu et al., 2020a) and batch normalization (Galloway et al., 2019). As for intermediate activation, Ma et al. (2018) characterized that adversarial activation forms an adversarial subspace that has much higher intrinsic dimensionality. Zhang et al. (2018) certified the robustness of neural networks with different activation functions. Xu et al. (2019) explored the influence of adversarial perturbations on activation from suppression, promotion and balance perspectives. Other works developed new activation operations with the manifold-interpolating data-dependent function (Wang et al., 2020a) and adaptive quantization techniques (Rakin et al., 2018). While these works directly modify the activation functions, there are also works focusing on the activation outputs. For instance, $k$ -Winner-Takes-All (kWTA) (Xiao et al., 2020) taked the largest $k$ feature values in each activation layer to enhance adversarial robustness. However, this has recently been shown not robust against adaptive attacks (Tramer et al., 2020). Stochastic Activation Pruning (SAP) (Dhillon et al., 2018) taked the randomness and the value of features into consideration. Each activation is chosen with a probability proportional to its absolute value. Adversarial Neural Pruning (ANP) (Madaan & Hwang, 2020) pruned out the features that are vulnerable to adversarial inputs using Bayesian method. Prototype Conformity Loss (PCL) (Mustafa et al., 2019) was proposed to cluster class-wise features and push class centers away from each other. Feature Denoising (FD) (Xie et al., 2019) added denoising layers to the network for sample-wise denoising on feature maps. However, these methods were developed based on observations on the full output (e.g. the entire feature or activation map that does not distinguish different channels) of DNN intermediate layers. In contrast, our CAS explores both channel importance and channel correlations, and the suppressing is done with the guidance of the labels.
+
+# 3 CHANNEL-WISE ACTIVATION AND ADVERSARIAL ROBUSTNESS
+
+In this part, we investigate two characteristics of DNN intermediate activation from a channel-wise perspective, and show two empirical connections between channel-wise activation and adversarial robustness. Specifically, we train ResNet-18 (He et al., 2016) and VGG16 (Simonyan & Zisserman, 2014) on CIFAR-10 (Krizhevsky et al., 2009) using both standard training and adversarial training under typical settings. We then apply global average pooling to extract the channel-wise activation from the penultimate layer. We investigate the extracted channel-wise activation of both natural and adversarial examples from two perspectives: 1) the magnitude of the activation, and 2) the activation frequency of the channels.
+
+Channel-wise Activation Magnitude. Figure 1 illustrates the averaged activation magnitudes for both natural test examples and the corresponding adversarial examples crafted by PGD-20 attack (Madry et al., 2018). For standard models (trained on natural examples), the activation magnitudes of adversarial examples are generally higher than that of natural examples as shown in Figure 1(a)/1(c). Adversarial perturbation exhibits a clear signal-boosting effect on the channels, which leads to the accumulation of adversarial distortions from the input to the output layer of the network. As shown in Figure 1(b)/1(d), adversarial training can effectively narrow the magnitude gaps between natural and adversarial examples, interestingly by decreasing the activation magnitudes of adversarial examples. This is because adversarial training can restrict the Lipschiz constant of the model at deeper layers (i.e. layers close to the output), which reduces the magnitude gaps caused by adversarial perturbations (Finlay et al., 2018; Sinha et al., 2019). Note that network architecture also influences activation magnitudes. Figure 1 show that magnitudes in VGG have much more zero values than those in ResNet, i.e. VGG produces more sparse channels than ResNet.
+
+![](images/d5587c2136185ea3ebd67fd62864182f31b1b34cc64c6cbf59efeb4aa14ed761.jpg)  
+Figure 1: The magnitudes (y-axis) of channel-wise activation at the penultimate layer (512 channels at $\mathbf { X }$ -axis) for both standard (‘STD’) and adversarially trained (‘ADV’) models. In each plot, the magnitudes are averaged and displayed separately for natural and adversarial test examples. The 512 channels are sorted in a descending order of the magnitude.
+
+![](images/3161e0ca965a494fa7cf3b5c952055395d4ed45f9124226ba66840200da372e5.jpg)  
+Figure 2: The activation frequency (y-axis) of channel-wise activation at the penultimate layer (512 channels at $\mathbf { X }$ -axis) of ResNet-18 trained using (a) standard training (‘STD’), (b) adversarial training (‘ADV’), and (c) our CAS-based adversarial training (‘CAS’). The activation frequencies are counted separately for the natural test examples and their PGD-20 adversarial examples. Channels are sorted in a descending order of activation frequency of natural examples.
+
+Channel-wise Activation Frequency. Given a specific class, different convolution filters learn different patterns associated with the class. Similar to the robust vs. non-robust feature differentiation in adversarial training (Ilyas et al., 2019), the intermediate filters (or channels) can also be robust or non-robust. Intuitively, for natural examples in the same class, robust channels produce more generic patterns and should be activated more frequently, yet the non-robust ones should be activated less frequently. As such, non-robust channels can cause more variations to the next layer if activated by adversarial perturbations, increasing the vulnerability to adversarial examples. To investigate this, we visualize the activation frequency of the channel-wise activation in Figure 2. Here, we take one specific class (e.g. class 0) of CIFAR-10 as an example. A channel is determined as activated if its activation value is larger than a threshold (e.g. $1 \%$ of the maximum activation value over all 512 channels). We count the activation frequency for each channel by natural examples and their PGD adversarial examples separately on standard or adversarially trained ResNet-18 models, and sort the channels in a descending order according to the activation frequency by natural examples. As can be observed in Figure 2(a), adversarial examples activate the channels more uniformly, and they tend to frequently activate those that are rarely activated by natural examples (e.g. the right region in Figure 2(a)). This observation is consistent across different classes. The low frequency channels are non-robust channels, and correspond to those redundant activation that are less important for the class prediction. It can also be observed that adversarial perturbations also inhibit those high frequency channels of natural examples (the left region of Figure 2(a)). Figure 2(b) shows that, by training on adversarial examples, adversarial training can force the channels to be activated in a similar frequency by both natural and adversarial examples. However, there are still a certain proportion of the redundant channels (e.g. channels #350 - #500) that are activated by adversarial examples. This motivates us to propose a Channel-wise Activation Suppressing (CAS) training strategy to avoid those redundant channels from being activated by adversarial examples. Figure 2(c) shows the effectiveness of our CAS strategy applied with adversarial training, that is, our CAS can suppress all channels, especially those low frequency ones on natural examples. More visualizations of channel-wise activation frequency can be found in Appendix C.
+
+# 4 PROPOSED CHANNEL-WISE ACTIVATION SUPPRESSING
+
+In this section, we introduce our Channel-wise Activation Suppressing (CAS) training strategy, which dynamically learns and incorporates the channel importance (to the class prediction) into the training phase to train a DNN model that inherently suppresses those less important channels.
+
+![](images/bf5291b3f532a69e821aba349ae4b4d8f1bc665c8e80895809db085e542a92e2.jpg)  
+Figure 3: Framework of our proposed Channel-wise Activation Suppressing (CAS).
+
+Overview. Figure 3 illustrates our CAS training strategy. The CAS module consists of a global average pooling operation (i.e. GAP in the CAS module) to obtain the channel-wise activation, and an auxiliary classifier (i.e. FC in the CAS module) to learn the channel importance. The learned channel importance is then multiplied back to the original activation for adjustment, and the adjusted activation are then passed into the next layer for model training. The entire network and the auxiliary classifier are trained simultaneously using a combination of the CAS loss and the CE loss. The CAS module can be attached to any intermediate layer of a DNN.
+
+# 4.1 CAS MODULE
+
+Denote the $l$ -th activation layer output of network $\mathcal { F }$ as $\pmb { f } ^ { l } \in \mathbb { R } ^ { H \times W \times K }$ , where $H , W , K$ represent the height, width, channel of the activation map, respectively. In CAS module, we first apply the GAP operation on the raw activation $f ^ { l }$ to obtain the channel-wise activation $\hat { \pmb f } ^ { l } \in \mathbb { R } ^ { K }$ . Formally, for the $k$ -th channel,
+
+$$
+\hat { \pmb f } _ { k } ^ { l } = \frac { 1 } { H \times W } \sum _ { i = 1 } ^ { H } \sum _ { j = 1 } ^ { W } \pmb f _ { k } ^ { l } ( i , j ) .
+$$
+
+The channel-wise activation $\hat { f } ^ { l }$ is then passed into the auxiliary classifier to perform multi-class classification with a fully-connected (FC) layer. For $C$ classes, the parameters of the auxiliary classifier can be written as $M ^ { l } = [ M _ { 1 } ^ { l } , M _ { 2 } ^ { l } , . . . , M _ { C } ^ { l } ] \in \mathbb { R } ^ { K \times C }$ , which can identify the importance of each channel to a specific class, and will be applied to reweight the original activation $f ^ { l }$ in a channel-wise manner. In the training phase, the ground-truth label $y$ is utilized as the index to determine the channel importance, i.e. $\dot { M } _ { y } ^ { l } \in \mathbb { R } ^ { K }$ . While in the test phase, since the ground-truth label is not available, we simply take the weight component $M _ { \hat { y } ^ { l } } ^ { l } \in \mathbb { R } ^ { K }$ that is associated to the predicted class $\hat { y } ^ { l }$ as the channel importance (detailed analysis can be found in Section 5.1). The computed channel importance is then applied to reweight the original activation map $f ^ { l }$ as follows:
+
+$$
+\tilde { \pmb { f } } ^ { l } = \left\{ \begin{array} { l l } { \pmb { f } ^ { l } \otimes M _ { y } ^ { l } , } & { ( \mathrm { t r a i n i n g ~ p h a s e } ) } \\ { \pmb { f } ^ { l } \otimes M _ { \hat { y } ^ { l } } ^ { l } , } & { ( \mathrm { t e s t ~ p h a s e } ) } \end{array} \right. ,
+$$
+
+where $\otimes$ represents the channel-wise multiplication. The adjusted $\tilde { \pmb { f } } { l }$ will be passed into the next layer via forward propagation. Note that, so far, neither the auxiliary nor the network is trained, just computing the channel importance and adjusting the activation in a channel-wise manner.
+
+# 4.2 MODEL TRAINING
+
+We can insert $S$ Channel-wise Activation Suppressing (CAS) modules into $S$ different intermediate layers of DNNs. The CAS modules can be considered as auxiliary components of the network, and can be trained using standard training or different types of adversarial training. Here, we take the original adversarial training (Madry et al., 2018) as an example, and define the loss functions to simultaneously train the network and our CAS modules. Each of our CAS modules has a FC layer. Taking one inserted CAS module after the $l$ -th activation layer of network $\mathcal { F }$ for examples, the CAS loss function can then be defined as,
+
+$$
+\mathcal { L } _ { \mathrm { C A S } } ( \hat { p } ^ { l } ( { \pmb x } ^ { \prime } , \theta , M ) , y ) = - \sum _ { c = 1 } ^ { C } \mathbb { 1 } \{ c = y \} \cdot \log \hat { p } _ { c } ^ { l } ( { \pmb x } ^ { \prime } ) ,
+$$
+
+where $C$ is the number of classes, $\hat { \pmb { p } } ^ { l } = \mathrm { s o f t m a x } ( \hat { \pmb { f } } ^ { l } M ^ { l } ) \in \mathbb { R } ^ { C }$ is the prediction score of the classifier in CAS module, and $\mathbf { x } ^ { \prime }$ is the adversarial example used for training. Note that ${ \mathcal { L } } _ { \mathrm { C A S } }$ is the cross entropy loss defined on the auxiliary classifier. Similarly, it can also be extended to multiple CAS modules. The overall objective function for adversarial training with our CAS strategy is:
+
+$$
+\mathcal { L } ( \mathbf { x } ^ { \prime } , y ; \theta , M ) = \mathcal { L } _ { \mathrm { C E } } ( \mathbf { \boldsymbol { p } } ( \mathbf { \boldsymbol { x } } ^ { \prime } , \theta ) , y ) + \frac { \beta } { S } \cdot \sum _ { s = 1 } ^ { S } \mathcal { L } _ { \mathrm { C A S } } ^ { s } ( \hat { \boldsymbol { p } } ^ { s } ( \mathbf { \boldsymbol { x } } ^ { \prime } , \theta , M ) , y )
+$$
+
+where $\beta$ is a tunable parameter balancing the strength of CAS. Besides the original adversarial training (AT) (Madry et al., 2018), we can also combine CAS with other defense techniques such as TRADES (Zhang et al., 2019) and MART (Wang et al., 2020c). In Appendix B, we summarize the loss functions of the original AT, TRADES, MART, and their combined versions with our CAS. The complete training procedure of our CAS is described in Algorithm 1 in Appendix A.
+
+# 5 EXPERIMENTS
+
+In this section, we first provide a comprehensive understanding of our CAS training strategy, then evaluate its robustness on benchmark datasets against various white-box and black-box attacks.
+
+# 5.1 EMPIRICAL UNDERSTANDING OF CAS
+
+In this part, we first show the channel-suppressing effect and robustness of our CAS, then analyze the effectiveness of our CAS when applied at different layers of DNN. The parameter analysis of CAS can be found in Appendix D. In Appendix E, we show that CAS can also help representation learning and natural training.
+
+Experimental Settings. We adversarially train ResNet-18 for 200 epochs on CIFAR-10 using SGD with momentum 0.9, weight decay 2e-4, and initial learning rate 0.1 which is divided by 10 at 75-th and 90-th epoch. We use PGD-10 $\acute { \epsilon } = 8 / 2 5 5$ and step size 2/255) with random start for training. The robustness (accuracy on adversarial examples) is evaluated under attacks: FGSM (Goodfellow et al., 2015), PGD-20 (Madry et al., 2018), and $\mathrm { C W } _ { \infty }$ (Carlini & Wagner, 2017) optimized by PGD.
+
+![](images/5c761eabde17603ca995eaa1a9fd0b3a060d2db74d7c919b80ede289a720fbfa.jpg)  
+Figure 4: Comparisons of activation frequency distribution between adversarial and natural examples on different activation or feature oriented defense methods (kWTA, SAP, PCL and our CAS).
+
+Channel Suppressing Effect. We compare CAS with three activation- or feature-based defense methods: kWTA (Xiao et al., 2020), SAP (Dhillon et al., 2018) and PCL (Mustafa et al., 2019). Here, we train $k \mathrm { W T A }$ with $20 \%$ sparse largest values in each activation layer, SAP with typical random pruning and PCL with warm-up training by CE loss and then fine-tuning with the added PCL loss. Figure 4 shows the activation frequencies at the penultimate layer of ResNet-18 trained by different methods. While kWTA, SAP and PCL demonstrate a certain level of channel suppressing, their effects are not as significant as our CAS training. kWTA and SAP hardly have the channel suppressing effect (e.g. channel $\# 3 5 0 \mathrm { ~ - ~ } \# 5 0 0$ in Figure 4(a) and channel $\# 3 8 \mathrm { 0 } \mathrm { ~ - ~ } \# 5 0 0$ in Figure
+
+Table 1: Robustness $( \% )$ of ResNet-18 trained by different defense (kWTA, SAP, PCL and our CAS) on CIFAR-10. Avg-PGD-100 denotes 100-step averaged PGD attack (Tramer et al., 2020).   
+
+<table><tr><td>Defense</td><td>Natural</td><td>FGSM</td><td>PGD-20</td><td>CW8</td><td>Avg-PGD-100</td><td>EOT</td></tr><tr><td>kWTA</td><td>76.48</td><td>59.56</td><td>50.72</td><td>46.84</td><td>16.72</td><td>1</td></tr><tr><td>SAP</td><td>79.13</td><td>59.04</td><td>46.35</td><td>46.65</td><td>1</td><td>19.98</td></tr><tr><td>PCL</td><td>88.15</td><td>46.47</td><td>24.68</td><td>37.50</td><td>1</td><td>一</td></tr><tr><td>CAS</td><td>86.79</td><td>61.23</td><td>48.88</td><td>53.33</td><td>53.20</td><td>56.47</td></tr></table>
+
+Table 2: Effectiveness of the channel suppressing operation in CAS module on CIFAR-10 with ResNet-18. CAS is inserted at Block4 of ResNet-18. Without suppressing means the CAS module is inserted, however, the channel suppressing operation is not applied during either training or testing. In this case, CAS is just a simple auxiliary classifier.   
+
+<table><tr><td>Defense</td><td>Natural</td><td>FGSM</td><td>PGD-20</td><td>CW8</td></tr><tr><td>AT</td><td>84.27</td><td>60.46</td><td>46.50</td><td>48.97</td></tr><tr><td>AT+CAS (without suppressing)</td><td>83.42</td><td>59.81</td><td>44.20</td><td>46.27</td></tr><tr><td>AT+CAS (with suppressing)</td><td>86.79</td><td>61.23</td><td>48.88</td><td>53.33</td></tr></table>
+
+4(b)), for the reason that they improve robustness mainly by introducing certain randomness into the activation, and thus can be easily attacked by some adaptive attacks (Tramer et al., 2020; Athalye et al., 2019). PCL still frequently activates many redundant channels (e.g. channel $\# 1 5 0 \mathrm { ~ - ~ } \# 2 5 0$ in Figure 4(c)). This is because PCL does not directly enforce channel suppression. Different from these methods, our CAS demonstrates the most effective channel suppression. As a side note, due to the dynamic thresholding, the frequency distributions should be compared within the same model between natural and adversarial examples not across different models. Within the same model, the closer the frequency distribution of the adversarial examples is to that of the natural examples, the better the adversarial robustness (i.e. the adversarial accuracy is closer to the natural accuracy).
+
+From this point of view, our CAS can effectively reduce the activation frequency gaps between natural and adversarial examples, producing superior robustness. The natural accuracy and robustness of these methods are reported in Table 1. Due to the randomness introduced in kWTA and SAP, they are not robust against average PGD (Avg-PGD) using margin loss (Tramer et al., 2020) or Expectation Over Transformation (EOT) (Athalye et al., 2019) attacks. Our CAS training strategy does not rely on randomness, thus is robust even against Avg-PGD or EOT attacks.
+
+We next verify that explicit Channel Suppressing (CS) is indeed essential to the improved robustness of CAS. Specifically, we remove CS defined in Equation 3 from CAS, then retrain ResNet-18 using adversarial training with the CAS loss defined in Equation 5. Table 2 shows that the robustness can not be improved without explicit channel suppressing.
+
+CAS at Different Layers. We insert the CAS module into different blocks of ResNet-18, and show the different robustness improvements in Table 3. Intuitively, deeper layer activation are more correlated to the class prediction, thus should benefit more from our CAS training. Shallow layers, however, may suffer from inaccurate channel importance estimations. As demonstrated in Table 3, it is indeed the case: the largest improvement is obtained when applying CAS at Block4 (e.g. after the ReLU output of Block4). The robustness can also be improved when inserting CAS into Block3 or both the Block3 and Block4 ( $\mathbf { \dot { B } } \mathbf { l o c } \mathbf { k } 3 + 4 \mathbf { \dot { \omega } }$ ), though notably less significant than that at Block4.
+
+Table 3: Effectiveness of our CAS module at different blocks of ResNet-18 on CIFAR-10.   
+
+<table><tr><td rowspan=1 colspan=1>Defense</td><td rowspan=1 colspan=1>Block</td><td rowspan=1 colspan=1>Natural</td><td rowspan=1 colspan=1>FGSM</td><td rowspan=1 colspan=1>PGD-20</td><td rowspan=1 colspan=1>CW8</td></tr><tr><td rowspan=4 colspan=1>AT+CAS</td><td rowspan=4 colspan=1>Block2Block3Block4Block3+4</td><td rowspan=1 colspan=1>71.89</td><td rowspan=1 colspan=1>49.69</td><td rowspan=1 colspan=1>40.26</td><td rowspan=1 colspan=1>46.46</td></tr><tr><td rowspan=3 colspan=1>83.0586.7983.77</td><td rowspan=1 colspan=1>59.20</td><td rowspan=1 colspan=1>47.84</td><td rowspan=1 colspan=1>48.19</td></tr><tr><td rowspan=1 colspan=1>61.23</td><td rowspan=1 colspan=1>48.88</td><td rowspan=1 colspan=1>53.33</td></tr><tr><td rowspan=1 colspan=1>58.32</td><td rowspan=1 colspan=1>48.27</td><td rowspan=1 colspan=1>54.62</td></tr></table>
+
+Robustness of the CAS Module. Since our CAS module suppresses channel-wise activation according to the label (during training) or the prediction (during testing), it might raise the concerns of whether the CAS module itself is robust or how the misclassification in CAS module would affect the final results. One observation is that, when the CAS module is inserted to deep layers that are close to the final layer of the network, it can learn to make very similar predictions with the final layer. For an empirical analysis, we test the robustness of the CAS module against different attacks in Table 4. The results indicate that our CAS module is robust by itself, leading to both higher natural accuracy and adversarial robustness. More evaluations can be found in Appendix F.5.
+
+Table 4: Robustness of defense ResNet-18 models trained with $\mathbf { \left( + C A S \right) }$ or without CAS module on CIFAR-10 against different attacks. For $\mathbf { + C A S }$ models, we only apply the attack on the CAS module using the CAS loss (Equation 4). For baseline defenses, we attack the final layer of the model.   
+
+<table><tr><td>Defense</td><td>Attack Place</td><td>Natural</td><td>FGSM</td><td>PGD-20</td><td>CW8</td></tr><tr><td>AT / +CAS</td><td>Final/CAS</td><td>84.27/84.95</td><td>60.46/61.40</td><td>46.50/47.99</td><td>48.97/57.79</td></tr><tr><td>TRADES / +CAS</td><td>Final/CAS</td><td>83.50/83.84</td><td>63.68/64.31</td><td>52.80/54.11</td><td>50.90/64.01</td></tr><tr><td>MART/+CAS</td><td>Final / CAS</td><td>82.16/84.89</td><td>63.91/65.14</td><td>52.67/54.48</td><td>49.44/66.92</td></tr></table>
+
+# 5.2 ROBUSTNESS EVALUATION
+
+In this section, we evaluate our CAS on CIFAR-10 (Krizhevsky et al., 2009) and SVHN (Netzer et al., 2011) datasets with ResNet-18 (He et al., 2016). We apply our CAS training strategy to several state-of-the-art adversarial training approaches: 1) AT (Adversarial Training) (Madry et al., 2018), 2) TRADES (Zhang et al., 2019), and 3) MART (Wang et al., 2020c). We follow the default settings as stated in their papers. More results on WideResNet-34-10 (Zagoruyko & Komodakis, 2016) and VGG16 (Simonyan & Zisserman, 2014) can be found in Appendix F.1 and F.2.
+
+Experimental Settings. The training settings for CIFAR-10 are the same as Section 5.1. For SVHN, we adversarially train ResNet-18 using SGD with momentum 0.9, weight decay 5e-4, initial learning rate 0.01 which is divided by 10 at 75-th and 90-th epoch, and training attack PGD-10 ( $\epsilon = 8 / 2 5 \bar { 5 }$ and step size 1/255) with random start.
+
+White-box Robustness. We evaluate the robustness of all defense models against three types of white-box attacks: FGSM, PGD-20 (step size $\epsilon / 1 0 \rangle$ ) and $\mathrm { C W } _ { \infty }$ (optimized by PGD). To fairly compare our method with baselines, we use adaptive white-box attack for our CAS models, i.e. the attacks are performed on the joint loss of CE and CAS. Here, we report the robustness of the models obtained at the last training epoch in Table 5. As shown in Table 5, our CAS can improve both the natural accuracy and the robustness of all baseline methods, resulting in noticeably better robustness. The improvement against $\mathrm { C W } _ { \infty }$ attack is more significant than against FGSM or PGD-20 attacks. This is because the prediction margins are enlarged by our CAS training with the channel suppression. As shown in Figure 9 (Appendix E), the deep representations learned by CAS-trained models are more compact within each class, while are more separated across different classes. This makes margin-based attacks like $\mathbf { C W } _ { \infty }$ more difficult to success.
+
+Robustness results obtained at the best checkpoint throughout the entire training process and the learning curves are provided in Appendix F.3. Our CAS can also improve the robustness of the best checkpoint model for each baseline defense. Thus the improvement of our CAS is reliable and consistent, and is not caused by the effect of overfitting (Rice et al., 2020). We have also evaluated our CAS training strategy under AutoAttack (Croce & Hein, 2020b) and different attack perturbation budget $\epsilon$ in Appendix F.4 and F.5.
+
+Black-box Robustness. We evaluate the black-box robustness of CAS and the baseline methods against both transfer and query-based attacks. For transfer attack, the adversarial examples are generated on CIFAR-10/SVHN test images by applying PGD-20 and $\mathrm { C W } _ { \infty }$ attacks on a naturally trained ResNet-50. For query-based attack, we adopt $\mathcal { N }$ Attack (Li et al., 2019). Since $\mathcal { N }$ Attack requires a lot of queries, we randomly sample 1,000 images from CIFAR-10/SVHN test set and limit the maximum query to 20,000. We test both black-box attacks on the models obtained at the last training epoch. The results are reported in Table 6. For both transfer and query-based attacks, our CAS can improve the robustness of all defense models by a considerable margin. Especially against the $\mathcal { N }$ Attack, our CAS training strategy can improve AT, TRADES and MART by $\mathrm { \sim 3 0 \% }$ - $\bar { 4 0 \% }$ . One reason why our CAS is particularly more effective against $\mathcal { N }$ Attack is that $\mathcal { N }$ Attack utilizes a similar margin objective function as $\mathrm { C W } _ { \infty }$ , which can be effectively blocked by channel suppressing.
+
+Table 5: White-box robustness (accuracy $( \% )$ on various white-box attacks) on CIFAR-10 and SVHN, based on the last checkpoint of ResNet-18. $\mathbf { \hat { \Pi } } _ { + \mathbf { C A S } } ,$ indicates applying our CAS training strategy to existing defense methods. The best results are boldfaced.   
+
+<table><tr><td rowspan="2">Defense</td><td colspan="4">SVHN</td><td colspan="4">CIFAR-10</td></tr><tr><td>Natural</td><td>FGSM</td><td>PGD-20</td><td>CW8</td><td>Natural</td><td>FGSM</td><td>PGD-20</td><td>CW8</td></tr><tr><td>AT</td><td>89.62</td><td>65.09</td><td>42.55</td><td>50.96</td><td>84.27</td><td>60.46</td><td>46.50</td><td>48.97</td></tr><tr><td>AT+CAS</td><td>90.39</td><td>67.51</td><td>51.98</td><td>53.53</td><td>86.79</td><td>61.23</td><td>48.88</td><td>53.33</td></tr><tr><td>TRADES</td><td>91.16</td><td>69.85</td><td>50.90</td><td>50.85</td><td>83.50</td><td>63.68</td><td>52.80</td><td>50.90</td></tr><tr><td>TRADES+CAS</td><td>91.69</td><td>70.97</td><td>55.26</td><td>60.10</td><td>85.83</td><td>65.21</td><td>55.99</td><td>67.17</td></tr><tr><td>MART</td><td>91.16</td><td>67.31</td><td>48.72</td><td>50.52</td><td>82.16</td><td>63.91</td><td>52.67</td><td>49.44</td></tr><tr><td>MART+CAS</td><td>93.05</td><td>70.30</td><td>51.57</td><td>53.38</td><td>86.95</td><td>63.64</td><td>54.37</td><td>63.16</td></tr></table>
+
+Table 6: Black-box robustness (accuracy $( \% )$ on various black-box attacks) of ResNet-18 on SVHN and CIFAR-10. $\mathbf { \partial } ^ { \bullet } { \mathbf { + C A S } } ^ { \bullet }$ indicates applying our CAS training strategy to existing defense methods. The best results are boldfaced.   
+
+<table><tr><td rowspan="2">Defense</td><td colspan="3">SVHN</td><td colspan="3">CIFAR-10</td></tr><tr><td>PGD-20</td><td>CW</td><td>NAttack</td><td>PGD-20</td><td>CW</td><td>NAttack</td></tr><tr><td>AT</td><td>64.42</td><td>70.60</td><td>40.36</td><td>79.13</td><td>79.87</td><td>45.05</td></tr><tr><td>AT+CAS</td><td>65.50</td><td>72.35</td><td>75.72</td><td>85.80</td><td>86.54</td><td>83.32</td></tr><tr><td>TRADES</td><td>67.81</td><td>74.43</td><td>44.16</td><td>78.18</td><td>78.95</td><td>49.25</td></tr><tr><td>TRADES+CAS</td><td>68.48</td><td>75.66</td><td>81.82</td><td>84.77</td><td>85.54</td><td>79.42</td></tr><tr><td>MART</td><td>66.85</td><td>73.90</td><td>41.66</td><td>76.93</td><td>77.49</td><td>49.05</td></tr><tr><td>MART+CAS</td><td>68.45</td><td>75.45</td><td>80.12</td><td>85.68</td><td>86.59</td><td>81.93</td></tr></table>
+
+# 6 CONCLUSION
+
+In this paper, we investigated intermediate activation of deep neural networks (DNNs) from a novel channel-wise perspective, in the context of adversarial robustness and adversarial training. We highlight two new characteristics of the channels of adversarial activation: 1) higher magnitude, and 2) more uniform activation frequency. We find that standard adversarial training improves robustness by addressing the first issue of the higher magnitude, however, it fails to address the second issue of the more uniform activation frequency. To overcome this, we proposed the Channel-wise Activation Suppressing (CAS), which dynamically learns the channel importance and leverages the learned channel importance to suppress the channel activation in the training phase. When combined with adversarial training, we show that, CAS can train DNNs that inherently suppress redundant channels from being activated by adversarial examples. Our CAS is a simple but generic training strategy that can be easily plugged into different defense methods to further improve their robustness, and can be readily applied to robustify the intermediate layers of DNNs.
+
+# ACKNOWLEDGEMENT
+
+Yisen Wang is partially supported by the National Natural Science Foundation of China under Grant 62006153, and CCF-Baidu Open Fund (OF2020002). Shu-Tao Xia is partially supported by the National Key Research and Development Program of China under Grant 2018YFB1800204, the National Natural Science Foundation of China under Grant 61771273, the R&D Program of Shenzhen under Grant JCYJ20180508152204044.
+
+# REFERENCES
+
+Anish Athalye, Nicholas Carlini, and David Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. In ICML, 2019.
+
+Yang Bai, Yan Feng, Yisen Wang, Tao Dai, Shu-Tao Xia, and Yong Jiang. Hilbert-based generative defense for adversarial examples. In ICCV, 2019.
+
+Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In S&P, 2017.
+
+Francesco Croce and Matthias Hein. Minimally distorted adversarial examples with a fast adaptive boundary attack. ICML, 2020a.
+
+Francesco Croce and Matthias Hein. Reliable evaluation of adversarial robustness with an ensemble of diverse parameter-free attacks. ICML, 2020b.
+
+Nilaksh Das, Madhuri Shanbhogue, Shang-Tse Chen, Fred Hohman, Siwei Li, Li Chen, Michael E Kounavis, and Duen Horng Chau. Compression to the rescue: Defending from adversarial attacks across modalities. In KDD, 2018.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. In NAACL, 2019.
+
+Guneet S Dhillon, Kamyar Azizzadenesheli, Zachary C Lipton, Jeremy Bernstein, Jean Kossaifi, Aran Khanna, and Anima Anandkumar. Stochastic activation pruning for robust adversarial defense. ICLR, 2018.
+
+Ranjie Duan, Xingjun Ma, Yisen Wang, James Bailey, A Kai Qin, and Yun Yang. Adversarial camouflage: Hiding physical-world attacks with natural styles. In CVPR, 2020.
+
+Kevin Eykholt, Ivan Evtimov, Earlence Fernandes, Bo Li, Amir Rahmati, Chaowei Xiao, Atul Prakash, Tadayoshi Kohno, and Dawn Song. Robust physical-world attacks on deep learning visual classification. In CVPR, 2018.
+
+Chris Finlay, Adam Oberman, and Bilal Abbasi. Improved robustness to adversarial examples using lipschitz regularization of the loss. arXiv preprint arXiv:1810.00953, 2018.
+
+Angus Galloway, Anna Golubeva, Thomas Tanay, Medhat Moussa, and Graham W Taylor. Batch normalization is a cause of adversarial vulnerability. ICML Workshop, 2019.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In ICLR, 2015.
+
+Shixiang Gu and Luca Rigazio. Towards deep neural network architectures robust to adversarial examples. Computer Science, 2014.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.
+
+Andrew Ilyas, Shibani Santurkar, Dimitris Tsipras, Logan Engstrom, Brandon Tran, and Aleksander Madry. Adversarial examples are not bugs, they are features. In NeurIPS, 2019.
+
+Linxi Jiang, Xingjun Ma, Zejia Weng, James Bailey, and Yu-Gang Jiang. Imbalanced gradients: A new cause of overestimated adversarial robustness. arXiv preprint arXiv:2006.13726, 2020.
+
+Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009.
+
+Alexey Kurakin, Ian Goodfellow, Samy Bengio, et al. Adversarial examples in the physical world, 2016.
+
+Yandong Li, Lijun Li, Liqiang Wang, Tong Zhang, and Boqing Gong. Nattack: Learning the distributions of adversarial examples for an improved black-box attack on deep neural networks. ICML, 2019.
+
+Fangzhou Liao, Ming Liang, Yinpeng Dong, Tianyu Pang, Xiaolin Hu, and Jun Zhu. Defense against adversarial attacks using high-level representation guided denoiser. In CVPR, 2018.
+
+Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. ICLR, 2017.
+
+Xingjun Ma, Bo Li, Yisen Wang, Sarah M Erfani, Sudanthi Wijewickrema, Grant Schoenebeck, Dawn Song, Michael E Houle, and James Bailey. Characterizing adversarial subspaces using local intrinsic dimensionality. In ICLR, 2018.
+
+Xingjun Ma, Yuhao Niu, Lin Gu, Yisen Wang, Yitian Zhao, James Bailey, and Feng Lu. Understanding adversarial attacks on deep learning based medical image analysis systems. Pattern Recognition, 110:107332, 2021.
+
+Laurens van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of Machine Learning Research, 9(Nov):2579–2605, 2008.
+
+Divyam Madaan and Sung Ju Hwang. Adversarial neural pruning with latent vulnerability suppression. ICML, 2020.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. ICLR, 2018.
+
+Aamir Mustafa, Salman Khan, Munawar Hayat, Roland Goecke, Jianbing Shen, and Ling Shao. Adversarial defense by restricting the hidden space of deep neural networks. In ICCV, 2019.
+
+Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y Ng. Reading digits in natural images with unsupervised feature learning. 2011.
+
+Nicolas Papernot, Patrick McDaniel, Xi Wu, Somesh Jha, and Ananthram Swami. Distillation as a defense to adversarial perturbations against deep neural networks. In S&P, 2016.
+
+Adnan Siraj Rakin, Jinfeng Yi, Boqing Gong, and Deliang Fan. Defend deep neural networks against adversarial examples via fixed anddynamic quantized activation functions. arXiv preprint arXiv:1807.06714, 2018.
+
+Leslie Rice, Eric Wong, and J Zico Kolter. Overfitting in adversarially robust deep learning. ICML, 2020.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. Computer Science, 2014.
+
+Abhishek Sinha, Vineeth N Balasubramanian, Harshitha Machiraju, et al. Harnessing the vulnerability of latent layers in adversarially trained models. AAAI, 2019.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. ICLR, 2014.
+
+Florian Tramer, Nicholas Carlini, Wieland Brendel, and Aleksander Madry. On adaptive attacks to adversarial example defenses. arXiv preprint arXiv:2002.08347, 2020.
+
+Bao Wang, Alex T Lin, Zuoqiang Shi, Wei Zhu, Penghang Yin, Andrea L Bertozzi, and Stanley J Osher. Adversarial defense via data dependent activation function and total variation minimization. Inverse Problems and Imaging, 2020a.
+
+Haotao Wang, Tianlong Chen, Shupeng Gui, Ting-Kuei Hu, Ji Liu, and Zhangyang Wang. Once-forall adversarial training: In-situ tradeoff between robustness and accuracy for free. arXiv preprint arXiv:2010.11828, 2020b.
+
+Xin Wang, Jie Ren, Shuyun Lin, Xiangming Zhu, Yisen Wang, and Quanshi Zhang. A unified approach to interpreting and boosting adversarial transferability. In ICLR, 2021.
+
+Yisen Wang, Xuejiao Deng, Songbai Pu, and Zhiheng Huang. Residual convolutional ctc networks for automatic speech recognition. arXiv preprint arXiv:1702.07793, 2017.
+
+Yisen Wang, Xingjun Ma, James Bailey, Jinfeng Yi, Bowen Zhou, and Quanquan Gu. On the convergence and robustness of adversarial training. In ICML, 2019.
+
+Yisen Wang, Difan Zou, Jinfeng Yi, James Bailey, Xingjun Ma, and Quanquan Gu. Improving adversarial robustness requires revisiting misclassified examples. In ICLR, 2020c.   
+Yandong Wen, Kaipeng Zhang, Zhifeng Li, and Yu Qiao. A discriminative feature learning approach for deep face recognition. In ECCV, 2016.   
+Dongxian Wu, Yisen Wang, Shu-Tao Xia, James Bailey, and Xingjun Ma. Skip connections matter: On the transferability of adversarial examples generated with resnets. In ICLR, 2020a.   
+Dongxian Wu, Shu-Tao Xia, and Yisen Wang. Adversarial weight perturbation helps robust generalization. NeurIPS, 33, 2020b.   
+Chang Xiao, Peilin Zhong, and Changxi Zheng. Resisting adversarial attacks by $k$ -winners-take-all. ICLR, 2020.   
+Cihang Xie, Yuxin Wu, Laurens van der Maaten, Alan L Yuille, and Kaiming He. Feature denoising for improving adversarial robustness. In CVPR, 2019.   
+Kaidi Xu, Sijia Liu, Gaoyuan Zhang, Mengshu Sun, Pu Zhao, Quanfu Fan, Chuang Gan, and Xue Lin. Interpreting adversarial examples by activation promotion and suppression. arXiv preprint arXiv:1904.02057, 2019.   
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. BMVC, 2016.   
+Hongyang Zhang, Yaodong Yu, Jiantao Jiao, Eric P Xing, Laurent El Ghaoui, and Michael I Jordan. Theoretically principled trade-off between robustness and accuracy. ICML, 2019.   
+Huan Zhang, Tsui-Wei Weng, Pin-Yu Chen, Cho-Jui Hsieh, and Luca Daniel. Efficient neural network robustness certification with general activation functions. In NeurIPS, 2018.
+
+# A ALGORITHM OF CAS TRAINING
+
+<table><tr><td>Algorithm1Robust Training with CAS.</td><td></td></tr><tr><td>Input: Training data {xi, yi}i=1,2,.,n, DNN F(0), CAS modules with parameters M, maximum training epochs T</td><td></td></tr><tr><td>Output: Robust Network F</td><td></td></tr><tr><td>1:for tin[1,2,·.,T] do</td><td></td></tr><tr><td>2: 3:</td><td>for minibatch {xi,..,xb} do</td></tr><tr><td>4:</td><td>Generate adversarial examples using PGD attack on Equation 5 Compute the CAS loss in Equation 4 using the channel-wise activation fl</td></tr><tr><td>5:</td><td>Reweight the original features fl = fl 8 Ml using the parameters My in CAS</td></tr><tr><td>6:</td><td>Forward with the adjusted fl and compute the CE loss at the output layer</td></tr><tr><td>7: end for 8:</td><td>Optimize all parameters (0,M) by Equation 5 using gradient descent</td></tr></table>
+
+# B A SUMMARY OF THE ADVERSARIAL LOSS FUNCTIONS USED WITH CAS
+
+When combined with our CAS, the training loss is a combination of the original adversarial loss and our CAS loss. Table 7 defines the exact loss functions used for AT (Madry et al., 2018), TRADES (Zhang et al., 2019), MART (Wang et al., 2020c) and their CAS enhanced versions. Here, we assume the CAS module is attached to $S$ number of layers of the network. $\hat { p } ^ { s }$ and $M ^ { s }$ denote the prediction score and weights of the auxiliary classifier in the $s$ -th CAS module, respectively.
+
+Table 7: A summary of the loss functions used for standard adversarial training (AT), TRADES, MART, and their corresponding versions with our CAS $\mathbf { \Lambda } ^ { ( \bullet } \mathbf { + } \mathbf { C } \mathbf { A } \mathbf { S } ^ { \prime }$ ).   
+
+<table><tr><td rowspan=1 colspan=1>Defense</td><td rowspan=1 colspan=1>Loss Function</td></tr><tr><td rowspan=1 colspan=1>AT+CAS</td><td rowspan=1 colspan=1>CE(p(x&#x27;,0),y)+∑=1CE(p（,0,M）,y）</td></tr><tr><td rowspan=1 colspan=1>TRADES+CAS</td><td rowspan=1 colspan=1>CE(p(x,θ),y)+λ·KL(p(x,θ)l|p(x&#x27;,0))+∑1CE(p²(,0,M）,y)+β·(·∑1 KL（(p(x,0,M)Ips(a&#x27;,0,M)))</td></tr><tr><td rowspan=1 colspan=1>MART+CAS</td><td rowspan=1 colspan=1>BCE(p(x&#x27;,0),y)+λ.KL(p(x,0)llp(x&#x27;,y))·(1-py(x,0))</td></tr></table>
+
+# C CHANNEL-WISE ACTIVATION SUPPRESSING ON MORE DATASETS AND DEFENSE MODELS
+
+Here, we visualize the channel suppressing effect of our CAS training strategy on more defense models: TRADES (Zhang et al., 2019) and MART (Wang et al., 2020c). We train ResNet-18 (He et al., 2016) on CIFAR-10 (Krizhevsky et al., 2009). The CAS modules are attached to the final block of ResNet-18.
+
+Figure 5 illustrates the channel activation frequencies of the original defense models and their improved versions with our CAS. As can be observed, our CAS can suppress the redundant channels consistently in both defense models. This restricts the channel-wise activation to be more classcorrelated. More importantly, the channel activation are suppressed to a similar frequency distribution between the natural and the adversarial examples.
+
+We further compare the channel-wise activation of natural versus adversarial examples on SVHN and ImageNet in Figure 6 and Figure 7. For SVHN, we choose examples of class 0 and construct the adversarial examples by PGD-20 with $\epsilon = 8 / 2 5 5$ . We count the channel activation frequency of naturally trained, adversarially trained and CAS trained models. As shown in Figure 6, neurons $\# 2 0 0$ - $\# 5 0 0$ in Figure 6(a) and neurons $\# 2 5 0 - \# 4 0 0$ in Figure 6(b), are frequently activated by adversarial examples while in Figure 6(c), our CAS can effectively suppress these redundant activation.
+
+For ImageNet, as it is extremely time consuming to perform adversarial training, we adopt the standard pre-trained ResNet-152 from torchvision.models \* and an adversarially trained ResNet-152 from the Github repository†. We select 5,900 dog images from the validation set of ImageNet (class #151-#269) and generate the adversarial examples using PGD-30 $\scriptstyle \epsilon = 1 6 / 2 5 5$ , $\alpha { = } 1 / 2 5 5$ ). We count the channel activation at the penultimate layer of ResNet-152. It can be observed in Figure 7(a) that adversarial examples activate more uniformly than natural examples. While in Figure 7(b), adversarially trained models can align the activation distribution of the natural examples with that of the adversarial examples to some extent, however, the activation frequencies of the adversarial examples are still higher than that of the natural examples. This indicates that there are still redundant channels and non-robust features in this adversarially trained ResNet-152 model.
+
+![](images/47a833a7a40cca062cb3213a7a87ad8619cece6b069a16874ca987feae04c484.jpg)  
+Figure 5: The distributions of channel activation frequency of both natural and adversarial examples in different defense models (e.g. TRADES and MART). The frequency distribution gap between natural and adversarial examples is effectively narrowed down by our CAS training, and the redundant channels (channel #200 - #512) are significantly suppressed by CAS.
+
+![](images/42f9036d854116bd6f8a042c809207d4b2ad68bfd4edd09a976c66fbb02f2495.jpg)  
+Figure 6: The distributions of channel activation frequency of both natural and PGD-20 adversarial examples for ResNet-18 on SVHN.
+
+![](images/a4f8365f1b4ca2a145bd1448a208fe86038fbf69c4a559711028a2f35ebb242d.jpg)  
+Figure 7: The distributions of channel activation frequency of both natural and PGD-30 adversarial examples for ResNet-152 on ImageNet.
+
+![](images/722211487c523bec2fc6222b2b8af321ef532bfb1ffb411973b8c55d9515ab88.jpg)  
+Figure 8: Robustness of $\mathrm { A T + C A S }$ against white-box attacks FGSM, PGD-20 and $\mathrm { C W } _ { \infty }$ under different $\beta$ . As $\beta$ increases, the robustness is also improved, especially against the $\mathrm { C W } _ { \infty }$ attack.
+
+# D SENSITIVITY OF CAS TO PARAMETER $\beta$
+
+As mentioned in Section 4, the parameter $\beta$ on the CAS loss controls the suppressing strength. To test the sensitivity of CAS training under different $\beta$ , we insert a CAS module to Block4 of ResNet18, and train the network on CIFAR-10 using $\mathrm { A T + C A S }$ under $\beta \in [ 0 , 0 . 5 , 1 , 2 , 5 , 1 0 , 2 0 ]$ . Note that $\beta = 0$ indicates the standard adversarial training (AT). We test the robustness of the models in a white-box setting against FGSM, PGD-20 and $\mathrm { C W } _ { \infty }$ . As shown in Figure 8, the models trained with larger $\beta$ are generally more robust, especially against the $\mathrm { C W } _ { \infty }$ attack. This is because larger $\beta$ increases the strength of channel suppressing, leading to larger inter-class margins. As we further show in Figure 9, the representations learned with CAS are more separated between different classes, and are more compact within the same class. This tends to increase the difficulty of margin-based attacks like white-box $\mathrm { C W } _ { \infty }$ attack and black-box $\mathcal { N }$ attack.
+
+# E CAS IMPROVES REPRESENTATION LEARNING
+
+The representations learned by natural or adversarial training with or without our CAS strategy are illustrated in Figure 9. The t-SNE (Maaten & Hinton, 2008) 2D embeddings are computed on deep features extracted at the penultimate layer of ResNet-18 on CIFAR-10. As can be observed, our CAS training improves representation learning for both natural training and adversarial training. This is largely attributed to the strong channel suppressing capability of our CAS training. Channel suppressing helps learn high-quality representations with high inter-class separation and intra-class compactness. Interestingly, our CAS training can even improve the performance of natural training from $9 2 . 7 5 \%$ to $9 4 . 5 6 \%$ . This implies that our CAS is a generic training strategy that can benefit both model training and representation learning. Although CAS is not a direct regularization technique, it can achieve a similar representation regularization effect as existing representation enhancing techniques like the center loss (Wen et al., 2016).
+
+# F MORE EXPERIMENTAL RESULTS
+
+# F.1 WIDERESNET RESULTS ON CIFAR-10
+
+The white-box robustness of WideResNet-34-10 (Zagoruyko & Komodakis, 2016) models trained using AT, $\mathrm { A T + C A S }$ , TRADES, TRADES $^ +$ CAS, MART and MART $^ +$ CAS are reported in Table 8. We attach the CAS module to the last two convolution layers of the network, and set $\beta = 2$ . The training settings are the same as used for ResNet-18, except that, here we use weight decay 5e-4. The ‘best’ and ‘last’ results indicate the best and last checkpoints, respectively. For our CAS, we generate the attacks using the same adaptive white-box attacks as used in Section 5.2. The robustness of AT, TRADES and MART can be consistently improved by our CAS training. The most improvements are achieved on AT. These results confirm that our CAS training can lead to consistent improvements to different adversarial training methods on more complex models.
+
+![](images/92cb77aeddab75e6e31c1f5554257ddf96158d32e28018fc9723264b64444df0.jpg)  
+Figure 9: The t-SNE 2D embeddings of deep features extracted at the penultimate layer of ResNet18 models trained using natural (‘STD’) or adversarial training (‘ADV’) on CIFAR-10. The embeddings are shown separately for natural versus adversarial examples. Our CAS training can help improve inter-class separation and intra-class compactness for both types of training.
+
+Table 8: White-box robustness (accuracy $( \% )$ on various white-box attacks) of WideResNet-34-10 on CIFAR-10 dataset. $\mathbf { \partial } ^ { \bullet } { + } \mathbf { C } \mathbf { A } \mathbf { S } ^ { \bullet }$ indicates applying our CAS training to existing defense methods. The best results are boldfaced.   
+
+<table><tr><td rowspan="2">Defense</td><td colspan="7">CIFAR-10</td></tr><tr><td>Natural</td><td></td><td>FGSM</td><td></td><td>PGD-20</td><td>Best</td><td>CW</td></tr><tr><td></td><td>Best</td><td>Last</td><td>Best</td><td>Last</td><td>Best</td><td>Last</td><td>Last</td></tr><tr><td>AT</td><td>84.16</td><td>84.23</td><td>66.62</td><td>61.27</td><td>53.75</td><td>49.53 50.52</td><td>47.68</td></tr><tr><td>AT+CAS</td><td>88.25</td><td>89.06</td><td>67.14</td><td>66.98</td><td>56.28 53.22</td><td>58.54</td><td>54.77</td></tr><tr><td>TRADES</td><td>86.23</td><td>86.41</td><td>66.41</td><td>65.63</td><td>54.42</td><td>52.64 53.45</td><td>52.43</td></tr><tr><td>TRADES+CAS</td><td>87.07</td><td>87.15</td><td>66.92</td><td>66.15</td><td>55.43</td><td>53.15 61.46</td><td>57.07</td></tr><tr><td>MART</td><td>84.09</td><td>85.69</td><td>67.24</td><td>66.41</td><td>57.56</td><td>54.49 54.42</td><td>52.55</td></tr><tr><td>MART+CAS</td><td>87.87</td><td>89.20</td><td>68.09</td><td>67.96</td><td>58.24</td><td>54.95 61.48</td><td>57.11</td></tr></table>
+
+# F.2 VGG16 RESULTS ON CIFAR-10
+
+Similar to the above WideResNet experiments, here we report the results of VGG16 (Simonyan & Zisserman, 2014) on CIFAR-10 in Table 9. For VGG16, we attach the CAS module to its last three convolution layers, and set $\beta = 3$ . We can see that our CAS training can enhance the robustness of ‘best’ models by a remarkable margin of $7 \% - 1 0 \%$ . Note that the accuracy of natural training is also improved by a considerable margin. Compared with complex models like WideResNet, our CAS training is even more beneficial for small capacity models (e.g. VGG16).
+
+Table 9: White-box robustness (accuracy $( \% )$ on various white-box attacks) of VGG16 on CIFAR10. $\mathbf { \partial } ^ { \bullet } { + } \mathbf { C } \mathbf { A } \mathbf { S } ^ { \prime }$ indicates applying our CAS training strategy to existing defense methods. The best results are boldfaced.   
+
+<table><tr><td rowspan="2">Defense</td><td colspan="7">CIFAR-10</td></tr><tr><td>Natural</td><td></td><td>FGSM</td><td></td><td>PGD-20</td><td></td><td>CW</td></tr><tr><td></td><td>Best</td><td>Last</td><td>Best</td><td>Last</td><td>Best</td><td>Last</td><td>Best Last</td></tr><tr><td>AT</td><td>70.32</td><td>70.38</td><td>51.87</td><td>51.85</td><td>42.23 42.01</td><td>43.63</td><td>43.81</td></tr><tr><td>AT+CAS</td><td>82.25</td><td>82.61</td><td>59.77</td><td>57.56</td><td>49.22 42.73</td><td>53.03</td><td>49.68</td></tr><tr><td>TRADES</td><td>74.98</td><td>76.67</td><td>52.10</td><td>52.99</td><td>41.53</td><td>41.13 45.50</td><td>45.25</td></tr><tr><td>TRADES+CAS</td><td>83.45</td><td>83.25</td><td>61.36</td><td>61.51</td><td>49.86</td><td>49.56 52.60 44.52</td><td>52.47</td></tr><tr><td>MART</td><td>71.70</td><td>72.20</td><td>54.72</td><td>54.90</td><td>46.55</td><td>46.53</td><td>44.72</td></tr><tr><td>MART+CAS</td><td>81.53</td><td>83.28</td><td>61.89</td><td>61.70</td><td>52.01</td><td>49.13 50.97</td><td>49.10</td></tr></table>
+
+# F.3 ROBUSTNESS RESULTS AT THE BEST CHECKPOINT
+
+We report the white-box robustness of the ‘best’ (i.e. the best checkpoint) models of ResNet-18 on SVHN and CIFAR-10 in Table 10, as a supplementary to the ‘last’ (i.e. the last checkpoint) results in Table 5. Again, our CAS can also improve the robustness of the ‘best’ checkpoint models consistently. This proves that our CAS can improve both the robustness and the natural accuracy throughout the entire training process.
+
+Table 10: White-box robustness (accuracy $( \% )$ on various white-box attacks) of ResNet-18 on CIFAR-10 and SVHN on the best checkpoint. $\mathbf { \partial } ^ { \bullet } { + } \mathbf { C } \mathbf { A } \mathbf { S } ^ { \prime }$ indicates applying our CAS training strategy to existing defense methods. The best results are boldfaced.   
+
+<table><tr><td rowspan="2">Defense</td><td colspan="4">SVHN</td><td colspan="4">CIFAR-10</td></tr><tr><td>Natural</td><td>FGSM</td><td>PGD-20</td><td>CW8</td><td>Natural</td><td>FGSM</td><td>PGD-20</td><td>CW8</td></tr><tr><td>AT</td><td>91.41</td><td>69.52</td><td>53.07</td><td>50.38</td><td>84.20</td><td>63.32</td><td>52.01</td><td>50.97</td></tr><tr><td>AT+CAS</td><td>92.69</td><td>71.83</td><td>54.78</td><td>54.13</td><td>86.72</td><td>62.92</td><td>54.40</td><td>62.72</td></tr><tr><td>TRADES</td><td>90.40</td><td>71.22</td><td>57.71</td><td>54.49</td><td>82.68</td><td>63.15</td><td>53.05</td><td>50.46</td></tr><tr><td>TRADES+CAS</td><td>91.41</td><td>71.39</td><td>59.32</td><td>66.94</td><td>84.75</td><td>63.94</td><td>57.20</td><td>67.77</td></tr><tr><td>MART</td><td>87.37</td><td>68.58</td><td>57.72</td><td>51.48</td><td>78.90</td><td>63.29</td><td>54.92</td><td>50.31</td></tr><tr><td>MART+CAS</td><td>91.04</td><td>72.32</td><td>60.29</td><td>57.05</td><td>85.99</td><td>64.23</td><td>58.21</td><td>69.91</td></tr></table>
+
+# F.4 ROBUSTNESS AGAINST AUTOATTACK
+
+We report the white-box AutoAttack (Croce & Hein, 2020b) evaluation results of ResNet-18 on CIFAR-10 in Table 11. AutoAttack is an ensemble of two proposed Auto-PGD attacks and the other two complementary attacks (Croce & Hein, 2020a). AutoAttack has been shown can produce more accurate robustness evaluations on a wide range of adversarial training defenses. As shown in Table 11, although less significant than against regular attacks like PGD and CW, CAS with proper training can still improve the robustness of AT, TRADES and MART by a noticeable margin. This confirms that the improvements brought by our CAS training is ‘real’ and substantial, rather than obfuscated gradients nor improper evaluation.
+
+Table 11: White-box robustness (accuracy $( \% )$ against AutoAttack) of ResNet-18 on CIFAR-10. $\mathbf { \partial } ^ { \circ } + \mathbf { C } \mathbf { A } \mathbf { S } ^ { \prime }$ indicates applying our CAS training strategy to existing defense methods. The best results are boldfaced.   
+
+<table><tr><td>Defense</td><td>AutoAttack Best Last</td></tr><tr><td>AT AT+CAS</td><td>46.58 41.90 47.40 44.74</td></tr><tr><td>TRADES</td><td>48.28 47.46</td></tr><tr><td>TRADES+CAS</td><td>48.40 48.38</td></tr><tr><td>MART MART+CAS</td><td>47.06 45.45 48.45 46.39</td></tr></table>
+
+# F.5 MORE ROBUSTNESS EVALUATIONS OF CAS
+
+The robustness of the CAS module is further evaluated in this section. By producing large margins, the CAS module and the channel suppression operation can make more boundary adversarial examples be correctly classified than that in the baseline models. However, this may also increase the risk of causing imbalanced margin and imbalanced gradients. To test this, we evaluate CAS against a recent Margin Decomposition (MD) attack (Jiang et al., 2020). We use the default setting of MD attack as stated in the original paper. The results are reported in Table 12, where it shows our CAS is robust against the MD attack. We also test our CAS against PGD-20 with step size $\epsilon / 1 0$ and various attack strengths. This result is presented in Table 13. The robustness of CAS decreases with the increase of $\epsilon$ , which proves that the robustness of CAS is not a result of obfuscated gradients.
+
+Table 12: Robustness of CAS against Margin Decomposition (MD) attack. This experiment was conducted with ResNet-18 on CIFAR-10.   
+
+<table><tr><td>Defense</td><td colspan="2">Adversarial Loss Type MD (CE) MD (CAS) MD (CE+CAS)</td></tr><tr><td>AT AT+CAS</td><td>43.35 1</td><td>1 49.56</td></tr><tr><td>TRADES TRADES+CAS</td><td>48.47</td><td>46.27 1 1 53.51 55.53</td></tr><tr><td>MART MART+CAS</td><td>1 46.99 49.89 1</td><td>1 55.75</td></tr></table>
+
+Table 13: Robustness $( \% )$ ) of CAS with ResNet-18 on CIFAR-10 against PGD-20 under different .   
+
+<table><tr><td>Attack strength e | 2/255</td><td></td><td>4/255</td><td>8/255</td><td>16/255</td><td>32/255</td></tr><tr><td>AT+CAS</td><td>79.15</td><td>70.26</td><td>48.88</td><td>16.64</td><td>2.48</td></tr><tr><td>TRADES+CAS</td><td>80.09</td><td>72.69</td><td>55.99</td><td>27.94</td><td>5.10</td></tr><tr><td>MART+CAS</td><td>81.01</td><td>73.56</td><td>54.37</td><td>20.49</td><td>2.19</td></tr></table>
+
+# F.6 CHANNEL ACTIVATION FREQUENCY UNDER DIFFERENT THRESHOLDS
+
+In Figure 2, we have shown the activation frequency of standard training (STD), adversarial training (AT) and CAS-based adversarial training $\scriptstyle ( \mathrm { A T + C A S } )$ on a ResNet-18 model with the threshold of $1 \%$ . That is, a channel is determined as activated if its activation count is larger that $1 \%$ of the maximum activation count over all 512 channels. In Figure 10, we show the distribution of activation frequency under different thresholds (e.g. $0 . 5 \%$ , $1 \%$ , $5 \%$ ). Larger threshold will truncate more low-count activation. The plots show that different thresholds will introduce some noise to the distributions but the general patterns do not change.
+
+![](images/ef4349ff8a0c104e410a229157aaa38ccfeb73c1f9ad00a89f9bc642778f6a61.jpg)  
+Figure 10: The activation frequency (y-axis) of channel-wise activation at the penultimate layer of adversarial training (AT) and our CAS-based adversarial training $\scriptstyle ( \mathrm { A T + C A S } )$ for ResNet-18 on CIFAR-10. The activation frequencies are visualized with respect to different thresholds (e.g. $0 . 5 \%$ , $1 \%$ and $5 \%$ ).

parse/train/zbEupOtJFF/zbEupOtJFF.md

@@ -0,0 +1,303 @@
+# ON INTERACTION BETWEEN AUGMENTATIONS AND CORRUPTIONS IN NATURAL CORRUPTION ROBUSTNESS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Invariance to a broad array of image corruptions, such as warping, noise, or color shifts, is an important aspect of building robust models in computer vision. Recently, several new data augmentations have been proposed that significantly improve performance on ImageNet-C, a benchmark of such corruptions. However, there is still a lack of basic understanding on the relationship between data augmentations and test-time corruptions. To this end, we develop a feature space for image transforms, and then use a new measure in this space between augmentations and corruptions called the Minimal Sample Distance to demonstrate there is a strong correlation between similarity and performance. We then investigate recent data augmentations and observe a significant degradation in corruption robustness when the test-time corruptions are sampled to be perceptually dissimilar from ImageNetC in this feature space. Our results suggest that test error can be improved by training on perceptually similar augmentations, and data augmentations may risk overfitting to the existing benchmark. We hope our results and tools will allow for more robust progress towards improving robustness to image corruptions.
+
+# 1 INTRODUCTION
+
+Robustness to distribution shift, i.e. when the train and test distributions differ, is an important feature of practical machine learning models. Among many forms of distribution shift, one particularly relevant category for computer vision are image corruptions. For example, test data may come from sources that differ from the training set in terms of lighting, camera quality, or other features. Postprocessing transforms, such as photo touch-up, image filters, or compression effects are commonplace in real-world data. Models developed using clean, undistorted inputs typically perform dramatically worse when confronted with these sorts of image corruptions (Hendrycks & Dietterich, 2018; Geirhos et al., 2018). The subject of corruption robustness has a long history in computer vision (Simard et al., 1998; Bruna & Mallat, 2013; Dodge & Karam, 2017) and recently has been studied actively with the release of benchmark datasets such as ImageNet-C (Hendrycks & Dietterich, 2018).
+
+One particular property of image corruptions is that they are low-level distortions in nature. Corruptions are transformations of an image that affect structural information such as colors, textures, or geometry (Ding et al., 2020) and are typically free of high-level semantics. Therefore, it is natural to expect that data augmentation techniques, which expand the training set with random low-level transformations, can help with learning robust models. Indeed, data augmentation has become a central technique in several recent methods (Hendrycks et al., 2019; Lopes et al., 2019; Rusak et al., 2020) that achieve large improvements on ImageNet-C and related benchmarks.
+
+One caveat for data augmentation based approaches is the test corruptions are expected to be unknown at training time. If the corruptions are known, they may simply be applied to the training set as data augmentations to trivially adapt to the test distribution. Instead, an ideal robust model needs to be robust to any valid corruption, including ones unseen in any previous benchmark. Of course, in practice the robustness of a model can only be evaluated approximately by measuring its corruption error on a representative corruption benchmark. To avoid trivial adaptation to the benchmark, recent works manually exclude test corruptions from the training augmentations. However, with a toy experiment presented in Figure 1, we argue that this strategy alone might not be enough and that visually similar augmentation outputs and test corruptions can lead to significant benchmark improvements even if the exact corruption transformations are excluded.
+
+![](images/84e71a0fbb624a3c4a29129ffd3c4970caa55a8e04f5627c88cbc2fa0003d4c9.jpg)  
+Figure 1: A toy experiment. We train multiple models on CIFAR-10 (Krizhevsky et al., 2009) using different augmentation schemes. Each scheme is based on a single basic image transformation type and enhanced by overlaying random instantiations of the transformation for each input image following Hendrycks et al. (2019). We compare these models on the CIFAR-10 test set corrupted by the motion blur, a corruption used in the ImageNet-C corruption benchmark Hendrycks & Dietterich (2018). None of the augmentation schemes contains motion blur; however, the models trained with geometric-based augmentations significantly outperform the baseline model trained on the clean images while color-based augmentations show no gains. We note the geometric augmentations can produce a result visually similar to a blur by overlaying copies of shifted images1.
+
+This observation raises two important questions. One, how exactly does the similarity between train time augmentations and corruptions of the test set affect the error? And two, if the gains are due to the similarity, the improvements may not translate into better robustness to other possible corruptions, so do we ever risk overfitting existing corruption benchmarks using a new augmentation scheme? In this work, we take a step towards answering these questions, with the goal of better understanding the relationship between data augmentation and test-time corruptions. Using a feature space on image transforms and a new measure called Minimal Sample Distance (MSD) on this space, we are able to quantify the distance between augmentation schemes and classes of corruption transformation. With our approach, we empirically show an intuitive yet surprisingly overlooked finding:
+
+# Augmentation-corruption perceptual similarity is a strong predictor of corruption error.
+
+Based on this finding, we perform additional experiments to show that data augmentation aids corruption robustness by increasing perceptual similarity between a (possibly small) fraction of the training data and the test set. To further support our claims, we introduce a set of new corruption, called CIFAR/ImageNet-C, to test the degree to which common data augmentation methods overfit original the CIFAR/ImageNet-C. To choose these corruptions, we expand the set of natural corruptions and sample new corruptions that are far away from CIFAR/ImageNet-C in our feature space for measuring perceptual similarity. We then demonstrate that augmentation schemes designed specifically to improve robustness show significantly degraded performance on CIFAR/ImageNet-C. Some augmentation schemes still show some improvement over baseline, which suggests meaningful progress towards general corruption robustness is being made, but different augmentation schemes exhibit different degrees of generalization capability. As an implication, caution is needed for fair robustness evaluations when additional data augmentation is introduced.
+
+These results suggest a major challenge that is often overlooked in the study of corruption robustness: overfitting indeed occurs. Since perceptual similarity can predict performance, for any fixed finite set of test corruptions, improvements on that set may generalize poorly to dissimilar corruptions. However, perceptual similarity is not expected to be the only interaction between augmentations and corruptions, so a proposed augmentation scheme’s degree of generalization capability may not be immediately clear. We hope that our results, together with new tools and benchmarks, will help researchers better understand why a given augmentation scheme has good corruption error and whether it should be expected to generalize to dissimilar corruptions. On the positive side, our experiments show that generalization does emerge within perceptually similar classes of transform, and that only a small fraction of sampled augmentations need to be similar to a given corruption. Section 6 discusses these points in more depth.
+
+# 2 RELATED WORK
+
+Corruption robustness benchmarks and analysis. ImageNet-C (Hendrycks & Dietterich, 2018) is a corruption dataset often used as a benchmark in robustness studies. Other corruption datasets (Hendrycks et al., 2020; Shankar et al., 2019) collect corrupted images from real world sources and thus have a mixture of semantic distribution shifts and perceptual transforms. Corruption robustness differs from adversarial robustness (Szegedy et al., 2014), which seeks invariance to small, worst case distortions. One notable difference is that improving corruption robustness often slightly improves regular test error, instead of harming it. Yin et al. (2019) analyzes corruption robustness in the context of transforms’ frequency spectra; this can also influence corruption error independently from perceptual similarity. Dao et al. (2019); Wu et al. (2020) study the theory of data augmentation for regular test error. Hendrycks et al. (2020); Taori et al. (2020) study how the performance on synthetic corruption transforms generalizes to performance on corruption datasets collected from the real world. Here we do not address this issue directly but touch upon it in the discussion.
+
+Improving corruption robustness. Data augmentations designed to improve robustness include AugMix (Hendrycks et al., 2019), which composites common image transforms, Patch Gaussian (Lopes et al., 2019), which applies Gaussian noise in square patches, and ANT (Rusak et al., 2020), which augments with an adversarially learned noise distribution. AutoAugment (Cubuk et al., 2019) learns augmentation policies that optimize clean error but has since been shown to improve corruption error (Yin et al., 2019). Mixup (Zhang et al., 2018a) can improve robustness (Lee et al., 2020), but its label augmentation complicates the dependence on image augmentation. Stylized-ImageNet (Geirhos et al., 2019) can improve robustness, but it is at the cost of clean test error without additional fine-tuning. Noisy Student (Xie et al., 2020) and Assemble-ResNet (Lee et al., 2020) combine data augmentation with new models and training procedures and greatly enhance corruption robustness.
+
+# 3 PERCEPTUAL SIMILARITY FOR AUGMENTATIONS AND CORRUPTIONS
+
+First, we study the importance of similarity between augmentations and corruptions for improving performance on those corruptions. To do so, we need a means to compare augmentations and corruptions. Both types of transforms are perceptual in nature, meaning they affect low-level image structure while leaving high-level semantic information intact, so we expect a good distance to be a measure of perceptual similarity. Then, we need to find the appropriate measure of distance between the augmentation and corruption distributions. We will argue below that distributional equivalence is not appropriate in the context of corruption robustness, and instead introduce the minimal sample distance, a simple measure that does capture a relevant sense of distribution distance.
+
+Measuring similarity between perceptual transforms. We define a perceptual transform as a transform that acts on low-level image structure but not high-level semantic information. As such, we expect two transforms should be similar if their actions on this low-level structure are similar, independent of algorithmic or per-pixel differences between them. A closely related, well-studied problem is the perceptual similarity between images. A common approach is to train a neural network on a classification task and use intermediate layers as a feature space for measuring distances (Zhang et al., 2018b). Here we adapt this idea to instead obtain a feature space for measuring distances between perceptual transforms.
+
+We start with a feature extractor for images, which we call ${ \hat { f } } ( x )$ . To train the model from which we will extract features, we assume access to a dataset $\mathbb { D }$ of image label pairs $( x , y )$ associated with a classification task. The model should be trained using only default data augmentation for the task in question so that the feature extractor is independent of the transforms we will use it to study. In order to obtain a very simple measure, we will use just the last hidden layer of the network as a feature space.
+
+A perceptual transform $t ( x )$ may be encoded by applying it to all images in $\mathbb { D }$ , encoding the transformed images, and averaging the features over these images. For efficiency, we find it sufficient to average over only a randomly sampled subset of images $\mathbb { D } _ { S }$ in $\mathbb { D }$ . We show in Appendix C this produces stable estimates for reasonable numbers of images. The random choice of images is a property of the feature extractor, and so remains fixed when encoding multiple transforms. This reduces variance when computing distances between two transforms. The transform feature extractor is given by $f ( t ) = \mathbb { E } _ { x \in \mathbb { D } _ { S } } [ \hat { f } ( t ( x ) ) ) ]$ . The perceptual similarity between an augmentation and a corruption can be taken as the $L _ { 2 }$ distance on this feature space $f$ .
+
+![](images/e596ac11e5ef00289444e4750fe4f90004f6818481661de931311b0f825fd368.jpg)  
+Figure 2: (a) Schematic comparison of MMD to MSD. MMD measure between distribution centers and is only small if the augmentation overlaps with a corruption. MSD measures to the nearest sampled point in set of samples (marked by a star), and is small even for broad distributions that overlap with multiple corruptions. (b) We test on images corruption with impulse noise, and train on images augmented with a mixture of impulse noise and motion blur. As the mixing fraction of impulse noise decreases, MMD between the augmentation and corruption grows linearly while MSD and error stay low until nearly $0 \%$ mixing fraction.
+
+Minimal sample distance. We now seek to compare the distribution of an augmentation scheme $p _ { a }$ to a distribution of a corruption benchmark $p _ { c }$ . A simple first guess would be to measure how close to equivalent the distributions are. Indeed, if the goal was to optimize error on a known corruption distribution, exact equivalence of distributions is the correct measure to minimize. But since the goal is robustness to general, unknown corruption distributions, a good augmentation scheme should be equivalent to no single corruption distribution.
+
+To illustrate this behavior, consider a toy problem where we have access to the corruption transforms at training time. A very rough, necessary but insufficient measure of distributional similarity is $d _ { \mathrm { M M D } } ( \bar { p _ { a } } , p _ { c } ) = | | \mathbb { E } _ { a \sim p _ { a } } [ f ( \bar { a } ) ] - \mathbb { E } _ { c \sim p _ { c } } [ \bar { f } ( c ) ] | |$ . This is the maximal mean discrepancy on a fixed, finite feature space, so for brevity we will refer to it as MMD. We still employ the featurization $f ( t )$ , since we are comparing transforms and not images, unlike in typical domain adaptation. Consider two corruption distributions, here impulse noise and motion blur, and an augmentation scheme that is a mixture of the two corruption distributions. Figure 2b shows that MMD between the augmentation and impulse noise corruption scales linearly with mixing fraction, but error on impulse noise remains low until the mixing fraction is almost $0 \%$ impulse noise. This implies distributional similarity is a poor predictor corruption error. Indeed, in the context of corruption robustness, low $d _ { \mathrm { M M D } }$ with any one corruption distribution is likely bad thing: it suggests the augmentation scheme overfits that one corruption distribution at expense of performance on other, dissimilar corruption distributions.
+
+Our expectation for the behavior of the error in Figure 2b is that networks can often successfully memorize rare examples seen during training, so that only a very small fraction of sampled images need impulse noise augmentations to perform well on impulse noise corruptions. An appropriate distance should then measure how close augmentation samples can come to the corruption distribution, even if the density of those samples is low. We thus propose a very simple measure called minimal sample distance (MSD), which is just the perceptual similarity between an average corruption and the closest augmentation from a finite set of samples $\mathbb { A } \sim p _ { a }$ :
+
+$$
+d _ { \mathrm { M S D } } ( p _ { a } , p _ { c } ) = \operatorname* { m i n } _ { a \in \mathbb { A } \sim p _ { a } } \left| | f ( a ) - \mathbb { E } _ { c \sim p _ { c } } [ f ( c ) ] | \right| .
+$$
+
+A schematic comparison of MMD and MSD is shown in Figure 2a. While both MMD and MSD are small for an augmentation scheme that is distributionally similar to a corruption distribution, only MSD remains small for a broad distribution that occasionally produces samples near multiple corruption distributions. Figure 2b shows MSD, like test error, remains small for most mixing fractions in the toy problem described above. Note that the need for our measure to accommodate robustness to general, unknown corruption distributions has led it to be asymmetric, so it differs from more formal distance metrics that may be used to predict generalization error, such as the Wasserstein distance (Zilly et al., 2019).
+
+# 4 PERCEPTUAL SIMILARITY IS PREDICTIVE OF CORRUPTION ERROR
+
+We are now equipped to measure how important this augmentation-corruption similarity is for corruption error. For a large number of augmentation schemes, we will measure both the MSD to a corruption distribution and the corruption error of a model trained with that scheme. We will find a correlation between MSD and corruption error, which provides evidence that networks can successfully generalize across perceptually similar transforms. Then, we will calculate the MSD for augmentation schemes in the literature that have been shown to improve error on corruption benchmarks. We will find a correlation between MSD and error here as well, which suggests the success of these models is in part explained by their perceptual similarity to the benchmark. This implies there may be a risk that the augmentation schemes overfit the benchmark, since we would not expect this improvement to transfer to a dissimilar corruption.
+
+# 4.1 EXPERIMENTAL SETUP
+
+Corruptions. We use CIFAR-10-C (Hendrycks & Dietterich, 2018), which is a common benchmark used for studying corruption robustness. It consists of 15 corruptions, each further split into five different severities of transformation, applied to the CIFAR-10 test set. The 15 corruptions fall into four categories: per-pixel noise, blurring, synthetic weather effects, and digital transforms. We treat each corruption at each severity as a separate distribution for the sake of calculating MSD and error; however, for simplicity we average errors and distances over severity to present a single result per corruption. Examples of each corruption are shown in Figure 13 in Appendix E.
+
+Space of augmentation schemes. To build each sampled augmentation transform, we will composite a set of base augmentations. For base augmentations, we consider the nine common image transforms used in Hendrycks et al. (2019), shown in Figure 12 of Appendix E. There are five geometric transforms and four color transforms. By taking all subsets of these base augmentations, we obtain $2 ^ { 9 } \ : = \ : 5 1 2$ unique augmentation schemes, collectively called the augmentation powerset. Also following Hendrycks et al. (2019), we composite transforms in two ways: by applying one after another, or by applying them to copies of the image and then linearly superimposing the results.
+
+Computing similarity and corruption error. A WideResNet-40-2 (Zagoruyko & Komodakis, 2016) model is pre-trained on CIFAR-10 using default augmentation and training parameters from Hendrycks et al. (2019). WideResNet is a common baseline model used when studying data augmentation on CIFAR-10 (Hendrycks et al., 2019; Cubuk et al., 2019; Zhang et al., 2018a). Its last hidden layer is used as the feature space. For MSD, we average over 100 images, 100 corruptions, and minimize over 100k augmentations. We argue in Appendix C that these are reasonable choices. Images are from the training set and do not have default training augmentation. For corruption error evaluation, we also use a WideResNet-40-2 and the same training parameters.
+
+# 4.2 ANALYSIS
+
+MSD correlates with corruption error. First, we establish the correlation between MSD and corruption error on the augmentation powerset. Figure 3 shows the relationship between distance and corruption error for both MSD on four example corruption distributions. MSD shows strong correlation with corruption error across corruptions types in all four categories of CIFAR-10-C. In Figure 14 in Appendix F, we compare to MMD and confirm that MMD correlates poorly with corruption error, as expected. In particular, our expectation is that broad augmentation schemes with many base transforms produce samples similar to a larger set of corruptions, even if those samples occur less frequently. This leads to both lower MSD and lower corruption error but higher MMD. Additionally, the correlation between MSD and corruption error suggests that perceptual similarity is a predictor of corruption error. However, as shown in Table 1, most but not all corruptions show strong correlation between MSD and error: 12 of 15 have Spearman rank correlation greater than 0.6. A complete set of correlation plots is shown in Figure 15 in Appendix F.
+
+An example of perceptual similarity. Here we briefly illustrate the perceptual nature of the similarity measure, using an example with two base augmentations and two corruptions. The augmentation solarize and the corruption impulse noise both insert brightly colored pixels into the image, though in different ways. The augmentation $x$ translation and the corruption motion blur are both geometric transforms, and linear superpositions of $x$ translation are visually similar to blurring. Examples of these transforms are shown in Figure 12 and Figure 13 in Appendix E. Figure 4 shows MSD vs error where augmentation schemes that include solarize and x translation are colored. It is clear that including an augmentation greatly decreases MSD to its perceptually similar corruption, while having little effect on MSD to its perceptually dissimilar corruption.
+
+![](images/cff38999ee79985ab76f48948fcfd76a315812ed0f1e2aa2494ad55e4f30a882.jpg)  
+Figure 3: Example relationships between MSD and corruption error for different corruptions. $\rho$ is the Spearman rank correlation. MSD correlates well with error across all four categories of corruption in CIFAR-10-C.
+
+Table 1: Spearman’s rank coefficient for the correlation between MSD and corruption error. Correlations are high for most corruptions, including those in all four categories in ImageNet-C. However, brightness, pixelate, and JPEG compression show poor correlation.   
+
+<table><tr><td>Corruption</td><td>p</td><td>Corruption</td><td>p</td><td>Corruption</td><td>p</td></tr><tr><td>Gaussian Noise</td><td>0.76</td><td>Zoom Blur</td><td>0.77</td><td>Snow</td><td>0.65</td></tr><tr><td>Shot Noise</td><td>0.83</td><td>Glass Blur</td><td>0.69</td><td>Contrast</td><td>0.66</td></tr><tr><td>Impulse Noise</td><td>0.90</td><td>Brightness</td><td>0.27</td><td>Pixelate</td><td>0.35</td></tr><tr><td>Motion Blur</td><td>0.86</td><td>Fog</td><td>0.68</td><td>JPEG Compression</td><td>0.33</td></tr><tr><td>Defocus Blur</td><td>0.83</td><td>Frost</td><td>0.66</td><td>Elastic Transform</td><td>0.77</td></tr></table>
+
+MSD and corruption error in real augmentation methods. The augmentation powerset may be used as a baseline for comparing real data augmentation schemes. Figure 5 shows example MSD-error correlations for Patch Gaussian, AutoAugment, and Augmix, along with the cloud of augmentation powerset points. The real augmentation schemes follow the same general trend that lower error predicts lower MSD. A few intuitive correlations are also captured in Figure 5. Patch Gaussian has low MSD to corruptions with noise corruptions and to glass blur which introduces random pixel-level permutations as noise, and may be distributionally similar to the noise corruptions, as we argue in Appendix A. AutoAugment, which contains contrast and Gaussian blurring augmentations in its sub-policies, has low MSD with contrast and defocus blur. AugMix, which introduces fewer base augmentations that AutoAugment but composites them in ways that may produce perceptually new effects (such as blurring from superimposing translations), has low MSD with all corruptions.
+
+The fact that improved corruption error typically implies greater similarity suggests overfitting may be an issue in the study of corruption robustness. For two augmentation schemes compared on a fixed corruption benchmark, the one that is more perceptually similar to the corruptions may perform better, but also generalize to dissimilar corruptions worse. This perceptual similarity may be exact and explicit, such as between AutoAugment, which contains contrast augmentations, and the contrast corruption. But it may also be naively unexpected, such as the similarity between Patch Gaussian and glass blur (since glass blur shares similarity with the noise corruptions) or between AugMix and blurs (since superimposed translations are blur-like). Note, however, that perceptual similarity is not expected to be the only interaction between augmentations and corruptions (for instance, the frequency dependence of Yin et al. (2019) is another), and other interactions may or may not lead to good generalization. Thus, tools such as MSD help us determine why an augmentation scheme improves corruption error, so we can better analyze and understand if newly proposed methods will generalize beyond their tested benchmarks. In the next section, we test this generalization directly by finding corruptions that are dissimilar to ImageNet-C.
+
+![](images/02fd16f0dedb0053fc55c0029a2ecafc93203d63623c1b5c8f2a0feda8e12ac0.jpg)  
+Figure 4: Example relationships between base augmentations and corruptions. Including ‘solarize’ reduces MSD on the perceptually similar impulse noise corruption, while including $x$ translation reduces MSD on the perceptually similar motion blur corruption. MSD is not decreased for dissimilar augmentation-corruption pairs.
+
+![](images/54a9db239d5963c947e3a2cd15f213da3b18209b52079c326778ba21d2426ae4.jpg)  
+Figure 5: Example correlations for augmentation schemes from the literature. Patch Gaussian is similar to noise, while AutoAugment is similar to contrast and blur, as expected from their formulation. Glass blur acts more like a noise corruption than a blur for these augmentation schemes, likely because it randomly permuting pixels. \*AugMix here refers to just the augmentation distribution in Hendrycks et al. (2019), not the proposed Jensen-Shannon divergence loss, which gives additional improvements in corruption error.
+
+# 5 IMAGENET-C: BENCHMARKING WITH DISSIMILAR CORRUPTIONS
+
+We now introduce a set of corruptions, called ImageNet-C, that are perceptually dissimilar to ImageNet-C in our transform feature space and will show that several augmentation schemes have degraded performance on the new dataset, suggesting that they have indeed overfit ImageNet-C to at least some degree. We emphasize that the dataset selection method does not involve any augmentation scheme beyond the default one used to train the feature extractor and was fixed before we looked at the results for different augmentations, so there should be no inadvertent adversarial selection against the augmentation schemes.
+
+Dataset construction. An overview of the dataset construction is presented here, with specific details described in Appendix D.1. We construct a set of 30 new corruptions types in 10 severities, from which the 10 most dissimilar corruptions types will be chosen. These corruptions are adapted from common filters and noise distributions available online (Huxtable, 2006; Gladman, 2016) and are designed to produce human interpretable images. The transforms include warps, blurs, color distortions, noise additions, and obscuring effects. Examples are shown in Appendix E.
+
+To assure that the new dataset is no harder than ImageNet-C, we restrict the average corruption error of the new dataset to be similar to that of ImageNet-C for default augmentation. We then generate many potential datasets and measure the average shift in distance to ImageNet-C that each corruption contributes, shown in Figure 16 in Appendix F. Note that while MSD was used to establish a correlation between perceptual similarity and error for augmentations and corruptions, here we are comparing corruptions to other corruptions and thus use MMD as the measure of distance in our transform feature space. Some generally intuitive results are recovered. First, scatter and blue noise, which are conceptually similar to ImageNet-C’s glass blur and gaussian noise corruptions, consistently lead to more similarity with ImageNet-C. Second, lower-frequency noise distortions tend to be included in more dissimilar datasets, possibly in contrast to ImageNet-C’s high frequency pixel noise. However, blue noise sample, which shares some visual similarities with impulse noise, also leads to larger distances. ImageNet-C then consists of the 10 corruptions types with the largest average shift in distance. Like ImageNet-C, each is included in five different severities, with severities chosen so that the average error matches ImageNet-C for default augmentation. Example transforms from ImageNet-C and CIFAR-10-C are shown in Figure 6.
+
+![](images/d64e851ccfd50809d3263248bbf0a2843fcb50fddd88c10ad5e4542378997fad.jpg)  
+Figure 6: Example CIFAR-10-C and ImageNet-C corruptions. While still human interpretable, new corruptions are sampled to be dissimilar from CIFAR-10/ImageNet-C. Base images $\circledcirc$ Sehee Park and Chenxu Han.
+
+Results. We test AutoAugment, Patch Gaussian, AugMix, and $\mathbf { A N T } ^ { 3 \mathrm { x } 3 }$ on our new datasets and show results in Table 2. CIFAR-10 models are WideResNet-40-2 with training parameters from Hendrycks et al. (2019), ImageNet (Deng et al., 2009) models are ResNet-50 (He et al., 2016) with training parameters from Goyal et al. (2017). Models use default data augmentation as well as the augmentation being tested, except ImageNet color jittering is not used. All corruptions are applied in-memory, instead of loaded from a compressed file; this can affect results especially on high frequency corruptions. Given the evidence of overfitting from Section 4, we expect these methods to have worse error on the new corruptions. Indeed, every augmentation scheme performs worse, even when baseline improves slightly.
+
+Additionally, there are a few other suggestive patterns. First, intuitively broader augmentation schemes perform better: AugMix and AutoAugment degrade less than Patch Gaussian or ANT. Patch Gaussian in particular, which has been identified as perceptually similar to pixel-noise type corruptions alone, sees a particularly large drop in performance. Second, AutoAugment is the only tested augmentation scheme that was designed before the release of ImageNet-C, and it has the smallest performance drop, despite known overlaps with the brightness, contrast, and defocus blur corruptions in ImageNet-C. This suggests that having ImageNet-C on hand may make it difficult to avoid overfitting to. Finally, it is possible that blue noise sample is a failure mode of our distance: it both shares visual features with impulse noise and most data augmentations have low error on it. On other corruptions, the increase in error is even worse than the mean would suggest, and even broad augmentations like AugMix are no better than baseline on several individual corruptions.
+
+Despite this degradation, note that the data augmentation schemes, especially broad ones such as AugMix, still show meaningful improvement on ImageNet-C over baseline. What we want to emphasize is that care must be taken when comparing methods, since the degradation differs dramatically for different augmentation schemes. Moreover, it does not appear exact augmentationcorruption overlap is especially predictive of poor generalization: AutoAugment includes exact overlap with some ImageNet-C corruptions but loses the least error compared to ImageNet-C. This suggests it may not be sufficient to simply remove such augmentations from an augmentation scheme when testing on a corruption benchmark. Instead, it is important to understand more in-depth the interaction between an augmentation scheme and the tested corruptions. We hope that MSD and ImageNet-C may be an additional tools to help researchers understand why a robust augmentation scheme works and whether it may be expected to generalize to unknown corruptions.
+
+# 6 DISCUSSION
+
+Corruption robustness as a secondary learning task. We have provided evidence that data augmentation can overfit a corruption benchmark. To explore this further, consider an analogy to a regular learning problem. We may think of corruption robustness in the presence of data augmentation as a sort of secondary task layered on the primary classification task: the set of data augmentations is the training set, the set of corruptions is the test set, and the goal is to achieve invariance of the underlying primary task. In this language, the ‘datasets’ involved are quite small: ImageNet-C has only 15 corruption types, and several augmentation schemes composite only around 10 basic transforms. To mitigate overfitting, standard machine learning practice would dictate a training/validation/test set split; it is only the size and breadth of modern vision datasets that has allowed this to be neglected in certain cases recently. But the effective dataset size of a corruption robustness problem is tiny, so having a held-out test set that is not used during model development seems necessary. To emphasize, this is not a test set of the underlying classification task, for which generalization has been studied in Recht et al. (2018; 2019). Instead, it is a test set of corruption transforms themselves. This means there would be two sets of dissimilar transformations, both applied to the ImageNet validation set, that would act as a validation/test split on transforms2.
+
+Table 2: Test error for several data augmentation methods on CIFAR-10-C and ImageNet-10-C. Every method performs worse on these new datasets than on ImageNet-C or CIFAR-10-C. Example corruptions and descriptions of the abbreviations are given in Appendix E, and standard deviations for individual corruption are given in Table 5 in Appendix D.2. ‘Baseline’ refers to default augmentation only. \*ANT uses the single pre-trained model provided with the paper and has slightly different training parameters.   
+
+<table><tr><td rowspan="2">Aug</td><td rowspan="2">IN-C Err</td><td colspan="2">IN-C</td><td colspan="10">ImageNet-C Corruptions</td></tr><tr><td>Err</td><td>△IN-C</td><td>BSmpl Plsm</td><td></td><td>Ckbd</td><td>CSin</td><td>SFrq</td><td>Brwn</td><td>Prln</td><td>ISprk</td><td>Sprk</td><td>Rfrac</td></tr><tr><td>Baseline</td><td>58.2 ±0.5 57.7±0.2</td><td></td><td>-0.5</td><td>68.6</td><td>71.7</td><td>49.4</td><td>84.7</td><td>79.0</td><td>37.5</td><td>34.3</td><td>32.4</td><td>76.7</td><td>42.8</td></tr><tr><td>AA</td><td>54.8±0.2</td><td>55.7±0.3</td><td>+0.9</td><td>54.8</td><td>68.3</td><td>43.8</td><td>86.5</td><td>78.8</td><td>34.5</td><td>33.8</td><td>36.1</td><td>77.1</td><td>43.8</td></tr><tr><td>PG</td><td>48.1±0.2</td><td>：56.6±0.4</td><td>+8.5</td><td>60.3</td><td>74.1</td><td>48.5</td><td>82.1</td><td>76.7</td><td>38.9</td><td>34.6</td><td>32.1</td><td>76.5</td><td>42.1</td></tr><tr><td>ANT*</td><td>48.8</td><td>53.9</td><td>+5.1</td><td>35.8</td><td>75.5</td><td>56.9</td><td>76.4</td><td>63.7</td><td>41.0</td><td>35.2</td><td>35.0</td><td>76.1</td><td>43.3</td></tr><tr><td>AugMix</td><td>49.1±0.7</td><td>52.4±0.2</td><td>+3.3</td><td>43.2</td><td>72.2</td><td>46.1</td><td>76.3</td><td>67.4</td><td>38.8</td><td>32.4</td><td>32.3</td><td>76.4</td><td>39.2</td></tr><tr><td></td><td>C10-C</td><td colspan="2">C10-C</td><td></td><td></td><td></td><td>CIFAR-10-C</td><td></td><td></td><td>Corruptions</td><td></td><td></td><td></td></tr><tr><td>Aug</td><td>Err</td><td>Err</td><td>△C10-C</td><td>BSmpl Brwn</td><td></td><td>Ckbd</td><td>CBlur</td><td>ISprk</td><td>Line</td><td>P&amp;T</td><td>Rppl</td><td>Sprk</td><td>TCA</td></tr><tr><td>Baseline</td><td></td><td>27.0±0.6 27.1 ±0.5</td><td>+0.1</td><td>42.9</td><td>27.2</td><td>23.3</td><td>11.8</td><td>43.3</td><td>26.2</td><td>11.3</td><td>21.6</td><td>21.0</td><td>42.9</td></tr><tr><td>AA</td><td></td><td>19.4±0.2 21.0±0.4</td><td>+1.6</td><td>17.7</td><td>17.5</td><td>17.6</td><td>9.5</td><td>40.4</td><td>23.6</td><td>10.7</td><td>23.5</td><td>17.5</td><td>31.8</td></tr><tr><td>PG</td><td>17.0±0.32</td><td>23.8±0.5</td><td>+6.8</td><td>9.0</td><td>30.1</td><td>21.6</td><td>12.8</td><td>35.4</td><td>20.6</td><td>8.8</td><td>21.5</td><td>19.3</td><td>59.5</td></tr><tr><td>AugMix</td><td>11.1±0.2</td><td>16.0±0.3</td><td>+5.9</td><td>9.8</td><td>27.8</td><td>13.4</td><td>5.9</td><td>30.3</td><td>18.0</td><td>8.3</td><td>12.1</td><td>15.5</td><td>19.2</td></tr></table>
+
+Real-world corruption robustness. Recently, Hendrycks et al. (2020) and Taori et al. (2020) study how performance on corruption transforms generalizes to real-world corruptions and come to conflicting conclusions. Though we do not study real-world corruptions directly, we have proposed a mechanism that may explain the conflict: performance will generalize between transforms and real-world corruptions if they are perceptually similar, but will likely not if they are dissimilar. Since Hendrycks et al. (2020) and Taori et al. (2020) draw on different real-world and synthetic corruptions, it may simply be that the perceptual similarity between datasets differs in the two analyses. This also suggests a way to find additional corruption transforms that correlate with real-world corruptions: transforms should be sought that have maximal perceptual similarity with real-world corruptions.
+
+Generalization does occur. Finally, let us end on a positive note. Through our study of overfitting, we have encountered two features of data augmentation that may explain why it can be such a powerful tool for corruption robustness. First, within a class of perceptually similar transforms, generalization does occur. This means a single, simple data augmentation may confer robustness to many, much more complicated corruptions, as long as they share perceptual similarity. Second, the presence of dissimilar augmentations in an augmenation scheme often causes little to no loss in performance, as long as a similar augmentation is also present. We study this in a bit more detail in Appendix B by demonstrating that adding many dissimilar augmentations increases error much less than adding a few similar augmentations decreases it. Together, these features suggest broad augmentation schemes with many dissimilar augmentations may be capable of conferring robustness to a large class of unknown corruptions. More generally, we think data augmentation is a promising direction of study for corruption robustness, as long as significant care is taken to avoid overfitting.
+
+# REFERENCES
+
+Joan Bruna and Stéphane Mallat. Invariant scattering convolution networks. IEEE transactions on pattern analysis and machine intelligence, 35(8):1872–1886, 2013.
+
+Ekin D Cubuk, Barret Zoph, Dandelion Mané, Vijay Vasudevan, and Quoc V Le. AutoAugment: Learning augmentation strategies from data. In CVPR, 2019.
+
+Tri Dao, Albert Gu, Alexander J Ratner, Virginia Smith, Christopher De Sa, and Christopher Ré. A kernel theory of modern data augmentation. Proceedings of machine learning research, 97:1528, 2019.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. ImageNet: A large-scale hierarchical image database. In CVPR, 2009.
+
+Keyan Ding, Kede Ma, Shiqi Wang, and Eero P Simoncelli. Image quality assessment: Unifying structure and texture similarity. arXiv preprint arXiv:2004.07728, 2020.
+
+Samuel Dodge and Lina Karam. A study and comparison of human and deep learning recognition performance under visual distortions. In ICCCN, 2017.
+
+Robert Geirhos, Carlos RM Temme, Jonas Rauber, Heiko H Schütt, Matthias Bethge, and Felix A Wichmann. Generalisation in humans and deep neural networks. In NeurIPS, 2018.
+
+Robert Geirhos, Patricia Rubisch, Claudio Michaelis, Matthias Bethge, Felix A Wichmann, and Wieland Brendel. ImageNet-trained CNNs are biased towards texture; increasing shape bias improves accuracy and robustness. In ICLR, 2019.
+
+Simon J Gladman. Filterpedia, 2016. URL https://github.com/FlexMonkey/ Filterpedia.
+
+Priya Goyal, Piotr Dollár, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, Andrew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch SGD: Training ImageNet in 1 hour. arXiv preprint arXiv:1706.02677, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.
+
+Dan Hendrycks and Thomas Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. In ICLR, 2018.
+
+Dan Hendrycks, Norman Mu, Ekin Dogus Cubuk, Barret Zoph, Justin Gilmer, and Balaji Lakshminarayanan. AugMix: A simple data processing method to improve robustness and uncertainty. In ICLR, 2019.
+
+Dan Hendrycks, Steven Basart, Norman Mu, Saurav Kadavath, Frank Wang, Evan Dorundo, Rahul Desai, Tyler Zhu, Samyak Parajuli, Mike Guo, et al. The many faces of robustness: A critical analysis of out-of-distribution generalization. arXiv preprint arXiv:2006.16241, 2020.
+
+Jerry Huxtable. JH Labs Java Image Processing, 2006. URL http://www.jhlabs.com/ip/ filters/.
+
+Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009.
+
+Jungkyu Lee, Taeryun Won, and Kiho Hong. Compounding the performance improvements of assembled techniques in a convolutional neural network. arXiv preprint arXiv:2001.06268, 2020.
+
+Raphael Gontijo Lopes, Dong Yin, Ben Poole, Justin Gilmer, and Ekin D Cubuk. Improving robustness without sacrificing accuracy with Patch Gaussian augmentation. arXiv preprint arXiv:1906.02611, 2019.
+
+Ilija Radosavovic, Justin Johnson, Saining Xie, Wan-Yen Lo, and Piotr Dollár. On network design spaces for visual recognition. In ICCV, 2019.
+
+Ilija Radosavovic, Raj Prateek Kosaraju, Ross Girshick, Kaiming He, and Piotr Dollár. Designing network design spaces. In CVPR, 2020.
+
+Benjamin Recht, Rebecca Roelofs, Ludwig Schmidt, and Vaishaal Shankar. Do CIFAR-10 classifiers generalize to CIFAR-10? arXiv preprint arXiv:1806.00451, 2018.
+
+Benjamin Recht, Rebecca Roelofs, Ludwig Schmidt, and Vaishaal Shankar. Do ImageNet classifiers generalize to ImageNet? In ICML, 2019.
+
+Evgenia Rusak, Lukas Schott, Roland Zimmermann, Julian Bitterwolf, Oliver Bringmann, Matthias Bethge, and Wieland Brendel. A simple way to make neural networks robust against diverse image corruptions. arXiv preprint arXiv:2001.06057, 2020.
+
+Vaishaal Shankar, Achal Dave, Rebecca Roelofs, Deva Ramanan, Benjamin Recht, and Ludwig Schmidt. Do image classifiers generalize across time? arXiv preprint arXiv:1906.02168, 2019.
+
+Patrice Y Simard, Yann A LeCun, John S Denker, and Bernard Victorri. Transformation invariance in pattern recognition—tangent distance and tangent propagation. In Neural networks: tricks of the trade, pp. 239–274. Springer, 1998.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In ICLR, 2014.
+
+Rohan Taori, Achal Dave, Vaishaal Shankar, Nicholas Carlini, Benjamin Recht, and Ludwig Schmidt. Measuring robustness to natural distribution shifts in image classification. arXiv preprint arXiv:2007.00644, 2020.
+
+Sen Wu, Hongyang R Zhang, Gregory Valiant, and Christopher Ré. On the generalization effects of linear transformations in data augmentation. In ICML, 2020.
+
+Qizhe Xie, Minh-Thang Luong, Eduard Hovy, and Quoc V Le. Self-training with Noisy Student improves imagenet classification. In CVPR, 2020.
+
+Dong Yin, Raphael Gontijo Lopes, Jon Shlens, Ekin Dogus Cubuk, and Justin Gilmer. A Fourier perspective on model robustness in computer vision. In NeurIPS, 2019.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. In BMVC, 2016.
+
+Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. In ICLR, 2018a.
+
+Richard Zhang, Phillip Isola, Alexei A Efros, Eli Shechtman, and Oliver Wang. The unreasonable effectiveness of deep features as a perceptual metric. In CVPR, 2018b.
+
+Julian Zilly, Hannes Zilly, Oliver Richter, Roger Wattenhofer, Andrea Censi, and Emilio Frazzoli. The Frechet Distance of training and test distribution predicts the generalization gap. OpenReview preprint, 2019. URL https://openreview.net/forum?id $=$ SJgSflHKDr.
+
+![](images/88157e0bb24612850605b10463cda56c75d13ad3590802eec42ed55d4f7072b7.jpg)  
+Figure 7: (a) Patch Gaussian shows a low MMD distance on the noise corruptions and a high MMD distance on every other corruption, suggesting that it overfits the noise corruptions. (b) While AutoAugment contains contrast and brightness augmentations, it is broad enough that it doesn’t have a low MMD to these corruptions. Note that since brightness shows poor correlation for MSD, it is possible that in this case the MMD does not change for other reasons.
+
+# A ANALYZING OVERFITTING WITH MMD
+
+Overfitting can be analyzed in a bit more detail by using the MMD distance from Section 3. Recall that low MMD may be indicative of overfitting a single type of corruption, since it suggests a possible equivalence between the augmentation and corruption distributions. Broad augmentation schemes will likely have low MMD with no single corruption distribution, but narrow ones that overfit to a single corruption will have low MMD with it and high MMD for others. Figure 7 shows example MMD-error correlations. For Patch Guassian, MMD is low for the noise corruptions and high for everything else, while AutoAugment and AugMix, which are constructed out of many visually distinct transforms, show no strong correlation. We might then expect greater overfitting from Patch Gaussian.
+
+# B SAMPLING SIMILAR AUGMENTATIONS MORE FREQUENTLY GIVES MINOR PERFORMANCE IMPROVEMENTS
+
+Here we describe an alternative experiment that shows how the introduction of dissimilar augmentations affects corruption error. For a broad data augmentation scheme that provides robustness to many dissimilar corruptions, each corruption may only have a similar augmentation sampled some small fraction of the time. This small fraction of samples must be sufficient to yield good performance on each corruption to obtain robustness overall. We expect that this should be the case, since neural networks are often good at memorizing rare examples. Additionally, the toy problem in Figure 2 suggests that a large fraction of sampled augmentations may be dissimilar without significant loss in corruption error. Here we show the effect using a real augmentation scheme.
+
+We consider performance on CIFAR-10-C when training with AugMix augmentations (we do not use their Jensen-Shannon divergence loss, which gives additional improvements). However, instead of sampling directly from the AugMix distribution during training, we first sample $1 0 0 \mathrm { k }$ transforms and sort these transforms by their distance to the CIFAR-10-C corruptions. This sorting is done to evenly distribute the augmentations among the 75 (15 corruptions in 5 severities) individual corruptions; e.g. the first 75 augmentations in the list are the closest augmentation to each corruption. Then we take a fixed-size subset A of these transforms and train on augmentations sampled only from this subset using the training parameters from Hendrycks et al. (2019). We select A three different ways: randomly, taking the $| \mathbb { A } |$ closest augmentations, and taking the $| \mathbb { A } |$ farthest augmentations. We then measure the average corruption error on CIFAR-10-C and plot this error against $| \mathbb { A } |$ in Figure 8.
+
+![](images/5194aced9dfc73bda2ea53c7a3fe7d6975a441904adcaafb96f4c763305e59cb.jpg)  
+Figure 8: Average corruption error on ImageNet-C as a function the size of a fixed subset of AugMix augmentations. During training, augmentations are only sampled from the subset. The subset is chosen one of three ways: randomly, the most similar augmentations to ImageNet-C, or the least similar augmentations to ImageNet-C. Choosing similar corruptions improves error beyond AugMix, but not by as much that choosing dissimilar augmentations harms it.
+
+First, we note that for randomly sampled augmentations, A does not need to be very large to match AugMix in performance. Even though training on AugMix with our training parameters would normally would produce 5 million uniquely sampled augmentations, only around 1000 are needed to achieve equivalent performance. Training on the closest augmentations exceeds regular AugMix performance with only around 100 unique transforms, which acts as additional evidence that augmentation-corruption similarity correlates with corruption error. This gain in accuracy comes not from having access to better transformations, but from having more frequent access to them at training time. However, the gain is fairly mild at only around $1 \%$ , even though the best transformations are sampled all of the time instead of rarely. The gain from frequency is much less than the gain from having more similar augmentations, since choosing the most dissimilar augmentations gives around a $5 \%$ drop in accuracy. This suggests that it is a net positive to decrease the frequency of sampling similar augmentations in order to include augmentations similar to another set of corruptions: the gain in accuracy on the new corruption set will likely out weight the small loss in accuracy on the original set.
+
+# C MSD ABLATION
+
+# C.1 ARCHITECTURE CHOICE
+
+Here we provide evidence that changing the architecture of the feature extractor used in the definition of MSD does not have any qualitative effect on the correlation with corruption error. We use a version of VGG-19 with batch normalization that has been modified for CIFAR-10. Otherwise, all other parameters are chosen the same. We then repeat the experiment of Section 4. In Table 3 and Figure 9, we show that the qualitative results of this experiment are unchanged when using VGG-19-BN as the feature extractor.
+
+# C.2 PARAMETER DEPENDENCIES
+
+In calculating the feature space for transforms and MSD, it is necessary to both pick a number of images to average over and a number of corruptions to average over. In our experiments, we use 100 images and 100 corruptions. Here we provide evidence that these are reasonable choices for these parameters.
+
+![](images/47fb7461136abf8c8398c9a43b79372e38dd7831a48298a525ea4d4dabac3bcb.jpg)  
+Figure 9: MSD vs corruption test error for which MSD is calculated using VGG-19-BN as the architecture for feature extraction. The corruption error is still calculated using WideResNet-40-2. Compare to Figure 16 to see that the qualitative structure of the correlation is the regardless of which architecture is used for the feature extractor.
+
+Table 3: Spearman’s rank coefficient for the correlation between MSD and corruption error for two architectures in the feature extractor: WideResNet-40-2 and VGG-19-BN. While WideResNet has slightly better correlations overall, the relative behavior across corruptions remains the same for the two architectures.   
+
+<table><tr><td rowspan=1 colspan=1>Corruption</td><td rowspan=1 colspan=1>WRS</td><td rowspan=1 colspan=1>VGG</td><td rowspan=1 colspan=1>Corruption</td><td rowspan=1 colspan=1>WRS</td><td rowspan=1 colspan=1>VGG</td></tr><tr><td rowspan=8 colspan=1>GaussianNoiseShot NoiseImpulse NoiseMotion BlurDefocus BlurZoom NoiseGlass BlurBrightness</td><td rowspan=1 colspan=1>0.76</td><td rowspan=1 colspan=1>0.70</td><td rowspan=1 colspan=1>Fog</td><td rowspan=1 colspan=1>0.68</td><td rowspan=1 colspan=1>0.60</td></tr><tr><td rowspan=1 colspan=1>0.83</td><td rowspan=1 colspan=1>0.78</td><td rowspan=1 colspan=1>Frost</td><td rowspan=1 colspan=1>0.66</td><td rowspan=1 colspan=1>0.66</td></tr><tr><td rowspan=1 colspan=1>0.90</td><td rowspan=1 colspan=1>0.92</td><td rowspan=1 colspan=1>Snow</td><td rowspan=1 colspan=1>0.65</td><td rowspan=1 colspan=1>0.53</td></tr><tr><td rowspan=1 colspan=1>0.86</td><td rowspan=1 colspan=1>0.81</td><td rowspan=1 colspan=1>Contrast</td><td rowspan=1 colspan=1>0.66</td><td rowspan=1 colspan=1>0.65</td></tr><tr><td rowspan=1 colspan=1>0.83</td><td rowspan=1 colspan=1>0.78</td><td rowspan=1 colspan=1>Pixelate</td><td rowspan=1 colspan=1>0.35</td><td rowspan=1 colspan=1>0.29</td></tr><tr><td rowspan=1 colspan=1>0.77</td><td rowspan=1 colspan=1>0.68</td><td rowspan=1 colspan=1>JPEGCompression</td><td rowspan=1 colspan=1>0.33</td><td rowspan=1 colspan=1>0.26</td></tr><tr><td rowspan=1 colspan=1>0.69</td><td rowspan=1 colspan=1>0.66</td><td rowspan=1 colspan=1>Elastic Transform</td><td rowspan=1 colspan=1>0.77</td><td rowspan=1 colspan=1>0.74</td></tr><tr><td rowspan=1 colspan=1>0.27</td><td rowspan=1 colspan=4>0.08</td></tr></table>
+
+![](images/60b1423408618b539c886fb4a8aba40fa2369833151617cb9105b3c2f7dd91a0.jpg)  
+Figure 10: The standard deviation of the distance between an augmentation and a corruption center, taken over 100 resamplings of images and corruptions. The standard deviation is calculated as a percentage of the mean distance, then averaged over 100 augmentation-corruption pairs. At our choice of parameters, 100 images and 100 corruptions, the standard deviation is only around $5 \%$ of the distance. This is smaller than the feature size in the scatter plots of Figure 14
+
+To do so, we use the augmentation scheme from AugMix and corruptions distributions from CIFAR10-C to randomly sample 100 augmentation-corruption pairs. Then, for different samplings of a fixed number of images and sampled corruptions, we measure the augmentation-corruption distance in the transform feature space 100 times for each augmentation-corruption pair. We calculate the standard deviation of the distance as a percentage of the mean distance for each augmentation-corruption pair, and average this over pairs. The results are shown in Figure 10. For our choice of image and corruption number, the standard deviation in distance is only around $5 \%$ of the mean distance, which is smaller than the size of the features in the scatter plots in Figure 14.
+
+# D IMAGENET-C DETAILS
+
+# D.1 DATASET CONSTRUCTION DETAILS
+
+First, 30 new corruptions, examples of which are shown in Figure 11, are adapted from common image filters and noise distributions available online (Huxtable, 2006; Gladman, 2016). These corruptions are generated in 10 severities such that the image remains human interpretable at all severities and the distribution of errors on a baseline model roughly matches that of ImageNet-C.
+
+For each corruption, groups of 5 severities are generated that roughly match the average spread in error across severities in ImageNet-C on a baseline model. Seven of these groups are formed for each corruption, each with one of severity 3 through 8 as the center severity of the group of 5.
+
+A candidate dataset is a set of 10 groups of severities, each from a different corruption whose average corruption error on a baseline model is within $1 \%$ of ImageNet-C. This is necessary so that a relative decrease in error of data augmented models is normalized against a fixed baseline. Also, more distorted, harder transforms are likely farther away, so if this wasn’t fixed maximizing distance would likely just pick the hardest transforms in the highest severities. It was computationally infeasible to enumerate all candidate datasets, so they were sampled as follows. For each choice of 5 corruptions, one choice of severities was selected at random so that the average corruption error was within $1 \%$ of ImageNet-C, if it existed. Then random disjoint pairs of two sets of 5 were sampled to generate candidate datasets. $1 0 0 \mathrm { k }$ candidate datasets are sampled.
+
+Call the set of all corruption-severity pairs in a dataset $\mathbb { C }$ . The distance of a candidate dataset to ImageNet-C is defined as
+
+$$
+d ( \mathbb { C } _ { \mathrm { n e w } } , \mathbb { C } _ { \mathrm { I N - C } } ) = \mathbb { E } _ { c \sim \mathbb { C } _ { \mathrm { n e w } } } \left[ \operatorname* { m i n } _ { c ^ { \prime } \sim \mathbb { C } _ { \mathrm { I N - C } } } d _ { \mathrm { M M D } } ( c , c ^ { \prime } ) \right] ,
+$$
+
+where $d _ { \mathrm { M M D } }$ is defined in Section 3. The minimum helps assure that new corruptions are far from all ImageNet-C corruptions.
+
+This distance is calculated for all $1 0 0 \mathrm { k }$ sampled candidate datasets. For CIFAR-10, the same parameters described in Section 4.1 are used to calculate the distance. For ImageNet, the feature extractor is a ResNet-50 trained according to Goyal et al. (2017), except color jittering is not used as a data augmentation. Since there is much greater image diversity in ImageNet, we jointly sample 10k images and corruptions instead of independently sampling 100 images and 100 corruptions. Code for measuring distances and training models is based on pyCls (Radosavovic et al., 2019; 2020).
+
+Table 4: Comparison between performance on ImageNet/CIFAR10-C and ImageNet/CIFAR10-C. Standard deviations are over 10 runs for CIFAR-10 and 5 runs for ImageNet. \*ANT results use the pre-trained model provided with the paper and thus has slightly different training parameters and only one run.   
+
+<table><tr><td></td><td>IN-C</td><td colspan="2">IN-C</td></tr><tr><td>Aug</td><td>Err</td><td>Err</td><td>△IN-C</td></tr><tr><td>Baseline</td><td>58.2±0.5</td><td>57.7±0.2</td><td>-0.5</td></tr><tr><td>AA</td><td>54.8±0.2</td><td>55.7±0.3</td><td>+0.9</td></tr><tr><td>PG</td><td>48.1 ±0.2</td><td>56.6±0.4</td><td>+8.5</td></tr><tr><td>ANT*</td><td>48.8</td><td>53.9</td><td>+5.1</td></tr><tr><td>AugMix</td><td>49.1 ±0.7</td><td>52.4±0.2</td><td>+3.4</td></tr></table>
+
+<table><tr><td></td><td>C10-C</td><td colspan="2">C10-C</td></tr><tr><td>Aug</td><td>Err</td><td>Err</td><td>△C10-C</td></tr><tr><td>Baseline</td><td>27.0±0.6</td><td>27.1±0.5</td><td>+0.1</td></tr><tr><td>AA</td><td>19.4±0.2</td><td>21.0±0.4</td><td>+1.6</td></tr><tr><td>PG</td><td>17.0±0.4</td><td>23.8±0.5</td><td>+6.8</td></tr><tr><td>AugMix</td><td>11.1 ±0.2</td><td>16.0±0.3</td><td>+4.9</td></tr></table>
+
+Table 5: Breakdown of performance on individual corruptions in ImageNet/CIFAR10-C. Standard deviations are over 10 runs for CIFAR-10 and 5 runs for ImageNet. Examples and full names of each corruption are given in Appendix E. $\bf \Pi ^ { * }$ results use the pre-trained model provided with the paper and thus has slightly different training parameters and only one run.   
+
+<table><tr><td></td><td colspan="9">ImageNet-C Corruptions</td></tr><tr><td>Aug</td><td>BSmpl</td><td>Plsm</td><td>Ckbd</td><td>CSin</td><td>SFrq</td><td>Brwn</td><td>Prln</td><td>ISprk</td><td>Sprk Rfrac</td></tr><tr><td>Baseline</td><td>68.6±0.571.7±0.7 49.4±0.6 84.7±0.5 79.0±0.8 37.5±0.5 34.3±0.1 32.4±0.5 76.7±0.2 42.8±0.2</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>AA</td><td>54.8±0.7 68.3 ±0.7 43.8±1.0 86.5±0.6 78.8±0.9 34.5±0.8 33.8±0.2 36.1±1.0 77.1±1.2 43.8±0.2</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>PG</td><td>60.3±2.9</td><td>74.1±0.7 48.5±1.0 82.1±0.4 76.7±0.8 38.9±0.4 34.6 ±0.1 32.1±0.7 76.5±0.6 42.1 ±0.4</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>ANT*</td><td>35.8</td><td>75.5 56.9</td><td>76.4</td><td>63.7</td><td>41.0</td><td>35.2</td><td>35.0</td><td>76.1</td><td>43.3</td></tr><tr><td>AugMix</td><td colspan="9">43.2 ±0.8 72.2±0.4 46.1±0.2 76.3±0.3 67.4±0.7 38.8 ±0.5 32.4±0.1 32.3±0.2 76.4±0.4 39.2 ±0.2</td></tr><tr><td>Aug</td><td>BSmpl</td><td>Brwn</td><td>Ckbd</td><td>CIFAR-10-C Corruptions CBlur ISprk</td><td>Line</td><td>P&amp;T</td><td>Rppl</td><td>Sprk</td><td>TCA</td></tr><tr><td>Baseline</td><td>42.9±5.1</td><td>27.2±0.5</td><td>23.3±0.6</td><td>511.8±0.4 43.3±0.8 26.2±0.911.3±0.3 21.6±1.2 21.0±1.1 42.9±2.7</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>AA</td><td>17.7 ±1.7</td><td>17.5 ±0.5</td><td>17.6±0.5</td><td>9.5±0.3 40.4 ±1.5 23.6±0.7 10.7 ±0.3 23.5±0.5 17.5±0.7 31.8±1.8</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>PG</td><td>9.0±1.1 30.1±1.1 2</td><td></td><td></td><td>21.6±0.8 12.8±0.5 35.4±1.6 20.6±0.5 8.8±0.2 21.5±0.9 19.3±0.5 59.5 ±3.5</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>AugMix</td><td></td><td>9.8±0.7 27.8±1.3 13.4±0.4 5.9±0.2 30.3 ±0.7 18.0±0.6 8.3±0.2 12.1±0.4 15.5±0.5 19.2 ±1.0</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+The corruptions are then ranked according the their average contribution to the dataset distance. This entire procedure is repeated 10 times for CIFAR and 5 times for ImageNet, and corruption contributions are averaged. The top 10 are chosen to form the new dataset. Of candidate datasets made up of these 10 corruptions, the one with baseline error closest to ImageNet-C is chosen, though run-to-run fluctuation still causes some variation.
+
+# D.2 COMPLETE RESULTS
+
+Here we show average results comparing ImageNet/CIFAR-10-C to ImageNet/CIFAR-10-C in Table 4, and a breakdown of ImageNet/CIFAR-10-C results by corruption in Table 5.
+
+# E GLOSSARY OF TRANSFORMS
+
+This appendix contains examples of the augmentations and corruptions discussed in the text. Figure 11 shows the 30 new corruptions introduced in Section 5. These transforms are adapted from common online filters and noise sources (Huxtable, 2006; Gladman, 2016). They are designed to be human interpretable and cover a wide range transforms, including noise additions, obscuring, warping, and color shifts. The 10 transforms chosen for ImageNet-C are blue noise sample $( { \mathrm { B S m p l } } )$ ), plasma noise (Plsm), checkerboard (Ckbd), cocentric sine waves (CSin), single frequency (SFrq), brown noise (Brwn), perlin noise (Prln), inverse sparkle (ISprk), sparkles (Sprk), and caustic refraction (Rfrac). For CIFAR-10-C, there is blue noise sample (BSmpl), brown noise (Brwn), checkerboard (Ckbd), circular motion blur (CBlur), inverse sparkle (ISprk), lines (Line), pinch and twirl (P&T), ripple (Rppl), sparkles (Sprk), and transverse chromatic abberation (TCA).
+
+Figure 12 shows the 9 base transforms used to build augmentation schemes in the analysis. These are transforms from the Pillow Image Library that are often used as data augmentation. They have no exact overlap with either the corruptions of ImageNet-C or the new corruptions we introduce here. There are five geometric transforms (shear x/y, translate $\mathrm { x / y }$ , and rotate) and four color transforms (solarize, equalize, autocontrast, and posterize). We choose this particular set of augmentations following Hendrycks et al. (2019).
+
+Figure 13 shows example corruptions from the ImageNet-C benchmark (Hendrycks & Dietterich, 2018). They a grouped into four categories: noise (gaussian noise, shot noise, and impulse noise), blurs (motion blur, defocus blur, zoom blur, and glass blur), synthetic weather effects (brightness, fog, frost, and snow), and digital transforms (contrast, pixelate, JPEG compression, and elastic transform).
+
+# F SUPPLEMENTARY PLOTS
+
+This appendix contains additional plots for the analysis in the main text.
+
+Fig 14 shows a comparison of how MMD and MSD correlate with corruption error. MMD typically shows poor correlation, while MSD has strong correlation in all four categories of corruption.
+
+Figure 15 shows the correlation between MSD and corruption error for all 15 ImageNet-C corruptions, where $\rho$ is the Spearman rank correlation. Here, ‘AugMix’ refers to just their augmentation scheme, and not their Jensen-Shannon divergence loss, which gives additional improvements in corruption error. 12 of 15 corruptions have a Spearman rank correlation greater than 0.6. The remaining three that show poor correlations are ‘brightness’, ‘JPEG compression’, and ‘pixelate’.
+
+Figure 16 shows the average contribution of a new corruption to the dataset’s distance from ImageNetC. The top 10 large average contributions, colored in blue, are chosen as the corruptions to make up the dataset ImageNet-C.
+
+![](images/03ba5522c7dcf83bdbf6d98b1659d59df4126495639ab11d138c5ee051b6e3b8.jpg)  
+Figure 11: Examples of each corruption considered when building the dataset dissimilar to ImageNet-C. Base image $\circledcirc$ Sehee Park.
+
+![](images/ddac8a1449bc953aedc70707eede3a45f3eb5f2c49b06af80550150814f068fe.jpg)  
+Figure 12: The nine base transforms used as augmentations in analysis. Base image $\circledcirc$ Sehee Park.
+
+![](images/c513fe8d60f6af6b89702dab561694cda55bc30ca0ae2e91da0601111e359ce1.jpg)  
+Figure 13: Examples of the 15 corruptions in the ImageNet-C corruption benchmark (Hendrycks & Dietterich, 2018). Base image $\circledcirc$ Sehee Park.
+
+![](images/9f9bec02fddf1be925170f504d7f07bb0879b86bf73fbe6c09299d8bf7e8d2e6.jpg)  
+Figure 14: Example relationships between augmentation-corruption distance and corruption error for two distance scores, MMD and MSD. $\rho$ is the Spearman rank correlation. MMD between an augmentation and corruption distribution is not typically predictive of corruption error. MSD correlates well across all four categories of corruption in CIFAR-10-C.
+
+![](images/451a1032afcd36f0e4b21c77cdf97ef75326d437980b248a5c0ca98b2670d6f6.jpg)  
+Figure 15: See text for details.
+
+![](images/e98996ab0b60dc017a6bfe2bdcf366fddffcbab91e746e1a2ec02e60b161306e.jpg)  
+Figure 16: A corruption’s average contribution to the distance to ImageNet-C, as a fraction of the population’s standard deviation. The blue corruptions are those used to construct ImageNet-C.

parse/train/zbEupOtJFF/zbEupOtJFF_content_list.json

@@ -0,0 +1,1704 @@
+[
+    {
+        "type": "text",
+        "text": "ON INTERACTION BETWEEN AUGMENTATIONS AND CORRUPTIONS IN NATURAL CORRUPTION ROBUSTNESS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            101,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Invariance to a broad array of image corruptions, such as warping, noise, or color shifts, is an important aspect of building robust models in computer vision. Recently, several new data augmentations have been proposed that significantly improve performance on ImageNet-C, a benchmark of such corruptions. However, there is still a lack of basic understanding on the relationship between data augmentations and test-time corruptions. To this end, we develop a feature space for image transforms, and then use a new measure in this space between augmentations and corruptions called the Minimal Sample Distance to demonstrate there is a strong correlation between similarity and performance. We then investigate recent data augmentations and observe a significant degradation in corruption robustness when the test-time corruptions are sampled to be perceptually dissimilar from ImageNetC in this feature space. Our results suggest that test error can be improved by training on perceptually similar augmentations, and data augmentations may risk overfitting to the existing benchmark. We hope our results and tools will allow for more robust progress towards improving robustness to image corruptions. ",
+        "bbox": [
+            233,
+            267,
+            766,
+            474
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            502,
+            336,
+            518
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Robustness to distribution shift, i.e. when the train and test distributions differ, is an important feature of practical machine learning models. Among many forms of distribution shift, one particularly relevant category for computer vision are image corruptions. For example, test data may come from sources that differ from the training set in terms of lighting, camera quality, or other features. Postprocessing transforms, such as photo touch-up, image filters, or compression effects are commonplace in real-world data. Models developed using clean, undistorted inputs typically perform dramatically worse when confronted with these sorts of image corruptions (Hendrycks & Dietterich, 2018; Geirhos et al., 2018). The subject of corruption robustness has a long history in computer vision (Simard et al., 1998; Bruna & Mallat, 2013; Dodge & Karam, 2017) and recently has been studied actively with the release of benchmark datasets such as ImageNet-C (Hendrycks & Dietterich, 2018). ",
+        "bbox": [
+            174,
+            535,
+            825,
+            674
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One particular property of image corruptions is that they are low-level distortions in nature. Corruptions are transformations of an image that affect structural information such as colors, textures, or geometry (Ding et al., 2020) and are typically free of high-level semantics. Therefore, it is natural to expect that data augmentation techniques, which expand the training set with random low-level transformations, can help with learning robust models. Indeed, data augmentation has become a central technique in several recent methods (Hendrycks et al., 2019; Lopes et al., 2019; Rusak et al., 2020) that achieve large improvements on ImageNet-C and related benchmarks. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            777
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One caveat for data augmentation based approaches is the test corruptions are expected to be unknown at training time. If the corruptions are known, they may simply be applied to the training set as data augmentations to trivially adapt to the test distribution. Instead, an ideal robust model needs to be robust to any valid corruption, including ones unseen in any previous benchmark. Of course, in practice the robustness of a model can only be evaluated approximately by measuring its corruption error on a representative corruption benchmark. To avoid trivial adaptation to the benchmark, recent works manually exclude test corruptions from the training augmentations. However, with a toy experiment presented in Figure 1, we argue that this strategy alone might not be enough and that visually similar augmentation outputs and test corruptions can lead to significant benchmark improvements even if the exact corruption transformations are excluded. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/84e71a0fbb624a3c4a29129ffd3c4970caa55a8e04f5627c88cbc2fa0003d4c9.jpg",
+        "image_caption": [
+            "Figure 1: A toy experiment. We train multiple models on CIFAR-10 (Krizhevsky et al., 2009) using different augmentation schemes. Each scheme is based on a single basic image transformation type and enhanced by overlaying random instantiations of the transformation for each input image following Hendrycks et al. (2019). We compare these models on the CIFAR-10 test set corrupted by the motion blur, a corruption used in the ImageNet-C corruption benchmark Hendrycks & Dietterich (2018). None of the augmentation schemes contains motion blur; however, the models trained with geometric-based augmentations significantly outperform the baseline model trained on the clean images while color-based augmentations show no gains. We note the geometric augmentations can produce a result visually similar to a blur by overlaying copies of shifted images1. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            99,
+            787,
+            241
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This observation raises two important questions. One, how exactly does the similarity between train time augmentations and corruptions of the test set affect the error? And two, if the gains are due to the similarity, the improvements may not translate into better robustness to other possible corruptions, so do we ever risk overfitting existing corruption benchmarks using a new augmentation scheme? In this work, we take a step towards answering these questions, with the goal of better understanding the relationship between data augmentation and test-time corruptions. Using a feature space on image transforms and a new measure called Minimal Sample Distance (MSD) on this space, we are able to quantify the distance between augmentation schemes and classes of corruption transformation. With our approach, we empirically show an intuitive yet surprisingly overlooked finding: ",
+        "bbox": [
+            174,
+            391,
+            825,
+            516
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Augmentation-corruption perceptual similarity is a strong predictor of corruption error. ",
+        "text_level": 1,
+        "bbox": [
+            207,
+            530,
+            785,
+            545
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Based on this finding, we perform additional experiments to show that data augmentation aids corruption robustness by increasing perceptual similarity between a (possibly small) fraction of the training data and the test set. To further support our claims, we introduce a set of new corruption, called CIFAR/ImageNet-C, to test the degree to which common data augmentation methods overfit original the CIFAR/ImageNet-C. To choose these corruptions, we expand the set of natural corruptions and sample new corruptions that are far away from CIFAR/ImageNet-C in our feature space for measuring perceptual similarity. We then demonstrate that augmentation schemes designed specifically to improve robustness show significantly degraded performance on CIFAR/ImageNet-C. Some augmentation schemes still show some improvement over baseline, which suggests meaningful progress towards general corruption robustness is being made, but different augmentation schemes exhibit different degrees of generalization capability. As an implication, caution is needed for fair robustness evaluations when additional data augmentation is introduced. ",
+        "bbox": [
+            174,
+            551,
+            825,
+            717
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "These results suggest a major challenge that is often overlooked in the study of corruption robustness: overfitting indeed occurs. Since perceptual similarity can predict performance, for any fixed finite set of test corruptions, improvements on that set may generalize poorly to dissimilar corruptions. However, perceptual similarity is not expected to be the only interaction between augmentations and corruptions, so a proposed augmentation scheme’s degree of generalization capability may not be immediately clear. We hope that our results, together with new tools and benchmarks, will help researchers better understand why a given augmentation scheme has good corruption error and whether it should be expected to generalize to dissimilar corruptions. On the positive side, our experiments show that generalization does emerge within perceptually similar classes of transform, and that only a small fraction of sampled augmentations need to be similar to a given corruption. Section 6 discusses these points in more depth. ",
+        "bbox": [
+            174,
+            724,
+            825,
+            877
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            344,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Corruption robustness benchmarks and analysis. ImageNet-C (Hendrycks & Dietterich, 2018) is a corruption dataset often used as a benchmark in robustness studies. Other corruption datasets (Hendrycks et al., 2020; Shankar et al., 2019) collect corrupted images from real world sources and thus have a mixture of semantic distribution shifts and perceptual transforms. Corruption robustness differs from adversarial robustness (Szegedy et al., 2014), which seeks invariance to small, worst case distortions. One notable difference is that improving corruption robustness often slightly improves regular test error, instead of harming it. Yin et al. (2019) analyzes corruption robustness in the context of transforms’ frequency spectra; this can also influence corruption error independently from perceptual similarity. Dao et al. (2019); Wu et al. (2020) study the theory of data augmentation for regular test error. Hendrycks et al. (2020); Taori et al. (2020) study how the performance on synthetic corruption transforms generalizes to performance on corruption datasets collected from the real world. Here we do not address this issue directly but touch upon it in the discussion. ",
+        "bbox": [
+            174,
+            137,
+            825,
+            303
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Improving corruption robustness. Data augmentations designed to improve robustness include AugMix (Hendrycks et al., 2019), which composites common image transforms, Patch Gaussian (Lopes et al., 2019), which applies Gaussian noise in square patches, and ANT (Rusak et al., 2020), which augments with an adversarially learned noise distribution. AutoAugment (Cubuk et al., 2019) learns augmentation policies that optimize clean error but has since been shown to improve corruption error (Yin et al., 2019). Mixup (Zhang et al., 2018a) can improve robustness (Lee et al., 2020), but its label augmentation complicates the dependence on image augmentation. Stylized-ImageNet (Geirhos et al., 2019) can improve robustness, but it is at the cost of clean test error without additional fine-tuning. Noisy Student (Xie et al., 2020) and Assemble-ResNet (Lee et al., 2020) combine data augmentation with new models and training procedures and greatly enhance corruption robustness. ",
+        "bbox": [
+            174,
+            310,
+            825,
+            449
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 PERCEPTUAL SIMILARITY FOR AUGMENTATIONS AND CORRUPTIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            477,
+            772,
+            492
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "First, we study the importance of similarity between augmentations and corruptions for improving performance on those corruptions. To do so, we need a means to compare augmentations and corruptions. Both types of transforms are perceptual in nature, meaning they affect low-level image structure while leaving high-level semantic information intact, so we expect a good distance to be a measure of perceptual similarity. Then, we need to find the appropriate measure of distance between the augmentation and corruption distributions. We will argue below that distributional equivalence is not appropriate in the context of corruption robustness, and instead introduce the minimal sample distance, a simple measure that does capture a relevant sense of distribution distance. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            622
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Measuring similarity between perceptual transforms. We define a perceptual transform as a transform that acts on low-level image structure but not high-level semantic information. As such, we expect two transforms should be similar if their actions on this low-level structure are similar, independent of algorithmic or per-pixel differences between them. A closely related, well-studied problem is the perceptual similarity between images. A common approach is to train a neural network on a classification task and use intermediate layers as a feature space for measuring distances (Zhang et al., 2018b). Here we adapt this idea to instead obtain a feature space for measuring distances between perceptual transforms. ",
+        "bbox": [
+            174,
+            628,
+            825,
+            741
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We start with a feature extractor for images, which we call ${ \\hat { f } } ( x )$ . To train the model from which we will extract features, we assume access to a dataset $\\mathbb { D }$ of image label pairs $( x , y )$ associated with a classification task. The model should be trained using only default data augmentation for the task in question so that the feature extractor is independent of the transforms we will use it to study. In order to obtain a very simple measure, we will use just the last hidden layer of the network as a feature space. ",
+        "bbox": [
+            173,
+            748,
+            825,
+            833
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A perceptual transform $t ( x )$ may be encoded by applying it to all images in $\\mathbb { D }$ , encoding the transformed images, and averaging the features over these images. For efficiency, we find it sufficient to average over only a randomly sampled subset of images $\\mathbb { D } _ { S }$ in $\\mathbb { D }$ . We show in Appendix C this produces stable estimates for reasonable numbers of images. The random choice of images is a property of the feature extractor, and so remains fixed when encoding multiple transforms. This reduces variance when computing distances between two transforms. The transform feature extractor is given by $f ( t ) = \\mathbb { E } _ { x \\in \\mathbb { D } _ { S } } [ \\hat { f } ( t ( x ) ) ) ]$ . The perceptual similarity between an augmentation and a corruption can be taken as the $L _ { 2 }$ distance on this feature space $f$ . ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/e596ac11e5ef00289444e4750fe4f90004f6818481661de931311b0f825fd368.jpg",
+        "image_caption": [
+            "Figure 2: (a) Schematic comparison of MMD to MSD. MMD measure between distribution centers and is only small if the augmentation overlaps with a corruption. MSD measures to the nearest sampled point in set of samples (marked by a star), and is small even for broad distributions that overlap with multiple corruptions. (b) We test on images corruption with impulse noise, and train on images augmented with a mixture of impulse noise and motion blur. As the mixing fraction of impulse noise decreases, MMD between the augmentation and corruption grows linearly while MSD and error stay low until nearly $0 \\%$ mixing fraction. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            104,
+            810,
+            241
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            363,
+            823,
+            393
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Minimal sample distance. We now seek to compare the distribution of an augmentation scheme $p _ { a }$ to a distribution of a corruption benchmark $p _ { c }$ . A simple first guess would be to measure how close to equivalent the distributions are. Indeed, if the goal was to optimize error on a known corruption distribution, exact equivalence of distributions is the correct measure to minimize. But since the goal is robustness to general, unknown corruption distributions, a good augmentation scheme should be equivalent to no single corruption distribution. ",
+        "bbox": [
+            173,
+            400,
+            825,
+            484
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To illustrate this behavior, consider a toy problem where we have access to the corruption transforms at training time. A very rough, necessary but insufficient measure of distributional similarity is $d _ { \\mathrm { M M D } } ( \\bar { p _ { a } } , p _ { c } ) = | | \\mathbb { E } _ { a \\sim p _ { a } } [ f ( \\bar { a } ) ] - \\mathbb { E } _ { c \\sim p _ { c } } [ \\bar { f } ( c ) ] | |$ . This is the maximal mean discrepancy on a fixed, finite feature space, so for brevity we will refer to it as MMD. We still employ the featurization $f ( t )$ , since we are comparing transforms and not images, unlike in typical domain adaptation. Consider two corruption distributions, here impulse noise and motion blur, and an augmentation scheme that is a mixture of the two corruption distributions. Figure 2b shows that MMD between the augmentation and impulse noise corruption scales linearly with mixing fraction, but error on impulse noise remains low until the mixing fraction is almost $0 \\%$ impulse noise. This implies distributional similarity is a poor predictor corruption error. Indeed, in the context of corruption robustness, low $d _ { \\mathrm { M M D } }$ with any one corruption distribution is likely bad thing: it suggests the augmentation scheme overfits that one corruption distribution at expense of performance on other, dissimilar corruption distributions. ",
+        "bbox": [
+            174,
+            491,
+            825,
+            659
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our expectation for the behavior of the error in Figure 2b is that networks can often successfully memorize rare examples seen during training, so that only a very small fraction of sampled images need impulse noise augmentations to perform well on impulse noise corruptions. An appropriate distance should then measure how close augmentation samples can come to the corruption distribution, even if the density of those samples is low. We thus propose a very simple measure called minimal sample distance (MSD), which is just the perceptual similarity between an average corruption and the closest augmentation from a finite set of samples $\\mathbb { A } \\sim p _ { a }$ : ",
+        "bbox": [
+            174,
+            664,
+            825,
+            763
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d100412d48f92d363f175e7c6c1f7eec5eec6229d75e3372e63b491645c346b2.jpg",
+        "text": "$$\nd _ { \\mathrm { M S D } } ( p _ { a } , p _ { c } ) = \\operatorname* { m i n } _ { a \\in \\mathbb { A } \\sim p _ { a } } \\left| | f ( a ) - \\mathbb { E } _ { c \\sim p _ { c } } [ f ( c ) ] | \\right| .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            775,
+            658,
+            799
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A schematic comparison of MMD and MSD is shown in Figure 2a. While both MMD and MSD are small for an augmentation scheme that is distributionally similar to a corruption distribution, only MSD remains small for a broad distribution that occasionally produces samples near multiple corruption distributions. Figure 2b shows MSD, like test error, remains small for most mixing fractions in the toy problem described above. Note that the need for our measure to accommodate robustness to general, unknown corruption distributions has led it to be asymmetric, so it differs from more formal distance metrics that may be used to predict generalization error, such as the Wasserstein distance (Zilly et al., 2019). ",
+        "bbox": [
+            173,
+            810,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 PERCEPTUAL SIMILARITY IS PREDICTIVE OF CORRUPTION ERROR ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            748,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We are now equipped to measure how important this augmentation-corruption similarity is for corruption error. For a large number of augmentation schemes, we will measure both the MSD to a corruption distribution and the corruption error of a model trained with that scheme. We will find a correlation between MSD and corruption error, which provides evidence that networks can successfully generalize across perceptually similar transforms. Then, we will calculate the MSD for augmentation schemes in the literature that have been shown to improve error on corruption benchmarks. We will find a correlation between MSD and error here as well, which suggests the success of these models is in part explained by their perceptual similarity to the benchmark. This implies there may be a risk that the augmentation schemes overfit the benchmark, since we would not expect this improvement to transfer to a dissimilar corruption. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            272
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            290,
+            372,
+            304
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Corruptions. We use CIFAR-10-C (Hendrycks & Dietterich, 2018), which is a common benchmark used for studying corruption robustness. It consists of 15 corruptions, each further split into five different severities of transformation, applied to the CIFAR-10 test set. The 15 corruptions fall into four categories: per-pixel noise, blurring, synthetic weather effects, and digital transforms. We treat each corruption at each severity as a separate distribution for the sake of calculating MSD and error; however, for simplicity we average errors and distances over severity to present a single result per corruption. Examples of each corruption are shown in Figure 13 in Appendix E. ",
+        "bbox": [
+            174,
+            315,
+            825,
+            414
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Space of augmentation schemes. To build each sampled augmentation transform, we will composite a set of base augmentations. For base augmentations, we consider the nine common image transforms used in Hendrycks et al. (2019), shown in Figure 12 of Appendix E. There are five geometric transforms and four color transforms. By taking all subsets of these base augmentations, we obtain $2 ^ { 9 } \\ : = \\ : 5 1 2$ unique augmentation schemes, collectively called the augmentation powerset. Also following Hendrycks et al. (2019), we composite transforms in two ways: by applying one after another, or by applying them to copies of the image and then linearly superimposing the results. ",
+        "bbox": [
+            174,
+            421,
+            825,
+            518
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Computing similarity and corruption error. A WideResNet-40-2 (Zagoruyko & Komodakis, 2016) model is pre-trained on CIFAR-10 using default augmentation and training parameters from Hendrycks et al. (2019). WideResNet is a common baseline model used when studying data augmentation on CIFAR-10 (Hendrycks et al., 2019; Cubuk et al., 2019; Zhang et al., 2018a). Its last hidden layer is used as the feature space. For MSD, we average over 100 images, 100 corruptions, and minimize over 100k augmentations. We argue in Appendix C that these are reasonable choices. Images are from the training set and do not have default training augmentation. For corruption error evaluation, we also use a WideResNet-40-2 and the same training parameters. ",
+        "bbox": [
+            174,
+            525,
+            825,
+            637
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            654,
+            285,
+            667
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "MSD correlates with corruption error. First, we establish the correlation between MSD and corruption error on the augmentation powerset. Figure 3 shows the relationship between distance and corruption error for both MSD on four example corruption distributions. MSD shows strong correlation with corruption error across corruptions types in all four categories of CIFAR-10-C. In Figure 14 in Appendix F, we compare to MMD and confirm that MMD correlates poorly with corruption error, as expected. In particular, our expectation is that broad augmentation schemes with many base transforms produce samples similar to a larger set of corruptions, even if those samples occur less frequently. This leads to both lower MSD and lower corruption error but higher MMD. Additionally, the correlation between MSD and corruption error suggests that perceptual similarity is a predictor of corruption error. However, as shown in Table 1, most but not all corruptions show strong correlation between MSD and error: 12 of 15 have Spearman rank correlation greater than 0.6. A complete set of correlation plots is shown in Figure 15 in Appendix F. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            847
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "An example of perceptual similarity. Here we briefly illustrate the perceptual nature of the similarity measure, using an example with two base augmentations and two corruptions. The augmentation solarize and the corruption impulse noise both insert brightly colored pixels into the image, though in different ways. The augmentation $x$ translation and the corruption motion blur are both geometric transforms, and linear superpositions of $x$ translation are visually similar to blurring. Examples of these transforms are shown in Figure 12 and Figure 13 in Appendix E. Figure 4 shows MSD vs error where augmentation schemes that include solarize and x translation are colored. It is clear that including an augmentation greatly decreases MSD to its perceptually similar corruption, while having little effect on MSD to its perceptually dissimilar corruption. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/cff38999ee79985ab76f48948fcfd76a315812ed0f1e2aa2494ad55e4f30a882.jpg",
+        "image_caption": [
+            "Figure 3: Example relationships between MSD and corruption error for different corruptions. $\\rho$ is the Spearman rank correlation. MSD correlates well with error across all four categories of corruption in CIFAR-10-C. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            101,
+            805,
+            239
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/07121fe456bb975fbd8dd005cc5b2247ab41d12f70cb4547f135cb87369cb6c2.jpg",
+        "table_caption": [
+            "Table 1: Spearman’s rank coefficient for the correlation between MSD and corruption error. Correlations are high for most corruptions, including those in all four categories in ImageNet-C. However, brightness, pixelate, and JPEG compression show poor correlation. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Corruption</td><td>p</td><td>Corruption</td><td>p</td><td>Corruption</td><td>p</td></tr><tr><td>Gaussian Noise</td><td>0.76</td><td>Zoom Blur</td><td>0.77</td><td>Snow</td><td>0.65</td></tr><tr><td>Shot Noise</td><td>0.83</td><td>Glass Blur</td><td>0.69</td><td>Contrast</td><td>0.66</td></tr><tr><td>Impulse Noise</td><td>0.90</td><td>Brightness</td><td>0.27</td><td>Pixelate</td><td>0.35</td></tr><tr><td>Motion Blur</td><td>0.86</td><td>Fog</td><td>0.68</td><td>JPEG Compression</td><td>0.33</td></tr><tr><td>Defocus Blur</td><td>0.83</td><td>Frost</td><td>0.66</td><td>Elastic Transform</td><td>0.77</td></tr></table>",
+        "bbox": [
+            223,
+            344,
+            774,
+            428
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            454,
+            825,
+            511
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "MSD and corruption error in real augmentation methods. The augmentation powerset may be used as a baseline for comparing real data augmentation schemes. Figure 5 shows example MSD-error correlations for Patch Gaussian, AutoAugment, and Augmix, along with the cloud of augmentation powerset points. The real augmentation schemes follow the same general trend that lower error predicts lower MSD. A few intuitive correlations are also captured in Figure 5. Patch Gaussian has low MSD to corruptions with noise corruptions and to glass blur which introduces random pixel-level permutations as noise, and may be distributionally similar to the noise corruptions, as we argue in Appendix A. AutoAugment, which contains contrast and Gaussian blurring augmentations in its sub-policies, has low MSD with contrast and defocus blur. AugMix, which introduces fewer base augmentations that AutoAugment but composites them in ways that may produce perceptually new effects (such as blurring from superimposing translations), has low MSD with all corruptions. ",
+        "bbox": [
+            173,
+            518,
+            825,
+            671
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The fact that improved corruption error typically implies greater similarity suggests overfitting may be an issue in the study of corruption robustness. For two augmentation schemes compared on a fixed corruption benchmark, the one that is more perceptually similar to the corruptions may perform better, but also generalize to dissimilar corruptions worse. This perceptual similarity may be exact and explicit, such as between AutoAugment, which contains contrast augmentations, and the contrast corruption. But it may also be naively unexpected, such as the similarity between Patch Gaussian and glass blur (since glass blur shares similarity with the noise corruptions) or between AugMix and blurs (since superimposed translations are blur-like). Note, however, that perceptual similarity is not expected to be the only interaction between augmentations and corruptions (for instance, the frequency dependence of Yin et al. (2019) is another), and other interactions may or may not lead to good generalization. Thus, tools such as MSD help us determine why an augmentation scheme improves corruption error, so we can better analyze and understand if newly proposed methods will generalize beyond their tested benchmarks. In the next section, we test this generalization directly by finding corruptions that are dissimilar to ImageNet-C. ",
+        "bbox": [
+            173,
+            678,
+            823,
+            707
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/02fd16f0dedb0053fc55c0029a2ecafc93203d63623c1b5c8f2a0feda8e12ac0.jpg",
+        "image_caption": [
+            "Figure 4: Example relationships between base augmentations and corruptions. Including ‘solarize’ reduces MSD on the perceptually similar impulse noise corruption, while including $x$ translation reduces MSD on the perceptually similar motion blur corruption. MSD is not decreased for dissimilar augmentation-corruption pairs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            734,
+            808,
+            872
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/54a9db239d5963c947e3a2cd15f213da3b18209b52079c326778ba21d2426ae4.jpg",
+        "image_caption": [
+            "Figure 5: Example correlations for augmentation schemes from the literature. Patch Gaussian is similar to noise, while AutoAugment is similar to contrast and blur, as expected from their formulation. Glass blur acts more like a noise corruption than a blur for these augmentation schemes, likely because it randomly permuting pixels. \\*AugMix here refers to just the augmentation distribution in Hendrycks et al. (2019), not the proposed Jensen-Shannon divergence loss, which gives additional improvements in corruption error. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            99,
+            797,
+            251
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            356,
+            825,
+            522
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 IMAGENET-C: BENCHMARKING WITH DISSIMILAR CORRUPTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            542,
+            746,
+            560
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We now introduce a set of corruptions, called ImageNet-C, that are perceptually dissimilar to ImageNet-C in our transform feature space and will show that several augmentation schemes have degraded performance on the new dataset, suggesting that they have indeed overfit ImageNet-C to at least some degree. We emphasize that the dataset selection method does not involve any augmentation scheme beyond the default one used to train the feature extractor and was fixed before we looked at the results for different augmentations, so there should be no inadvertent adversarial selection against the augmentation schemes. ",
+        "bbox": [
+            174,
+            575,
+            825,
+            672
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Dataset construction. An overview of the dataset construction is presented here, with specific details described in Appendix D.1. We construct a set of 30 new corruptions types in 10 severities, from which the 10 most dissimilar corruptions types will be chosen. These corruptions are adapted from common filters and noise distributions available online (Huxtable, 2006; Gladman, 2016) and are designed to produce human interpretable images. The transforms include warps, blurs, color distortions, noise additions, and obscuring effects. Examples are shown in Appendix E. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            763
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To assure that the new dataset is no harder than ImageNet-C, we restrict the average corruption error of the new dataset to be similar to that of ImageNet-C for default augmentation. We then generate many potential datasets and measure the average shift in distance to ImageNet-C that each corruption contributes, shown in Figure 16 in Appendix F. Note that while MSD was used to establish a correlation between perceptual similarity and error for augmentations and corruptions, here we are comparing corruptions to other corruptions and thus use MMD as the measure of distance in our transform feature space. Some generally intuitive results are recovered. First, scatter and blue noise, which are conceptually similar to ImageNet-C’s glass blur and gaussian noise corruptions, consistently lead to more similarity with ImageNet-C. Second, lower-frequency noise distortions tend to be included in more dissimilar datasets, possibly in contrast to ImageNet-C’s high frequency pixel noise. However, blue noise sample, which shares some visual similarities with impulse noise, also leads to larger distances. ImageNet-C then consists of the 10 corruptions types with the largest average shift in distance. Like ImageNet-C, each is included in five different severities, with severities chosen so that the average error matches ImageNet-C for default augmentation. Example transforms from ImageNet-C and CIFAR-10-C are shown in Figure 6. ",
+        "bbox": [
+            174,
+            771,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/d64e851ccfd50809d3263248bbf0a2843fcb50fddd88c10ad5e4542378997fad.jpg",
+        "image_caption": [
+            "Figure 6: Example CIFAR-10-C and ImageNet-C corruptions. While still human interpretable, new corruptions are sampled to be dissimilar from CIFAR-10/ImageNet-C. Base images $\\circledcirc$ Sehee Park and Chenxu Han. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            99,
+            820,
+            220
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            290,
+            825,
+            345
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results. We test AutoAugment, Patch Gaussian, AugMix, and $\\mathbf { A N T } ^ { 3 \\mathrm { x } 3 }$ on our new datasets and show results in Table 2. CIFAR-10 models are WideResNet-40-2 with training parameters from Hendrycks et al. (2019), ImageNet (Deng et al., 2009) models are ResNet-50 (He et al., 2016) with training parameters from Goyal et al. (2017). Models use default data augmentation as well as the augmentation being tested, except ImageNet color jittering is not used. All corruptions are applied in-memory, instead of loaded from a compressed file; this can affect results especially on high frequency corruptions. Given the evidence of overfitting from Section 4, we expect these methods to have worse error on the new corruptions. Indeed, every augmentation scheme performs worse, even when baseline improves slightly. ",
+        "bbox": [
+            174,
+            353,
+            825,
+            479
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Additionally, there are a few other suggestive patterns. First, intuitively broader augmentation schemes perform better: AugMix and AutoAugment degrade less than Patch Gaussian or ANT. Patch Gaussian in particular, which has been identified as perceptually similar to pixel-noise type corruptions alone, sees a particularly large drop in performance. Second, AutoAugment is the only tested augmentation scheme that was designed before the release of ImageNet-C, and it has the smallest performance drop, despite known overlaps with the brightness, contrast, and defocus blur corruptions in ImageNet-C. This suggests that having ImageNet-C on hand may make it difficult to avoid overfitting to. Finally, it is possible that blue noise sample is a failure mode of our distance: it both shares visual features with impulse noise and most data augmentations have low error on it. On other corruptions, the increase in error is even worse than the mean would suggest, and even broad augmentations like AugMix are no better than baseline on several individual corruptions. ",
+        "bbox": [
+            174,
+            486,
+            825,
+            637
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Despite this degradation, note that the data augmentation schemes, especially broad ones such as AugMix, still show meaningful improvement on ImageNet-C over baseline. What we want to emphasize is that care must be taken when comparing methods, since the degradation differs dramatically for different augmentation schemes. Moreover, it does not appear exact augmentationcorruption overlap is especially predictive of poor generalization: AutoAugment includes exact overlap with some ImageNet-C corruptions but loses the least error compared to ImageNet-C. This suggests it may not be sufficient to simply remove such augmentations from an augmentation scheme when testing on a corruption benchmark. Instead, it is important to understand more in-depth the interaction between an augmentation scheme and the tested corruptions. We hope that MSD and ImageNet-C may be an additional tools to help researchers understand why a robust augmentation scheme works and whether it may be expected to generalize to unknown corruptions. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            797
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            821,
+            310,
+            837
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Corruption robustness as a secondary learning task. We have provided evidence that data augmentation can overfit a corruption benchmark. To explore this further, consider an analogy to a regular learning problem. We may think of corruption robustness in the presence of data augmentation as a sort of secondary task layered on the primary classification task: the set of data augmentations is the training set, the set of corruptions is the test set, and the goal is to achieve invariance of the underlying primary task. In this language, the ‘datasets’ involved are quite small: ImageNet-C has only 15 corruption types, and several augmentation schemes composite only around 10 basic transforms. To mitigate overfitting, standard machine learning practice would dictate a training/validation/test set split; it is only the size and breadth of modern vision datasets that has allowed this to be neglected in certain cases recently. But the effective dataset size of a corruption robustness problem is tiny, so having a held-out test set that is not used during model development seems necessary. To emphasize, this is not a test set of the underlying classification task, for which generalization has been studied in Recht et al. (2018; 2019). Instead, it is a test set of corruption transforms themselves. This means there would be two sets of dissimilar transformations, both applied to the ImageNet validation set, that would act as a validation/test split on transforms2. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/bd6b34b81d8c9354cc4603833cb48d6a2ad2a61afb3b7a5dd0ac4cb0b2365da3.jpg",
+        "table_caption": [
+            "Table 2: Test error for several data augmentation methods on CIFAR-10-C and ImageNet-10-C. Every method performs worse on these new datasets than on ImageNet-C or CIFAR-10-C. Example corruptions and descriptions of the abbreviations are given in Appendix E, and standard deviations for individual corruption are given in Table 5 in Appendix D.2. ‘Baseline’ refers to default augmentation only. \\*ANT uses the single pre-trained model provided with the paper and has slightly different training parameters. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Aug</td><td rowspan=\"2\">IN-C Err</td><td colspan=\"2\">IN-C</td><td colspan=\"10\">ImageNet-C Corruptions</td></tr><tr><td>Err</td><td>△IN-C</td><td>BSmpl Plsm</td><td></td><td>Ckbd</td><td>CSin</td><td>SFrq</td><td>Brwn</td><td>Prln</td><td>ISprk</td><td>Sprk</td><td>Rfrac</td></tr><tr><td>Baseline</td><td>58.2 ±0.5 57.7±0.2</td><td></td><td>-0.5</td><td>68.6</td><td>71.7</td><td>49.4</td><td>84.7</td><td>79.0</td><td>37.5</td><td>34.3</td><td>32.4</td><td>76.7</td><td>42.8</td></tr><tr><td>AA</td><td>54.8±0.2</td><td>55.7±0.3</td><td>+0.9</td><td>54.8</td><td>68.3</td><td>43.8</td><td>86.5</td><td>78.8</td><td>34.5</td><td>33.8</td><td>36.1</td><td>77.1</td><td>43.8</td></tr><tr><td>PG</td><td>48.1±0.2</td><td>：56.6±0.4</td><td>+8.5</td><td>60.3</td><td>74.1</td><td>48.5</td><td>82.1</td><td>76.7</td><td>38.9</td><td>34.6</td><td>32.1</td><td>76.5</td><td>42.1</td></tr><tr><td>ANT*</td><td>48.8</td><td>53.9</td><td>+5.1</td><td>35.8</td><td>75.5</td><td>56.9</td><td>76.4</td><td>63.7</td><td>41.0</td><td>35.2</td><td>35.0</td><td>76.1</td><td>43.3</td></tr><tr><td>AugMix</td><td>49.1±0.7</td><td>52.4±0.2</td><td>+3.3</td><td>43.2</td><td>72.2</td><td>46.1</td><td>76.3</td><td>67.4</td><td>38.8</td><td>32.4</td><td>32.3</td><td>76.4</td><td>39.2</td></tr><tr><td></td><td>C10-C</td><td colspan=\"2\">C10-C</td><td></td><td></td><td></td><td>CIFAR-10-C</td><td></td><td></td><td>Corruptions</td><td></td><td></td><td></td></tr><tr><td>Aug</td><td>Err</td><td>Err</td><td>△C10-C</td><td>BSmpl Brwn</td><td></td><td>Ckbd</td><td>CBlur</td><td>ISprk</td><td>Line</td><td>P&amp;T</td><td>Rppl</td><td>Sprk</td><td>TCA</td></tr><tr><td>Baseline</td><td></td><td>27.0±0.6 27.1 ±0.5</td><td>+0.1</td><td>42.9</td><td>27.2</td><td>23.3</td><td>11.8</td><td>43.3</td><td>26.2</td><td>11.3</td><td>21.6</td><td>21.0</td><td>42.9</td></tr><tr><td>AA</td><td></td><td>19.4±0.2 21.0±0.4</td><td>+1.6</td><td>17.7</td><td>17.5</td><td>17.6</td><td>9.5</td><td>40.4</td><td>23.6</td><td>10.7</td><td>23.5</td><td>17.5</td><td>31.8</td></tr><tr><td>PG</td><td>17.0±0.32</td><td>23.8±0.5</td><td>+6.8</td><td>9.0</td><td>30.1</td><td>21.6</td><td>12.8</td><td>35.4</td><td>20.6</td><td>8.8</td><td>21.5</td><td>19.3</td><td>59.5</td></tr><tr><td>AugMix</td><td>11.1±0.2</td><td>16.0±0.3</td><td>+5.9</td><td>9.8</td><td>27.8</td><td>13.4</td><td>5.9</td><td>30.3</td><td>18.0</td><td>8.3</td><td>12.1</td><td>15.5</td><td>19.2</td></tr></table>",
+        "bbox": [
+            176,
+            178,
+            821,
+            352
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            398,
+            825,
+            537
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Real-world corruption robustness. Recently, Hendrycks et al. (2020) and Taori et al. (2020) study how performance on corruption transforms generalizes to real-world corruptions and come to conflicting conclusions. Though we do not study real-world corruptions directly, we have proposed a mechanism that may explain the conflict: performance will generalize between transforms and real-world corruptions if they are perceptually similar, but will likely not if they are dissimilar. Since Hendrycks et al. (2020) and Taori et al. (2020) draw on different real-world and synthetic corruptions, it may simply be that the perceptual similarity between datasets differs in the two analyses. This also suggests a way to find additional corruption transforms that correlate with real-world corruptions: transforms should be sought that have maximal perceptual similarity with real-world corruptions. ",
+        "bbox": [
+            174,
+            544,
+            825,
+            670
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Generalization does occur. Finally, let us end on a positive note. Through our study of overfitting, we have encountered two features of data augmentation that may explain why it can be such a powerful tool for corruption robustness. First, within a class of perceptually similar transforms, generalization does occur. This means a single, simple data augmentation may confer robustness to many, much more complicated corruptions, as long as they share perceptual similarity. Second, the presence of dissimilar augmentations in an augmenation scheme often causes little to no loss in performance, as long as a similar augmentation is also present. We study this in a bit more detail in Appendix B by demonstrating that adding many dissimilar augmentations increases error much less than adding a few similar augmentations decreases it. Together, these features suggest broad augmentation schemes with many dissimilar augmentations may be capable of conferring robustness to a large class of unknown corruptions. More generally, we think data augmentation is a promising direction of study for corruption robustness, as long as significant care is taken to avoid overfitting. ",
+        "bbox": [
+            173,
+            676,
+            826,
+            843
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Joan Bruna and Stéphane Mallat. Invariant scattering convolution networks. IEEE transactions on pattern analysis and machine intelligence, 35(8):1872–1886, 2013. ",
+        "bbox": [
+            171,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ekin D Cubuk, Barret Zoph, Dandelion Mané, Vijay Vasudevan, and Quoc V Le. AutoAugment: Learning augmentation strategies from data. In CVPR, 2019. ",
+        "bbox": [
+            171,
+            165,
+            825,
+            194
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tri Dao, Albert Gu, Alexander J Ratner, Virginia Smith, Christopher De Sa, and Christopher Ré. A kernel theory of modern data augmentation. Proceedings of machine learning research, 97:1528, 2019. ",
+        "bbox": [
+            174,
+            203,
+            825,
+            246
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. ImageNet: A large-scale hierarchical image database. In CVPR, 2009. ",
+        "bbox": [
+            174,
+            256,
+            821,
+            286
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Keyan Ding, Kede Ma, Shiqi Wang, and Eero P Simoncelli. Image quality assessment: Unifying structure and texture similarity. arXiv preprint arXiv:2004.07728, 2020. ",
+        "bbox": [
+            174,
+            295,
+            823,
+            324
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Samuel Dodge and Lina Karam. A study and comparison of human and deep learning recognition performance under visual distortions. In ICCCN, 2017. ",
+        "bbox": [
+            173,
+            334,
+            823,
+            363
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Robert Geirhos, Carlos RM Temme, Jonas Rauber, Heiko H Schütt, Matthias Bethge, and Felix A Wichmann. Generalisation in humans and deep neural networks. In NeurIPS, 2018. ",
+        "bbox": [
+            174,
+            372,
+            825,
+            402
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Robert Geirhos, Patricia Rubisch, Claudio Michaelis, Matthias Bethge, Felix A Wichmann, and Wieland Brendel. ImageNet-trained CNNs are biased towards texture; increasing shape bias improves accuracy and robustness. In ICLR, 2019. ",
+        "bbox": [
+            174,
+            411,
+            826,
+            454
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Simon J Gladman. Filterpedia, 2016. URL https://github.com/FlexMonkey/ Filterpedia. ",
+        "bbox": [
+            171,
+            464,
+            825,
+            494
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Priya Goyal, Piotr Dollár, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, Andrew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch SGD: Training ImageNet in 1 hour. arXiv preprint arXiv:1706.02677, 2017. ",
+        "bbox": [
+            178,
+            503,
+            823,
+            547
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016. ",
+        "bbox": [
+            173,
+            556,
+            823,
+            585
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks and Thomas Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. In ICLR, 2018. ",
+        "bbox": [
+            176,
+            594,
+            823,
+            625
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks, Norman Mu, Ekin Dogus Cubuk, Barret Zoph, Justin Gilmer, and Balaji Lakshminarayanan. AugMix: A simple data processing method to improve robustness and uncertainty. In ICLR, 2019. ",
+        "bbox": [
+            174,
+            633,
+            826,
+            676
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks, Steven Basart, Norman Mu, Saurav Kadavath, Frank Wang, Evan Dorundo, Rahul Desai, Tyler Zhu, Samyak Parajuli, Mike Guo, et al. The many faces of robustness: A critical analysis of out-of-distribution generalization. arXiv preprint arXiv:2006.16241, 2020. ",
+        "bbox": [
+            174,
+            686,
+            826,
+            731
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jerry Huxtable. JH Labs Java Image Processing, 2006. URL http://www.jhlabs.com/ip/ filters/. ",
+        "bbox": [
+            171,
+            739,
+            823,
+            768
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            173,
+            777,
+            826,
+            794
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jungkyu Lee, Taeryun Won, and Kiho Hong. Compounding the performance improvements of assembled techniques in a convolutional neural network. arXiv preprint arXiv:2001.06268, 2020. ",
+        "bbox": [
+            169,
+            803,
+            825,
+            833
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Raphael Gontijo Lopes, Dong Yin, Ben Poole, Justin Gilmer, and Ekin D Cubuk. Improving robustness without sacrificing accuracy with Patch Gaussian augmentation. arXiv preprint arXiv:1906.02611, 2019. ",
+        "bbox": [
+            173,
+            842,
+            825,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ilija Radosavovic, Justin Johnson, Saining Xie, Wan-Yen Lo, and Piotr Dollár. On network design spaces for visual recognition. In ICCV, 2019. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ilija Radosavovic, Raj Prateek Kosaraju, Ross Girshick, Kaiming He, and Piotr Dollár. Designing network design spaces. In CVPR, 2020. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Benjamin Recht, Rebecca Roelofs, Ludwig Schmidt, and Vaishaal Shankar. Do CIFAR-10 classifiers generalize to CIFAR-10? arXiv preprint arXiv:1806.00451, 2018. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Benjamin Recht, Rebecca Roelofs, Ludwig Schmidt, and Vaishaal Shankar. Do ImageNet classifiers generalize to ImageNet? In ICML, 2019. ",
+        "bbox": [
+            174,
+            178,
+            823,
+            208
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Evgenia Rusak, Lukas Schott, Roland Zimmermann, Julian Bitterwolf, Oliver Bringmann, Matthias Bethge, and Wieland Brendel. A simple way to make neural networks robust against diverse image corruptions. arXiv preprint arXiv:2001.06057, 2020. ",
+        "bbox": [
+            176,
+            215,
+            823,
+            260
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Vaishaal Shankar, Achal Dave, Rebecca Roelofs, Deva Ramanan, Benjamin Recht, and Ludwig Schmidt. Do image classifiers generalize across time? arXiv preprint arXiv:1906.02168, 2019. ",
+        "bbox": [
+            173,
+            267,
+            825,
+            297
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Patrice Y Simard, Yann A LeCun, John S Denker, and Bernard Victorri. Transformation invariance in pattern recognition—tangent distance and tangent propagation. In Neural networks: tricks of the trade, pp. 239–274. Springer, 1998. ",
+        "bbox": [
+            176,
+            305,
+            821,
+            349
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In ICLR, 2014. ",
+        "bbox": [
+            173,
+            357,
+            823,
+            387
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rohan Taori, Achal Dave, Vaishaal Shankar, Nicholas Carlini, Benjamin Recht, and Ludwig Schmidt. Measuring robustness to natural distribution shifts in image classification. arXiv preprint arXiv:2007.00644, 2020. ",
+        "bbox": [
+            174,
+            395,
+            823,
+            438
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sen Wu, Hongyang R Zhang, Gregory Valiant, and Christopher Ré. On the generalization effects of linear transformations in data augmentation. In ICML, 2020. ",
+        "bbox": [
+            173,
+            446,
+            823,
+            476
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Qizhe Xie, Minh-Thang Luong, Eduard Hovy, and Quoc V Le. Self-training with Noisy Student improves imagenet classification. In CVPR, 2020. ",
+        "bbox": [
+            173,
+            484,
+            823,
+            513
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dong Yin, Raphael Gontijo Lopes, Jon Shlens, Ekin Dogus Cubuk, and Justin Gilmer. A Fourier perspective on model robustness in computer vision. In NeurIPS, 2019. ",
+        "bbox": [
+            173,
+            522,
+            825,
+            551
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. In BMVC, 2016. ",
+        "bbox": [
+            174,
+            559,
+            728,
+            575
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. In ICLR, 2018a. ",
+        "bbox": [
+            173,
+            583,
+            820,
+            613
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Richard Zhang, Phillip Isola, Alexei A Efros, Eli Shechtman, and Oliver Wang. The unreasonable effectiveness of deep features as a perceptual metric. In CVPR, 2018b. ",
+        "bbox": [
+            171,
+            621,
+            823,
+            651
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Julian Zilly, Hannes Zilly, Oliver Richter, Roger Wattenhofer, Andrea Censi, and Emilio Frazzoli. The Frechet Distance of training and test distribution predicts the generalization gap. OpenReview preprint, 2019. URL https://openreview.net/forum?id $=$ SJgSflHKDr. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            702
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/88157e0bb24612850605b10463cda56c75d13ad3590802eec42ed55d4f7072b7.jpg",
+        "image_caption": [
+            "Figure 7: (a) Patch Gaussian shows a low MMD distance on the noise corruptions and a high MMD distance on every other corruption, suggesting that it overfits the noise corruptions. (b) While AutoAugment contains contrast and brightness augmentations, it is broad enough that it doesn’t have a low MMD to these corruptions. Note that since brightness shows poor correlation for MSD, it is possible that in this case the MMD does not change for other reasons. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            101,
+            800,
+            428
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A ANALYZING OVERFITTING WITH MMD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            531,
+            534,
+            547
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Overfitting can be analyzed in a bit more detail by using the MMD distance from Section 3. Recall that low MMD may be indicative of overfitting a single type of corruption, since it suggests a possible equivalence between the augmentation and corruption distributions. Broad augmentation schemes will likely have low MMD with no single corruption distribution, but narrow ones that overfit to a single corruption will have low MMD with it and high MMD for others. Figure 7 shows example MMD-error correlations. For Patch Guassian, MMD is low for the noise corruptions and high for everything else, while AutoAugment and AugMix, which are constructed out of many visually distinct transforms, show no strong correlation. We might then expect greater overfitting from Patch Gaussian. ",
+        "bbox": [
+            173,
+            564,
+            825,
+            689
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B SAMPLING SIMILAR AUGMENTATIONS MORE FREQUENTLY GIVES MINOR PERFORMANCE IMPROVEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            714,
+            808,
+            746
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Here we describe an alternative experiment that shows how the introduction of dissimilar augmentations affects corruption error. For a broad data augmentation scheme that provides robustness to many dissimilar corruptions, each corruption may only have a similar augmentation sampled some small fraction of the time. This small fraction of samples must be sufficient to yield good performance on each corruption to obtain robustness overall. We expect that this should be the case, since neural networks are often good at memorizing rare examples. Additionally, the toy problem in Figure 2 suggests that a large fraction of sampled augmentations may be dissimilar without significant loss in corruption error. Here we show the effect using a real augmentation scheme. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            875
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We consider performance on CIFAR-10-C when training with AugMix augmentations (we do not use their Jensen-Shannon divergence loss, which gives additional improvements). However, instead of sampling directly from the AugMix distribution during training, we first sample $1 0 0 \\mathrm { k }$ transforms and sort these transforms by their distance to the CIFAR-10-C corruptions. This sorting is done to evenly distribute the augmentations among the 75 (15 corruptions in 5 severities) individual corruptions; e.g. the first 75 augmentations in the list are the closest augmentation to each corruption. Then we take a fixed-size subset A of these transforms and train on augmentations sampled only from this subset using the training parameters from Hendrycks et al. (2019). We select A three different ways: randomly, taking the $| \\mathbb { A } |$ closest augmentations, and taking the $| \\mathbb { A } |$ farthest augmentations. We then measure the average corruption error on CIFAR-10-C and plot this error against $| \\mathbb { A } |$ in Figure 8. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/5194aced9dfc73bda2ea53c7a3fe7d6975a441904adcaafb96f4c763305e59cb.jpg",
+        "image_caption": [
+            "Figure 8: Average corruption error on ImageNet-C as a function the size of a fixed subset of AugMix augmentations. During training, augmentations are only sampled from the subset. The subset is chosen one of three ways: randomly, the most similar augmentations to ImageNet-C, or the least similar augmentations to ImageNet-C. Choosing similar corruptions improves error beyond AugMix, but not by as much that choosing dissimilar augmentations harms it. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            101,
+            820,
+            238
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            347,
+            825,
+            444
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "First, we note that for randomly sampled augmentations, A does not need to be very large to match AugMix in performance. Even though training on AugMix with our training parameters would normally would produce 5 million uniquely sampled augmentations, only around 1000 are needed to achieve equivalent performance. Training on the closest augmentations exceeds regular AugMix performance with only around 100 unique transforms, which acts as additional evidence that augmentation-corruption similarity correlates with corruption error. This gain in accuracy comes not from having access to better transformations, but from having more frequent access to them at training time. However, the gain is fairly mild at only around $1 \\%$ , even though the best transformations are sampled all of the time instead of rarely. The gain from frequency is much less than the gain from having more similar augmentations, since choosing the most dissimilar augmentations gives around a $5 \\%$ drop in accuracy. This suggests that it is a net positive to decrease the frequency of sampling similar augmentations in order to include augmentations similar to another set of corruptions: the gain in accuracy on the new corruption set will likely out weight the small loss in accuracy on the original set. ",
+        "bbox": [
+            174,
+            452,
+            825,
+            646
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C MSD ABLATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            671,
+            348,
+            688
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C.1 ARCHITECTURE CHOICE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            705,
+            387,
+            719
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Here we provide evidence that changing the architecture of the feature extractor used in the definition of MSD does not have any qualitative effect on the correlation with corruption error. We use a version of VGG-19 with batch normalization that has been modified for CIFAR-10. Otherwise, all other parameters are chosen the same. We then repeat the experiment of Section 4. In Table 3 and Figure 9, we show that the qualitative results of this experiment are unchanged when using VGG-19-BN as the feature extractor. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            818
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C.2 PARAMETER DEPENDENCIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            840,
+            415,
+            854
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In calculating the feature space for transforms and MSD, it is necessary to both pick a number of images to average over and a number of corruptions to average over. In our experiments, we use 100 images and 100 corruptions. Here we provide evidence that these are reasonable choices for these parameters. ",
+        "bbox": [
+            176,
+            867,
+            825,
+            922
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/47fb7461136abf8c8398c9a43b79372e38dd7831a48298a525ea4d4dabac3bcb.jpg",
+        "image_caption": [
+            "Figure 9: MSD vs corruption test error for which MSD is calculated using VGG-19-BN as the architecture for feature extraction. The corruption error is still calculated using WideResNet-40-2. Compare to Figure 16 to see that the qualitative structure of the correlation is the regardless of which architecture is used for the feature extractor. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            169,
+            810,
+            484
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/e6b9d0c136a8732c39f369d8a700ac6f7761943e3d3abb842676cd44eb87dbc4.jpg",
+        "table_caption": [
+            "Table 3: Spearman’s rank coefficient for the correlation between MSD and corruption error for two architectures in the feature extractor: WideResNet-40-2 and VGG-19-BN. While WideResNet has slightly better correlations overall, the relative behavior across corruptions remains the same for the two architectures. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Corruption</td><td rowspan=1 colspan=1>WRS</td><td rowspan=1 colspan=1>VGG</td><td rowspan=1 colspan=1>Corruption</td><td rowspan=1 colspan=1>WRS</td><td rowspan=1 colspan=1>VGG</td></tr><tr><td rowspan=8 colspan=1>GaussianNoiseShot NoiseImpulse NoiseMotion BlurDefocus BlurZoom NoiseGlass BlurBrightness</td><td rowspan=1 colspan=1>0.76</td><td rowspan=1 colspan=1>0.70</td><td rowspan=1 colspan=1>Fog</td><td rowspan=1 colspan=1>0.68</td><td rowspan=1 colspan=1>0.60</td></tr><tr><td rowspan=1 colspan=1>0.83</td><td rowspan=1 colspan=1>0.78</td><td rowspan=1 colspan=1>Frost</td><td rowspan=1 colspan=1>0.66</td><td rowspan=1 colspan=1>0.66</td></tr><tr><td rowspan=1 colspan=1>0.90</td><td rowspan=1 colspan=1>0.92</td><td rowspan=1 colspan=1>Snow</td><td rowspan=1 colspan=1>0.65</td><td rowspan=1 colspan=1>0.53</td></tr><tr><td rowspan=1 colspan=1>0.86</td><td rowspan=1 colspan=1>0.81</td><td rowspan=1 colspan=1>Contrast</td><td rowspan=1 colspan=1>0.66</td><td rowspan=1 colspan=1>0.65</td></tr><tr><td rowspan=1 colspan=1>0.83</td><td rowspan=1 colspan=1>0.78</td><td rowspan=1 colspan=1>Pixelate</td><td rowspan=1 colspan=1>0.35</td><td rowspan=1 colspan=1>0.29</td></tr><tr><td rowspan=1 colspan=1>0.77</td><td rowspan=1 colspan=1>0.68</td><td rowspan=1 colspan=1>JPEGCompression</td><td rowspan=1 colspan=1>0.33</td><td rowspan=1 colspan=1>0.26</td></tr><tr><td rowspan=1 colspan=1>0.69</td><td rowspan=1 colspan=1>0.66</td><td rowspan=1 colspan=1>Elastic Transform</td><td rowspan=1 colspan=1>0.77</td><td rowspan=1 colspan=1>0.74</td></tr><tr><td rowspan=1 colspan=1>0.27</td><td rowspan=1 colspan=4>0.08</td></tr></table>",
+        "bbox": [
+            258,
+            738,
+            740,
+            857
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/60b1423408618b539c886fb4a8aba40fa2369833151617cb9105b3c2f7dd91a0.jpg",
+        "image_caption": [
+            "Figure 10: The standard deviation of the distance between an augmentation and a corruption center, taken over 100 resamplings of images and corruptions. The standard deviation is calculated as a percentage of the mean distance, then averaged over 100 augmentation-corruption pairs. At our choice of parameters, 100 images and 100 corruptions, the standard deviation is only around $5 \\%$ of the distance. This is smaller than the feature size in the scatter plots of Figure 14 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            334,
+            101,
+            666,
+            250
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "To do so, we use the augmentation scheme from AugMix and corruptions distributions from CIFAR10-C to randomly sample 100 augmentation-corruption pairs. Then, for different samplings of a fixed number of images and sampled corruptions, we measure the augmentation-corruption distance in the transform feature space 100 times for each augmentation-corruption pair. We calculate the standard deviation of the distance as a percentage of the mean distance for each augmentation-corruption pair, and average this over pairs. The results are shown in Figure 10. For our choice of image and corruption number, the standard deviation in distance is only around $5 \\%$ of the mean distance, which is smaller than the size of the features in the scatter plots in Figure 14. ",
+        "bbox": [
+            173,
+            351,
+            825,
+            463
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "D IMAGENET-C DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            481,
+            398,
+            500
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "D.1 DATASET CONSTRUCTION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            515,
+            459,
+            529
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "First, 30 new corruptions, examples of which are shown in Figure 11, are adapted from common image filters and noise distributions available online (Huxtable, 2006; Gladman, 2016). These corruptions are generated in 10 severities such that the image remains human interpretable at all severities and the distribution of errors on a baseline model roughly matches that of ImageNet-C. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            597
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For each corruption, groups of 5 severities are generated that roughly match the average spread in error across severities in ImageNet-C on a baseline model. Seven of these groups are formed for each corruption, each with one of severity 3 through 8 as the center severity of the group of 5. ",
+        "bbox": [
+            176,
+            603,
+            823,
+            646
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A candidate dataset is a set of 10 groups of severities, each from a different corruption whose average corruption error on a baseline model is within $1 \\%$ of ImageNet-C. This is necessary so that a relative decrease in error of data augmented models is normalized against a fixed baseline. Also, more distorted, harder transforms are likely farther away, so if this wasn’t fixed maximizing distance would likely just pick the hardest transforms in the highest severities. It was computationally infeasible to enumerate all candidate datasets, so they were sampled as follows. For each choice of 5 corruptions, one choice of severities was selected at random so that the average corruption error was within $1 \\%$ of ImageNet-C, if it existed. Then random disjoint pairs of two sets of 5 were sampled to generate candidate datasets. $1 0 0 \\mathrm { k }$ candidate datasets are sampled. ",
+        "bbox": [
+            173,
+            652,
+            825,
+            779
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Call the set of all corruption-severity pairs in a dataset $\\mathbb { C }$ . The distance of a candidate dataset to ImageNet-C is defined as ",
+        "bbox": [
+            173,
+            784,
+            823,
+            813
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4d948c9890abec1e08a2b634489e3d3924b541c8f1d0cc8c54c2087f23beea59.jpg",
+        "text": "$$\nd ( \\mathbb { C } _ { \\mathrm { n e w } } , \\mathbb { C } _ { \\mathrm { I N - C } } ) = \\mathbb { E } _ { c \\sim \\mathbb { C } _ { \\mathrm { n e w } } } \\left[ \\operatorname* { m i n } _ { c ^ { \\prime } \\sim \\mathbb { C } _ { \\mathrm { I N - C } } } d _ { \\mathrm { M M D } } ( c , c ^ { \\prime } ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            316,
+            819,
+            679,
+            854
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "where $d _ { \\mathrm { M M D } }$ is defined in Section 3. The minimum helps assure that new corruptions are far from all ImageNet-C corruptions. ",
+        "bbox": [
+            176,
+            859,
+            823,
+            888
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "This distance is calculated for all $1 0 0 \\mathrm { k }$ sampled candidate datasets. For CIFAR-10, the same parameters described in Section 4.1 are used to calculate the distance. For ImageNet, the feature extractor is a ResNet-50 trained according to Goyal et al. (2017), except color jittering is not used as a data augmentation. Since there is much greater image diversity in ImageNet, we jointly sample 10k images and corruptions instead of independently sampling 100 images and 100 corruptions. Code for measuring distances and training models is based on pyCls (Radosavovic et al., 2019; 2020). ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/07b1aff37a7df6346b7740bcac468e52eb99b81f440fb7679d338367b83f8c33.jpg",
+        "table_caption": [
+            "Table 4: Comparison between performance on ImageNet/CIFAR10-C and ImageNet/CIFAR10-C. Standard deviations are over 10 runs for CIFAR-10 and 5 runs for ImageNet. \\*ANT results use the pre-trained model provided with the paper and thus has slightly different training parameters and only one run. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>IN-C</td><td colspan=\"2\">IN-C</td></tr><tr><td>Aug</td><td>Err</td><td>Err</td><td>△IN-C</td></tr><tr><td>Baseline</td><td>58.2±0.5</td><td>57.7±0.2</td><td>-0.5</td></tr><tr><td>AA</td><td>54.8±0.2</td><td>55.7±0.3</td><td>+0.9</td></tr><tr><td>PG</td><td>48.1 ±0.2</td><td>56.6±0.4</td><td>+8.5</td></tr><tr><td>ANT*</td><td>48.8</td><td>53.9</td><td>+5.1</td></tr><tr><td>AugMix</td><td>49.1 ±0.7</td><td>52.4±0.2</td><td>+3.4</td></tr></table>",
+        "bbox": [
+            187,
+            151,
+            486,
+            255
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/6a7741df1206400333813bc862269c028f640b5dc7c529ce64f0acc2051c3f95.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>C10-C</td><td colspan=\"2\">C10-C</td></tr><tr><td>Aug</td><td>Err</td><td>Err</td><td>△C10-C</td></tr><tr><td>Baseline</td><td>27.0±0.6</td><td>27.1±0.5</td><td>+0.1</td></tr><tr><td>AA</td><td>19.4±0.2</td><td>21.0±0.4</td><td>+1.6</td></tr><tr><td>PG</td><td>17.0±0.4</td><td>23.8±0.5</td><td>+6.8</td></tr><tr><td>AugMix</td><td>11.1 ±0.2</td><td>16.0±0.3</td><td>+4.9</td></tr></table>",
+        "bbox": [
+            509,
+            157,
+            808,
+            251
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/35e808661dda5786cd7880b88d6d396cde2be6ca8eef8c5353011cb2352c33c9.jpg",
+        "table_caption": [
+            "Table 5: Breakdown of performance on individual corruptions in ImageNet/CIFAR10-C. Standard deviations are over 10 runs for CIFAR-10 and 5 runs for ImageNet. Examples and full names of each corruption are given in Appendix E. $\\bf \\Pi ^ { * }$ results use the pre-trained model provided with the paper and thus has slightly different training parameters and only one run. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"9\">ImageNet-C Corruptions</td></tr><tr><td>Aug</td><td>BSmpl</td><td>Plsm</td><td>Ckbd</td><td>CSin</td><td>SFrq</td><td>Brwn</td><td>Prln</td><td>ISprk</td><td>Sprk Rfrac</td></tr><tr><td>Baseline</td><td>68.6±0.571.7±0.7 49.4±0.6 84.7±0.5 79.0±0.8 37.5±0.5 34.3±0.1 32.4±0.5 76.7±0.2 42.8±0.2</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>AA</td><td>54.8±0.7 68.3 ±0.7 43.8±1.0 86.5±0.6 78.8±0.9 34.5±0.8 33.8±0.2 36.1±1.0 77.1±1.2 43.8±0.2</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>PG</td><td>60.3±2.9</td><td>74.1±0.7 48.5±1.0 82.1±0.4 76.7±0.8 38.9±0.4 34.6 ±0.1 32.1±0.7 76.5±0.6 42.1 ±0.4</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>ANT*</td><td>35.8</td><td>75.5 56.9</td><td>76.4</td><td>63.7</td><td>41.0</td><td>35.2</td><td>35.0</td><td>76.1</td><td>43.3</td></tr><tr><td>AugMix</td><td colspan=\"9\">43.2 ±0.8 72.2±0.4 46.1±0.2 76.3±0.3 67.4±0.7 38.8 ±0.5 32.4±0.1 32.3±0.2 76.4±0.4 39.2 ±0.2</td></tr><tr><td>Aug</td><td>BSmpl</td><td>Brwn</td><td>Ckbd</td><td>CIFAR-10-C Corruptions CBlur ISprk</td><td>Line</td><td>P&amp;T</td><td>Rppl</td><td>Sprk</td><td>TCA</td></tr><tr><td>Baseline</td><td>42.9±5.1</td><td>27.2±0.5</td><td>23.3±0.6</td><td>511.8±0.4 43.3±0.8 26.2±0.911.3±0.3 21.6±1.2 21.0±1.1 42.9±2.7</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>AA</td><td>17.7 ±1.7</td><td>17.5 ±0.5</td><td>17.6±0.5</td><td>9.5±0.3 40.4 ±1.5 23.6±0.7 10.7 ±0.3 23.5±0.5 17.5±0.7 31.8±1.8</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>PG</td><td>9.0±1.1 30.1±1.1 2</td><td></td><td></td><td>21.6±0.8 12.8±0.5 35.4±1.6 20.6±0.5 8.8±0.2 21.5±0.9 19.3±0.5 59.5 ±3.5</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>AugMix</td><td></td><td>9.8±0.7 27.8±1.3 13.4±0.4 5.9±0.2 30.3 ±0.7 18.0±0.6 8.3±0.2 12.1±0.4 15.5±0.5 19.2 ±1.0</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            196,
+            332,
+            802,
+            506
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            529,
+            825,
+            585
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "The corruptions are then ranked according the their average contribution to the dataset distance. This entire procedure is repeated 10 times for CIFAR and 5 times for ImageNet, and corruption contributions are averaged. The top 10 are chosen to form the new dataset. Of candidate datasets made up of these 10 corruptions, the one with baseline error closest to ImageNet-C is chosen, though run-to-run fluctuation still causes some variation. ",
+        "bbox": [
+            174,
+            592,
+            825,
+            661
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "D.2 COMPLETE RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            679,
+            361,
+            693
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Here we show average results comparing ImageNet/CIFAR-10-C to ImageNet/CIFAR-10-C in Table 4, and a breakdown of ImageNet/CIFAR-10-C results by corruption in Table 5. ",
+        "bbox": [
+            174,
+            704,
+            823,
+            733
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "E GLOSSARY OF TRANSFORMS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            753,
+            444,
+            768
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "This appendix contains examples of the augmentations and corruptions discussed in the text. Figure 11 shows the 30 new corruptions introduced in Section 5. These transforms are adapted from common online filters and noise sources (Huxtable, 2006; Gladman, 2016). They are designed to be human interpretable and cover a wide range transforms, including noise additions, obscuring, warping, and color shifts. The 10 transforms chosen for ImageNet-C are blue noise sample $( { \\mathrm { B S m p l } } )$ ), plasma noise (Plsm), checkerboard (Ckbd), cocentric sine waves (CSin), single frequency (SFrq), brown noise (Brwn), perlin noise (Prln), inverse sparkle (ISprk), sparkles (Sprk), and caustic refraction (Rfrac). For CIFAR-10-C, there is blue noise sample (BSmpl), brown noise (Brwn), checkerboard (Ckbd), circular motion blur (CBlur), inverse sparkle (ISprk), lines (Line), pinch and twirl (P&T), ripple (Rppl), sparkles (Sprk), and transverse chromatic abberation (TCA). ",
+        "bbox": [
+            173,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Figure 12 shows the 9 base transforms used to build augmentation schemes in the analysis. These are transforms from the Pillow Image Library that are often used as data augmentation. They have no exact overlap with either the corruptions of ImageNet-C or the new corruptions we introduce here. There are five geometric transforms (shear x/y, translate $\\mathrm { x / y }$ , and rotate) and four color transforms (solarize, equalize, autocontrast, and posterize). We choose this particular set of augmentations following Hendrycks et al. (2019). ",
+        "bbox": [
+            173,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Figure 13 shows example corruptions from the ImageNet-C benchmark (Hendrycks & Dietterich, 2018). They a grouped into four categories: noise (gaussian noise, shot noise, and impulse noise), blurs (motion blur, defocus blur, zoom blur, and glass blur), synthetic weather effects (brightness, fog, frost, and snow), and digital transforms (contrast, pixelate, JPEG compression, and elastic transform). ",
+        "bbox": [
+            174,
+            194,
+            826,
+            251
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "F SUPPLEMENTARY PLOTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            270,
+            410,
+            286
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "This appendix contains additional plots for the analysis in the main text. ",
+        "bbox": [
+            174,
+            301,
+            643,
+            316
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Fig 14 shows a comparison of how MMD and MSD correlate with corruption error. MMD typically shows poor correlation, while MSD has strong correlation in all four categories of corruption. ",
+        "bbox": [
+            174,
+            323,
+            823,
+            352
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Figure 15 shows the correlation between MSD and corruption error for all 15 ImageNet-C corruptions, where $\\rho$ is the Spearman rank correlation. Here, ‘AugMix’ refers to just their augmentation scheme, and not their Jensen-Shannon divergence loss, which gives additional improvements in corruption error. 12 of 15 corruptions have a Spearman rank correlation greater than 0.6. The remaining three that show poor correlations are ‘brightness’, ‘JPEG compression’, and ‘pixelate’. ",
+        "bbox": [
+            174,
+            358,
+            825,
+            429
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Figure 16 shows the average contribution of a new corruption to the dataset’s distance from ImageNetC. The top 10 large average contributions, colored in blue, are chosen as the corruptions to make up the dataset ImageNet-C. ",
+        "bbox": [
+            174,
+            435,
+            825,
+            478
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/03ba5522c7dcf83bdbf6d98b1659d59df4126495639ab11d138c5ee051b6e3b8.jpg",
+        "image_caption": [
+            "Figure 11: Examples of each corruption considered when building the dataset dissimilar to ImageNet-C. Base image $\\circledcirc$ Sehee Park. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            138,
+            816,
+            834
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/ddac8a1449bc953aedc70707eede3a45f3eb5f2c49b06af80550150814f068fe.jpg",
+        "image_caption": [
+            "Figure 12: The nine base transforms used as augmentations in analysis. Base image $\\circledcirc$ Sehee Park. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            147,
+            815,
+            367
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/c513fe8d60f6af6b89702dab561694cda55bc30ca0ae2e91da0601111e359ce1.jpg",
+        "image_caption": [
+            "Figure 13: Examples of the 15 corruptions in the ImageNet-C corruption benchmark (Hendrycks & Dietterich, 2018). Base image $\\circledcirc$ Sehee Park. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            498,
+            816,
+            832
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/9f9bec02fddf1be925170f504d7f07bb0879b86bf73fbe6c09299d8bf7e8d2e6.jpg",
+        "image_caption": [
+            "Figure 14: Example relationships between augmentation-corruption distance and corruption error for two distance scores, MMD and MSD. $\\rho$ is the Spearman rank correlation. MMD between an augmentation and corruption distribution is not typically predictive of corruption error. MSD correlates well across all four categories of corruption in CIFAR-10-C. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            340,
+            815,
+            614
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/451a1032afcd36f0e4b21c77cdf97ef75326d437980b248a5c0ca98b2670d6f6.jpg",
+        "image_caption": [
+            "Figure 15: See text for details. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            109,
+            782,
+            888
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "image",
+        "img_path": "images/e98996ab0b60dc017a6bfe2bdcf366fddffcbab91e746e1a2ec02e60b161306e.jpg",
+        "image_caption": [
+            "Figure 16: A corruption’s average contribution to the distance to ImageNet-C, as a fraction of the population’s standard deviation. The blue corruptions are those used to construct ImageNet-C. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            227,
+            385,
+            774,
+            599
+        ],
+        "page_idx": 21
+    }
+]