Datasets:

zai-org
/

RPC-Bench

+# PARAMETER EFFICIENT MULTIMODAL TRANSFORMERS FOR VIDEO REPRESENTATION LEARNING
+Sangho Lee, Youngjae Yu, Gunhee Kim
+Seoul National University
+{sangho.lee,yj.yu}@vision.snu.ac.kr, gunhee@snu.ac.kr
+Thomas Breuel, Jan Kautz NVIDIA Research {tbreuel,jkautz}@nvidia.com
+Yale Song
+Microsoft Research
+yalesong@microsoft.com
+# ABSTRACT
+The recent success of Transformers in the language domain has motivated adapting it to a multimodal setting, where a new visual model is trained in tandem with an already pretrained language model. However, due to the excessive memory requirements from Transformers, existing work typically fixes the language model and train only the vision module, which limits its ability to learn cross-modal information in an end-to-end manner. In this work, we focus on reducing the parameters of multimodal Transformers in the context of audio-visual video representation learning. We alleviate the high memory requirement by sharing the parameters of Transformers across layers and modalities; we decompose the Transformer into modality-specific and modality-shared parts so that the model learns the dynamics of each modality both individually and together, and propose a novel parameter sharing scheme based on low-rank approximation. We show that our approach reduces parameters of the Transformers up to $9 7 \%$ , allowing us to train our model end-to-end from scratch. We also propose a negative sampling approach based on an instance similarity measured on the CNN embedding space that our model learns together with the Transformers. To demonstrate our approach, we pretrain our model on 30-second clips (480 frames) from Kinetics-700 and transfer it to audio-visual classification tasks.
+# 1 INTRODUCTION
+Learning multimodal representation from unlabeled videos has received considerable attention (Baltrušaitis et al., 2018). Audio-visual learning is of particular interest due to the abundance of videos with natural audio-visual co-occurrence (Owens & Efros, 2018; Owens et al., 2018; Arandjelovic & Zisserman, 2018; Ephrat et al., 2018; Gao & Grauman, 2019; Alwassel et al., 2019). However, existing approaches learn localized representations from short videos (hundreds of milliseconds to just under a few seconds), capturing only short-term dependencies in data. While this is useful for certain applications, e.g., source separation (Ephrat et al., 2018) and atomic action recognition (Gu et al., 2018), learning representation that captures long-term dependencies is equally important, e.g., for activity recognition (Kay et al., 2017; Carreira et al., 2019; Sigurdsson et al., 2016). Unfortunately, processing long videos requires large memory resource and capturing long-term dependencies is a long-standing problem (Hochreiter & Schmidhuber, 1997; Cho et al., 2014; Vaswani et al., 2017).
+In language understanding, strong progress has been made in large-scale learning of contextualized language representations using Transformers (Vaswani et al., 2017; Howard & Ruder, 2018; Peters et al., 2018; Radford et al., 2018; 2019; Devlin et al., 2019; Liu et al., 2019; Yang et al., 2019). Riding on the success of Transformers, several recent works have extended it to the multimodal setting by adding an additional vision module to the Transformer framework (Sun et al., 2019b; Lu et al., 2019). However, these models are typically not end-to-end trained; they rely on a language-pretrained BERT (Devlin et al., 2019), which is fixed throughout, and train only the visual components. While the pretrained BERT helps accelerate convergence and brings reliable extra supervision signal to the vision component, this partial learning setup can be undesirable if the text data comes from different distributions (of topics, dialects, or foreign languages) or if we want to apply it to different modalities (e.g., audio-visual). Unfortunately, end-to-end training of such multimodal Transformer architectures is challenging for most existing compute environments due to the excessive memory requirement.
+![](images/ec7a499eb1816cbea6560807a25e2ab536cf8f8b4c3ca522b5ae15513ee23387.jpg)
+Figure 1: (Left) Our model consists of CNNs encoding short-term dynamics of each modality and Transformers encoding long-term dynamics of audio-visual information from videos. (Right) To alleviate excessive memory requirements, we propose an efficient parameter sharing scheme based on matrix decomposition with low-rank approximation, which allows us to train our model end-to-end.
+In this work, we make three key contributions. First, we propose an end-to-end trainable bidirectional transformer architecture that learns contextualized audio-visual representations of long videos. Our model, shown in Figure 1, consists of audio/visual CNNs, audio/visual Transformers, and a multimodal Transformer. The CNNs operate on short (e.g., one second) video clips and are intended to capture short-term dynamics within each modality. The Transformer layers operate on long video sequences (e.g., 30 seconds), capturing long-term dynamics. To enable end-to-end training, we propose a novel parameter reduction technique that shares parts of weight parameters across Transformers and across layers within each Transformer. We show that this results in up to $9 7 \%$ parameter reduction, enabling end-to-end training of our model, with a minimal performance degradation. To the best of our knowledge, our work is the first to report end-to-end trained multimodal Transformers, and the first to apply Transformers for audio-visual representation learning.
+The quality of negative samples is crucial in contrastive learning, which is part of our learning objective. As our second contribution, we propose a content-aware negative sampling strategy that favors negatives sufficiently similar to a positive instance. Our approach measures the similarity by reusing the CNN embeddings obtained during model training, and thus do not introduce extra parameters to learn. We show that this improves performance over the standard sampling strategies.
+Our third contribution is a systematic evaluation of different modality fusion strategies. Existing works on multimodal BERT (all using vision-and-language data) typically apply one fusion strategy without thoroughly comparing with alternatives, e.g., some works perform early fusion (Sun et al., 2019b; Su et al., 2020) while others perform mid-level fusion (Lu et al., 2019; Tan & Bansal, 2019). As a result, it is unclear how different fusion methods affect the final performance. In this work, we compare three fusion strategies (early, mid, late) and show the superiority of mid-level fusion.
+To demonstrate our approach, we pretrain our model on long (30-second) video clips from Kinetics700 (Carreira et al., 2019) and finetune it on various video classification tasks. One benefit of the modular design of our architecture is flexibility: once pretrained, we can use any of the subnetworks for downstream tasks depending on the modalities involved (audio-only, visual-only, audio-visual) and video lengths (short and long). To show this, we evaluate our model on UCF101 (Soomro et al., 2012) and ESC-50 (Gemmeke et al., 2017) for short-term visual/audio classification, and Charades (Sigurdsson et al., 2016) and Kinetics-Sounds (Arandjelovic & Zisserman, 2017) for long-term audio-visual action recognition.
+# 2 APPROACH
+Figure 1 shows an overview of the proposed model architecture. The input to our model is a sequence of visual clips $\mathbf { v } _ { 1 : T }$ and the corresponding sequence of audio streams $\mathbf { a } _ { 1 : T }$ . For example, each sequence is a 30 second-long video divided into 30 non-overlapping clips (each clip is one second long). We divide our model into three parts with different characteristics, which are explained below.
+Local Feature Embedding. We feed each of $T$ video clips to a visual CNN $f _ { V } ( \mathbf { v } _ { t } )$ to obtain $\mathbf { x } _ { 1 : T } ^ { v } \in \mathbb { R } ^ { T \times D }$ , and each audio stream to an audio CNN $f _ { A } ( \mathbf { a } _ { t } )$ to obtain $\mathbf { x } _ { 1 : T } ^ { a } \in \mathbb { R } ^ { T \times D }$ .1 Intuitively, the CNN outputs are temporally local embeddings as they have access to only a short-range temporal window of the entire video sequence. Thus, they are suitable for representing short-range atomic actions (e.g., sit down, raise arms) that constitute long-range events (e.g., gym workout). We use the SlowFast network (Feichtenhofer et al., 2019) with a ResNet-50 backbone (He et al., 2016) as a visual CNN $f _ { V }$ , and a ResNet-50 as an audio CNN $f _ { A }$ . The weights of both CNNs are randomly initialized and trained end-to-end with the Transformer layers.
+Unimodal Contextualized Embedding. The local feature embeddings capture short-term dynamics but lack long-term contextual information. We use Transformers (Vaswani et al., 2017) to enrich the embeddings with sequence-level context. We start by learning unimodal contextualized representations using the visual Transformer $g _ { V }$ and the audio Transformer $g _ { A }$ , respectively.
+The Transformer consists of $\mathrm { L }$ layers, each with two sub-layers: a multi-head attention layer and a feed-forward layer. Given an input sequence of embeddings $\mathbf { x } \in \mathbb { R } ^ { T \times D }$ and $A$ attention heads, the $j$ -th head in the attention layer computes the output embedding sequence $\mathbf { a } _ { j } \in \mathbb { R } ^ { T \times \gamma } , \gamma = D / A$ as
+$$
+{ \bf a } _ { j } = \mathrm { s o f t m a x } \left( \frac { Q _ { j } K _ { j } ^ { \top } } { \sqrt { \gamma } } \right) V _ { j } , \qquad Q _ { j } = { \bf x } W _ { j } ^ { q } , K _ { j } = { \bf x } W _ { j } ^ { k } , V _ { j } = { \bf x } W _ { j } ^ { v }
+$$
+where $W _ { j . } ^ { q } , W _ { j } ^ { k } , W _ { j . } ^ { v } \in \mathbb { R } ^ { D \times \gamma }$ are weight matrices for computing the (query, key, value) triplet given the input $\mathbf { x }$ . This operation is repeated for each attention head, and the outputs are combined (with concatenation followed by one linear layer with weights $W ^ { b } \in \mathbb { R } ^ { D \times D } )$ , producing $\mathbf { a } \in \mathbb { R } ^ { T \times D }$ . Next, the feed-forward layer takes this intermediate output and computes $\mathbf { o } \in \mathbb { R } ^ { T \times D }$ using a twolayer fully-connected network with weights $W ^ { c } \in \mathbb { R } ^ { D \times E }$ and $W ^ { d } \in \mathbb { R } ^ { E \times D }$ . The output of each sub-layer is computed using a residual function followed by layer normalization (Ba et al., 2016), i.e., LayerNorm $( { \overline { { x } } } + { \mathrm { S u b l a y e r } } ( x ) )$ . In this work, we set the number of layers $L = 6$ , the number of attention heads $A = 1 2$ , the feature dimension $D = 7 6 8$ and the intermediate dimension $E = 3 0 7 2$ . For simplicity, we use this design for all layers across all three Transformers in our model.
+Before feeding local embeddings $\mathbf { x } ^ { v }$ and $\mathbf { x } ^ { a }$ to unimodal Transformers, we augment them with “positional” embeddings. Specifically, we append to the beginning of each sequence a special vector BOS (beginning of sequence), i.e., $\mathbf { x } _ { 0 } ^ { v }$ for visual and $\mathbf { x } _ { 0 } ^ { a }$ for audio streams; their dimensions are same as $\mathbf { x } _ { t } ^ { v }$ and $\mathbf { x } _ { t } ^ { a }$ , respectively. We also define positional embeddings $\mathbf { p } _ { 0 : T }$ encoding time indices (we call this “time” embedding). This is necessary to preserve information about temporal ordering of local feature embeddings, which is otherwise lost in Eqn. 1. We combine them via layer normalization,
+$$
+\begin{array} { r } { \mathbf { u } _ { t } ^ { v } = \mathrm { L a y e r N o r m } ( \mathbf { x } _ { t } ^ { v } + \mathbf { p } _ { t } ^ { v } ) , \quad \mathbf { u } _ { t } ^ { a } = \mathrm { L a y e r N o r m } ( \mathbf { x } _ { t } ^ { a } + \mathbf { p } _ { t } ^ { a } ) , \quad \forall t \in [ 0 , T ] } \end{array}
+$$
+We initialize $\{ \mathbf { x } _ { 0 } ^ { v } , \mathbf { x } _ { 0 } ^ { a } , \mathbf { p } _ { 0 : T } ^ { v } , \mathbf { p } _ { 0 : T } ^ { a } \}$ to the normal distribution and train them with the rest of the model.
+We feed the augmented visual embeddings into the visual Transformer $g _ { V }$ and obtain ${ \bf y } _ { 0 : T } ^ { v } =$ $g _ { V } \big ( \mathbf { u } _ { 0 : T } ^ { v } \big )$ , and similarly obtain ${ \bf y } _ { 0 : T } ^ { a } = g _ { A } ( { \bf u } _ { 0 : T } ^ { a } )$ . The embeddings at each time step has a direct access to the entire input sequence regardless of their position (it has a one-step signal path during forward and backward inference). Multiple layers of such feature transformation thus allow the resulting embedding to be deeply contextualized in the time dimension. We denote the output embeddings corresponding to the BOS positions by ${ \sf B O S } _ { g } ^ { v } = { \bf y } _ { 0 } ^ { v }$ and $\mathbf { B } 0 \mathbf { S } _ { g } ^ { a } = \mathbf { y } _ { 0 } ^ { a }$ , and designate them as the summary embeddings representing the sequence of each modality.
+Multimodal Contextualized Embedding. The unimodal embeddings capture long-term temporal context but miss out on cross-modal information. The final step in forward inference is to use a multimodal Transformer $h _ { A V }$ to obtain embeddings contextualized in the audio-visual space.
+We first augment the embeddings $\mathbf { y } _ { 0 : T } ^ { v }$ and ${ \bf y } _ { 0 : T } ^ { a }$ with modality and time embeddings. The modality embeddings $\mathbf { m } ^ { v }$ and $\mathbf { m } ^ { a }$ are vectors of the same dimension as $\mathbf { y } _ { t } ^ { v }$ and $\mathbf { y } _ { t } ^ { a }$ , respectively. We share $\mathbf { m } ^ { v }$ (and $\mathbf { m } ^ { a }$ ) across all the unimodal embeddings $\mathbf { y } _ { 0 : T } ^ { v }$ (and ${ \bf y } _ { 0 : T } ^ { a } )$ ; thus, they add modality-discriminative information to the Transformer. We also add time embeddings $\mathbf { p } _ { 0 : T }$ as before; however, unlike in the previous step, we share the same $\mathbf { p } _ { 0 : T }$ between embeddings from the two modalities to correctly indicate the time indices. We augment the modality and time embeddings via layer normalization,
+$$
+\mathbf { w } _ { t } ^ { v } = \mathrm { L a y e r N o r m } ( \mathbf { y } _ { t } ^ { v } + \mathbf { p } _ { t } + \mathbf { m } ^ { v } ) , \mathbf { w } _ { t } ^ { a } = \mathrm { L a y e r N o r m } ( \mathbf { y } _ { t } ^ { a } + \mathbf { p } _ { t } + \mathbf { m } ^ { a } ) , \forall t \in [ 0 , T ]
+$$
+We feed the augmented visual embeddings $\mathbf { w } _ { 0 : T } ^ { v }$ and audio embeddings $\mathbf { w } _ { 0 : T } ^ { a }$ to the multimodal Transformer $h _ { A V }$ , one after another, and obtain $\mathbf { \bar { z } } _ { 0 : ( 2 T + 1 ) } = h _ { A V } \big ( \bigl [ \mathbf { w } _ { 0 : T } ^ { v } ; \mathbf { w } _ { 0 : T } ^ { a } \bigr ] \big )$ . We again denote the output embeddings corresponding to the BOS positions by ${ \tt B O S } _ { h } ^ { v } = { \bf z } _ { 0 } ^ { v } ( = { \bf z } _ { 0 } )$ and ${ \tt B O S } _ { h } ^ { a } = { \bf z } _ { 0 } ^ { a } ( =$ ${ \bf z } _ { T + 1 } ,$ ), and use them as summary embeddings encoding multimodal context.
+We emphasize the importance of feeding $\mathbf { w } _ { 0 : T } ^ { v }$ and ${ \bf w } _ { 0 : T } ^ { a }$ one after another. An alternative would be concatenating them before feeding them to $h _ { A V }$ and obtaining an output $\mathbf { z } _ { 0 : T }$ (instead of $\mathbf { z } _ { 0 : ( 2 T + 1 ) } )$ . However, this restricts the Transformer to access audio-visual embeddings only from the same time slices, which could be problematic when there is a temporally asynchronous relationship between the two modalities (e.g., a visual clip matches with sound captured a few times steps before) (Kazakos et al., 2019; Morgado et al., 2020). By arranging the two sequences one after the other, the Transformer can mix-and-match appropriate audio-visual embeddings in an asynchronous manner. Another practical concern with the alternative approach is that it significantly increases the model size; the weight matrices $W _ { q } , W _ { k } , W _ { v }$ grow quadratically with the input feature dimension $D$ . Serializing the input resolves both issues.
+# 2.1 SELF-SUPERVISED PRETRAINING OBJECTIVES
+Task 1: Masked Embedding Prediction (MEP). BERT (Devlin et al., 2019) is trained using the masked language model (MLM) task, which randomly selects input tokens and replaces them with a mask token. The model is then trained to predict the original (unmasked) tokens by solving a classification task with a cross-entropy loss. However, inputs to our model are real-valued audiovisual signals (rather than discrete tokens),2 so applying the MLM task requires input discretization, which causes information loss (Lu et al., 2019; Sun et al., 2019a). We instead train our model to identify the correct visual clip or audio stream compared to a set of negative samples in a contrastive manner, which does not require input discretization.
+We formulate our MEP task using InfoNCE (Oord et al., 2018), which is the softmax version of the noise contrastive estimation (NCE) (Gutmann & Hyvärinen, 2010). Let $\tilde { \bf { o } } _ { t }$ be the $t$ -th output of any of the three Transformers obtained by masking the $t$ -th input $\mathbf { x } _ { t }$ . Our InfoNCE loss is then defined as
+$$
+\mathcal { L } _ { \mathrm { N C E } } ( \mathbf { x } , \tilde { \mathbf { o } } ) = - \mathbb { E } _ { \mathbf { x } } \left[ \sum _ { t } \log \frac { \mathrm { I } ( \mathbf { x } _ { t } , \tilde { \mathbf { o } } _ { t } ) } { \mathrm { I } ( \mathbf { x } _ { t } , \tilde { \mathbf { o } } _ { t } ) + \sum _ { j \in \mathrm { n e g } ( t ) } \mathrm { I } ( \mathbf { x } _ { j } , \tilde { \mathbf { o } } _ { t } ) } \right] ,
+$$
+where $\mathrm { n e g } ( t )$ are negative sample indices and the compatibility function $\mathbf { I } ( \mathbf { x } _ { t } , \tilde { \mathbf { o } } _ { t } )$ is,
+$$
+\begin{array} { r } { \operatorname { I } ( \mathbf { x } _ { t } , \tilde { \mathbf { o } } _ { t } ) = \exp \left( \mathrm { F F N } ^ { \top } ( \tilde { \mathbf { o } } _ { t } ) W _ { I } \mathbf { x } _ { t } \right) , } \end{array}
+$$
+where $W _ { I } \in \mathbb { R } ^ { P \times D }$ $P = 2 5 6 )$ and FFN is a two-layer feed-forward network. The use of a non-linear prediction head has shown to improve the quality of the representations learned in a contrastive learning setup (Chen et al., 2020); following the recent work in Transformers (Devlin et al., 2019; Liu et al., 2019; Lan et al., 2020), we use a GELU non-linear activation function (Hendrycks & Gimpel, 2016) in FFN. Optimizing Eqn. 4 enforces $\mathbf { I } ( \mathbf { x } _ { t } , \tilde { \mathbf { o } } _ { t } )$ to approximate the density ratio $\frac { p ( \mathbf { x } _ { t } | \tilde { \mathbf { o } } _ { t } ) } { p ( \mathbf { x } _ { t } ) }$ ; this can be seen as maximizing the mutual information between $\mathbf { x } _ { t }$ and $\tilde { \bf { o } } _ { t }$ (Oord et al., 2018). Intuitively, this encourages the Transformer to capture the underlying dynamics of $\mathbf { x }$ from each modality without explicitly learning a generative model $p ( \mathbf { x } _ { t } | \tilde { \mathbf { o } } _ { t } )$ .
+Negative sampling. We find that a good negative sampling strategy is essential for the model’s convergence. Existing approaches either use all but $\mathbf { x } _ { t }$ (positive) within a mini-batch as negative samples or limit it to the current sequence only. However, both these methods ignore the data content and thus can miss useful negatives. Oord et al. (2018) showed that leveraging prior knowledge about data can improve the negative sample quality (e.g., by sampling negatives from the same speaker as the positive). Unfortunately, such prior knowledge is often not available in unlabeled videos.
+![](images/fe1bde5984ac8e8c111139ad98e20af0644e624550ba140705e6f9d6c8566b8b.jpg)
+Figure 2: Comparison of parameter sharing schemes. Ours combines (b) and (c) but decomposes weights in each layer into private and shared parts so only the latter is shared across Transformers.
+We propose a content-aware negative sampling strategy that favors negatives sufficiently similar to a positive instance in the CNN embedding space; we call our approach CANS-Similar. Our approach is inspired by Ulyanov et al. (2018) who showed that randomly initialized CNNs provide a strong prior over natural images due to the inductive bias already built into the design of the CNNs. This suggests that our local feature embeddings $\mathbf { x } ^ { v }$ (and $\mathbf { x } ^ { a }$ ) can capture the underlying statistical regularities in video clips (and audio streams) right from the beginning, which can be sufficient to assess the similarity/dissimilarity between clips. Therefore, the distance measured on them can approximate content dissimilarity well (and this will improve as the training progresses).
+Motivated by this, we sample the negatives based on local feature embeddings $\mathbf { x } ^ { v }$ (and $\mathbf { x } ^ { a }$ ). Specifically, we compute a pairwise $\ell _ { 2 }$ distance between $\mathbf { x } _ { t }$ (positive) and all other instances within a mini-batch, and normalize them to the [0, 1] interval. To remove samples that are either too similar or too different from the positive sample, we discard instances that fall outside the $9 5 \%$ confidence interval in the normalized distance space. We then sample the negatives from the remainder using the normalized distance as sampling probability. This makes instances similar to the positive instance have more chance to become negatives. We emphasize the importance of sampling, instead of deterministically taking top most similar samples; the stochasticity allows our model to be robust to potentially inaccurate distance estimates because samples with low probabilities will still have a chance to be selected as negatives.
+Finally, our MEP loss is the InfoNCE loss computed on all three Transformers,
+$$
+\mathcal { L } _ { \mathrm { M E P } } = \mathcal { L } _ { \mathrm { N C E } } ( \mathbf { x } ^ { a } , \tilde { \mathbf { y } } ^ { a } ) + \mathcal { L } _ { \mathrm { N C E } } ( \mathbf { x } ^ { v } , \tilde { \mathbf { y } } ^ { v } ) + \mathcal { L } _ { \mathrm { N C E } } ( [ \mathbf { x } ^ { a } ; \mathbf { x } ^ { v } ] , \tilde { \mathbf { z } } )
+$$
+Task 2: Correct Pair Prediction (CPP). The MEP task encourages our model to learn the underlying dynamics within each modality. To help our model learn cross-modal dynamics, we design a task that predicts whether a pair of audio-visual embeddings is from the same video. Specifically, we define two binary classifiers, one for the two unimodal Transformers and another for the multimodal Transformer. Each classifier takes as input either $\mathbf { s } _ { g } = [ \mathbf { y } _ { 0 } ^ { v } ; \mathbf { y } _ { 0 } ^ { a } ]$ (and $[ \mathbf { z } _ { 0 } ^ { v } ; \mathbf { z } _ { 0 } ^ { a } ] )$ , a pair of audio-visual “summary” embeddings corresponding to the BOS positions, or $\mathbf { s } _ { h } = [ \mathbf { y } _ { t } ^ { v } ; \mathbf { y } _ { t } ^ { a } ]$ (or $[ \mathbf { z } _ { t } ^ { v } ; \mathbf { z } _ { t } ^ { a } ] )$ , the output embeddings sampled at random positions (we take two random positions $t \in [ 1 , T ] )$ . The classifier predicts $p ( c | \mathbf { s } )$ indicating whether the pair is from the same video $\overset { \cdot } { c } = 1$ ) or from different videos $c = 0$ ). We train the classifiers with a binary cross-entropy loss,
+$$
+\begin{array} { r } { \mathcal { L } _ { C P P } = - \mathbb { E } _ { \mathbf { x } , \mathbf { y } } \left[ c \cdot \log p ( c | \mathbf { s } _ { g } ) + c \cdot \log p ( c | \mathbf { s } _ { h } ) \right] } \end{array}
+$$
+where $\ast$ is the inner product. We generate a random derangement of the input mini-batch so that the number of positive and negative pairs are guaranteed to be the same.
+Overall Pretraining Objective. We train our model end-to-end from scratch by optimizing $\mathcal { L } _ { M E P } +$ $\alpha \mathcal { L } _ { C P P }$ with a balancing term $\alpha$ . We find our model is insensitive to this term, so we set $\alpha = 1 . 0$ .
+# 2.2 PARAMETER REDUCTION
+Optimizing our model is challenging due to the large memory requirement. The most expensive part is the Transformers, which take up $82 \%$ of model parameters. One could reduce the model size by making the Transformers shallower, but the depth of Transformers has shown to be crucial to get good performance (Devlin et al., 2019). We propose to reduce the model size by aggressively sharing parts of weights across Transformers as well as layers within each Transformer (see Figure 2 (d)).
+Sharing across Transformers. We first consider sharing weights across Transformers. Each Transformer encodes data coming from different distributions: $g _ { V }$ encodes $\mathbf { x } ^ { v }$ , $g _ { A }$ encodes $\mathbf { x } ^ { a }$ , and $h _ { A V }$ encodes $\left( \mathbf { y } ^ { v } , \mathbf { y } ^ { a } \right)$ . These input distributions may each exhibit different dynamics, yet together share certain regularities because they all come from the same videos. Motivated by this, we decompose Transformer weights into shared and private parts so that different patterns can be learned in a parameter-efficient manner. Recall that each layer of a Transformer contains weights $\{ W ^ { q } , W ^ { k } , \dot { W } ^ { v } , W ^ { b } , W ^ { c } , W ^ { d } \}$ . We decompose each of these weights into $W = U \Sigma V ^ { \top }$ , where $\begin{array} { r } { \dot { W } \in \mathbb { R } ^ { M \times N } , U \in \mathbb { R } ^ { M \times O } , \Sigma \in \mathbb { R } ^ { O \times O } , V \in \mathbb { R } ^ { N \times O } } \end{array}$ . We perform low-rank approximation of $W$ by setting the rank $O \ll M , N$ , and share $U$ across Transformers while keeping $\Sigma$ and $V$ private to each Transformer. This helps reduce parameters because $M O + 3 ( O ^ { 2 } + N O ) { \mathrm { ' } } \ll 3 M N$ . We experimented with different matrix ranks $O$ but the differences were small; we set $O = 1 2 8$ $( M , N = 7 6 8$ or 3072).
+The decomposition converts a linear projection of input $W \mathbf { x }$ into a series of (unconstrained) linear projections $U \Sigma V ^ { \top } { \bf x }$ . However, this can cause numerical instability during optimization (Nocedal & Wright, 2006). We could perform the Singular Value Decomposition (SVD) over $W$ so that it performs rotation $( V ^ { \top } )$ , stretch $\left( \Sigma \right)$ , and rotation $( U )$ with orthogonal basis vectors in $U$ and $V$ Unfortunately, solving the full SVD has a computational complexity of $\mathcal { O } ( \operatorname* { m a x } ( M , N ) ^ { 2 } )$ (Golub & Van Loan, 2012). Here, we put an orthogonality constraint only on $\Sigma$ and perform projection $( V ^ { \top } )$ , rotation $\left( \Sigma \right)$ , and projection $( U )$ of input $\mathbf { x }$ . In addition, we put $V ^ { \top } { \bf x }$ in a unit sphere (via $\ell _ { 2 }$ - normalization) before rotating it with $\Sigma$ . This not only improves numerical stability, but also removes magnitude information in $V ^ { \top } { \bf x }$ and keeps angular information only, which has been shown to provide sample discriminative information (Chen et al., 2019a). To impose the orthogonality constraint on $\Sigma$ , we use the Padé approximation with a scale-squaring trick of Lezcano-Casado $\&$ Martínez-Rubio (2019). Intuitively, we linearly project $\mathbf { x }$ onto a unit sphere $( V ^ { \top } { \bf x } )$ and rotate it $( \Sigma V ^ { \top } { \bf x } )$ in each Transformer so that it captures the dynamics of each input distribution independently. We then project it to the shared space via $U$ , capturing shared regularities across all three Transformers.
+Sharing across Layers. Recently, Bai et al. (2019a) showed that sharing parameters across layers in deep neural networks does not hurt the representational power of the network. Furthermore, (Lan et al., 2020) demonstrated that cross-layer parameter sharing in the Transformer leads to a lighter and faster-to-train model without sacrificing the performance on various language understanding benchmarks. Motivated by this, we let each Transformer share parameters across different layers.
+# 3 EXPERIMENTS
+We pretrain our model on Kinetics-700 (Carreira et al., 2019) or AudioSet (Gemmeke et al., 2017) and finetune it on various downstream tasks. The official release of Kinetics-700 contains 10-second clips only, so we download 410K original videos from YouTube and take 30-second clips from each video. For fair comparison with prior work, we use 10-second clips from the official release of AudioSet (we used 1.8M clips). We pretrain our model on 64 NVIDIA Tesla V100 GPUs with a batch size of 256 for 220K iterations. For downstream tasks, we evaluate on short-video/audio classification using UCF-101 (Soomro et al., 2012) (13K clips from 101 classes; 7.2 seconds on average) and ESC50 (Gemmeke et al., 2017) (2K clips from 50 classes; 5 seconds), and on long-video classification using Kinetics-Sounds (Arandjelovic & Zisserman, 2017) (23K videos from 32 classes; 10 seconds on average) and Charades (Sigurdsson et al., 2016) (10K videos from 157 classes; 30 seconds on average). We describe various details about experimental setup in Appendix.
+# 3.1 RESULTS AND DISCUSSION
+Multimodal Fusion Methods. To evaluate different fusion methods on the quality of learned representation, we test the following settings: (i) Early uses a single multimodal Transformer with $2 \times L$ layers, (ii) Mid is our approach described in Figure 1, (iii) Late uses two unimodal Transformers each with $2 \times L$ layers. All the methods are pretrained on audio-visual data using CPP and MEP losses, except for (iv) $\mathtt { L a t e - w / o - C P P }$ where we use only the MEP loss. We finetune the pretrained models on audio-visual, audio-only, and visual-only scenarios. For fair comparisons across different fusion methods, we do not perform parameter sharing in this ablation setting.
+Table 1 (a) shows that Early and Mid outperform Late on the audio-visual scenario. This suggests the importance of encoding cross-modal information. Note that Late-w/-CPP gets cross-modal self-supervision, which gives marginal performance improvement over Late-w/o-CPP; however, both methods miss the opportunity to encode any cross-modal relationship, leading to inferior results.
+Table 1: Ablation study on Kinetics-Sounds comparing: (a; top-left) multimodal fusion methods, (b; top-right) negative sampling strategies, and (c & d; bottom) parameter sharing schemes. X.-L: Cross-layer, X.-T: Cross-Transformer sharing. We report top-1 and top-5 accuracy $\hat { ( \% ) }$ . †: Ours.
+<table><tr><td colspan="2">a) Fusion Method</td><td>Audio-Visual</td><td colspan="2">Audio-only -/</td><td colspan="2">Visual-only</td><td colspan="2">b) Sampling Method</td><td colspan="2">top-5</td><td colspan="2">89.8</td></tr><tr><td>Early Late-w/-CPP</td><td colspan="2"></td><td colspan="2">64.9/89.8 61.0/88.7</td><td colspan="2">-/-</td><td colspan="2">Current-Sequence</td><td colspan="2">Current-MiniBatch</td><td colspan="2">top-1 64.6 65.5 66.2</td></tr><tr><td>Late-w/o-CPP</td><td></td><td>60.6 /87.6</td><td colspan="2">52.3/80.8 50.5/79.9</td><td colspan="2">41.0 /71.3 40.7/71.7</td><td colspan="2">CANS-Dissimilar</td><td colspan="2"></td><td colspan="2">90.8</td></tr><tr><td>Midt</td><td></td><td>65.7 /89.9</td><td>53.5 /82.7</td><td colspan="2"></td><td colspan="2">42.5 /73.2</td><td colspan="2">CANS-Similart</td><td colspan="2">67.5</td><td>91.1 92.3</td></tr><tr><td></td><td></td><td>X.-T</td><td></td><td colspan="2"></td><td colspan="2"></td><td colspan="2"></td><td colspan="2"></td><td></td></tr><tr><td>c)Model</td><td>X.-L X</td><td>X</td><td>Params</td><td colspan="2">top-1/5</td><td colspan="2">d) Model</td><td colspan="2">X.-L X.-T</td><td colspan="2">Params</td><td>top-1/5</td></tr><tr><td>Multi-2 Multi-6</td><td></td><td>X</td><td>7M 21M</td><td colspan="2">60.3/88.9 65.7 /89.9</td><td colspan="2">Vis-2 Vis-2</td><td colspan="2">X X X</td><td colspan="2">14M 7M</td><td>41.4/71.0 41.2 /72.9</td></tr><tr><td>Multi-6</td><td></td><td>√(Al1)</td><td colspan="2">7M 67.1/92.3</td><td colspan="2">Vis-6</td><td colspan="2">√ X X</td><td colspan="2">43M</td><td colspan="2">43.8/74.2</td></tr><tr><td>Multi-6</td><td>√ √</td><td>(Partt)</td><td colspan="2">4M 67.5 /92.3</td><td colspan="2">Vis-6</td><td colspan="2">√</td><td colspan="2">7M</td><td colspan="2">43.5 /73.7</td></tr></table>
+While both Early and Late perform similarly in the audio-visual scenario, only Late can be used in unimodal downstream scenarios (c.f., Early requires the presence of both modalities). This has practical implications: Mid and Late can effectively handle missing modalities, i.e., once pretrained on audio-visual data, we can use it on any of audio-visual, audio-only, and visual-only scenarios. Our Mid fusion approach enjoys both the advantages, i.e., learning cross-modal relationship and being robust to missing modalities, achieving overall the best performance.
+Negative Sampling Strategies. We compare four strategies: (i) Current-Sequence takes all but the positive instance from the same sequence as negatives, (ii) Current-MiniBatch takes all but the positive instance in the mini-batch as negatives; this subsumes Current-Sequence, (iii) CANS-Dissimilar stochastically samples negatives using a modified version of our contentaware negative sampling (CANS) that favors dissimilar samples, and (iv) CANS-Similar is our proposed CANS approach that favors negatives that are similar to the positive instance.
+Table 1 (b) shows Current-Sequence is the least effective: It makes MEP too difficult because negatives are (sometimes too much) similar to positives. As a result, the training dynamics is dominated by CPP, which is relatively easier, leading to inferior performance. We make quite the contrary observations from Current-MiniBatch: the inclusion of negatives from different videos makes MEP easier and thus makes it dominate the training dynamics. Our CANS approach solves both these issues by eliminating negatives that are either almost identical to or trivial to distinguish from the positives, based on the $9 5 \%$ CI over the CNN embedding distances. It also samples negatives in a stochastic manner so a wide variety of samples can be included as negatives. Our proposed CANS-Similar can be considered as a “softened” version of Current-Sequence; it samples negatives that are similar to positives with a high probability (this can be considered as online hard negative mining), but it also takes instances from different videos with a lower probability. This balances out hard and easy negatives, making the MEP task effective.
+Parameter Sharing Schemes. Our parameter reduction scheme reduces the number of parameters from 128M to 4M (by $9 7 \%$ ) (Table 1 (c)). We reduce the model size by sharing weights across Transformers and across layers. We validate these ideas in two sets of experiments. Table 1 (c) compares cross-Transformer weight sharing schemes. We use $\mathrm { M u l t i } - 6$ that uses all three Transformers with 6 layers each, and compare four methods that correspond to Figure 2 (a)-(d). Note that No sharing is too large to fit in a Tesla V100 GPU (16GB) even with 2 samples, so we define Multi-2 that uses three Transformers with 2 layers each, and with the reduced number of attention heads $A$ to 5, the feature dimension $D$ to 320 and the intermediate dimension $E$ to 1280. We see that our proposed approach, Part, achieves the best performance with the least number of parameters. One might ask how Part leads to a smaller model when All shares all the weights across Transformers: We decompose weights $W = U \Sigma V ^ { \top }$ with low-rank approximation and share only $U$ across Transformers, while the $\bar { \Sigma } V ^ { \top }$ part learns modality-specific dynamics. Table 1 (d) compares cross-layer weight sharing schemes using the visual Transformer with either 2 $\left( \mathrm { \nabla } \mathrm { i } \mathrm { \mathbf { s } } - 2 \right)$ or $6 \left( \mathrm { V i } \thinspace \mathrm { s } - 6 \right)$ layers. The results show that sharing weights across layers does not hurt the performance, confirming the observations by Lan et al. (2020) in the audio-visual setting.
+Pretraining Objectives. To evaluate the importance of MEP and CPP tasks, we test two settings: (i) $\mathsf { M i d - w / o - C P P }$ and (ii) Mid-w/o-MEP. On Kinetics-Sounds, these achieve $6 5 . 9 \%$ and $6 4 . 6 \%$ respectively; ours achieve $6 7 . 5 \%$ (top-1 accuracy). The result show that the MEP task plays an important role during pretraining, confirming the findings from Sun et al. (2019a) that the InfoNCE
+<table><tr><td>a) Model</td><td>Net</td><td>Data</td><td>UCF</td><td>b) Model</td><td>Net</td><td>Data</td><td>ESC</td><td>c)Model</td><td>Charades</td><td>KS</td></tr><tr><td>ST-Puzzle</td><td>3D-R18</td><td>K400</td><td>65.8</td><td>SVM</td><td>MLP</td><td>-</td><td>39.6</td><td>Random</td><td>5.9</td><td>-/-</td></tr><tr><td>ClipOrder</td><td>R(2+1)D</td><td>UCF</td><td>72.4</td><td>ConvAE</td><td>CNN-4</td><td></td><td>39.9</td><td>ATF</td><td>18.3</td><td>-/-</td></tr><tr><td>DPC</td><td>3D-R34</td><td>K400</td><td>75.7</td><td>RF</td><td>MLP</td><td>=</td><td>44.3</td><td>ATF (OF)</td><td>22.4</td><td>-/-</td></tr><tr><td>CBT</td><td>S3D</td><td>K600</td><td>79.5</td><td>ConvNet</td><td>CNN-4</td><td>=</td><td>64.5</td><td>V-CNN</td><td>18.7</td><td>45.8/73.3</td></tr><tr><td>MultiSens</td><td>3D-R18</td><td>AS</td><td>82.1</td><td>SoundNet</td><td>CNN-8</td><td>FS</td><td>74.2</td><td>A-CNN</td><td>18.9</td><td>49.4 /76.9</td></tr><tr><td>AVTS</td><td>MC3-18</td><td>K400</td><td>85.8</td><td>L-Net</td><td>CNN-8</td><td>FS</td><td>79.3</td><td>M-CNN</td><td>23.1</td><td>59.4/83.6</td></tr><tr><td>AVTS</td><td>MC3-18</td><td>AS</td><td>89.0</td><td>DMC</td><td>VGG-ish</td><td>FS</td><td>79.8</td><td>V-BERT</td><td>26.0</td><td>49.5/78.9</td></tr><tr><td>V-CNN↑</td><td>SlowFast</td><td>K700</td><td>85.2</td><td>AVTS</td><td>VGG-M</td><td>AS</td><td>80.6</td><td>A-BERT</td><td>27.4</td><td>58.9 /85.7</td></tr><tr><td>V-CNNt</td><td>SlowFast</td><td>AS</td><td>86.1</td><td>A-CNN</td><td>R50</td><td>AS</td><td>81.5</td><td>M-BERT+</td><td>29.5</td><td>75.6 /94.6</td></tr></table>
+Datasets. K: Kinetics, AS: AudioSet, FS: Flicker-SoundNet, KS: Kinetics-Sounds. Baselines. ST-Puzzle (Kim et al., 2019), ClipOrder (Xu et al., 2019), DPC (Han et al., 2019), CBT (Sun et al., 2019a), MultiSens (Owens & Efros, 2018), AVTS (Korbar et al., 2018), AE (Aytar et al., 2016), SVM (Piczak, 2015a), RF (Piczak, 2015a), ConvNet (Piczak, 2015b), SoundNet (Aytar et al., 2016), $L ^ { 3 }$ -Net (Arandjelovic & Zisserman, 2017), DMC (Hu et al., 2019), ATF (Sigurdsson et al., 2017)
+Table 2: (a; left): Short video classification results on UCF101 (mean accuracy $( \% )$ ). (b; center): Short audio classification results on ESC-50 (mean accuracy $( \% )$ ). (c; right): Long video classification results on Charades (mAP) and Kinetics-Sounds (KS; top-1/5 accuracy $( \% )$ ). †: Ours.
+loss, as deployed in CBT, is effective in the cross-modal setting. The result also shows that augmenting MEP with CPP provides further performance improvement by learning cross-modal correspondence.
+Downstream Evaluation. We pretrain our model with Mid fusion using MEP and CPP tasks (with CANS-Similar), and employ Part weight sharing. We use either Kinetics-700 or AudioSet for fair comparisons with prior work. Table 2 (a)/(b) shows short-video/audio classification results on UCF-101/ESC-50. For fair comparisons to the baselines, we use only the visual/audio CNN (no Transformers); we finetune a linear classifier on top of the visual CNN end-to-end for UCF-101, and train a multi-class one-vs-all linear SVM on top of the fixed audio CNN for ESC-50. Although our model is pretrained on long video clips with no direct supervision to the CNN layers (gradients must flow through Transformers), it outperforms most of the baselines (except for AVTS on UCF-101) that received direct supervision from short video clips. We note that, similar to ours, CBT (Su et al., 2020) is a multimodal Transformer pretrained on long video clips and thus is the most meaningful comparison to ours; ours outperform CBT on UCF-101 by $5 . 7 \%$ . For sound classification, our approach outperform all existing published results.
+Table 2 (c) shows long-video classification results on Charades and Kinetics-Sounds (KS) when pretrained on Kinetics-700. We test Visual-only (V), Audio-only (A), and Multimodal (M) settings to verify the benefit of multimodal learning. Because there is no published selfsupervised learning results on these datasets, we demonstrate long-term representations by comparing CNNs (CNN; short-term) to Transformers (BERT; long-term) on KS that contains 10-second clips. Since CNNs process 1-second clips, we feed 10 non-overlapping clips to CNNs and average the prediction output. In all settings, we add a 2-layer MLP with softmax classifier on top. The results show that Transformers outperform CNNs on Kinetics-Sounds, suggesting the superiority of long-term representations. We also see that combining audio-visual information performs the best. We notice that audio representations are generally stronger than visual representations; we believe that learning discriminative visual representations is generally more challenging, especially when the CNNs receive (self-)supervision signals only indirectly through Transformers. We believe that providing (self-)supervision directly to CNNs, e.g., by first pretraining CNNs on 3D rotation prediction (Jing et al., 2018) and then jointly training the whole model (as was done in CBT (Sun et al., 2019a)), could further improve performance. Incorporating contrastive learning (Chen et al., 2020) over the CNN embeddings and training the whole model end-to-end is another promising direction for future work.
+# 4 RELATED WORK
+Multimodal BERT. Extending BERT (Devlin et al., 2019) to vision-and-language has been actively studied. Existing work typically adopt early fusion (Li et al., 2019; Alberti et al., 2019; Sun et al., 2019b; Li et al., 2020; Zhou et al., 2020; Su et al., 2020; Chen et al., 2019b; Zhu & Yang, 2020) or mid fusion (Tan & Bansal, 2019; Lu et al., 2019; Sun et al., 2019a; Luo et al., 2020) without thorough validation, and they train only visual components while relying on a language-pretrained BERT. Although there have been some efforts to leverage the Transformer architecture (Vaswani et al., 2017) for audio and visual inputs (Boes & Van hamme, 2019; Tian et al., 2020), our approach is the first to demonstrate multimodal audio-visual BERT trained from scratch in an end-to-end manner. This is enabled by our novel parameter reduction technique, which is one of our main technical contributions.
+Audio-Visual Learning. Early work in audio-visual learning focused on speech signals, improving audio-visual speech recognition than unimodal approaches (Ngiam et al., 2011; Srivastava & Salakhutdinov, 2012). Recent approaches leverage unlabeled videos from specific domains (Owens et al., 2016; Gao & Grauman, 2019; Zhao et al., 2018; Ephrat et al., 2018; Alwassel et al., 2019; Miech et al., 2020; Piergiovanni et al., 2020) and often demonstrate on audio-visual source separation, localization, and co-segmentation. However, these approaches rely on short-term audio-visual correspondence and thus may not generalize to long-term video recognition that requires global context (as was suggested in (Hjelm et al., 2019)), which this work focuses on.
+Parameter Reduction. Network pruning (Reed, 1993; Caron et al., 2020) trains a large model and then reduces its size while maintaining performance. Reducing the size of CNNs for mobile applications is an active research area (Rastegari et al., 2016; Howard et al., 2017; 2019; Zhang et al., 2018; Iandola et al., 2016). Our work is closely related to the work that shares parameters across layers in deep neural networks. Trellis network (Bai et al., 2019b) is a temporal convolutional architecture with weight-tying across time and depth. Similar to ours, Universal Transformer (Dehghani et al., 2019), RSNMT (Dabre & Fujita, 2019), DEQ (Bai et al., 2019a), ALBERT (Lan et al., 2020) share weights across layers in Transformers. We combine this idea with our novel cross-Transformer weight sharing, which decomposes weight matrices with low-rank approximation.
+Negative Sampling. Hard negative mining has been shown to be crucial for contrastive learning (Arandjelovic & Zisserman, 2017; Owens & Efros, 2018; Korbar et al., 2018; Schroff et al., 2015; Zhuang et al., 2019; Morgado et al., 2020; Wu et al., 2020). Korbar et al. (2018) use the time difference between clips to approximate clip similarity (i.e., clips that are further apart are deemed more different). However, such an assumption may not hold for real-world videos, e.g., periodic actions such as push-ups. Unlike this line of approaches, we directly use the feature embeddings learned by our model. Several apparoaches adapted a similar idea (Schroff et al., 2015; Zhuang et al., 2019; Morgado et al., 2020; Wu et al., 2020). Different from prior work, we bring the stochasticity to the sampling procedure by using the content similarity as the sampling probability; this helps reduce potential errors especially during the early stage of training.
+# 5 CONCLUSION
+We introduced a multimodal bidirectional Transformer architecture for self-supervised learning of contextualized audio-visual representation from unlabeled videos. Our main technical contributions include: (1) we propose a parameter efficient multimodal Transformers based on matrix decomposition with low-rank approximation; (2) we propose a novel content-aware negative sampling technique for contrastive learning. We demonstrate a successful end-to-end training of multimodal Transformers for audio-visual learning (which is, to the best of our knowledge, the first time in the literature). We also report comprehensive evaluation of various design decisions in multimodal learning.
+Acknowledgements. This work was partially supported by Institute of Information & communications Technology Planning & Evaluation (IITP) grant funded by the Korea government (MSIT) (No.2017-0-01772, Video Turing Test, No.2019-0-01082, SW StarLab) and the international cooperation program by the NRF of Korea (NRF-2018K2A9A2A11080927).
+# REFERENCES
+Chris Alberti, Jeffrey Ling, Michael Collins, and David Reitter. Fusion of Detected Objects in Text for Visual Question Answering. In EMNLP-IJCNLP, 2019.
+Humam Alwassel, Dhruv Mahajan, Lorenzo Torresani, Bernard Ghanem, and Du Tran. SelfSupervised Learning by Cross-Modal Audio-Video Clustering. arXiv preprint arXiv:1911.12667, 2019.
+Relja Arandjelovic and Andrew Zisserman. Look, Listen and Learn. In ICCV, 2017.
+Relja Arandjelovic and Andrew Zisserman. Objects that Sound. In ECCV, 2018.
+Yusuf Aytar, Carl Vondrick, and Antonio Torralba. SoundNet: Learning Sound Representations from Unlabeled Video. In NeurIPS, 2016.
+Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer Normalization. In NeurIPS Deep Learning Symposium, 2016.
+Shaojie Bai, J. Zico Kolter, and Vladlen Koltun. Deep Equilibrium Models. In NeurIPS, 2019a.
+Shaojie Bai, J Zico Kolter, and Vladlen Koltun. Trellis Networks for Sequence Modeling. In ICLR, 2019b.
+Tadas Baltrušaitis, Chaitanya Ahuja, and Louis-Philippe Morency. Multimodal Machine Learning: A Survey and Taxonomy. IEEE Transactions on Pattern Analysis and Machine Intelligence, 41(2): 423–443, 2018.
+Wim Boes and Hugo Van hamme. Audiovisual Transformer Architectures for Large-Scale Classification and Synchronization of Weakly Labeled Audio Events. In ACM MM, 2019.
+Mathilde Caron, Ari Morcos, Piotr Bojanowski, Julien Mairal, and Armand Joulin. Pruning Convolutional Neural Networks with Self-Supervision. arXiv preprint arXiv:2001.03554, 2020.
+Joao Carreira, Eric Noland, Chloe Hillier, and Andrew Zisserman. A Short Note on the Kinetics-700 Human Action Dataset. arXiv preprint arXiv:1907.06987, 2019.
+Beidi Chen, Weiyang Liu Animesh Garg, Zhiding Yu, Anshumali Shrivastava, Jan Kautz, and Anima Anandkumar. Angular Visual Hardness. In ICML Workshop on Identifying and Understanding Deep Learning Phenomena, 2019a.
+Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A Simple Framework for Contrastive Learning of Visual Representations. arXiv preprint arXiv:2002.05709, 2020.
+Yen-Chun Chen, Linjie Li, Licheng Yu, Ahmed El Kholy, Faisal Ahmed, Zhe Gan, Yu Cheng, and Jingjing Liu. UNITER: UNiversal Image-TExt Representation Learning. arXiv preprint arXiv:1909.11740, 2019b.
+Kyunghyun Cho, Bart Van Merriënboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Holger Schwenk, and Yoshua Bengio. Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation. In EMNLP, 2014.
+Raj Dabre and Atsushi Fujita. Recurrent Stacking of Layers for Compact Neural Machine Translation Models. In AAAI, 2019.
+Mostafa Dehghani, Stephan Gouws, Oriol Vinyals, Jakob Uszkoreit, and Łukasz Kaiser. Universal Transformers. In ICLR, 2019.
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. In NAACL-HLT, 2019.
+Ariel Ephrat, Inbar Mosseri, Oran Lang, Tali Dekel, Kevin Wilson, Avinatan Hassidim, William T Freeman, and Michael Rubinstein. Looking to Listen at the Cocktail Party: A Speaker-Independent Audio-Visual Model for Speech Separation. ACM Transactions on Graphics, 37(4), 2018.
+Christoph Feichtenhofer, Haoqi Fan, Jitendra Malik, and Kaiming He. SlowFast Networks for Video Recognition. In ICCV, 2019.
+Ruohan Gao and Kristen Grauman. 2.5D Visual Sound. In CVPR, 2019.
+Jort F. Gemmeke, Daniel P. W. Ellis, Dylan Freedman, Aren Jansen, Wade Lawrence, R. Channing Moore, Manoj Plakal, and Marvin Ritter. Audio Set: An Ontology and Human-Labeled Dataset for Audio Events. In ICASSP, 2017.
+Gene H Golub and Charles F Van Loan. Matrix Computations, volume 3. JHU press, 2012.
+Chunhui Gu, Chen Sun, David A Ross, Carl Vondrick, Caroline Pantofaru, Yeqing Li, Sudheendra Vijayanarasimhan, George Toderici, Susanna Ricco, Rahul Sukthankar, et al. AVA: A Video Dataset of Spatio-temporally Localized Atomic Visual Actions. In CVPR, 2018.
+Michael Gutmann and Aapo Hyvärinen. Noise-Contrastive Estimation: A New Estimation Principle for Unnormalized Statistical Models. In AISTATS, 2010.
+Tengda Han, Weidi Xie, and Andrew Zisserman. Video Representation Learning by Dense Predictive Coding. In ICCV Workshop on Large Scale Holistic Video Understanding, 2019.
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep Residual Learning for Image Recognition. In CVPR, 2016.
+Dan Hendrycks and Kevin Gimpel. Gaussian Error Linear Units (GELUs). arXiv preprint arXiv:1606.08415, 2016.
+R Devon Hjelm, Alex Fedorov, Samuel Lavoie-Marchildon, Karan Grewal, Phil Bachman, Adam Trischler, and Yoshua Bengio. Learning deep representations by mutual information estimation and maximization. In ICLR, 2019.
+Sepp Hochreiter and Jürgen Schmidhuber. Long Short-Term Memory. Neural computation, 9(8): 1735–1780, 1997.
+Andrew Howard, Mark Sandler, Grace Chu, Liang-Chieh Chen, Bo Chen, Mingxing Tan, Weijun Wang, Yukun Zhu, Ruoming Pang, Vijay Vasudevan, et al. Searching for MobileNetV3. In ICCV, 2019.
+Andrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications. arXiv preprint arXiv:1704.04861, 2017.
+Jeremy Howard and Sebastian Ruder. Universal Language Model Fine-tuning for Text Classification. In ACL, 2018.
+Di Hu, Feiping Nie, and Xuelong Li. Deep Multimodal Clustering for Unsupervised Audiovisual Learning. In CVPR, 2019.
+Forrest N Iandola, Song Han, Matthew W Moskewicz, Khalid Ashraf, William J Dally, and Kurt Keutzer. SqueezeNet: AlexNet-level accuracy with 50x fewer parameters and ${ < } 0 . 5 \mathrm { M B }$ model size. arXiv preprint arXiv:1602.07360, 2016.
+Longlong Jing, Xiaodong Yang, Jingen Liu, and Yingli Tian. Self-Supervised Spatiotemporal Feature Learning via Video Rotation Prediction. arXiv preprint arXiv:1811.11387, 2018.
+Will Kay, Joao Carreira, Karen Simonyan, Brian Zhang, Chloe Hillier, Sudheendra Vijayanarasimhan, Fabio Viola, Tim Green, Trevor Back, Paul Natsev, et al. The Kinetics Human Action Video Dataset. arXiv preprint arXiv:1705.06950, 2017.
+Evangelos Kazakos, Arsha Nagrani, Andrew Zisserman, and Dima Damen. EPIC-Fusion: AudioVisual Temporal Binding for Egocentric Action Recognition. In ICCV, 2019.
+Dahun Kim, Donghyeon Cho, and In So Kweon. Self-Supervised Video Representation Learning with Space-Time Cubic Puzzles. In AAAI, 2019.
+Bruno Korbar, Du Tran, and Lorenzo Torresani. Cooperative Learning of Audio and Video Models from Self-Supervised Synchronization. In NeurIPS, 2018.
+Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, and Radu Soricut. ALBERT: A Lite BERT for Self-supervised Learning of Language Representations. In ICLR, 2020.
+Mario Lezcano-Casado and David Martínez-Rubio. Cheap Orthogonal Constraints in Neural Networks: A Simple Parametrization of the Orthogonal and Unitary Group. In ICML, 2019.
+Gen Li, Nan Duan, Yuejian Fang, Min Gong, Daxin Jiang, and Ming Zhou. Unicoder-VL: A Universal Encoder for Vision and Language by Cross-modal Pre-training. In AAAI, 2020.
+Liunian Harold Li, Mark Yatskar, Da Yin, Cho-Jui Hsieh, and Kai-Wei Chang. VisualBERT: A Simple and Performant Baseline for Vision and Language. arXiv preprint arXiv:1908.03557, 2019.
+Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. RoBERTa: A Robustly Optimized BERT Pretraining Approach. arXiv preprint arXiv:1907.11692, 2019.
+Ilya Loshchilov and Frank Hutter. Decoupled Weight Decay Regularization. In ICLR, 2019.
+Jiasen Lu, Dhruv Batra, Devi Parikh, and Stefan Lee. ViLBERT: Pretraining Task-Agnostic Visiolinguistic Representations for Vision-and-Language Tasks. In NeurIPS, 2019.
+Huaishao Luo, Lei Ji, Botian Shi, Haoyang Huang, Nan Duan, Tianrui Li, Xilin Chen, and Ming Zhou. UniViLM: A Unified Video and Language Pre-Training Model for Multimodal Understanding and Generation. arXiv preprint arXiv:2002.06353, 2020.
+Antoine Miech, Jean-Baptiste Alayrac, Lucas Smaira, Ivan Laptev, Josef Sivic, and Andrew Zisserman. End-to-End Learning of Visual Representations from Uncurated Instructional Videos. In CVPR, 2020.
+Pedro Morgado, Nuno Vasconcelos, and Ishan Misra. Audio-Visual Instance Discrimination with Cross-Modal Agreement. arXiv preprint arXiv:2004.12943, 2020.
+Jiquan Ngiam, Aditya Khosla, Mingyu Kim, Juhan Nam, Honglak Lee, and Andrew Y Ng. Multimodal Deep Learning. In ICML, 2011.
+Jorge Nocedal and Stephen Wright. Numerical Optimization. Springer Science & Business Media, 2006.
+Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation Learning with Contrastive Predictive Coding. arXiv preprint arXiv:1807.03748, 2018.
+Andrew Owens and Alexei A Efros. Audio-Visual Scene Analysis with Self-Supervised Multisensory Features. In ECCV, 2018.
+Andrew Owens, Phillip Isola, Josh McDermott, Antonio Torralba, Edward H Adelson, and William T Freeman. Visually Indicated Sounds. In CVPR, 2016.
+Andrew Owens, Jiajun Wu, Josh H McDermott, William T Freeman, and Antonio Torralba. Learning Sight from Sound: Ambient Sound Provides Supervision for Visual Learning. International Journal of Computer Vision, 126(10):1120–1137, 2018.
+Daniel S Park, William Chan, Yu Zhang, Chung-Cheng Chiu, Barret Zoph, Ekin D Cubuk, and Quoc V Le. SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition. In INTERSPEECH, 2019.
+Mandela Patrick, Yuki M Asano, Ruth Fong, João F Henriques, Geoffrey Zweig, and Andrea Vedaldi. Multi-modal Self-Supervision from Generalized Data Transformations. arXiv preprint arXiv:2003.04298, 2020.
+Matthew E Peters, Mark Neumann, Mohit Iyyer, Matt Gardner, Christopher Clark, Kenton Lee, and Luke Zettlemoyer. Deep Contextualized Word Representations. In NAACL-HLT, 2018.
+Karol J. Piczak. ESC: Dataset for Environmental Sound Classification. In ACM-MM, 2015a.
+Karol J. Piczak. Environmental Sound Classification with Convolutional Neural Networks. In MLSP, 2015b.
+AJ Piergiovanni, Anelia Angelova, and Michael S Ryoo. Evolving Losses for Unsupervised Video Representation Learning. In CVPR, 2020.
+Alec Radford, Karthik Narasimhan, Tim Salimans, and Ilya Sutskever. Improving Language Understanding by Generative Pre-Training. Techincal Report, OpenAI, 2018.
+Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. Language Models are Unsupervised Multitask Learners. OpenAI Blog, 1(8), 2019.
+Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. XNOR-Net: ImageNet Classification Using Binary Convolutional Neural Networks. In ECCV, 2016.
+Sashank J Reddi, Satyen Kale, and Sanjiv Kumar. On the Convergence of Adam and Beyond. In ICLR, 2018.
+Russell Reed. Pruning Algorithms-A Survey. IEEE Transactions on Neural Networks, 4(5):740–747, 1993.
+Florian Schroff, Dmitry Kalenichenko, and James Philbin. FaceNet: A Unified Embedding for Face Recognition and Clustering. In CVPR, 2015.
+Gunnar A Sigurdsson, Gül Varol, Xiaolong Wang, Ali Farhadi, Ivan Laptev, and Abhinav Gupta. Hollywood in Homes: Crowdsourcing Data Collection for Activity Understanding. In ECCV, 2016.
+Gunnar A Sigurdsson, Santosh Divvala, Ali Farhadi, and Abhinav Gupta. Asynchronous Temporal Fields for Action Recognition. In CVPR, 2017.
+Khurram Soomro, Amir Roshan Zamir, and Mubarak Shah. UCF101: A Dataset of 101 Human Action Classes From Videos in The Wild. CRCV-TR-12-01, 2012.
+Nitish Srivastava and Russ R Salakhutdinov. Multimodal Learning with Deep Boltzmann Machines. In NeurIPS, 2012.
+Weijie Su, Xizhou Zhu, Yue Cao, Bin Li, Lewei Lu, Furu Wei, and Jifeng Dai. VL-BERT: Pre-training of Generic Visual-Linguistic Representations. In ICLR, 2020.
+Chen Sun, Fabien Baradel, Kevin Murphy, and Cordelia Schmid. Learning Video Representations using Contrastive Bidirectional Transformer. arXiv preprint arXiv:1906.05743, 2019a.
+Chen Sun, Austin Myers, Carl Vondrick, Kevin Murphy, and Cordelia Schmid. VideoBERT: A Joint Model for Video and Language Representation Learning. In ICCV, 2019b.
+Hao Tan and Mohit Bansal. LXMERT: Learning Cross-Modality Encoder Representations from Transformers. In EMNLP-IJCNLP, 2019.
+Yapeng Tian, Dingzeyu Li, and Chenliang Xu. Unified Multisensory Perception: Weakly-Supervised Audio-Visual Video Parsing. In ECCV, 2020.
+Dmitry Ulyanov, Andrea Vedaldi, and Victor Lempitsky. Deep Image Prior. In CVPR, 2018.
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention Is All You Need. In NeurIPS, 2017.
+Mike Wu, Chengxu Zhuang, Milan Mosse, Daniel Yamins, and Noah Goodman. On Mutual Information in Contrastive Learning for Visual Representations. arXiv preprint arXiv:2005.13149, 2020.
+Dejing Xu, Jun Xiao, Zhou Zhao, Jian Shao, Di Xie, and Yueting Zhuang. Self-supervised Spatiotemporal Learning via Video Clip Order Prediction. In CVPR, 2019.
+Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Russ R Salakhutdinov, and Quoc V Le. XLNet: Generalized Autoregressive Pretraining for Language Understanding. In NeurIPS, 2019.
+Xiangyu Zhang, Xinyu Zhou, Mengxiao Lin, and Jian Sun. ShuffleNet: An Extremely Efficient Convolutional Neural Network for Mobile Devices. In CVPR, 2018.
+Hang Zhao, Chuang Gan, Andrew Rouditchenko, Carl Vondrick, Josh McDermott, and Antonio Torralba. The Sound of Pixels. In ECCV, 2018.
+Luowei Zhou, Hamid Palangi, Lei Zhang, Houdong Hu, Jason J Corso, and Jianfeng Gao. Unified Vision-Language Pre-Training for Image Captioning and VQA. In AAAI, 2020.
+Linchao Zhu and Yi Yang. ActBERT: Learning Global-Local Video-Text Representations. In CVPR, 2020.
+Chengxu Zhuang, Alex Lin Zhai, and Daniel Yamins. Local Aggregation for Unsupervised Learning of Visual Embeddings. In ICCV, 2019.
+# A IMPLEMENTATION DETAILS
+# A.1 ARCHITECTURES OF VISUAL/AUDIO CNNS
+Table 3 shows the architectures of visual and audio CNNs we use for our model. For the visual CNN, we use the SlowFast network (Feichtenhofer et al., 2019) with a ResNet-50 backbone (He et al., 2016). We use the speed ratio $\alpha = 8$ and the channel ratio $\beta = 1 / 8$ for the SlowFast architecture, so $T _ { f } = 8 \times T _ { s }$ . We use different values of $T _ { s }$ and $T _ { f }$ for different tasks. During pretraining, we set $\dot { T } _ { s } = 4$ and $T _ { f } = 3 2$ . During finetuning, we use $\mathrm { { \dot { } } } T _ { s } = 8$ and $T _ { f } = 6 4$ for short-video action classification on UCF101 (Soomro et al., 2012) while we use $T _ { s } = 4$ and $T _ { f } = 3 2$ for long-video action classification on Charades (Sigurdsson et al., 2016) and Kinetics-Sounds (Arandjelovic & Zisserman, 2017). For the audio CNN, we use a ResNet-50 without the downsampling layer $\mathsf { p o o l } _ { 1 }$ to preserve information along both frequency and time axis in early stages. We use different values of $T _ { a }$ for different training phases. We set $T _ { a } = 2 2 0$ for one-second clip during pretraining while we use $T _ { a } = 4 4 0$ for two-second clip during finetuning.
+Table 3: The architectures of visual and audio CNNs. For the visual CNN, the input dimensions are denoted by {channel size, temporal size, spatial $s i z e ^ { 2 } \}$ , kernels are denoted by {temporal size, spatial $s i z e ^ { 2 }$ , channel size} and strides are denoted by {temporal stride, spatial stride $\mathrm { ~ \bar { ~ } { ~ } ~ } ^ { 2 } \}$ . For the audio CNN, the input dimensions are denoted by {frequency size, temporal size}, kernels are denoted by {frequency size, time size, channel size} and strides are denoted by {frequency stride, temporal stride}.
+<table><tr><td rowspan=2 colspan=1> Stage</td><td rowspan=1 colspan=6>Visual CNN</td><td rowspan=2 colspan=2>Audio CNN</td></tr><tr><td rowspan=1 colspan=3>Slow pathway</td><td rowspan=1 colspan=3>Fast pathway</td></tr><tr><td rowspan=1 colspan=1>raw clip</td><td rowspan=1 colspan=3>3×Ts×112²</td><td rowspan=1 colspan=3>3×Tf × 112²</td><td rowspan=1 colspan=2>128×Ta</td></tr><tr><td rowspan=1 colspan=1>conV1</td><td rowspan=1 colspan=3>1 × 7²,64stride 1,2</td><td rowspan=1 colspan=3>5×7²,8stride 1, 22</td><td rowspan=1 colspan=2>9×9,32stride 1, 1</td></tr><tr><td rowspan=1 colspan=1>pool</td><td rowspan=1 colspan=3>1 ×3²,maxstride 1, 2²</td><td rowspan=1 colspan=3>1 × 3²,maxstride 1,22</td><td rowspan=1 colspan=2></td></tr><tr><td rowspan=1 colspan=1>res2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1²,641×3²,641 ×1²,256</td><td rowspan=1 colspan=1>x3</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>3×1²,81×3²,81 × 1²,32</td><td rowspan=1 colspan=1>×3</td><td rowspan=1 colspan=2>[1×1,32]3×3,32×3[1 × 1,128]</td></tr><tr><td rowspan=1 colspan=1>res3</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1 ×1²,1281 ×3²,128[1 × 1²,512</td><td rowspan=1 colspan=1>×4</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>3×1²,161×3²,161 × 1²,64</td><td rowspan=1 colspan=1>×4</td><td rowspan=1 colspan=2>[1×1,64]3×3,64×4[1 × 1,256]</td></tr><tr><td rowspan=1 colspan=1>res4</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>3 ×1²,2561 × 3²,2561 × 1²,1024</td><td rowspan=1 colspan=1>×6</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>3×1²,321×3²,321 × 1²,128</td><td rowspan=1 colspan=1>×6</td><td rowspan=1 colspan=1>[1 ×1,128]3×3,128[1 × 1,512]</td><td rowspan=1 colspan=1>×6</td></tr><tr><td rowspan=1 colspan=1>res5</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>3 × 1²,5121× 3²,5121 ×1²,2048</td><td rowspan=1 colspan=1>×3</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>3×1²,641× 3²,641 ×1²,256</td><td rowspan=1 colspan=1>×3</td><td rowspan=1 colspan=2>[1×1,256]3×3,256×3[1×1,1024]</td></tr></table>
+# A.2 DATA PREPROCESSING
+We preprocess the data by dividing $T$ -second clips into $T$ non-overlapping parts ( $T = 3 0$ for Kinetics700 (Carreira et al., 2019) and $T = 1 0$ for AudioSet (Gemmeke et al., 2017)) and sampling 16 frames from each. For audio stream, we take waveform sampled at $4 4 . 1 \mathrm { k H z }$ and convert it to log-mel-scaled spectrogram. We augment audio data with random frequency/time masking using SpecAugment (Park et al., 2019), and visual data with color normalization, random resizing, random horizontal flip, and random cropping to obtain $1 1 2 \times 1 1 2$ pixel frames; for test data, we resize videos to 128 pixels on the shorter side and take three equidistant crops of $1 2 8 \times 1 2 8$ pixels to cover the entire region. We also apply audio-visual synchronized temporal jittering (Patrick et al., 2020).
+![](images/a884a15853da6aa7603f4f7a16f94798b41470b09c1b8ca6795f0b06f3ce69c6.jpg)
+Figure 3: Loss curves during pretraining under different ablative settings. (a) compares ContentAware Negative Sampling (CANS) that favors negatives that are dissimilar vs. similar to the positive instance. (b) compares different cross-Transformer weight sharing schemes; see the text for details.
+# A.3 DOWNSTREAM EVALUATION
+For evaluation on UCF101, we follow the test protocol of (Feichtenhofer et al., 2019): We sample 10 clips from each test video at a uniform time interval, and for each sampled clip, we take three equidistant spatial crops, resulting in a total of 30 views. We use each of the 30 views as input to our visual CNN and average the prediction scores from all 30 views to obtain the final prediction result. For evaluation on ESC-50 (Piczak, 2015a), we extract 10 equally spaced 2-second clips from each test audio sample. We use each of 10 clips as input to our audio CNN and average the prediction scores to obtain the final prediction result. For evaluation on Charades and Kinetics-Sounds, we use three audio-visual sequences with different spatial crops from a test video and max-pool/average the prediction scores from each sequence, respectively.
+# A.4 OPTIMIZATION
+In all experiments, we use the AMSGrad (Reddi et al., 2018) variant of AdamW (Loshchilov & Hutter, 2019) optimizer with $\beta _ { 1 } = 0 . 9$ , $\beta _ { 2 } = 0 . 9 8$ , L2 weight decay of 1e-4. We use a learning rate warm-up for the first $6 \%$ of iterations followed by a linear decay of learning rate.
+From the observations of Lezcano-Casado and Martínez-Rubio (Lezcano-Casado & Martínez-Rubio, 2019), we have 10 times less learning rate for the orthogonal parameters than that for the nonorthogonal parameters: we use 1e-5 for the former and 1e-4 for the latter.
+We pretrain our model on Kinetics-700 (Carreira et al., 2019) with a batch size 256 for 220K iterations and AudioSet (Gemmeke et al., 2017) with a batch size 300 for 220K iterations in the main experiments; for the ablation study, we use a much smaller batch size of 4 and pretrain our model on Kinetics-700 for 80K iterations.
+For finetuning on UCF101, we train our model for 40K iterations with a batch size of 64 and learning rate of 0.02. For evaluation on ESC-50, we train a multi-class one-vs-all linear SVM on top of our fixed audio CNN for 38K iterations with a batch size of 128 and learning rate of 0.003. For finetuning on Charades, we train for 40K iterations with a batch size of 8, with learning rate of 0.001 for the classifier and CNN parameters, 1e-5 for the orthogonal parameters and 1e-4 for the rest parameters. For finetuning on Kinetics-Sounds, we train for 24K iterations with a batch size of 32, with learning rate of 0.005 for the classifier and CNN parameters, 1e-4 for the orthogonal parameters and 1e-3 for the rest parameters.
+# B EXTRA RESULTS FROM THE ABLATION STUDY
+# B.1 NEGATIVE SAMPLING STRATEGIES
+We proposed the content-aware negative sampling strategy (CANS) using pairwise $l _ { 2 }$ distances between CNN embeddings. We introduced two variants of CANS: CANS-Dissimilar that favors negatives that are dissimilar to the positive instance and CANS-Similar that favors negatives that are similar to the positive instance. We chose to use CANS-Similar based on the results from our ablation study presented in the main paper, Table 1 (b).
+Figure 3 (a) in this appendix provides additional evidence that supports our decision. We see that the loss of CANS-Disimilar initially drops rapidly but starts increasing around iteration 7K and continues to increase until around 15K; this is mainly caused by the visual MEP loss shown in Figure 3 (a-2). One explanation for this might that CANS-Disimilar is easier to solve than CANS-Similar, which causes the loss landscape of CANS-Disimilar to contain too many shallow local minima compared to that of CANS-Similar. Recall that we use a learning rate warm-up for the first $6 \%$ of iterations during pretraining; this roughly equals to the first 13K (out of 220K) iterations. Given this, we speculate that the model got out of a local minima around iteration 7K (most likely due to the increasing learning rate), and then eventually settled in another (bad) local minima after the warm-up period ended. Compared to this, we observe much milder learning dynamics with CANS-Similar: the loss decreases relatively slowly but steadily, and eventually leaps around 35K to go below the loss of CANS-Disimilar. We, again, believe that this is because CANS-Similar is more difficult to solve than CANS-Disimilar (as shown by the slower decrease in loss values), which caused the resulting loss landscape to contain steeper local minima. Our model eventually found one of those after round 40K of iterations, resulting in a better performing model in the downstream tasks shown in Table 1 (b) of the main paper (the loss kept slowly decreasing after iteration 50K).
+# B.2 PARAMETER SHARING SCHEMES
+We proposed a cross-Transformer weight sharing technique, which decomposes weight matrices with low-rank approximation. Recall that each layer of a Transformer contains the multi-head attention layer weights $\{ W ^ { q } , W ^ { k } , W ^ { v } , W ^ { b } \}$ and the feed-forward layer weights $\{ W ^ { c } , W ^ { d } \}$ . We chose to share all six weight matrices across Transformers, though we could have shared any combination of them. To justify this design choice, we empirically compared three variants: (i) $\mathrm { M u l t i } - 6$ that do not share parameters across Transformers, (ii) Multi-6-Part_Att that shares only $\{ W ^ { q } , W ^ { k } , W ^ { v } , W ^ { b } \}$ (but not $\{ W ^ { c } , W ^ { d } \} _ { \ r }$ ) and (iii) $\mathtt { M u l t i - 6 - P a r t }$ that shares all six weight matrices. Figure 3 (b) shows that there is not much difference between all the variants in terms of the loss curves; we chose to use Multi-6-Part that requires the least number of parameters. We showed that our approach outperforms Multi-6 in the ablation study (Table 1 (c-left) in the main paper).
+# B.3 JUSTIFICATION FOR THE MEP LOSS FORMULATION
+Since the multimodal Transformer $h _ { A V }$ has access to both visual and audio inputs, one might think that the model could “leak” information about visual input into $\mathbf { z } ^ { a }$ and information about audio input into $\mathbf { z } ^ { v }$ , which could make MEP trivial to solve. Here we show that this is not the case. By construction, we mask the same positions in audio and visual streams when designing the MEP task, so the model has no access to the masked input even in a cross-modal manner. Empirically, removing the third term in Eq. 6 $( \mathcal { L } _ { \mathrm { N C E } } \big ( \big [ \mathbf { x } ^ { a } ; \mathbf { x } ^ { v } \big ] , \tilde { \mathbf { z } } \big ) )$ leads to performance degradation in Kinetics-Sounds, i.e., top-1 accuracy $6 6 . 7 \%$ vs. ours $6 7 . 5 \%$ (see Table 1), which suggests that solving the MEP task in the multimodal Transformer is beneficial to our model.
+# B.4 JUSTIFICATION FOR THE CPP LOSS FORMULATION
+Recall that our CPP loss has two terms; the first term uses the summary embeddings ${ \bf s } _ { g }$ and the second term uses output embeddings ${ \mathbf { s } } _ { h }$ sampled at random positions; see Eq. 7. One could argue that the two terms are redundant as bidirectional Transformers have “one-step” access to all the input embeddings, and thus solving CPP only with the summary embeddings (the first term) would be enough. This is not the case. We encode ${ \bf s } _ { h }$ with position-specific information through the time embeddings $\mathbf { p } _ { t }$ , which makes every ${ \mathbf { s } } _ { h }$ different compared to ${ \bf s } _ { g }$ . Empirically, we find that removing the second term of Eqn. 7 $\left( \mathbf { s } _ { h } \right)$ in our CPP loss leads to an inferior accuracy $6 6 . 9 \%$ vs. ours $67 . 5 \%$ on Kinetics-Sounds, suggesting its importance in learning.
+# B.5 USE OF MODALITY EMBEDDINGS IN THE MULTIMODAL TRANSFORMER
+We use modality embeddings $\mathbf { m } ^ { v }$ and $\mathbf { m } ^ { a }$ as part of input to the multimodal Transformer in order to distinguish embeddings coming from visual and audio Transformers. They are learnable weights trained end-to-end with other parameters. Conceptually, incorporating modality-discriminative embeddings is crucial because of our aggressive weight sharing scheme. Without them, the multimodal Transformer will see the output from audio/visual Transformers $\boldsymbol y ^ { a }$ and $y ^ { v }$ ) as if they are coming from the same distribution because the two Transformers share a large part of weights. Using modality embeddings encourages our model to preserve modality-specific information in the final output, and this empirically leads to performance improvements: ours $6 7 . 5 \%$ vs. without modality embeddings $6 7 . 1 \%$ on Kinetics-Sounds.
+# B.6 ON THE IMPORTANCE OF END-TO-END PRETRAINING
+Previous work in multimodal visual-and-language tasks (Tan & Bansal, 2019; Lu et al., 2019) point out that using partially fixed Transformers of different modalities is detrimental to multimodal representation learning (c.f., Sun et al. (2019a;b)). We make the same observation in our audiovisual learning scenario. We compare two variants of Multi-6 Part in Table 1 (c), each of which pretrains only the audio (or visual) CNN/Transformer in the first half of pretraining stage and then continues pretraining the remaining weights while fixing the weights of the audio (or visual) CNN/Transformer in the second half. This leads to inferior performance (audio-fixed $6 2 . 8 \%$ and visual-fixed $6 3 . 1 \%$ vs. ours $6 7 . 5 \%$ ), which is consistent with the results reported in Tan & Bansal (2019); Lu et al. (2019).

parse/train/6UdQLhqJyFD/6UdQLhqJyFD_content_list.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/6UdQLhqJyFD/6UdQLhqJyFD_middle.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/6UdQLhqJyFD/6UdQLhqJyFD_model.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/HJfQrs0qt7/HJfQrs0qt7_content_list.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/SkaPsfZ0W/SkaPsfZ0W.md ADDED Viewed

	@@ -0,0 +1,409 @@

+# NETWORK OF GRAPH CONVOLUTIONAL NETWORKS TRAINED ON RANDOM WALKS
+Anonymous authors Paper under double-blind review
+# ABSTRACT
+Graph Convolutional Networks (GCNs) are a recently proposed architecture which has had success in semi-supervised learning on graph-structured data. At the same time, unsupervised learning of graph embeddings has benefited from the information contained in random walks. In this paper we propose a model, Network of GCNs (N-GCN), which marries these two lines of work. At its core, N-GCN trains multiple instances of GCNs over node pairs discovered at different distances in random walks, and learns a combination of the instance outputs which optimizes the classification objective. Our experiments show that our proposed NGCN model achieves state-of-the-art performance on all of the challenging node classification tasks we consider: Cora, Citeseer, Pubmed, and PPI. In addition, our proposed method has other desirable properties, including generalization to recently proposed semi-supervised learning methods such as GraphSAGE, allowing us to propose N-SAGE, and resilience to adversarial input perturbations.
+# 1 INTRODUCTION
+Semi-supervised learning on graphs is important in many real-world applications, where the goal is to recover labels for all nodes given only a fraction of labeled ones. Some applications include social networks, where one wishes to predict user interests, or in health care, where one wishes to predict whether a patient should be screened for cancer. In many such cases, collecting node labels can be prohibitive. However, edges between nodes can be easier to obtain, either using an explicit graph (e.g. social network) or implicitly by calculating pairwise similarities (e.g. using a patient-patient similarity kernel, Merdan et al., 2017).
+Convolutional Neural Networks (LeCun et al., 1998) learn location-invariant hierarchical filters, enabling significant improvements on Computer Vision tasks (Krizhevsky et al., 2012; Szegedy et al., 2015; He et al., 2016). This success has motivated researchers (Bruna et al., 2014) to extend convolutions from spatial (i.e. regular lattice) domains to graph-structured (i.e. irregular) domains, yielding a class of algorithms known as Graph Convolutional Networks (GCNs).
+Formally, we are interested in semi-supervised learning where we are given a graph $\mathcal { G } = ( \nu , \mathcal { E } )$ with $N = | \nu |$ nodes; adjacency matrix $A$ ; and matrix $\mathbf { \Psi } _ { X } \in \mathbb { R } ^ { N \times F }$ of node features. Labels for only a subset of nodes $\nu _ { L } \subset \nu$ observed. In general, $| \mathcal { V } _ { L } | \ll | \mathcal { V } |$ . Our goal is to recover labels for all unlabeled nodes $\mathcal { V } _ { U } = \mathcal { V } - \mathcal { V } _ { L }$ , using the feature matrix $X$ , the known labels for nodes in $\gamma _ { L }$ , and the graph $G$ . In this setting, one treats the graph as the “unsupervised” and labels of $\gamma _ { L }$ as the “supervised” portions of the data.
+Depicted in Figure 1, our model for semi-supervised node classification builds on the GCN module proposed by Kipf & Welling (2017), which operates on the normalized adjacency matrix $\hat { A }$ , as in $\mathrm { G C N } ( { \hat { A } } )$ , where $\hat { A } = D ^ { - \frac { 1 } { 2 } } A D ^ { - \frac { 1 } { 2 } }$ , and $D$ is diagonal matrix of node degrees. Our proposed extension of GCNs is inspired by the recent advancements in random walk based graph embeddings (e.g. Perozzi et al., 2014; Grover & Leskovec, 2016; Abu-El-Haija et al., 2017). We make a Network of GCN modules (N-GCN), feeding each module a different power of $\hat { A }$ , as in $\{ \mathrm { G C N } ( \hat { A } ^ { 0 } ) , \mathrm { G C N } ( \hat { A } ^ { 1 } ) , \mathrm { G C N } ( \hat { A } ^ { 2 } ) , \dots \}$ . The $k$ -th power contains statistics from the $k$ -th step of a random walk on the graph. Therefore, our N-GCN model is able to combine information from various step-sizes. We then combine the output of all GCN modules into a classification sub-network, and we jointly train all GCN modules and the classification sub-network on the upstream objective, semi-supervised node classification. Weights of the classification sub-network give us insight on how the N-GCN model works. For instance, in the presence of input perturbations, we observe that the classification sub-network weights shift towards GCN modules utilizing higher powers of the adjacency matrix, effectively widening the “receptive field” of the (spectral) convolutional filters. We achieve state-of-the-art on several semi-supervised graph learning tasks, showing that explicit random walks enhance the representational power of vanilla GCN’s.
+![](images/991a2af6381889f75b8a8cb0aa21827ce958d82a66b177e0ba94be2399ff1a67.jpg)
+Figure 1: Left: Model architecture, where $\hat { A }$ is the normalized normalized adjacency matrix, $I$ is the identity matrix, $X$ is node features matrix, and $\times$ is matrix-matrix multiply operator. We calculate $K$ powers of the $\hat { A }$ , feeding each power into $r$ GCNs, along with $X$ . The output of all $K \times r$ GCNs can be concatenated along the column dimension, then fed into fully-connected layers, outputting $C$ channels per node, where $C$ is size of label space. We calculate cross entropy error, between rows prediction $N \times C$ with known labels, and use them to update parameters of classification subnetwork and all GCNs. Right: pre-relu activations after the first fully-connected layer of a 2-layer classification sub-network. Activations are PCA-ed to 50 dimensions then visualized using t-SNE.
+The rest of this paper is organized as follows. Section 2 reviews background work that provides the foundation for this paper. In Section 3, we describe our proposed method, followed by experimental evaluation in Section 4. We compare our work with recent closely-related methods in Section 5. Finally, we conclude with our contributions and future work in Section 6.
+# 2 BACKGROUND
+# 2.1 SEMI-SUPERVISED NODE CLASSIFICATION
+Traditional label propagation algorithms (Weston et al., 2012; Belkin et al., 2006a) learn a model that transforms node features into node labels and uses the graph to add a regularizer term:
+$$
+\mathcal { L } _ { \mathrm { l a b e l . p r o p a g a t i o n } } = \mathcal { L } _ { \mathrm { c l a s s i f i c a t i o n } } + \mathcal { L } _ { r e g } = \mathcal { L } _ { \mathrm { c l a s s i f i c a t i o n } } + \lambda f ( X ) ^ { T } \Delta f ( X ) ,
+$$
+where $f : \mathbb { R } ^ { N \times d _ { 0 } } \to \mathbb { R } ^ { N \times C }$ is the model, $\Delta$ is the graph Laplacian, and $\lambda \in \mathbb { R }$ is the regularization coefficient hyperparameter.
+# 2.2 GRAPH CONVOLUTIONAL NETWORKS
+Graph Convolution (Bruna et al., 2014) generalizes convolution from Euclidean domains to graphstructured data. Convolving a “filter” over a signal on graph nodes can be calculated by transforming both the filter and the signal to the Fourier domain, multiplying them, and then transforming the result back into the discrete domain. The signal transform is achieved by multiplying with the eigenvectors of the graph Laplacian. The transformation requires a quadratic eigendecomposition of the symmetric Laplacian; however, the low-rank approximation of the eigendecomposition can be calculated using truncated Chebyshev polynomials (Hammond et al., 2011). For instance, Kipf &
+Welling (2017) calculates a rank-1 approximation of the decomposition. They propose a multi-layer Graph Convolutional Networks (GCNs) for semi-supervised graph learning. Every layer computes the transformation:
+$$
+H ^ { ( l + 1 ) } = \sigma \left( \hat { A } H ^ { ( l ) } W ^ { ( l ) } \right) ,
+$$
+where $H ^ { ( l ) } \in \mathbb { R } ^ { N \times d _ { l } }$ is the input activation matrix to the $l$ -th hidden layer with row $H _ { i } ^ { ( l ) }$ containing a $d _ { l }$ -dimensional feature vector for vertex $i \in \mathcal V$ , and $W ^ { ( l ) } \in \mathbb { R } ^ { d _ { l } \times d _ { l + 1 } }$ is the layer’s trainable weights. The first hidden layer $H ^ { ( 0 ) }$ is set to the input features $X$ . A softmax on the last layer is used to classify labels. All layers use the same “normalized adjacency” $\hat { A }$ , obtained by the “renormalization trick” utilized by Kipf & Welling (2017), as $\hat { A } = D ^ { - \frac { 1 } { 2 } } A D ^ { - \frac { 1 } { 2 } }$ . 1
+Eq. (2) is a first order approximation of convolving filter $W ^ { ( l ) }$ over signal $H ^ { ( l ) }$ (Hammond et al., 2011; Kipf & Welling, 2017). The left-multiplication with $\hat { A }$ averages node features with their direct neighbors; this signal is then passed through a non-linearity function $\sigma ( \cdot )$ (e.g, $\begin{array} { r l } { \operatorname { R e L U } ( z ) = } \end{array}$ $\operatorname* { m a x } ( 0 , z ) { \bar { ) } }$ . Successive layers effectively diffuse signals from nodes to neighbors.
+Two-layer GCN model can be defined in terms of vertex features $X$ and normalized adjacency $\hat { A }$ as:
+$$
+\mathrm { { G C N } } _ { 2 - \mathrm { l a y e r } } ( \hat { A } , X ; \theta ) = \mathrm { s o f t m a x } \left( \hat { A } \sigma ( \hat { A } X W ^ { ( 0 ) } ) W ^ { ( 1 ) } \right) ,
+$$
+where the GCN parameters $\theta = \left\{ W ^ { ( 0 ) } , W ^ { ( 1 ) } \right\}$ are trained to minimize the cross-entropy error over labeled examples. The output of the GCN model is a matrix $\mathbb { R } ^ { N \times C }$ , where $N$ is the number of nodes and $C$ is the number of labels. Each row contains the label scores for one node, assuming there are $C$ classes.
+# 2.3 GRAPH EMBEDDINGS
+Node Embedding methods represent graph nodes in a continuous vector space. They learn a dictionary $Z ~ \in ~ \mathbb { R } ^ { \breve { N } \times d }$ , with one $d$ -dimensional embedding per node. Traditional methods use the adjacency matrix to learn embeddings. For example, Eigenmaps (Belkin & Niyogi, 2003) calculates the following constrained optimization:
+$$
+\sum _ { i , j } | | A _ { i j } ( Z _ { i } - Z _ { J } ) | | \mathrm { ~ s . t . ~ } Z ^ { T } D Z = I ,
+$$
+where $I$ is identity vector. Skipgram models on text corpora (Mikolov et al., 2013) inspired modern graph embedding methods, which simulate random walks to learn node embeddings (Perozzi et al., 2014; Grover & Leskovec, 2016). Each random walk generates a sequence of nodes. Sequences are converted to textual paragraphs, and are passed to a word2vec-style embedding learning algorithm (Mikolov et al., 2013). As shown in Abu-El-Haija et al. (2017), this learning-by-simulation is equivalent, in expectation, to the decomposition of a random walk co-occurrence statistics matrix $\mathcal { D }$ . The expectation on $\mathcal { D }$ can be written as:
+$$
+\begin{array} { r } { \mathbb { E } [ \mathcal { D } ] \propto \mathbb { E } _ { q \sim \mathcal { Q } } \left[ ( \mathcal { T } ) ^ { q } \right] = \mathbb { E } _ { q \sim \mathcal { Q } } \left[ \left( D ^ { - 1 } A \right) ^ { q } \right] , } \end{array}
+$$
+where ${ \mathcal { T } } = D ^ { - 1 } A$ is the row-normalized transition matrix (a.k.a right-stochastic adjacency matrix), and $\mathcal { Q }$ is a “context distribution” that is determined by random walk hyperparameters, such as the length of the random walk. The expectation therefore weights the importance of one node on another as a function of how well-connected they are, and the distance between them. The main difference between traditional node embedding methods and random walk methods is the optimization criteria: the former minimizes a loss on representing the adjacency matrix $A$ (see Eq. 4), while the latter minimizes a loss on representing random walk co-occurrence statistics $\mathcal { D }$ .
+# 3 OUR METHOD
+# 3.1 MOTIVATION
+Graph Convolutional Networks and random walk graph embeddings are individually powerful. Kipf & Welling (2017) uses GCNs for semi-supervised node classification. Instead of following traditional methods that use the graph for regularization (e.g. Eq. 4), Kipf & Welling (2017) use the adjacency matrix for training and inference, effectively diffusing information across edges at all GCN layers (see Eq. 6). Separately, recent work has showed that random walk statistics can be very powerful for learning an unsupervised representation of nodes that can preserve the structure of the graph (Perozzi et al., 2014; Grover & Leskovec, 2016; Abu-El-Haija et al., 2017).
+Under special conditions, it is possible for the GCN model to learn random walks. In particular, consider a two-layer GCN defined in Eq. 6 with the assumption that first-layer activation is identity as $\sigma ( z ) = z$ , and weight $W ^ { ( 0 ) }$ is an identity matrix (either explicitly set or learned to satisfy the upstream objective). Under these two identity conditions, the model reduces to:
+$$
+\mathbf { G C N _ { 2 \mathrm { - } \mathrm { l a y e r - s p e c i a l } } } ( \hat { A } , X ) = \mathrm { s o f t m a x } \left( \hat { A } \hat { A } X W ^ { ( 1 ) } \right) = \mathrm { s o f t m a x } \left( \hat { A } ^ { 2 } X W ^ { ( 1 ) } \right) ,
+$$
+where $\hat { A } ^ { 2 }$ can be expanded as:
+$$
+\hat { A } ^ { 2 } = \left( D ^ { - \frac { 1 } { 2 } } A D ^ { - \frac { 1 } { 2 } } \right) \left( D ^ { - \frac { 1 } { 2 } } A D ^ { - \frac { 1 } { 2 } } \right) = D ^ { - \frac { 1 } { 2 } } A \left[ D ^ { - 1 } A \right] D ^ { - \frac { 1 } { 2 } } = D ^ { - \frac { 1 } { 2 } } A T D ^ { - \frac { 1 } { 2 } } .
+$$
+By multiplying the adjacency $A$ with the transition matrix $\tau$ before normalization, the GCN is effectively doing a one-step random walk.
+# 3.2 EXPLICIT RANDOM WALKS
+The special conditions described above are not true in practice. Although stacking hidden GCN layers allows information to flow through graph edges, this flow is indirect as the information goes through feature reduction (matrix multiplication) and a non-linearity (activation function $\sigma ( \cdot ) _ { . } ^ { . }$ ). Therefore, the vanilla GCN cannot directly learn high powers of $\hat { A }$ , and could struggle with modeling information across distant nodes. We hypothesize that making the GCN directly operate on random walk statistics will allow the network to better utilize information across distant nodes, in the same way that node embedding methods (e.g. DeepWalk, Perozzi et al. (2014)) operating on $\mathcal { D }$ are superior to traditional embedding methods operating on the adjacency matrix (e.g. Eigenmaps, Belkin & Niyogi (2003)). Therefore, in addition to feeding only $\hat { A }$ to the GCN model as proposed by Kipf & Welling (2017) (see Eq. 6), we propose to feed a $K$ -degree polynomial of $\hat { A }$ to $K$ instantiations of GCN. Generalizing Eq. (7) gives:
+$$
+\hat { A } ^ { k } = D ^ { - \frac { 1 } { 2 } } A \mathcal { T } ^ { k - 1 } D ^ { - \frac { 1 } { 2 } } .
+$$
+We also define $\hat { A } ^ { 0 }$ to be the identity matrix. Similar to Kipf $\&$ Welling (2017), we add selfconnections and convert directed graphs to undirected ones, making $\hat { A }$ and hence $\hat { A } ^ { k }$ symmetric matrices. The eigendecomposition of symmetric matrices is real. Therefore, the low-rank approximation of the eigendecomposition Hammond et al. (2011) is still valid, and a one layer of Kipf & Welling (2017) utilizing $\hat { A } ^ { k }$ should still approximate multiplication in the Fourier domain.
+# 3.3 NETWORK OF GCNS
+Consider $K$ instantiations of $\{ \mathbf { G C N } ( \hat { A } ^ { 0 } , X ) , \mathbf { G C N } ( \hat { A } ^ { 1 } , X ) , \ldots , \mathbf { G C N } ( \hat { A } ^ { K - 1 } , X ) \}$ . Each GCN outputs a matrix $\mathbb { R } ^ { N \times C _ { k } }$ , where the $v$ -th row describes a latent representation of that particular GCN for node $v \in \mathcal V$ , and where $C _ { k }$ is the latent dimensionality. Though $C _ { k }$ can be different for each GCN, we set all $C _ { k }$ to be the same for simplicity. We then combine the output of all $K$ GCN and feed them into a classification sub-network, allowing us to jointly train all GCNs and the classification sub-network via backpropagation. This should allow the classification sub-network to choose features from the various GCNs, effectively allowing the overall model to learn a combination of features using the raw (normalized) adjacency, different steps of random walks, and the input features $X$ (as they are multiplied by identity $\hat { A } ^ { 0 }$ ).
+# 3.3.1 FULLY-CONNECTED CLASSIFICATION NETWORK
+From a deep learning prospective, it is intuitive to represent the classification network as a fullyconnected layer. We can concatenate the output of the $K$ GCNs along the column dimension, i.e. concatenating all $\mathrm { G C N } ( X , { \hat { A } } ^ { k } )$ , each $\mathbf { \Sigma } \in \mathbb { R } ^ { N \times C _ { k } }$ into matrix $\mathbf { \Psi } \in \mathbb { R } ^ { N \times C _ { K } }$ where $\begin{array} { r } { C _ { K } \ = \ \sum _ { k } C _ { k } } \end{array}$
+We add a fully-connected layer $f _ { \mathrm { f c } } ~ \colon ~ \mathbb { R } ^ { N \times C _ { K } } \ \to ~ \mathbb { R } ^ { N \times C }$ , with trainable parameter matrix $W _ { \mathrm { f c } } \in$ $\mathbb { R } ^ { C _ { K } \times C }$ , written as:
+$\operatorname { N - G C N } _ { \mathrm { f c } } ( \hat { A } , A ; W _ { \mathrm { f c } } , \theta ) = \operatorname { s o f t m a x } \left( \left[ \begin{array} { l }  \operatorname { G C N } ( \hat { A } ^ { 0 } , X ; \theta ^ { ( 0 ) } ) \enspace ; \enspace \operatorname { G C N } ( \hat { A } ^ { 1 } , X ; \theta ^ { ( 1 ) } ) \enspace ; \enspace \dots \enspace \right] W _ { \mathrm { f c } } \right) . \end{array}$ (9) The classifier parameters $W _ { \mathrm { f c } }$ are jointly trained with GCN parameters $\theta = \{ \theta ^ { ( 0 ) } , \theta ^ { ( 1 ) } , \dots \}$ . We use subscript fc on N-GCN to indicate the classification network is a fully-connected layer.
+# 3.3.2 ATTENTION CLASSIFICATION NETWORK
+We also propose a classification network based on “softmax attention”, which learns a convex combination of the GCN instantiations. Our attention model $\left( \mathrm { { N - G C N _ { a } } } \right)$ is parametrized by vector $\widetilde { m } \in \mathbb { R } ^ { K }$ , one scalar for each GCN. It can be written as:
+$$
+\mathrm { N } \mathrm { - } \mathrm { G C N } _ { \mathrm { a } } ( \hat { A } , X ; m , \theta ) = \sum _ { k } m _ { k } \mathrm { G C N } ( \hat { A } ^ { k } , X ; \theta ^ { ( k ) } )
+$$
+where $m$ is output of a softmax: $m = \mathrm { s o f t m a x } ( \widetilde { m } )$ .
+This softmax attention is similar to “Mixture of Experts” model, especially if we set the number of output channels for all GCNs equal to the number of classes, as in $C _ { 0 } = C _ { 1 } = \cdot \cdot \cdot = C$ . This allows us to add cross entropy loss terms on all GCN outputs in addition to the loss applied at the output NGCN, forcing all GCN’s to be independently useful. It is possible to set the $m \in \mathbb { R } ^ { K }$ parameter vector “by hand” using the validation split, especially for reasonable $K$ such as $K \leq 6$ . One possible choice might be setting $m _ { 0 }$ to some small value and remaining $m _ { 1 } , \ldots , m _ { K - 1 }$ to the harmonic series $\frac { 1 } { k }$ ; another choice may be linear decay $\frac { K - k } { K - 1 }$ . These are respectively similar to the context distributions of GloVe (Pennington et al., 2014) and word2vec (Mikolov et al., 2013; Levy et al., 2015). We note that if on average a node’s information is captured by its direct or nearby neighbors, then the output of GCNs consuming lower powers of $\hat { A }$ should be weighted highly.
+# 3.4 TRAINING
+We minimize the cross entropy between our model output and the known training labels $Y$ as:
+$$
+\operatorname* { m i n } \mathrm { d i a g } ( \mathcal { V } _ { L } ) \left[ Y \circ \log \mathrm { N - G C N } ( X , \hat { A } ) \right] ,
+$$
+where $\circ$ is Hadamard product, and $\mathrm { d i a g } ( \mathcal { V } _ { L } )$ denotes a diagonal matrix, with entry at $( i , i )$ set to 1 if $i \in \mathcal { V } _ { L }$ and 0 otherwise. In addition, we can apply intermediate supervision for the $\mathrm { N G C N _ { a } }$ to attempt make all GCN become independently useful, yielding minimization objective:
+$$
+\operatorname* { m i n } _ { m , \theta } \mathrm { d i a g } ( \mathcal { V } _ { L } ) \left[ Y \circ \log \mathrm { N } \mathrm { - } \mathbf { G } \mathbf { C } \mathrm { N } _ { \mathrm { a } } ( \hat { A } , X ; m , \theta ) + \sum _ { k } Y \circ \log \mathbf { G } \mathbf { C } \mathrm { N } ( \hat { A } ^ { k } , X ; \theta ^ { ( k ) } ) \right] .
+$$
+# 3.5 GCN REPLICATION
+To simplify notation, our N-GCN derivations (e.g. Eq. 9) assume that there is one GCN per $\hat { A }$ power. However, our implementation feeds every $\hat { A }$ to $r$ GCN modules, as shown in Fig. 1.
+# 3.6 GENERALIZATION TO OTHER GRAPH MODELS
+In addition to vanilla GCNs (e.g. Kipf & Welling, 2017), our derivation also applies to other graph models including GraphSAGE (SAGE, Hamilton et al., 2017). Algorithm 1 shows a generalization that allows us to make a network of arbitrary graph models (e.g. GCN, SAGE, or others). Algorithm 2 shows pseudo-code for the vanilla GCN. Finally, Algorithm 3 defines our full Network of GCN model (N-GCN) by plugging Algorithm 2 into Algorithm 1. Similarly, we list the algorithms for SAGE and Network of SAGE (N-SAGE) in the Appendix.
+We can recover the original algorithms GCN (Kipf & Welling, 2017) and SAGE (Hamilton et al., 2017), respectively, by using Algorithms 3 (N-GCN) and 5 (N-SAGE, listed in Appendix) with $r = 1$ , $K = 1$ , identity CLASSIFIERFN, and modifying line 2 in Algorithm 1 to $P  { \hat { A } }$ . Moreover, we can recover original DCNN (Atwood & Towsley, 2016) by calling Algorithm 3 with $L = 1$ , $r = 1$ , modifying line 3 to $\hat { A }  D ^ { - 1 } A$ , and keeping $K > 1$ as their proposed model operates on the power series of the transition matrix i.e. unmodified random walks, like ours.
+Algorithm 1 General Implementation: Network of Graph Models
+<table><tr><td colspan="2">Require: A is a normalization of A</td></tr><tr><td colspan="2">1: function NETWORK(GRAPHMODELFN,A,X,L,r = 4,K = 6,CLASSIFIERFN=FCLAYER)</td></tr><tr><td>2: 3:</td><td>P←I</td></tr><tr><td>4:</td><td>GraphModels ←[] for k=1 to K do</td></tr><tr><td>5:</td><td>fori=1 to r do</td></tr><tr><td>6:</td><td>GraphModels.append(GRAPHMoDELFN(P,X,L))</td></tr><tr><td>7:</td><td>P←AP</td></tr><tr><td>8:</td><td>return CLASSIFIERFN(GraphModels)</td></tr><tr><td></td><td></td></tr></table>
+<table><tr><td>Algorithm 2 GCN (Kipf &amp; Welling,2017)</td><td>Algorithm 3 N-GCN</td></tr><tr><td>Require: A is a normalization of A</td><td>1: function NGCN(A, X,L = 2)</td></tr><tr><td>1: function GCNMODEL(A, X,L)</td><td>2: D ← diag(A1) Sum rows</td></tr><tr><td>2: Z←X</td><td>3: A←D-1/2AD-1/2</td></tr><tr><td>3: for i= 1 to L do</td><td>4: return NETWORK(GCNMODEL, A, X, L)</td></tr><tr><td>4: Z ←σ(AzW())</td><td></td></tr><tr><td>5: return Z</td><td></td></tr></table>
+# 4 EXPERIMENTS
+We follow the experimental setup by Kipf & Welling (2017) and Yang et al. (2016), including the provided dataset splits (train, validation, test) produced by Yang et al. (2016).
+# 4.1 DATASETS
+We experiment on three citation graph datasets: Pubmed, Citeseer, Cora, and a biological graph: Protein-Protein Interactions (PPI). We choose the aforementioned datasets because they are available online and are used by our baselines. The citation datasets are prepared by Yang et al. (2016), and the PPI dataset is prepared by Hamilton et al. (2017). Table 1 summarizes dataset statistics.
+Each node in the citation datasets represents an article published in the corresponding journal. An edge between two nodes represents a citation from one article to another, and a label represents the subject of the article. Each dataset contains a binary Bag-of-Words (BoW) feature vector for each node. The BoW are extracted from the article abstract. Therefore, the task is to predict the subject of articles, given the $\mathbf { B o W }$ of their abstract and the citations to other (possibly labeled) articles. Following Yang et al. (2016) and Kipf & Welling (2017), we use 20 nodes per class for training, 500 (overall) nodes for validation, and 1000 nodes for evaluation. We note that the validation set is larger than training $| \nu _ { L } |$ for these datasets!
+The PPI graph, as processed and described by Hamilton et al. (2017), consists of 24 disjoint subgraphs, each corresponding to a different human tissue. 20 of those subgraphs are used for training, 2 for validation, and 2 for testing, as partitioned by Hamilton et al. (2017).
+# 4.2 BASELINE METHODS
+For the citation datasets, we copy baseline numbers from Kipf & Welling (2017). These include label propagation (LP, Zhu et al. (2003)); semi-supervised embedding (SemiEmb, Weston et al. (2012)); manifold regularization (ManiReg, Belkin et al. (2006b)); skip-gram graph embeddings (DeepWalk Perozzi et al., 2014); Iterative Classification Algorithm (ICA, Lu & Getoor, 2003); Planetoid (Yang et al., 2016); vanilla GCN (Kipf & Welling, 2017). For PPI, we copy baseline numbers from (Hamilton et al., 2017), which include GraphSAGE with LSTM aggregation (SAGELSTM) and GraphSAGE with pooling aggregation (SAGE). Further, for all datasets, we use our implementation to run baselines DCNN (Atwood & Towsley, 2016), GCN (Kipf & Welling, 2017), and SAGE (with pooling aggregation, Hamilton et al., 2017), as these baselines can be recovered as special cases of our algorithm, as explained in Section 3.6.
+Table 1: Dataset used for experiments. For citation datasets, 20 training nodes per class are observed, with $| \mathcal { V } _ { L } | = 2 0 \times C$
+<table><tr><td>Dataset</td><td>Type</td><td>Nodes V</td><td>Edges E</td><td>Classes C</td><td>Features F</td><td>Labeled nodes VL</td></tr><tr><td>Citeseer</td><td>citaction</td><td>3,327</td><td>4,732</td><td>6 (single class)</td><td>3,703</td><td>120</td></tr><tr><td>Cora</td><td>citaction</td><td>2,708</td><td>5,429</td><td>7 (single class)</td><td>1,433</td><td>140</td></tr><tr><td>Pubmed</td><td>citaction</td><td>19,717</td><td>44,338</td><td>3 (single class)</td><td>500</td><td>60</td></tr><tr><td>PPI</td><td>biological</td><td>56,944</td><td>818,716</td><td>121 (multi-class)</td><td>50</td><td>44,906</td></tr></table>
+Table 2: Node classification performance $\%$ accuracy for the first three, citation datasets, and f1 micro-averaged for multiclass PPI), using data splits of Yang et al. (2016); Kipf & Welling (2017) and Hamilton et al. (2017). We report the test accuracy corresponding to the run with the highest validation accuracy. Results in rows (a) through (g) are copied from Kipf & Welling (2017), rows (h) and (i) from (Hamilton et al., 2017), and (j) through (l) are generated using our code since we can recover other algorithms as explained in Section 3.6. Rows (m) and (n) are our models. Entries with “–” indicate that authors from whom we copied results did not run on those datasets. Nonetheless, we run all datasets using our implementation of the most-competitive baselines.
+<table><tr><td>Method</td><td></td><td>Citeseer</td><td>Cora</td><td>Pubmed</td><td>PPI</td></tr><tr><td>(a)</td><td>ManiReg (Belkin et al.,2006b)</td><td>60.1</td><td>59.5</td><td>70.7</td><td>1</td></tr><tr><td>(b)</td><td>SemiEmb (Weston et al., 2012)</td><td>59.6</td><td>59.0</td><td>71.1</td><td></td></tr><tr><td>(c)</td><td>LP (Zhu et al., 2003)</td><td>45.3</td><td>68.0</td><td>63.0</td><td></td></tr><tr><td>(d)</td><td>DeepWalk (Perozzi et al., 2014)</td><td>43.2</td><td>67.2</td><td>65.3</td><td></td></tr><tr><td>e)</td><td>ICA (Lu &amp; Getoor,2003)</td><td>69.1</td><td>75.1</td><td>73.9</td><td></td></tr><tr><td>f</td><td>Planetoid (Yang et al., 2016)</td><td>64.7</td><td>75.7</td><td>77.2</td><td></td></tr><tr><td>(g）)</td><td>GCN(Kipf &amp; Welling,2017)</td><td>70.3</td><td>81.5</td><td>79.0</td><td></td></tr><tr><td>h</td><td>SAGE-LSTM (Hamilton et al., 2017)</td><td></td><td>1</td><td>1</td><td>61.2</td></tr><tr><td>(i)</td><td>SAGE (Hamilton et al., 2017)</td><td>1</td><td>1</td><td>1</td><td>60.0</td></tr><tr><td>j</td><td>DCNN (our implementation)</td><td>71.1</td><td>81.3</td><td>79.3</td><td>44.0</td></tr><tr><td>(k)</td><td>GCN (our implementation)</td><td>71.2</td><td>81.0</td><td>78.8</td><td>46.2</td></tr><tr><td>(1)</td><td>SAGE (our implementation)</td><td>63.5</td><td>77.4</td><td>77.6</td><td>59.8</td></tr><tr><td>(m)</td><td>N-GCN (ours)</td><td>72.2</td><td>83.0</td><td>79.5</td><td>46.8</td></tr><tr><td>(n)</td><td>N-SAGE (ours)</td><td>71.0</td><td>81.8</td><td>79.4</td><td>65.0</td></tr></table>
+# 4.3 IMPLEMENTATION
+We use TensorFlow(Abadi et al., 2015) to implement our methods, which we use to also measure the performance of baselines GCN, SAGE, and DCNN. For our methods and baselines, all GCN and SAGE modules that we train are 2 layers, where the first outputs 16 dimensions per node and the second outputs the number of classes (dataset-dependent). DCNN baseline has one layer and outputs 16 dimensions per node, and its channels (one per transition matrix power) are concatenated into a fully-connected layer that outputs the number of classes. We use $5 0 \%$ dropout and L2 regularization of $\mathrm { i 0 ^ { - 5 } }$ for all of the aforementioned models.
+# 4.4 NODE CLASSIFICATION ACCURACY
+Table 2 shows node classification accuracy results. We run 20 different random initializations for every model (baselines and ours), train using Adam optimizer (Ba & Kingma, 2015) with learning rate of 0.01 for 600 steps, capturing the model parameters at peak validation accuracy to avoid overfitting. For our models, we sweep our hyperparameters $r , K$ , and choice of classification subnetwork $\bar { \in } \lbrace \mathrm { { f c , a } } \rbrace$ . For baselines and our models, we choose the model with the highest accuracy on validation set, and use it to record metrics on the test set in Table 2.
+![](images/ce744284a395afbb3e698181d8f4aa5e6bf25e34ac330acdca33461f0577af7b.jpg)
+Figure 2: Sensitivity Analysis. Model performance when varying random walk steps $K$ and replication factor $r$ . Best viewed with zoom. Overall, model performance increases with larger values of $K$ and $r$ . In addition, having random walk steps (larger $K$ ) boosts performance more than increasing model capacity (larger $r$ ), as seen by the cross-section cuts on along the $K$ -axis versus the $r$ -axis.
+<table><tr><td>Nodes per class</td><td>5</td><td>10</td><td>20</td><td>100</td></tr><tr><td>DCNN (our implementation)</td><td>63.0±1.0</td><td>72.3± 0.4</td><td>79.2± 0.2</td><td>82.6± 0.3</td></tr><tr><td>GCN (our implementation)</td><td>64.6 ± 0.3</td><td>70.0 ± 3.7</td><td>79.1 ± 0.3</td><td>81.8 ± 0.3</td></tr><tr><td>SAGE (our implementation)</td><td>69.0 ± 1.4</td><td>72.0 ± 1.3</td><td>77.2 ± 0.5</td><td>80.7 ± 0.7</td></tr><tr><td>N-GCNa (ours)</td><td>65.1 ±0.7</td><td>71.2 ± 1.1</td><td>79.7 ± 0.3</td><td>83.0±0.4</td></tr><tr><td>N-GCNfc (ours)</td><td>65.0± 2.1</td><td>71.7 ± 0.7</td><td>79.7 ± 0.4</td><td>82.9 ± 0.3</td></tr><tr><td>N-SAGEa (ours)</td><td>66.9 ± 0.4</td><td>73.4 ± 0.7</td><td>79.0 ± 0.3</td><td>82.5 ± 0.2</td></tr><tr><td>N-SAGEfc (ours)</td><td>70.7 ± 0.4</td><td>74.1 ± 0.8</td><td>78.5 ±1.0</td><td>81.8 ± 0.3</td></tr></table>
+Table 3: Node classification accuracy (in $\%$ ) for our largest dataset (Pubmed) as we vary size of training data $\frac { | \mathcal { V } | } { C } ~ \in ~ \{ 5 , 1 0 , 2 0 , 1 0 0 \}$ . We report mean and standard deviations on 10 runs. We use a different random seed for every run (i.e. selecting different labeled nodes), but the same 10 random seeds across models. Convolution-based methods (e.g. SAGE) work well with few training examples, but unmodified random walk methods (e.g. DCNN) work well with more training data. Our methods combine convolution and random walks, making them work well in both conditions.
+Table 2 shows that N-GCN outperforms GCN (Kipf & Welling, 2017) and N-SAGE improves on SAGE for all datasets, showing that unmodified random walks indeed help in semi-supervised node classification. Finally, our proposed models acheive state-of-the-art on all datasets.
+# 4.5 SENSITIVITY ANALYSIS
+We analyze the impact of $K$ and $r$ on classification accuracy in Figure 2. We note that adding random walks by specifically setting $K > 1$ improves model accuracy due to the additional information, not due to increased model capacity. Contrast $K = 1 , r > 1$ (i.e. mixture of GCNs, no random walks) with $K > 1 , r = 1$ (i.e. N-GCN on random walks): in both scenarios, the model has more capacity, but the latter shows better performance. The same holds for SAGE, as shown in Appendix.
+# 4.6 TOLERANCE TO FEATURE NOISE
+We test our method under feature noise perturbations by removing node features at random. This is practical, as article authors might forget to include relevant terms in the article abstract, and more generally not all nodes will have the same amount of detailed information. Figure 3 shows that when features are removed, methods utilizing unmodified random walks: N-GCN, N-SAGE, and DCNN, outperform convolutional methods including GCN and SAGE. Moreover, the performance gap widens as we remove more features. This suggests that our methods can somewhat recover removed features by directly pulling-in features from nearby and distant neighbors. We visualize in Figure 4 the attention weights as a function of $\%$ features removed. With little feature removal, there is some weight on $\hat { A } ^ { 0 }$ , and the attention weights for $\hat { A } ^ { 1 } , \hat { A } ^ { 2 } , \ldots$ follow some decay function. Maliciously dropping features causes our model to shift its attention weights towards higher powers of $\hat { A }$ .
+![](images/adbaffb4c98c32d52371d96121e6848f764655a24e4754bae1672e032c39adc7.jpg)
+Figure 3: Classification accuracy for the Cora dataset with 20 labeled nodes per class $( | \mathcal { V } | = 2 0 \times C )$ , but features removed at random, averaging 10 runs. We use a different random seed for every run (i.e. removing different features per node), but the same 10 random seeds across models.
+![](images/fe35c4ae7b88b5c7bebfefbd2f7489b4f729d05eae39def979a57cc46ef26765.jpg)
+Figure 4: Attention weights $( m )$ for $\mathrm { { N - G C N _ { a } } }$ when trained with feature removal perturbation on the Cora dataset. Removing features shifts the attention weights to the right, suggesting the model is relying more on long range dependencies.
+# 5 RELATED WORK
+The field of graph learning algorithms is quickly evolving. We review work most similar to ours.
+Defferrard et al. (2016) define graph convolutions as a $K$ -degree polynomial of the Laplacian, where the polynomial coefficients are learned. In their setup, the $K$ -th degree Laplacian is a sparse square matrix where entry at $( i , j )$ will be zero if nodes $i$ and $j$ are more than $K$ hops apart. Their sparsity analysis also applies here. A minor difference is the adjacency normalization. We use $\hat { A }$ whereas they use the Laplacian defined as $I - { \hat { A } }$ . Raising $\hat { A }$ to power $K$ will produce a square matrix with entry $( i , j )$ being the probability of random walker ending at node $i$ after $K$ steps from node $j$ . The major difference is the order of random walk versus non-linearity. In particular, their model calculates learns a linear combination of $K$ -degree polynomial and pass through classifier function $g$ , as in $g ( \sum _ { k } q _ { k } { \widetilde { A } } ^ { k } )$ , while our (e.g. N-GCN) model calculates $\textstyle \sum _ { k } q _ { k } g ( \widetilde { A } ^ { k } )$ , where $\widetilde { A }$ is $\hat { A }$ in our model and $I - { \hat { A } }$ in theirs, and our $g$ can be a GCN module. In fact, Defferrard et al. (2016) is also similar to work by Abu-El-Haija et al. (2017), as they both learn polynomial coefficients to some normalized adjacency matrix.
+Atwood & Towsley (2016) propose DCNN, which calculates powers of the transition matrix and keeps each power in a separate channel until the classification sub-network at the end. Their model is therefore similar to our work in that it also falls under $\begin{array} { r } { \sum _ { k } q _ { k } g ( \widetilde { A } ^ { k } ) } \end{array}$ . However, where their model multiplies features with each power $\smash { \widetilde { A } ^ { k } }$ once, our model makes use of GCN’s (Kipf & Welling, 2017) that multiply by $\smash { \widetilde { A } ^ { k } }$ at every GCN layer (see Eq. 2). Thus, DCNN model (Atwood & Towsley, 2016) is a special case of ours, when GCN module contains only one layer, as explained in Section 3.6.
+# 6 CONCLUSIONS AND FUTURE WORK
+In this paper, we propose a meta-model that can run arbitrary Graph Convolution models, such as GCN (Kipf & Welling, 2017) and SAGE (Hamilton et al., 2017), on the output of random walks. Traditional Graph Convolution models operate on the normalized adjacency matrix. We make multiple instantiations of such models, feeding each instantiation a power of the adjacency matrix, and then concatenating the output of all instances into a classification sub-network. Our model, Network of GCNs (and similarly, Network of SAGE), is end-to-end trainable, and is able to directly learn information across near or distant neighbors. We inspect the distribution of parameter weights in our classification sub-network, which reveal to us that our model is effectively able to circumvent adversarial perturbations on the input by shifting weights towards model instances consuming higher powers of the adjacency matrix. For future work, we plan to extend our methods to a stochastic implementation and tackle other (larger) graph datasets.
+# REFERENCES
+Mart´ın Abadi, Ashish Agarwal, and TensorFlow Team. TensorFlow: Large-scale machine learning on heterogeneous systems. 2015.
+Sami Abu-El-Haija, Bryan Perozzi, Rami Al-Rfou, and Alex Alemi. Watch your step: Learning graph embeddings through attention. In arxiv, 2017.
+James Atwood and Don Towsley. Diffusion-convolutional neural networks. In Advances in Neural Information Processing Systems (NIPS), 2016.
+Jimmy Ba and Diederik Kingma. Adam: A method for stochastic optimization. In International Conference on Learning Representations, 2015.
+Mikhail Belkin and Partha Niyogi. Laplacian eigenmaps for dimensionality reduction and data representation. In Neural Computation, 2003.
+Mikhail Belkin, Partha Niyogi, and Vikas Sindhwani. Manifold regularization: A geometric framework for learning from labeled and unlabeled examples. In Journal of machine learning research (JMLR), 2006a.
+Mikhail Belkin, Partha Niyogi, and Vikas Sindhwani. Manifold regularization: A geometric framework for learning from labeled and unlabeled examples. In Journal of machine learning research (JMLR), 2006b.
+J. Bruna, W. Zaremba, A. Szlam, and Y. LeCun. Spectral networks and locally connected networks on graphs. In International Conference on Learning Representations, 2014.
+Michael Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks ¨ on graphs with fast localized spectral filtering. In Advances in Neural Information Processing Systems (NIPS), 2016.
+A. Grover and J. Leskovec. node2vec: Scalable feature learning for networks. In Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, 2016.
+W. Hamilton, R. Ying, and J. Leskovec. Inductive representation learning on large graphs. In NIPS, 2017.
+David K. Hammond, Pierre Vandergheynst, and R. Gribonval. Wavelets on graphs via spectral graph theory. In Applied and Computational Harmonic Analysis, 2011.
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016.
+G. Hinton J. Ba, J. Kiros. Layer normalization. In arxiv 1607.06450, 2016.
+T. Kipf and M. Welling. Semi-supervised classification with graph convolutional networks. In International Conference on Learning Representations, 2017.
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems, 2012.
+Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document recognition. In Proceedings of the IEEE, 1998.
+Omer Levy, Yoav Goldberg, and Ido Dagan. Improving distributional similarity with lessons learned from word embeddings. In Transactions of the Association for Computational Linguistics (TACL), 2015.
+Qing Lu and Lise Getoor. Link-based classification. In International Conference on Machine Learning (ICML), 2003.
+Selin Merdan, Christine L. Barnett, and Brian T. Denton. Data analytics for optimal detection of metastatic prostate cancer. 2017.
+T. Mikolov, I. Sutskever, K. Chen, G. Corrado, and J. Dean. Distributed representations of words and phrases and their compositionality. In Advances in Neural Information Processing Systems, 2013.
+Jeffrey Pennington, Richard Socher, and Christopher D. Manning. Glove: Global vectors for word representation. In Conference on Empirical Methods in Natural Language Processing, EMNLP, 2014.
+B. Perozzi, R. Al-Rfou, and S. Skiena. Deepwalk: Online learning of social representations. In Knowledge Discovery and Data Mining, 2014.
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott E. Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2015.
+Jason Weston, Frederic Ratle, Hossein Mobahi, and Ronan Collobert. Deeplearning via semisupervised embedding. In Neural Networks: Tricks of the Trade, pp. 639–655, 2012.
+Z. Yang, W. Cohen, and R. Salakhutdinov. Revisiting semi-supervised learning with graph embeddings. In International Conference on Machine Learning (ICML), 2016.
+Xiaojin Zhu, Zoubin Ghahramani, and John Lafferty. Semi-supervised learning using gaussian fields and harmonic functions. In International Conference on Machine Learning (ICML), 2003.
+# 7 APPENDIX
+# 7.1 ALGORITHM FOR NETWORK OF SAGE
+Algorithms 4 and 5, respectively, define SAGE Hamilton et al. (2017) and Network of SAGE (NSAGE). Algorithm 4 assumes mean-pool aggregation by Hamilton et al. (2017), which performs on-par to their top performer max-pool aggregation. Further, Algorithm 4 operates in full-batch while Hamilton et al. (2017) offer a stochastic implementation with edge sampling. Nonetheless, their proposed stochastic implementation should be wrapped in a network, though we would need a way to approximate (e.g. sample entries) from dense $\hat { A } ^ { k }$ as $k$ increases. We leave this as future work.
+<table><tr><td colspan="4">Algorithm 4 SAGE Model (Hamilton et al., 2017) Algorithm 5 N-SAGE</td></tr><tr><td colspan="2">Require: A is a normalization of A</td><td>1: function NSAGE(A, X)</td><td> Sum rows</td></tr><tr><td colspan="2">1: function SAGEMODEL(A, X, L)</td><td>2: D ← diag(A1)</td></tr><tr><td colspan="2">Z←X 2:</td><td>3: A←D-1A</td></tr><tr><td colspan="2">3: fori=1 toL do</td></tr><tr><td>4: Z ←σ([ ziAz]W(i))</td><td>4: return NETWORK(SAGEMODEL, A, X,2)</td></tr><tr><td colspan="2"></td></tr><tr><td>5: Z ← L2NORMALIZEROWS(Z)</td><td></td></tr><tr><td>6: return Z</td><td></td></tr><tr><td colspan="2"></td></tr></table>
+Using SAGE with mean-pooling aggregation is very similar to a vanilla GCN model but with three differences. First, the choice of adjacency normalization $D ^ { - 1 } A$ versus $D ^ { - { \frac { 1 } { 2 } } } A D ^ { - { \frac { 1 } { 2 } } } ,$ ). Second, the skip connections in line 4, which concatenates the features with the adjacency-multiplied (i.e. diffused) features. We believe this is analogous in intuition of incorporating $\hat { A } ^ { 0 }$ in our model, which keeps the original features. Third, the use of node-wise L2 feature normalization at line 5, which is equivalent to applying a layernorm transformation J. Ba (2016). Nonetheless, it is worth noting Hamilton et al. (2017)’s formulation of SAGE is flexible to allow different aggregations, such as max-pooling or LSTM, which further deviates SAGE from GCN.
+# 7.2 SENSITIVITY ANALYSIS
+Earlier, in Table 2, we showed the test performance corresponding to the model performing best on the validation split. The number of labeled nodes are small, and such model selection is important to avoid overfitting. For example, there can be up to $1 0 \%$ relative test accuracy difference when training the same model architecture but with different random seed. In this section, we programatically sweep hyperparameters $r , K$ , choice of classification network $( \in \ \{ \mathrm { f c } , \mathrm { a } \} )$ , and whether or not we enable $\hat { A } ^ { 0 }$ , for both N-GCN and N-SAGE models.
+The settings when ( $K = 1$ , $r = 1$ , and $\hat { A } ^ { 0 }$ disabled), correspond to the vanilla base model. Further, the settings when $K = 1$ , $r > 1$ , and $\hat { A } ^ { 0 }$ disabled), correspond to an ensemble of the base model. These cases are outperformed when $K > 1$ , showing that unmodified random walks indeed help these convolutional methods perform better, by gathering information from nearby and distant nodes.
+The automatically generated tables are shown below:
+$$
+\begin{array} { c c }  { \frac { K = 1 } { r = 1 } \left| { \begin{array} { c } { { K = 1 } } \\ { { 7 9 . 0 \pm 0 . 1 6 3 } } \\ { { r = 2 } } \\ { { 7 9 . 1 \pm 0 . 2 8 3 } } \\ { { r = 4 } } \end{array} } \right| { \begin{array} { c } { { K = 2 } } \\ { { 7 9 . 5 \pm 0 . 1 0 0 } } \\ { { 7 9 . 3 \pm 0 . 2 4 1 } } \\ { { 7 9 . 3 \pm 0 . 1 6 1 } } \end{array} } } &  { \left| { \begin{array} { c } { { K = 3 } } \\ { { 7 9 . 3 \pm 0 . 3 7 2 } } \\ { { 7 9 . 4 \pm 0 . 1 3 4 } } \\ { { 7 9 . 3 \pm 0 . 1 6 3 } } \end{array} } \right| { \begin{array} { c } { { K = 4 } } \\ { { 7 9 . 4 \pm 0 . 2 3 4 } } \\ { { 7 9 . 4 \pm 0 . 1 3 4 } } \end{array} } } &  { \left| { \begin{array} { c } { { K = 5 } } \\ { { 7 9 . 4 \pm 0 . 2 3 4 } } \\ { { 7 9 . 4 \pm 0 . 1 4 6 } } \\ { { 7 9 . 5 \pm 0 . 3 0 2 } } \end{array} } \right| { \begin{array} { c } { { K = 5 } } \\ { { 7 9 . 4 \pm 0 . 3 3 7 } } \\ { { 7 9 . 4 \pm 0 . 1 6 0 } } \end{array} } } &  { \left| { \begin{array} { c } { { K = 5 } } \\ { { 7 9 . 5 \pm 0 . 2 3 4 } } \\ { { 7 9 . 4 \pm 0 . 1 6 0 } } \end{array} } \right| { \begin{array} { c } { { K = 5 } } \\ { { 7 9 . 4 \pm 0 . 3 3 7 } } \\ { { 7 9 . 5 \pm 0 . 1 6 0 } } \end{array} } } \end{array}
+$$
+Table 4: $\mathrm { { N - G C N _ { a } } }$ results on Citeseer dataset, with $\hat { A } ^ { 0 }$ disabled. Top-left entry corresponds to vanilla GCN. Left column corresponds to ensemble of GCN models.
+Table 5: $\mathbf { N } { \cdot } \mathbf { G C N } _ { \mathrm { a } }$ results on Citeseer dataset, with $\hat { A } ^ { 0 }$ enabled.
+<table><tr><td></td><td>K=1</td><td>K=2</td><td>K=3</td><td>K=4</td><td>K=5</td></tr><tr><td>r=1</td><td>78.1± 0.339</td><td>79.6± 0.293</td><td>79.8 ± 0.189</td><td>79.7± 0.170</td><td>79.6 ± 0.243</td></tr><tr><td>r=2</td><td>77.3 ± 0.125</td><td>79.7 ± 0.171</td><td>79.6 ± 0.189</td><td>79.6 ± 0.138</td><td>79.9 ± 0.177</td></tr><tr><td>r=4</td><td>77.3 ± 0.287</td><td>79.5 ± 0.396</td><td>79.5 ± 0.219</td><td>79.7 ± 0.149</td><td>79.9 ± 0.189</td></tr></table>
+<table><tr><td></td><td>K=1</td><td>K=2</td><td>K=3</td><td>K=4</td><td>K=5</td></tr><tr><td>r=1</td><td></td><td>78.6± 0.723</td><td>78.7± 0.407</td><td>78.7± 0.530</td><td>78.0± 0.690</td></tr><tr><td>r=2</td><td>78.5 ± 0.353</td><td>77.9 ± 0.234</td><td>78.5± 0.724</td><td>78.8 ± 0.562</td><td>79.1 ± 0.267</td></tr><tr><td>r=4</td><td>78.4± 0.499</td><td>78.4 ± 0.716</td><td>78.9 ± 0.306</td><td>78.9 ± 0.385</td><td>79.0 ± 0.228</td></tr></table>
+Table 6: $\mathbf { N { \mathrm { - G C N } } _ { \mathrm { f c } } }$ results on Citeseer dataset, with $\hat { A } ^ { 0 }$ disabled. Left column corresponds to ensemble of GCN models.
+Table $7 \colon \mathrm { N - G C N _ { \mathrm { f c } } }$ results on Citeseer dataset, with $\hat { A } ^ { 0 }$ enabled.
+<table><tr><td></td><td>K=1</td><td>K=2</td><td>K=3</td><td>K=4</td><td>K=5</td></tr><tr><td>r=1</td><td>76.5 ± 1.490</td><td>78.2 ± 1.290</td><td>79.2 ± 1.061</td><td>78.5 ± 0.963</td><td>78.7 ± 1.384</td></tr><tr><td>r=2</td><td>76.1 ± 1.118</td><td>77.1 ± 1.152</td><td>78.8 ± 1.479</td><td>79.4± 0.754</td><td>78.7 ± 0.612</td></tr><tr><td>r=4</td><td>76.0± 0.770</td><td>77.2 ± 0.785</td><td>78.7 ± 0.716</td><td>78.7 ± 0.953</td><td>79.0 ± 0.313</td></tr></table>
+$$
+\begin{array}{c} \begin{array} { c c } { { } } & { { | \begin{array} { c c } { { K = 1 } } & { { K = 2 } } \\ { { 7 6 . 0 \pm 1 . 2 3 9 } } & { { 7 7 . 0 \pm 0 . 8 5 6 } } \end{array} | 7 7 . 3 \pm 0 . 6 8 2 } } & { { K = 4 } } \\ { { } } & { { | \begin{array} { c c } { { 7 7 . 4 \pm 0 . 1 2 1 9 } } & { { 7 7 . 3 \pm 0 . 9 7 9 } } \\ { { 7 7 . 6 \pm 0 . 5 8 6 3 } } & { { 7 7 . 6 \pm 0 . 5 0 8 } } \end{array} | 7 7 . 6 \pm 0 . 4 1 4 } } & { { 7 7 . 7 \pm 0 . 5 8 6 } } \\ { { } } & { { | \begin{array} { c c } { { 8 . 5 \pm 0 . 8 6 3 } } & { { 7 7 . 3 \pm 0 . 1 9 8 } } \end{array} | 7 7 . 8 \pm 0 . 5 2 5 } } \end{array} | 7 7 . 9 \pm 0 . 5 2 2 2   & { { | \begin{array} { c c } { { K = 5 } } & { { K = 5 } } \\ { { 7 7 . 3 \pm 0 . 4 1 9 } } & { { 7 7 . 3 \pm 0 . 9 7 9 } } \end{array} | 7 7 . 7 3 \pm 0 . 9 7 9 } } \end{array}
+$$
+Table 8: $\mathrm { N - S A G E _ { a } }$ results on Citeseer dataset, with $\hat { A } ^ { 0 }$ disabled. Top-left entry corresponds to vanilla SAGE. Left column corresponds to ensemble of SAGE models.
+$$
+\begin{array} { c c } { { \frac { K = 1 } { r = 1 } | \begin{array} { c } { { K = 1 } } \\ { { 7 3 . 4 \pm 1 . 2 6 4 } } \end{array} | \begin{array} { c } { { K = 2 } } \\ { { 7 6 . 1 \pm 0 . 3 0 6 } } \end{array} | \begin{array} { c } { { K = 3 } } \\ { { 7 6 . 8 \pm 0 . 6 4 7 } } \end{array} | \begin{array} { c } { { K = 4 } } \\ { { 7 6 . 6 \pm 0 . 6 2 3 } } \end{array} | \begin{array} { c } { { K = 5 } } \\ { { 7 7 . 0 \pm 0 . 3 4 0 } } \end{array} } } \\ { { \begin{array} { c } { { r = 2 } } \\ { { 7 7 . 2 \pm 0 . 5 9 7 } } \end{array} | \begin{array} { c } { { 7 6 . 0 \pm 0 . 4 5 3 } } \\ { { 7 6 . 8 \pm 0 . 5 3 5 } } \end{array} | \begin{array} { c } { { 7 6 . 4 \pm 0 . 2 4 1 } } \\ { { 7 7 . 0 \pm 0 . 2 8 9 } } \end{array} | \begin{array} { c } { { 7 7 . 2 \pm 0 . 3 0 6 } } \\ { { 7 7 . 5 \pm 0 . 4 0 7 } } \end{array} | \begin{array} { c } { { 7 7 . 3 \pm 0 . 8 6 9 } } \end{array} | \begin{array} { c } { { 8 . 0 9 . 1 \pm 0 . 7 6 } } \\ { { 7 7 . 0 \pm 0 . 8 1 8 } } \end{array} } } \end{array}
+$$
+Table 9: $\mathrm { N - S A G E _ { a } }$ results on Citeseer dataset, with $\hat { A } ^ { 0 }$ enabled.
+$$
+\begin{array}{c} \begin{array}{c} \begin{array} { c } { { \begin{array} { c c } { { \frac { K } { r = 1 } | } } & { { K = 1 } } \\ { { \frac { - } { r = 2 } | } } & { { 7 6 . 5 \pm 1 . 5 4 5 } } \\ { { \frac { 7 6 . 6 \pm 1 . 1 9 6 } { r = 4 } | } } & { { 7 7 . 3 \pm 1 . 3 0 9 } } \\ { { 7 6 . 5 \pm 0 . 6 0 2 } } & { { 7 8 . 1 \pm 1 . 2 3 9 } } \end{array} | } } & { { K = 3 } } \end{array} \begin{array} { c } { { K = 4 } } \\ { { 7 6 . 7 \pm 1 . 0 9 8 } } \\ { { 7 7 . 5 \pm 0 . 7 4 6 } } \end{array} |   & { { K = 1 . 4 2 7 } } \\ { { 7 6 . 9 \pm 0 . 4 7 2 } } \end{array}  7 . 3 \pm 1 . 0 3 8  \end{array}   \end{array} {array} \begin{array}
+$$
+Table 10 $: \ \mathrm { N } { - } \mathrm { S } \mathrm { A G E } _ { \mathrm { f c } }$ results on Citeseer dataset, with $\hat { A } ^ { 0 }$ disabled. Left column corresponds to ensemble of SAGE models.
+Table $\mathrm { . 1 { : N - S A G E _ { \mathrm { f c } } } }$ results on Citeseer dataset, with $\hat { A } ^ { 0 }$ enabled.
+<table><tr><td></td><td>K=1</td><td>K=2</td><td>K=3</td><td>K=4</td><td>K=5</td></tr><tr><td>r=1</td><td>72.9± 0.972</td><td>75.9 ± 0.922</td><td>75.5± 0.499</td><td>76.6 ± 1.641</td><td>76.8± 0.589</td></tr><tr><td>r=2</td><td>75.3 ± 0.879</td><td>76.1 ± 1.237</td><td>76.6 ± 0.579</td><td>76.4 ± 0.383</td><td>76.2 ± 0.626</td></tr><tr><td>r=4</td><td>75.3 ± 1.730</td><td>76.4 ± 1.186</td><td>76.6 ± 0.576</td><td>76.8 ± 0.450</td><td>77.4± 0.712</td></tr></table>
+$$
+\begin{array} { c } { { \begin{array} { c } { { \kappa = 1 } } \\ { { \tau = 1 } } \\ { { r = 2 } } \\ { { r = 4 } } \end{array} } | \begin{array} { c } { { K = 1 } } \\ { { 7 9 . 0 \pm 0 . 1 6 3 } } \\ { { 7 9 . 1 \pm 0 . 2 8 3 } } \\ { { 7 8 . 9 \pm 0 . 1 8 1 } } \end{array} | \begin{array} { c } { { K = 2 } } \\ { { 7 9 . 5 \pm 0 . 1 0 0 } } \\ { { 7 9 . 3 \pm 0 . 2 4 1 } } \\ { { 7 9 . 3 \pm 0 . 1 6 3 } } \end{array} | \begin{array} { c } { { K = 3 } } \\ { { 7 9 . 3 \pm 0 . 3 7 2 } } \\ { { 7 9 . 4 \pm 0 . 1 3 4 } } \\ { { 7 9 . 3 \pm 0 . 1 6 3 } } \end{array} | \begin{array} { c } { { K = 4 } } \\ { { 7 9 . 4 \pm 0 . 2 3 4 } } \\ { { 7 9 . 4 \pm 0 . 1 4 6 } } \\ { { 7 9 . 5 \pm 0 . 3 0 2 } } \end{array} | \begin{array} { c } { { K = 5 } } \\ { { 7 9 . 4 \pm 0 . 3 3 7 } } \\ { { 7 9 . 4 \pm 0 . 1 6 0 } } \end{array} | \begin{array} { c } { { K = 5 } } \\ { { 7 9 . 5 \pm 0 . 3 3 7 } } \\ { { 7 9 . 4 \pm 0 . 1 6 0 } } \end{array} }  \end{array}
+$$
+Table 12: $\mathrm { { N - G C N _ { a } } }$ results on Cora dataset, with $\hat { A } ^ { 0 }$ disabled. Top-left entry corresponds to vanilla GCN. Left column corresponds to ensemble of GCN models.
+Table $1 3 \colon \mathrm { N \mathrm { \mathrm { - G C N } _ { a } } }$ results on Cora dataset, with $\hat { A } ^ { 0 }$ enabled.
+<table><tr><td></td><td>K=1</td><td>K=2</td><td>K=3</td><td>K=4</td><td>K=5</td></tr><tr><td>r=1</td><td>78.1± 0.339</td><td>79.6± 0.293</td><td>79.8 ± 0.189</td><td>79.7± 0.170</td><td>79.6 ± 0.243</td></tr><tr><td>r=2</td><td>77.3 ± 0.125</td><td>79.7 ± 0.171</td><td>79.6 ± 0.189</td><td>79.6 ± 0.138</td><td>79.9 ± 0.177</td></tr><tr><td>r=4</td><td>77.3 ± 0.287</td><td>79.5 ± 0.396</td><td>79.5 ± 0.219</td><td>79.7 ± 0.149</td><td>79.9 ± 0.189</td></tr></table>
+<table><tr><td></td><td>K=1</td><td>K=2</td><td>K=3</td><td>K=4</td><td>K=5</td></tr><tr><td>r=1</td><td></td><td>78.6± 0.723</td><td>78.7± 0.407</td><td>78.7± 0.530</td><td>78.0± 0.690</td></tr><tr><td>r=2</td><td>78.5 ± 0.353</td><td>77.9 ± 0.234</td><td>78.5 ± 0.724</td><td>78.8 ± 0.562</td><td>79.1 ± 0.267</td></tr><tr><td>r=4</td><td>78.4± 0.499</td><td>78.4± 0.716</td><td>78.9 ± 0.306</td><td>78.9 ± 0.385</td><td>79.0 ± 0.228</td></tr></table>
+Table 14 $: \mathrm { N - G C N _ { \mathrm { f c } } }$ results on Cora dataset, with $\hat { A } ^ { 0 }$ disabled. Left column corresponds to ensemble of GCN models.
+Table 15: $\mathrm { N - G C N _ { \mathrm { f c } } }$ results on Cora dataset, with $\hat { A } ^ { 0 }$ enabled.
+<table><tr><td></td><td>K=1</td><td>K=2</td><td>K=3</td><td>K=4</td><td>K=5</td></tr><tr><td>r=1</td><td>76.5 ± 1.490</td><td>78.2 ± 1.290</td><td>79.2 ± 1.061</td><td>78.5 ± 0.963</td><td>78.7 ± 1.384</td></tr><tr><td>r=2</td><td>76.1 ± 1.118</td><td>77.1 ± 1.152</td><td>78.8 ± 1.479</td><td>79.4± 0.754</td><td>78.7 ± 0.612</td></tr><tr><td>r=4</td><td>76.0± 0.770</td><td>77.2 ± 0.785</td><td>78.7 ± 0.716</td><td>78.7 ± 0.953</td><td>79.0 ± 0.313</td></tr></table>
+$$
+\begin{array}{c} \begin{array} { c c } { { } } & { { | \begin{array} { c c } { { K = 1 } } & { { K = 2 } } \\ { { 7 6 . 0 \pm 1 . 2 3 9 } } & { { 7 7 . 0 \pm 0 . 8 5 6 } } \end{array} | 7 7 . 3 \pm 0 . 6 8 2 } } & { { K = 4 } } \\ { { } } & { { | \begin{array} { c c } { { 7 7 . 4 \pm 0 . 1 2 1 9 } } & { { 7 7 . 3 \pm 0 . 9 7 9 } } \\ { { 7 7 . 6 \pm 0 . 5 8 6 3 } } & { { 7 7 . 6 \pm 0 . 5 0 8 } } \end{array} | 7 7 . 6 \pm 0 . 4 1 4 } } & { { 7 7 . 7 \pm 0 . 5 8 6 } } \\ { { } } & { { | \begin{array} { c c } { { 8 . 5 \pm 0 . 8 6 3 } } & { { 7 7 . 3 \pm 0 . 1 9 8 } } \end{array} | 7 7 . 8 \pm 0 . 5 2 5 } } \end{array} | 7 7 . 9 \pm 0 . 5 2 2 2   & { { | \begin{array} { c c } { { K = 5 } } & { { K = 5 } } \\ { { 7 7 . 3 \pm 0 . 4 1 9 } } & { { 7 7 . 3 \pm 0 . 9 7 9 } } \end{array} | 7 7 . 7 3 \pm 0 . 9 7 9 } } \end{array}
+$$
+Table 16: $\mathrm { N - S A G E _ { a } }$ results on Cora dataset, with $\hat { A } ^ { 0 }$ disabled. Top-left entry corresponds to vanilla SAGE. Left column corresponds to ensemble of SAGE models.
+$$
+\begin{array} { c c } { { \frac { K = 1 } { r = 1 } | \begin{array} { c } { { K = 1 } } \\ { { 7 3 . 4 \pm 1 . 2 6 4 } } \end{array} | \begin{array} { c } { { K = 2 } } \\ { { 7 6 . 1 \pm 0 . 3 0 6 } } \end{array} | \begin{array} { c } { { K = 3 } } \\ { { 7 6 . 8 \pm 0 . 6 4 7 } } \end{array} | \begin{array} { c } { { K = 4 } } \\ { { 7 6 . 6 \pm 0 . 6 2 3 } } \end{array} | \begin{array} { c } { { K = 5 } } \\ { { 7 7 . 0 \pm 0 . 3 4 0 } } \end{array} } } \\ { { \begin{array} { c } { { r = 2 } } \\ { { 7 7 . 2 \pm 0 . 5 9 7 } } \end{array} | \begin{array} { c } { { 7 6 . 0 \pm 0 . 4 5 3 } } \\ { { 7 6 . 8 \pm 0 . 5 3 5 } } \end{array} | \begin{array} { c } { { 7 6 . 4 \pm 0 . 2 4 1 } } \\ { { 7 7 . 0 \pm 0 . 2 8 9 } } \end{array} | \begin{array} { c } { { 7 7 . 2 \pm 0 . 3 0 6 } } \\ { { 7 7 . 5 \pm 0 . 4 0 7 } } \end{array} | \begin{array} { c } { { 7 7 . 3 \pm 0 . 8 6 9 } } \end{array} | \begin{array} { c } { { 8 . 0 9 . 1 \pm 0 . 7 6 } } \\ { { 7 7 . 0 \pm 0 . 8 1 8 } } \end{array} } } \end{array}
+$$
+Table 17 $: \mathrm { N - S A G E _ { a } }$ results on Cora dataset, with $\hat { A } ^ { 0 }$ enabled.
+<table><tr><td></td><td>K=1</td><td>K=2</td><td>K=3</td><td>K=4</td><td>K=5</td></tr><tr><td>r=1</td><td>1</td><td>76.3 ± 1.545</td><td>76.7 ± 1.098</td><td>78.0 ± 1.427</td><td>77.3 ± 1.038</td></tr><tr><td>r=2</td><td>76.6 ± 1.196</td><td>77.3 ± 1.309</td><td>77.8 ± 0.746</td><td>77.5 ± 0.836</td><td>77.5 ± 0.298</td></tr><tr><td>r=4</td><td>76.5 ± 0.602</td><td>78.1 ± 1.239</td><td>77.6 ± 0.287</td><td>76.9 ± 0.472</td><td>77.7 ± 1.119</td></tr></table>
+Table $1 8 \colon \mathrm { N } { \cdot } \mathrm { S } \mathrm { A G E } _ { \mathrm { f c } }$ results on Cora dataset, with $\hat { A } ^ { 0 }$ disabled. Left column corresponds to ensemble of SAGE models.
+Table $9 \colon \mathrm { N } { \cdot } \mathrm { S } \mathrm { A G E } _ { \mathrm { f c } }$ results on Cora dataset, with $\hat { A } ^ { 0 }$ enabled.
+<table><tr><td></td><td>K=1</td><td>K=2</td><td>K=3</td><td>K=4</td><td>K=5</td></tr><tr><td>r=1</td><td>72.9± 0.972</td><td>75.9± 0.922</td><td>75.5 ± 0.499</td><td>76.6 ± 1.641</td><td>76.8± 0.589</td></tr><tr><td>r=2</td><td>75.3 ± 0.879</td><td>76.1 ± 1.237</td><td>76.6 ± 0.579</td><td>76.4 ± 0.383</td><td>76.2 ± 0.626</td></tr><tr><td>r=4</td><td>75.3 ± 1.730</td><td>76.4 ± 1.186</td><td>76.6 ± 0.576</td><td>76.8 ± 0.450</td><td>77.4 ± 0.712</td></tr></table>
+$$
+\begin{array} { c } { { \begin{array} { c } { { \kappa = 1 } } \\ { { \tau = 1 } } \\ { { r = 2 } } \\ { { r = 4 } } \end{array} } | \begin{array} { c } { { K = 1 } } \\ { { 7 9 . 0 \pm 0 . 1 6 3 } } \\ { { 7 9 . 1 \pm 0 . 2 8 3 } } \\ { { 7 8 . 9 \pm 0 . 1 8 1 } } \end{array} | \begin{array} { c } { { K = 2 } } \\ { { 7 9 . 5 \pm 0 . 1 0 0 } } \\ { { 7 9 . 3 \pm 0 . 2 4 1 } } \\ { { 7 9 . 3 \pm 0 . 1 6 3 } } \end{array} | \begin{array} { c } { { K = 3 } } \\ { { 7 9 . 3 \pm 0 . 3 7 2 } } \\ { { 7 9 . 4 \pm 0 . 1 3 4 } } \\ { { 7 9 . 3 \pm 0 . 1 6 3 } } \end{array} | \begin{array} { c } { { K = 4 } } \\ { { 7 9 . 4 \pm 0 . 2 3 4 } } \\ { { 7 9 . 4 \pm 0 . 1 4 6 } } \\ { { 7 9 . 5 \pm 0 . 3 0 2 } } \end{array} | \begin{array} { c } { { K = 5 } } \\ { { 7 9 . 4 \pm 0 . 3 3 7 } } \\ { { 7 9 . 4 \pm 0 . 1 6 0 } } \end{array} | \begin{array} { c } { { K = 5 } } \\ { { 7 9 . 5 \pm 0 . 3 3 7 } } \\ { { 7 9 . 4 \pm 0 . 1 6 0 } } \end{array} }  \end{array}
+$$
+Table 20: $\mathbf { N } { \cdot } \mathbf { G C N } _ { \mathbf { a } }$ results on Pubmed dataset, with $\hat { A } ^ { 0 }$ disabled. Top-left entry corresponds to vanilla GCN. Left column corresponds to ensemble of GCN models.
+Table 21: $\mathbf { N } { \cdot } \mathbf { G C N } _ { \mathrm { a } }$ results on Pubmed dataset, with $\hat { A } ^ { 0 }$ enabled.
+<table><tr><td></td><td>K=1</td><td>K=2</td><td>K=3</td><td>K=4</td><td>K=5</td></tr><tr><td>r=1</td><td>78.1 ± 0.339</td><td>79.6± 0.293</td><td>79.8± 0.189</td><td>79.7 ± 0.170</td><td>79.6± 0.243</td></tr><tr><td>r=2</td><td>77.3 ± 0.125</td><td>79.7 ± 0.171</td><td>79.6 ± 0.189</td><td>79.6 ± 0.138</td><td>79.9 ± 0.177</td></tr><tr><td>r=4</td><td>77.3 ± 0.287</td><td>79.5 ± 0.396</td><td>79.5 ± 0.219</td><td>79.7 ± 0.149</td><td>79.9 ± 0.189</td></tr></table>
+<table><tr><td></td><td>K=1</td><td>K=2</td><td>K=3</td><td>K=4</td><td>K=5</td></tr><tr><td>r=1</td><td>1</td><td>78.6± 0.723</td><td>78.7± 0.407</td><td>78.7± 0.530</td><td>78.0± 0.690</td></tr><tr><td>r=2</td><td>78.5 ± 0.353</td><td>77.9 ± 0.234</td><td>78.5± 0.724</td><td>78.8 ± 0.562</td><td>79.1 ± 0.267</td></tr><tr><td>r=4</td><td>78.4± 0.499</td><td>78.4± 0.716</td><td>78.9 ± 0.306</td><td>78.9 ± 0.385</td><td>79.0 ± 0.228</td></tr></table>
+Table 22: ${ \bf N } { \mathrm { - G C N _ { \mathrm { f c } } } }$ results on Pubmed dataset, with $\hat { A } ^ { 0 }$ disabled. Left column corresponds to ensemble of GCN models.
+Table 23: $\mathbf { N { \mathrm { - G C N } } _ { \mathrm { f c } } }$ results on Pubmed dataset, with $\hat { A } ^ { 0 }$ enabled.
+<table><tr><td></td><td>K=1</td><td>K=2</td><td>K=3</td><td>K=4</td><td>K=5</td></tr><tr><td>r=1</td><td>76.5 ± 1.490</td><td>78.2 ± 1.290</td><td>79.2 ± 1.061</td><td>78.5 ± 0.963</td><td>78.7 ± 1.384</td></tr><tr><td>r=2</td><td>76.1 ± 1.118</td><td>77.1 ± 1.152</td><td>78.8 ± 1.479</td><td>79.4± 0.754</td><td>78.7 ± 0.612</td></tr><tr><td>r=4</td><td>76.0± 0.770</td><td>77.2 ± 0.785</td><td>78.7 ± 0.716</td><td>78.7 ± 0.953</td><td>79.0 ± 0.313</td></tr></table>
+<table><tr><td></td><td>K=1</td><td>K=2</td><td>K=3</td><td>K=4</td><td>K=5</td></tr><tr><td>r=1</td><td>76.0±1.239</td><td>77.0± 0.856</td><td>77.3 ± 0.682</td><td>77.4± 0.419</td><td>77.3± 0.979</td></tr><tr><td>r=2</td><td>76.4 ± 1.219</td><td>77.6 ± 0.508</td><td>77.6 ± 0.414</td><td>77.7 ± 0.586</td><td>78.0± 0.250</td></tr><tr><td>r=4</td><td>76.5 ± 0.863</td><td>77.3 ± 0.198</td><td>77.8 ± 0.525</td><td>77.9 ± 0.522</td><td>77.6 ± 0.393</td></tr></table>
+Table 24: $\mathrm { N - S A G E _ { a } }$ results on Pubmed dataset, with $\hat { A } ^ { 0 }$ disabled. Top-left entry corresponds to vanilla SAGE. Left column corresponds to ensemble of SAGE models.
+<table><tr><td></td><td>K=1</td><td>K=2</td><td>K=3</td><td>K=4</td><td>K=5</td></tr><tr><td>r=1</td><td>73.4 ± 1.264</td><td>76.1 ± 0.306</td><td>76.8 ± 0.647</td><td>76.6± 0.623</td><td>77.0± 0.340</td></tr><tr><td>r=2</td><td>75.2 ± 0.597</td><td>76.0 ± 0.453</td><td>76.4 ± 0.241</td><td>77.2 ± 0.306</td><td>77.3 ± 0.869</td></tr><tr><td>r=4</td><td>74.9 ± 0.530</td><td>76.8± 0.535</td><td>77.0± 0.289</td><td>77.5 ± 0.407</td><td>77.3 ± 0.318</td></tr></table>
+Table 25: $\mathrm { N - S A G E _ { a } }$ results on Pubmed dataset, with $\hat { A } ^ { 0 }$ enabled.
+<table><tr><td></td><td>K=1</td><td>K=2</td><td>K=3</td><td>K=4</td><td>K=5</td></tr><tr><td>r=1</td><td>1</td><td>76.3 ± 1.545</td><td>76.7 ± 1.098</td><td>78.0± 1.427</td><td>77.3 ± 1.038</td></tr><tr><td>r=2</td><td>76.6 ± 1.196</td><td>77.3 ± 1.309</td><td>77.8 ± 0.746</td><td>77.5 ± 0.836</td><td>77.5 ± 0.298</td></tr><tr><td>r=4</td><td>76.5 ± 0.602</td><td>78.1 ± 1.239</td><td>77.6 ± 0.287</td><td>76.9 ± 0.472</td><td>77.7 ± 1.119</td></tr></table>
+Table 26: ${ \mathrm { N } { \mathrm { - } } } { \mathrm { S } } { \mathrm { A G E } } _ { \mathrm { f c } }$ results on Pubmed dataset, with $\hat { A } ^ { 0 }$ disabled. Left column corresponds to ensemble of SAGE models.
+<table><tr><td></td><td>K=1</td><td>K=2</td><td>K=3</td><td>K=4</td><td>K=5</td></tr><tr><td>r=1</td><td>72.9 ± 0.972</td><td>75.9 ± 0.922</td><td>75.5 ± 0.499</td><td>76.6 ± 1.641</td><td>76.8 ± 0.589</td></tr><tr><td>r=2</td><td>75.3 ± 0.879</td><td>76.1 ± 1.237</td><td>76.6 ± 0.579</td><td>76.4 ± 0.383</td><td>76.2 ± 0.626</td></tr><tr><td>r=4</td><td>75.3 ± 1.730</td><td>76.4 ± 1.186</td><td>76.6 ± 0.576</td><td>76.8 ± 0.450</td><td>77.4± 0.712</td></tr></table>
+Table $2 7 { : } \mathrm { N } { \cdot } \mathrm { S } \mathrm { A G E } _ { \mathrm { f c } }$ results on Pubmed dataset, with $\hat { A } ^ { 0 }$ enabled.

parse/train/SkaPsfZ0W/SkaPsfZ0W_content_list.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/SkaPsfZ0W/SkaPsfZ0W_middle.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/SkaPsfZ0W/SkaPsfZ0W_model.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/b4YiFnQH3gN/b4YiFnQH3gN.md ADDED Viewed

	@@ -0,0 +1,314 @@

+# CAFE: Catastrophic Data Leakage in Vertical Federated Learning
+Xiao Jin Rensselaer Polytechnic Institute jinx2@rpi.edu
+Pin-Yu ChenIBM Researchpin-yu.chen@ibm.com
+Chia-Yi Hsu National Yang Ming Chiao Tung University chiayihsu $8 3 1 5 @$ gmail.com
+Chia-Mu Yu National Yang Ming Chiao Tung University chiamuyu@gmail.com
+Tianyi Chen Rensselaer Polytechnic Institute chent18@rpi.edu
+# Abstract
+Recent studies show that private training data can be leaked through the gradients sharing mechanism deployed in distributed machine learning systems, such as federated learning (FL). Increasing batch size to complicate data recovery is often viewed as a promising defense strategy against data leakage. In this paper, we revisit this defense premise and propose an advanced data leakage attack with theoretical justification to efficiently recover batch data from the shared aggregated gradients. We name our proposed method as catastrophic data leakage in vertical federated learning (CAFE). Comparing to existing data leakage attacks, our extensive experimental results on vertical FL settings demonstrate the effectiveness of CAFE to perform large-batch data leakage attack with improved data recovery quality. We also propose a practical countermeasure to mitigate CAFE. Our results suggest that private data participated in standard FL, especially the vertical case, have a high risk of being leaked from the training gradients. Our analysis implies unprecedented and practical data leakage risks in those learning settings. The code of our work is available at https://github.com/DeRafael/CAFE.
+# 1 Introduction
+Federated learning (FL) $\mathbb { B } \mathbb { B }$ is an emerging machine learning framework where a central server and multiple workers collaboratively train a machine learning model. Some existing FL methods consider the setting where each worker has data of a different set of subjects but sharing common features. This setting is also referred to data partitioned or horizontal FL (HFL). Unlike the HFL setting, in many learning scenarios, multiple workers handle data about the same set of subjects, but each has a different set of features. This case is common in finance and healthcare applications [6]. In these examples, data owners (e.g., financial institutions and hospitals) have different records of those users in their joint user base, and so, by combining their features through FL, they can establish a more accurate model. We refer to this setting as feature-partitioned or vertical FL (VFL).
+Compared with existing distributed learning paradigms, FL raises new challenges including data heterogeneity and privacy $\left[ \left[ 2 0 \right] \right]$ . To protect data privacy, only model parameters and the change of parameters (e.g., gradients) are exchanged between server and workers [19, 15]. Recent works have studied how a malicious worker can embed backdoors or replace the global model in FL [2, 3, 27]. Furthermore, as exchanging gradients is often viewed as privacy-preserving protocols, little attention has been paid to information leakage from public shared gradients and batch identities.
+In the context of data security and AI ethics, the possibility of inferring private user data from the gradients in FL has received growing interests [10, 14, 21], known as the data leakage problems.
+![](images/2eb9a963a9a9a54f822632455758f7a57ec430880008974da1ed7ffe23897908.jpg)
+Figure 1: Visual comparison between CAFE (our method) with the state-of-the-art data leakage attacks including DLG [32], Cosine similarity $\mathbb { \ m }$ , SAPAG $\mathbb { \left[ \left[ 2 5 \right] \right] }$ , BN regularzier $\left[ \left[ 2 9 \right] \right]$ and GC regularizer $\left[ \left[ 2 9 \right] \right]$ on Linnaeus 5 in VFL (4 workers, batch size $= 4 0$ and batch ratio $= 0 . 0 5$ ).
+Previous works have made exploratory efforts on data recovery through gradients. See Section 2 and Table 1 for details. However, existing approaches often have the limitation of scaling up large-batch data recovery and are lacking in theoretical justification on the capability of data recovery, which may give a false sense of security that increasing the data batch size during training can prevent data leakage $\textcircled { \lvert 3 0 \rvert }$ . Some recent works provide sufficient conditions for guaranteed data recovery, but the assumptions are overly restrictive and can be sometimes impractical, such as requiring the number of classes to be much larger than the number of recovered data samples [29].
+To enhance scalability in data recovery and gain fundamental understanding on data leakage in VFL, in this paper we propose an advanced data leakage attack with theoretical analysis on the data recovery performance, which we call catastrophic data leakage in vertical federated learning (CAFE). As an illustration, Figure 1 demonstrates the effectiveness of CAFE for large-batch data recovery compared to existing methods. The contributions of this paper are summarized as follows.
+C1) We develop a new data leakage attack named CAFE to overcome the limitation of current data leakage attacks on VFL. Leveraging the novel use of data index and internal representation alignments in VFL, CAFE is able to recover large-scale data in general VFL protocols.
+C2) We provide theoretical guarantees on the recovery performance of CAFE, which permeates three steps of CAFE: (I) recovering gradients of loss with respect to the outputs of the first fully connected (FC) layer; (II) recovering inputs to the first FC layer; (III) recovering the original data.
+C3) To mitigate the data leakage attack by CAFE, we develop a defense strategy which leverages the fake gradients and preserves the model training performance.
+C4) We conduct extensive experiments on both static and dynamic VFL training settings to validate the superior data recovery performance of CAFE over state-of-the-art methods.
+# 2 Related Work
+Recovering private training data from gradients has gained growing interests in FL. Recently, a popular method termed deep leakage from gradients (DLG) $\left[ \left[ 3 2 \right] \right]$ has been developed to infer training data in an efficient way without using any generative models or prior information. However, DLG lacks generalizability on model architecture and weight distribution initialization $\mathbb { \left[ \left. 2 5 \right] \right. }$ . In $\pmb { \mathbb { B } } 0 \|$ , an analytical approach has been developed to extract accurate labels from the gradients. In $\mathbb { m }$ , another analytical approach has been developed to derive the inputs before a fully connected (FC) layer. However, in $\dot { \left[ \mathrm { l i l l } \right] }$ , their method only works on a single sample input and fails to extend on a batch of data. In $\pmb { \Vert 2 2 \Vert }$ , a new approach has been developed by recovering the batch inputs before the FC layer through solving linear equations. However, strong assumptions have been made for solving the equations and cannot guarantee data recovery in more general cases. In $\bigstar \bigstar$ , it is claimed that a convolutional layer can always be converted to a FC layer. However, the gradients of the original convolutional layer are still different from the gradients of the converted FC layer, which impedes data recovery. Besides the new loss function proposed in $[ \equiv 1 ]$ , several previous works design new loss functions or regularizers based on DLG and try to make their algorithms work on more general models and weight distribution initialization. In $\bar { \| 2 5 \| }$ , a new Gaussian kernel based gradient difference is used as the distance measure. In $\textcircled { \scriptsize { 1 3 1 } }$ , a recursive method attack procedure has been developed to recover data from gradients. However, in both $\mathbb { \left. \boldsymbol { \Sigma } \boldsymbol { \bar { \Sigma } } \right. }$ and $\pmb { \mathbb { B } } \mathbf { \mathbb { 1 } }$ , the quality of recovery on batch data is degraded. A recent work $\left[ \left[ 2 9 \right] \right]$ proposes an algorithm named GradInversion to reconstruct images from noise based on given gradients. However, their theory and algorithm are mostly built on strong assumptions and empirical observations. Although they successfully reconstruct a batch of training data, the reported batch size is still no larger than 48.
+Table 1: Comparison of CAFE with state-of-the-art data leakage attack methods in FL.
+<table><tr><td>Method</td><td>Optimization terms</td><td>Reported maximal batch size</td><td>Training while attacking</td><td>Theoretical guarantee</td><td>Additional information other than gradients</td></tr><tr><td>DLG B2</td><td>l2 distance between real and fake gradients</td><td>8</td><td>No</td><td>No</td><td>No</td></tr><tr><td>iDLG 目</td><td>l2 distance</td><td>8</td><td>No</td><td>Yes</td><td>No</td></tr><tr><td>Inverting Gradients 自</td><td>Cosine similarity, TV norm</td><td>8 100 (Mostly unrecognizable)</td><td>Yes</td><td>Yes</td><td>Number of local updates</td></tr><tr><td>AFramework for Evaluating Gradient Leakage 26]</td><td>l2 distance, label based regualrizer</td><td>8</td><td>No</td><td>Yes</td><td>No</td></tr><tr><td>SAPAG[ 因</td><td>Gaussian kernel based funciton</td><td>8</td><td>No</td><td>No</td><td>No</td></tr><tr><td>R-GAP 目</td><td>recursive gradient loss</td><td>5</td><td>No</td><td>Yes</td><td>The rank of matrix A defined in [31</td></tr><tr><td>Theory oriented 22]</td><td>l2 distance, l1 distances of the recovered feature map</td><td>32</td><td>No</td><td>Yes</td><td>Number of Exclusive activated neurons</td></tr><tr><td>GradInversion29]</td><td>Fidelity regularizers, Group consistency regularizers</td><td>48</td><td>No</td><td>No</td><td>Batch size &lt;number of classes &amp; Non repeating labels in a batch</td></tr><tr><td>CAFE (ours)</td><td>l2 distance, TV norm, Internal representation norm</td><td>100 (our hardware limit)</td><td>Yes</td><td>Yes</td><td>Batch indices</td></tr></table>
+# 3 CAFE: Catastrophic Data Leakage in Vertical Federated Learning
+In this section, we will introduce some necessary background of VFL and present our novel attack method. We consider the attack scenario where a honest-but-curious server follows the regular VFL protocols but intends to recover clients’ private data based on the aggregated gradients. Our method is termed CAFE: Catastrophic data leakage in vertical federated learning. While CAFE can be applied to any type of data, without loss of generality, we use image datasets throughout the paper.
+# 3.1 Preliminaries
+VFL setting. FL can be categorized into horizontal and vertical FL settings $\mathbb { \left[ \left[ 1 6 \right] \right] }$ . In this paragraph, we provide necessary background of VFL. Consider a set of $M$ clients: $\mathcal { M } = \{ 1 , 2 , \dots , M \}$ . A dataset of $N$ samples $\mathcal { D } = \{ ( \mathbf { x } _ { n } , y _ { n } ) \} _ { n = 1 } ^ { N }$ are maintained by the $M$ local clients, where $n$ is the data index. Each client $m$ in $\mathcal { M }$ is associated with a unique features set. A certain data point ${ \bf { X } } _ { n }$ in $\mathcal { D }$ can be denoted by $\mathbf { x } _ { n } = [ \mathbf { x } _ { n , 1 } ^ { \top } , \mathbf { x } _ { n , 2 } ^ { \top } , \ldots , \mathbf { x } _ { n , M } ^ { \top } ] ^ { \top }$ where ${ \bf x } _ { n , m }$ is the $m$ -th partition of the $n$ -th sample vector. The label set $\{ y _ { n } \} _ { n = 1 } ^ { N }$ can be viewed as a special feature and is kept at the server or a certain local worker. Throughout this paper, we mainly study the VFL setting. CAFE can also be applied to HFL if the data indices of each randomly selected batch are known to workers during training.
+Use case of VFL. VFL is suitable for cases where multiple data owners share the same data identity but their data differ in feature space. Use cases of VFL appear in finance, e-commerce, and health. For example, in medical industry, test results of the same patient from different medical institutions are required to diagnose whether the patient has a certain disease or not, but institutions tend not to share raw data. Figure 2 gives an example of VFL in medical industry.
+Batch indices in each iteration. For a given batch size $K$ , we define a set of vectors with binary entries as ${ \mathcal { S } = \{ \mathbf { s } _ { 1 } , \mathbf { s } _ { 2 } , \dots , \mathbf { s } _ { i } , \dots \} }$ with $| S | = { \binom { \bar { N } } { K } }$ . For each vector $\mathbf { s } _ { i } \in \mathbb { R } ^ { N }$ in $s$ , its $n$ -th element ${ \mathbf s } _ { i } [ n ]$ can be either 0 or 1. There are in total $K$ enires of $\cdot _ { 1 } \cdot$ in $\mathbf { s } _ { i }$ . In each iteration $t$ , the server randomly selects one element from set $s$ denoted by $\mathbf { s } ^ { t }$ , where $\mathsf { \bar { s } } ^ { t } [ n ]$ is the nth element in $\mathbf { s } ^ { t }$ . The selected batch samples in the $t$ -th iteration are denoted by $\mathcal { D } ( \mathbf { s } ^ { t } ) = \{ \bar { ( } \bar { \mathbf { x } _ { n } } , y _ { n } \mathbf { ) } \vert \mathbf { s } ^ { t } [ n ] = 1 \}$ .
+![](images/584aa44df41bf7437f10749d505ef3bf910675e011e4af438b3ef47b5a87fcb8.jpg)
+Figure 2: VFL among medical institutions
+Loss function and gradients. We assume that the model is a neural network parameterized by $\Theta$ , where the first FC layer is parameterized by $\Theta _ { 1 } \in \mathbb { R } ^ { d _ { 1 } \times d _ { 2 } }$ and its bias is $\mathbf { b } _ { 1 } \in \mathbb { R } ^ { \hat { d } _ { 2 } }$ . The loss function on the batch data $\mathcal { D } \dot { ( \mathbf { s } ^ { t } ) }$ and on the entire training data $\mathcal { D }$ is, respectively, denoted by
+$$
+\mathcal { L } ( \boldsymbol { \Theta } , \mathcal { D } ( \mathbf { s } ^ { t } ) ) : = \frac { 1 } { K } \sum _ { n = 1 } ^ { N } \mathbf { s } ^ { t } [ n ] \mathcal { L } ( \boldsymbol { \Theta } , \mathbf { x } _ { n } , y _ { n } ) \quad \mathrm { a n d } \quad \mathcal { L } ( \boldsymbol { \Theta } , \mathcal { D } ) : = \frac { 1 } { N } \sum _ { n = 1 } ^ { N } \mathcal { L } ( \boldsymbol { \Theta } , \mathbf { x } _ { n } , y _ { n } ) .
+$$
+The gradients of losses w.r.t. $\Theta$ is denoted as
+$$
+\nabla _ { \Theta } \mathcal { L } ( \Theta , \mathcal { D } ( \mathbf { s } ^ { t } ) ) : = \frac { \partial \mathcal { L } ( \Theta , \mathcal { D } ( \mathbf { s } ^ { t } ) ) } { \partial \Theta } = \frac { 1 } { K } \sum _ { n = 1 } ^ { N } \mathbf { s } ^ { t } [ n ] \frac { \partial \mathcal { L } ( \Theta , \mathbf { x } _ { n } , y _ { n } ) } { \partial \Theta } .
+$$
+And similarly, we define $\nabla _ { \Theta } \mathcal { L } ( \Theta , \mathcal { D } )$
+# 3.2 Why large-batch data leakage attack is difficult?
+We motivate the design of our algorithm by providing some intuition on why performing large-batch data leakage from aggregated gradients is difficult $\mathbb { \lVert 3 2 \rVert }$ . Assume that $K$ images are selected as the inputs for a certain learning iteration. We define the selected batch data as $\mathcal { D } ^ { \prime } = \{ ( \mathbf { x } _ { n } , y _ { n } ) \}$ . Likewise, the batched ‘recovered data’ is denoted by $\hat { \mathcal { D } } ^ { \prime } = \{ ( \hat { \bf x } _ { n } , \hat { y } _ { n } ) \}$ . Then the objective function is
+$$
+\hat { \boldsymbol D } ^ { \prime } = \arg \operatorname* { m i n } _ { \hat { \boldsymbol D } ^ { \prime } } \left\| \frac { 1 } { K } \sum _ { ( \mathbf x _ { n } , y _ { n } ) \in \mathcal { D } } \nabla _ { \Theta } \mathcal { L } ( \boldsymbol \Theta , \mathbf x _ { n } , y _ { n } ) - \frac { 1 } { K } \sum _ { ( \hat { \mathbf x } _ { n } , \hat { y } _ { n } ) \in \hat { \mathcal { D } } ^ { \prime } } \nabla _ { \Theta } \mathcal { L } ( \boldsymbol \Theta , \hat { \mathbf x } _ { n } , \hat { y } _ { n } ) \right\| ^ { 2 } .
+$$
+Note that in $( 3 )$ , the dimensions of the aggregated gradients is fixed. However, as $K$ increases, the cardinality of $\hat { \mathcal { D } } ^ { \prime }$ and $\mathcal { D } ^ { \prime }$ rise. When $K$ is sufficiently large, it will be more challenging to find the “right” solution $\hat { \mathcal { D } } ^ { \prime }$ of $( 3 )$ corresponding to the ground-truth dataset $\mathcal { D } ^ { \prime }$ . On the other hand, CAFE addresses this issue of large-batch data recovery by data index alignment (defined in next subsection), which can effectively exclude undesired solutions. We discuss a specific example in Appendix B.
+# 3.3 CAFE implementation
+The main idea of our algorithm is that we divide the entire data leakage attack procedure into several steps. Specifically, we fully recover the inputs to the first FC layers of the model that we term the internal representation with theoretical guarantee and use the internal representation as a learnt regularizer to help improve the performance of data leakage attack. During the process, to overcome the difficulty mentioned in Section $\underline { { \boldsymbol { \mathrm { 3 . 2 } } } }$ we fully use the batch data index known by the attacker in the VFL setting so that the system equation in $\textcircled { 3 }$ can be determined instead of undetermined.
+![](images/2567c1a1c3dba78f8a84d0ec8bb570f5a31141f1c1b572c8196955596eb0f2cd.jpg)
+Figure 3: Overview of CAFE. The left part (blue box) performs the regular VFL protocol and the right part (red box) illustrates the main steps of CAFE.
+![](images/a90dbb5332cdc41c29c75e188ec7368a8883cf82625affa935c6ba7a0b453297.jpg)
+Figure 4: Model structure in VFL.
+Prerequisite: Notably, CAFE can be readily applied to existing VFL protocols where the batch data indices is assigned or other deep learning protocols as long as the batch data indices are given. In Figure 3, the blue box represents the VFL paradigm and the red box denotes the attack paradigm.
+In a typical VFL process, the server sends public key to local workers and decides the data indices in each iteration of training and evaluation $\bar { \big \vert } \bar { \big \vert } , \bar { \big \vert } \bar { \big \vert }$ . During the training process, local workers exchange their intermediate results with others to compute gradients and upload them. Therefore, the server has access to both of the model parameters and their gradients. Since data are vertically partitioned among different workers, for each batch, the server (acting as the attacker) needs to send a data index or data id list to all the local workers to ensure that data with the same id sequence have been selected by each worker $\left[ \left[ 2 8 \right] \right]$ and we name this step as data index alignment. Data index alignment turns out to be an inevitable step in the vertical training process, which provides the server (the attacker) an opportunity to control the selected batch data indices.
+In the rest of this subsection, we explain our algorithm CAFE in detail, which consists of three steps.
+Step I: Recover the gradients of loss w.r.t the outputs of the first FC layer. As shown in Figure $^ { 4 , }$ for a certain data point ${ \bf { X } } _ { n }$ , we denote the inputs to the first FC layer as $\mathbf { h } _ { n } = h ( \mathbf { \Theta } _ { \mathbf { } } \mathbf { e } , \mathbf { x } _ { n } ) \in \mathbf { \bar { \mathbb { R } } } ^ { d _ { 1 } }$ where $h$ is the forward function and $\Theta _ { c }$ is the parameters before the first FC layer. Let ${ \bf u } _ { n }$ denote the outputs of the first FC layer in the neural network, given by
+$$
+{  { \mathbf { u } } } _ { n } = \Theta _ { 1 } ^ { \top } {  { \mathbf { h } } } _ { n } + {  { \mathbf { b } } } _ { 1 } \in \mathbb { R } ^ { d _ { 2 } } .
+$$
+For the training data $\mathcal { D }$ , the corresponding inputs before the first FC layer are concatenated as $\mathbf { H } =$ $[ \mathbf { h } _ { 1 } , \mathbf { h } _ { 2 } , \ldots , \mathbf { h } _ { N } ^ { - } ] ^ { \top } \in \mathbb { R } ^ { N \times d _ { 1 } }$ and the corresponding outputs of the first FC layer are concatenated as ${ \mathbf { U } } = [ { \mathbf { u } } _ { 1 } , { \mathbf { u } } _ { 2 } , \ldots , { \mathbf { u } } _ { N } ] ^ { \top } \in \mathbb { R } ^ { N \times d _ { 2 } }$ . The gradients of loss w.r.t $\mathbf { U }$ can be denoted by
+$$
+\begin{array} { r l r } & { } & { \nabla _ { \mathbf { U } } \mathcal { L } ( \boldsymbol { \Theta } , \mathcal { D } ) = \displaystyle \frac { 1 } { N } [ \nabla _ { \mathbf { u } _ { 1 } } \mathcal { L } ( \boldsymbol { \Theta } , \mathbf { x } _ { 1 } , y _ { 1 } ) , \nabla _ { \mathbf { u } _ { 2 } } \mathcal { L } ( \boldsymbol { \Theta } , \mathbf { x } _ { 2 } , y _ { 2 } ) , \dots , \nabla _ { \mathbf { u } _ { N } } \mathcal { L } ( \boldsymbol { \Theta } , \mathbf { x } _ { N } , y _ { N } ) ] ^ { \top } } \\ & { } & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { } & { \displaystyle \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \frac { \partial \mathcal { L } ( \boldsymbol { \Theta } , \mathbf { x } _ { 1 } , y _ { 1 } ) } { \partial \mathbf { u } _ { 1 } } , \frac { \partial \mathcal { L } ( \boldsymbol { \Theta } , \mathbf { x } _ { 2 } , y _ { 2 } ) } { \partial \mathbf { u } _ { 2 } } , \dots , \frac { \partial \mathcal { L } ( \boldsymbol { \Theta } , \mathbf { x } _ { N } , y _ { N } ) } { \partial \mathbf { u } _ { N } } \Big ] ^ { \top } \in \mathbb { R } ^ { N \times d _ { 2 } } . } \end{array}
+$$
+For a batch of data in the $t$ -th iteration $\mathcal { D } ( \mathbf { s } ^ { t } )$ , we have
+$$
+\begin{array} { l }  { \displaystyle \nabla _ { { \bf b } _ { 1 } } { \mathcal L } ( { \bf \Theta } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } ^ { t } ) \left. = \frac { 1 } { K } \sum _ { n = 1 } ^ { N } { \bf s } ^ { t } [ n ] \frac { \partial { \mathcal L } ( { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } , { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } _ { n } , y _ { n }  } { \partial { \bf b } _ { 1 } } = \sum _ { n = 1 } ^ { N } { \bf s } ^ { t } [ n ] \frac { 1 } { K } \sum _ { z = 1 } ^ { N } { \bf s } ^ { t } [ z ] \frac { \partial { \mathcal L } ( { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } } \\  {\right) \displaystyle \quad \quad \quad } { \quad \quad } { \quad \quad } { \quad \quad } { \quad \quad } = \sum _ { n = 1 } ^ { N } { \bf s } ^ { t } [ n ] \nabla _ { { \bf u } _ { n } } { \mathcal L } ( { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf } { \bf }  \bf  \end{array}
+$$
+Although we do not have access to $\nabla _ { \mathbf { U } } \mathcal { L } ( \mathbf { \Theta } \Theta , \mathcal { D } )$ as gradients are only given w.r.t. the model parameters, we can successfully recover it through an iterative optimization process.
+Algorithm 2 Recover the inputs to the first FC layer $\mathbf { H }$ ( regular VFL and attacker )
+<table><tr><td rowspan=1 colspan=2>Algorithm 1 Recover the gradients VuL(0,D)(regular VFLandattacker</td></tr><tr><td rowspan=1 colspan=1>6:</td><td></td></tr><tr><td rowspan=1 colspan=1>7:</td><td></td></tr><tr><td rowspan=1 colspan=1></td><td></td></tr><tr><td rowspan=1 colspan=1>8:</td><td></td></tr><tr><td rowspan=1 colspan=1>9:10:</td><td></td></tr><tr><td rowspan=1 colspan=1>11:</td><td rowspan=2 colspan=1>Server computes F1(V; st) in (Z)Server updates V with VvF1(V; st)</td></tr><tr><td rowspan=1 colspan=1>12:</td></tr></table>
+13: end for
+<table><tr><td colspan="2">1: Given @,trained V, initialize H ~UN ×d2 2: for t = 1,2,...,T do</td></tr><tr><td>3: 4: 5: 6: 7:</td><td>Server select st from S. Server broadcasts ? and st to all workers for m = 1,2,..., M do Worker m takes real batch data Worker m exchanges intermediate results with other workers and computes V@L(@, D(st))</td></tr><tr><td>9: 10: 11:</td><td>end for Server computes V@1 L(Θ,D(st)) Server computes F2(H; st) in )</td></tr><tr><td>12:</td><td>Server updates H with VHF2(H; st)</td></tr></table>
+13: end for
+# Algorithm 3 CAFE (Nested-loops)
+<table><tr><td colspan="2">1: Given model parameters @,initialize V~ uNxd1，H~uNxdD={,n1 2:Run Algorithmsand2each for T iterations 3: for t =1,2,...,T do</td></tr><tr><td>4: 5:</td><td>Run Step 3-10 in Algorithml1lonce Server computes V@L(Θ,D(st))</td></tr><tr><td>6:</td><td>Server computes the fake global aggregated gra- dients VL(Θ,D(t))</td></tr><tr><td>7:</td><td>Server computes CAFE loss F3(D; st) in )</td></tr><tr><td>8:</td><td>Server updates D with VbF3(D; st)</td></tr></table>
+9: end for
+# Algorithm 4 CAFE (Single-loop)
+<table><tr><td colspan="2">1:Given model parameters @,initialize V~ uNxd1H~uNxdD={nn1 2: for t =1,2,...,T do</td></tr><tr><td>3: 4:</td><td>Run Step 3-10 in Algorithm 1 once Server computes V@L(@,D(st)) including Vb1L(②,D(st)), Vθ1L(Θ,D(st))</td></tr><tr><td>5: 6: 7: 8:</td><td>Run Step 11 - 12 in Algorithm 1 lonce Run Step 11 - 12 in Algorithm ② Jonce Server computes CAFE loss F3(D; st) in ) Server updates D with VbF3(D; st)</td></tr></table>
+9: end for
+Specifically, we randomly initialize an estimate of $\nabla _ { \mathbf { U } } \mathcal { L } ( \mathbf { \Theta } \Theta , \mathcal { D } )$ denoted as $\mathbf { V }$ , e.g., ${ \textbf { V } } =$ $\left[ \mathbf { v } _ { 1 } , \mathbf { v } _ { 2 } , \ldots , \mathbf { v } _ { n } , \ldots , \mathbf { v } _ { N } \right] ^ { \top } \ \in \ \mathbb { R } ^ { N \times d _ { 2 } }$ , where $\begin{array} { r c l } { \mathbf { v } _ { n } } & { = } & { [ v _ { n , 1 } , v _ { n , 1 } , \hdots , v _ { n , d _ { 2 } } ] ^ { \top } \mathrm { ~  ~ \in ~ \mathbb ~ R ^ { } { d } _ { 2 } ~ } } \end{array}$ . Given $\nabla _ {  { \mathbf { b } } _ { 1 } } \mathcal { L } ( \Theta , \mathcal { D } (  { \mathbf { s } } ^ { t } ) )$ , we recover $\nabla _ { \mathbf { U } } \mathcal { L } ( \mathbf { \Theta } \Theta , \mathcal { D } )$ by minimizing the following objective function
+$$
+\mathbf { V } ^ { * } = \arg \operatorname* { m i n } _ { \mathbf { V } } \underbrace { \mathbb { E } _ { { \mathbf { s } } _ { i } \sim \mathrm { U n i f } ( { \boldsymbol { S } } ) } \left[ \mathcal { F } _ { 1 } ( { \mathbf { V } } ; { \mathbf { s } } _ { i } ) \right] } _ { : = \mathcal { F } _ { 1 } ( \mathbf { V } ) } \mathrm { w i t h } \mathcal { F } _ { 1 } ( { \mathbf { V } } ; { \mathbf { s } } _ { i } ) : = \left\| { \mathbf { V } } ^ { \top } { \mathbf { s } } _ { i } - \nabla _ { { \mathbf { b } } _ { 1 } } \mathcal { L } ( \Theta , \mathcal { D } ( { \mathbf { s } } _ { i } ) ) \right\| _ { 2 } ^ { 2 } .
+$$
+In each iteration $t$ , the objective function of Step I is given by $\mathcal { F } _ { 1 } ( { \mathbf { V } } ; { \mathbf { s } } ^ { t } )$ .
+The first step of CAFE is summarized in Algorithm 1, which enjoys the following guarantee.
+Theorem 1. If $K < N$ , the objective function $\mathcal { F } _ { 1 } ( \mathbf { V } )$ in $( 7 )$ is strongly convex in $\mathbf { V }$ . For a fixed $\Theta$ , applying SGD to $\textcircled { 7 }$ guarantees the convergence to the ground truth almost surely.
+When the batch size $K$ is smaller than the number of total data samples $N$ , the Hessian matrix of $\mathcal { F } _ { 1 } ( \mathbf { V } )$ is shown to be strongly convex in Appendix $\boxed { \mathsf { C } }$ and the convergence is guaranteed according to [23]. Step I is essential in CAFE because we separate the gradients of loss w.r.t each single input to the first FC layer from the aggregated gradients in this step.
+Step II: Recover inputs to the first FC layer. Using the chain rule, we have $\nabla _ { \Theta _ { 1 } } \mathcal { L } ( \Theta , \mathcal { D } ) =$ $\begin{array} { r l r } { { \bf H } ^ { \top } \nabla _ { \bf U } \mathcal { L } ( \boldsymbol { \Theta } , \mathcal { D } ) } & { { } \in } & { \mathbb { R } ^ { d _ { 1 } \times d _ { 2 } } } \end{array}$ . We randomly initialize an estimate of $\mathbf { H }$ as $\begin{array} { r l } { \hat { \bf { H } } } & { { } = } \end{array}$ $[ \hat { \bf h } _ { 1 } , \hat { \bf h } _ { 2 } , \dots , \hat { \bf h } _ { n } , \dots , \hat { \bf h } _ { N } ] ^ { \top } \in \mathbb { R } ^ { N \times d _ { 1 } }$ , where $\hat { \bf h } _ { n } ^ { \mathrm { ~ \tiny ~  ~  ~ }  } = [ \hat { h } _ { n , 1 } , \hat { h } _ { n , 1 } , \ldots , \hat { h } _ { n , d _ { 1 } } ] ^ { \top } \in \mathbb { R } ^ { d _ { 1 } }$ . Given $\mathsf { \bar { V } } _ { \Theta _ { 1 } } \mathcal { L } ( \Theta , \mathcal { D } ( \mathbf { s } ^ { t } ) )$ and $\mathbf { V } ^ { * }$ , we recover $\mathbf { H }$ by minimizing the following objective
+$$
+\hat { \mathbf { H } } ^ { * } = \arg \operatorname* { m i n } _ { \hat { \mathbf { H } } } \underbrace { \mathbb { E } _ { s _ { i } \sim \operatorname { U n i f } ( S ) } \mathcal { F } _ { 2 } ( \hat { \mathbf { H } } ; \mathbf { s } _ { i } ) } _ { : = \mathcal { F } _ { 2 } ( \hat { \mathbf { H } } ) } \mathrm { w i t h } \mathcal { F } _ { 2 } ( \hat { \mathbf { H } } ; \mathbf { s } _ { i } ) : = \Big \lVert \sum _ { n = 1 } ^ { N } \mathbf { s } _ { i } [ n ] \hat { \mathbf { h } } _ { n } ( \mathbf { v } _ { n } ^ { * } ) ^ { \top } - \nabla \mathbf { \Theta } _ { \Theta _ { 1 } } \mathcal { L } ( \mathbf { \Theta } , \mathcal { D } ( \mathbf { s } _ { i } ) ) \Big \rVert _ { F } ^ { 2 } .
+$$
+In each iteration $t$ , the objective function of Step II can be denoted by $\mathcal { F } _ { 2 } ( \hat { \mathbf { H } } ; \mathbf { s } ^ { t } )$
+Through the first two steps, parts of the information about the data have already been leaked. Step II also has the following guarantee.
+Theorem 2. If $N < d _ { 2 }$ and $\operatorname { R a n k } ( \mathbf { V } ^ { * } ) = N$ , the objective function $\mathcal { F } _ { 2 } ( \hat { \mathbf { H } } )$ is strongly convex. When $\Theta$ keeps unchanged, applying SGD guarantees the convergence of $\hat { \bf H }$ to $\mathbf { H }$ .
+Our experiment setting satisfies the assumption, e.g., $N = 8 0 0$ and $d _ { 2 } ~ = ~ 1 0 2 4$ , and thus the convergence is guaranteed according to $\mathbb { \left| \left[ 2 3 \right] \right| }$ . The proof of Theorem 2 can be found in Appendix $\bigtriangledown ,$ In some simple models such as logistic regression or neural network models only containing $F C$ layers, the attack will recover the data only by implementing the first two steps.
+Step III: Recover data. We randomly initialize the fake data and fake labels followed by uniform distribution $\hat { \mathcal { D } } = \{ \hat { \mathbf { x } } _ { n } , \hat { y } _ { n } \} _ { n = 1 } ^ { N }$ . According to equation $( 4 )$ , we have $\widetilde { \mathbf { h } } _ { n } = h ( \boldsymbol { \Theta } _ { c } , \hat { \mathbf { x } } _ { n } ) \in \mathbb { R } ^ { \dot { d } _ { 1 } }$ .
+Given $\nabla _ { \Theta } \mathcal { L } ( \Theta , \mathcal { D } ( \mathbf { s } _ { i } ) )$ and $\hat { \mathbf { H } } ^ { * }$ , our objective function in the last step is
+$$
+\begin{array} { r l } { \displaystyle } & { \displaystyle = \arg \operatorname* { m i n } _ { \hat { \mathcal { D } } } \mathbb { E } _ { s _ { i } \sim \mathrm { U n i f } ( \mathcal { S } ) } [ \mathcal { F } _ { 3 } ( \hat { D } ; \mathbf { s } _ { i } ) ] \medskip } \\ & { \displaystyle } \\ & { \mathcal { F } _ { 3 } ( \hat { D } ; \mathbf { s } _ { i } ) : = \alpha \big \| \nabla _ { \Theta } \mathcal { L } ( \Theta , \mathcal { D } ( \mathbf { s } _ { i } ) ) - \nabla _ { \Theta } \mathcal { L } ( \Theta , \hat { \mathcal { D } } ( \mathbf { s } _ { i } ) ) \big \| _ { 2 } ^ { 2 } + \beta \underline { { \mathrm { T V } } } _ { \xi } ( \hat { \mathcal { X } } ( \mathbf { s } _ { i } ) ) + \gamma \displaystyle \sum _ { n = 1 } ^ { N } \big \| \mathbf { s } _ { i } [ n ] \big ( \hat { \mathbf { H } } _ { n } ^ { * } - \tilde { \mathbf { h } } _ { n } \big ) \big \| _ { 2 } ^ { 2 } } \end{array}
+$$
+where $\alpha , \beta$ and $\gamma$ are coefficients, $\underline { { \mathrm { T V } } } _ { \xi } ( \hat { \mathcal X } ( \mathbf { s } _ { i } ) )$ is the truncated total variation (TV) norm which is 0 if the TV-norm of $\hat { \mathcal { X } } ( \mathbf { s } _ { i } ) = \{ \hat { \mathbf { x } } _ { n } | \mathbf { s } _ { i } [ n ] = 1 \}$ is smaller than $\xi$ , and $\hat { \cal { D } } ( { \bf s } _ { i } ) = \{ \{ \hat { \bf x } _ { n } , \hat { y } _ { n } \} | { \bf s } _ { i } [ n ] = 1 \}$ . In each iteration $t$ , the objective function of step III is $\mathcal { F } _ { 3 } ( \hat { \mathcal { D } } ; \mathbf { s } ^ { t } )$ . The first term in $\textcircled{9}$ is the $\ell _ { 2 }$ norm in $\pmb { \Vert 3 2 \Vert }$ . The second term is the TV norm and the last term is the internal representation norm regularizer. We also define $\nabla _ { \hat { D } } \mathcal { F } _ { 3 } ( \hat { D } ; \mathbf { s } ^ { t } ) = \{ \nabla _ { \hat { \mathbf { x } } _ { n } } \mathcal { F } _ { 3 } ( \hat { D } ; \mathbf { s } ^ { t } ) , \nabla _ { \hat { y } _ { n } } \mathcal { F } _ { 3 } ( \hat { D } ; \mathbf { s } ^ { t } ) \} _ { n = 1 } ^ { N } .$ .
+To ensure attacking efficiency, we consider two flexible update protocols in CAFE — Algorithm $3 \mathrm { { : } }$ CAFE (Nested-loops) and Algorithm $4 { : }$ CAFE (Single-loop). Empirically, Algorithm $\bar { 4 }$ will take fewer iterations than those of Algorithm $\textcircled { 3 }$ More details can be found in the experiment results in Section $4 . 2 .$ We also discuss the theoretical guarantee for each step and its proof in Appendix E.
+# 3.4 Defense strategy: Leveraging fake gradients as a countermeasure to CAFE
+Although CAFE comes with theoretical recovery guarantees, the underlying premise is that the clients will upload true (correct) gradients for aggregation. Therefore, we propose an intuitive and practical approach to mitigate CAFE by requiring each client to upload fake (but similar) gradients, resulting in incorrect data recovery via CAFE. Specifically, to solve the problem of leakage from true gradients, we design a defense called Fake Gradients and summarize it in Algorithm 5 of Appendix F. The main idea of this defense is that attackers will aim to match wrong gradients and invert incorrect inputs to the first FC layer so that attackers cannot recover the true training data. The defending strategy in Algorithm 5 (Appendix F) can be added between Line 8 and 9 in Algorithms 1 and 2.
+As summarized in Algorithm $\boxed { 5 }$ (Appendix F), each local worker can randomly generate gradients with the normal distribution ${ \sqrt { ( 0 , \sigma ^ { 2 } ) } }$ and sort the elements in descending order (Line $1 , \stackrel {  } { 2 } )$ . At the same time, local workers also sort their true gradients in descending order and record indexes of the sorted items (Line $^ { 7 ) }$ . Then, one computes the $L _ { 2 }$ -norm distance between a true gradient and all fake gradients to find the nearest fake gradient (Line $^ { 1 2 ) }$ . Afterwards, we pair fake gradients to match true gradients by the sorted order (Line $^ { 1 7 ) }$ . This an important step so that we can keep large/small values at the same positions of true gradients. Finally, local workers upload the fake gradients to the server.
+Impact on model training. Chen et al. [5] has proved that if the distance between the actual gradients and the gradient surrogate is smaller than a decreasing threshold, using the gradient surrogate to update the model still guarantees convergence. Building upon the results in $[ \bar { | 5 | }$ , we set a sufficient threshold such that the distance between the fake gradients and the true gradients are smaller than the threshold. In this case, we can still achieve the learning performance as if true gradients are used.
+Table 2: Comparison with the state-of-the-art ( $M = 4$ , $K = 4 0$ , batch ratio $= 0 . 0 5 \mathrm { , }$ )
+<table><tr><td rowspan=1 colspan=1>PSNR   DatasetMethod</td><td rowspan=1 colspan=1>CIFAR-10</td><td rowspan=1 colspan=1>MNIST</td><td rowspan=1 colspan=1>Linnaeus 5</td></tr><tr><td rowspan=1 colspan=1>CAFE</td><td rowspan=1 colspan=1>31.83</td><td rowspan=1 colspan=1>43.15</td><td rowspan=1 colspan=1>33.22</td></tr><tr><td rowspan=1 colspan=1>DLG</td><td rowspan=1 colspan=1>9.29</td><td rowspan=1 colspan=1>7.96</td><td rowspan=1 colspan=1>7.14</td></tr><tr><td rowspan=1 colspan=1>Cosine Similarity</td><td rowspan=1 colspan=1>7.38</td><td rowspan=1 colspan=1>7.84</td><td rowspan=1 colspan=1>8.31</td></tr><tr><td rowspan=1 colspan=1>SAPAG</td><td rowspan=1 colspan=1>6.07</td><td rowspan=1 colspan=1>3.86</td><td rowspan=1 colspan=1>6.74</td></tr><tr><td rowspan=1 colspan=1>BN regularizer</td><td rowspan=1 colspan=1>18.94</td><td rowspan=1 colspan=1>13.38</td><td rowspan=1 colspan=1>8.09</td></tr><tr><td rowspan=1 colspan=1>GC regularizer</td><td rowspan=1 colspan=1>13.63</td><td rowspan=1 colspan=1>9.24</td><td rowspan=1 colspan=1>12.32</td></tr></table>
+Table 3: PSNR vs batch size $K$ (800 data samples in total)
+<table><tr><td rowspan=1 colspan=1>PSNR     DatasetK</td><td rowspan=1 colspan=1>CIFAR-10</td><td rowspan=1 colspan=1>MNIST</td><td rowspan=1 colspan=1>Linnaeus 5</td></tr><tr><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>30.83</td><td rowspan=1 colspan=1>32.60</td><td rowspan=1 colspan=1>28.00</td></tr><tr><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>35.70</td><td rowspan=1 colspan=1>39.00</td><td rowspan=1 colspan=1>30.53</td></tr><tr><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>31.83</td><td rowspan=1 colspan=1>43.15</td><td rowspan=1 colspan=1>33.22</td></tr><tr><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>36.87</td><td rowspan=1 colspan=1>47.05</td><td rowspan=1 colspan=1>30.43</td></tr><tr><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>38.94</td><td rowspan=1 colspan=1>47.50</td><td rowspan=1 colspan=1>29.18</td></tr></table>
+![](images/0e7004dce0f73e82eb5c47099291c9e1d863aafe693bc73748eeff8b470b12c5.jpg)
+Figure 5: Visual comparison on the effect of auxiliary regularizers.
+![](images/631b3174ebcd9842ff09a53e80bbfef965598b958109d216f846ac3ebce4a685.jpg)
+Figure 6: Visual comparison of the real and recovered data using ordinary and fake gradients.
+# 4 Experiments
+We conduct experiments on MNIST $ { \mathbb { I } }  { \mathrm { 1 8 } }  { \mathrm { ] } }$ , CIFAR-10 [17] and Linnaeus 5 [4] datasets in VFL settings. The hyper-parameter settings are shown in Appendix $\mathbf { G . l . }$ Our algorithm recovers all the data participating in VFL with a relative large batch size (more than 40). Scaling up to our hardware limits (RTX 2080 and TITAN V), CAFE can leak as many as 800 images in the VFL setting including 4 workers with a batch size as large as 100. The neural network model architecture used in the simulation is shown in Figure 4. To measure the data leakage performance, we use the peak signalto-noise ratio (PSNR) value and the mean squared error (MSE). Higher PSNR value of leaked data represents better performance of data recovery.
+# 4.1 Comparison with the state-of-the-art
+We compare CAFE with five state-of-the-art methods using the batch size of 40 images in each iteration. For fair comparisons, all methods were run on the the same model and iterations.
+i) DLG $\pmb { \mathbb { B 2 } }$ : The deep gradients leakage method is equivalent to replacing the objective function in $\textcircled { 9 }$ with the squared $\ell _ { 2 }$ norm distance.
+ii) Cosine Similarity [11]: The objective function is equivalent to replacing the objective function in $\textcircled { 9 }$ with the linear combination of cosine similarity and TV norm of the recovered images. iii) SAPAG [25]: The objective function is equivalent to replacing the objective function in $( 9 )$ with the Gaussian kernel based function.
+iv) Batch normalization (BN) regularizer $[ \pmb { \big | 2 9 } ]$ : The objective function is equivalent to replacing the TV norm and internal representation norm in $\textcircled{9}$ with the batch normalization regularizer $\mathbb { \left[ \left[ 2 9 \right] \right. }$ v) Group consistency (GC) regularizer $[ \pmb { \big | 2 9 } ]$ : The objective function is equivalent to replacing the TV norm and internal representation norm in $( 9 )$ with the group consistency regularizer $\dot { \mathbb { R } } \mathfrak { Q } \mathfrak { h }$ .
+In GradInversion $\mathbb { \left. 2 9 \right. }$ , several additional assumptions have been made. For example, the assumption of non-repeating labels in the batch is hard to be satisfied in datasets such as CIFAR-10, MNIST and Linnaeus 5. In those datasets, we use batch size of more than 40, which is larger than the number of classes (10 or 5). Nevertheless, we still compared our CAFE to the methods by using the batch normalization regularizer and group consistency regularizer mentioned in $\mathbb { \left[ \left[ 2 9 \right] \right. }$ in CAFE.
+Theory-driven label inference methods have been proposed in $\pmb { \| } \pmb { \bigtriangledown } $ and $\left[ \left[ 2 6 \right] \right]$ . However, our attack mainly deals with training data leakage rather than labels. In $\lVert 2 2 \rVert$ , the authors proposed a sufficient requirement that "each data sample has at least two exclusively activated neurons at the last but one layer". However, in our training protocol, the batch size is too large and it is almost impossible to ensure that each selected sample has at least two exclusively activated neurons. In $\pmb { \mathbb { B } } \mathbf { \mathbb { I } }$ , it is assumed that the method will only return a linear combination of the selected training data, which is a very restricted assumption. As the results, we did not compare to those methods in Table 2.
+Table 4: Effect of auxiliary regularizers $M = 4$ , $K = 4 0$ , batch ratio $= 0 . 0 5$ )
+<table><tr><td rowspan=1 colspan=1>PSNR  DatasetsAlgorithm</td><td rowspan=1 colspan=1>CIFAR-10</td><td rowspan=1 colspan=1>Linnaeus 5</td><td rowspan=1 colspan=1>MNIST</td></tr><tr><td rowspan=1 colspan=1>CAFE</td><td rowspan=1 colspan=1>31.83</td><td rowspan=1 colspan=1>33.22</td><td rowspan=1 colspan=1>43.15</td></tr><tr><td rowspan=1 colspan=1>CAFE (α = 0)</td><td rowspan=1 colspan=1>33.93</td><td rowspan=1 colspan=1>28.62</td><td rowspan=1 colspan=1>31.93</td></tr><tr><td rowspan=1 colspan=1>CAFE (g = 0)</td><td rowspan=1 colspan=1>25.57</td><td rowspan=1 colspan=1>25.29</td><td rowspan=1 colspan=1>34.51</td></tr><tr><td rowspan=1 colspan=1>CAFE (β = 0)</td><td rowspan=1 colspan=1>18.25</td><td rowspan=1 colspan=1>23.22</td><td rowspan=1 colspan=1>31.98</td></tr><tr><td rowspan=1 colspan=1>CAFE (γ = 0)</td><td rowspan=1 colspan=1>12.51</td><td rowspan=1 colspan=1>12.37</td><td rowspan=1 colspan=1>6.34</td></tr></table>
+Table 5: Nested-loops vs single-loop CAFE $M = 4$ , $K = 4 0$ , batch ratio $= 0 . 0 5$ )
+<table><tr><td rowspan=1 colspan=1>Iterations  modeDatasets</td><td rowspan=1 colspan=1>CIFAR-10</td><td rowspan=1 colspan=1>MNIST</td><td rowspan=1 colspan=1>Linnaues 5</td></tr><tr><td rowspan=1 colspan=1>Single loop</td><td rowspan=1 colspan=1>7300(8000)</td><td rowspan=1 colspan=1>6600(8000)</td><td rowspan=1 colspan=1>12400(20000)</td></tr><tr><td rowspan=1 colspan=1>Nested-loopsStepI</td><td rowspan=1 colspan=1>8000(8000)</td><td rowspan=1 colspan=1>8000(8000)</td><td rowspan=1 colspan=1>12428(20000)</td></tr><tr><td rowspan=1 colspan=1>Nested-loopsStep II</td><td rowspan=1 colspan=1>2404(8000)</td><td rowspan=1 colspan=1>8000(8000)</td><td rowspan=1 colspan=1>20000(20000)</td></tr><tr><td rowspan=1 colspan=1>Nested-loopsStep II</td><td rowspan=1 colspan=1>1635(8000)</td><td rowspan=1 colspan=1>2468(8000)</td><td rowspan=1 colspan=1>20000(20000)</td></tr></table>
+Table 6: Effects of number of workers $M$ ( $K = 4 0$ , batch ratio $= 0 . 0 5$ )
+<table><tr><td rowspan=1 colspan=1>PSNR    DatasetsM</td><td rowspan=1 colspan=1>CIFAR-10</td><td rowspan=1 colspan=1>Linnaeus 5</td><td rowspan=1 colspan=1>MNIST</td></tr><tr><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>31.83</td><td rowspan=1 colspan=1>33.22</td><td rowspan=1 colspan=1>43.15</td></tr><tr><td rowspan=1 colspan=1>16</td><td rowspan=1 colspan=1>28.39</td><td rowspan=1 colspan=1>39.85</td><td rowspan=1 colspan=1>39.28</td></tr></table>
+![](images/c9a7b613b5c42b8ef154263afdb51b1b7d2b39819d2ae8e13939cab5c0d3a1a9.jpg)
+Figure 7: Training loss of true gradients and fake gradients on CIFAR-10, Linnaeus 5 and MNIST.
+CAFE outperforms these methods both qualitatively (Figure $^ { 1 ) }$ and quantitatively (Table $^ { 2 ) }$ . Its PSNR values are always above 30 at the end of each CAFE attacking process, suggesting high data recovery quality. However, the PSNR of other methods are below 10 on all the three datasets.
+# 4.2 Ablation study
+We test CAFE under different batch size, network structure and with/without auxiliary regularizers.
+(i) PSNR via Batch size $K$ . Table 3 shows that the PSNR values always keep above 30 on CIFAR-10, above 32 on MNIST and above 28 on Linnaeus 5 when the batch size $K$ increases with fixed number of workers and number of total data points. The result implies that the increasing $K$ has almost no influence on data leakage performance of CAFE and it fails to be an effective defense.
+(ii) PSNR via Epoch. Theoretically, given infinite number of iterations, we prove that we can recover $\nabla _ { \mathbf { U } } \mathcal { L }$ and $\mathbf { H }$ because the respective objective function in $( 7 )$ and $\textcircled{8}$ in our paper is strongly convex as long as $N < d _ { 2 }$ and $\mathbf { R a n k } ( \mathbf { V } ^ { * } ) = \bar { N }$ in Sections $\underset { . } { \mathrm {  ~ { \cal { C } } ~ } }$ and D of supplementary material. The corresponding experimental results and analysis are shown in Appendix G.2.
+(iii) Effect of regularizers. Table 4 demonstrates the impact of regularizers. From Figure 5, adjusting the threshold $\xi$ prevents images from being over blurred during the reconstruction process. TV norm can eliminate the noisy patterns on the recovered images and increase the PSNR. We also find that the last term in $\textcircled{9}$ , the internal representation norm regularizer, contributes most to the data recovery. In Table 4, CAFE still performs well without the first term $( \alpha = 0$ ) in $( 9 )$ . The reason is that the internal representation regularizer already allows data to be fully recovered. Notably, CAFE also performs well on MNIST even without the second term $\beta = 0$ ) in $( 9 )$ . It is mainly due to that MNIST is a simple dataset that CAFE can successfully recover even without the TV-norm regularizer.
+(iv) Nested-loops vs single-loop. We compare both modes of CAFE (Algorithms $\boxed { 3 } \mathrm { a n d } \boxed { 4 }$ on all datasets. In Table $5 ,$ the number of iterations is the maximum iterations at each step. For the CAFE (single-loop), if the objective function in step I $\textcircled { 7 }$ decreases below $1 0 ^ { - 9 }$ , we switch to step II. If the objective function in step II $( 8 )$ decreases below $5 \times 1 0 ^ { - 9 }$ , we switch to step III. When the PSNR value reaches 27 on CIFAR-10, 30 on Linnaeus 5, 38 on MNIST, we stop both algorithms and record the iteration numbers. As shown in Table $5 ,$ CAFE single-loop requires fewer number of iterations. Meanwhile, it is difficult to set the loop stopping conditions in the CAFE Nested-loops mode. In particular, $\mathbf { V } ^ { * }$ and $\hat { \mathbf { H } } ^ { * }$ with low recovery precision may impact the data recovery performance.
+(v) Effects of number of workers $M$ . Although data are partitioned on feature space across workers, the dimension of the entire data feature space is fixed and independent of $M$ . Therefore, increasing number of workers theoretically does not change the dimension of variables associated with data recovery in $\textcircled { 3 }$ . In practice, different from HFL, where there could be hundreds of workers, in VFL, the workers are typically financial organizations or companies. Therefore, the number of workers is usually small $\mathbb { \lVert 1 3 \rVert }$ . In Table $6 ,$ we compare the results of 4 workers with 16 workers following the same experiment setup. The CAFE performances are comparable.
+Table 7: Attacking while training in VFL
+<table><tr><td rowspan=1 colspan=1>PSNR(Ir)   SettingDataset</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>3</td></tr><tr><td rowspan=1 colspan=1>CIFAR10</td><td rowspan=1 colspan=1>31.24(10-4)</td><td rowspan=1 colspan=1>27.62(5×10-4)</td><td rowspan=1 colspan=1>25.22(10-3)</td></tr><tr><td rowspan=1 colspan=1>MNIST</td><td rowspan=1 colspan=1>31.82(10-4)</td><td rowspan=1 colspan=1>28.42(5×10-4)</td><td rowspan=1 colspan=1>23.60(10-3)</td></tr><tr><td rowspan=1 colspan=1>Linaeus 5</td><td rowspan=1 colspan=1>30.74(10-6)</td><td rowspan=1 colspan=1>21.45(5×10-5)</td><td rowspan=1 colspan=1>20.68(10-4)</td></tr></table>
+Table 8: Training while attacking on MNIST
+<table><tr><td rowspan=1 colspan=1>#of iterations</td><td rowspan=1 colspan=1>PSNR value</td><td rowspan=1 colspan=1>Training loss</td><td rowspan=1 colspan=1>Testing accuracy</td></tr><tr><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>5.07</td><td rowspan=1 colspan=1>2.36</td><td rowspan=1 colspan=1>0.11</td></tr><tr><td rowspan=1 colspan=1>2000</td><td rowspan=1 colspan=1>11.68</td><td rowspan=1 colspan=1>2.31</td><td rowspan=1 colspan=1>0.27</td></tr><tr><td rowspan=1 colspan=1>6000</td><td rowspan=1 colspan=1>18.07</td><td rowspan=1 colspan=1>1.99</td><td rowspan=1 colspan=1>0.54</td></tr><tr><td rowspan=1 colspan=1>10000</td><td rowspan=1 colspan=1>18.12</td><td rowspan=1 colspan=1>1.82</td><td rowspan=1 colspan=1>0.64</td></tr><tr><td rowspan=1 colspan=1>15000</td><td rowspan=1 colspan=1>16.86</td><td rowspan=1 colspan=1>1.63</td><td rowspan=1 colspan=1>0.65</td></tr><tr><td rowspan=1 colspan=1>20000</td><td rowspan=1 colspan=1>20.72</td><td rowspan=1 colspan=1>1.68</td><td rowspan=1 colspan=1>0.68</td></tr></table>
+# 4.3 Tests for attacking while training scenarios
+Previous works have shown that DLG performs better on an untrained model than a trained one $\mathbb { m }$ This is also true for CAFE. Our theoretical analysis can provide the partial reason. When the model is trained or even convergent, the real gradients of loss can be very small. It is possible that the value of the recovered $\nabla _ { \mathbf { U } } \mathcal { L } ( \hat { \textbf { \Theta } } , \mathcal { D } )$ will also be close to 0. In that case, it can be difficult to recover H.
+We also implement CAFE in the ‘attacking while training’ scenario, in which we continuously run the VFL process. When the model is training, both of the selected batch data and the model parameters change every iteration, which may cause the attack loss to diverge. However, from our experimental results in Table $\bigtriangledown ,$ CAFE is able to recover training images when the learning rate (lr) is relatively small. Increasing the learning rate renders data leakage more difficult because the model is making more sizeable parameter changes in each iteration, which can be regarded as an effective defense strategy. According to our experiment in Table $\boxed { 8 }$ the model indeed converges with a relative small learning rate (e.g., Adam with learning rate $1 0 ^ { - 6 }$ , trained on 800 images, tested on 100 images, batch size $K = 4 0$ ), which indicates that we can conduct our attack successfully while a model is converging. The data indeed leaks to a certain level (PSNR above 20) while the model converges at a certain accuracy (0.68), which indicates that CAFE works in an attacking while training scenario.
+# 4.4 Mitigation of CAFE data leakage attack via fake gradients
+Training and defense performance. To demonstrate how fake gradients defend against CAFE (Section $\overline { { \textcircled { 3 . 4 } } }$ , we conduct CAFE with unchanged $\Theta$ , which is the strongest data leakage attack setting. We use the SGD optimizer with learning rate set as 0.1, $\sigma ^ { 2 } = 1 . 1$ , and $\nu = 1 0 0 0$ for fake gradients. Figure $\boxed { 6 }$ shows a comparison between the visual image quality of the data recovered by CAFE on CIFAR-10 when the ordinary gradients and fake gradients are used, respectively. The PSNR of recovered data in CAFE on ordinary and fake gradients is 28.68 and 7.67, respectively. Moreover, Figure $^ { 7 }$ shows that the training process with fakes gradients behaves in a similar way to the one with true gradients, confirming that the use of fake gradients does not lose the training efficacy. We have also added the experiment to discuss the difference of our fake gradients method to differential privacy (DP). The results and analysis are shown in Appendix G.3.
+# 4.5 Recover human face data
+We also implement CAFE on Yale $3 2 \times 3 2$ human face dataset $\pmb { \mathbb { L 2 } }$ , which achieves the PSNR above 42. The recovered data are shown in Appendix $\mathbf { G . } 4 .$ It implies that CAFE can fully recover data that requires privacy protection such as facial images.
+# 5 Conclusions
+In this paper, we uncover the risk of catastrophic data leakage in vertical federated learning (CAFE) through a novel algorithm that can perform large-batch data leakage with high data recovery quality and theoretical guarantees. Extensive experimental results demonstrate that CAFE can recover large-scale private data from the shared aggregated gradients on vertical FL settings, overcoming the batch limitation problem in current data leakage attacks. We also propose an effective countermeasure using fake gradients to mitigate the potential risks of CAFE.
+# Acknowledgments
+This work was supported by National Science Foundation CAREER Award 2047177, and the Rensselaer-IBM AI Research Collaboration (http://airc.rpi.edu), part of the IBM AI Horizons Network (http://ibm.biz/AIHorizons). C-Y Hsu and C-M Yu were supported by MOST 110- 2636-E-009-018, and we also thank National Center for High-performance Computing (NCHC) of National Applied Research Laboratories (NARLabs) in Taiwan for providing computational and storage resources.
+# References
+[1] M. Abadi, A. Chu, I. Goodfellow, H. B. McMahan, I. Mironov, K. Talwar, and L Zhang. "Deep learning with differential privacy". In Proc. the 2016 ACM SIGSAC Conference on Computer and Communications Security, pages 308–318, Vienna, Austria, Oct, 2016.
+[2] E. Bagdasaryan, A. Veit, Y. Hua, D. Estrin, and V. Shmatikov. "How to backdoor federated learning". In Proc. the Twenty Third International Conference on Artificial Intelligence and Statistics, volume 108 of Proceedings of Machine Learning Research, pages 2938–2948. PMLR, 26–28 Aug 2020.
+[3] A. N. Bhagoji, S. Chakraborty, P. Mittal, and S. Calo. "Analyzing federated learning through an adversarial lens". In Proc. International Conference on Machine Learning, pages 634–643, Long Beach, California, 2019.
+[4] G. Chaladze and L. Kalatozishvili. Linnaeus 5 dataset for machine learning, 2017.
+[5] T. Chen, G. Giannakis, T. Sun, and W. Yin. "LAG: lazily aggregated gradient for communicationefficient distributed learning". In Proc. Advances in Neural Information Processing Systems, volume 31, Montréal, CANADA, 2018.
+[6] T. Chen, X. Jin, Y. Sun, and W. Yin. "VAFL: a method of vertical asynchronous federated learning". arXiv preprint:2007.06081, Jul, 2020.
+[7] K. Cheng, T. Fan, Y. Jin, Y. Liu, T. Chen, and Q. Yang. "Secureboost: A lossless federated learning framework". In Proc. The 1st International Workshop on Federated Machine Learning for User Privacy and Data Confidentiality (FML’19) in conjunction with IJCAI, 2019.
+[8] T. Chilimbi, Y. Suzue, J. Apacible, and K. Kalyanaraman. "Project adam: Building an efficient and scalable deep learning training system". In 11th USENIX Symposium on Operating Systems Design and Implementation (OSDI 14), pages 571–582, Broomfield, CO, October 2014.
+[9] L. Fan, K. Ng, C. Ju, T. Zhang, C. Liu, C. S. Chan, and Q. Yang. "Rethinking privacy preserving deep learning: How to evaluate and thwart privacy attacks". In Federated Learning - Privacy and Incentive, volume 12500 of Lecture Notes in Computer Science, pages 32–50. Springer, 2020.
+[10] M. Fredrikson, S. Jha, and T. Ristenpart. "Model inversion attacks that exploit confidence information and basic countermeasures". In Proc. the 22nd ACM SIGSAC Conference on Computer and Communications Security, pages 1322–1333, New York, NY, USA, 10 2015.
+[11] J. Geiping, H. Bauermeister, H. Dröge, and M. Moeller. "Inverting gradients - how easy is it to break privacy in federated learning?". In Proc. Advances in Neural Information Processing Systems, 2020.
+[12] A.S. Georghiades, P.N. Belhumeur, and D.J. Kriegman. "From few to many: Illumination cone models for face recognition under variable lighting and pose". IEEE Trans. Pattern Anal. Mach. Intelligence, 23(6):643–660, 2001.
+[13] C. He, S. Li, J. So, M. Zhang, H. Wang, X. Wang, P. Vepakomma, A. Singh, H. Qiu, L. Shen, P. Zhao, Y. Kang, Y. Liu, R. Raskar, Q. Yang, M. Annavaram, and S. Avestimehr. "Fedml: A research library and benchmark for federated machine learning". In Proc. Advances in Neural Information Processing Systems Workshop: SpicyFL 2020, 2020.
+[14] B. Hitaj, G. Ateniese, and F. Pérez-Cruz. Deep models under the GAN: information leakage from collaborative deep learning. In Proc. the 2017 ACM SIGSAC Conference on Computer and Communications Security, New York, NY, USA, 2017.
+[15] F.N. Iandola, K. Ashraf, M.W. Moskewicz, and K. Keutzer. Firecaffe: near-linear acceleration of deep neural network training on compute clusters. In Proc. 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 2592–2600, Los Alamitos, CA, USA, Jun 2016.
+[16] P. Kairouz, H. B. McMahan, B. Avent, A. Bellet, M. Bennis, A. N. Bhagoji, K. Bonawit, Z. Charles, G. Cormode, R. Cummings, R. G. L. D’Oliveira, H. Eichner, S. El Rouayheb, D. Evans, J. Gardner, Z. Garrett, A. Gascón, B. Ghazi, P. B. Gibbons, M. Gruteser, Z. Harchaoui, C. He, L. He, Z. Huo, B. Hutchinson, J. Hsu, M. Jaggi, T. Javidi, G. Joshi, M. Khodak, J. Konecný, A. Korolova, F. Koushanfar, S. Koyejo, T. Lepoint, Y. Liu, P. Mittal, M. Mohri, R. Nock, A. Özgür, R. Pagh, H. Qi, D. Ramage, R. Raskar, M. Raykova, D. Song, W. Song, S. U. Stich, Z. Sun, A. Theertha Suresh, F. Tramèr, P. Vepakomma, J. Wang, L. Xiong, Z. Xu, Q. Yang, F. X. Yu, H. Yu, and S. Zhao. "Advances and open problems in federated learning". arXiv preprint:1912.04977, December 2019.
+[17] A. Krizhevsky and G. Hinton. "Learning multiple layers of features from tiny images". Master’s thesis, Department of Computer Science, University of Toronto, 2009.
+[18] Y. LeCun and C. Cortes. MNIST handwritten digit database. 2010.
+[19] M. Li. "Scaling distributed machine learning with the parameter server". In Proc. the 11th USENIX Conference on Operating Systems Design and Implementation, pages 1–1, Broomfield, CO, USA, 08 2014.
+[20] H. McMahan, E. Moore, D. Ramage, S. Hampson, and B. A. Arcas. "Communication-efficient learning of deep networks from decentralized data". In AISTATS, Ft. Lauderdale, FL, USA, 2017.
+[21] L. Melis, C. Song, E. D. Cristofaro, and V. Shmatikov. "Inference attacks against collaborative learning". In Proc. the 35th Annual Computer Security Applications Conference, page 148–162, New York, NY, USA, 2018.
+[22] X. Pan, M. Zhang, Y. Yan, J. Zhu, and M. Yang. "Theory-oriented deep leakage from gradients via linear equation solver". In arXiv eprint 2010.13356, 2020.
+[23] A. Rakhlin, O. Shamir, and K. Sridharan. "Making gradient descent optimal for strongly convex stochastic optimization". In Proc. International Conference on Learning Representations, Edinburgh, Scotland, 2012.
+[24] R. Shokri and V. Shmatikov. "Privacy-preserving deep learning". In Proc. the 22nd ACM SIGSAC Conference on Computer and Communications Security, page 1310–1321, Denver, Colorado, USA, 2015.
+[25] Y. Wang, J. Deng, D. Guo, C. Wang, X. Meng, H. Liu, C. Ding, and S. Rajasekaran. Sapag: A self-adaptive privacy attack from gradients. arXiv, eprint:2009.06228, 2020.
+[26] W. Wei, L. Liu, M. Loper, K. H. Chow, M. E. Gursoy, S. Truex, and Y. Wu. "A framework for evaluating gradient leakage attacks in federated learning". arXiv, eprint 2004.10397, 2020.
+[27] C. Xie, K. Huang, P. Chen, and B. Li. "DBA: Distributed backdoor attacks against federated learning". In International Conference on Learning Representations, Addis Ababa, Ethiopia, 2020.
+[28] Q. Yang, Y. Liu, T. Chen, and Yongxin Tong. Federated machine learning: Concept and applications. ACM Trans. Intell. Syst. Technol., 10(2), January 2019.
+[29] H. Yin, A. Mallya, A. Vahdat, J. M. Alvarez, J. Kautz, and P. Molchanov. "See through gradients: Image batch recovery via gradinversion". In Proc. Conference on Computer Vision and Pattern Recognition, 2021.
+[30] B. Zhao, K. R. Mopuri, and H. Bilen. idlg: Improved deep leakage from gradients. arXiv, eprint:2001.02610, 2020.
+[31] J. Zhu and M. B. Blaschko. "R-GAP: Recursive gradient attack on privacy". In International Conference on Learning Representations, 2021.
+[32] L. Zhu, Z. Liu, and S. Han. "Deep leakage from gradients". In Advances in Neural Information Processing Systems 32, pages 14774–14784, Vancouver, Canada, 2019.

parse/train/b4YiFnQH3gN/b4YiFnQH3gN_content_list.json ADDED Viewed

	@@ -0,0 +1,1461 @@

+[
+    {
+        "type": "text",
+        "text": "CAFE: Catastrophic Data Leakage in Vertical Federated Learning ",
+        "text_level": 1,
+        "bbox": [
+            271,
+            122,
+            725,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Xiao Jin Rensselaer Polytechnic Institute jinx2@rpi.edu ",
+        "bbox": [
+            173,
+            226,
+            382,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Pin-Yu ChenIBM Researchpin-yu.chen@ibm.com",
+        "bbox": [
+            387,
+            226,
+            537,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Chia-Yi Hsu National Yang Ming Chiao Tung University chiayihsu $8 3 1 5 @$ gmail.com ",
+        "bbox": [
+            540,
+            226,
+            828,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Chia-Mu Yu National Yang Ming Chiao Tung University chiamuyu@gmail.com ",
+        "bbox": [
+            214,
+            287,
+            501,
+            329
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tianyi Chen Rensselaer Polytechnic Institute chent18@rpi.edu ",
+        "bbox": [
+            547,
+            287,
+            759,
+            329
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            363,
+            535,
+            380
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent studies show that private training data can be leaked through the gradients sharing mechanism deployed in distributed machine learning systems, such as federated learning (FL). Increasing batch size to complicate data recovery is often viewed as a promising defense strategy against data leakage. In this paper, we revisit this defense premise and propose an advanced data leakage attack with theoretical justification to efficiently recover batch data from the shared aggregated gradients. We name our proposed method as catastrophic data leakage in vertical federated learning (CAFE). Comparing to existing data leakage attacks, our extensive experimental results on vertical FL settings demonstrate the effectiveness of CAFE to perform large-batch data leakage attack with improved data recovery quality. We also propose a practical countermeasure to mitigate CAFE. Our results suggest that private data participated in standard FL, especially the vertical case, have a high risk of being leaked from the training gradients. Our analysis implies unprecedented and practical data leakage risks in those learning settings. The code of our work is available at https://github.com/DeRafael/CAFE. ",
+        "bbox": [
+            233,
+            393,
+            766,
+            601
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            625,
+            310,
+            641
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Federated learning (FL) $\\mathbb { B } \\mathbb { B }$ is an emerging machine learning framework where a central server and multiple workers collaboratively train a machine learning model. Some existing FL methods consider the setting where each worker has data of a different set of subjects but sharing common features. This setting is also referred to data partitioned or horizontal FL (HFL). Unlike the HFL setting, in many learning scenarios, multiple workers handle data about the same set of subjects, but each has a different set of features. This case is common in finance and healthcare applications [6]. In these examples, data owners (e.g., financial institutions and hospitals) have different records of those users in their joint user base, and so, by combining their features through FL, they can establish a more accurate model. We refer to this setting as feature-partitioned or vertical FL (VFL). ",
+        "bbox": [
+            174,
+            654,
+            825,
+            780
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Compared with existing distributed learning paradigms, FL raises new challenges including data heterogeneity and privacy $\\left[ \\left[ 2 0 \\right] \\right]$ . To protect data privacy, only model parameters and the change of parameters (e.g., gradients) are exchanged between server and workers [19, 15]. Recent works have studied how a malicious worker can embed backdoors or replace the global model in FL [2, 3, 27]. Furthermore, as exchanging gradients is often viewed as privacy-preserving protocols, little attention has been paid to information leakage from public shared gradients and batch identities. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            869
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In the context of data security and AI ethics, the possibility of inferring private user data from the gradients in FL has received growing interests [10, 14, 21], known as the data leakage problems. ",
+        "bbox": [
+            174,
+            876,
+            825,
+            904
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/2eb9a963a9a9a54f822632455758f7a57ec430880008974da1ed7ffe23897908.jpg",
+        "image_caption": [
+            "Figure 1: Visual comparison between CAFE (our method) with the state-of-the-art data leakage attacks including DLG [32], Cosine similarity $\\mathbb { \\ m }$ , SAPAG $\\mathbb { \\left[ \\left[ 2 5 \\right] \\right] }$ , BN regularzier $\\left[ \\left[ 2 9 \\right] \\right]$ and GC regularizer $\\left[ \\left[ 2 9 \\right] \\right]$ on Linnaeus 5 in VFL (4 workers, batch size $= 4 0$ and batch ratio $= 0 . 0 5$ ). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            92,
+            813,
+            396
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Previous works have made exploratory efforts on data recovery through gradients. See Section 2 and Table 1 for details. However, existing approaches often have the limitation of scaling up large-batch data recovery and are lacking in theoretical justification on the capability of data recovery, which may give a false sense of security that increasing the data batch size during training can prevent data leakage $\\textcircled { \\lvert 3 0 \\rvert }$ . Some recent works provide sufficient conditions for guaranteed data recovery, but the assumptions are overly restrictive and can be sometimes impractical, such as requiring the number of classes to be much larger than the number of recovered data samples [29]. ",
+        "bbox": [
+            174,
+            472,
+            825,
+            570
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To enhance scalability in data recovery and gain fundamental understanding on data leakage in VFL, in this paper we propose an advanced data leakage attack with theoretical analysis on the data recovery performance, which we call catastrophic data leakage in vertical federated learning (CAFE). As an illustration, Figure 1 demonstrates the effectiveness of CAFE for large-batch data recovery compared to existing methods. The contributions of this paper are summarized as follows. ",
+        "bbox": [
+            173,
+            577,
+            825,
+            646
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "C1) We develop a new data leakage attack named CAFE to overcome the limitation of current data leakage attacks on VFL. Leveraging the novel use of data index and internal representation alignments in VFL, CAFE is able to recover large-scale data in general VFL protocols.   \nC2) We provide theoretical guarantees on the recovery performance of CAFE, which permeates three steps of CAFE: (I) recovering gradients of loss with respect to the outputs of the first fully connected (FC) layer; (II) recovering inputs to the first FC layer; (III) recovering the original data.   \nC3) To mitigate the data leakage attack by CAFE, we develop a defense strategy which leverages the fake gradients and preserves the model training performance.   \nC4) We conduct extensive experiments on both static and dynamic VFL training settings to validate the superior data recovery performance of CAFE over state-of-the-art methods. ",
+        "bbox": [
+            161,
+            656,
+            826,
+            813
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            837,
+            321,
+            854
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recovering private training data from gradients has gained growing interests in FL. Recently, a popular method termed deep leakage from gradients (DLG) $\\left[ \\left[ 3 2 \\right] \\right]$ has been developed to infer training data in an efficient way without using any generative models or prior information. However, DLG lacks generalizability on model architecture and weight distribution initialization $\\mathbb { \\left[ \\left. 2 5 \\right] \\right. }$ . In $\\pmb { \\mathbb { B } } 0 \\|$ , an analytical approach has been developed to extract accurate labels from the gradients. In $\\mathbb { m }$ , another analytical approach has been developed to derive the inputs before a fully connected (FC) layer. However, in $\\dot { \\left[ \\mathrm { l i l l } \\right] }$ , their method only works on a single sample input and fails to extend on a batch of data. In $\\pmb { \\Vert 2 2 \\Vert }$ , a new approach has been developed by recovering the batch inputs before the FC layer through solving linear equations. However, strong assumptions have been made for solving the equations and cannot guarantee data recovery in more general cases. In $\\bigstar \\bigstar$ , it is claimed that a convolutional layer can always be converted to a FC layer. However, the gradients of the original convolutional layer are still different from the gradients of the converted FC layer, which impedes data recovery. Besides the new loss function proposed in $[ \\equiv 1 ]$ , several previous works design new loss functions or regularizers based on DLG and try to make their algorithms work on more general models and weight distribution initialization. In $\\bar { \\| 2 5 \\| }$ , a new Gaussian kernel based gradient difference is used as the distance measure. In $\\textcircled { \\scriptsize { 1 3 1 } }$ , a recursive method attack procedure has been developed to recover data from gradients. However, in both $\\mathbb { \\left. \\boldsymbol { \\Sigma } \\boldsymbol { \\bar { \\Sigma } } \\right. }$ and $\\pmb { \\mathbb { B } } \\mathbf { \\mathbb { 1 } }$ , the quality of recovery on batch data is degraded. A recent work $\\left[ \\left[ 2 9 \\right] \\right]$ proposes an algorithm named GradInversion to reconstruct images from noise based on given gradients. However, their theory and algorithm are mostly built on strong assumptions and empirical observations. Although they successfully reconstruct a batch of training data, the reported batch size is still no larger than 48. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/f079a4f13bad23bf5dad072397a8b1a36ab2326a7d11bf7b5bed5c4c79f3ac6a.jpg",
+        "table_caption": [
+            "Table 1: Comparison of CAFE with state-of-the-art data leakage attack methods in FL. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Optimization terms</td><td>Reported maximal batch size</td><td>Training while attacking</td><td>Theoretical guarantee</td><td>Additional information other than gradients</td></tr><tr><td>DLG B2</td><td>l2 distance between real and fake gradients</td><td>8</td><td>No</td><td>No</td><td>No</td></tr><tr><td>iDLG 目</td><td>l2 distance</td><td>8</td><td>No</td><td>Yes</td><td>No</td></tr><tr><td>Inverting Gradients 自</td><td>Cosine similarity, TV norm</td><td>8 100 (Mostly unrecognizable)</td><td>Yes</td><td>Yes</td><td>Number of local updates</td></tr><tr><td>AFramework for Evaluating Gradient Leakage 26]</td><td>l2 distance, label based regualrizer</td><td>8</td><td>No</td><td>Yes</td><td>No</td></tr><tr><td>SAPAG[ 因</td><td>Gaussian kernel based funciton</td><td>8</td><td>No</td><td>No</td><td>No</td></tr><tr><td>R-GAP 目</td><td>recursive gradient loss</td><td>5</td><td>No</td><td>Yes</td><td>The rank of matrix A defined in [31</td></tr><tr><td>Theory oriented 22]</td><td>l2 distance, l1 distances of the recovered feature map</td><td>32</td><td>No</td><td>Yes</td><td>Number of Exclusive activated neurons</td></tr><tr><td>GradInversion29]</td><td>Fidelity regularizers, Group consistency regularizers</td><td>48</td><td>No</td><td>No</td><td>Batch size &lt;number of classes &amp; Non repeating labels in a batch</td></tr><tr><td>CAFE (ours)</td><td>l2 distance, TV norm, Internal representation norm</td><td>100 (our hardware limit)</td><td>Yes</td><td>Yes</td><td>Batch indices</td></tr></table>",
+        "bbox": [
+            173,
+            112,
+            826,
+            405
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            420,
+            825,
+            669
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 CAFE: Catastrophic Data Leakage in Vertical Federated Learning ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            691,
+            761,
+            710
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we will introduce some necessary background of VFL and present our novel attack method. We consider the attack scenario where a honest-but-curious server follows the regular VFL protocols but intends to recover clients’ private data based on the aggregated gradients. Our method is termed CAFE: Catastrophic data leakage in vertical federated learning. While CAFE can be applied to any type of data, without loss of generality, we use image datasets throughout the paper. ",
+        "bbox": [
+            174,
+            724,
+            825,
+            795
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Preliminaries ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            814,
+            307,
+            829
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "VFL setting. FL can be categorized into horizontal and vertical FL settings $\\mathbb { \\left[ \\left[ 1 6 \\right] \\right] }$ . In this paragraph, we provide necessary background of VFL. Consider a set of $M$ clients: $\\mathcal { M } = \\{ 1 , 2 , \\dots , M \\}$ . A dataset of $N$ samples $\\mathcal { D } = \\{ ( \\mathbf { x } _ { n } , y _ { n } ) \\} _ { n = 1 } ^ { N }$ are maintained by the $M$ local clients, where $n$ is the data index. Each client $m$ in $\\mathcal { M }$ is associated with a unique features set. A certain data point ${ \\bf { X } } _ { n }$ in $\\mathcal { D }$ can be denoted by $\\mathbf { x } _ { n } = [ \\mathbf { x } _ { n , 1 } ^ { \\top } , \\mathbf { x } _ { n , 2 } ^ { \\top } , \\ldots , \\mathbf { x } _ { n , M } ^ { \\top } ] ^ { \\top }$ where ${ \\bf x } _ { n , m }$ is the $m$ -th partition of the $n$ -th sample vector. The label set $\\{ y _ { n } \\} _ { n = 1 } ^ { N }$ can be viewed as a special feature and is kept at the server or a certain local worker. Throughout this paper, we mainly study the VFL setting. CAFE can also be applied to HFL if the data indices of each randomly selected batch are known to workers during training. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            912
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            133
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Use case of VFL. VFL is suitable for cases where multiple data owners share the same data identity but their data differ in feature space. Use cases of VFL appear in finance, e-commerce, and health. For example, in medical industry, test results of the same patient from different medical institutions are required to diagnose whether the patient has a certain disease or not, but institutions tend not to share raw data. Figure 2 gives an example of VFL in medical industry. ",
+        "bbox": [
+            173,
+            138,
+            519,
+            265
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Batch indices in each iteration. For a given batch size $K$ , we define a set of vectors with binary entries as ${ \\mathcal { S } = \\{ \\mathbf { s } _ { 1 } , \\mathbf { s } _ { 2 } , \\dots , \\mathbf { s } _ { i } , \\dots \\} }$ with $| S | = { \\binom { \\bar { N } } { K } }$ . For each vector $\\mathbf { s } _ { i } \\in \\mathbb { R } ^ { N }$ in $s$ , its $n$ -th element ${ \\mathbf s } _ { i } [ n ]$ can be either 0 or 1. There are in total $K$ enires of $\\cdot _ { 1 } \\cdot$ in $\\mathbf { s } _ { i }$ . In each iteration $t$ , the server randomly selects one element from set $s$ denoted by $\\mathbf { s } ^ { t }$ , where $\\mathsf { \\bar { s } } ^ { t } [ n ]$ is the nth element in $\\mathbf { s } ^ { t }$ . The selected batch samples in the $t$ -th iteration are denoted by $\\mathcal { D } ( \\mathbf { s } ^ { t } ) = \\{ \\bar { ( } \\bar { \\mathbf { x } _ { n } } , y _ { n } \\mathbf { ) } \\vert \\mathbf { s } ^ { t } [ n ] = 1 \\}$ . ",
+        "bbox": [
+            173,
+            270,
+            519,
+            357
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/584aa44df41bf7437f10749d505ef3bf910675e011e4af438b3ef47b5a87fcb8.jpg",
+        "image_caption": [
+            "Figure 2: VFL among medical institutions "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            537,
+            143,
+            828,
+            316
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            357,
+            823,
+            387
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Loss function and gradients. We assume that the model is a neural network parameterized by $\\Theta$ , where the first FC layer is parameterized by $\\Theta _ { 1 } \\in \\mathbb { R } ^ { d _ { 1 } \\times d _ { 2 } }$ and its bias is $\\mathbf { b } _ { 1 } \\in \\mathbb { R } ^ { \\hat { d } _ { 2 } }$ . The loss function on the batch data $\\mathcal { D } \\dot { ( \\mathbf { s } ^ { t } ) }$ and on the entire training data $\\mathcal { D }$ is, respectively, denoted by ",
+        "bbox": [
+            173,
+            391,
+            828,
+            434
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/65398c96be28f567ae66cf230889c7cce4117c0209f6e606713930bae2928549.jpg",
+        "text": "$$\n\\mathcal { L } ( \\boldsymbol { \\Theta } , \\mathcal { D } ( \\mathbf { s } ^ { t } ) ) : = \\frac { 1 } { K } \\sum _ { n = 1 } ^ { N } \\mathbf { s } ^ { t } [ n ] \\mathcal { L } ( \\boldsymbol { \\Theta } , \\mathbf { x } _ { n } , y _ { n } ) \\quad \\mathrm { a n d } \\quad \\mathcal { L } ( \\boldsymbol { \\Theta } , \\mathcal { D } ) : = \\frac { 1 } { N } \\sum _ { n = 1 } ^ { N } \\mathcal { L } ( \\boldsymbol { \\Theta } , \\mathbf { x } _ { n } , y _ { n } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            220,
+            440,
+            779,
+            484
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The gradients of losses w.r.t. $\\Theta$ is denoted as ",
+        "bbox": [
+            174,
+            491,
+            470,
+            506
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/155bf567631c932136bd216462aa194123ef2dedd158cc9d03d1ab4d5b98b437.jpg",
+        "text": "$$\n\\nabla _ { \\Theta } \\mathcal { L } ( \\Theta , \\mathcal { D } ( \\mathbf { s } ^ { t } ) ) : = \\frac { \\partial \\mathcal { L } ( \\Theta , \\mathcal { D } ( \\mathbf { s } ^ { t } ) ) } { \\partial \\Theta } = \\frac { 1 } { K } \\sum _ { n = 1 } ^ { N } \\mathbf { s } ^ { t } [ n ] \\frac { \\partial \\mathcal { L } ( \\Theta , \\mathbf { x } _ { n } , y _ { n } ) } { \\partial \\Theta } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            277,
+            512,
+            720,
+            556
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "And similarly, we define $\\nabla _ { \\Theta } \\mathcal { L } ( \\Theta , \\mathcal { D } )$ ",
+        "bbox": [
+            174,
+            563,
+            428,
+            578
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Why large-batch data leakage attack is difficult? ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            593,
+            549,
+            609
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We motivate the design of our algorithm by providing some intuition on why performing large-batch data leakage from aggregated gradients is difficult $\\mathbb { \\lVert 3 2 \\rVert }$ . Assume that $K$ images are selected as the inputs for a certain learning iteration. We define the selected batch data as $\\mathcal { D } ^ { \\prime } = \\{ ( \\mathbf { x } _ { n } , y _ { n } ) \\}$ . Likewise, the batched ‘recovered data’ is denoted by $\\hat { \\mathcal { D } } ^ { \\prime } = \\{ ( \\hat { \\bf x } _ { n } , \\hat { y } _ { n } ) \\}$ . Then the objective function is ",
+        "bbox": [
+            173,
+            619,
+            826,
+            679
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/274ab9202d1d9ad80c07187eeadd3acc5b5916ac1901b3b85a4f7e3f3dfb12b1.jpg",
+        "text": "$$\n\\hat { \\boldsymbol D } ^ { \\prime } = \\arg \\operatorname* { m i n } _ { \\hat { \\boldsymbol D } ^ { \\prime } } \\left\\| \\frac { 1 } { K } \\sum _ { ( \\mathbf x _ { n } , y _ { n } ) \\in \\mathcal { D } } \\nabla _ { \\Theta } \\mathcal { L } ( \\boldsymbol \\Theta , \\mathbf x _ { n } , y _ { n } ) - \\frac { 1 } { K } \\sum _ { ( \\hat { \\mathbf x } _ { n } , \\hat { y } _ { n } ) \\in \\hat { \\mathcal { D } } ^ { \\prime } } \\nabla _ { \\Theta } \\mathcal { L } ( \\boldsymbol \\Theta , \\hat { \\mathbf x } _ { n } , \\hat { y } _ { n } ) \\right\\| ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            238,
+            688,
+            759,
+            731
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that in $( 3 )$ , the dimensions of the aggregated gradients is fixed. However, as $K$ increases, the cardinality of $\\hat { \\mathcal { D } } ^ { \\prime }$ and $\\mathcal { D } ^ { \\prime }$ rise. When $K$ is sufficiently large, it will be more challenging to find the “right” solution $\\hat { \\mathcal { D } } ^ { \\prime }$ of $( 3 )$ corresponding to the ground-truth dataset $\\mathcal { D } ^ { \\prime }$ . On the other hand, CAFE addresses this issue of large-batch data recovery by data index alignment (defined in next subsection), which can effectively exclude undesired solutions. We discuss a specific example in Appendix B. ",
+        "bbox": [
+            173,
+            739,
+            826,
+            814
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 CAFE implementation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            829,
+            370,
+            844
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The main idea of our algorithm is that we divide the entire data leakage attack procedure into several steps. Specifically, we fully recover the inputs to the first FC layers of the model that we term the internal representation with theoretical guarantee and use the internal representation as a learnt regularizer to help improve the performance of data leakage attack. During the process, to overcome the difficulty mentioned in Section $\\underline { { \\boldsymbol { \\mathrm { 3 . 2 } } } }$ we fully use the batch data index known by the attacker in the VFL setting so that the system equation in $\\textcircled { 3 }$ can be determined instead of undetermined. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/2567c1a1c3dba78f8a84d0ec8bb570f5a31141f1c1b572c8196955596eb0f2cd.jpg",
+        "image_caption": [
+            "Figure 3: Overview of CAFE. The left part (blue box) performs the regular VFL protocol and the right part (red box) illustrates the main steps of CAFE. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            102,
+            692,
+            285
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/a90dbb5332cdc41c29c75e188ec7368a8883cf82625affa935c6ba7a0b453297.jpg",
+        "image_caption": [
+            "Figure 4: Model structure in VFL. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            715,
+            89,
+            812,
+            286
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            339,
+            821,
+            368
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Prerequisite: Notably, CAFE can be readily applied to existing VFL protocols where the batch data indices is assigned or other deep learning protocols as long as the batch data indices are given. In Figure 3, the blue box represents the VFL paradigm and the red box denotes the attack paradigm. ",
+        "bbox": [
+            174,
+            373,
+            825,
+            416
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In a typical VFL process, the server sends public key to local workers and decides the data indices in each iteration of training and evaluation $\\bar { \\big \\vert } \\bar { \\big \\vert } , \\bar { \\big \\vert } \\bar { \\big \\vert }$ . During the training process, local workers exchange their intermediate results with others to compute gradients and upload them. Therefore, the server has access to both of the model parameters and their gradients. Since data are vertically partitioned among different workers, for each batch, the server (acting as the attacker) needs to send a data index or data id list to all the local workers to ensure that data with the same id sequence have been selected by each worker $\\left[ \\left[ 2 8 \\right] \\right]$ and we name this step as data index alignment. Data index alignment turns out to be an inevitable step in the vertical training process, which provides the server (the attacker) an opportunity to control the selected batch data indices. ",
+        "bbox": [
+            173,
+            421,
+            825,
+            547
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the rest of this subsection, we explain our algorithm CAFE in detail, which consists of three steps. ",
+        "bbox": [
+            173,
+            553,
+            825,
+            568
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Step I: Recover the gradients of loss w.r.t the outputs of the first FC layer. As shown in Figure $^ { 4 , }$ for a certain data point ${ \\bf { X } } _ { n }$ , we denote the inputs to the first FC layer as $\\mathbf { h } _ { n } = h ( \\mathbf { \\Theta } _ { \\mathbf { } } \\mathbf { e } , \\mathbf { x } _ { n } ) \\in \\mathbf { \\bar { \\mathbb { R } } } ^ { d _ { 1 } }$ where $h$ is the forward function and $\\Theta _ { c }$ is the parameters before the first FC layer. Let ${ \\bf u } _ { n }$ denote the outputs of the first FC layer in the neural network, given by ",
+        "bbox": [
+            171,
+            574,
+            825,
+            631
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a8542f375f00adbdc4a5cce7618649e09eaef7dc6dd0dfa494fd89185c146f60.jpg",
+        "text": "$$\n{  { \\mathbf { u } } } _ { n } = \\Theta _ { 1 } ^ { \\top } {  { \\mathbf { h } } } _ { n } + {  { \\mathbf { b } } } _ { 1 } \\in \\mathbb { R } ^ { d _ { 2 } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            410,
+            633,
+            586,
+            654
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For the training data $\\mathcal { D }$ , the corresponding inputs before the first FC layer are concatenated as $\\mathbf { H } =$ $[ \\mathbf { h } _ { 1 } , \\mathbf { h } _ { 2 } , \\ldots , \\mathbf { h } _ { N } ^ { - } ] ^ { \\top } \\in \\mathbb { R } ^ { N \\times d _ { 1 } }$ and the corresponding outputs of the first FC layer are concatenated as ${ \\mathbf { U } } = [ { \\mathbf { u } } _ { 1 } , { \\mathbf { u } } _ { 2 } , \\ldots , { \\mathbf { u } } _ { N } ] ^ { \\top } \\in \\mathbb { R } ^ { N \\times d _ { 2 } }$ . The gradients of loss w.r.t $\\mathbf { U }$ can be denoted by ",
+        "bbox": [
+            174,
+            656,
+            825,
+            702
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1d7faf84da2962028f8660e7e70a9ff563d92a4b113902ad148618e39e3755f8.jpg",
+        "text": "$$\n\\begin{array} { r l r } & { } & { \\nabla _ { \\mathbf { U } } \\mathcal { L } ( \\boldsymbol { \\Theta } , \\mathcal { D } ) = \\displaystyle \\frac { 1 } { N } [ \\nabla _ { \\mathbf { u } _ { 1 } } \\mathcal { L } ( \\boldsymbol { \\Theta } , \\mathbf { x } _ { 1 } , y _ { 1 } ) , \\nabla _ { \\mathbf { u } _ { 2 } } \\mathcal { L } ( \\boldsymbol { \\Theta } , \\mathbf { x } _ { 2 } , y _ { 2 } ) , \\dots , \\nabla _ { \\mathbf { u } _ { N } } \\mathcal { L } ( \\boldsymbol { \\Theta } , \\mathbf { x } _ { N } , y _ { N } ) ] ^ { \\top } } \\\\ & { } & { \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad } \\\\ & { } & { \\displaystyle \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\frac { \\partial \\mathcal { L } ( \\boldsymbol { \\Theta } , \\mathbf { x } _ { 1 } , y _ { 1 } ) } { \\partial \\mathbf { u } _ { 1 } } , \\frac { \\partial \\mathcal { L } ( \\boldsymbol { \\Theta } , \\mathbf { x } _ { 2 } , y _ { 2 } ) } { \\partial \\mathbf { u } _ { 2 } } , \\dots , \\frac { \\partial \\mathcal { L } ( \\boldsymbol { \\Theta } , \\mathbf { x } _ { N } , y _ { N } ) } { \\partial \\mathbf { u } _ { N } } \\Big ] ^ { \\top } \\in \\mathbb { R } ^ { N \\times d _ { 2 } } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            214,
+            705,
+            784,
+            770
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For a batch of data in the $t$ -th iteration $\\mathcal { D } ( \\mathbf { s } ^ { t } )$ , we have ",
+        "bbox": [
+            173,
+            772,
+            531,
+            787
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cad1415c6af0bdd8c83805471554951988e5934083290415e8c6a587bf24b47e.jpg",
+        "text": "$$\n\\begin{array} { l }  { \\displaystyle \\nabla _ { { \\bf b } _ { 1 } } { \\mathcal L } ( { \\bf \\Theta } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } ^ { t } ) \\left. = \\frac { 1 } { K } \\sum _ { n = 1 } ^ { N } { \\bf s } ^ { t } [ n ] \\frac { \\partial { \\mathcal L } ( { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } , { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } _ { n } , y _ { n }  } { \\partial { \\bf b } _ { 1 } } = \\sum _ { n = 1 } ^ { N } { \\bf s } ^ { t } [ n ] \\frac { 1 } { K } \\sum _ { z = 1 } ^ { N } { \\bf s } ^ { t } [ z ] \\frac { \\partial { \\mathcal L } ( { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } } \\\\  {\\right) \\displaystyle \\quad \\quad \\quad } { \\quad \\quad } { \\quad \\quad } { \\quad \\quad } { \\quad \\quad } = \\sum _ { n = 1 } ^ { N } { \\bf s } ^ { t } [ n ] \\nabla _ { { \\bf u } _ { n } } { \\mathcal L } ( { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf } { \\bf }  \\bf  \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            212,
+            791,
+            782,
+            880
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Although we do not have access to $\\nabla _ { \\mathbf { U } } \\mathcal { L } ( \\mathbf { \\Theta } \\Theta , \\mathcal { D } )$ as gradients are only given w.r.t. the model parameters, we can successfully recover it through an iterative optimization process. ",
+        "bbox": [
+            173,
+            882,
+            825,
+            912
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/860890e6c5639022d40d603546c2293795ba481be851837b64d1814e5a96fe45.jpg",
+        "table_caption": [
+            "Algorithm 2 Recover the inputs to the first FC layer $\\mathbf { H }$ ( regular VFL and attacker ) "
+        ],
+        "table_footnote": [
+            "13: end for "
+        ],
+        "table_body": "<table><tr><td rowspan=1 colspan=2>Algorithm 1 Recover the gradients VuL(0,D)(regular VFLandattacker</td></tr><tr><td rowspan=1 colspan=1>6:</td><td></td></tr><tr><td rowspan=1 colspan=1>7:</td><td></td></tr><tr><td rowspan=1 colspan=1></td><td></td></tr><tr><td rowspan=1 colspan=1>8:</td><td></td></tr><tr><td rowspan=1 colspan=1>9:10:</td><td></td></tr><tr><td rowspan=1 colspan=1>11:</td><td rowspan=2 colspan=1>Server computes F1(V; st) in (Z)Server updates V with VvF1(V; st)</td></tr><tr><td rowspan=1 colspan=1>12:</td></tr></table>",
+        "bbox": [
+            173,
+            88,
+            511,
+            313
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/f1e54b296994b12b3c5b7938a61dc15be3127b739fe36a3ac0c55abbfd047360.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "13: end for "
+        ],
+        "table_body": "<table><tr><td colspan=\"2\">1: Given @,trained V, initialize H ~UN ×d2 2: for t = 1,2,...,T do</td></tr><tr><td>3: 4: 5: 6: 7:</td><td>Server select st from S. Server broadcasts ? and st to all workers for m = 1,2,..., M do Worker m takes real batch data Worker m exchanges intermediate results with other workers and computes V@L(@, D(st))</td></tr><tr><td>9: 10: 11:</td><td>end for Server computes V@1 L(Θ,D(st)) Server computes F2(H; st) in )</td></tr><tr><td>12:</td><td>Server updates H with VHF2(H; st)</td></tr></table>",
+        "bbox": [
+            516,
+            121,
+            849,
+            314
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 3 CAFE (Nested-loops) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            337,
+            408,
+            351
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/0c019f7d4039295391caf73dfa701c7dfc2c92aaf7754a8bff68578556a02ad4.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "9: end for "
+        ],
+        "table_body": "<table><tr><td colspan=\"2\">1: Given model parameters @,initialize V~ uNxd1，H~uNxdD={,n1 2:Run Algorithmsand2each for T iterations 3: for t =1,2,...,T do</td></tr><tr><td>4: 5:</td><td>Run Step 3-10 in Algorithml1lonce Server computes V@L(Θ,D(st))</td></tr><tr><td>6:</td><td>Server computes the fake global aggregated gra- dients VL(Θ,D(t))</td></tr><tr><td>7:</td><td>Server computes CAFE loss F3(D; st) in )</td></tr><tr><td>8:</td><td>Server updates D with VbF3(D; st)</td></tr></table>",
+        "bbox": [
+            178,
+            354,
+            503,
+            502
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 4 CAFE (Single-loop) ",
+        "text_level": 1,
+        "bbox": [
+            524,
+            337,
+            746,
+            352
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/9563b011aa609272b8d7284cc065654585cf77fad3b8775b391c1f5e5d6e7ad4.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "9: end for "
+        ],
+        "table_body": "<table><tr><td colspan=\"2\">1:Given model parameters @,initialize V~ uNxd1H~uNxdD={nn1 2: for t =1,2,...,T do</td></tr><tr><td>3: 4:</td><td>Run Step 3-10 in Algorithm 1 once Server computes V@L(@,D(st)) including Vb1L(②,D(st)), Vθ1L(Θ,D(st))</td></tr><tr><td>5: 6: 7: 8:</td><td>Run Step 11 - 12 in Algorithm 1 lonce Run Step 11 - 12 in Algorithm ② Jonce Server computes CAFE loss F3(D; st) in ) Server updates D with VbF3(D; st)</td></tr></table>",
+        "bbox": [
+            527,
+            356,
+            852,
+            501
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Specifically, we randomly initialize an estimate of $\\nabla _ { \\mathbf { U } } \\mathcal { L } ( \\mathbf { \\Theta } \\Theta , \\mathcal { D } )$ denoted as $\\mathbf { V }$ , e.g., ${ \\textbf { V } } =$ $\\left[ \\mathbf { v } _ { 1 } , \\mathbf { v } _ { 2 } , \\ldots , \\mathbf { v } _ { n } , \\ldots , \\mathbf { v } _ { N } \\right] ^ { \\top } \\ \\in \\ \\mathbb { R } ^ { N \\times d _ { 2 } }$ , where $\\begin{array} { r c l } { \\mathbf { v } _ { n } } & { = } & { [ v _ { n , 1 } , v _ { n , 1 } , \\hdots , v _ { n , d _ { 2 } } ] ^ { \\top } \\mathrm { ~  ~ \\in ~ \\mathbb ~ R ^ { } { d } _ { 2 } ~ } } \\end{array}$ . Given $\\nabla _ {  { \\mathbf { b } } _ { 1 } } \\mathcal { L } ( \\Theta , \\mathcal { D } (  { \\mathbf { s } } ^ { t } ) )$ , we recover $\\nabla _ { \\mathbf { U } } \\mathcal { L } ( \\mathbf { \\Theta } \\Theta , \\mathcal { D } )$ by minimizing the following objective function ",
+        "bbox": [
+            176,
+            542,
+            826,
+            588
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7b79ee7dc38126a97e884ad36b272a313d2abd26beeb1be11c5c86fa0abedab3.jpg",
+        "text": "$$\n\\mathbf { V } ^ { * } = \\arg \\operatorname* { m i n } _ { \\mathbf { V } } \\underbrace { \\mathbb { E } _ { { \\mathbf { s } } _ { i } \\sim \\mathrm { U n i f } ( { \\boldsymbol { S } } ) } \\left[ \\mathcal { F } _ { 1 } ( { \\mathbf { V } } ; { \\mathbf { s } } _ { i } ) \\right] } _ { : = \\mathcal { F } _ { 1 } ( \\mathbf { V } ) } \\mathrm { w i t h } \\mathcal { F } _ { 1 } ( { \\mathbf { V } } ; { \\mathbf { s } } _ { i } ) : = \\left\\| { \\mathbf { V } } ^ { \\top } { \\mathbf { s } } _ { i } - \\nabla _ { { \\mathbf { b } } _ { 1 } } \\mathcal { L } ( \\Theta , \\mathcal { D } ( { \\mathbf { s } } _ { i } ) ) \\right\\| _ { 2 } ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            192,
+            593,
+            784,
+            637
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In each iteration $t$ , the objective function of Step I is given by $\\mathcal { F } _ { 1 } ( { \\mathbf { V } } ; { \\mathbf { s } } ^ { t } )$ . ",
+        "bbox": [
+            173,
+            642,
+            655,
+            659
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The first step of CAFE is summarized in Algorithm 1, which enjoys the following guarantee. ",
+        "bbox": [
+            176,
+            662,
+            784,
+            679
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1. If $K < N$ , the objective function $\\mathcal { F } _ { 1 } ( \\mathbf { V } )$ in $( 7 )$ is strongly convex in $\\mathbf { V }$ . For a fixed $\\Theta$ , applying SGD to $\\textcircled { 7 }$ guarantees the convergence to the ground truth almost surely. ",
+        "bbox": [
+            173,
+            683,
+            825,
+            713
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "When the batch size $K$ is smaller than the number of total data samples $N$ , the Hessian matrix of $\\mathcal { F } _ { 1 } ( \\mathbf { V } )$ is shown to be strongly convex in Appendix $\\boxed { \\mathsf { C } }$ and the convergence is guaranteed according to [23]. Step I is essential in CAFE because we separate the gradients of loss w.r.t each single input to the first FC layer from the aggregated gradients in this step. ",
+        "bbox": [
+            173,
+            718,
+            826,
+            775
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Step II: Recover inputs to the first FC layer. Using the chain rule, we have $\\nabla _ { \\Theta _ { 1 } } \\mathcal { L } ( \\Theta , \\mathcal { D } ) =$ $\\begin{array} { r l r } { { \\bf H } ^ { \\top } \\nabla _ { \\bf U } \\mathcal { L } ( \\boldsymbol { \\Theta } , \\mathcal { D } ) } & { { } \\in } & { \\mathbb { R } ^ { d _ { 1 } \\times d _ { 2 } } } \\end{array}$ . We randomly initialize an estimate of $\\mathbf { H }$ as $\\begin{array} { r l } { \\hat { \\bf { H } } } & { { } = } \\end{array}$ $[ \\hat { \\bf h } _ { 1 } , \\hat { \\bf h } _ { 2 } , \\dots , \\hat { \\bf h } _ { n } , \\dots , \\hat { \\bf h } _ { N } ] ^ { \\top } \\in \\mathbb { R } ^ { N \\times d _ { 1 } }$ , where $\\hat { \\bf h } _ { n } ^ { \\mathrm { ~ \\tiny ~  ~  ~ }  } = [ \\hat { h } _ { n , 1 } , \\hat { h } _ { n , 1 } , \\ldots , \\hat { h } _ { n , d _ { 1 } } ] ^ { \\top } \\in \\mathbb { R } ^ { d _ { 1 } }$ . Given $\\mathsf { \\bar { V } } _ { \\Theta _ { 1 } } \\mathcal { L } ( \\Theta , \\mathcal { D } ( \\mathbf { s } ^ { t } ) )$ and $\\mathbf { V } ^ { * }$ , we recover $\\mathbf { H }$ by minimizing the following objective ",
+        "bbox": [
+            173,
+            780,
+            826,
+            843
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/25447ab163e00b416a54d7fd8ce468a5cb28029a434b3d4caf64973a98528db7.jpg",
+        "text": "$$\n\\hat { \\mathbf { H } } ^ { * } = \\arg \\operatorname* { m i n } _ { \\hat { \\mathbf { H } } } \\underbrace { \\mathbb { E } _ { s _ { i } \\sim \\operatorname { U n i f } ( S ) } \\mathcal { F } _ { 2 } ( \\hat { \\mathbf { H } } ; \\mathbf { s } _ { i } ) } _ { : = \\mathcal { F } _ { 2 } ( \\hat { \\mathbf { H } } ) } \\mathrm { w i t h } \\mathcal { F } _ { 2 } ( \\hat { \\mathbf { H } } ; \\mathbf { s } _ { i } ) : = \\Big \\lVert \\sum _ { n = 1 } ^ { N } \\mathbf { s } _ { i } [ n ] \\hat { \\mathbf { h } } _ { n } ( \\mathbf { v } _ { n } ^ { * } ) ^ { \\top } - \\nabla \\mathbf { \\Theta } _ { \\Theta _ { 1 } } \\mathcal { L } ( \\mathbf { \\Theta } , \\mathcal { D } ( \\mathbf { s } _ { i } ) ) \\Big \\rVert _ { F } ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            847,
+            838,
+            900
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In each iteration $t$ , the objective function of Step II can be denoted by $\\mathcal { F } _ { 2 } ( \\hat { \\mathbf { H } } ; \\mathbf { s } ^ { t } )$ ",
+        "bbox": [
+            173,
+            90,
+            702,
+            106
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Through the first two steps, parts of the information about the data have already been leaked. Step II also has the following guarantee. ",
+        "bbox": [
+            173,
+            111,
+            825,
+            141
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2. If $N < d _ { 2 }$ and $\\operatorname { R a n k } ( \\mathbf { V } ^ { * } ) = N$ , the objective function $\\mathcal { F } _ { 2 } ( \\hat { \\mathbf { H } } )$ is strongly convex. When $\\Theta$ keeps unchanged, applying SGD guarantees the convergence of $\\hat { \\bf H }$ to $\\mathbf { H }$ . ",
+        "bbox": [
+            173,
+            147,
+            823,
+            180
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our experiment setting satisfies the assumption, e.g., $N = 8 0 0$ and $d _ { 2 } ~ = ~ 1 0 2 4$ , and thus the convergence is guaranteed according to $\\mathbb { \\left| \\left[ 2 3 \\right] \\right| }$ . The proof of Theorem 2 can be found in Appendix $\\bigtriangledown ,$ In some simple models such as logistic regression or neural network models only containing $F C$ layers, the attack will recover the data only by implementing the first two steps. ",
+        "bbox": [
+            173,
+            185,
+            825,
+            242
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Step III: Recover data. We randomly initialize the fake data and fake labels followed by uniform distribution $\\hat { \\mathcal { D } } = \\{ \\hat { \\mathbf { x } } _ { n } , \\hat { y } _ { n } \\} _ { n = 1 } ^ { N }$ . According to equation $( 4 )$ , we have $\\widetilde { \\mathbf { h } } _ { n } = h ( \\boldsymbol { \\Theta } _ { c } , \\hat { \\mathbf { x } } _ { n } ) \\in \\mathbb { R } ^ { \\dot { d } _ { 1 } }$ . ",
+        "bbox": [
+            173,
+            247,
+            823,
+            280
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Given $\\nabla _ { \\Theta } \\mathcal { L } ( \\Theta , \\mathcal { D } ( \\mathbf { s } _ { i } ) )$ and $\\hat { \\mathbf { H } } ^ { * }$ , our objective function in the last step is ",
+        "bbox": [
+            174,
+            286,
+            648,
+            303
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bfee655cf098190f04cde9c7b1c2b8486a5b11e9afc841dec14b6f7638cbe867.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\displaystyle } & { \\displaystyle = \\arg \\operatorname* { m i n } _ { \\hat { \\mathcal { D } } } \\mathbb { E } _ { s _ { i } \\sim \\mathrm { U n i f } ( \\mathcal { S } ) } [ \\mathcal { F } _ { 3 } ( \\hat { D } ; \\mathbf { s } _ { i } ) ] \\medskip } \\\\ & { \\displaystyle } \\\\ & { \\mathcal { F } _ { 3 } ( \\hat { D } ; \\mathbf { s } _ { i } ) : = \\alpha \\big \\| \\nabla _ { \\Theta } \\mathcal { L } ( \\Theta , \\mathcal { D } ( \\mathbf { s } _ { i } ) ) - \\nabla _ { \\Theta } \\mathcal { L } ( \\Theta , \\hat { \\mathcal { D } } ( \\mathbf { s } _ { i } ) ) \\big \\| _ { 2 } ^ { 2 } + \\beta \\underline { { \\mathrm { T V } } } _ { \\xi } ( \\hat { \\mathcal { X } } ( \\mathbf { s } _ { i } ) ) + \\gamma \\displaystyle \\sum _ { n = 1 } ^ { N } \\big \\| \\mathbf { s } _ { i } [ n ] \\big ( \\hat { \\mathbf { H } } _ { n } ^ { * } - \\tilde { \\mathbf { h } } _ { n } \\big ) \\big \\| _ { 2 } ^ { 2 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            173,
+            321,
+            856,
+            397
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha , \\beta$ and $\\gamma$ are coefficients, $\\underline { { \\mathrm { T V } } } _ { \\xi } ( \\hat { \\mathcal X } ( \\mathbf { s } _ { i } ) )$ is the truncated total variation (TV) norm which is 0 if the TV-norm of $\\hat { \\mathcal { X } } ( \\mathbf { s } _ { i } ) = \\{ \\hat { \\mathbf { x } } _ { n } | \\mathbf { s } _ { i } [ n ] = 1 \\}$ is smaller than $\\xi$ , and $\\hat { \\cal { D } } ( { \\bf s } _ { i } ) = \\{ \\{ \\hat { \\bf x } _ { n } , \\hat { y } _ { n } \\} | { \\bf s } _ { i } [ n ] = 1 \\}$ . In each iteration $t$ , the objective function of step III is $\\mathcal { F } _ { 3 } ( \\hat { \\mathcal { D } } ; \\mathbf { s } ^ { t } )$ . The first term in $\\textcircled{9}$ is the $\\ell _ { 2 }$ norm in $\\pmb { \\Vert 3 2 \\Vert }$ . The second term is the TV norm and the last term is the internal representation norm regularizer. We also define $\\nabla _ { \\hat { D } } \\mathcal { F } _ { 3 } ( \\hat { D } ; \\mathbf { s } ^ { t } ) = \\{ \\nabla _ { \\hat { \\mathbf { x } } _ { n } } \\mathcal { F } _ { 3 } ( \\hat { D } ; \\mathbf { s } ^ { t } ) , \\nabla _ { \\hat { y } _ { n } } \\mathcal { F } _ { 3 } ( \\hat { D } ; \\mathbf { s } ^ { t } ) \\} _ { n = 1 } ^ { N } .$ . ",
+        "bbox": [
+            173,
+            420,
+            826,
+            502
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To ensure attacking efficiency, we consider two flexible update protocols in CAFE — Algorithm $3 \\mathrm { { : } }$ CAFE (Nested-loops) and Algorithm $4 { : }$ CAFE (Single-loop). Empirically, Algorithm $\\bar { 4 }$ will take fewer iterations than those of Algorithm $\\textcircled { 3 }$ More details can be found in the experiment results in Section $4 . 2 .$ We also discuss the theoretical guarantee for each step and its proof in Appendix E. ",
+        "bbox": [
+            174,
+            506,
+            825,
+            563
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.4 Defense strategy: Leveraging fake gradients as a countermeasure to CAFE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            592,
+            732,
+            608
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Although CAFE comes with theoretical recovery guarantees, the underlying premise is that the clients will upload true (correct) gradients for aggregation. Therefore, we propose an intuitive and practical approach to mitigate CAFE by requiring each client to upload fake (but similar) gradients, resulting in incorrect data recovery via CAFE. Specifically, to solve the problem of leakage from true gradients, we design a defense called Fake Gradients and summarize it in Algorithm 5 of Appendix F. The main idea of this defense is that attackers will aim to match wrong gradients and invert incorrect inputs to the first FC layer so that attackers cannot recover the true training data. The defending strategy in Algorithm 5 (Appendix F) can be added between Line 8 and 9 in Algorithms 1 and 2. ",
+        "bbox": [
+            173,
+            621,
+            826,
+            734
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As summarized in Algorithm $\\boxed { 5 }$ (Appendix F), each local worker can randomly generate gradients with the normal distribution ${ \\sqrt { ( 0 , \\sigma ^ { 2 } ) } }$ and sort the elements in descending order (Line $1 , \\stackrel {  } { 2 } )$ . At the same time, local workers also sort their true gradients in descending order and record indexes of the sorted items (Line $^ { 7 ) }$ . Then, one computes the $L _ { 2 }$ -norm distance between a true gradient and all fake gradients to find the nearest fake gradient (Line $^ { 1 2 ) }$ . Afterwards, we pair fake gradients to match true gradients by the sorted order (Line $^ { 1 7 ) }$ . This an important step so that we can keep large/small values at the same positions of true gradients. Finally, local workers upload the fake gradients to the server. ",
+        "bbox": [
+            173,
+            738,
+            825,
+            835
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Impact on model training. Chen et al. [5] has proved that if the distance between the actual gradients and the gradient surrogate is smaller than a decreasing threshold, using the gradient surrogate to update the model still guarantees convergence. Building upon the results in $[ \\bar { | 5 | }$ , we set a sufficient threshold such that the distance between the fake gradients and the true gradients are smaller than the threshold. In this case, we can still achieve the learning performance as if true gradients are used. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/ff91a98115e6b9d7a66a43351f562d3986794d337b562aa88bd9e877479a41cc.jpg",
+        "table_caption": [
+            "Table 2: Comparison with the state-of-the-art ( $M = 4$ , $K = 4 0$ , batch ratio $= 0 . 0 5 \\mathrm { , }$ ) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>PSNR   DatasetMethod</td><td rowspan=1 colspan=1>CIFAR-10</td><td rowspan=1 colspan=1>MNIST</td><td rowspan=1 colspan=1>Linnaeus 5</td></tr><tr><td rowspan=1 colspan=1>CAFE</td><td rowspan=1 colspan=1>31.83</td><td rowspan=1 colspan=1>43.15</td><td rowspan=1 colspan=1>33.22</td></tr><tr><td rowspan=1 colspan=1>DLG</td><td rowspan=1 colspan=1>9.29</td><td rowspan=1 colspan=1>7.96</td><td rowspan=1 colspan=1>7.14</td></tr><tr><td rowspan=1 colspan=1>Cosine Similarity</td><td rowspan=1 colspan=1>7.38</td><td rowspan=1 colspan=1>7.84</td><td rowspan=1 colspan=1>8.31</td></tr><tr><td rowspan=1 colspan=1>SAPAG</td><td rowspan=1 colspan=1>6.07</td><td rowspan=1 colspan=1>3.86</td><td rowspan=1 colspan=1>6.74</td></tr><tr><td rowspan=1 colspan=1>BN regularizer</td><td rowspan=1 colspan=1>18.94</td><td rowspan=1 colspan=1>13.38</td><td rowspan=1 colspan=1>8.09</td></tr><tr><td rowspan=1 colspan=1>GC regularizer</td><td rowspan=1 colspan=1>13.63</td><td rowspan=1 colspan=1>9.24</td><td rowspan=1 colspan=1>12.32</td></tr></table>",
+        "bbox": [
+            174,
+            117,
+            500,
+            220
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/9854aaf4f099aeb4b2f379e16918bdda1151bd3f93db74dfee2c57324fa4c6a7.jpg",
+        "table_caption": [
+            "Table 3: PSNR vs batch size $K$ (800 data samples in total) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>PSNR     DatasetK</td><td rowspan=1 colspan=1>CIFAR-10</td><td rowspan=1 colspan=1>MNIST</td><td rowspan=1 colspan=1>Linnaeus 5</td></tr><tr><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>30.83</td><td rowspan=1 colspan=1>32.60</td><td rowspan=1 colspan=1>28.00</td></tr><tr><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>35.70</td><td rowspan=1 colspan=1>39.00</td><td rowspan=1 colspan=1>30.53</td></tr><tr><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>31.83</td><td rowspan=1 colspan=1>43.15</td><td rowspan=1 colspan=1>33.22</td></tr><tr><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>36.87</td><td rowspan=1 colspan=1>47.05</td><td rowspan=1 colspan=1>30.43</td></tr><tr><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>38.94</td><td rowspan=1 colspan=1>47.50</td><td rowspan=1 colspan=1>29.18</td></tr></table>",
+        "bbox": [
+            501,
+            117,
+            826,
+            200
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/0e7004dce0f73e82eb5c47099291c9e1d863aafe693bc73748eeff8b470b12c5.jpg",
+        "image_caption": [
+            "Figure 5: Visual comparison on the effect of auxiliary regularizers. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            231,
+            419,
+            319
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/631b3174ebcd9842ff09a53e80bbfef965598b958109d216f846ac3ebce4a685.jpg",
+        "image_caption": [
+            "Figure 6: Visual comparison of the real and recovered data using ordinary and fake gradients. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            434,
+            233,
+            823,
+            311
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            367,
+            312,
+            385
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We conduct experiments on MNIST $ { \\mathbb { I } }  { \\mathrm { 1 8 } }  { \\mathrm { ] } }$ , CIFAR-10 [17] and Linnaeus 5 [4] datasets in VFL settings. The hyper-parameter settings are shown in Appendix $\\mathbf { G . l . }$ Our algorithm recovers all the data participating in VFL with a relative large batch size (more than 40). Scaling up to our hardware limits (RTX 2080 and TITAN V), CAFE can leak as many as 800 images in the VFL setting including 4 workers with a batch size as large as 100. The neural network model architecture used in the simulation is shown in Figure 4. To measure the data leakage performance, we use the peak signalto-noise ratio (PSNR) value and the mean squared error (MSE). Higher PSNR value of leaked data represents better performance of data recovery. ",
+        "bbox": [
+            173,
+            398,
+            826,
+            511
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.1 Comparison with the state-of-the-art ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            527,
+            467,
+            542
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We compare CAFE with five state-of-the-art methods using the batch size of 40 images in each iteration. For fair comparisons, all methods were run on the the same model and iterations. ",
+        "bbox": [
+            176,
+            549,
+            823,
+            578
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "i) DLG $\\pmb { \\mathbb { B 2 } }$ : The deep gradients leakage method is equivalent to replacing the objective function in $\\textcircled { 9 }$ with the squared $\\ell _ { 2 }$ norm distance.   \nii) Cosine Similarity [11]: The objective function is equivalent to replacing the objective function in $\\textcircled { 9 }$ with the linear combination of cosine similarity and TV norm of the recovered images. iii) SAPAG [25]: The objective function is equivalent to replacing the objective function in $( 9 )$ with the Gaussian kernel based function.   \niv) Batch normalization (BN) regularizer $[ \\pmb { \\big | 2 9 } ]$ : The objective function is equivalent to replacing the TV norm and internal representation norm in $\\textcircled{9}$ with the batch normalization regularizer $\\mathbb { \\left[ \\left[ 2 9 \\right] \\right. }$ v) Group consistency (GC) regularizer $[ \\pmb { \\big | 2 9 } ]$ : The objective function is equivalent to replacing the TV norm and internal representation norm in $( 9 )$ with the group consistency regularizer $\\dot { \\mathbb { R } } \\mathfrak { Q } \\mathfrak { h }$ . ",
+        "bbox": [
+            173,
+            583,
+            826,
+            733
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In GradInversion $\\mathbb { \\left. 2 9 \\right. }$ , several additional assumptions have been made. For example, the assumption of non-repeating labels in the batch is hard to be satisfied in datasets such as CIFAR-10, MNIST and Linnaeus 5. In those datasets, we use batch size of more than 40, which is larger than the number of classes (10 or 5). Nevertheless, we still compared our CAFE to the methods by using the batch normalization regularizer and group consistency regularizer mentioned in $\\mathbb { \\left[ \\left[ 2 9 \\right] \\right. }$ in CAFE. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            808
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Theory-driven label inference methods have been proposed in $\\pmb { \\| } \\pmb { \\bigtriangledown } $ and $\\left[ \\left[ 2 6 \\right] \\right]$ . However, our attack mainly deals with training data leakage rather than labels. In $\\lVert 2 2 \\rVert$ , the authors proposed a sufficient requirement that \"each data sample has at least two exclusively activated neurons at the last but one layer\". However, in our training protocol, the batch size is too large and it is almost impossible to ensure that each selected sample has at least two exclusively activated neurons. In $\\pmb { \\mathbb { B } } \\mathbf { \\mathbb { I } }$ , it is assumed that the method will only return a linear combination of the selected training data, which is a very restricted assumption. As the results, we did not compare to those methods in Table 2. ",
+        "bbox": [
+            173,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/1686530351f9be861acb04b9a6bb3e7ef754d30a9cf7bbe9c2a01528ed9e5d1a.jpg",
+        "table_caption": [
+            "Table 4: Effect of auxiliary regularizers $M = 4$ , $K = 4 0$ , batch ratio $= 0 . 0 5$ ) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>PSNR  DatasetsAlgorithm</td><td rowspan=1 colspan=1>CIFAR-10</td><td rowspan=1 colspan=1>Linnaeus 5</td><td rowspan=1 colspan=1>MNIST</td></tr><tr><td rowspan=1 colspan=1>CAFE</td><td rowspan=1 colspan=1>31.83</td><td rowspan=1 colspan=1>33.22</td><td rowspan=1 colspan=1>43.15</td></tr><tr><td rowspan=1 colspan=1>CAFE (α = 0)</td><td rowspan=1 colspan=1>33.93</td><td rowspan=1 colspan=1>28.62</td><td rowspan=1 colspan=1>31.93</td></tr><tr><td rowspan=1 colspan=1>CAFE (g = 0)</td><td rowspan=1 colspan=1>25.57</td><td rowspan=1 colspan=1>25.29</td><td rowspan=1 colspan=1>34.51</td></tr><tr><td rowspan=1 colspan=1>CAFE (β = 0)</td><td rowspan=1 colspan=1>18.25</td><td rowspan=1 colspan=1>23.22</td><td rowspan=1 colspan=1>31.98</td></tr><tr><td rowspan=1 colspan=1>CAFE (γ = 0)</td><td rowspan=1 colspan=1>12.51</td><td rowspan=1 colspan=1>12.37</td><td rowspan=1 colspan=1>6.34</td></tr></table>",
+        "bbox": [
+            173,
+            111,
+            511,
+            252
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/916b88b45a4b1ab31b2b1cda235b320b1549dc8c36f5f4cdca06195642c00dda.jpg",
+        "table_caption": [
+            "Table 5: Nested-loops vs single-loop CAFE $M = 4$ , $K = 4 0$ , batch ratio $= 0 . 0 5$ ) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Iterations  modeDatasets</td><td rowspan=1 colspan=1>CIFAR-10</td><td rowspan=1 colspan=1>MNIST</td><td rowspan=1 colspan=1>Linnaues 5</td></tr><tr><td rowspan=1 colspan=1>Single loop</td><td rowspan=1 colspan=1>7300(8000)</td><td rowspan=1 colspan=1>6600(8000)</td><td rowspan=1 colspan=1>12400(20000)</td></tr><tr><td rowspan=1 colspan=1>Nested-loopsStepI</td><td rowspan=1 colspan=1>8000(8000)</td><td rowspan=1 colspan=1>8000(8000)</td><td rowspan=1 colspan=1>12428(20000)</td></tr><tr><td rowspan=1 colspan=1>Nested-loopsStep II</td><td rowspan=1 colspan=1>2404(8000)</td><td rowspan=1 colspan=1>8000(8000)</td><td rowspan=1 colspan=1>20000(20000)</td></tr><tr><td rowspan=1 colspan=1>Nested-loopsStep II</td><td rowspan=1 colspan=1>1635(8000)</td><td rowspan=1 colspan=1>2468(8000)</td><td rowspan=1 colspan=1>20000(20000)</td></tr></table>",
+        "bbox": [
+            516,
+            111,
+            826,
+            263
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/920264304b0cbe77749cb57ed0c824662c159015c0c967e173a5ca32bf958732.jpg",
+        "table_caption": [
+            "Table 6: Effects of number of workers $M$ ( $K = 4 0$ , batch ratio $= 0 . 0 5$ ) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>PSNR    DatasetsM</td><td rowspan=1 colspan=1>CIFAR-10</td><td rowspan=1 colspan=1>Linnaeus 5</td><td rowspan=1 colspan=1>MNIST</td></tr><tr><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>31.83</td><td rowspan=1 colspan=1>33.22</td><td rowspan=1 colspan=1>43.15</td></tr><tr><td rowspan=1 colspan=1>16</td><td rowspan=1 colspan=1>28.39</td><td rowspan=1 colspan=1>39.85</td><td rowspan=1 colspan=1>39.28</td></tr></table>",
+        "bbox": [
+            581,
+            324,
+            823,
+            376
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/c9a7b613b5c42b8ef154263afdb51b1b7d2b39819d2ae8e13939cab5c0d3a1a9.jpg",
+        "image_caption": [
+            "Figure 7: Training loss of true gradients and fake gradients on CIFAR-10, Linnaeus 5 and MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            263,
+            575,
+            356
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "CAFE outperforms these methods both qualitatively (Figure $^ { 1 ) }$ and quantitatively (Table $^ { 2 ) }$ . Its PSNR values are always above 30 at the end of each CAFE attacking process, suggesting high data recovery quality. However, the PSNR of other methods are below 10 on all the three datasets. ",
+        "bbox": [
+            174,
+            396,
+            825,
+            439
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.2 Ablation study ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            455,
+            315,
+            470
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We test CAFE under different batch size, network structure and with/without auxiliary regularizers. ",
+        "bbox": [
+            171,
+            478,
+            820,
+            492
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "(i) PSNR via Batch size $K$ . Table 3 shows that the PSNR values always keep above 30 on CIFAR-10, above 32 on MNIST and above 28 on Linnaeus 5 when the batch size $K$ increases with fixed number of workers and number of total data points. The result implies that the increasing $K$ has almost no influence on data leakage performance of CAFE and it fails to be an effective defense. ",
+        "bbox": [
+            173,
+            497,
+            825,
+            554
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "(ii) PSNR via Epoch. Theoretically, given infinite number of iterations, we prove that we can recover $\\nabla _ { \\mathbf { U } } \\mathcal { L }$ and $\\mathbf { H }$ because the respective objective function in $( 7 )$ and $\\textcircled{8}$ in our paper is strongly convex as long as $N < d _ { 2 }$ and $\\mathbf { R a n k } ( \\mathbf { V } ^ { * } ) = \\bar { N }$ in Sections $\\underset { . } { \\mathrm {  ~ { \\cal { C } } ~ } }$ and D of supplementary material. The corresponding experimental results and analysis are shown in Appendix G.2. ",
+        "bbox": [
+            174,
+            560,
+            825,
+            617
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "(iii) Effect of regularizers. Table 4 demonstrates the impact of regularizers. From Figure 5, adjusting the threshold $\\xi$ prevents images from being over blurred during the reconstruction process. TV norm can eliminate the noisy patterns on the recovered images and increase the PSNR. We also find that the last term in $\\textcircled{9}$ , the internal representation norm regularizer, contributes most to the data recovery. In Table 4, CAFE still performs well without the first term $( \\alpha = 0$ ) in $( 9 )$ . The reason is that the internal representation regularizer already allows data to be fully recovered. Notably, CAFE also performs well on MNIST even without the second term $\\beta = 0$ ) in $( 9 )$ . It is mainly due to that MNIST is a simple dataset that CAFE can successfully recover even without the TV-norm regularizer. ",
+        "bbox": [
+            173,
+            622,
+            825,
+            733
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "(iv) Nested-loops vs single-loop. We compare both modes of CAFE (Algorithms $\\boxed { 3 } \\mathrm { a n d } \\boxed { 4 }$ on all datasets. In Table $5 ,$ the number of iterations is the maximum iterations at each step. For the CAFE (single-loop), if the objective function in step I $\\textcircled { 7 }$ decreases below $1 0 ^ { - 9 }$ , we switch to step II. If the objective function in step II $( 8 )$ decreases below $5 \\times 1 0 ^ { - 9 }$ , we switch to step III. When the PSNR value reaches 27 on CIFAR-10, 30 on Linnaeus 5, 38 on MNIST, we stop both algorithms and record the iteration numbers. As shown in Table $5 ,$ CAFE single-loop requires fewer number of iterations. Meanwhile, it is difficult to set the loop stopping conditions in the CAFE Nested-loops mode. In particular, $\\mathbf { V } ^ { * }$ and $\\hat { \\mathbf { H } } ^ { * }$ with low recovery precision may impact the data recovery performance. ",
+        "bbox": [
+            173,
+            739,
+            825,
+            853
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "(v) Effects of number of workers $M$ . Although data are partitioned on feature space across workers, the dimension of the entire data feature space is fixed and independent of $M$ . Therefore, increasing number of workers theoretically does not change the dimension of variables associated with data recovery in $\\textcircled { 3 }$ . In practice, different from HFL, where there could be hundreds of workers, in VFL, the workers are typically financial organizations or companies. Therefore, the number of workers is usually small $\\mathbb { \\lVert 1 3 \\rVert }$ . In Table $6 ,$ we compare the results of 4 workers with 16 workers following the same experiment setup. The CAFE performances are comparable. ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/103587b974b38629ba681716da2d9c6a2af88449a622734c07e765b251f5fb1b.jpg",
+        "table_caption": [
+            "Table 7: Attacking while training in VFL "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>PSNR(Ir)   SettingDataset</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>3</td></tr><tr><td rowspan=1 colspan=1>CIFAR10</td><td rowspan=1 colspan=1>31.24(10-4)</td><td rowspan=1 colspan=1>27.62(5×10-4)</td><td rowspan=1 colspan=1>25.22(10-3)</td></tr><tr><td rowspan=1 colspan=1>MNIST</td><td rowspan=1 colspan=1>31.82(10-4)</td><td rowspan=1 colspan=1>28.42(5×10-4)</td><td rowspan=1 colspan=1>23.60(10-3)</td></tr><tr><td rowspan=1 colspan=1>Linaeus 5</td><td rowspan=1 colspan=1>30.74(10-6)</td><td rowspan=1 colspan=1>21.45(5×10-5)</td><td rowspan=1 colspan=1>20.68(10-4)</td></tr></table>",
+        "bbox": [
+            174,
+            111,
+            480,
+            231
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/7209223b4be78e9aaa201905356f1e2027c7c80b7bb389463b0c2eccafe82599.jpg",
+        "table_caption": [
+            "Table 8: Training while attacking on MNIST "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>#of iterations</td><td rowspan=1 colspan=1>PSNR value</td><td rowspan=1 colspan=1>Training loss</td><td rowspan=1 colspan=1>Testing accuracy</td></tr><tr><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>5.07</td><td rowspan=1 colspan=1>2.36</td><td rowspan=1 colspan=1>0.11</td></tr><tr><td rowspan=1 colspan=1>2000</td><td rowspan=1 colspan=1>11.68</td><td rowspan=1 colspan=1>2.31</td><td rowspan=1 colspan=1>0.27</td></tr><tr><td rowspan=1 colspan=1>6000</td><td rowspan=1 colspan=1>18.07</td><td rowspan=1 colspan=1>1.99</td><td rowspan=1 colspan=1>0.54</td></tr><tr><td rowspan=1 colspan=1>10000</td><td rowspan=1 colspan=1>18.12</td><td rowspan=1 colspan=1>1.82</td><td rowspan=1 colspan=1>0.64</td></tr><tr><td rowspan=1 colspan=1>15000</td><td rowspan=1 colspan=1>16.86</td><td rowspan=1 colspan=1>1.63</td><td rowspan=1 colspan=1>0.65</td></tr><tr><td rowspan=1 colspan=1>20000</td><td rowspan=1 colspan=1>20.72</td><td rowspan=1 colspan=1>1.68</td><td rowspan=1 colspan=1>0.68</td></tr></table>",
+        "bbox": [
+            488,
+            111,
+            820,
+            231
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            239,
+            825,
+            282
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.3 Tests for attacking while training scenarios ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            297,
+            511,
+            313
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Previous works have shown that DLG performs better on an untrained model than a trained one $\\mathbb { m }$ This is also true for CAFE. Our theoretical analysis can provide the partial reason. When the model is trained or even convergent, the real gradients of loss can be very small. It is possible that the value of the recovered $\\nabla _ { \\mathbf { U } } \\mathcal { L } ( \\hat { \\textbf { \\Theta } } , \\mathcal { D } )$ will also be close to 0. In that case, it can be difficult to recover H. ",
+        "bbox": [
+            174,
+            319,
+            825,
+            376
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We also implement CAFE in the ‘attacking while training’ scenario, in which we continuously run the VFL process. When the model is training, both of the selected batch data and the model parameters change every iteration, which may cause the attack loss to diverge. However, from our experimental results in Table $\\bigtriangledown ,$ CAFE is able to recover training images when the learning rate (lr) is relatively small. Increasing the learning rate renders data leakage more difficult because the model is making more sizeable parameter changes in each iteration, which can be regarded as an effective defense strategy. According to our experiment in Table $\\boxed { 8 }$ the model indeed converges with a relative small learning rate (e.g., Adam with learning rate $1 0 ^ { - 6 }$ , trained on 800 images, tested on 100 images, batch size $K = 4 0$ ), which indicates that we can conduct our attack successfully while a model is converging. The data indeed leaks to a certain level (PSNR above 20) while the model converges at a certain accuracy (0.68), which indicates that CAFE works in an attacking while training scenario. ",
+        "bbox": [
+            173,
+            381,
+            825,
+            534
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.4 Mitigation of CAFE data leakage attack via fake gradients ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            546,
+            619,
+            560
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Training and defense performance. To demonstrate how fake gradients defend against CAFE (Section $\\overline { { \\textcircled { 3 . 4 } } }$ , we conduct CAFE with unchanged $\\Theta$ , which is the strongest data leakage attack setting. We use the SGD optimizer with learning rate set as 0.1, $\\sigma ^ { 2 } = 1 . 1$ , and $\\nu = 1 0 0 0$ for fake gradients. Figure $\\boxed { 6 }$ shows a comparison between the visual image quality of the data recovered by CAFE on CIFAR-10 when the ordinary gradients and fake gradients are used, respectively. The PSNR of recovered data in CAFE on ordinary and fake gradients is 28.68 and 7.67, respectively. Moreover, Figure $^ { 7 }$ shows that the training process with fakes gradients behaves in a similar way to the one with true gradients, confirming that the use of fake gradients does not lose the training efficacy. We have also added the experiment to discuss the difference of our fake gradients method to differential privacy (DP). The results and analysis are shown in Appendix G.3. ",
+        "bbox": [
+            173,
+            568,
+            826,
+            704
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.5 Recover human face data ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            715,
+            390,
+            729
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We also implement CAFE on Yale $3 2 \\times 3 2$ human face dataset $\\pmb { \\mathbb { L 2 } }$ , which achieves the PSNR above 42. The recovered data are shown in Appendix $\\mathbf { G . } 4 .$ It implies that CAFE can fully recover data that requires privacy protection such as facial images. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            779
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            797,
+            307,
+            814
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we uncover the risk of catastrophic data leakage in vertical federated learning (CAFE) through a novel algorithm that can perform large-batch data leakage with high data recovery quality and theoretical guarantees. Extensive experimental results demonstrate that CAFE can recover large-scale private data from the shared aggregated gradients on vertical FL settings, overcoming the batch limitation problem in current data leakage attacks. We also propose an effective countermeasure using fake gradients to mitigate the potential risks of CAFE. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            89,
+            328,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This work was supported by National Science Foundation CAREER Award 2047177, and the Rensselaer-IBM AI Research Collaboration (http://airc.rpi.edu), part of the IBM AI Horizons Network (http://ibm.biz/AIHorizons). C-Y Hsu and C-M Yu were supported by MOST 110- 2636-E-009-018, and we also thank National Center for High-performance Computing (NCHC) of National Applied Research Laboratories (NARLabs) in Taiwan for providing computational and storage resources. ",
+        "bbox": [
+            174,
+            121,
+            826,
+            204
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            223,
+            266,
+            239
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] M. Abadi, A. Chu, I. Goodfellow, H. B. McMahan, I. Mironov, K. Talwar, and L Zhang. \"Deep learning with differential privacy\". In Proc. the 2016 ACM SIGSAC Conference on Computer and Communications Security, pages 308–318, Vienna, Austria, Oct, 2016.   \n[2] E. Bagdasaryan, A. Veit, Y. Hua, D. Estrin, and V. Shmatikov. \"How to backdoor federated learning\". In Proc. the Twenty Third International Conference on Artificial Intelligence and Statistics, volume 108 of Proceedings of Machine Learning Research, pages 2938–2948. PMLR, 26–28 Aug 2020.   \n[3] A. N. Bhagoji, S. Chakraborty, P. Mittal, and S. Calo. \"Analyzing federated learning through an adversarial lens\". In Proc. International Conference on Machine Learning, pages 634–643, Long Beach, California, 2019.   \n[4] G. Chaladze and L. Kalatozishvili. Linnaeus 5 dataset for machine learning, 2017.   \n[5] T. Chen, G. Giannakis, T. Sun, and W. Yin. \"LAG: lazily aggregated gradient for communicationefficient distributed learning\". In Proc. Advances in Neural Information Processing Systems, volume 31, Montréal, CANADA, 2018.   \n[6] T. Chen, X. Jin, Y. Sun, and W. Yin. \"VAFL: a method of vertical asynchronous federated learning\". arXiv preprint:2007.06081, Jul, 2020.   \n[7] K. Cheng, T. Fan, Y. Jin, Y. Liu, T. Chen, and Q. Yang. \"Secureboost: A lossless federated learning framework\". In Proc. The 1st International Workshop on Federated Machine Learning for User Privacy and Data Confidentiality (FML’19) in conjunction with IJCAI, 2019.   \n[8] T. Chilimbi, Y. Suzue, J. Apacible, and K. Kalyanaraman. \"Project adam: Building an efficient and scalable deep learning training system\". In 11th USENIX Symposium on Operating Systems Design and Implementation (OSDI 14), pages 571–582, Broomfield, CO, October 2014.   \n[9] L. Fan, K. Ng, C. Ju, T. Zhang, C. Liu, C. S. Chan, and Q. Yang. \"Rethinking privacy preserving deep learning: How to evaluate and thwart privacy attacks\". In Federated Learning - Privacy and Incentive, volume 12500 of Lecture Notes in Computer Science, pages 32–50. Springer, 2020.   \n[10] M. Fredrikson, S. Jha, and T. Ristenpart. \"Model inversion attacks that exploit confidence information and basic countermeasures\". In Proc. the 22nd ACM SIGSAC Conference on Computer and Communications Security, pages 1322–1333, New York, NY, USA, 10 2015.   \n[11] J. Geiping, H. Bauermeister, H. Dröge, and M. Moeller. \"Inverting gradients - how easy is it to break privacy in federated learning?\". In Proc. Advances in Neural Information Processing Systems, 2020.   \n[12] A.S. Georghiades, P.N. Belhumeur, and D.J. Kriegman. \"From few to many: Illumination cone models for face recognition under variable lighting and pose\". IEEE Trans. Pattern Anal. Mach. Intelligence, 23(6):643–660, 2001.   \n[13] C. He, S. Li, J. So, M. Zhang, H. Wang, X. Wang, P. Vepakomma, A. Singh, H. Qiu, L. Shen, P. Zhao, Y. Kang, Y. Liu, R. Raskar, Q. Yang, M. Annavaram, and S. Avestimehr. \"Fedml: A research library and benchmark for federated machine learning\". In Proc. Advances in Neural Information Processing Systems Workshop: SpicyFL 2020, 2020.   \n[14] B. Hitaj, G. Ateniese, and F. Pérez-Cruz. Deep models under the GAN: information leakage from collaborative deep learning. In Proc. the 2017 ACM SIGSAC Conference on Computer and Communications Security, New York, NY, USA, 2017.   \n[15] F.N. Iandola, K. Ashraf, M.W. Moskewicz, and K. Keutzer. Firecaffe: near-linear acceleration of deep neural network training on compute clusters. In Proc. 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 2592–2600, Los Alamitos, CA, USA, Jun 2016.   \n[16] P. Kairouz, H. B. McMahan, B. Avent, A. Bellet, M. Bennis, A. N. Bhagoji, K. Bonawit, Z. Charles, G. Cormode, R. Cummings, R. G. L. D’Oliveira, H. Eichner, S. El Rouayheb, D. Evans, J. Gardner, Z. Garrett, A. Gascón, B. Ghazi, P. B. Gibbons, M. Gruteser, Z. Harchaoui, C. He, L. He, Z. Huo, B. Hutchinson, J. Hsu, M. Jaggi, T. Javidi, G. Joshi, M. Khodak, J. Konecný, A. Korolova, F. Koushanfar, S. Koyejo, T. Lepoint, Y. Liu, P. Mittal, M. Mohri, R. Nock, A. Özgür, R. Pagh, H. Qi, D. Ramage, R. Raskar, M. Raykova, D. Song, W. Song, S. U. Stich, Z. Sun, A. Theertha Suresh, F. Tramèr, P. Vepakomma, J. Wang, L. Xiong, Z. Xu, Q. Yang, F. X. Yu, H. Yu, and S. Zhao. \"Advances and open problems in federated learning\". arXiv preprint:1912.04977, December 2019.   \n[17] A. Krizhevsky and G. Hinton. \"Learning multiple layers of features from tiny images\". Master’s thesis, Department of Computer Science, University of Toronto, 2009.   \n[18] Y. LeCun and C. Cortes. MNIST handwritten digit database. 2010.   \n[19] M. Li. \"Scaling distributed machine learning with the parameter server\". In Proc. the 11th USENIX Conference on Operating Systems Design and Implementation, pages 1–1, Broomfield, CO, USA, 08 2014.   \n[20] H. McMahan, E. Moore, D. Ramage, S. Hampson, and B. A. Arcas. \"Communication-efficient learning of deep networks from decentralized data\". In AISTATS, Ft. Lauderdale, FL, USA, 2017.   \n[21] L. Melis, C. Song, E. D. Cristofaro, and V. Shmatikov. \"Inference attacks against collaborative learning\". In Proc. the 35th Annual Computer Security Applications Conference, page 148–162, New York, NY, USA, 2018.   \n[22] X. Pan, M. Zhang, Y. Yan, J. Zhu, and M. Yang. \"Theory-oriented deep leakage from gradients via linear equation solver\". In arXiv eprint 2010.13356, 2020.   \n[23] A. Rakhlin, O. Shamir, and K. Sridharan. \"Making gradient descent optimal for strongly convex stochastic optimization\". In Proc. International Conference on Learning Representations, Edinburgh, Scotland, 2012.   \n[24] R. Shokri and V. Shmatikov. \"Privacy-preserving deep learning\". In Proc. the 22nd ACM SIGSAC Conference on Computer and Communications Security, page 1310–1321, Denver, Colorado, USA, 2015.   \n[25] Y. Wang, J. Deng, D. Guo, C. Wang, X. Meng, H. Liu, C. Ding, and S. Rajasekaran. Sapag: A self-adaptive privacy attack from gradients. arXiv, eprint:2009.06228, 2020.   \n[26] W. Wei, L. Liu, M. Loper, K. H. Chow, M. E. Gursoy, S. Truex, and Y. Wu. \"A framework for evaluating gradient leakage attacks in federated learning\". arXiv, eprint 2004.10397, 2020.   \n[27] C. Xie, K. Huang, P. Chen, and B. Li. \"DBA: Distributed backdoor attacks against federated learning\". In International Conference on Learning Representations, Addis Ababa, Ethiopia, 2020.   \n[28] Q. Yang, Y. Liu, T. Chen, and Yongxin Tong. Federated machine learning: Concept and applications. ACM Trans. Intell. Syst. Technol., 10(2), January 2019.   \n[29] H. Yin, A. Mallya, A. Vahdat, J. M. Alvarez, J. Kautz, and P. Molchanov. \"See through gradients: Image batch recovery via gradinversion\". In Proc. Conference on Computer Vision and Pattern Recognition, 2021.   \n[30] B. Zhao, K. R. Mopuri, and H. Bilen. idlg: Improved deep leakage from gradients. arXiv, eprint:2001.02610, 2020.   \n[31] J. Zhu and M. B. Blaschko. \"R-GAP: Recursive gradient attack on privacy\". In International Conference on Learning Representations, 2021.   \n[32] L. Zhu, Z. Liu, and S. Han. \"Deep leakage from gradients\". In Advances in Neural Information Processing Systems 32, pages 14774–14784, Vancouver, Canada, 2019. ",
+        "bbox": [
+            173,
+            236,
+            826,
+            917
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            82,
+            828,
+            916
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            90,
+            826,
+            195
+        ],
+        "page_idx": 12
+    }
+]

parse/train/b4YiFnQH3gN/b4YiFnQH3gN_middle.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/b4YiFnQH3gN/b4YiFnQH3gN_model.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/hbHkvGBZB9/hbHkvGBZB9.md ADDED Viewed

	@@ -0,0 +1,261 @@

+# Are Transformers More Robust Than CNNs?
+Yutong Bai1 Jieru Mei1 Alan Yuille1 Cihang Xie2 1Johns Hopkins University 2 University of California, Santa Cruz {ytongbai, meijieru, alan.l.yuille, cihangxie306}@gmail.com
+# Abstract
+Transformer emerges as a powerful tool for visual recognition. In addition to demonstrating competitive performance on a broad range of visual benchmarks, recent works also argue that Transformers are much more robust than Convolutions Neural Networks (CNNs). Nonetheless, surprisingly, we find these conclusions are drawn from unfair experimental settings, where Transformers and CNNs are compared at different scales and are applied with distinct training frameworks. In this paper, we aim to provide the first fair & in-depth comparisons between Transformers and CNNs, focusing on robustness evaluations.
+With our unified training setup, we first challenge the previous belief that Transformers outshine CNNs when measuring adversarial robustness. More surprisingly, we find CNNs can easily be as robust as Transformers on defending against adversarial attacks, if they properly adopt Transformers’ training recipes. While regarding generalization on out-of-distribution samples, we show pretraining on (external) large-scale datasets is not a fundamental request for enabling Transformers to achieve better performance than CNNs. Moreover, our ablations suggest such stronger generalization is largely benefited by the Transformer’s self-attention-like architectures per se, rather than by other training setups. We hope this work can help the community better understand and benchmark the robustness of Transformers and CNNs. The code and models are publicly available at https://github.com/ytongbai/ViTs-vs-CNNs.
+# 1 Introduction
+Convolutional Neural Networks (CNNs) have been the widely-used architecture for visual recognition in recent years [22, 38, 40, 16, 21]. It is commonly believed the key to such success is the usage of the convolutional operation, as it introduces several useful inductive biases (e.g., translation equivalence) to models for benefiting object recognition. Interestingly, recent works alternatively suggest that it is also possible to build successful recognition models without convolutions [34, 60, 3]. The most representative work in this direction is Vision Transformer (ViT) [12], which applies the pure self-attention-based architecture to sequences of images patches and attains competitive performance on the challenging ImageNet classification task [35] compared to CNNs. Later works [26, 47] further expand Transformers with compelling performance on other visual benchmarks, including COCO detection and instance segmentation [23], ADE20K semantic segmentation [61].
+The dominion of CNNs on visual recognition is further challenged by the recent findings that Transformers appear to be much more robust than CNNs. For example, Shao et al. [37] observe that the usage of convolutions may introduce a negative effect on models’ adversarial robustness, while migrating to Transformer-like architectures (e.g., the Conv-Transformer hybrid model or the pure Transformer) can help secure models’ adversarial robustness. Similarly, Bhojanapalli et al. [4] report that, if pre-trained on sufficiently large datasets, Transformers exhibit considerably stronger robustness than CNNs on a spectrum of out-of-distribution tests (e.g., common image corruptions [17], texture-shape cue conflicting stimuli [13]).
+Though both [4] and [37] claim that Transformers are preferable to CNNs in terms of robustness, we find that such conclusion cannot be strongly drawn based on their existing experiments. Firstly, Transformers and CNNs are not compared at the same model scale, e.g., a small CNN, ResNet50 ${ \sim } 2 5$ million parameters), by default is compared to a much larger Transformer, ViT-B ( $\mathord { \sim } 8 6$ million parameters), for these robustness evaluations. Secondly, the training frameworks applied to Transformers and CNNs are distinct from each other (e.g., training datasets, number of epochs, and augmentation strategies are all different), while little efforts are devoted on ablating the corresponding effects. In a nutshell, due to these inconsistent and unfair experiment settings, it remains an open question whether Transformers are truly more robust than CNNs.
+To answer it, in this paper, we aim to provide the first benchmark to fairly compare Transformers to CNNs in robustness evaluations. We particularly focus on the comparisons between Small Data-efficient image Transformer (DeiT-S) [43] and ResNet-50 [16], as they have similar model capacity (i.e., ${ \sim } 2 2$ million parameters vs. ${ \sim } 2 5$ million parameters) and achieve similar performance on ImageNet (i.e., $7 6 . 8 \%$ top-1 accuracy vs. $7 6 . 9 \%$ top-1 accuracy1). Our evaluation suite accesses model robustness in two ways: 1) adversarial robustness, where the attackers can actively and aggressively manipulate inputs to approximate the worst-case scenario; 2) generalization on out-of-distribution samples, including common image corruptions (ImageNet-C [17]), texture-shape cue conflicting stimuli (Stylized-ImageNet [13]) and natural adversarial examples (ImageNet-A [19]).
+With this unified training setup, we present a completely different picture from previous ones [37, 4]. Regarding adversarial robustness, we find that Transformers actually are no more robust than CNNs— if CNNs are allowed to properly adopt Transformers’ training recipes, then these two types of models will attain similar robustness on defending against both perturbation-based adversarial attacks and patch-based adversarial attacks. While for generalization on out-of-distribution samples, we find Transformers can still substantially outperform CNNs even without the needs of pre-training on sufficiently large (external) datasets. Additionally, our ablations show that adopting Transformer’s self-attention-like architecture is the key for achieving strong robustness on these out-of-distribution samples, while tuning other training setups will only yield subtle effects here. We hope this work can serve as a useful benchmark for future explorations on robustness, using different network architectures, like CNNs, Transformers, and beyond [42, 24].
+# 2 Related Works
+Vision Transformer. Transformers, invented by Vaswani et al. in 2017 [46], have largely advanced the field of natural language processing (NLP). With the introduction of self-attention module, Transformer can effectively capture the non-local relationships between all input sequence elements, achieving the state-of-the-art performance on numerous NLP tasks [54, 10, 5, 11, 31, 32].
+The success of Transformer on NLP also starts to get witnessed in computer vision. The pioneering work, ViT [12], demonstrates that the pure Transformer architectures are able to achieve exciting results on several visual benchmarks, especially when extremely large datasets (e.g., JFT-300M [39]) are available for pre-training. This work is then subsequently improved by carefully curating the training pipeline and the distillation strategy to Transformers [43], enhancing the Transformers’ tokenization module [55], building multi-resolution feature maps on Transformers [26, 47], designing parameter-efficient Transformers for scaling [57, 45, 52], etc. In this work, rather than focusing on furthering Transformers on standard visual benchmarks, we aim to provide a fair and comprehensive study of their performance when testing out of the box.
+Robustness Evaluations. Conventional learning paradigm assumes training data and testing data are drawn from the same distribution. This assumption generally does not hold, especially in the real-world case where the underlying distribution is too complicated to be covered in a (limitedsized) dataset. To properly access model performance in the wild, a set of robustness generalization benchmarks have been built, e.g., ImageNet-C [17], Stylized-ImageNet [13], ImageNet-A [19], etc. Another standard surrogate for testing model robustness is via adversarial attacks, where the attackers deliberately add small perturbations or patches to input images, for approximating the worst-case evaluation scenario [41, 14]. In this work, both robustness generalization and adversarial robustness are considered in our robustness evaluation suite.
+Concurrent to ours, both Bhojanapalli et al. [4] and Shao et al. [37] conduct robustness comparisons between Transformers and CNNs. Nonetheless, we find their experimental settings are unfair, e.g., models are compared at different capacity [4, 37] or are trained under distinct frameworks [37]. In this work, our comparison carefully align the model capacity and the training setups, which draws completely different conclusions from the previous ones.
+# 3 Settings
+# 3.1 Training CNNs and Transformers
+Convolutional Neural Networks. ResNet [16] is a milestone architecture in the history of CNN. We choose its most popular instantiation, ResNet-50 (with ${ \sim } 2 5 $ million parameters), as the default CNN architecture. To train CNNs on ImageNet, we follow the standard recipe of [15, 33]. Specifically, we train all CNNs for a total of 100 epochs, using momentum-SGD optimizer; we set the initial learning rate to 0.1, and decrease the learning rate by $1 0 \times$ at the 30-th, 60-th, and 90-th epoch; no regularization except weight decay is applied.
+Vision Transformer. ViT [12] successfully introduces Transformers from natural language processing to computer vision, achieving excellent performance on several visual benchmarks compared to CNNs. In this paper, we follow the training recipe of DeiT [43], which successfully trains ViT on ImageNet without any external data, and set DeiT-S (with ${ \sim } 2 2$ million parameters) as the default Transformer architecture. Specifically, we train all Transformers using AdamW optimizer [27]; we set the initial learning rate to 5e-4, and apply the cosine learning rate scheduler to decrease it; besides weight decay, we additionally adopt three data augmentation strategies (i.e., RandAug [9], MixUp [59] and CutMix [56]) to regularize training (otherwise DeiT-S will attain significantly lower ImageNet accuracy due to overfitting [6]).
+Note that different from the standard recipe of DeiT (which applies 300 training epochs by default), we hereby train Transformers only for a total of 100 epochs, i.e., same as the setup in ResNet. We also remove {Erasing, Stochastic Depth, Repeated Augmentation}, which were applied in the original DeiT framework, in this basic 100 epoch schedule, for preventing over-regularization in training. Such trained DeiT-S yields $7 6 . 8 \%$ top-1 ImageNet accuracy, which is similar to the ResNet-50’s performance $7 6 . 9 \%$ top-1 ImageNet accuracy).
+# 3.2 Robustness Evaluations
+Our experiments mainly consider two types of robustness here, i.e., robustness on adversarial examples and robustness on out-of-distribution samples.
+Adversarial Examples, which are crafted by adding human-imperceptible perturbations or smallsized patches to images, can lead deep neural networks to make wrong predictions. In addition to the very popular PGD attack [28], our robustness evaluation suite also contains: A) AutoAttack [8], which is an ensemble of diverse attacks (i.e., two variants of PGD attack, FAB attack [7] and Square Attack [1]) and is parameter-free; and B) Texture Patch Attack (TPA) [53], which uses a predefined texture dictionary of patches to fool deep neural networks.
+Recently, several benchmarks of out-of-distribution samples have been proposed to evaluate how deep neural networks perform when testing out of the box. Particularly, our robustness evaluation suite contains three such benchmarks: A) ImageNet-A [19], which are real-world images but are collected from challenging recognition scenarios (e.g., occlusion, fog scene); B) ImageNet-C [17], which is designed for measuring model robustness against 75 distinct common image corruptions; and C) Stylized-ImageNet [13], which creates texture-shape cue conflicting stimuli by removing local texture cues from images while retaining their global shape information.
+# 4 Adversarial Robustness
+In this section, we investigate the robustness of Transformers and CNNs on defending against adversarial attacks, using ImageNet validation set (with 50,000 images). We consider both perturbation-based attacks (i.e., PGD and AutoAttack) and patch-based attacks (i.e., TPA) for robustness evaluations.
+# 4.1 Robustness to Perturbation-Based Attacks
+Following [37], we first report the robustness of ResNet-50 and DeiT-S on defending against AutoAttack. We verify that, when applying with a small perturbation radius $\epsilon = 0 . 0 0 1$ , DeiT-S indeed achieves higher robustness than ResNet-50, i.e., $2 2 . 1 \%$ vs. $1 7 . 8 \%$ as shown in Table 1.
+However, when increasing the perturbation radius to 4/255, a more challenging but standard case studied in previous works [36, 48, 49], both models will be circumvented completely, i.e., $0 \%$ robustness on defending against AutoAttack. This is mainly due to that both models are not adversarially trained [14, 28], which is an effective way to secure model robustness against adversarial attacks, and we will study it next.
+Table 1: Performance of ResNet-50 and DeiT-S on defending against AutoAttack, using ImageNet validation set. We note both models are completely broken when setting perturbation radius to 4/255.
+<table><tr><td rowspan="2"></td><td rowspan="2">Clean</td><td colspan="2">Perturbation Radius</td></tr><tr><td>0.001</td><td>4/255</td></tr><tr><td>ResNet-50</td><td>76.9</td><td>17.8</td><td>0.0</td></tr><tr><td>DeiT-S</td><td>76.8</td><td>22.1</td><td>0.0</td></tr></table>
+# 4.1.1 Adversarial Training
+Adversarial training [14, 28], which trains models with adversarial examples that are generated on-the-fly, aims to optimize the following min-max framework:
+$$
+\underset { \theta } { \arg \operatorname* { m i n } } \mathbb { E } _ { ( x , y ) \sim \mathbb { D } } \Big [ \underset { \epsilon \in \mathbb { S } } { \operatorname* { m a x } } L ( \theta , x + \epsilon , y ) \Big ] ,
+$$
+where $\mathbb { D }$ is the underlying data distribution, $L ( \cdot , \cdot , \cdot )$ is the loss function, $\theta$ is the network parameter, $x$ is a training sample with the ground-truth label $y , \epsilon$ is the added adversarial perturbation, and $\mathbb { S }$ is the allowed perturbation range. Following [51, 48], the adversarial training here applies single-step PGD (PGD-1) to generate adversarial examples (for lowering training cost), with the constrain that maximum per-pixel change $\epsilon = 4 / 2 5 5$ .
+Adversarial Training on Transformers. We apply the setup above to adversarially train both ResNet-50 and DeiT-S. However, surprisingly, this default setup works for ResNet-50 but will collapse the training with DeiT-S, i.e., the robustness of such trained DeiT-S is merely ${ \sim } 4 \%$ when evaluating against PGD-5. We identify the issue is over-regularization—when combining strong data augmentation strategies (i.e., RangAug, Mixup and CutMix) with adversarial attacks, the yielded training samples are too hard to be learnt by DeiT-S.
+![](images/a2f799125ca6f7dbb0833cd607301c9f054edae0c4dd865ac2a4577d18566455.jpg)
+Figure 1: The illustration of the proposed augmentation warm-up strategy. At the beginning of adversarial training (from epoch ${ } = 0$ to epoch $^ { - 9 }$ ), we progressively increase the augmentation strength.
+To ease this observed training difficulty, we design a curriculum of the applied augmentation strategies. Specifically, as shown in Figure 1, at the first 10 epoch, we progressively enhance the augmentation strength (e.g., gradually changing the distortion magnitudes in RandAug from 1 to 9) to warmup the training process. Our experiment verifies this curriculum enables a successful adversarial training—DeiT-S now attains ${ \sim } 4 4 \%$ robustness (boosted from ${ \sim } 4 \%$ ) on defending against PGD-5.
+Transformers with CNNs’ Training Recipes. Interestingly, an alternative way to address the observed training difficulty is directly adopting CNN’s recipes to train Transformers [37], i.e., applying M-SGD with step decay learning rate scheduler and removing strong data augmentation strategies (like Mixup). Though this setup can stabilize the adversarial training process, it significantly hurts the overall performance of DeiT-S—the clean accuracy drops to $5 9 . 9 \%$ $( \mathbf { - 6 . 6 \% } )$ , and the robustness on defending against PGD-100 drops to $3 1 . 9 \%$ $( - 8 . 4 \% )$ .
+One reason for this degenerated performance is that strong data augmentation strategies are not included in CNNs’ recipes, therefore Transformers will be easily overfitted during training [6]. Another key factor here is the incompatibility between the SGD optimizer and Transformers. As explained in [25], compared to SGD, adaptive optimizers (like AdamW) are capable of assigning different learning rates to different parameters, resulting in consistent update magnitudes even with unbalanced gradients. This property is crucial for enabling successful training of Transformers, given the gradients of attention modules are highly unbalanced.
+CNNs with Transformers’ Training Recipes. As shown in Table 2, adversarially trained ResNet50 is less robust than adversarially trained DeiT-S, i.e., $3 2 . 2 6 \%$ vs. $4 0 . 3 2 \%$ on defending against PGD-100. It motivates us to explore whether adopting Transformers’ training recipes to CNNs can enhance CNNs’ adversarial training. Interestingly, if we directly apply AdamW to ResNet-50, the adversarial training will collapses. We also explore the possibility of adversarially training ResNet-50 with strong data augmentation strategies (i.e., RandAug, Mixup and CutMix). However, we find ResNet-50 will be overly regularized in adversarial training, leading to very unstable training process, sometimes may even collapse completely.
+Though Transformers’ optimizer and augmentation strategies cannot improve CNNs’ adversarial training, we find Transformers’ choice of activation functions matters. Unlike the widely-used activation function in CNNs is ReLU, Transformers by default use GELU [18]. As suggested in [49], ReLU significantly weakens adversarial training due to its non-smooth nature; replacing ReLU with its smooth approximations (e.g., GELU, SoftPlus) can strengthen adversarial training. We verify that by replacing ReLU with Transformers’ activation function (i.e., GELU) in ResNet-50. As shown in Table 2, adversarial training now can be significantly enhanced, i.e., ResNet- $5 0 +$ GELU substantially outperforms its ReLU counterpart by $8 . 0 1 \%$ on defending against PGD-100. Moreover, we note the usage of GELU enables ResNet-50 to match DeiT-S in adversarial robustness, i.e., $4 0 . 2 7 \%$ vs. $4 0 . 3 2 \%$ for defending against PGD-100, and $3 5 . 5 1 \%$ vs. $3 5 . 5 0 \%$ for defending against AutoAttack, challenging the previous conclusions [4, 37] that Transformers are more robust than CNNs on defending against adversarial attacks.
+Table 2: The performance of ResNet-50 and DeiT-S on defending against adversarial attacks (with $\epsilon = 4$ ). After replacing ReLU with DeiT’s activation function GELU in ResNet-50, its robustness can match the robustness of DeiT-S.
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Activation</td><td rowspan=1 colspan=1>Clean Acc</td><td rowspan=1 colspan=1>PGD-5</td><td rowspan=1 colspan=1>PGD-10</td><td rowspan=1 colspan=1>PGD-50</td><td rowspan=1 colspan=1>PGD-100</td><td rowspan=1 colspan=1>AutoAttack</td></tr><tr><td rowspan=1 colspan=1>ResNet-50</td><td rowspan=1 colspan=1>ReLUGELU</td><td rowspan=1 colspan=1>66.7767.38</td><td rowspan=1 colspan=1>38.7044.01</td><td rowspan=1 colspan=1>34.1940.98</td><td rowspan=1 colspan=1>32.4740.28</td><td rowspan=1 colspan=1>32.2640.27</td><td rowspan=1 colspan=1>26.4135.51</td></tr><tr><td rowspan=1 colspan=1>DeiT-S</td><td rowspan=1 colspan=1>GELU</td><td rowspan=1 colspan=1>66.50</td><td rowspan=1 colspan=1>43.95</td><td rowspan=1 colspan=1>41.03</td><td rowspan=1 colspan=1>40.34</td><td rowspan=1 colspan=1>40.32</td><td rowspan=1 colspan=1>35.50</td></tr></table>
+# 4.2 Robustness to Patch-Based Attacks
+We next study the robustness of CNNs and Transformers on defending against patch-based attacks. We choose Texture Patch Attack (TPA) [53] as the attacker. Note that different from typical patchbased attacks which apply monochrome patches, TPA additionally optimizes the pattern of the patches to enhance attack strength. By default, we set the number of attacking patches to 4, limit the largest manipulated area to $10 \%$ of the whole image area, and set the attack mode as the non-targeted attack. For ResNet-50 and DeiT-S, we do not consider adversarial training here as their vanilla counterparts already demonstrate non-trivial performance on defending against TPA.
+Table 3: Performance of ResNet-50 and DeiT-S on defending against Texture Patch Attack.
+<table><tr><td>Architecture</td><td>Clean Acc</td><td>TexturePatchAttack</td></tr><tr><td>ResNet-50</td><td>76.9</td><td>19.7</td></tr><tr><td>DeiT-S</td><td>76.8</td><td>47.7</td></tr></table>
+Interestingly, as shown in Table 3, though both models attain similar clean image accuracy, DeiT-S substantially outperforms ResNet-50 by $28 \%$ on defending against TPA. We conjecture such huge performance gap is originated from the differences in training setups; more specifically, it may be resulted by the fact DeiT-S by default use strong data augmentation strategies while ResNet-50 use none of them. The augmentation strategies like CutMix already naïvely introduce occlusion or image/patch mixing during training, therefore are potentially helpful for securing model robustness against patch-based adversarial attacks.
+To verify the hypothesis above, we next ablate how strong augmentation strategies in DeiT-S (i.e., RandAug, Mixup and CutMix) affect ResNet-50’s robustness. We report the results in Table 4. Firstly, we note all augmentation strategies can help ResNet-50 achieve stronger TPA robustness, with improvements ranging from $+ 4 . 6 \%$ to $+ 3 2 . 7 \%$ . Among all these augmentation strategies, CutMix stands as the most effective one to secure model’s TPA robustness, i.e., CutMix alone can improve TPA robustness by $2 9 . 4 \%$ . Our best model is obtained by using both CutMix and RandAug, reporting $5 2 . 4 \%$ TPA robustness, which is even stronger than DeiT-S ( $4 7 . 7 \%$ TPA robustness). This observation still holds by using stronger TPA with 10 patches (increased from 4), i.e., ResNet-50 now attains $3 4 . 5 \%$ TPA robustness, outperforming DeiT-S by $5 . 6 \%$ . These results suggest that Transformers are also no more robust than CNNs on defending against patch-based adversarial attacks.
+Table 4: Performance of ResNet-50 trained with different augmentation strategies on defending against Texture Patch Attack. We note 1) all augmentation strategies can improve model robustness, and 2) CutMix is the most effective augmentation strategy to secure model robustness.
+<table><tr><td colspan="3">Augmentations</td><td rowspan="2">Clean Acc</td><td rowspan="2">Texture Patch Attack</td></tr><tr><td>RandAug</td><td>MixUp</td><td>CutMix</td></tr><tr><td>X</td><td>×</td><td>×</td><td>76.9</td><td>19.7</td></tr><tr><td>√</td><td>X</td><td>×</td><td>77.5</td><td>24.3 (+4.6)</td></tr><tr><td>X</td><td>√</td><td>X</td><td>75.9</td><td>31.5 (+11.8)</td></tr><tr><td>X</td><td>X</td><td>√</td><td>77.2</td><td>49.1 (+29.4)</td></tr><tr><td>√</td><td>√</td><td>X</td><td>75.7</td><td>31.7 (+12.0)</td></tr><tr><td>√</td><td>×</td><td>√</td><td>76.7</td><td>52.4 (+32.7)</td></tr><tr><td>X</td><td>√</td><td>！</td><td>77.1</td><td>39.8 (+20.1)</td></tr><tr><td>√</td><td>√</td><td>√</td><td>76.4</td><td>48.6 (+28.9)</td></tr></table>
+# 5 Robustness on Out-of-distribution Samples
+In addition to adversarial robustness, we are also interested in comparing the robustness of CNNs and Transformers on out-of-distribution samples. We hereby select three datasets, i.e., ImageNet-A, ImageNet-C and Stylized ImageNet, to capture the different aspects of out-of-distribution robustness.
+# 5.1 Aligning Training Recipes
+We first provide a direct comparison between ResNet-50 and DeiT-S with their default training setup. As shown in Table 5, we observe that, even without pretraining on (external) large scale datasets, DeiT-S still significantly outperforms ResNet-50 on ImageNet-A $( + 9 . 0 \% )$ , ImageNet-C $( + 9 . 9 )$ and Stylized-ImageNet $( + 4 . 7 \% )$ . It is possible that such performance gap is caused by the differences in training recipes (similar to the situation we observed in Section 4), which we plan to ablate next.
+Table 5: DeiT-S shows stronger robustness generalization than ResNet-50 on ImageNet-C, ImageNetA and Stylized-ImageNet. Note the results on ImageNet-C is measured by mCE (lower is better).
+<table><tr><td>Architecture</td><td>ImageNet个</td><td>ImageNet-A↑</td><td>ImageNet-C</td><td>Stylized-ImageNet↑</td></tr><tr><td>ResNet-50</td><td>76.9</td><td>3.2</td><td>57.9</td><td>8.3</td></tr><tr><td>ResNet-50*</td><td>76.3</td><td>4.5</td><td>55.6</td><td>8.2</td></tr><tr><td>DeiT-S</td><td>76.8</td><td>12.2</td><td>48.0</td><td>13.0</td></tr></table>
+A fully aligned version. A simple baseline here is that we completely adopt the recipes of DeiT-S to train ResNet-50, denoted as ResNet- $5 0 ^ { \ast }$ . Specifically, this ResNet- ${ } . 5 0 ^ { * }$ will be trained with AdamW optimizer, cosine learning rate scheduler and strong data augmentation strategies. Nonetheless, as reported in Table 5, ResNet- ${ } . 5 0 ^ { * }$ only marginally improves ResNet-50 on ImageNet-A $( + 1 . 3 \% )$ and ImageNet-C $( + 2 . 3 )$ , which is still much worse than DeiT-S on robustness generalization.
+It is possible that completely adopting the recipes of DeiT-S overly regularizes the training of ResNet50, leading to suboptimal performance. To this end, we next seek to discover the “best” setups to train ResNet-50, by ablating learning rate scheduler (step decay vs. cosine decay), optimizer (M-SGD vs. AdamW) and augmentation strategies (RandAug, Mixup and CutMix) progressively.
+Step 1: aligning learning rate scheduler. It is known that switching learning rate scheduler from step decay to cosine decay improves model accuracy on clean images [2]. We additionally verify that such trained ResNet-50 (second row in Table 6) attains slightly better performance on ImageNet-A $( + 0 . 1 \% )$ , ImageNet-C $( + 1 . 0 )$ and Stylized-ImageNet $( + 0 . 1 \% )$ . Given the improvements here, we will use cosine decay by default for later ResNet training.
+Step 2: aligning optimizer. We next ablate the effects of optimizers. As shown in the third row in Table 6, switching optimizer from M-SGD to AdamW weakens ResNet training, i.e., it not only decreases ResNet-50’s accuracy on ImageNet $( - 1 . 0 \% )$ , but also hurts ResNet-50’s robustness generalization on ImageNet-A $( - 0 . 2 \% )$ , ImageNet-C (-2.4) and Stylized-ImageNet $( - 0 . 3 \% )$ . Given this degenerated performance, we stick to M-SGD for later ResNet-training.
+Table 6: The robustness generalization of ResNet-50 trained with different learning rate schedulers and optimizers. Nonetheless, compared to DeiT-S, all the resulted ResNet-50 show worse generalization on out-of-distribution samples.
+<table><tr><td></td><td>Optimizer-LR Scheduler</td><td>ImageNet 个</td><td>ImageNet-A↑</td><td>ImageNet-C</td><td>Stylized-ImageNet↑</td></tr><tr><td rowspan="2">ResNet-50</td><td>SGD-Step</td><td>76.9</td><td>3.2</td><td>57.9</td><td>8.3</td></tr><tr><td>SGD-Cosine</td><td>77.4</td><td>3.3</td><td>56.9</td><td>8.4</td></tr><tr><td>DeiT-S</td><td>AdamW-Cosine</td><td>76.4</td><td>3.1</td><td>59.3</td><td>8.1</td></tr><tr><td></td><td>AdamW-Cosine</td><td>76.8</td><td>12.2</td><td>48.0</td><td>13.0</td></tr></table>
+Step 3: aligning augmentation strategies. Compared to ResNet-50, DeiT-S additionally applied RandAug, Mixup and CutMix to augment training data. We hereby examine whether these augmentation strategies affect robustness generalization. The performance of ResNet-50 trained with different combinations of augmentation strategies is reported in Table 7. Compared to the vanilla counterpart, nearly all the combinations of augmentation strategies can improve ResNet-50’s generalization on out-of-distribution samples. The best performance is achieved by using RandAug $^ +$ Mixup, outperforming the vanilla ResNet-50 by $3 . 0 \%$ on ImageNet-A, 4.6 on ImageNet-C and $2 . 4 \%$ on Stylized-ImageNet.
+Table 7: The robustness generalization of ResNet-50 trained with different combinations of augmentation strategies. We note applying RandAug $^ +$ Mixup yields the best ResNet-50 on out-ofdistribution samples; nonetheless, DeiT-S still significantly outperforms such trained ResNet-50.
+<table><tr><td rowspan="2">Architecture</td><td colspan="2">Augmentation Strategies</td><td rowspan="2">ImageNet ↑</td><td rowspan="2">ImageNet-A ↑</td><td rowspan="2">ImageNet-C</td><td rowspan="2">Stylized-ImageNet↑</td></tr><tr><td>RandAug MixUp</td><td>CutMix</td></tr><tr><td rowspan="4">ResNet-50</td><td>X X</td><td>X</td><td>77.4</td><td>3.3</td><td>56.9</td><td>8.4</td></tr><tr><td>√ √</td><td>X</td><td>75.7</td><td>6.3</td><td>52.3</td><td>10.8</td></tr><tr><td>√</td><td>X 公</td><td>76.7</td><td>6.3</td><td>56.3</td><td>7.1</td></tr><tr><td>×</td><td>√</td><td>77.1</td><td>6.1</td><td>55.1</td><td>8.8</td></tr><tr><td></td><td>√</td><td>√ √</td><td>76.4</td><td>5.5</td><td>54.0</td><td>9.1</td></tr><tr><td>DeiT-S</td><td>√</td><td>√ √</td><td>76.8</td><td>12.2</td><td>48.0</td><td>13.0</td></tr></table>
+Comparing ResNet with the “best” training recipes to DeiT-S. With the ablations above, we can conclude that the “best” training recipes for ResNet-50 (denoted as ResNet-50-Best) is by applying M-SGD optimizer, scheduling learning rate using cosine decay, and augmenting training data using RandAug and Mixup. As shown in the second row of Table 7, ResNet-50-Best attains $6 . 3 \%$ accuracy on ImageNet-A, $5 2 . 3 \mathrm { m C E }$ on ImageNet-C and $1 0 . 8 \%$ accuracy on Stylized-ImageNet.
+Nonetheless, interestingly, we note DeiT-S still shows much stronger robustness generalization on out-of-distribution samples than our “best” ResNet-50, i.e., $+ 5 . 9 \%$ on ImageNet-A, $+ 4 . 3$ on ImageNet-C and $+ 2 . 2 \%$ on Stylized-ImageNet. These results suggest that the differences in training recipes (including the choice of optimizer, learning rate scheduler and augmentation strategies) is not the key for leading the observed huge performance gap between CNNs and Transformers on out-of-distribution samples.
+Model size. To further validate that Transformers are indeed more robust than CNNs on out-ofdistribution samples, we hereby extend the comparisons above to other model sizes. Specifically, we consider the comparison at a smaller scale, i.e. ResNet-18 ( ${ \sim } 1 2$ million parameters) vs. DeiTMini ${ \sim } 1 0$ million parameters, with embedding dimension $= 2 5 6$ and number of head $= 4$ ). For ResNet training, we consider both the fully aligned recipe version (denoted as ResNet\*) and the “best” recipe version (denoted as ResNet-Best). Figure 2 shows the main results. Similar to the comparison between ResNet-50 and DeiT-S, DeiT-Mini also demonstrates much stronger robustness generalization than ResNet- $. 1 8 ^ { * }$ and ResNet-18-Best.
+We next study DeiT and ResNet at a more challenging setting—comparing DeiT to a much larger ResNet on robustness generalization. Surprisingly, we note in both cases, DeiT-Mini vs. ResNet-50 and DeiT-S vs. ResNet-101, DeiTs are able to show similar, sometimes even superior, performance than ResNets. For example, DeiT-S beats the nearly $2 \times$ larger ResNet- $1 0 1 ^ { \ast }$ ${ \sim } 2 2$ million parameters vs. ${ \sim } 4 5$ million parameters) by $3 . 3 7 \%$ on ImageNet-A, 1.20 on ImageNet-C and $1 . 3 8 \%$ on StylizedImageNet. All these results further corroborate that Transformers are much more robust than CNNs on out-of-distribution samples.
+![](images/bf4d39032ccfa302941ff1a4cbed3b351becccb56bcd88acbc853ff679346427.jpg)
+Figure 2: By comparing models at different scales, DeiT consistently outperforms ResNet\* and ResNet-Best by a large margin on ImageNet-A, ImageNet-C and Stylized-ImageNet.
+# 5.2 Distillation
+In this section, we make another attempt to bridge the robustness generalization gap between CNNs and Transformers—we apply knowledge distillation to let ResNet-50 (student model) directly learn from DeiT-S (teacher model). Specifically, we perform soft distillation [20], which minimizes the Kullback-Leibler divergence between the softmax of the teacher model and the softmax of the student model; we adopt the training recipe of DeiT during distillation.
+Main results. We report the distillation results in Table 8. Though both models attain similar clean image accuracy, the student model ResNet-50 shows much worse robustness generalization than the teacher model DeiT-S, i.e., the performance is decreased by $7 . 0 \%$ on ImageNet-A, 6.2 on ImageNet-C and $3 . 2 \%$ on Stylized-ImageNet. This observation is counter-intuitive as student models typically achieve higher performance than teacher models in knowledge distillation.
+However, interestingly, if we switch the roles of DeiT-S and ResNet-50, the student model DeiT-S is able to significantly outperforms the teacher model ResNet-50 on out-of-distribution samples. As shown in the third row and the fourth row in Table 8, the improvements are $6 . 4 \%$ on ImageNet-A, 6.3 on ImageNet-C and $3 . 7 \%$ on Stylized-ImageNet. These results arguably suggest that the strong generalization robustness of DeiT is rooted in the architecture design of Transformer that cannot be transferred to ResNet via neither training setups or knowledge distillation.
+Table 8: The robustness generalization of ResNet-50, DeiT-S and their distilled models.
+<table><tr><td>Distillation</td><td>Architecture</td><td>ImageNet</td><td>ImageNet-A 个</td><td>ImageNet-C</td><td>Stylized-ImageNet个</td></tr><tr><td>Teacher</td><td>DeiT-S</td><td>76.8</td><td>12.2</td><td>48.0</td><td>13.0</td></tr><tr><td>Student Teacher</td><td>ResNet-50*-Distill ResNet-50*</td><td>76.7 76.3</td><td>5.2 (-7.0) 4.5</td><td>54.2 (+6.2) 55.6</td><td>9.8 (-3.2) 8.2</td></tr><tr><td>Student</td><td>DeiT-S-Distill</td><td>76.2</td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td>10.9 (+6.4)</td><td>49.3 (-6.3)</td><td>11.9 (+3.7)</td></tr></table>
+# 5.3 Hybrid Architecture
+Following the discussion in Section 5.2, we hereby ablate whether incorporating Transformer’s self-attention-like architecture into model design can help robustness generalization. Specifically, we create a hybrid architecture (named Hybrid-DeiT) by directly feeding the output of res_4 block in ResNet-18 into DeiT-Mini, and compare its robustness generalization to ResNet-50 and DeiT-Small. Note that under this setting, these three models are at the same scale, i.e., hybrid-DeiT ( ${ \sim } 2 1$ million parameters) vs. ResNet-50 ( ${ \sim } 2 5$ million parameters) vs. DeiT-S ${ \sim } 2 2$ million parameters). We apply the recipe of DeiT to train these three models.
+Main results. We report the robustness generalization of these three models in Figure 3. Interestingly, with the introduction of Transformer blocks, Hybrid-DeiT is able to achieve better robustness generalization than ResNet-50, i.e., $+ 1 . 1 \%$ on ImageNet-A and $+ 2 . 5 \%$ on Stylized-ImageNet, suggesting Transformer’s self-attention-like architectures is essential for boosting performance on out-of-distribution samples. We additionally compare this hybrid architecture to the pure Transformer architecture. As expected, Hybrid-DeiT attains lower robustness generalization than DeiT-S, as shown in Figure 3.
+![](images/47be14ef538bca69f32ca448f05e8b70af8abee7ace8f7a694c64624869f6146.jpg)
+Figure 3: The robustness generalization of ResNet-50, DeiT-S and Hybrid-DeiT. We note introducing Transformer blocks into model design benefits generalization on out-of-distribution samples.
+# 5.4 300-Epoch Training
+As mentioned in Section 3.1, we by default train all models for only 100 epochs. This is a standard setup in training CNNs [15, 33], but not typical in training Transformers [44, 26]. To rule out the possibility of introducing negative effects in shortening training length, we lastly ablate the 300-epoch setup, i.e., we directly borrow the default setup in [44] to train both ResNet and DeiT.
+As reported in Table 9, DeiT-S substantially outperforms ResNet-50 by $1 0 . 4 \%$ on ImageNet-A, 7.5 on ImageNet-C and 5.6 on Stylized-ImageNet. Nonetheless, we argue that such comparison is less interesting and even unfair—DeiT-S already beats ResNet-50 by $1 . 8 \%$ on ImageNet classification, therefore it is expected that DeiT-S will also show stronger performance than ResNet-50 on ImageNetA, ImageNet-C and Stylized-ImageNet.
+Table 9: The robustness generalization of ResNet-50 and DeiT-S under the 300-epoch training setup. We note DeiT-S shows stronger performance than ResNet-50 on both clean images and out-of-distribution samples.
+<table><tr><td>Architecture</td><td>ImageNet↑</td><td>ImageNet-A↑</td><td>ImageNet-C</td><td>Stylized-ImageNet↑</td></tr><tr><td>ResNet-50</td><td>78.1</td><td>8.8</td><td>50.3</td><td>9.5</td></tr><tr><td>DeiT-S</td><td>79.9</td><td>19.2</td><td>42.8</td><td>15.1</td></tr></table>
+To make the setup fairer (i.e., comparing the robustness of models that have similar accuracy), we now compare DeiT-S to the much larger ResNet-101 (i.e., ${ \sim } 2 2$ million parameters vs. ${ \sim } 4 5$ million parameters). The results are shown in Table 10. We observer that though both models achieve similar accuracy on ImageNet, DeiT-S demonstrates much stronger robustness generalization than ResNet-101. This observation can also holds for bigger Transformers and CNNs, e.g., DeiT-B can consistently outperforms ResNet-200 on ImageNet-A, ImageNet-C and Stylized- ImageNet, despite they attain similar clean image accuracy (i.e., $8 1 . 8 \%$ vs. $8 2 . 1 \%$ ).
+Table 10: The robustness generalization of ResNet and DeiT under the 300-epoch training setup. Though both models attain similar clean image accuracy, DeiTs show much stronger robustness generalization than ResNets.
+<table><tr><td rowspan=1 colspan=1>Architecture</td><td rowspan=1 colspan=1>ImageNet个</td><td rowspan=1 colspan=1>ImageNet-A↑</td><td rowspan=1 colspan=1>ImageNet-C↓</td><td rowspan=1 colspan=1>Stylized-ImageNet个</td></tr><tr><td rowspan=1 colspan=1>ResNet-101DeiT-S</td><td rowspan=1 colspan=1>80.279.9</td><td rowspan=1 colspan=1>17.619.2</td><td rowspan=1 colspan=1>45.842.8</td><td rowspan=1 colspan=1>11.915.1</td></tr><tr><td rowspan=1 colspan=1>ResNet-200DeiT-B</td><td rowspan=1 colspan=1>82.181.8</td><td rowspan=1 colspan=1>23.827.9</td><td rowspan=1 colspan=1>40.838.0</td><td rowspan=1 colspan=1>13.617.9</td></tr></table>
+In summary, in this 300-epoch training setup, we can draw the same conclusion as the one in the 100-epoch training setup, i.e., Transformers are truly much more robust than CNNs on out-ofdistribution samples. In addition, we note this conclusion is further corroborated in concurrent works [58, 30, 50, 62, 29], where a range of additional out-of-distribution tasks/datasets are tested. We refer interested readers to their papers for details.
+# 6 Conclusion
+With the recent success of Transformer in visual recognition, researchers begin to study its robustness compared with CNNs. While recent works suggest that Transformers are much more robust than CNNs, their comparisons are not fair in many aspects, e.g., training datasets, model scales, training strategies, etc. This motivates us to provide a fair and in-depth comparisons between CNNs and Transformers, focusing on adversarial robustness and robustness on out-of-distribution samples. With our unified training setup, we found that Transformers are no more robust than CNNs on adversarial robustness. By properly adopting Transformer’s training recipes, CNNs can achieve similar robustness as Transformers on defending against both perturbation-based adversarial attacks and patch-based adversarial attacks. While regarding generalization on out-of-distribution samples (e.g., ImageNet-A, ImageNet-C and Stylized ImageNet), we find Transformer’s self-attention-like architectures is the key. We hope this work would shed lights on the understanding of Transformer, and help the community to fairly compare robustness between Transformers and CNNs.
+# Acknowledgements
+This work was partially supported by the ONR N00014-20-1-2206, ONR N00014-18-1-2119 and Institute for Assured Autonomy at JHU with Grant IAA 80052272. Cihang Xie was supported by a gift grant from Open Philanthropy.
+# References
+[1] Maksym Andriushchenko, Francesco Croce, Nicolas Flammarion, and Matthias Hein. Square attack: a query-efficient black-box adversarial attack via random search. In ECCV, 2020.
+[2] Irwan Bello, William Fedus, Xianzhi Du, Ekin D Cubuk, Aravind Srinivas, Tsung-Yi Lin, Jonathon Shlens, and Barret Zoph. Revisiting resnets: Improved training and scaling strategies. In NeurIPS, 2021.
+[3] Irwan Bello, Barret Zoph, Ashish Vaswani, Jonathon Shlens, and Quoc V Le. Attention augmented convolutional networks. In ICCV, 2019.
+[4] Srinadh Bhojanapalli, Ayan Chakrabarti, Daniel Glasner, Daliang Li, Thomas Unterthiner, and Andreas Veit. Understanding robustness of transformers for image classification. arXiv preprint arXiv:2103.14586, 2021.
+[5] Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. In NeurIPS, 2020.
+[6] Xiangning Chen, Cho-Jui Hsieh, and Boqing Gong. When vision transformers outperform resnets without pretraining or strong data augmentations. arXiv preprint arXiv:2106.01548, 2021.
+[7] Francesco Croce and Matthias Hein. Minimally distorted adversarial examples with a fast adaptive boundary attack. In ICML, 2020.
+[8] Francesco Croce and Matthias Hein. Reliable evaluation of adversarial robustness with an ensemble of diverse parameter-free attacks. In ICML, 2020.
+[9] Ekin D Cubuk, Barret Zoph, Jonathon Shlens, and Quoc V Le. Randaugment: Practical data augmentation with no separate search. In NeurIPS, 2020.
+[10] Zihang Dai, Zhilin Yang, Yiming Yang, Jaime Carbonell, Quoc V Le, and Ruslan Salakhutdinov. Transformer-xl: Attentive language models beyond a fixed-length context. In ACL, 2019.
+[11] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. In NAACL-HLT, 2019.
+[12] Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. In ICLR, 2020.
+[13] 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, 2018.
+[14] Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In ICLR, 2015.
+[15] 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.
+[16] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.
+[17] Dan Hendrycks and Thomas G Dietterich. Benchmarking neural network robustness to common corruptions and surface variations. In ICLR, 2018.
+[18] Dan Hendrycks and Kevin Gimpel. Gaussian error linear units (gelus). arXiv preprint arXiv:1606.08415, 2016.
+[19] Dan Hendrycks, Kevin Zhao, Steven Basart, Jacob Steinhardt, and Dawn Song. Natural adversarial examples. CVPR, 2021.
+[20] Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. In NeurIPS Workshop, 2015.
+[21] Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In CVPR, 2017.
+[22] Alex Krizhevsky, Ilya Sutskever, and Geoff Hinton. Imagenet classification with deep convolutional neural networks. In NeurIPS, 2012.
+[23] Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In European conference on computer vision, pages 740–755. Springer, 2014.
+[24] Hanxiao Liu, Zihang Dai, David R So, and Quoc V Le. Pay attention to mlps. arXiv preprint arXiv:2105.08050, 2021.
+[25] Liyuan Liu, Xiaodong Liu, Jianfeng Gao, Weizhu Chen, and Jiawei Han. Understanding the difficulty of training transformers. In EMNLP, 2020.
+[26] Ze Liu, Yutong Lin, Yue Cao, Han Hu, Yixuan Wei, Zheng Zhang, Stephen Lin, and Baining Guo. Swin transformer: Hierarchical vision transformer using shifted windows. In ICCV, 2021.
+[27] Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. In ICLR, 2019.
+[28] Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In ICLR, 2018.
+[29] Muzammal Naseer, Kanchana Ranasinghe, Salman Khan, Munawar Hayat, Fahad Shahbaz Khan, and Ming-Hsuan Yang. Intriguing properties of vision transformers. In NeurIPS, 2021.
+[30] Sayak Paul and Pin-Yu Chen. Vision transformers are robust learners. In AAAI, 2022.
+[31] Alec Radford, Karthik Narasimhan, Tim Salimans, and Ilya Sutskever. Improving language understanding by generative pre-training. https://s3-us-west-2.amazonaws.com/openai-assets/ research-covers/language-unsupervised/language_understanding_paper.pdf, 2018.
+[32] Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. Language models are unsupervised multitask learners. OpenAI blog, 2019.
+[33] Ilija Radosavovic, Raj Prateek Kosaraju, Ross Girshick, Kaiming He, and Piotr Dollár. Designing network design spaces. In CVPR, 2020.
+[34] Prajit Ramachandran, Niki Parmar, Ashish Vaswani, Irwan Bello, Anselm Levskaya, and Jonathon Shlens. Stand-alone self-attention in vision models. In NeurIPS, 2019.
+[35] 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. IJCV, 2015.
+[36] Ali Shafahi, Mahyar Najibi, Amin Ghiasi, Zheng Xu, John P. Dickerson, Christoph Studer, Larry S. Davis, Gavin Taylor, and Tom Goldstein. Adversarial training for free! In NeurIPS, 2019.
+[37] Rulin Shao, Zhouxing Shi, Jinfeng Yi, Pin-Yu Chen, and Cho-Jui Hsieh. On the adversarial robustness of visual transformers. arXiv preprint arXiv:2103.15670, 2021.
+[38] Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.
+[39] Chen Sun, Abhinav Shrivastava, Saurabh Singh, and Abhinav Gupta. Revisiting unreasonable effectiveness of data in deep learning era. In ICCV, 2017.
+[40] Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In CVPR, 2015.
+[41] Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In ICLR, 2014.
+[42] Ilya Tolstikhin, Neil Houlsby, Alexander Kolesnikov, Lucas Beyer, Xiaohua Zhai, Thomas Unterthiner, Jessica Yung, Daniel Keysers, Jakob Uszkoreit, Mario Lucic, et al. Mlp-mixer: An all-mlp architecture for vision. arXiv preprint arXiv:2105.01601, 2021.
+[43] Hugo Touvron, Matthieu Cord, Matthijs Douze, Francisco Massa, Alexandre Sablayrolles, and Hervé Jégou. Training data-efficient image transformers & distillation through attention. In ICML, 2021.
+[44] Hugo Touvron, Matthieu Cord, Matthijs Douze, Francisco Massa, Alexandre Sablayrolles, and Herve Jegou. Training data-efficient image transformers &amp; distillation through attention. In International Conference on Machine Learning, volume 139, pages 10347–10357, July 2021.
+[45] Hugo Touvron, Matthieu Cord, Alexandre Sablayrolles, Gabriel Synnaeve, and Hervé Jégou. Going deeper with image transformers. In ICCV, 2021.
+[46] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In NeurIPS, 2017.
+[47] Wenhai Wang, Enze Xie, Xiang Li, Deng-Ping Fan, Kaitao Song, Ding Liang, Tong Lu, Ping Luo, and Ling Shao. Pyramid vision transformer: A versatile backbone for dense prediction without convolutions. In ICCV, 2021.
+[48] Eric Wong, Leslie Rice, and J Zico Kolter. Fast is better than free: Revisiting adversarial training. In ICLR, 2020.
+[49] Cihang Xie, Mingxing Tan, Boqing Gong, Alan Yuille, and Quoc V Le. Smooth adversarial training. arXiv preprint arXiv:2006.14536, 2020.
+[50] Enze Xie, Wenhai Wang, Zhiding Yu, Anima Anandkumar, Jose M Alvarez, and Ping Luo. Segformer: Simple and efficient design for semantic segmentation with transformers. In NeurIPS, 2021.
+[51] Qizhe Xie, Eduard Hovy, Minh-Thang Luong, and Quoc Le. Self-training with noisy student improves imagenet classification. In CVPR, 2020.
+[52] Fuzhao Xue, Ziji Shi, Yuxuan Lou, Yong Liu, and Yang You. Go wider instead of deeper. arXiv preprint arXiv:2107.11817, 2021.
+[53] Chenglin Yang, Adam Kortylewski, Cihang Xie, Yinzhi Cao, and Alan Yuille. Patchattack: A black-box texture-based attack with reinforcement learning. In ECCV, 2020.
+[54] Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, and Quoc V Le. Xlnet: Generalized autoregressive pretraining for language understanding. In NeurIPS, 2019.
+[55] Li Yuan, Yunpeng Chen, Tao Wang, Weihao Yu, Yujun Shi, Zihang Jiang, Francis EH Tay, Jiashi Feng, and Shuicheng Yan. Tokens-to-token vit: Training vision transformers from scratch on imagenet. In ICCV, 2021.
+[56] Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun, Junsuk Choe, and Youngjoon Yoo. Cutmix: Regularization strategy to train strong classifiers with localizable features. In ICCV, 2019.
+[57] Xiaohua Zhai, Alexander Kolesnikov, Neil Houlsby, and Lucas Beyer. Scaling vision transformers. arXiv preprint arXiv:2106.04560, 2021.
+[58] Chongzhi Zhang, Mingyuan Zhang, Shanghang Zhang, Daisheng Jin, Qiang Zhou, Zhongang Cai, Haiyu Zhao, Shuai Yi, Xianglong Liu, and Ziwei Liu. Delving deep into the generalization of vision transformers under distribution shifts. arXiv preprint arXiv:2106.07617, 2021.
+[59] Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. In ICLR, 2018.
+[60] Hengshuang Zhao, Jiaya Jia, and Vladlen Koltun. Exploring self-attention for image recognition. In CVPR, 2020.
+[61] Bolei Zhou, Hang Zhao, Xavier Puig, Sanja Fidler, Adela Barriuso, and Antonio Torralba. Scene parsing through ade20k dataset. In CVPR, 2017.
+[62] Chen Zhu, Wei Ping, Chaowei Xiao, Mohammad Shoeybi, Tom Goldstein, Anima Anandkumar, and Bryan Catanzaro. Long-short transformer: Efficient transformers for language and vision. In NeurIPS, 2021.

parse/train/hbHkvGBZB9/hbHkvGBZB9_content_list.json ADDED Viewed

	@@ -0,0 +1,1086 @@

+[
+    {
+        "type": "text",
+        "text": "Are Transformers More Robust Than CNNs? ",
+        "text_level": 1,
+        "bbox": [
+            222,
+            122,
+            774,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yutong Bai1 Jieru Mei1 Alan Yuille1 Cihang Xie2 1Johns Hopkins University 2 University of California, Santa Cruz {ytongbai, meijieru, alan.l.yuille, cihangxie306}@gmail.com ",
+        "bbox": [
+            246,
+            195,
+            753,
+            247
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            281,
+            535,
+            297
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Transformer emerges as a powerful tool for visual recognition. In addition to demonstrating competitive performance on a broad range of visual benchmarks, recent works also argue that Transformers are much more robust than Convolutions Neural Networks (CNNs). Nonetheless, surprisingly, we find these conclusions are drawn from unfair experimental settings, where Transformers and CNNs are compared at different scales and are applied with distinct training frameworks. In this paper, we aim to provide the first fair & in-depth comparisons between Transformers and CNNs, focusing on robustness evaluations. ",
+        "bbox": [
+            232,
+            313,
+            766,
+            424
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "With our unified training setup, we first challenge the previous belief that Transformers outshine CNNs when measuring adversarial robustness. More surprisingly, we find CNNs can easily be as robust as Transformers on defending against adversarial attacks, if they properly adopt Transformers’ training recipes. While regarding generalization on out-of-distribution samples, we show pretraining on (external) large-scale datasets is not a fundamental request for enabling Transformers to achieve better performance than CNNs. Moreover, our ablations suggest such stronger generalization is largely benefited by the Transformer’s self-attention-like architectures per se, rather than by other training setups. We hope this work can help the community better understand and benchmark the robustness of Transformers and CNNs. The code and models are publicly available at https://github.com/ytongbai/ViTs-vs-CNNs. ",
+        "bbox": [
+            233,
+            425,
+            766,
+            590
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            616,
+            310,
+            632
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Convolutional Neural Networks (CNNs) have been the widely-used architecture for visual recognition in recent years [22, 38, 40, 16, 21]. It is commonly believed the key to such success is the usage of the convolutional operation, as it introduces several useful inductive biases (e.g., translation equivalence) to models for benefiting object recognition. Interestingly, recent works alternatively suggest that it is also possible to build successful recognition models without convolutions [34, 60, 3]. The most representative work in this direction is Vision Transformer (ViT) [12], which applies the pure self-attention-based architecture to sequences of images patches and attains competitive performance on the challenging ImageNet classification task [35] compared to CNNs. Later works [26, 47] further expand Transformers with compelling performance on other visual benchmarks, including COCO detection and instance segmentation [23], ADE20K semantic segmentation [61]. ",
+        "bbox": [
+            174,
+            646,
+            825,
+            785
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The dominion of CNNs on visual recognition is further challenged by the recent findings that Transformers appear to be much more robust than CNNs. For example, Shao et al. [37] observe that the usage of convolutions may introduce a negative effect on models’ adversarial robustness, while migrating to Transformer-like architectures (e.g., the Conv-Transformer hybrid model or the pure Transformer) can help secure models’ adversarial robustness. Similarly, Bhojanapalli et al. [4] report that, if pre-trained on sufficiently large datasets, Transformers exhibit considerably stronger robustness than CNNs on a spectrum of out-of-distribution tests (e.g., common image corruptions [17], texture-shape cue conflicting stimuli [13]). ",
+        "bbox": [
+            174,
+            791,
+            825,
+            902
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Though both [4] and [37] claim that Transformers are preferable to CNNs in terms of robustness, we find that such conclusion cannot be strongly drawn based on their existing experiments. Firstly, Transformers and CNNs are not compared at the same model scale, e.g., a small CNN, ResNet50 ${ \\sim } 2 5$ million parameters), by default is compared to a much larger Transformer, ViT-B ( $\\mathord { \\sim } 8 6$ million parameters), for these robustness evaluations. Secondly, the training frameworks applied to Transformers and CNNs are distinct from each other (e.g., training datasets, number of epochs, and augmentation strategies are all different), while little efforts are devoted on ablating the corresponding effects. In a nutshell, due to these inconsistent and unfair experiment settings, it remains an open question whether Transformers are truly more robust than CNNs. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            215
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To answer it, in this paper, we aim to provide the first benchmark to fairly compare Transformers to CNNs in robustness evaluations. We particularly focus on the comparisons between Small Data-efficient image Transformer (DeiT-S) [43] and ResNet-50 [16], as they have similar model capacity (i.e., ${ \\sim } 2 2$ million parameters vs. ${ \\sim } 2 5$ million parameters) and achieve similar performance on ImageNet (i.e., $7 6 . 8 \\%$ top-1 accuracy vs. $7 6 . 9 \\%$ top-1 accuracy1). Our evaluation suite accesses model robustness in two ways: 1) adversarial robustness, where the attackers can actively and aggressively manipulate inputs to approximate the worst-case scenario; 2) generalization on out-of-distribution samples, including common image corruptions (ImageNet-C [17]), texture-shape cue conflicting stimuli (Stylized-ImageNet [13]) and natural adversarial examples (ImageNet-A [19]). ",
+        "bbox": [
+            174,
+            222,
+            825,
+            347
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "With this unified training setup, we present a completely different picture from previous ones [37, 4]. Regarding adversarial robustness, we find that Transformers actually are no more robust than CNNs— if CNNs are allowed to properly adopt Transformers’ training recipes, then these two types of models will attain similar robustness on defending against both perturbation-based adversarial attacks and patch-based adversarial attacks. While for generalization on out-of-distribution samples, we find Transformers can still substantially outperform CNNs even without the needs of pre-training on sufficiently large (external) datasets. Additionally, our ablations show that adopting Transformer’s self-attention-like architecture is the key for achieving strong robustness on these out-of-distribution samples, while tuning other training setups will only yield subtle effects here. We hope this work can serve as a useful benchmark for future explorations on robustness, using different network architectures, like CNNs, Transformers, and beyond [42, 24]. ",
+        "bbox": [
+            174,
+            353,
+            825,
+            505
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Works ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            523,
+            330,
+            541
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Vision Transformer. Transformers, invented by Vaswani et al. in 2017 [46], have largely advanced the field of natural language processing (NLP). With the introduction of self-attention module, Transformer can effectively capture the non-local relationships between all input sequence elements, achieving the state-of-the-art performance on numerous NLP tasks [54, 10, 5, 11, 31, 32]. ",
+        "bbox": [
+            174,
+            555,
+            825,
+            611
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The success of Transformer on NLP also starts to get witnessed in computer vision. The pioneering work, ViT [12], demonstrates that the pure Transformer architectures are able to achieve exciting results on several visual benchmarks, especially when extremely large datasets (e.g., JFT-300M [39]) are available for pre-training. This work is then subsequently improved by carefully curating the training pipeline and the distillation strategy to Transformers [43], enhancing the Transformers’ tokenization module [55], building multi-resolution feature maps on Transformers [26, 47], designing parameter-efficient Transformers for scaling [57, 45, 52], etc. In this work, rather than focusing on furthering Transformers on standard visual benchmarks, we aim to provide a fair and comprehensive study of their performance when testing out of the box. ",
+        "bbox": [
+            174,
+            616,
+            825,
+            742
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Robustness Evaluations. Conventional learning paradigm assumes training data and testing data are drawn from the same distribution. This assumption generally does not hold, especially in the real-world case where the underlying distribution is too complicated to be covered in a (limitedsized) dataset. To properly access model performance in the wild, a set of robustness generalization benchmarks have been built, e.g., ImageNet-C [17], Stylized-ImageNet [13], ImageNet-A [19], etc. Another standard surrogate for testing model robustness is via adversarial attacks, where the attackers deliberately add small perturbations or patches to input images, for approximating the worst-case evaluation scenario [41, 14]. In this work, both robustness generalization and adversarial robustness are considered in our robustness evaluation suite. ",
+        "bbox": [
+            174,
+            753,
+            825,
+            877
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Concurrent to ours, both Bhojanapalli et al. [4] and Shao et al. [37] conduct robustness comparisons between Transformers and CNNs. Nonetheless, we find their experimental settings are unfair, e.g., models are compared at different capacity [4, 37] or are trained under distinct frameworks [37]. In this work, our comparison carefully align the model capacity and the training setups, which draws completely different conclusions from the previous ones. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            161
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Settings ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            179,
+            271,
+            196
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Training CNNs and Transformers ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            209,
+            447,
+            224
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Convolutional Neural Networks. ResNet [16] is a milestone architecture in the history of CNN. We choose its most popular instantiation, ResNet-50 (with ${ \\sim } 2 5 $ million parameters), as the default CNN architecture. To train CNNs on ImageNet, we follow the standard recipe of [15, 33]. Specifically, we train all CNNs for a total of 100 epochs, using momentum-SGD optimizer; we set the initial learning rate to 0.1, and decrease the learning rate by $1 0 \\times$ at the 30-th, 60-th, and 90-th epoch; no regularization except weight decay is applied. ",
+        "bbox": [
+            174,
+            234,
+            825,
+            319
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Vision Transformer. ViT [12] successfully introduces Transformers from natural language processing to computer vision, achieving excellent performance on several visual benchmarks compared to CNNs. In this paper, we follow the training recipe of DeiT [43], which successfully trains ViT on ImageNet without any external data, and set DeiT-S (with ${ \\sim } 2 2$ million parameters) as the default Transformer architecture. Specifically, we train all Transformers using AdamW optimizer [27]; we set the initial learning rate to 5e-4, and apply the cosine learning rate scheduler to decrease it; besides weight decay, we additionally adopt three data augmentation strategies (i.e., RandAug [9], MixUp [59] and CutMix [56]) to regularize training (otherwise DeiT-S will attain significantly lower ImageNet accuracy due to overfitting [6]). ",
+        "bbox": [
+            174,
+            329,
+            825,
+            455
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Note that different from the standard recipe of DeiT (which applies 300 training epochs by default), we hereby train Transformers only for a total of 100 epochs, i.e., same as the setup in ResNet. We also remove {Erasing, Stochastic Depth, Repeated Augmentation}, which were applied in the original DeiT framework, in this basic 100 epoch schedule, for preventing over-regularization in training. Such trained DeiT-S yields $7 6 . 8 \\%$ top-1 ImageNet accuracy, which is similar to the ResNet-50’s performance $7 6 . 9 \\%$ top-1 ImageNet accuracy). ",
+        "bbox": [
+            174,
+            460,
+            825,
+            545
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 Robustness Evaluations ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            559,
+            377,
+            574
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our experiments mainly consider two types of robustness here, i.e., robustness on adversarial examples and robustness on out-of-distribution samples. ",
+        "bbox": [
+            176,
+            585,
+            823,
+            613
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Adversarial Examples, which are crafted by adding human-imperceptible perturbations or smallsized patches to images, can lead deep neural networks to make wrong predictions. In addition to the very popular PGD attack [28], our robustness evaluation suite also contains: A) AutoAttack [8], which is an ensemble of diverse attacks (i.e., two variants of PGD attack, FAB attack [7] and Square Attack [1]) and is parameter-free; and B) Texture Patch Attack (TPA) [53], which uses a predefined texture dictionary of patches to fool deep neural networks. ",
+        "bbox": [
+            174,
+            619,
+            825,
+            703
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Recently, several benchmarks of out-of-distribution samples have been proposed to evaluate how deep neural networks perform when testing out of the box. Particularly, our robustness evaluation suite contains three such benchmarks: A) ImageNet-A [19], which are real-world images but are collected from challenging recognition scenarios (e.g., occlusion, fog scene); B) ImageNet-C [17], which is designed for measuring model robustness against 75 distinct common image corruptions; and C) Stylized-ImageNet [13], which creates texture-shape cue conflicting stimuli by removing local texture cues from images while retaining their global shape information. ",
+        "bbox": [
+            174,
+            709,
+            825,
+            806
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 Adversarial Robustness ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            825,
+            403,
+            842
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we investigate the robustness of Transformers and CNNs on defending against adversarial attacks, using ImageNet validation set (with 50,000 images). We consider both perturbation-based attacks (i.e., PGD and AutoAttack) and patch-based attacks (i.e., TPA) for robustness evaluations. ",
+        "bbox": [
+            174,
+            856,
+            823,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4.1 Robustness to Perturbation-Based Attacks ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            508,
+            106
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Following [37], we first report the robustness of ResNet-50 and DeiT-S on defending against AutoAttack. We verify that, when applying with a small perturbation radius $\\epsilon = 0 . 0 0 1$ , DeiT-S indeed achieves higher robustness than ResNet-50, i.e., $2 2 . 1 \\%$ vs. $1 7 . 8 \\%$ as shown in Table 1. ",
+        "bbox": [
+            174,
+            116,
+            825,
+            159
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "However, when increasing the perturbation radius to 4/255, a more challenging but standard case studied in previous works [36, 48, 49], both models will be circumvented completely, i.e., $0 \\%$ robustness on defending against AutoAttack. This is mainly due to that both models are not adversarially trained [14, 28], which is an effective way to secure model robustness against adversarial attacks, and we will study it next. ",
+        "bbox": [
+            174,
+            164,
+            825,
+            234
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/d43c582ff004a64ddbe8cb8df890479bcbd71f9638a197648860070ecd8b11f2.jpg",
+        "table_caption": [
+            "Table 1: Performance of ResNet-50 and DeiT-S on defending against AutoAttack, using ImageNet validation set. We note both models are completely broken when setting perturbation radius to 4/255. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td rowspan=\"2\">Clean</td><td colspan=\"2\">Perturbation Radius</td></tr><tr><td>0.001</td><td>4/255</td></tr><tr><td>ResNet-50</td><td>76.9</td><td>17.8</td><td>0.0</td></tr><tr><td>DeiT-S</td><td>76.8</td><td>22.1</td><td>0.0</td></tr></table>",
+        "bbox": [
+            357,
+            284,
+            633,
+            338
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1.1 Adversarial Training ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            358,
+            372,
+            375
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Adversarial training [14, 28], which trains models with adversarial examples that are generated on-the-fly, aims to optimize the following min-max framework: ",
+        "bbox": [
+            173,
+            382,
+            823,
+            411
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/db31db9ceb554ac2996f5289630b74228306f5627c8ab939bff4727f81134199.jpg",
+        "text": "$$\n\\underset { \\theta } { \\arg \\operatorname* { m i n } } \\mathbb { E } _ { ( x , y ) \\sim \\mathbb { D } } \\Big [ \\underset { \\epsilon \\in \\mathbb { S } } { \\operatorname* { m a x } } L ( \\theta , x + \\epsilon , y ) \\Big ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            415,
+            629,
+            444
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbb { D }$ is the underlying data distribution, $L ( \\cdot , \\cdot , \\cdot )$ is the loss function, $\\theta$ is the network parameter, $x$ is a training sample with the ground-truth label $y , \\epsilon$ is the added adversarial perturbation, and $\\mathbb { S }$ is the allowed perturbation range. Following [51, 48], the adversarial training here applies single-step PGD (PGD-1) to generate adversarial examples (for lowering training cost), with the constrain that maximum per-pixel change $\\epsilon = 4 / 2 5 5$ . ",
+        "bbox": [
+            173,
+            449,
+            825,
+            520
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Adversarial Training on Transformers. We apply the setup above to adversarially train both ResNet-50 and DeiT-S. However, surprisingly, this default setup works for ResNet-50 but will collapse the training with DeiT-S, i.e., the robustness of such trained DeiT-S is merely ${ \\sim } 4 \\%$ when evaluating against PGD-5. We identify the issue is over-regularization—when combining strong data augmentation strategies (i.e., RangAug, Mixup and CutMix) with adversarial attacks, the yielded training samples are too hard to be learnt by DeiT-S. ",
+        "bbox": [
+            174,
+            530,
+            825,
+            614
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/a2f799125ca6f7dbb0833cd607301c9f054edae0c4dd865ac2a4577d18566455.jpg",
+        "image_caption": [
+            "Figure 1: The illustration of the proposed augmentation warm-up strategy. At the beginning of adversarial training (from epoch ${ } = 0$ to epoch $^ { - 9 }$ ), we progressively increase the augmentation strength. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            230,
+            633,
+            772,
+            786
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To ease this observed training difficulty, we design a curriculum of the applied augmentation strategies. Specifically, as shown in Figure 1, at the first 10 epoch, we progressively enhance the augmentation strength (e.g., gradually changing the distortion magnitudes in RandAug from 1 to 9) to warmup the training process. Our experiment verifies this curriculum enables a successful adversarial training—DeiT-S now attains ${ \\sim } 4 4 \\%$ robustness (boosted from ${ \\sim } 4 \\%$ ) on defending against PGD-5. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Transformers with CNNs’ Training Recipes. Interestingly, an alternative way to address the observed training difficulty is directly adopting CNN’s recipes to train Transformers [37], i.e., applying M-SGD with step decay learning rate scheduler and removing strong data augmentation strategies (like Mixup). Though this setup can stabilize the adversarial training process, it significantly hurts the overall performance of DeiT-S—the clean accuracy drops to $5 9 . 9 \\%$ $( \\mathbf { - 6 . 6 \\% } )$ , and the robustness on defending against PGD-100 drops to $3 1 . 9 \\%$ $( - 8 . 4 \\% )$ . ",
+        "bbox": [
+            174,
+            90,
+            825,
+            174
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "One reason for this degenerated performance is that strong data augmentation strategies are not included in CNNs’ recipes, therefore Transformers will be easily overfitted during training [6]. Another key factor here is the incompatibility between the SGD optimizer and Transformers. As explained in [25], compared to SGD, adaptive optimizers (like AdamW) are capable of assigning different learning rates to different parameters, resulting in consistent update magnitudes even with unbalanced gradients. This property is crucial for enabling successful training of Transformers, given the gradients of attention modules are highly unbalanced. ",
+        "bbox": [
+            174,
+            181,
+            825,
+            279
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "CNNs with Transformers’ Training Recipes. As shown in Table 2, adversarially trained ResNet50 is less robust than adversarially trained DeiT-S, i.e., $3 2 . 2 6 \\%$ vs. $4 0 . 3 2 \\%$ on defending against PGD-100. It motivates us to explore whether adopting Transformers’ training recipes to CNNs can enhance CNNs’ adversarial training. Interestingly, if we directly apply AdamW to ResNet-50, the adversarial training will collapses. We also explore the possibility of adversarially training ResNet-50 with strong data augmentation strategies (i.e., RandAug, Mixup and CutMix). However, we find ResNet-50 will be overly regularized in adversarial training, leading to very unstable training process, sometimes may even collapse completely. ",
+        "bbox": [
+            173,
+            290,
+            825,
+            401
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Though Transformers’ optimizer and augmentation strategies cannot improve CNNs’ adversarial training, we find Transformers’ choice of activation functions matters. Unlike the widely-used activation function in CNNs is ReLU, Transformers by default use GELU [18]. As suggested in [49], ReLU significantly weakens adversarial training due to its non-smooth nature; replacing ReLU with its smooth approximations (e.g., GELU, SoftPlus) can strengthen adversarial training. We verify that by replacing ReLU with Transformers’ activation function (i.e., GELU) in ResNet-50. As shown in Table 2, adversarial training now can be significantly enhanced, i.e., ResNet- $5 0 +$ GELU substantially outperforms its ReLU counterpart by $8 . 0 1 \\%$ on defending against PGD-100. Moreover, we note the usage of GELU enables ResNet-50 to match DeiT-S in adversarial robustness, i.e., $4 0 . 2 7 \\%$ vs. $4 0 . 3 2 \\%$ for defending against PGD-100, and $3 5 . 5 1 \\%$ vs. $3 5 . 5 0 \\%$ for defending against AutoAttack, challenging the previous conclusions [4, 37] that Transformers are more robust than CNNs on defending against adversarial attacks. ",
+        "bbox": [
+            173,
+            407,
+            825,
+            574
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/f19e50212d836e039da67d0767a11489fcf05ae7fe367afd8c7692f8e286c031.jpg",
+        "table_caption": [
+            "Table 2: The performance of ResNet-50 and DeiT-S on defending against adversarial attacks (with $\\epsilon = 4$ ). After replacing ReLU with DeiT’s activation function GELU in ResNet-50, its robustness can match the robustness of DeiT-S. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Activation</td><td rowspan=1 colspan=1>Clean Acc</td><td rowspan=1 colspan=1>PGD-5</td><td rowspan=1 colspan=1>PGD-10</td><td rowspan=1 colspan=1>PGD-50</td><td rowspan=1 colspan=1>PGD-100</td><td rowspan=1 colspan=1>AutoAttack</td></tr><tr><td rowspan=1 colspan=1>ResNet-50</td><td rowspan=1 colspan=1>ReLUGELU</td><td rowspan=1 colspan=1>66.7767.38</td><td rowspan=1 colspan=1>38.7044.01</td><td rowspan=1 colspan=1>34.1940.98</td><td rowspan=1 colspan=1>32.4740.28</td><td rowspan=1 colspan=1>32.2640.27</td><td rowspan=1 colspan=1>26.4135.51</td></tr><tr><td rowspan=1 colspan=1>DeiT-S</td><td rowspan=1 colspan=1>GELU</td><td rowspan=1 colspan=1>66.50</td><td rowspan=1 colspan=1>43.95</td><td rowspan=1 colspan=1>41.03</td><td rowspan=1 colspan=1>40.34</td><td rowspan=1 colspan=1>40.32</td><td rowspan=1 colspan=1>35.50</td></tr></table>",
+        "bbox": [
+            228,
+            633,
+            764,
+            689
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 Robustness to Patch-Based Attacks ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            713,
+            457,
+            728
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We next study the robustness of CNNs and Transformers on defending against patch-based attacks. We choose Texture Patch Attack (TPA) [53] as the attacker. Note that different from typical patchbased attacks which apply monochrome patches, TPA additionally optimizes the pattern of the patches to enhance attack strength. By default, we set the number of attacking patches to 4, limit the largest manipulated area to $10 \\%$ of the whole image area, and set the attack mode as the non-targeted attack. For ResNet-50 and DeiT-S, we do not consider adversarial training here as their vanilla counterparts already demonstrate non-trivial performance on defending against TPA. ",
+        "bbox": [
+            173,
+            739,
+            826,
+            837
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/2655b69773e2a5664901a61d41b23fc7b32a513ef5a7305acd7a08a57ffece18.jpg",
+        "table_caption": [
+            "Table 3: Performance of ResNet-50 and DeiT-S on defending against Texture Patch Attack. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Architecture</td><td>Clean Acc</td><td>TexturePatchAttack</td></tr><tr><td>ResNet-50</td><td>76.9</td><td>19.7</td></tr><tr><td>DeiT-S</td><td>76.8</td><td>47.7</td></tr></table>",
+        "bbox": [
+            351,
+            867,
+            642,
+            909
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Interestingly, as shown in Table 3, though both models attain similar clean image accuracy, DeiT-S substantially outperforms ResNet-50 by $28 \\%$ on defending against TPA. We conjecture such huge performance gap is originated from the differences in training setups; more specifically, it may be resulted by the fact DeiT-S by default use strong data augmentation strategies while ResNet-50 use none of them. The augmentation strategies like CutMix already naïvely introduce occlusion or image/patch mixing during training, therefore are potentially helpful for securing model robustness against patch-based adversarial attacks. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            188
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To verify the hypothesis above, we next ablate how strong augmentation strategies in DeiT-S (i.e., RandAug, Mixup and CutMix) affect ResNet-50’s robustness. We report the results in Table 4. Firstly, we note all augmentation strategies can help ResNet-50 achieve stronger TPA robustness, with improvements ranging from $+ 4 . 6 \\%$ to $+ 3 2 . 7 \\%$ . Among all these augmentation strategies, CutMix stands as the most effective one to secure model’s TPA robustness, i.e., CutMix alone can improve TPA robustness by $2 9 . 4 \\%$ . Our best model is obtained by using both CutMix and RandAug, reporting $5 2 . 4 \\%$ TPA robustness, which is even stronger than DeiT-S ( $4 7 . 7 \\%$ TPA robustness). This observation still holds by using stronger TPA with 10 patches (increased from 4), i.e., ResNet-50 now attains $3 4 . 5 \\%$ TPA robustness, outperforming DeiT-S by $5 . 6 \\%$ . These results suggest that Transformers are also no more robust than CNNs on defending against patch-based adversarial attacks. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            333
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/2f8a97b610ceaec731d23ea0aeb59133329b8a0a27d8232f401fe6024cc844f5.jpg",
+        "table_caption": [
+            "Table 4: Performance of ResNet-50 trained with different augmentation strategies on defending against Texture Patch Attack. We note 1) all augmentation strategies can improve model robustness, and 2) CutMix is the most effective augmentation strategy to secure model robustness. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"3\">Augmentations</td><td rowspan=\"2\">Clean Acc</td><td rowspan=\"2\">Texture Patch Attack</td></tr><tr><td>RandAug</td><td>MixUp</td><td>CutMix</td></tr><tr><td>X</td><td>×</td><td>×</td><td>76.9</td><td>19.7</td></tr><tr><td>√</td><td>X</td><td>×</td><td>77.5</td><td>24.3 (+4.6)</td></tr><tr><td>X</td><td>√</td><td>X</td><td>75.9</td><td>31.5 (+11.8)</td></tr><tr><td>X</td><td>X</td><td>√</td><td>77.2</td><td>49.1 (+29.4)</td></tr><tr><td>√</td><td>√</td><td>X</td><td>75.7</td><td>31.7 (+12.0)</td></tr><tr><td>√</td><td>×</td><td>√</td><td>76.7</td><td>52.4 (+32.7)</td></tr><tr><td>X</td><td>√</td><td>！</td><td>77.1</td><td>39.8 (+20.1)</td></tr><tr><td>√</td><td>√</td><td>√</td><td>76.4</td><td>48.6 (+28.9)</td></tr></table>",
+        "bbox": [
+            305,
+            392,
+            687,
+            523
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 Robustness on Out-of-distribution Samples ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            542,
+            565,
+            561
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In addition to adversarial robustness, we are also interested in comparing the robustness of CNNs and Transformers on out-of-distribution samples. We hereby select three datasets, i.e., ImageNet-A, ImageNet-C and Stylized ImageNet, to capture the different aspects of out-of-distribution robustness. ",
+        "bbox": [
+            174,
+            574,
+            826,
+            616
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 Aligning Training Recipes ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            631,
+            395,
+            647
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We first provide a direct comparison between ResNet-50 and DeiT-S with their default training setup. As shown in Table 5, we observe that, even without pretraining on (external) large scale datasets, DeiT-S still significantly outperforms ResNet-50 on ImageNet-A $( + 9 . 0 \\% )$ , ImageNet-C $( + 9 . 9 )$ and Stylized-ImageNet $( + 4 . 7 \\% )$ . It is possible that such performance gap is caused by the differences in training recipes (similar to the situation we observed in Section 4), which we plan to ablate next. ",
+        "bbox": [
+            173,
+            656,
+            826,
+            727
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/277d471717dcda06f68a967a27f469d0afc347499e3cc94d6add4806be899754.jpg",
+        "table_caption": [
+            "Table 5: DeiT-S shows stronger robustness generalization than ResNet-50 on ImageNet-C, ImageNetA and Stylized-ImageNet. Note the results on ImageNet-C is measured by mCE (lower is better). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Architecture</td><td>ImageNet个</td><td>ImageNet-A↑</td><td>ImageNet-C</td><td>Stylized-ImageNet↑</td></tr><tr><td>ResNet-50</td><td>76.9</td><td>3.2</td><td>57.9</td><td>8.3</td></tr><tr><td>ResNet-50*</td><td>76.3</td><td>4.5</td><td>55.6</td><td>8.2</td></tr><tr><td>DeiT-S</td><td>76.8</td><td>12.2</td><td>48.0</td><td>13.0</td></tr></table>",
+        "bbox": [
+            251,
+            771,
+            738,
+            827
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A fully aligned version. A simple baseline here is that we completely adopt the recipes of DeiT-S to train ResNet-50, denoted as ResNet- $5 0 ^ { \\ast }$ . Specifically, this ResNet- ${ } . 5 0 ^ { * }$ will be trained with AdamW optimizer, cosine learning rate scheduler and strong data augmentation strategies. Nonetheless, as reported in Table 5, ResNet- ${ } . 5 0 ^ { * }$ only marginally improves ResNet-50 on ImageNet-A $( + 1 . 3 \\% )$ and ImageNet-C $( + 2 . 3 )$ , which is still much worse than DeiT-S on robustness generalization. ",
+        "bbox": [
+            173,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "It is possible that completely adopting the recipes of DeiT-S overly regularizes the training of ResNet50, leading to suboptimal performance. To this end, we next seek to discover the “best” setups to train ResNet-50, by ablating learning rate scheduler (step decay vs. cosine decay), optimizer (M-SGD vs. AdamW) and augmentation strategies (RandAug, Mixup and CutMix) progressively. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Step 1: aligning learning rate scheduler. It is known that switching learning rate scheduler from step decay to cosine decay improves model accuracy on clean images [2]. We additionally verify that such trained ResNet-50 (second row in Table 6) attains slightly better performance on ImageNet-A $( + 0 . 1 \\% )$ , ImageNet-C $( + 1 . 0 )$ and Stylized-ImageNet $( + 0 . 1 \\% )$ . Given the improvements here, we will use cosine decay by default for later ResNet training. ",
+        "bbox": [
+            173,
+            159,
+            825,
+            228
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Step 2: aligning optimizer. We next ablate the effects of optimizers. As shown in the third row in Table 6, switching optimizer from M-SGD to AdamW weakens ResNet training, i.e., it not only decreases ResNet-50’s accuracy on ImageNet $( - 1 . 0 \\% )$ , but also hurts ResNet-50’s robustness generalization on ImageNet-A $( - 0 . 2 \\% )$ , ImageNet-C (-2.4) and Stylized-ImageNet $( - 0 . 3 \\% )$ . Given this degenerated performance, we stick to M-SGD for later ResNet-training. ",
+        "bbox": [
+            173,
+            239,
+            825,
+            309
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/9511ce6f04e766e91e350c50f299f43eb9818bbb75cec3912f99e97ac7f1a6e6.jpg",
+        "table_caption": [
+            "Table 6: The robustness generalization of ResNet-50 trained with different learning rate schedulers and optimizers. Nonetheless, compared to DeiT-S, all the resulted ResNet-50 show worse generalization on out-of-distribution samples. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Optimizer-LR Scheduler</td><td>ImageNet 个</td><td>ImageNet-A↑</td><td>ImageNet-C</td><td>Stylized-ImageNet↑</td></tr><tr><td rowspan=\"2\">ResNet-50</td><td>SGD-Step</td><td>76.9</td><td>3.2</td><td>57.9</td><td>8.3</td></tr><tr><td>SGD-Cosine</td><td>77.4</td><td>3.3</td><td>56.9</td><td>8.4</td></tr><tr><td>DeiT-S</td><td>AdamW-Cosine</td><td>76.4</td><td>3.1</td><td>59.3</td><td>8.1</td></tr><tr><td></td><td>AdamW-Cosine</td><td>76.8</td><td>12.2</td><td>48.0</td><td>13.0</td></tr></table>",
+        "bbox": [
+            178,
+            371,
+            813,
+            439
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Step 3: aligning augmentation strategies. Compared to ResNet-50, DeiT-S additionally applied RandAug, Mixup and CutMix to augment training data. We hereby examine whether these augmentation strategies affect robustness generalization. The performance of ResNet-50 trained with different combinations of augmentation strategies is reported in Table 7. Compared to the vanilla counterpart, nearly all the combinations of augmentation strategies can improve ResNet-50’s generalization on out-of-distribution samples. The best performance is achieved by using RandAug $^ +$ Mixup, outperforming the vanilla ResNet-50 by $3 . 0 \\%$ on ImageNet-A, 4.6 on ImageNet-C and $2 . 4 \\%$ on Stylized-ImageNet. ",
+        "bbox": [
+            173,
+            454,
+            825,
+            566
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/fb6d3a5a7be3436a78a3a8b3a0895bd8e7c4039d3e832f88a5e554d61716b84b.jpg",
+        "table_caption": [
+            "Table 7: The robustness generalization of ResNet-50 trained with different combinations of augmentation strategies. We note applying RandAug $^ +$ Mixup yields the best ResNet-50 on out-ofdistribution samples; nonetheless, DeiT-S still significantly outperforms such trained ResNet-50. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Architecture</td><td colspan=\"2\">Augmentation Strategies</td><td rowspan=\"2\">ImageNet ↑</td><td rowspan=\"2\">ImageNet-A ↑</td><td rowspan=\"2\">ImageNet-C</td><td rowspan=\"2\">Stylized-ImageNet↑</td></tr><tr><td>RandAug MixUp</td><td>CutMix</td></tr><tr><td rowspan=\"4\">ResNet-50</td><td>X X</td><td>X</td><td>77.4</td><td>3.3</td><td>56.9</td><td>8.4</td></tr><tr><td>√ √</td><td>X</td><td>75.7</td><td>6.3</td><td>52.3</td><td>10.8</td></tr><tr><td>√</td><td>X 公</td><td>76.7</td><td>6.3</td><td>56.3</td><td>7.1</td></tr><tr><td>×</td><td>√</td><td>77.1</td><td>6.1</td><td>55.1</td><td>8.8</td></tr><tr><td></td><td>√</td><td>√ √</td><td>76.4</td><td>5.5</td><td>54.0</td><td>9.1</td></tr><tr><td>DeiT-S</td><td>√</td><td>√ √</td><td>76.8</td><td>12.2</td><td>48.0</td><td>13.0</td></tr></table>",
+        "bbox": [
+            173,
+            628,
+            830,
+            734
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Comparing ResNet with the “best” training recipes to DeiT-S. With the ablations above, we can conclude that the “best” training recipes for ResNet-50 (denoted as ResNet-50-Best) is by applying M-SGD optimizer, scheduling learning rate using cosine decay, and augmenting training data using RandAug and Mixup. As shown in the second row of Table 7, ResNet-50-Best attains $6 . 3 \\%$ accuracy on ImageNet-A, $5 2 . 3 \\mathrm { m C E }$ on ImageNet-C and $1 0 . 8 \\%$ accuracy on Stylized-ImageNet. ",
+        "bbox": [
+            173,
+            751,
+            825,
+            821
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Nonetheless, interestingly, we note DeiT-S still shows much stronger robustness generalization on out-of-distribution samples than our “best” ResNet-50, i.e., $+ 5 . 9 \\%$ on ImageNet-A, $+ 4 . 3$ on ImageNet-C and $+ 2 . 2 \\%$ on Stylized-ImageNet. These results suggest that the differences in training recipes (including the choice of optimizer, learning rate scheduler and augmentation strategies) is not the key for leading the observed huge performance gap between CNNs and Transformers on out-of-distribution samples. ",
+        "bbox": [
+            174,
+            827,
+            823,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Model size. To further validate that Transformers are indeed more robust than CNNs on out-ofdistribution samples, we hereby extend the comparisons above to other model sizes. Specifically, we consider the comparison at a smaller scale, i.e. ResNet-18 ( ${ \\sim } 1 2$ million parameters) vs. DeiTMini ${ \\sim } 1 0$ million parameters, with embedding dimension $= 2 5 6$ and number of head $= 4$ ). For ResNet training, we consider both the fully aligned recipe version (denoted as ResNet\\*) and the “best” recipe version (denoted as ResNet-Best). Figure 2 shows the main results. Similar to the comparison between ResNet-50 and DeiT-S, DeiT-Mini also demonstrates much stronger robustness generalization than ResNet- $. 1 8 ^ { * }$ and ResNet-18-Best. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            202
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We next study DeiT and ResNet at a more challenging setting—comparing DeiT to a much larger ResNet on robustness generalization. Surprisingly, we note in both cases, DeiT-Mini vs. ResNet-50 and DeiT-S vs. ResNet-101, DeiTs are able to show similar, sometimes even superior, performance than ResNets. For example, DeiT-S beats the nearly $2 \\times$ larger ResNet- $1 0 1 ^ { \\ast }$ ${ \\sim } 2 2$ million parameters vs. ${ \\sim } 4 5$ million parameters) by $3 . 3 7 \\%$ on ImageNet-A, 1.20 on ImageNet-C and $1 . 3 8 \\%$ on StylizedImageNet. All these results further corroborate that Transformers are much more robust than CNNs on out-of-distribution samples. ",
+        "bbox": [
+            173,
+            208,
+            825,
+            306
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/bf4d39032ccfa302941ff1a4cbed3b351becccb56bcd88acbc853ff679346427.jpg",
+        "image_caption": [
+            "Figure 2: By comparing models at different scales, DeiT consistently outperforms ResNet\\* and ResNet-Best by a large margin on ImageNet-A, ImageNet-C and Stylized-ImageNet. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            321,
+            820,
+            477
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 Distillation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            536,
+            289,
+            551
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we make another attempt to bridge the robustness generalization gap between CNNs and Transformers—we apply knowledge distillation to let ResNet-50 (student model) directly learn from DeiT-S (teacher model). Specifically, we perform soft distillation [20], which minimizes the Kullback-Leibler divergence between the softmax of the teacher model and the softmax of the student model; we adopt the training recipe of DeiT during distillation. ",
+        "bbox": [
+            174,
+            561,
+            825,
+            632
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Main results. We report the distillation results in Table 8. Though both models attain similar clean image accuracy, the student model ResNet-50 shows much worse robustness generalization than the teacher model DeiT-S, i.e., the performance is decreased by $7 . 0 \\%$ on ImageNet-A, 6.2 on ImageNet-C and $3 . 2 \\%$ on Stylized-ImageNet. This observation is counter-intuitive as student models typically achieve higher performance than teacher models in knowledge distillation. ",
+        "bbox": [
+            174,
+            642,
+            825,
+            713
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "However, interestingly, if we switch the roles of DeiT-S and ResNet-50, the student model DeiT-S is able to significantly outperforms the teacher model ResNet-50 on out-of-distribution samples. As shown in the third row and the fourth row in Table 8, the improvements are $6 . 4 \\%$ on ImageNet-A, 6.3 on ImageNet-C and $3 . 7 \\%$ on Stylized-ImageNet. These results arguably suggest that the strong generalization robustness of DeiT is rooted in the architecture design of Transformer that cannot be transferred to ResNet via neither training setups or knowledge distillation. ",
+        "bbox": [
+            173,
+            718,
+            825,
+            803
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/e5ea68fbd40aabc191f218202f701feca7de3bb6075ef2c22dc95789a6a78c01.jpg",
+        "table_caption": [
+            "Table 8: The robustness generalization of ResNet-50, DeiT-S and their distilled models. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Distillation</td><td>Architecture</td><td>ImageNet</td><td>ImageNet-A 个</td><td>ImageNet-C</td><td>Stylized-ImageNet个</td></tr><tr><td>Teacher</td><td>DeiT-S</td><td>76.8</td><td>12.2</td><td>48.0</td><td>13.0</td></tr><tr><td>Student Teacher</td><td>ResNet-50*-Distill ResNet-50*</td><td>76.7 76.3</td><td>5.2 (-7.0) 4.5</td><td>54.2 (+6.2) 55.6</td><td>9.8 (-3.2) 8.2</td></tr><tr><td>Student</td><td>DeiT-S-Distill</td><td>76.2</td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td>10.9 (+6.4)</td><td>49.3 (-6.3)</td><td>11.9 (+3.7)</td></tr></table>",
+        "bbox": [
+            197,
+            833,
+            797,
+            902
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 Hybrid Architecture ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            354,
+            106
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Following the discussion in Section 5.2, we hereby ablate whether incorporating Transformer’s self-attention-like architecture into model design can help robustness generalization. Specifically, we create a hybrid architecture (named Hybrid-DeiT) by directly feeding the output of res_4 block in ResNet-18 into DeiT-Mini, and compare its robustness generalization to ResNet-50 and DeiT-Small. Note that under this setting, these three models are at the same scale, i.e., hybrid-DeiT ( ${ \\sim } 2 1$ million parameters) vs. ResNet-50 ( ${ \\sim } 2 5$ million parameters) vs. DeiT-S ${ \\sim } 2 2$ million parameters). We apply the recipe of DeiT to train these three models. ",
+        "bbox": [
+            173,
+            116,
+            826,
+            214
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Main results. We report the robustness generalization of these three models in Figure 3. Interestingly, with the introduction of Transformer blocks, Hybrid-DeiT is able to achieve better robustness generalization than ResNet-50, i.e., $+ 1 . 1 \\%$ on ImageNet-A and $+ 2 . 5 \\%$ on Stylized-ImageNet, suggesting Transformer’s self-attention-like architectures is essential for boosting performance on out-of-distribution samples. We additionally compare this hybrid architecture to the pure Transformer architecture. As expected, Hybrid-DeiT attains lower robustness generalization than DeiT-S, as shown in Figure 3. ",
+        "bbox": [
+            173,
+            224,
+            826,
+            323
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/47be14ef538bca69f32ca448f05e8b70af8abee7ace8f7a694c64624869f6146.jpg",
+        "image_caption": [
+            "Figure 3: The robustness generalization of ResNet-50, DeiT-S and Hybrid-DeiT. We note introducing Transformer blocks into model design benefits generalization on out-of-distribution samples. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            340,
+            823,
+            492
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.4 300-Epoch Training ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            546,
+            352,
+            561
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As mentioned in Section 3.1, we by default train all models for only 100 epochs. This is a standard setup in training CNNs [15, 33], but not typical in training Transformers [44, 26]. To rule out the possibility of introducing negative effects in shortening training length, we lastly ablate the 300-epoch setup, i.e., we directly borrow the default setup in [44] to train both ResNet and DeiT. ",
+        "bbox": [
+            173,
+            571,
+            825,
+            627
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As reported in Table 9, DeiT-S substantially outperforms ResNet-50 by $1 0 . 4 \\%$ on ImageNet-A, 7.5 on ImageNet-C and 5.6 on Stylized-ImageNet. Nonetheless, we argue that such comparison is less interesting and even unfair—DeiT-S already beats ResNet-50 by $1 . 8 \\%$ on ImageNet classification, therefore it is expected that DeiT-S will also show stronger performance than ResNet-50 on ImageNetA, ImageNet-C and Stylized-ImageNet. ",
+        "bbox": [
+            173,
+            633,
+            825,
+            704
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/0b79ae59399fe647049796f94885b5e82eca486dcdb9a9c2becb9fd502ce0152.jpg",
+        "table_caption": [
+            "Table 9: The robustness generalization of ResNet-50 and DeiT-S under the 300-epoch training setup. We note DeiT-S shows stronger performance than ResNet-50 on both clean images and out-of-distribution samples. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Architecture</td><td>ImageNet↑</td><td>ImageNet-A↑</td><td>ImageNet-C</td><td>Stylized-ImageNet↑</td></tr><tr><td>ResNet-50</td><td>78.1</td><td>8.8</td><td>50.3</td><td>9.5</td></tr><tr><td>DeiT-S</td><td>79.9</td><td>19.2</td><td>42.8</td><td>15.1</td></tr></table>",
+        "bbox": [
+            251,
+            761,
+            738,
+            803
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To make the setup fairer (i.e., comparing the robustness of models that have similar accuracy), we now compare DeiT-S to the much larger ResNet-101 (i.e., ${ \\sim } 2 2$ million parameters vs. ${ \\sim } 4 5$ million parameters). The results are shown in Table 10. We observer that though both models achieve similar accuracy on ImageNet, DeiT-S demonstrates much stronger robustness generalization than ResNet-101. This observation can also holds for bigger Transformers and CNNs, e.g., DeiT-B can consistently outperforms ResNet-200 on ImageNet-A, ImageNet-C and Stylized- ImageNet, despite they attain similar clean image accuracy (i.e., $8 1 . 8 \\%$ vs. $8 2 . 1 \\%$ ). ",
+        "bbox": [
+            173,
+            814,
+            825,
+            912
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/f7038a116790f402f939a7f0376325bcabbff7b4cf4239f993616ade27e0352b.jpg",
+        "table_caption": [
+            "Table 10: The robustness generalization of ResNet and DeiT under the 300-epoch training setup. Though both models attain similar clean image accuracy, DeiTs show much stronger robustness generalization than ResNets. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Architecture</td><td rowspan=1 colspan=1>ImageNet个</td><td rowspan=1 colspan=1>ImageNet-A↑</td><td rowspan=1 colspan=1>ImageNet-C↓</td><td rowspan=1 colspan=1>Stylized-ImageNet个</td></tr><tr><td rowspan=1 colspan=1>ResNet-101DeiT-S</td><td rowspan=1 colspan=1>80.279.9</td><td rowspan=1 colspan=1>17.619.2</td><td rowspan=1 colspan=1>45.842.8</td><td rowspan=1 colspan=1>11.915.1</td></tr><tr><td rowspan=1 colspan=1>ResNet-200DeiT-B</td><td rowspan=1 colspan=1>82.181.8</td><td rowspan=1 colspan=1>23.827.9</td><td rowspan=1 colspan=1>40.838.0</td><td rowspan=1 colspan=1>13.617.9</td></tr></table>",
+        "bbox": [
+            251,
+            140,
+            740,
+            208
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In summary, in this 300-epoch training setup, we can draw the same conclusion as the one in the 100-epoch training setup, i.e., Transformers are truly much more robust than CNNs on out-ofdistribution samples. In addition, we note this conclusion is further corroborated in concurrent works [58, 30, 50, 62, 29], where a range of additional out-of-distribution tasks/datasets are tested. We refer interested readers to their papers for details. ",
+        "bbox": [
+            173,
+            223,
+            826,
+            292
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            311,
+            299,
+            329
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "With the recent success of Transformer in visual recognition, researchers begin to study its robustness compared with CNNs. While recent works suggest that Transformers are much more robust than CNNs, their comparisons are not fair in many aspects, e.g., training datasets, model scales, training strategies, etc. This motivates us to provide a fair and in-depth comparisons between CNNs and Transformers, focusing on adversarial robustness and robustness on out-of-distribution samples. With our unified training setup, we found that Transformers are no more robust than CNNs on adversarial robustness. By properly adopting Transformer’s training recipes, CNNs can achieve similar robustness as Transformers on defending against both perturbation-based adversarial attacks and patch-based adversarial attacks. While regarding generalization on out-of-distribution samples (e.g., ImageNet-A, ImageNet-C and Stylized ImageNet), we find Transformer’s self-attention-like architectures is the key. We hope this work would shed lights on the understanding of Transformer, and help the community to fairly compare robustness between Transformers and CNNs. ",
+        "bbox": [
+            173,
+            343,
+            826,
+            510
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            530,
+            338,
+            546
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work was partially supported by the ONR N00014-20-1-2206, ONR N00014-18-1-2119 and Institute for Assured Autonomy at JHU with Grant IAA 80052272. Cihang Xie was supported by a gift grant from Open Philanthropy. ",
+        "bbox": [
+            176,
+            560,
+            825,
+            603
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            622,
+            266,
+            637
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] Maksym Andriushchenko, Francesco Croce, Nicolas Flammarion, and Matthias Hein. Square attack: a query-efficient black-box adversarial attack via random search. In ECCV, 2020.   \n[2] Irwan Bello, William Fedus, Xianzhi Du, Ekin D Cubuk, Aravind Srinivas, Tsung-Yi Lin, Jonathon Shlens, and Barret Zoph. Revisiting resnets: Improved training and scaling strategies. In NeurIPS, 2021.   \n[3] Irwan Bello, Barret Zoph, Ashish Vaswani, Jonathon Shlens, and Quoc V Le. Attention augmented convolutional networks. In ICCV, 2019.   \n[4] Srinadh Bhojanapalli, Ayan Chakrabarti, Daniel Glasner, Daliang Li, Thomas Unterthiner, and Andreas Veit. Understanding robustness of transformers for image classification. arXiv preprint arXiv:2103.14586, 2021.   \n[5] Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. In NeurIPS, 2020.   \n[6] Xiangning Chen, Cho-Jui Hsieh, and Boqing Gong. When vision transformers outperform resnets without pretraining or strong data augmentations. arXiv preprint arXiv:2106.01548, 2021.   \n[7] Francesco Croce and Matthias Hein. Minimally distorted adversarial examples with a fast adaptive boundary attack. In ICML, 2020.   \n[8] Francesco Croce and Matthias Hein. Reliable evaluation of adversarial robustness with an ensemble of diverse parameter-free attacks. In ICML, 2020.   \n[9] Ekin D Cubuk, Barret Zoph, Jonathon Shlens, and Quoc V Le. Randaugment: Practical data augmentation with no separate search. In NeurIPS, 2020.   \n[10] Zihang Dai, Zhilin Yang, Yiming Yang, Jaime Carbonell, Quoc V Le, and Ruslan Salakhutdinov. Transformer-xl: Attentive language models beyond a fixed-length context. In ACL, 2019.   \n[11] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. In NAACL-HLT, 2019.   \n[12] Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. In ICLR, 2020.   \n[13] 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, 2018.   \n[14] Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In ICLR, 2015.   \n[15] 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.   \n[16] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.   \n[17] Dan Hendrycks and Thomas G Dietterich. Benchmarking neural network robustness to common corruptions and surface variations. In ICLR, 2018.   \n[18] Dan Hendrycks and Kevin Gimpel. Gaussian error linear units (gelus). arXiv preprint arXiv:1606.08415, 2016.   \n[19] Dan Hendrycks, Kevin Zhao, Steven Basart, Jacob Steinhardt, and Dawn Song. Natural adversarial examples. CVPR, 2021.   \n[20] Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. In NeurIPS Workshop, 2015.   \n[21] Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In CVPR, 2017.   \n[22] Alex Krizhevsky, Ilya Sutskever, and Geoff Hinton. Imagenet classification with deep convolutional neural networks. In NeurIPS, 2012.   \n[23] Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In European conference on computer vision, pages 740–755. Springer, 2014.   \n[24] Hanxiao Liu, Zihang Dai, David R So, and Quoc V Le. Pay attention to mlps. arXiv preprint arXiv:2105.08050, 2021.   \n[25] Liyuan Liu, Xiaodong Liu, Jianfeng Gao, Weizhu Chen, and Jiawei Han. Understanding the difficulty of training transformers. In EMNLP, 2020.   \n[26] Ze Liu, Yutong Lin, Yue Cao, Han Hu, Yixuan Wei, Zheng Zhang, Stephen Lin, and Baining Guo. Swin transformer: Hierarchical vision transformer using shifted windows. In ICCV, 2021.   \n[27] Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. In ICLR, 2019.   \n[28] Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In ICLR, 2018.   \n[29] Muzammal Naseer, Kanchana Ranasinghe, Salman Khan, Munawar Hayat, Fahad Shahbaz Khan, and Ming-Hsuan Yang. Intriguing properties of vision transformers. In NeurIPS, 2021.   \n[30] Sayak Paul and Pin-Yu Chen. Vision transformers are robust learners. In AAAI, 2022.   \n[31] Alec Radford, Karthik Narasimhan, Tim Salimans, and Ilya Sutskever. Improving language understanding by generative pre-training. https://s3-us-west-2.amazonaws.com/openai-assets/ research-covers/language-unsupervised/language_understanding_paper.pdf, 2018.   \n[32] Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. Language models are unsupervised multitask learners. OpenAI blog, 2019.   \n[33] Ilija Radosavovic, Raj Prateek Kosaraju, Ross Girshick, Kaiming He, and Piotr Dollár. Designing network design spaces. In CVPR, 2020.   \n[34] Prajit Ramachandran, Niki Parmar, Ashish Vaswani, Irwan Bello, Anselm Levskaya, and Jonathon Shlens. Stand-alone self-attention in vision models. In NeurIPS, 2019.   \n[35] 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. IJCV, 2015.   \n[36] Ali Shafahi, Mahyar Najibi, Amin Ghiasi, Zheng Xu, John P. Dickerson, Christoph Studer, Larry S. Davis, Gavin Taylor, and Tom Goldstein. Adversarial training for free! In NeurIPS, 2019.   \n[37] Rulin Shao, Zhouxing Shi, Jinfeng Yi, Pin-Yu Chen, and Cho-Jui Hsieh. On the adversarial robustness of visual transformers. arXiv preprint arXiv:2103.15670, 2021.   \n[38] Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.   \n[39] Chen Sun, Abhinav Shrivastava, Saurabh Singh, and Abhinav Gupta. Revisiting unreasonable effectiveness of data in deep learning era. In ICCV, 2017.   \n[40] Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In CVPR, 2015.   \n[41] Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In ICLR, 2014.   \n[42] Ilya Tolstikhin, Neil Houlsby, Alexander Kolesnikov, Lucas Beyer, Xiaohua Zhai, Thomas Unterthiner, Jessica Yung, Daniel Keysers, Jakob Uszkoreit, Mario Lucic, et al. Mlp-mixer: An all-mlp architecture for vision. arXiv preprint arXiv:2105.01601, 2021.   \n[43] Hugo Touvron, Matthieu Cord, Matthijs Douze, Francisco Massa, Alexandre Sablayrolles, and Hervé Jégou. Training data-efficient image transformers & distillation through attention. In ICML, 2021.   \n[44] Hugo Touvron, Matthieu Cord, Matthijs Douze, Francisco Massa, Alexandre Sablayrolles, and Herve Jegou. Training data-efficient image transformers &amp; distillation through attention. In International Conference on Machine Learning, volume 139, pages 10347–10357, July 2021.   \n[45] Hugo Touvron, Matthieu Cord, Alexandre Sablayrolles, Gabriel Synnaeve, and Hervé Jégou. Going deeper with image transformers. In ICCV, 2021.   \n[46] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In NeurIPS, 2017.   \n[47] Wenhai Wang, Enze Xie, Xiang Li, Deng-Ping Fan, Kaitao Song, Ding Liang, Tong Lu, Ping Luo, and Ling Shao. Pyramid vision transformer: A versatile backbone for dense prediction without convolutions. In ICCV, 2021.   \n[48] Eric Wong, Leslie Rice, and J Zico Kolter. Fast is better than free: Revisiting adversarial training. In ICLR, 2020.   \n[49] Cihang Xie, Mingxing Tan, Boqing Gong, Alan Yuille, and Quoc V Le. Smooth adversarial training. arXiv preprint arXiv:2006.14536, 2020.   \n[50] Enze Xie, Wenhai Wang, Zhiding Yu, Anima Anandkumar, Jose M Alvarez, and Ping Luo. Segformer: Simple and efficient design for semantic segmentation with transformers. In NeurIPS, 2021.   \n[51] Qizhe Xie, Eduard Hovy, Minh-Thang Luong, and Quoc Le. Self-training with noisy student improves imagenet classification. In CVPR, 2020.   \n[52] Fuzhao Xue, Ziji Shi, Yuxuan Lou, Yong Liu, and Yang You. Go wider instead of deeper. arXiv preprint arXiv:2107.11817, 2021.   \n[53] Chenglin Yang, Adam Kortylewski, Cihang Xie, Yinzhi Cao, and Alan Yuille. Patchattack: A black-box texture-based attack with reinforcement learning. In ECCV, 2020.   \n[54] Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, and Quoc V Le. Xlnet: Generalized autoregressive pretraining for language understanding. In NeurIPS, 2019.   \n[55] Li Yuan, Yunpeng Chen, Tao Wang, Weihao Yu, Yujun Shi, Zihang Jiang, Francis EH Tay, Jiashi Feng, and Shuicheng Yan. Tokens-to-token vit: Training vision transformers from scratch on imagenet. In ICCV, 2021.   \n[56] Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun, Junsuk Choe, and Youngjoon Yoo. Cutmix: Regularization strategy to train strong classifiers with localizable features. In ICCV, 2019.   \n[57] Xiaohua Zhai, Alexander Kolesnikov, Neil Houlsby, and Lucas Beyer. Scaling vision transformers. arXiv preprint arXiv:2106.04560, 2021.   \n[58] Chongzhi Zhang, Mingyuan Zhang, Shanghang Zhang, Daisheng Jin, Qiang Zhou, Zhongang Cai, Haiyu Zhao, Shuai Yi, Xianglong Liu, and Ziwei Liu. Delving deep into the generalization of vision transformers under distribution shifts. arXiv preprint arXiv:2106.07617, 2021.   \n[59] Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. In ICLR, 2018.   \n[60] Hengshuang Zhao, Jiaya Jia, and Vladlen Koltun. Exploring self-attention for image recognition. In CVPR, 2020.   \n[61] Bolei Zhou, Hang Zhao, Xavier Puig, Sanja Fidler, Adela Barriuso, and Antonio Torralba. Scene parsing through ade20k dataset. In CVPR, 2017.   \n[62] Chen Zhu, Wei Ping, Chaowei Xiao, Mohammad Shoeybi, Tom Goldstein, Anima Anandkumar, and Bryan Catanzaro. Long-short transformer: Efficient transformers for language and vision. In NeurIPS, 2021. ",
+        "bbox": [
+            179,
+            643,
+            828,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            75,
+            828,
+            917
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            68,
+            828,
+            920
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            828,
+            463
+        ],
+        "page_idx": 12
+    }
+]

parse/train/hbHkvGBZB9/hbHkvGBZB9_model.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/rJzIBfZAb/rJzIBfZAb.md ADDED Viewed

	@@ -0,0 +1,398 @@

+# TOWARDS DEEP LEARNING MODELS RESISTANT TO ADVERSARIAL ATTACKS
+Aleksander M ˛adry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, Adrian Vladu∗
+Department of Electrical Engineering and Computer Science
+Massachusetts Institute of Technology
+Cambridge, MA 02139, USA
+{madry,amakelov,ludwigs,tsipras,avladu}@mit.ed
+# ABSTRACT
+Recent work has demonstrated that neural networks are vulnerable to adversarial examples, i.e., inputs that are almost indistinguishable from natural data and yet classified incorrectly by the network. To address this problem, we study the adversarial robustness of neural networks through the lens of robust optimization. This approach provides us with a broad and unifying view on much prior work on this topic. Its principled nature also enables us to identify methods for both training and attacking neural networks that are reliable and, in a certain sense, universal. In particular, they specify a concrete security guarantee that would protect against a well-defined class of adversaries. These methods let us train networks with significantly improved resistance to a wide range of adversarial attacks. They also suggest robustness against a first-order adversary as a natural security guarantee. We believe that robustness against such well-defined classes of adversaries is an important stepping stone towards fully resistant deep learning models.
+# 1 INTRODUCTION
+Recent breakthroughs in computer vision and speech recognition are bringing trained classifiers into the center of security-critical systems. Important examples include vision for autonomous cars, face recognition, and malware detection. These developments make security aspects of machine learning increasingly important. In particular, resistance to adversarially chosen inputs is becoming a crucial design goal. While trained models tend to be very effective in classifying benign inputs, recent work (Dalvi et al., 2004; Szegedy et al., 2013; Goodfellow et al., 2014; Nguyen et al., 2015; Sharif et al., 2016) shows that an adversary is often able to manipulate the input so that the model produces an incorrect output.
+This phenomenon has received particular attention in the context of deep neural networks, and there is now a quickly growing body of work on this topic (Fawzi et al., 2015; Kurakin et al., 2016; Papernot & McDaniel, 2016; Rozsa et al., 2016; Torkamani, 2016; Sokolic et al., 2016; Tramèr et al., 2017b). Computer vision presents a particularly striking challenge: very small changes to the input image can fool state-of-the-art neural networks with high probability (Szegedy et al., 2013; Goodfellow et al., 2014; Nguyen et al., 2015; Sharif et al., 2016; Moosavi-Dezfooli et al., 2016). This holds even when the benign example was classified correctly, and the change is imperceptible to a human. Apart from the security implications, this phenomenon also demonstrates that our current models are not learning the underlying concepts in a robust manner. All these findings raise a fundamental question:
+# How can we learn models robust to adversarial inputs?
+There are now many proposed defense mechanisms for the adversarial setting. Examples include defensive distillation (Papernot et al., 2016a; Papernot & McDaniel, 2016), feature squeezing (Xu et al., 2017), and several detection approaches for adversarial inputs (see Carlini & Wagner (2017) for references). While these works constitute important first steps in exploring the realm of possibilities, they do not offer a good understanding of the guarantees they provide. We can never be certain that a particular defense mechanism prevents the existence of some well-defined class of adversarial attacks. This makes it difficult to navigate the landscape of adversarial robustness or to fully evaluate the possible security implications. Moreover, subsequent work (Carlini & Wagner, 2016a; He et al., 2017) has shown that most of these defenses can be bypassed by stronger, adaptive adversaries.
+In this paper, we study the adversarial robustness of neural networks through the lens of robust optimization. We use a natural saddle point (min-max) formulation to capture the notion of security against adversarial attacks in a principled manner. This formulation allows us to be precise about the type of security guarantee we would like to achieve, i.e., the broad class of attacks we want to be resistant to (in contrast to defending only against specific known attacks). The formulation also enables us to cast both attacks and defenses into a common theoretical framework. Most prior work on adversarial examples naturally fits into this framework. In particular, adversarial training directly corresponds to optimizing this saddle point problem. Similarly, prior methods for attacking neural networks correspond to specific algorithms for solving the underlying optimization problem.
+Equipped with this perspective, we make the following contributions.
+1. We conduct a careful experimental study of the optimization landscape corresponding to this saddle point formulation. Despite the non-convexity and non-concavity of its constituent parts, we find that the underlying optimization problem is tractable after all. In particular, we provide strong evidence that first-order methods can reliably solve this problem and motivate projected gradient descent (PGD) as a universal “first-order adversary”, i.e., the strongest attack utilizing the local first order information about the network. We supplement these insights with ideas from real analysis to further motivate adversarial training against a PGD adversary as a strong and natural defense.
+2. We explore the impact of network architecture on adversarial robustness and find that model capacity plays an important role. To reliably withstand strong adversarial attacks, networks require a significantly larger capacity than for correctly classifying benign examples only. This shows that a robust decision boundary of the saddle point problem can be significantly more complicated than a decision boundary that simply separates the benign data points.
+3. Building on the above insights, we train networks on MNIST and CIFAR10 that are robust to a wide range of adversarial attacks against adversaries bounded by 0.3 and 8 in $\ell _ { \infty }$ norm respectively. Our approach is based on optimizing the aforementioned saddle point formulation and uses our optimal “first-order adversary”. Our best MNIST model achieves an accuracy of more than $89 \%$ against the strongest adversaries in our test suite. In particular, our MNIST network is even robust against white box attacks of an iterative adversary. Our CIFAR10 model achieves an accuracy of $46 \%$ against the same adversary. Furthermore, in case of the weaker black box (transfer) attacks, our MNIST and CIFAR10 networks achieve an accuracy of more than $9 5 \%$ and $64 \%$ , respectively (a more detailed overview can be found in Tables 1 and 2). To the best of our knowledge, we are the first to achieve these levels of robustness on MNIST and CIFAR10 against a broad set of attacks.
+Overall, these findings suggest that secure neural networks are within reach. In order to further support this claim, we have invited the community to attempt attacks against our MNIST and CIFAR10 networks in the form of an open challenge1,2. At the time of writing, we received about fifteen submissions to the MNIST challenge and the best submission achieved roughly $93 \%$ accuracy in a black box attack. We received no submissions for the CIFAR10 challenge that went beyond the $64 \%$ accuracy of our attack. Considering that other proposed defenses were often quickly broken (Carlini & Wagner, 2017), we believe that our robust models are significant progress on the defense side. Furthermore, recent work (Carlini et al., 2017) on verifiable adversarial examples showed that our proposed defense reliably increased the robustness to any $\ell _ { \infty }$ -bounded attack.
+# 2 AN OPTIMIZATION VIEW ON ADVERSARIAL ROBUSTNESS
+Much of our discussion will revolve around an optimization view of adversarial robustness. This perspective not only captures the phenomena we want to study in a precise manner, but will also inform our investigations. To this end, let us consider a standard classification task with an underlying data distribution $\mathcal { D }$ over pairs of examples $\boldsymbol { x } \in \mathbb { R } ^ { d }$ and corresponding labels $y \in [ k ]$ . We also assume that we are given a suitable loss function $L ( \theta , x , y )$ , for instance the cross-entropy loss for a neural network. As usual, $\theta \in \mathbb { R } ^ { p }$ is the set of model parameters. Our goal then is to find model parameters $\theta$ that minimize the risk $\mathbb { E } _ { ( x , y ) \sim \mathcal { D } } [ L ( x , y , \theta ) ]$ .
+Empirical risk minimization (ERM) has been tremendously successful as a recipe for finding classifiers with small population risk. Unfortunately, ERM often does not yield models that are robust to adversarially crafted examples (Goodfellow et al., 2014; Kurakin et al., 2016; Moosavi-Dezfooli et al., 2016; Tramèr et al., 2017b). Formally, there are efficient algorithms (“adversaries”) that take an example $x$ belonging to class $c _ { 1 }$ as input and find examples $x ^ { \mathrm { a d v } }$ such that $x ^ { \mathrm { a d v } }$ is very close to $x$ but the model incorrectly classifies $x ^ { \mathrm { a d v } }$ as belonging to class $c _ { 2 } \neq c _ { 1 }$ .
+In order to reliably train models that are robust to adversarial attacks, it is necessary to augment the ERM paradigm. Instead of resorting to methods that directly focus on improving the robustness to specific attacks, our approach is to first propose a concrete guarantee that an adversarially robust model should satisfy. We then adapt our training methods towards achieving this guarantee.
+The first step towards such a guarantee is to specify an threat model, i.e., a precise definition of the attacks our models should be resistant to. For each data point $x$ , we introduce a set of allowed perturbations $S \subseteq \mathbb { R } ^ { d }$ that formalizes the manipulative power of the adversary. In image classification, we choose $s$ so that it captures perceptual similarity between images. For instance, the $\ell _ { \infty }$ -ball around $x$ has recently been studied as a natural notion for adversarial perturbations (Goodfellow et al., 2014). While we focus on robustness against $\ell _ { \infty }$ -bounded attacks in this paper, we remark that more comprehensive notions of perceptual similarity are an important direction for future research.
+Next, we modify the definition of population risk $\mathbb { E } _ { \mathcal { D } } [ L ]$ by incorporating the above adversary. Instead of computing the loss $L$ directly on samples from the distribution $\mathcal { D }$ , we allow the adversary to perturb the input first. This gives rise to the following saddle point problem, which is our central object of study:
+$$
+\operatorname* { m i n } _ { \theta } \rho ( \theta ) , \quad \mathrm { w h e r e } \quad \rho ( \theta ) = \mathbb { E } _ { ( x , y ) \sim \mathcal { D } } \left[ \operatorname* { m a x } _ { \delta \in \mathcal { S } } L ( \theta , x + \delta , y ) \right] \ .
+$$
+Formulations of this type (and their finite-sample counterparts) have a long history in robust optimization, going back to Wald (Wald, 1939; 1945; 1992). It turns out that this formulation is also particularly useful in our context. We will refer to the quantity $\rho ( \theta )$ as the adversarial loss of the network with parameters $\theta$ .
+First, this formulation gives us a unifying perspective that encompasses much prior work on adversarial robustness. Our perspective stems from viewing the saddle point problem as the composition of an inner maximization problem and an outer minimization problem. Both of these problems have a natural interpretation in our context. The inner maximization problem aims to find an adversarial version of a given data point $x$ that achieves a high loss. This is precisely the problem of attacking a given neural network. On the other hand, the goal of the outer minimization problem is to find model parameters so that the adversarial loss given by the inner attack problem is minimized. This is precisely the problem of training a robust classifier using adversarial training techniques.
+Second, the saddle point problem specifies a clear goal that a robust classifier should achieve, as well as a quantitative measure of its robustness. In particular, when the parameters $\theta$ yield a (nearly) vanishing risk, the corresponding model is perfectly robust to attacks specified by our threat model.
+Our paper investigates the structure of this saddle point problem in the context of deep neural networks. This formulation will be the main drive of our investigations that will lead us to training techniques that produce models with high resistance to a wide range of adversarial attacks.
+# 3 TOWARDS ADVERSARIALLY ROBUST NETWORKS
+Current work on adversarial examples usually focuses on specific defensive mechanisms, or on attacks against such defenses. An important feature of formulation (2.1) is that attaining small adversarial loss gives a guarantee that no allowed attack will fool the network. By definition, no adversarial perturbations are possible because the loss is small for all perturbations allowed by our threat model. This perspective allows us to reduce the task of finding truly robust models to an optimization problem. Hence, we can now focus our attention solely on obtaining a good solution to Problem (2.1).
+Gradients from attacks. Since Stochastic Gradient Descent (SGD) and its variants are by far the most successful algorithms for training neural networks, we also want to apply SGD to Problem (2.1). This raises the question how we can compute gradients $\nabla _ { \boldsymbol { \theta } } \rho ( \boldsymbol { \theta } )$ for the outer minimization problem. Since the adversarial loss function $\rho ( \theta )$ corresponds to a maximization problem, we cannot simply apply the usual backpropagation algorithm. Instead, a natural approach is to compute the gradient at the maximizer of the inner maximization problem. A priori, it is not clear that this is a valid descent direction for the saddle point problem. However, for the case of continuously differentiable functions, Danskin’s theorem – a classic theorem in optimization – states that this is indeed true and gradients at maximizers of the inner problem correspond to descent directions for the saddle point problem (see Appendix C for details).
+Leveraging this connection, our goal now is to find a reliable algorithm for solving the inner maximization problem, i.e., to evaluate $\rho ( \theta )$ . When instantiated for a batch of examples (instead of the expectation over the entire distribution $\mathcal { D }$ ), finding a maximizer $\delta \in S$ of $\rho ( \theta )$ corresponds exactly to finding an attack on the neural network. This allows us to employ known attacks as inner maximization algorithms. Prior work has proposed methods such as the Fast Gradient Sign Method (FGSM) and multiple variations of it (Goodfellow et al., 2014). FGSM is an attack for an $\ell _ { \infty }$ -bounded adversary and computes an adversarial example as
+$$
+x + \varepsilon \operatorname { s g n } ( \nabla _ { x } L ( \theta , x , y ) ) .
+$$
+One can interpret this attack as a simple one-step scheme for maximizing the inner part of the saddle point formulation. A more powerful adversary is the multi-step variant $\bar { \mathrm { F G S M } } ^ { k }$ , which is essentially projected gradient descent (PGD) on the negative loss function (Kurakin et al., 2016):3
+$$
+x ^ { t + 1 } = \operatorname { P r o j } _ { x + S } \left( x ^ { t } + \alpha \operatorname { s g n } ( \nabla _ { x ^ { t } } L ( \theta , x ^ { t } , y ) ) \right) .
+$$
+Loss landscape. While PGD is a well-motivated approach for the inner maximization problem, it is not clear whether we can actually find a good solution in a reasonable amount of time. The problem is non-concave, so a priori we have no guarantees on the solution quality of PGD. One of our contributions is demonstrating that, in practice, the inner maximization problem is indeed well-behaved. In particular, we experimentally explore the structure given by the non-concave inner problem and find that its loss landscape has a surprisingly tractable structure of local maxima (see Appendix A). This structure also points towards projected gradient descent as the “ultimate” first-order adversary (see Section 5).
+Despite the fact that the exact assumptions of Danskin’s theorem do not hold for our problem (the function is not continuously differentiable due to ReLU activations, and we only compute approximate maximizers of the inner problem), our experiments suggest that we can still use these gradients to optimize our problem. By applying SGD using the gradient of the loss at adversarial examples, we can consistently reduce the loss of the saddle point problem during training (e.g., see Figure 1 in Section 4). These observations suggest that we reliably optimize the saddle point formulation (2.1) and thus train robust classifiers.
+Model capacity. Before we proceed to our main experiment results in the next section, we briefly mention another important insight from our robust optimization perspective. Solving the problem from Equation (2.1) successfully is not sufficient to guarantee robust and accurate classification. We also require that the value of the problem (i.e., the final loss we achieve against adversarial examples) is small, which then provides guarantees for the performance of our classifier. In particular, achieving a very small value corresponds to a perfect classifier, which is robust to adversarial inputs. In Appendix B, we show experimentally that network capacity plays a crucial role in enabling robustness. In particular, training a robust classifier requires a significantly larger network than only achieving high accuracy on natural examples.
+# 4 EXPERIMENTS: ADVERSARIALLY ROBUST DEEP LEARNING MODELS?
+Following our understanding developed in the previous section, we can now apply our proposed approach to train robust classifiers. For both MNIST and CIFAR10, our adversary of choice will be projected gradient descent starting from a random perturbation around the natural example. As our experiments suggest (Appendix A) this algorithm is very efficient at reliably producing examples of (near) maximal loss. In a sense, it seems to correspond to a “ultimate” f irst order adversary. Since we are training the model for multiple epochs, we did not see any benefit in restarting PGD multiple times per batch – a new start is chosen each time the same example is encountered.
+During the training procedure against the PGD adversary, we observe a steady decrease in the training loss of adversarial examples, illustrated in Figure 1. This behavior indicates that we are consistently decreasing the adversarial loss and indeed successfully solving our original optimization problem.
+![](images/a075c178644df2c3ad6a5cfe992d76e6f74b9a58bbe31a5587d4350e584ff0f1.jpg)
+Figure 1: Cross-entropy loss on adversarial examples during training. The plots show how the adversarial loss on training examples evolves during training the MNIST and CIFAR10 networks against a PGD adversary. The sharp drops in the CIFAR10 plot correspond to decreases in training learning rate. These plots illustrate that we can consistently reduce the value of the inner problem of the saddle point formulation (2.1), thus producing an increasingly robust classifier.
+We evaluate the trained models against a range of adversaries. We illustrate our results in Table 1 for MNIST and Table 2 for CIFAR10. The adversaries we consider are:
+• White-box attacks with PGD for a different number of of iterations and restarts, denoted by source A.
+White-box attacks from Carlini & Wagner (2016b). We use their suggested loss function and minimize it using PGD. This is denoted as CW, where the corresponding attack with a high confidence parameter $\kappa = 5 0$ ) is denoted as $\mathrm { C W } +$ .
+• Black-box attacks from an independently trained copy of the network, denoted A’.
+• Black-box attacks from a version of the same network trained only on natural examples, denoted $A _ { n a t }$ .
+• Black-box attacks from a different convolution architecture, denoted B, described in Tramèr et al. (2017a).
+MNIST. We run 40 iterations of projected gradient descent as our adversary, with a step size of 0.01 (we choose to take gradient steps in the $\ell _ { \infty }$ norm, i.e. adding the sign of the gradient, since this makes the choice of the step size simpler). We train and evaluate against perturbations of size $\varepsilon = 0 . 3$ We use a network consisting of two convolutional layers with 32 and 64 filters respectively, each followed by $2 \times 2$ max-pooling, and a fully connected layer of size 1024. When trained with natural examples, this network reaches $9 9 . 2 \%$ accuracy on the evaluation set. However, when evaluating on examples perturbed with FGSM the accuracy drops to $6 . 4 \%$ . Given that the resulting MNIST model is very robust, we investigated the learned parameters in order to understand how they affect adversarial robustness. The results of the investigation are presented in Appendix E.
+CIFAR10. For the CIFAR10 dataset, we use the two architectures described in $\mathbf { B }$ (the original Resnet and its $1 0 \times$ wider variant). We trained the network against a PGD adversary with $\ell _ { \infty }$ projected
+Table 1: MNIST: Performance of the adversarially trained network against different adversaries for $\varepsilon = 0 . 3$ . For each model of attack we show the most successful attack with bold. The source networks used for the attack are: the network itself (A) (white-box attack), an indepentenly initialized and trained copy of the network (A’), architecture B from Tramèr et al. (2017a) (B).
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>Steps</td><td rowspan=1 colspan=1>Restarts</td><td rowspan=1 colspan=1>Source</td><td rowspan=1 colspan=1>Accuracy</td></tr><tr><td rowspan=1 colspan=1>Natural</td><td rowspan=1 colspan=1>二</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>98.8%</td></tr><tr><td rowspan=1 colspan=1>FGSM</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>95.6%</td></tr><tr><td rowspan=1 colspan=1>PGD</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>93.2%</td></tr><tr><td rowspan=1 colspan=1>PGD</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>91.8%</td></tr><tr><td rowspan=1 colspan=1>PGD</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>90.4%</td></tr><tr><td rowspan=1 colspan=1>PGD</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>89.3%</td></tr><tr><td rowspan=1 colspan=1>Targeted</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>92.7%</td></tr><tr><td rowspan=1 colspan=1>CW</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>94.0%</td></tr><tr><td rowspan=1 colspan=1>CW+</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>93.9%</td></tr><tr><td rowspan=1 colspan=1>FGSM</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>96.8%</td></tr><tr><td rowspan=1 colspan=1>PGD</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>96.0%</td></tr><tr><td rowspan=1 colspan=1>PGD</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>95.7%</td></tr><tr><td rowspan=1 colspan=1>CW</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>97.0%</td></tr><tr><td rowspan=1 colspan=1>CW+</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>96.4%</td></tr><tr><td rowspan=1 colspan=1>FGSM</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>B</td><td rowspan=1 colspan=1>95.4%</td></tr><tr><td rowspan=1 colspan=1>PGD</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>B</td><td rowspan=1 colspan=1>96.4%</td></tr><tr><td rowspan=1 colspan=1>CW+</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>B</td><td rowspan=1 colspan=1>95.7%</td></tr></table>
+gradient descent again, this time using 7 steps of size 2, and a total $\varepsilon = 8$ . For our hardest adversary we chose 20 steps with the same settings, since other hyperparameter choices didn’t offer a significant decrease in accuracy. The results of our experiments appear in Table 2. The adversarial robustness of our network is significant, given the power of iterative adversaries, but still far from satisfactory. We believe that further progress is possible along these lines by understanding how adversarial training works and what techniques can complement it leading to robust models.
+Table 2: CIFAR10: Performance of the adversarially trained network against different adversaries for $\varepsilon = 8$ . For each model of attack we show the most effective attack in bold. The source networks considered for the attack are: the network itself (A) (white-box attack), an independtly initialized and trained copy of the network (A’), a copy of the network trained on natural examples $( \mathrm { A } _ { n a t } )$ .
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>Steps</td><td rowspan=1 colspan=1>Source</td><td rowspan=1 colspan=1>Accuracy</td></tr><tr><td rowspan=1 colspan=1>Natural</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>87.3%</td></tr><tr><td rowspan=1 colspan=1>FGSM</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>56.1%</td></tr><tr><td rowspan=1 colspan=1>PGD</td><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>50.0%</td></tr><tr><td rowspan=1 colspan=1>PGD</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>45.8%</td></tr><tr><td rowspan=1 colspan=1>CW</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>46.8%</td></tr><tr><td rowspan=1 colspan=1>FGSM</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>67.0%</td></tr><tr><td rowspan=1 colspan=1>PGD</td><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>64.2%</td></tr><tr><td rowspan=1 colspan=1>CW</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>78.7%</td></tr><tr><td rowspan=1 colspan=1>FGSM</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>Anat</td><td rowspan=1 colspan=1>85.6%</td></tr><tr><td rowspan=1 colspan=1>PGD</td><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>Anat</td><td rowspan=1 colspan=1>86.0%</td></tr></table>
+Resistance for different values of $\varepsilon$ and $\ell _ { 2 }$ -bounded attacks. In order to perform a broader evaluation of the adversarial robustness of our models, we run two kinds of additional experiments. On one hand, we investigate the resistance to $\ell _ { \infty }$ -bounded attacks for different values of $\varepsilon$ . On the other hand, we examine the resistance of our model to attacks that are bounded in $\ell _ { 2 }$ as opposed to $\ell _ { \infty }$ norm. The results appear in Figure 2. We emphasize that the models we are examining here correspond to training against $\ell _ { \infty }$ -bounded attacks with the original value of $\varepsilon = 0 . 3$ , for
+MNIST, and $\varepsilon = 8$ for CIFAR10. In particular, our MNIST model retains significant resistance to $\ell _ { 2 }$ -norm-bounded perturbations too – it has good accuracy even for $\varepsilon = 4 . 5 . \mathrm { W e }$ provide a sample of corresponding adversarial examples in Figure 12 of Appendix F. One can observe that some of the underlying perturbations are large enough that even a human could be confused.
+Training Accuracy. It is worth noting our MNIST and (wide) CIFAR10 networks reached $100 \%$ adversarial accuracy on the training set. That is we can fit the training set even against a PGD adversary of $\varepsilon = 0 . 3$ and $\varepsilon = 8$ respectively. This shows that the landscape of the underlying optimization problem is tractable and does not present a significant barrier to our techniques.
+![](images/3124475d5dd1494654fc4f747dacac62694871f28f9e36a1a8919210c5f08c89.jpg)
+Figure 2: Performance of our adversarially trained networks against PGD adversaries of different strength. The MNIST and CIFAR10 networks were trained against $\varepsilon = 0 . 3$ and $\varepsilon = 8$ PGD $\ell _ { \infty }$ adversaries respectively (the training $\varepsilon$ is denoted with a red dashed lines in the $\ell _ { \infty }$ plots). We notice that for $\varepsilon$ less or equal to the value used during training, the performance is equal or better.
+Running Time. Unfortunately, solving the robust version of the problem instead of the standard one imposes a significant computational overhead. Standard training requires one forward and one backward pass through the network for each training batch. Instead, adversarial training with a $k$ -step PGD adversary, requires additionally $k$ forward and $k$ backward passes through the network to compute the adversarial version of the training batch. This implies an increase in running time of a factor of $( k + 1 )$ . We hope that future research will propose ways to mitigate this drawback.
+# 5 FIRST-ORDER ADVERSARIES.
+Our exploration of the loss landscape (Appendix A) shows that the local maxima found by PGD all have similar loss values, both for normally trained networks and adversarially trained networks. This concentration phenomenon suggests an intriguing view on the problem in which robustness against the PGD adversary yields robustness against all first-order adversaries, i.e., attacks that rely only on first-order information. As long as the adversary only uses gradients of the loss function with respect to the input, we conjecture that it will not find significantly better local maxima than PGD. This hypothesis is validated by the experimental evidence provided in Section 4: if we train a network to be robust against PGD adversaries, it becomes robust against a wide range of other attacks as well.
+Of course, our exploration with PGD does not preclude the existence of some isolated maxima with much larger function value. However, our experiments suggest that such better local maxima are hard to find with first order methods: even a large number of random restarts did not find function values with significantly different loss values (see Appendix A). Incorporating the computational power of the adversary into the threat model should be reminiscent of the notion of polynomially bounded adversary that is a cornerstone of modern cryptography. There, this classic threat model allows the adversary to only solve problems that require at most polynomial computation time. Here, we employ an optimization-based view on the power of the adversary as it is more suitable in the context of machine learning. After all, we have not yet developed a thorough understanding of the computational complexity of many recent machine learning problems. However, the vast majority of optimization problems in ML is solved with first-order methods, and variants of SGD are the most effective way of training deep learning models in particular. Hence we believe that the class of attacks relying on first-order information is, in some sense, universal for the current practice of deep learning.
+Put together, these two ideas chart the way towards machine learning models with guaranteed robustness. If we train the network to be robust against PGD adversaries, it will be robust against a wide range of attacks that encompasses all current approaches.
+In fact, this robustness guarantee would become even stronger in the context of transfer attacks, i.e., attacks in which the adversary does not have a direct access to the target network. Instead, the adversary only has less specific information such as the (rough) model architecture and the training data set. One can view this threat model as an example of “zero order” attacks, i.e., attacks in which the adversary has no direct access to the classifier and is only able to evaluate it on chosen examples without gradient feedback. Still, even for the case of zero-order attacks, the gradient of the network can be estimated using a finite differences method, rendering first-order attacks also relevant in this context.
+We discuss transferability in Appendix D. We observe that increasing network capacity and strengthening the adversary we train against (FGSM or PGD training, rather than natural training) improves resistance against transfer attacks. Also, as expected, the resistance of our best models to such attacks tends to be significantly larger than to the (strongest) first order attacks.
+# 6 RELATED WORK
+Due to the growing body of work on adversarial examples in the context of deep learning networks (Gu & Rigazio, 2014; Fawzi et al., 2015; Torkamani, 2016; Papernot et al., 2016b; Carlini & Wagner, 2016a; Tramèr et al., 2017b; Goodfellow et al., 2014; Kurakin et al., 2016), we focus only on the most related papers here. Before we compare our contributions, we remark that robust optimization has been studied outside deep learning for multiple decades. We refer the reader to Ben-Tal et al. (2009) for an overview of this field.
+To the best of our knowledge, in the context of adversarial examples, an explicit formulation of the min-max optimization first appeared in Huang et al. (2015), Shaham et al. (2015), and Lyu et al. (2015). All of these works, however, consider very weak adversaries/methods for solving the maximization problem, mainly relying on linearizing the loss and performing a single step, similar to FGSM. These adversaries do not capture the full range of possible attacks and thus training only against them leaves the resulting classifier vulnerable to more powerful, iterative attacks.
+Recent work on adversarial training on ImageNet also observed that the model capacity is important for adversarial training Kurakin et al. (2016). However, their work was focused on FGSM attacks, since they report the iterative attacks are too expensive computationally and don’t provide any significant benefits. In contrast to that, we discover that for the datasets we considered training against iterative adversaries does result in a model that is robust against such adversaries.
+A more recent paper (Tramèr et al., 2017b) also explores the transferability phenomenon. This exploration focuses mostly on the region around natural examples where the loss is (close to) linear. When large perturbations are allowed, this region does not give a complete picture of the adversarial landscape. This is confirmed by our experiments, as well as pointed out by Tramèr et al. (2017a).
+Another recent paper (Tramèr et al., 2017a), considers adversarial training using black-box attacks from similar networks in order to increase the robustness of the network against such adversaries. However, this is not an effective defense against the white-box setting we consider, since a PGD adversary can reliably produce adversarial examples for such networks.
+# 7 CONCLUSION
+Our findings provide evidence that deep neural networks can be made resistant to adversarial attacks. As our theory and experiments indicate, we can design reliable adversarial training methods. One of the key insights behind this is the unexpectedly regular structure of the underlying optimization task: even though the relevant problem corresponds to the maximization of a highly non-concave function with many distinct local maxima, their values are highly concentrated. Overall, our findings give us hope that adversarially robust deep learning models may be within current reach.
+For the MNIST dataset, our networks are very robust, achieving high accuracy for a wide range of powerful adversaries and large perturbations. Our experiments on CIFAR10 have not reached the same level of performance yet. However, our results already show that our techniques lead to significant increase in the robustness of the network. We believe that further exploring this direction will lead to adversarially robust networks for this dataset.
+# ACKNOWLEDGMENTS
+Aleksander M ˛adry, Aleksandar Makelov, and Dimitris Tsipras were supported by the NSF Grant No. 1553428, a Google Research Fellowship, and a Sloan Research Fellowship. Ludwig Schmidt was supported by a Google PhD Fellowship. Adrian Vladu was supported by the NSF Grants No. 1111109 and No. 1553428.
+We thank Wojciech Matusik for kindly providing us with computing resources to perform this work.
+# REFERENCES
+Tensor flow models repository. https://github.com/tensorflow/models/tree/ master/resnet, 2017.
+Aharon Ben-Tal, Laurent El Ghaoui, and Arkadi Nemirovski. Robust optimization. Princeton University Press, 2009.
+Nicholas Carlini and David Wagner. Defensive distillation is not robust to adversarial examples. arXiv preprint arXiv:1607.04311, 2016a.
+Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. arXiv preprint arXiv:1608.04644, 2016b.
+Nicholas Carlini and David Wagner. Adversarial examples are not easily detected: Bypassing ten detection methods. arXiv preprint arXiv:1705.07263, 2017.
+Nicholas Carlini, Guy Katz, Clark Barrett, and David L Dill. Ground-truth adversarial examples. arXiv preprint arXiv:1709.10207, 2017.
+Nilesh Dalvi, Pedro Domingos, Mausam, Sumit Sanghai, and Deepak Verma. Adversarial classification. In International Conference on Knowledge Discovery and Data Mining (KDD), 2004.
+Alhussein Fawzi, Omar Fawzi, and Pascal Frossard. Analysis of classifiers’ robustness to adversarial perturbations. arXiv preprint arXiv:1502.02590, 2015.
+Ian J. Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014.
+Shixiang Gu and Luca Rigazio. Towards deep neural network architectures robust to adversarial examples. arXiv preprint arXiv:1412.5068, 2014.
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 770–778, 2016.
+Warren He, James Wei, Xinyun Chen, Nicholas Carlini, and Dawn Song. Adversarial example defenses: Ensembles of weak defenses are not strong. arXiv preprint arXiv:1706.04701, 2017.
+Ruitong Huang, Bing Xu, Dale Schuurmans, and Csaba Szepesvári. Learning with a strong adversary. arXiv preprint arXiv:1511.03034, 2015.
+Alexey Kurakin, Ian J. Goodfellow, and Samy Bengio. Adversarial machine learning at scale. arXiv preprint arXiv:1611.01236, 2016.
+Chunchuan Lyu, Kaizhu Huang, and Hai-Ning Liang. A unified gradient regularization family for adversarial examples. In Data Mining (ICDM), 2015 IEEE International Conference on, pp. 301–309. IEEE, 2015.
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: A simple and accurate method to fool deep neural networks. In 2016 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2016, Las Vegas, NV, USA, June 27-30, 2016, pp. 2574–2582, 2016.
+Anh Mai Nguyen, Jason Yosinski, and Jeff Clune. Deep neural networks are easily fooled: High confidence predictions for unrecognizable images. In IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2015, Boston, MA, USA, June 7-12, 2015, pp. 427–436, 2015.
+Nicolas Papernot and Patrick D. McDaniel. On the effectiveness of defensive distillation. arXiv preprint arXiv:1607.05113, 2016.
+Nicolas Papernot, Patrick McDaniel, Xi Wu, Somesh Jha, and Ananthram Swami. Distillation as a defense to adversarial perturbations against deep neural networks. In Security and Privacy (SP), 2016 IEEE Symposium on, pp. 582–597. IEEE, 2016a.
+Nicolas Papernot, Patrick D. McDaniel, Somesh Jha, Matt Fredrikson, Z. Berkay Celik, and Ananthram Swami. The limitations of deep learning in adversarial settings. In IEEE European Symposium on Security and Privacy, EuroS&P 2016, Saarbrücken, Germany, March 21-24, 2016, pp. 372–387, 2016b.
+Andras Rozsa, Manuel Günther, and Terrance E. Boult. Towards robust deep neural networks with BANG. arXiv preprint arXiv:1612.00138, 2016.
+Uri Shaham, Yutaro Yamada, and Sahand Negahban. Understanding adversarial training: Increasing local stability of neural nets through robust optimization. arXiv preprint arXiv:1511.05432, 2015.
+Mahmood Sharif, Sruti Bhagavatula, Lujo Bauer, and Michael K. Reiter. Accessorize to a crime: Real and stealthy attacks on state-of-the-art face recognition. In Proceedings of the 2016 ACM SIGSAC Conference on Computer and Communications Security, Vienna, Austria, October 24-28, 2016, pp. 1528–1540, 2016.
+Jure Sokolic, Raja Giryes, Guillermo Sapiro, and Miguel RD Rodrigues. Robust large margin deep neural networks. arXiv preprint arXiv:1605.08254, 2016.
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian J. Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013.
+MohamadAli Torkamani. Robust Large Margin Approaches for Machine Learning in Adversarial Settings. PhD thesis, University of Oregon, 2016.
+Florian Tramèr, Alexey Kurakin, Nicolas Papernot, Dan Boneh, and Patrick D. McDaniel. Ensemble adversarial training: Attacks and defenses. arXiv preprint arXiv:1705.07204, 2017a.
+Florian Tramèr, Nicolas Papernot, Ian J. Goodfellow, Dan Boneh, and Patrick D. McDaniel. The space of transferable adversarial examples. arXiv preprint arXiv:1704.03453, 2017b. URL http://arxiv.org/abs/1704.03453.
+Abraham Wald. Contributions to the theory of statistical estimation and testing hypotheses. The Annals of Mathematical Statistics, 10(4):299–326, 1939.
+Abraham Wald. Statistical decision functions which minimize the maximum risk. Annals of Mathematics, pp. 265–280, 1945.
+Abraham Wald. Statistical decision functions. In Breakthroughs in Statistics, pp. 342–357. Springer, 1992.
+Weilin Xu, David Evans, and Yanjun Qi. Feature squeezing: Detecting adversarial examples in deep neural networks. arXiv preprint arXiv:1704.01155, 2017.
+# A THE LANDSCAPE OF ADVERSARIAL EXAMPLES
+The inner problem of the saddle point formulation (2.1) corresponds to finding an adversarial example for a given network and data point (subject to our attack model). As this problem requires us to maximize a highly non-concave function, one would expect it to be intractable. Indeed, this is the conclusion reached by prior work which then resorted to linearizing the inner maximization problem (Huang et al., 2015; Shaham et al., 2015). As pointed out above, this linearization approach yields well-known methods such as FGSM. While training against FGSM adversaries has shown some successes, recent work also highlights important shortcomings of this one-step approach (Tramèr et al., 2017a).
+To understand the inner problem in more detail, we investigate the landscape of local maxima for multiple models on MNIST and CIFAR10. The main tool in our experiments is projected gradient descent (PGD), since it is the standard method for large-scale constrained optimization. In order to explore a large part of the loss landscape, we re-start PGD from many points in the $\ell _ { \infty }$ balls around data points from the respective evaluation sets.
+Surprisingly, our experiments show that the inner problem is tractable after all, at least from the perspective of first-order methods. While there are many local maxima spread widely apart within $x _ { i } + \mathcal { S }$ , they tend to have very well-concentrated loss values. This echoes the folklore belief that training neural networks is possible because the loss (as a function of model parameters) typically has many local minima with very similar values.
+Specifically, in our experiments we found the following phenomena:
+• We observe that the loss achieved by the adversary increases in a fairly consistent way and plateaus rapidly when performing projected $\ell _ { \infty }$ gradient descent for randomly chosen starting points inside $x + { \mathcal { S } }$ (see Figure 3).
+![](images/93e7d012fbb3e52f3c0dbba80dccb025773446a7bbb9d5419dcd308da9993280.jpg)
+Figure 3: Cross-entropy loss values while creating an adversarial example from the MNIST and CIFAR10 evaluation datasets. The plots show how the loss evolves during 20 runs of projected gradient descent (PGD). Each run starts at a uniformly random point in the $\ell _ { \infty }$ -ball around the same natural example (additional plots for different examples appear in Figure 11). The adversarial loss plateaus after a small number of iterations. The optimization trajectories and final loss values are also fairly clustered, especially on CIFAR10. Moreover, the final loss values on adversarially trained networks are significantly smaller than on their naturally trained counterparts.
+• Investigating the concentration of maxima further, we observe that over a large number of random restarts, the loss of the final iterate follows a well-concentrated distribution without extreme outliers (see Figure 4; we verified this concentration based on $1 0 ^ { 5 }$ restarts). To demonstrate that maxima are noticeably distinct, we also measured the $\ell _ { 2 }$ distance and angles between all pairs of them and observed that distances are distributed close to the expected distance between two random points in the $\ell _ { \infty }$ ball, and angles are close to $9 0 °$ . Along the line segment between local maxima, the loss is convex, attaining its maximum at the endpoints and is reduced by a constant factor in the middle. Nevertheless, for the entire segment, the loss is considerably higher than that of a random point.
+• Finally, we observe that the distribution of maxima suggests that the recently developed subspace view of adversarial examples is not fully capturing the richness of attacks (Tramèr et al., 2017b). In particular, we observe adversarial perturbations with negative inner product with the gradient
+![](images/1dadd46a427e0c9b9ea40096cdc1895b05fc9376f15cca7def88e3d2c9cee894.jpg)
+Figure 4: Values of the local maxima given by the cross-entropy loss for five examples from the MNIST and CIFAR10 evaluation datasets. For each example, we start projected gradient descent (PGD) from $1 0 ^ { 5 }$ uniformly random points in the $\ell _ { \infty }$ -ball around the example and iterate PGD until the loss plateaus. The blue histogram corresponds to the loss on a naturally trained network, while the red histogram corresponds to the adversarially trained counterpart. The loss is significantly smaller for the adversarially trained networks, and the final loss values are very concentrated without any outliers.
+of the example, and deteriorating overall correlation with the gradient direction as the scale of perturbation increases.
+# B NETWORK CAPACITY AND ADVERSARIAL ROBUSTNESS
+For a fixed set $s$ of possible perturbations, the value of the problem (2.1) is entirely dependent on the architecture of the classifier we are learning. Consequently, the architectural capacity of the model becomes a major factor affecting its overall performance. At a high level, classifying examples in a robust way requires a stronger classifier, since the presence of adversarial examples changes the decision boundary of the problem to a more complicated one (see Figure 5 for an illustration).
+![](images/36cb97ed8caa3c7d3fc12935fe9787ee1cacab53006e77dd7c59f923132ee179.jpg)
+Figure 5: A conceptual illustration of “natural” vs. “adversarial” decision boundaries. Left: A set of points that can be easily separated with a simple (in this case, linear) decision boundary. Middle: The simple decision boundary does not separate the $\ell _ { \infty }$ -balls (here, squares) around the data points. Hence there are adversarial examples (the red stars) that will be misclassified. Right: Separating the $\ell _ { \infty }$ -balls requires a significantly more complicated decision boundary. The resulting classifier is robust to adversarial examples with bounded $\ell _ { \infty }$ -norm perturbations.
+Our experiments verify that capacity is crucial for robustness, as well as for the ability to successfully train against strong adversaries. For the MNIST dataset, we consider a simple convolutional network and study how its behavior changes against different adversaries as we keep doubling the size of network (i.e. double the number of convolutional filters and the size of the fully connected layer). The initial network has a convolutional layer with 2 filters, followed by another convolutional layer with 4 filters, and a fully connected hidden layer with 64 units. Convolutional layers are followed by $2 \times 2$ max-pooling layers and adversarial examples are constructed with $\varepsilon = 0 . 3$ . The results are in Figure 6.
+For the CIFAR10 dataset, we used the Resnet model He et al. (2016); TFM (2017). We performed data augmentation using random crops and flips, as well as per image standarization. To increase the capacity, we modified the network incorporating wider layers by a factor of 10. This results in a network with 5 residual units with (16, 160, 320, 640) filters each. This network can achieve an accuracy of $9 5 . 2 \%$ when trained with natural examples. Adversarial examples were constructed with $\varepsilon = 8$ . Results on capacity experiments appear in Figure 6.
+We observe the following phenomena:
+Capacity alone helps. We observe that increasing the capacity of the network when training using only natural examples (apart from increasing accuracy on these examples) increases the robustness against one-step perturbations. This effect is greater when considering adversarial examples with smaller $\varepsilon$ .
+FGSM adversaries don’t increase robustness (for large $\varepsilon$ ). When training the network using adversarial examples generated with the FGSM, we observe that the network overfits to these adversarial examples. This behavior is known as label leaking Kurakin et al. (2016) and stems from the fact that the adversary produces a very restricted set of adversarial examples that the network can overfit to. These networks have poor performance on natural examples and don’t exhibit any kind of robustness against PGD adversaries. For the case of smaller $\varepsilon$ the loss is ofter linear enough in the $\ell _ { \infty }$ ball around natural examples, that FGSM finds adversarial examples close to those found by PGD thus being a reasonable adversary to train against.
+Weak models may fail to learn non-trivial classifiers. In the case of small capacity networks, attempting to train against a strong adversary (PGD) prevents the network from learning anything meaningful. The network converges to always predicting a fixed class, even though it could converge to an accurate classifier through natural training. The small capacity of the network forces the training procedure to sacrifice performance on natural examples in order to provide any kind of robustness against adversarial inputs.
+The value of the saddle point problem decreases as we increase the capacity. Fixing an adversary model, and training against it, the value of (2.1) drops as capacity increases, indicating the the model can fit the adversarial examples increasingly well.
+More capacity and stronger adversaries decrease transferability. Either increasing the capacity of the network, or using a stronger method for the inner optimization problem reduces the effectiveness of transferred adversarial inputs. We validate this experimentally by observing that the correlation between gradients from the source and the transfer network, becomes less significant as capacity increases. We describe our experiments in Appendix D.
+# C STATEMENT AND APPLICATION OF DANSKIN’S THEOREM
+Recall that our goal is to minimize the value of the saddle point problem
+$$
+\operatorname* { m i n } _ { \theta } \rho ( \theta ) , \quad \mathrm { w h e r e } \quad \rho ( \theta ) = \mathbb { E } _ { ( x , y ) \sim \mathcal { D } } \left[ \operatorname* { m a x } _ { \delta \in \mathcal { S } } L ( \theta , x + \delta , y ) \right] \ .
+$$
+In practice, we don’t have access to the distribution $\mathcal { D }$ so both the gradients and the value of $\rho ( \theta )$ will be computed using sampled input points. Therefore we can consider –without loss of generality– the case of a single random example $x$ with label $y$ , in which case the problem becomes
+$$
+\operatorname* { m i n } _ { \theta } \operatorname* { m a x } _ { \delta \in S } g ( \theta , \delta ) , \quad \mathrm { w h e r e } \quad g ( \theta , \delta ) = L ( \theta , x + \delta , y ) ~ .
+$$
+If we assume that the loss $L$ is continuously differentiable in $\theta$ , we can compute a descent direction for $\theta$ by utilizing the classical theorem of Danskin.
+![](images/232804b3b40c8cdf3b08b55474656181ec7e923bdcc45127f2416fa3bd074d9c.jpg)
+Figure 6: The effect of network capacity on the performance of the network. We trained MNIST and CIFAR10 networks of varying capacity on: (a) natural examples, (b) with FGSM-made adversarial examples, (c) with PGD-made adversarial examples. In the first three plots/tables of each dataset, we show how the natural and adversarial accuracy changes with respect to capacity for each training regime. In the final plot/table, we show the value of the cross-entropy loss on the adversarial examples the networks were trained on. This corresponds to the value of our saddle point formulation (2.1) for different sets of allowed perturbations.
+Theorem C.1 (Danskin). Let $s$ be nonempty compact topological space and $g : \mathbb { R } ^ { n } \times S  \mathbb { R }$ be such that $g ( \cdot , \delta )$ is differentiable for every $\delta \in S$ and $\nabla _ { \boldsymbol { \theta } } g ( \boldsymbol { \theta } , \boldsymbol { \delta } )$ is continuous on $\mathbb { R } ^ { n } \times S$ . Also, let $\delta ^ { * } ( \theta ) = \{ \delta \in \arg \operatorname* { m a x } _ { \delta \in { \mathcal { S } } } g ( \theta , \delta ) \}$ .
+Then the corresponding max-function
+$$
+\phi ( \theta ) = \operatorname* { m a x } _ { \delta \in { \mathcal { S } } } g ( \theta , \delta )
+$$
+is locally Lipschitz continuous, directionally differentiable, and its directional derivatives satisfy
+$$
+\phi ^ { \prime } ( \theta , h ) = \operatorname* { s u p } _ { \delta \in \delta ^ { * } ( \theta ) } h ^ { \top } \nabla _ { \theta } g ( \theta , \delta ) .
+$$
+In particular, if for some $\theta \in \mathbb { R } ^ { n }$ the set $\delta ^ { * } ( \theta ) = \{ \delta _ { \theta } ^ { * } \}$ is a singleton, the the max-function is differentiable at $\theta$ and
+$$
+\nabla \phi ( \theta ) = \nabla _ { \theta } g ( \theta , \delta _ { \theta } ^ { * } ) .
+$$
+The intution behind the theorem is that since gradients are local objects, and the function $\phi ( \theta )$ is locally the same as $g ( \theta , \delta _ { \theta } ^ { * } )$ their gradients will be the same. The theorem immediately gives us the following corollary, stating the we can indeed compute gradients for the saddle point by computing gradients at the inner optimizers.
+Corollary C.2. Let $\overline { { \delta } }$ be such that $\bar { \delta } \in \mathcal { S }$ and is a maximizer for maxδ $L ( \theta , x + \delta , y )$ . Then, as long as it is nonzero, $- \nabla _ { \boldsymbol { \theta } } L ( \boldsymbol { \theta } , \boldsymbol { x } + \overline { { \boldsymbol { \delta } } } , y )$ is a descent direction for $\phi ( \theta ) = \mathrm { m a x } _ { \delta \in { \cal S } } { \cal L } ( \theta , x + \delta , y )$ .
+Proof of Corollary C.2. We apply Theorem C.1 to $g ( \theta , \delta ) : = L ( \theta , x + \delta , y )$ and $S = B _ { \parallel \cdot \parallel } ( \varepsilon )$ . We see that the directional derivative in the direction of $h = \nabla _ { \boldsymbol { \theta } } L ( \boldsymbol { \theta } , x + \overline { { \boldsymbol { \delta } } } , y )$ satisfies
+$$
+\phi ^ { \prime } ( \theta , h ) = \operatorname* { s u p } _ { \delta \in \delta ^ { * } ( \theta ) } h ^ { \top } \nabla _ { \theta } L ( \theta , x + \delta , y ) \geq h ^ { \top } h = \| \nabla _ { \theta } L ( \theta , x + \bar { \delta } , y ) \| _ { 2 } ^ { 2 } \geq 0 .
+$$
+If this gradient is nonzero, then the inequality above is strict. Therefore it gives a descent direction.
+A technical issue is that, since we use ReLU and max-pooling units in our neural network architecture, the loss function is not continuously differentiable. Nevertheless, since the set of discontinuities has measure zero, we can assume that this will not be an issue in practice, as we will never encounter the problematic points.
+Another technical issue is that, due to the not concavity of the inner problem, we are not able to compute global maximizers, since PGD will converge to local maxima. In such cases, we can consider a subset $S ^ { \prime }$ of $s$ such that the local maximum is a global maximum in the region $S ^ { \prime }$ . Applying the theorem for $S ^ { \prime }$ gives us that the gradient corresponds to a descent direction for the saddle point problem when the adversary is constrained in $S ^ { \prime }$ . Therefore if the inner maximum is a true adversarial example for the network, then SGD using the gradient at that point will decrease the loss value at this particular adversarial examples, thus making progress towards a robust model.
+These arguments suggest that the conclusions of the theorem are still valid in our saddle point problem, and –as our experiments confirm– we can solve it reliably.
+# D TRANSFERABILITY
+A lot of recent literature on adversarial training discusses the phenomenon of transferability Goodfellow et al. (2014); Kurakin et al. (2016); Tramèr et al. (2017b), i.e. adversarial examples transfer between differently trained networks. This raises concerns for practical applications, since it suggests that deep networks are extremely vulnerable to attacks, even when there is no direct access to the target network.
+This phenomenon is further confirmed by our current experiments. 4 Moreover, we notice that the extent to which adversarial examples transfer decreases as we increase either network capacity or the power of the adversary used for training the network. This serves as evidence for the fact that the transferability phenomenon can be alleviated by using high capacity networks in conjunction with strong oracles for the inner optimization problem.
+MNIST. In an attempt to understand these phenomena we inspect the loss functions corresponding to the trained models we used for testing transferability. More precisely, we compute angles between gradients of the loss functions evaluated over a large set of input examples, and plot their distribution. Similarly, we plot the value of the loss functions between clean and perturbed examples for both the source and transfer networks. In Figure 8 we plot our experimental findings on the MNIST dataset for $\varepsilon = 0 . 3$ . We consider a naturally trained large network (two convolutional layers of sizes 32 and 64, and a fully connected layer of size 1024), which we train twice starting with different initializations. We plot the distribution of angles between gradients for the same test image in the two resulting networks (orange histograms), noting that they are somewhat correlated. As opposed to this, we see that pairs of gradients for random pairs of inputs for one architecture are as uncorrelated as they can be (blue histograms), since the distribution of their angles looks Gaussian.
+Next, we run the same experiment on a naturally trained very large network (two convolutional layers of sizes 64 and 128, and a fully connected layer of size 1024). We notice a mild increase in classification accuracy for transferred examples.
+Finally, we repeat the same set of experiments, after training the large and very large networks against the FGSM adversary. We notice that gradients between the two architectures become significantly less correlated. Also, the classification accuracy for transferred examples increases significantly compared to the naturally trained networks.
+We further plot how the value of the loss function changes when moving from the natural input towards the adversarially perturbed input (in Figure 8 we show these plots for four images in the MNIST test dataset), for each pair of networks we considered. We observe that, while for the naturally trained networks, when moving towards the perturbed point, the value of the loss function on the transfer architecture tends to start increasing soon after it starts increasing on the source architecture. In contrast, for the stronger models, the loss function on the transfer network tends to start increasing later, and less aggressively.
+CIFAR10. For the CIFAR10 dataset, we investigate the transferability of the FGSM and PGD adversaries between our simple and wide architectures, each trained on natural, FGSM and PGD examples. Transfer accuracies for the FGSM adversary and PGD adversary between all pairs of such configurations (model $^ +$ training method) with independently random weight initialization are given in tables 3 and 4 respectively. The results exhibit the following trends:
+• Stronger adversaries decrease transferability: In particular, transfer attacks between two PGD-trained models are less successful than transfer attacks between their naturally-trained counterparts. Moreover, adding PGD training helps with transferability from all adversarial datasets, except for those with source a PGD-trained model themselves. This applies to both FGSM attacks and PGD attacks. Capacity decreases transferability: In particular, transfer attacks between two PGDtrained wide networks are less successful than transfer attacks between their simple PGDtrained counterparts. Moreover, with few close exceptions, changing the architecture from simple to wide (and keeping the training method the same) helps with transferability from all adversarial datasets.
+We additionally plotted how the loss of a network behaves in the direction of FGSM and PGD examples obtained from itself and an independently trained copy; results for the simple naturally trained network and the wide PGD trained network are given in Table 7. As expected, we observe the following phenomena:
+• sometimes, the FGSM adversary manages to increase loss faster near the natural example, but as we move towards the boundary of the $\ell _ { \infty }$ box of radius $\varepsilon$ , the PGD attack always achieves higher loss.
+• the transferred attacks do worse than their white-box counterparts in terms of increasing the loss;
+• and yet, the transferred PGD attacks dominate the white-box FGSM attacks for the naturally trained network (and sometimes for the PGD-trained one too).
+Table 3: CIFAR10: black-box FGSM attacks. We create FGSM adversarial examples with $\varepsilon = 8$ from the evaluation set on the source network, and then evaluate them on an independently initialized target network.
+<table><tr><td rowspan=1 colspan=1>SourceTarget</td><td rowspan=1 colspan=1>Simple(naturaltraining)</td><td rowspan=1 colspan=1>Simple(FGSMtraining)</td><td rowspan=1 colspan=1>Simple(PGDtraining)</td><td rowspan=1 colspan=1>Wide(naturaltraining)</td><td rowspan=1 colspan=1>Wide(FGSMtraining)</td><td rowspan=1 colspan=1>Wide(PGDtraining)</td></tr><tr><td rowspan=1 colspan=1>Simple(natural training)</td><td rowspan=1 colspan=1>32.9%</td><td rowspan=1 colspan=1>74.0%</td><td rowspan=1 colspan=1>73.7%</td><td rowspan=1 colspan=1>27.6%</td><td rowspan=1 colspan=1>71.8%</td><td rowspan=1 colspan=1>76.6%</td></tr><tr><td rowspan=1 colspan=1>Simple(FGSM training)</td><td rowspan=1 colspan=1>64.2%</td><td rowspan=1 colspan=1>90.7%</td><td rowspan=1 colspan=1>60.9%</td><td rowspan=1 colspan=1>61.5%</td><td rowspan=1 colspan=1>90.2%</td><td rowspan=1 colspan=1>67.3%</td></tr><tr><td rowspan=1 colspan=1>Simple(PGD training)</td><td rowspan=1 colspan=1>77.1%</td><td rowspan=1 colspan=1>78.1%</td><td rowspan=1 colspan=1>60.2%</td><td rowspan=1 colspan=1>77.0%</td><td rowspan=1 colspan=1>77.9%</td><td rowspan=1 colspan=1>66.3%</td></tr><tr><td rowspan=1 colspan=1>Wide(natural training)</td><td rowspan=1 colspan=1>34.9%</td><td rowspan=1 colspan=1>78.7%</td><td rowspan=1 colspan=1>80.2%</td><td rowspan=1 colspan=1>21.3%</td><td rowspan=1 colspan=1>75.8%</td><td rowspan=1 colspan=1>80.6%</td></tr><tr><td rowspan=1 colspan=1>Wide(FGSM training)</td><td rowspan=1 colspan=1>64.5%</td><td rowspan=1 colspan=1>93.6%</td><td rowspan=1 colspan=1>69.1%</td><td rowspan=1 colspan=1>53.7%</td><td rowspan=1 colspan=1>92.2%</td><td rowspan=1 colspan=1>72.8%</td></tr><tr><td rowspan=1 colspan=1>Wide(PGD training)</td><td rowspan=1 colspan=1>85.8%</td><td rowspan=1 colspan=1>86.6%</td><td rowspan=1 colspan=1>73.3%</td><td rowspan=1 colspan=1>85.6%</td><td rowspan=1 colspan=1>86.2%</td><td rowspan=1 colspan=1>67.0%</td></tr></table>
+Table 4: CIFAR10: black-box PGD attacks. We create PGD adversarial examples with $\varepsilon = 8$ for 7 iterations from the evaluation set on the source network, and then evaluate them on an independently initialized target network.
+<table><tr><td rowspan=1 colspan=1>SourceTarget</td><td rowspan=1 colspan=1>Simple(naturaltraining)</td><td rowspan=1 colspan=1>Simple(FGSMtraining)</td><td rowspan=1 colspan=1>Simple(PGDtraining)</td><td rowspan=1 colspan=1>Wide(naturaltraining)</td><td rowspan=1 colspan=1>Wide(FGSMtraining)</td><td rowspan=1 colspan=1>Wide(PGDtraining)</td></tr><tr><td rowspan=1 colspan=1>Simple(natural training)</td><td rowspan=1 colspan=1>6.6%</td><td rowspan=1 colspan=1>71.6%</td><td rowspan=1 colspan=1>71.8%</td><td rowspan=1 colspan=1>1.4%</td><td rowspan=1 colspan=1>51.4%</td><td rowspan=1 colspan=1>75.6%</td></tr><tr><td rowspan=1 colspan=1>Simple(FGSM training)</td><td rowspan=1 colspan=1>66.3%</td><td rowspan=1 colspan=1>40.3%</td><td rowspan=1 colspan=1>58.4%</td><td rowspan=1 colspan=1>65.4%</td><td rowspan=1 colspan=1>26.8%</td><td rowspan=1 colspan=1>66.2%</td></tr><tr><td rowspan=1 colspan=1>Simple(PGD training)</td><td rowspan=1 colspan=1>78.1%</td><td rowspan=1 colspan=1>78.2%</td><td rowspan=1 colspan=1>57.7%</td><td rowspan=1 colspan=1>77.9%</td><td rowspan=1 colspan=1>78.1%</td><td rowspan=1 colspan=1>65.2%</td></tr><tr><td rowspan=1 colspan=1>Wide(natural training)</td><td rowspan=1 colspan=1>10.9%</td><td rowspan=1 colspan=1>79.6%</td><td rowspan=1 colspan=1>79.1%</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>51.3%</td><td rowspan=1 colspan=1>79.7%</td></tr><tr><td rowspan=1 colspan=1>Wide(FGSM training)</td><td rowspan=1 colspan=1>67.6%</td><td rowspan=1 colspan=1>51.7%</td><td rowspan=1 colspan=1>67.4%</td><td rowspan=1 colspan=1>56.5%</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>71.6%</td></tr><tr><td rowspan=1 colspan=1>Wide(PGD training)</td><td rowspan=1 colspan=1>86.4%</td><td rowspan=1 colspan=1>86.8%</td><td rowspan=1 colspan=1>72.1%</td><td rowspan=1 colspan=1>86.0%</td><td rowspan=1 colspan=1>86.3%</td><td rowspan=1 colspan=1>64.2%</td></tr></table>
+Table 5: CIFAR10: white-box attacks for $\varepsilon = 8$ . For each architecture and training method, we list the accuracy of the resulting network on the full CIFAR10 evaluation set of 10,000 examples. The FGSM random method is the one suggested by Tramèr et al. (2017a), whereby we first do a small random perturbation of the natural example, and the apply FGSM to that.
+<table><tr><td rowspan=1 colspan=1>AdversaryModel</td><td rowspan=1 colspan=1>Natural</td><td rowspan=1 colspan=1>FGSM</td><td rowspan=1 colspan=1>FGSM random|PGD (7 steps)</td><td rowspan=1 colspan=1>FGSM random|PGD (7 steps)</td><td rowspan=1 colspan=1>PGD (20 steps)</td></tr><tr><td rowspan=1 colspan=1>Simple(natural training)</td><td rowspan=1 colspan=1>92.7%</td><td rowspan=1 colspan=1>27.5%</td><td rowspan=1 colspan=1>19.6%</td><td rowspan=1 colspan=1>1.2%</td><td rowspan=1 colspan=1>0.8%</td></tr><tr><td rowspan=1 colspan=1>Simple(FGSM training)</td><td rowspan=1 colspan=1>87.4%</td><td rowspan=1 colspan=1>90.9%</td><td rowspan=1 colspan=1>90.4%</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>0.0%</td></tr><tr><td rowspan=1 colspan=1>Simple(PGD training)</td><td rowspan=1 colspan=1>79.4%</td><td rowspan=1 colspan=1>51.7%</td><td rowspan=1 colspan=1>55.9%</td><td rowspan=1 colspan=1>47.1%</td><td rowspan=1 colspan=1>43.7%</td></tr><tr><td rowspan=1 colspan=1>Wide(natural training)</td><td rowspan=1 colspan=1>95.2%</td><td rowspan=1 colspan=1>32.7%</td><td rowspan=1 colspan=1>25.1%</td><td rowspan=1 colspan=1>4.1%</td><td rowspan=1 colspan=1>3.5%</td></tr><tr><td rowspan=1 colspan=1>Wide(FGSM training)</td><td rowspan=1 colspan=1>90.3%</td><td rowspan=1 colspan=1>95.1%</td><td rowspan=1 colspan=1>95.0%</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>0.0%</td></tr><tr><td rowspan=1 colspan=1>Wide(PGD training)</td><td rowspan=1 colspan=1>87.3%</td><td rowspan=1 colspan=1>56.1%</td><td rowspan=1 colspan=1>60.3%</td><td rowspan=1 colspan=1>50.0%</td><td rowspan=1 colspan=1>45.8%</td></tr></table>
+![](images/30f9a4cfeaff5640e9040aba4d1d44dd69632bc9c1ef5b25bdddfc385e319972.jpg)
+Figure 7: CIFAR10: change of loss function in the direction of white-box and black-box FGSM and PGD examples with $\varepsilon = 8$ for the same five natural examples. Each line shows how the loss changes as we move from the natural example to the corresponding adversarial example. Top: simple naturally trained model. Bottom: wide PGD trained model. We plot the loss of the original network in the direction of the FGSM example for the original network (red lines), 5 PGD examples for the original network obtained from 5 random starting points (blue lines), the FGSM example for an independently trained copy network (green lines) and 5 PGD examples for the copy network obtained from 5 random starting points (black lines). All PGD attacks use 100 steps with step size 0.3.
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Source</td><td rowspan=1 colspan=1>Transfer</td></tr><tr><td rowspan=1 colspan=1>Clean</td><td rowspan=1 colspan=1>99.2%</td><td rowspan=1 colspan=1>99.2%</td></tr><tr><td rowspan=1 colspan=1>FGSM</td><td rowspan=1 colspan=1>3.9%</td><td rowspan=1 colspan=1>41.9%</td></tr><tr><td rowspan=1 colspan=1>PGD</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>26.0%</td></tr></table>
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Source</td><td rowspan=1 colspan=1>Transfer</td></tr><tr><td rowspan=1 colspan=1>Clean</td><td rowspan=1 colspan=1>92.9%</td><td rowspan=1 colspan=1>96.1%</td></tr><tr><td rowspan=1 colspan=1>FGSM</td><td rowspan=1 colspan=1>99.9%</td><td rowspan=1 colspan=1>62.0%</td></tr><tr><td rowspan=1 colspan=1>PGD</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>54.1%</td></tr></table>
+Large network, FGSM training
+Very large network, natural training
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Source</td><td rowspan=1 colspan=1>Transfer</td></tr><tr><td rowspan=1 colspan=1>Clean</td><td rowspan=1 colspan=1>99.2%</td><td rowspan=1 colspan=1>99.3%</td></tr><tr><td rowspan=1 colspan=1>FGSM</td><td rowspan=1 colspan=1>7.2%</td><td rowspan=1 colspan=1>44.6%</td></tr><tr><td rowspan=1 colspan=1>PGD</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>35.0%</td></tr></table>
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Source</td><td rowspan=1 colspan=1>Transfer</td></tr><tr><td rowspan=1 colspan=1>Clean</td><td rowspan=1 colspan=1>96.4%</td><td rowspan=1 colspan=1>97.8%</td></tr><tr><td rowspan=1 colspan=1>FGSM</td><td rowspan=1 colspan=1>99.4%</td><td rowspan=1 colspan=1>71.6%</td></tr><tr><td rowspan=1 colspan=1>PGD</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>60.6%</td></tr></table>
+![](images/cf4496228e3128a1ca678c430d22bf5104058b8333c15791c811be049900538e.jpg)
+Figure 8: Transferability experiments for four different instances (naturally trained large and very large networks, and FGSM-trained large and very large networks, respectively). For each instance we ran the same training algorithm twice, starting from different initializations. Tables on the left show the accuracy of the networks against three types of input (clean, perturbed with FGSM, perturbed with PGD ran for 40 steps); the first column shows the resilience of the first network against examples produced using its own gradients, the second column shows resilience of the second network against examples transferred from the former network. The histograms reflect angles between pairs of gradients corresponding to the same inputs versus the baseline consisting of angles between gradients from random pairs of points. Images on the right hand side reflect how the loss functions of the native and the transfer network change when moving in the direction of the perturbation; the perturbation is at 1 on the horizontal axis. Plots in the top row are for FGSM perturbations, plots in the bottom row are for PGD perturbations produced over 40 iterations.
+Very large network, FGSM training
+Large network, natural training
+# E MNIST INSPECTION
+The robust MNIST model described so far is small enough that we can visually inspect most of its parameters. Doing so will allow us to understand how it is different from a naturally trained variant and what are the general characteristics of a network that is robust against $\ell _ { \infty }$ adversaries. We will compare three different networks: a naturally trained model, and two adversarially trained ones. The latter two models are identical, modulo the random weight initialization, and were used as the public and secret models used for our robustness challenge.
+Initially, we examine the first convolutional layer of each network. We observe that the robust models only utilize 3 out of the total 32 filters, and for each of these filters only one weight is non-zero. By doing so, the convolution degrades into a scaling of the original image. Combined with the bias and the ReLU that follows, this results in a thresholding filter, or equivalently $\mathrm { R e L U } ( \alpha x - \beta )$ for some constants $\alpha$ , $\beta$ . From the perspective of adversarial robustness, thresholding filters are immune to any perturbations on pixels with value less than $\beta - \varepsilon$ . We visualize a sample of the filters in Figure 9 (plots a, c, and e).
+Having observed that the first layer of the network essentially maps the original image to three copies thresholded at different values, we examine the second convolutional layer of the classifier. Again, the filter weights are relatively sparse and have a significantly wider value range than the naturally trained version. Since only three channels coming out of the first layer matter, is follows (and is verified) that the only relevant convolutional filters are those that interact with these three channels. We visualize a sample of the filters in Figure 9 (plots b, d, and f).
+Finally, we examine the softmax/output layer of the network. While the weights seem to be roughly similar between all three version of the network, we notice a significant difference in the class biases. The adversarially trained networks heavily utilize class biases (far from uniform), and do so in a way very similar to each other. A plausible explanation is that certain classes tend to be very vulnerable to adversarial perturbations, and the network learns to be more conservative in predicting them. The plots can be found in Figure 10.
+All of the “tricks” described so far seem intuitive to a human and would seem reasonable directions when trying to increase the adversarial robustness of a classifier. We emphasize the none of these modifications were hard-coded in any way and they were all learned solely through adversarial training. We attempted to manually introduce these modifications ourselves, aiming to achieve adversarial robustness without adversarial training, but with no success. A simple PGD adversary could fool the resulting models on all the test set examples.
+![](images/dbb24eb20cc9bd4cc699d6f4ecde36d76e21e1c5e2052afbfde1a72e5f2142fd.jpg)
+(a) Natural Model First Conv. Layers
+(b) Natural Model Second Conv. Layer
+Figure 9: Visualizing a sample of the convolutional filters. For the natural model (a,b) we visualize random filters, since there is no observable difference in any of them. For the first layer of robust networks we make sure to include the 3 non-zero filters. For the second layer, the first three columns represent convolutional filters that utilize the 3 non-zero channels, and we choose the most interesting ones (larger range of values). We observe that adversarially trained networks have significantly more concentrated weights. Moreover, the first convolutional layer degrades into a few thresholding filters.
+![](images/6f841cf01e7dc83fd47f6373870734999b53027be5d1ea987b391f3714b84b72.jpg)
+Figure 10: Softmax layer examination. For each network we create a histogram of the layer’s weights and plot the per-class bias. We observe that while weights are similar (slightly more concentrated for the natural one) the biases are far from uniform and with a similar pattern for the two adversarially trained networks.
+![](images/295347f2615bff0e6df31523308b6b1bb94a5000099b40e452b41e350d5cfd16.jpg)
+Figure 11: Loss function value over PGD iterations for 20 random restarts on random examples. The 1st and 3rd rows correspond to naturally trained networks, while the 2nd and 4th to adversarially trained ones.
+![](images/0bfe21b4b9afda97427b514d2b2a7e30677152063b0166fe480a55437d899283.jpg)
+Figure 12: Sample adversarial examples with $\ell _ { 2 }$ norm bounded by 4. The perturbations are significant enough to cause misclassification by humans too.

parse/train/rJzIBfZAb/rJzIBfZAb_content_list.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/rJzIBfZAb/rJzIBfZAb_middle.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/rJzIBfZAb/rJzIBfZAb_model.json ADDED Viewed

The diff for this file is too large to render. See raw diff