| Contrastive loss | ${\mathcal{L}}_{\text{con,}\theta }\left( {x,\left\{ {x}_{\text{pos }}\right\} ,\left\{ {x}_{\text{neg }}\right\} }\right)$ $\mathop{\sum }\limits_{\left\{ f{\left( x\right) }_{\text{pos }}\right\} }\exp \left( {\operatorname{sim}\left( {f\left( x\right) ,\left\{ {f{\left( x\right) }_{\text{pos }}}\right\} }\right) /\tau }\right)$ $\leftarrow - \log \mathop{\sum }\limits_{\left\{ f{\left( x\right) }_{\text{pos }}\right\} }\exp \left( {\operatorname{sim}\left( {f\left( x\right) ,\left\{ {f{\left( x\right) }_{\text{pos }}}\right\} }\right) /\tau }\right) + \mathop{\sum }\limits_{\left\{ f{\left( x\right) }_{\text{neg }}\right\} }\exp \left( {\operatorname{sim}\left( {f\left( x\right) ,\left\{ {f{\left( x\right) }_{\text{neg }}}\right\} }\right) /\tau }\right)$ |
| RoCL PGD | ${t}_{1}{\left( x\right) }^{i + 1} = {\Pi }_{B\left( {{t}_{1}\left( x\right) ,\varepsilon }\right) }\left( {{t}_{1}{\left( x\right) }^{i} + \alpha \operatorname{sign}\left( {{\nabla }_{{t}_{1}{\left( x\right) }^{i}}{\mathcal{L}}_{\operatorname{con},\theta }\left( {{t}_{1}{\left( x\right) }^{i},\left\{ {{t}_{2}\left( x\right) }\right\} ,\left\{ {{t}_{1}{\left( x\right) }_{\text{neg }}}\right\} }\right) }\right) }\right)$ |
| RoCL | $\underset{\theta }{{arg}\;{min}}{E}_{x \sim D}\left\lbrack {\mathop{\max }\limits_{{\delta \in B\left( {{t}_{1}\left( x\right) ,\varepsilon }\right) }}{\mathcal{L}}_{\mathrm{{con}},\theta }\left( {{t}_{1}\left( x\right) + \delta ,\left\{ {{t}_{2}\left( x\right) }\right\} ,\left\{ {{t}_{1}{\left( x\right) }_{\mathrm{{neg}}}}\right\} }\right) }\right\rbrack$ |
| MoCo Loss | ${\mathcal{L}}_{\mathrm{{NCE}}} = - \log \frac{\exp \left( {q \cdot {k}_{\text{pos }}/\tau }\right) }{\exp \left( {q \cdot {k}_{\text{pos }}/\tau }\right) + \mathop{\sum }\limits_{{{k}_{\text{neg }} \in \mathcal{M}}}\exp \left( {q \cdot {k}_{\text{neg }}/\tau }\right) }$ |
| AMOC | $\mathop{\min }\limits_{{{\theta }_{q},{\theta }_{k}}}{E}_{x \in D}{E}_{{t}_{1},{t}_{2} \in \mathcal{T}}\mathop{\max }\limits_{{\parallel \delta \parallel ,\begin{Vmatrix}{\delta }^{\prime }\end{Vmatrix} \leq \varepsilon }}\mathcal{L}\left( {{t}_{1}\left( x\right) + \delta ,{t}_{2}\left( x\right) + {\delta }^{\prime },{\mathcal{M}}_{\text{clean }},{\mathcal{M}}_{\text{adv }}}\right)$ |
| AMOC ACC | ${\mathcal{L}}_{\mathrm{{ACC}}} = {\mathcal{L}}_{\mathrm{{NCE}}}\left( {{f}_{q}\left( {{t}_{1}\left( x\right) + \delta ;{\mathrm{{BN}}}_{\mathrm{{adv}}}}\right) ,{f}_{k}\left( {{t}_{2}\left( x\right) ;{\mathrm{{BN}}}_{\text{clean }}}\right) ,{\mathcal{M}}_{\text{clean }}}\right)$ |
+
+---
+
+Table 3: Loss functions and optimization problems defined for the used self-supervised adversarial training methods. In all formulations $x$ is a given clean sample, $f$ indicates the observed model, and $\delta$ is the adversarial perturbation. Also ${t}_{1}$ and ${t}_{2}$ define two different random transformation, while $\tau$ is some temperature hyperparameter. The contrastive loss is used within the RoCL framework, based on SimCLR, where ${x}_{\text{pos }}$ and ${x}_{\text{neg }}$ give the positive and negative samples, respectively. The similarity sim between two output vectors is calculated as the cosine similarity. To create an adversarial sample, the PGD equation (cf. Equation 1) is adapted by replacing the cross entropy loss with the contrastive loss. For the MoCo Loss, $q$ and $k$ represent the query and key encoder, respectively, and $\mathcal{M}$ is the used memory bank. While standard MoCo only defines one memory bank, within the AMOC framework the authors use two memory banks ${\mathcal{M}}_{\text{clean }}$ and ${\mathcal{M}}_{\text{adv }}$ to store the clean and adversarial historical samples. AMOC ACC is one specific loss function within the overall AMOC framework, for which the authors report good results, and which is therefore used in this study. term simclr, are explained in the caption. The same applies for the comprehensive list of hyperparameters for training $\mathrm{{RoCL}}$ and the respective classification heads, given in Table 5 .
+
+Further details:
+
+- All experiments were run on NVIDIA GeForce GTX 1080.
+
+- For RoCL training, we were not able to use the suggested batch size of 256 per GPU with our hardware.
+
+- For RoCL we changed the projector to consist of 2, instead of 1 , linear layers, followed by a normalization layer.
+
+- Finetuning RoCL with only adversarial inputs led in our experiments to a classification accuracy of ${10}\%$ . Using additional clean samples, we achieved a robust accuracy around ${30}\%$ , which is ${10}\%$ lower than the reported values, and would not be comparable to standard adversarial training. Therefore, RoCL + AF was excluded from our experiments.
+
+## Additional time demand
+
+In Table 6 the mean time required for one step of the indicated adversarial training method is listed. Further down, we split the time demand into the creation of the initial adversarial instance, which already takes up between 40.97 to ${66.92}\%$ of the overall time. Calculating ${\delta }_{{x}^{\prime }, x}$ is only required once. Because for AT, the output vector of the clean sample is not calculated during training, the proportional time requirement is comparable large to the unsupervised methods, where the output vector is already calculated independent of our adaptation. Creating each pseudo adversarial input only adds a small portion, between ${0.2}\%$ to ${0.52}\%$ to the overall time demand per step. For RoCL the evaluation of the loss function furthermore takes up 84.96% of the time to create one pseudo adversarial instance. We explain this comparable large time demand by the fact that the RoCL framework implements the loss function itself, while AMOC uses the cross entropy loss provided by pytorch and does very limited own computation in context of the loss evaluation.
+
+## Differences between the attacks
+
+Acknowledgments
+
+| Attribute | Layer | Size |
| Encoder | Conv2d | Channels: (c, 32) |
| Kernel: (4,4, stride=2, padding=1) |
| BatchNorm2d | 32 |
| Relu | |
| Conv2d | Channels: (32, 64) |
| Kernel: (4,4, stride=2, padding=1) |
| BatchNorm2d | 64 |
| Relu | |
| Conv2d | Channels: (64, 128) Kernel: (4,4, stride=2, padding=1) |
| BatchNorm2d | 128 |
| Mean | Linear | (1024, ${z}_{d\mathit{{im}}} = {128}$ ) |
| Variance | Linear | (1024, ${z}_{d\;i\;m} =$ 128) |
| Project | Linear | $\left( {{z}_{dim} = {128},{1024}}\right)$ |
| Reshape | (128,4,4) |
| Decoder | ConvTranspose2d | Channels: (128, 64) Kernel: (4,4, stride=2, padding=1) |
| BatchNorm2d | 64 |
| Relu | |
| ConvTranspose2d | Channels: (64, 32) |
| Kernel: (4,4, stride=2, padding=1) |
| BatchNorm2d | 64 |
| Relu | |
| ConvTranspose2d | Channels: (32, c) |
| Kernel: (4,4, stride=2, padding=1) |
| Sigmoid | |
+
+TABLE I: CVAE Architecture Layer Sizes. $c =$ Number of Channels in the Input Image $(c = 3$ for CIIFAR-10 and $c = 1$ for MNIST).
+
+## Determining Reconstruction Errors
+
+Let $X$ be the input image and ${y}_{\text{pred }}$ be the predicted class obtained from the target classifier network. ${X}_{{rcn},{y}_{pred}}$ is the reconstructed image obtained from the trained encoder and decoder networks with the condition ${y}_{\text{pred }}$ . We define the reconstruction error or the reconstruction distance as in Equation 8. The network architectures for encoder and decoder layers are given in Figure 1.
+
+$$
+\operatorname{Recon}\left( {X, y}\right) = {\left( X - {X}_{{rcn}, y}\right) }^{2} \tag{8}
+$$
+
+Two pertinent points to note here are:
+
+- For clean test examples, the reconstruction error is bound to be less since the CVAE is trained on clean train images. As the classifier gives correct class for the clean examples, the reconstruction error with the correct class of the image as input is less.
+
+- For the adversarial examples, as they fool the classifier network, passing the malicious output class, ${y}_{\text{pred }}$ of the classifier network to the CVAE with the slightly perturbed input image, the reconstructed image tries to be closer to the input with class ${y}_{\text{pred }}$ and hence, the reconstruction error is large.
+
+As an example, let the clean image be a cat and its slightly perturbed image fools the classifier network to believe it is a dog. Hence, the input to the CVAE will be the slightly perturbed cat image with the class dog. Now as the encoder and decoder layers are trained to output a dog image if the class inputted is dog, the reconstructed image will try to resemble a dog but since the input is a cat image, there will be large reconstruction error. Hence, we use reconstruction error as a measure to determine if the input image is adversarial. We first train the Conditional Variational AutoEncoder (CVAE) on clean images with the ground truth class as the condition. Examples of reconstructions for clean and adversarial examples are given in Figure 2 and Figure 3.
+
+
+
+Fig. 2: Clean and Adversarial Attacked Images to CVAE from MNIST Dataset
+
+
+
+Fig. 3: Clean and Adversarial Attacked Images to CVAE from CIFAR-10 Dataset.
+
+## Obtaining $p$ -value
+
+As already discussed, the reconstruction error is used as a basis for detection of adversaries. We first obtain the reconstruction distances for the train dataset of clean images which is expected to be similar to that of the train images. On the other hand, for the adversarial examples, as the predicted class $y$ is incorrect, the reconstruction is expected to be worse as it will be more similar to the image of class $y$ as the decoder network is trained to generate such images. Also for random images, as they do not mostly fool the classifier network, the predicted class, $y$ is expected to be correct, hence reconstruction distance is expected to be less. Besides qualitative analysis, for the quantitative measure, we use the permutation test from (Efron and Tibshirani 1993). We can provide an uncertainty value for each input about whether it comes from the training distribution. Specifically, let the input ${X}^{\prime }$ and training images ${X}_{1},{X}_{2},\ldots ,{X}_{N}$ . We first compute the reconstruction distances denoted by $\operatorname{Recon}\left( {X, y}\right)$ for all samples with the condition as the predicted class $y =$ Classifier(X). Then, using the rank of $\operatorname{Recon}\left( {{X}^{\prime },{y}^{\prime }}\right)$ in $\{ \mathtt{{Recon}}({X}_{1},{y}_{1}),\mathtt{{Recon}}({X}_{2},{y}_{2}),\ldots ,\mathtt{{Recon}}({X}_{N},{y}_{N})\} \;$ as our test statistic, we get,
+
+$$
+T = T\left( {{X}^{\prime };{X}_{1},{X}_{2},\ldots ,{X}_{N}}\right)
+$$
+
+$$
+= \mathop{\sum }\limits_{{i = 1}}^{N}I\left\lbrack {\operatorname{Recon}\left( {{X}_{i},{y}_{i}}\right) \leq \operatorname{Recon}\left( {{X}^{\prime },{y}^{\prime }}\right) }\right\rbrack \tag{9}
+$$
+
+Where $I\left\lbrack .\right\rbrack$ is an indicator function which returns 1 if the condition inside brackets is true, and 0 if false. By permutation principle, $p$ -value for each sample will be,
+
+$$
+p = \frac{1}{N + 1}\left( {\mathop{\sum }\limits_{{i = 1}}^{N}I\left\lbrack {{T}_{i} \leq T}\right\rbrack + 1}\right) \tag{10}
+$$
+
+Larger $p$ -value implies that the sample is more probable to be a clean example. Let $t$ be the threshold on the obtained $p$ -value for the sample, hence if ${p}_{X, y} < t$ , the sample $X$ is classified as an adversary. Algorithm 1 presents the overall resulting procedure combining all above mentioned stages.
+
+Algorithm 1 Adversarial Detection Algorithm
+
+---
+
+ function DETECT_ADVERSARIES $\left( {{X}_{\text{train }},{Y}_{\text{train }}, X, t}\right)$
+
+ recon $\leftarrow \operatorname{Train}\left( {{X}_{\text{train }},{Y}_{\text{train }}}\right)$
+
+3: recon_dists $\leftarrow \operatorname{Recon}\left( {{X}_{\text{train }},{Y}_{\text{train }}}\right)$
+
+4: Adversaries $\leftarrow \phi$
+
+5: for $x$ in $X$ do
+
+6: ${y}_{\text{pred }} \leftarrow$ Classifier(x)
+
+7: recon_dist_x $\leftarrow \operatorname{Recon}\left( {x,{y}_{\text{pred }}}\right)$
+
+8: pval $\leftarrow p$ -value $\left( {\text{recon_dist_x},\text{recon_dists}}\right)$
+
+9: if pval $\leq t$ then
+
+10: Adversaries.insert( $x$ )
+
+11: return Adversaries
+
+---
+
+Algorithm 1 first trains the CVAE network with clean training samples (Line 2) and formulates the reconstruction distances (Line 3). Then, for each of the test samples which may contain clean, randomly perturbed as well as adversarial examples, first the output predicted class is obtained using a target classifier network, followed by finding it's reconstructed image from CVAE, and finally by obtaining it’s $p$ -value to be used for thresholding (Lines 5- 8). Images with $p$ -value less than given threshold(t)are classified as adversaries (Lines 9-10).
+
+## Experimental Results
+
+We experimented our proposed methodology over MNIST and CIFAR-10 datasets. All the experiments are performed in Google Colab GPU having ${0.82}\mathrm{{GHz}}$ frequency, ${12}\mathrm{{GB}}$ RAM and dual-core CPU having ${2.3}\mathrm{{GHz}}$ frequency, ${12}\mathrm{{GB}}$ RAM. An exploratory version of the code-base will be made public on github.
+
+## Datasets and Models
+
+Two datasets are used for the experiments in this paper, namely MNIST (LeCun, Cortes, and Burges 2010) and CIFAR-10 (Krizhevsky 2009). MNIST dataset consists of hand-written images of numbers from 0 to 9 . It consists of 60,000 training examples and 10,000 test examples where each image is a ${28} \times {28}$ gray-scale image associated with a label from 1 of the 10 classes. CIFAR-10 is broadly used for comparison of image classification tasks. It also consists of 60,000 image of which 50,000 are used for training and the rest10,000are used for testing. Each image is a ${32} \times {32}$ coloured image i.e. consisting of 3 channels associated with a label indicating 1 out of 10 classes.
+
+We use state-of-the-art deep neural network image classifier, ResNet18 (He et al. 2015) as the target network for the experiments. We use the pre-trained model weights available from (Idelbayev) for both MNIST as well as CIFAR-10 datasets.
+
+## Performance over Grey-box attacks
+
+If the attacker has the access only to the model parameters of the target classifier model and no information about the detector method or it's model parameters, then we call such attack setting as Grey-box. This is the most common attack setting used in previous works against which we evaluate the most common attacks with standard epsilon setting as used in other works for both the datasets. For MNIST, the value of $\epsilon$ is commonly used between 0.15-0.3 for FGSM attack and 0.1 for iterative attacks (Samangouei, Kabkab, and Chellappa 2018) (Gong, Wang, and Ku 2017) (Xu, Evans, and Qi 2017). While for CIFAR10, the value of $\epsilon$ is most commonly chosen to be $\frac{8}{255}$ as in (Song et al. 2017) (Xu, Evans, and Qi 2017) (Fidel, Bitton, and Shabtai 2020). For DeepFool (Moosavi-Dezfooli, Fawzi, and Frossard 2016) and Carlini Wagner (CW) (Carlini and Wagner 2017) attacks, the $\epsilon$ bound is not present. The standard parameters as used by default in (Li et al. 2020) have been used for these 2 attacks. For ${L}_{2}$ attacks, the $\epsilon$ bound is chosen such that success of the attack is similar to their ${L}_{\infty }$ counterparts as the values used are very different in previous works.
+
+Reconstruction Error Distribution: The histogram distribution of reconstruction errors for MNIST and CIFAR- 10 datasets for different attacks are given in Figure 4. For adversarial attacked examples, only examples which fool the network are included in the distribution for fair comparison. It may be noted that, the reconstruction errors for adversarial examples is higher than normal examples as expected. Also, reconstructions errors for randomly perturbed test samples are similar to those of normal examples but slightly larger as expected due to reconstruction error contributed from noise.
+
+
+
+Fig. 4: Reconstruction Distances for different Grey-box attacks
+
+$p$ -value Distribution: From the reconstruction error values, the distribution histogram of p-values of test samples for MNIST and CIFAR-10 datasets are given in Figure 5. It may be noted that, in case of adversaries, most samples have $p$ -value close to 0 due to their high reconstruction error; whereas for the normal and randomly perturbed images, $p$ -value is nearly uniformly distributed as expected.
+
+ROC Characteristics: Using the $p$ -values, ROC curves can be plotted as shown in Figure 6. As can be observed from ROC curves, clean and randomly perturbed attacks can be very well classified from all adversarial attacks. The values of ${\epsilon }_{atk}$ were used such that the attack is able to fool the target detector for at-least ${45}\%$ samples. The percentage of samples on which the attack was successful for each attack is shown in Table 1
+
+Statistical Results and Discussions: The statistics for clean, randomly perturbed and adversarial attacked images for MNIST and CIFAR datasets are given in Table II. Error rate signifies the ratio of the number of examples which were misclassified by the target network. Last column (AUC) lists the area under the ROC curve. The area for adversaries is expected to be close to 1 ; whereas for the normal and randomly perturbed images, it is expected to be around 0.5 .
+
+It is worthy to note that, the obtained statistics are much comparable with the state-of-the-art results as tabulated in
+
+
+
+(b) $p$ -values from CIFAR-10 dataset
+
+Fig. 5: Generated $p$ -values for different Grey-box attacks
+
+| References | Concepts Established | Datasets Used | Attack Types | Primary Results | Major Shortcomings | Advantages of our Proposed Work |
| (Hendrycks and Gimpel 2016) | PCA whitening on distribution of final softmax layer | MNIST, CIFAR- 10, Tiny- ImageNet | $\operatorname{FGSM}\left( {l}_{\infty }\right)$ , $\mathrm{{BIM}}\left( {l}_{\infty }\right)$ | AUC ROC for CIFAR-10: $\mathrm{{FGSM}}\left( {l}_{\infty }\right) = {0.928},$ $\mathrm{{BIM}}\left( {l}_{\infty }\right) = {0.912}$ | Not tested for strong attacks, Not tested to differentiate random noisy images | Ability to differentiate from randomly perturbed images, evaluation against strong attacks and target classifier. |
| (Li and Li 2017) | Cascade classi- fier based PCA statistics of in- termediate con- volution layers | ILSVRC- 2012 | L-BGFS (Similar to CW) | AUC of ROC: 0.908 | Not tested for strong attacks, standard datsets, for random noises | Ability to differentiate from randomly perturbed images, evaluation against strong and wider attacks. |
| (Metzen et al. 2017) | Binary classifier network with intermediate layer features as input | CIFAR- 10 | FGSM $\left( {{l}_{2},{l}_{\infty }}\right)$ , BIM $\left( {{l}_{2},{l}_{\infty }}\right)$ , DeepFool, Dynamic BIM (Similar to S-BIM) | Highest detection accuracy among different layers: $\mathrm{{FGSM}} = {0.97},$ $\operatorname{BIM}\left( {l}_{2}\right) = {0.8}$ , $\operatorname{BIM}\left( {l}_{\infty }\right) = {0.82}$ , $\mathrm{{DeepFool}}\left( {l}_{2}\right) = {0.72},$ DeepFool $\left( {l}_{\infty }\right)$ 0.75, Dynamic-BIM $= {0.8}$ (Average) | Need to train with adversarial examples, hence do not generalize well on other attacks, not evaluated for random noisy images | No use of adversaries for training, ability to differentiate from randomly perturbed images, more robust to dynamic adversaries, better AUC results |
| (Gong, Wang, and Ku 2017) | Binary classifier network trained with input image | MNIST, CIFAR- 10. SVHN | $\operatorname{FGSM}\left( {l}_{\infty }\right)$ , $\operatorname{TGSM}\left( {L\infty }\right)$ JSMA | Average accuracy of 0.9914 (MNIST), 0.8279 (CIFAR-10), 0.9378 (SVHN) | Trained with generated adversaries, hence does not generalize well on other adversaries, sensitive to $\epsilon$ changes | No use of adversaries for training, ability to differentiate from randomly perturbed images |
| (Carrara et al. 2018) | LSTM on dis- tant features at each layer of target classifier network | ILSVRC dataset | FGSM, BIM, PGD, L-BFGS $\left( {L\infty }\right)$ | ROC AUC: FGSM = 0.996, $\mathrm{{BIM}} = {0.997}$ , L-BFGS = 0.854 , PGD $= {0.997}$ | Not evaluated for differentiation from random noisy images, on special attack which has access to network weights | No use of adversaries for training, ability to differentiate from randomly perturbed images, evaluaion on ${l}_{2}$ attacks |
| (Feinman et al. 2017) | Bayesian density estimate on final softmax layer | MNIST, CIFAR- 10, SVHN | FGSM, BIM, JSMA, CW $\left( {l}_{\infty }\right)$ | CIFAR-10 ROC- AUC: FGSM $=$ 0.9057, $\mathrm{{BIM}} = {0.81}$ , JSMA $= {0.92},\mathrm{{CW}}$ $= {0.92}$ | No explicit test for random noisy images | Ability to differentiate between randomly perturbed images, better AUC values |
| (Song et al. 2017) | Using PixelDe- fend to get re- construction er- ror on input im- age | Fashion MNIST, CIFAR- 10 | FGSM, BIM, DeepFool, CW $\left( {L}_{\infty }\right)$ | ROC curves given, AUC not given | Cannot differentiate random noisy images from adversaries | Ability to differenti- ate between randomly perturbed and clean images |
| (Xu, Evans, and Qi 2017) | Feature squeez- ing and com- parison | MNIST, CIFAR- 10, ImageNet | FGSM, BIM, DeepFool, JSMA, CW | Overall detection rate: MNIST = 0.982, CIFAR-10 $=$ 0.845, ImageNet = 0.859 | No test for randomly perturbed images | Ability differentiate from randomly perturbed images, better AUC values |
| (Jha et al. 2018) | Using bayesian inference from manifolds on input image | MNIST, CIFAR- 10 | FGSM, BIM | No quantitative re- sults reported | No comparison with- out quantitative re- sults | Ability differentiate from randomly perturbed images, evaluation against strong attacks |
| (Fidel, Bitton, and Shabtai 2020) | Using SHAP signatures of input image | MNIST, CIFAR- 10 | FGSM, BIM, DeepFool etc. | Average ROC-AUC: CIFAR-10 = 0.966, MNIST $= {0.967}$ | Not tested for ran- dom noisy images | No use of adversaries for training, ability to differentiate from randomly perturbed images |
+
+TABLE IV: Summary of Related Works and Comparative Study with these Existing Methods
+
diff --git a/papers/AAAI/AAAI 2022/AAAI 2022 Workshop/AAAI 2022 Workshop AdvML/Ex1yemaQgU/Initial_manuscript_tex/Initial_manuscript.tex b/papers/AAAI/AAAI 2022/AAAI 2022 Workshop/AAAI 2022 Workshop AdvML/Ex1yemaQgU/Initial_manuscript_tex/Initial_manuscript.tex
new file mode 100644
index 0000000000000000000000000000000000000000..3f02e5fc895327592e9e3f40a0a40881a01868d6
--- /dev/null
+++ b/papers/AAAI/AAAI 2022/AAAI 2022 Workshop/AAAI 2022 Workshop AdvML/Ex1yemaQgU/Initial_manuscript_tex/Initial_manuscript.tex
@@ -0,0 +1,453 @@
+§ DETECTING ADVERSARIES, YET FALTERING TO NOISE? LEVERAGING CONDITIONAL VARIATIONAL AUTOENCODERS FOR ADVERSARY DETECTION IN THE PRESENCE OF NOISY IMAGES
+
+§ ABSTRACT
+
+With the rapid advancement and increased use of deep learning models in image identification, security becomes a major concern to their deployment in safety-critical systems. Since the accuracy and robustness of deep learning models are primarily attributed from the purity of the training samples, therefore the deep learning architectures are often susceptible to adversarial attacks. Adversarial attacks are often obtained by making subtle perturbations to normal images, which are mostly imperceptible to humans, but can seriously confuse the state-of-the-art machine learning models. What is so special in the slightest intelligent perturbations or noise additions over normal images that it leads to catastrophic classifications by the deep neural networks? Using statistical hypothesis testing, we find that Conditional Variational AutoEncoders (CVAE) are surprisingly good at detecting imperceptible image perturbations. In this paper, we show how CVAEs can be effectively used to detect adversarial attacks on image classification networks. We demonstrate our results over MNIST, CIFAR-10 dataset and show how our method gives comparable performance to the state-of-the-art methods in detecting adversaries while not getting confused with noisy images, where most of the existing methods falter.
+
+Index Terms-Deep Neural Networks, Adversarial Attacks, Image Classification, Variational Autoencoders, Noisy Images
+
+§ INTRODUCTION
+
+The phenomenal success of deep learning models in image identification and object detection has led to its wider adoption in diverse domains ranging from safety-critical systems, such as automotive and avionics (Rao and Frtunikj 2018) to healthcare like medical imaging, robot-assisted surgery, genomics etc. (Esteva et al. 2019), to robotics and image forensics (Yang et al. 2020), etc. The performance of these deep learning architectures are often dictated by the volume of correctly labelled data used during its training phases. Recent works (Szegedy et al. 2013) (Goodfellow, Shlens, and Szegedy 2014) have shown that small and carefully chosen modifications (often in terms of noise) to the input data of a neural network classifier can cause the model to give incorrect labels. This weakness of neural networks allows the possibility of making adversarial attacks on the input image by creating perturbations which are imperceptible to humans but however are able to convince the neural network in getting completely wrong results that too with very high confidence. Due to this, adversarial attacks may pose a serious threat to deploying deep learning models in real-world safety-critical applications. It is, therefore, imperative to devise efficient methods to thwart such adversarial attacks.
+
+Many recent works have presented effective ways in which adversarial attacks can be avoided. Adversarial attacks can be classified into whitebox and blackbox attacks. White-box attacks (Akhtar and Mian 2018) assume access to the neural network weights and architecture, which are used for classification, and thereby specifically targeted to fool the neural network. Hence, they are more accurate than blackbox attacks (Akhtar and Mian 2018) which do not assume access the model parameters. Methods for detection of adversarial attacks can be broadly categorized as - (i) statistical methods, (ii) network based methods, and (iii) distribution based methods. Statistical methods (Hendrycks and Gimpel 2016) (Li and Li 2017) focus on exploiting certain characteristics of the input images or the final logistic-unit layer of the classifier network and try to identify adversaries through their statistical inference. A certain drawback of such methods as pointed by (Carlini and Wagner 2017) is that the statistics derived may be dataset specific and same techniques are not generalized across other datasets and also fail against strong attacks like CW-attack. Network based methods (Metzen et al. 2017) (Gong, Wang, and Ku 2017) aim at specifically training a binary classification neural network to identify the adversaries. These methods are restricted since they do not generalize well across unknown attacks on which these networks are not trained, also they are sensitive to change with the amount of perturbation values such that a small increase in these values makes this attacks unsuccessful. Also, potential whitebox attacks can be designed as shown by (Carlini and Wagner 2017) which fool both the detection network as well as the adversary classifier networks. Distribution based methods (Feinman et al. 2017) (Gao et al. 2021) (Song et al. 2017) (Xu, Evans, and Qi 2017) (Jha et al. 2018) aim at finding the probability distribution from the clean examples and try to find the probability of the input example to quantify how much they fall within the same distribution. However, some of the methods do not guarantee robust separation of randomly perturbed and adversarial perturbed images. Hence there is a high chance that all these methods tend to get confused with random noises in the image, treating them as adversaries.
+
+Copyright © 2021, Association for the Advancement of Artificial Intelligence (www.aaai.org). All rights reserved.
+
+To overcome this drawback so that the learned models are robust with respect to both adversarial perturbations as well as sensitivity to random noises, we propose the use of Conditional Variational AutoEncoder (CVAE) trained over a clean image set. At the time of inference, we empirically establish that the input example falls within a low probability region of the clean examples of the predicted class from the target classifier network. It is important to note here that, this method uses both the input image as well as the predicted class to detect whether the input is an adversary as opposed to some distribution based methods which use only the distribution from the input images. On the contrary, random perturbations activate the target classifier network in such a way that the predicted output class matches with the actual class of the input image and hence it falls within the high probability region. Thus, it is empirically shown that our method does not confuse random noise with adversarial noises. Moreover, we show how our method is robust towards special attacks which have access to both the network weights of CVAE as well as the target classifier networks where many network based methods falter. Further, we show that to eventually fool our method, we may need larger perturbations which becomes visually perceptible to the human eye. The experimental results shown over MNIST and CIFAR-10 datasets present the working of our proposal. In particular, the primary contributions made by our work is as follows.
+
+(a) We propose a framework based on CVAE to detect the possibility of adversarial attacks.
+
+(b) We leverage distribution based methods to effectively differentiate between randomly perturbed and adversar-ially perturbed images.
+
+(c) We devise techniques to robustly detect specially targeted BIM-attacks (Metzen et al. 2017) using our proposed framework.
+
+To the best of our knowledge, this is the first work which leverages use of Variational AutoEncoder architecture for detecting adversaries as well as aptly differentiates noise from adversaries to effectively safeguard learned models against adversarial attacks.
+
+§ ADVERSARIAL ATTACK MODELS AND METHODS
+
+For a test example $X$ , an attacking method tries to find a perturbation, ${\Delta X}$ such that ${\left| \Delta X\right| }_{k} \leq {\epsilon }_{atk}$ where ${\epsilon }_{atk}$ is the perturbation threshold and $k$ is the appropriate order, generally selected as 2 or $\infty$ so that the newly formed perturbed image, ${X}_{adv} = X + {\Delta X}$ . Here, each pixel in the image is represented by the $\langle \mathrm{R},\mathrm{G},\mathrm{B}\rangle$ tuple, where $\mathrm{R},\mathrm{G},\mathrm{B} \in$ $\left\lbrack {0,1}\right\rbrack$ . In this paper, we consider only white-box attacks, i.e. the attack methods which have access to the weights of the target classifier model. However, we believe that our method should work much better for black-box attacks as they need more perturbation to attack and hence should be more easily detected by our framework. For generating the attacks, we use the library by (Li et al. 2020).
+
+§ RANDOM PERTURBATION (RANDOM)
+
+Random perturbations are simply unbiased random values added to each pixel ranging in between $- {\epsilon }_{atk}$ to ${\epsilon }_{atk}$ . Formally, the randomly perturbed image is given by,
+
+$$
+{X}_{\text{ rand }} = X + \mathcal{U}\left( {-{\epsilon }_{atk},{\epsilon }_{atk}}\right) \tag{1}
+$$
+
+where, $\mathcal{U}\left( {a,b}\right)$ denote a continuous uniform distribution in the range $\left\lbrack {a,b}\right\rbrack$ .
+
+§ FAST GRADIENT SIGN METHOD (FGSM)
+
+Earlier works by (Goodfellow, Shlens, and Szegedy 2014) introduced the generation of malicious biased perturbations at each pixel of the input image in the direction of the loss gradient ${\Delta }_{X}L\left( {X,y}\right)$ , where $L\left( {X,y}\right)$ is the loss function with which the target classifier model was trained. Formally, the adversarial examples with with ${l}_{\infty }$ norm for ${\epsilon }_{atk}$ are computed by,
+
+$$
+{X}_{\text{ adv }} = X + {\epsilon }_{\text{ atk }} \cdot \operatorname{sign}\left( {{\Delta }_{X}L\left( {X,y}\right) }\right) \tag{2}
+$$
+
+FGSM perturbations with ${l}_{2}$ norm on attack bound are calculated as,
+
+$$
+{X}_{adv} = X + {\epsilon }_{atk} \cdot \frac{{\Delta }_{X}L\left( {X,y}\right) }{{\left| {\Delta }_{X}L\left( X,y\right) \right| }_{2}} \tag{3}
+$$
+
+§ PROJECTED GRADIENT DESCENT (PGD)
+
+Earlier works by (Kurakin, Goodfellow, and Bengio 2017) propose a simple variant of the FGSM method by applying it multiple times with a rather smaller step size than ${\epsilon }_{atk}$ . However, as we need the overall perturbation after all the iterations to be within ${\epsilon }_{atk}$ -ball of $X$ , we clip the modified $X$ at each step within the ${\epsilon }_{atk}$ ball with ${l}_{\infty }$ norm.
+
+$$
+{X}_{{adv},0} = X, \tag{4a}
+$$
+
+$$
+{X}_{{adv},n + 1} = {\operatorname{Clip}}_{X}^{{\epsilon }_{atk}}\left\{ {{X}_{{adv},n} + \alpha \operatorname{.sign}\left( {{\Delta }_{X}L\left( {{X}_{{adv},n},y}\right) }\right) }\right\}
+$$
+
+(4b)
+
+Given $\alpha$ , we take the no of iterations, $n$ to be $\left\lfloor {\frac{2{\epsilon }_{atk}}{\alpha } + }\right.$ 2]. This attacking method has also been named as Basic Iterative Method (BIM) in some works.
+
+§ CARLINI-WAGNER (CW) METHOD
+
+(Carlini and Wagner 2017) proposed a more sophisticated way of generating adversarial examples by solving an optimization objective as shown in Equation 5. Value of $c$ is chosen by an efficient binary search. We use the same parameters as set in (Li et al. 2020) to make the attack.
+
+$$
+{X}_{\text{ adv }} = {\operatorname{Clip}}_{X}^{{\epsilon }_{\text{ atk }}}\left\{ {\mathop{\min }\limits_{\epsilon }\parallel \epsilon {\parallel }_{2} + c.f\left( {x + \epsilon }\right) }\right\} \tag{5}
+$$
+
+§ DEEPFOOL METHOD
+
+DeepFool (Moosavi-Dezfooli, Fawzi, and Frossard 2016) is an even more sophisticated and efficient way of generating adversaries. It works by making the perturbation iteratively towards the decision boundary so as to achieve the adversary with minimum perturbation. We use the default parameters set in (Li et al. 2020) to make the attack.
+
+§ PROPOSED FRAMEWORK LEVERAGING CVAE
+
+In this section, we present how Conditional Variational Au-toEncoders (CVAE), trained over a dataset of clean images, are capable of comprehending the inherent differentiable attributes between adversaries and noisy data and separate out both using their probability distribution map.
+
+§ CONDITIONAL VARIATIONAL AUTOENCODERS (CVAE)
+
+Variational AutoEncoder is a type of a Generative Adversarial Network (GAN) having two components as Encoder and Decoder. The input is first passed through an encoder to get the latent vector for the image. The latent vector is passed through the decoder to get the reconstructed input of the same size as the image. The encoder and decoder layers are trained with the objectives to get the reconstructed image as close to the input image as possible thus forcing to preserve most of the features of the input image in the latent vector to learn a compact representation of the image. The second objective is to get the distribution of the latent vectors for all the images close to the desired distribution. Hence, after the variational autoencoder is fully trained, decoder layer can be used to generate examples from randomly sampled latent vectors from the desired distribution with which the encoder and decoder layers were trained.
+
+ < g r a p h i c s >
+
+Fig. 1: CVAE Model Architecture
+
+Conditional VAE is a variation of VAE in which along with the input image, the class of the image is also passed with the input at the encoder layer and also with the latent vector before the decoder layer (refer to Figure 1). This helps Conditional VAE to generate specific examples of a class. The loss function for CVAE is defined by Equation 6, The first term is the reconstruction loss which signifies how closely can the input $X$ be reconstructed given the latent vector $z$ and the output class from the target classifier network as condition, $c$ . The second term of the loss function is the KL-divergence $\left( {\mathcal{D}}_{KL}\right)$ between the desired distribution, $P\left( {z \mid c}\right)$ and the current distribution $\left( {Q\left( {z \mid X,c}\right) }\right)$ of $z$ given input image $X$ and the condition $c$ .
+
+$$
+L\left( {X,c}\right) = \mathbb{E}\left\lbrack {\log P\left( {X \mid z,c}\right) }\right\rbrack - {\mathcal{D}}_{KL}\left\lbrack {Q\left( {z \mid X,c}\right) \parallel P\left( {z \mid c}\right) }\right\rbrack
+$$
+
+(6)
+
+§ TRAINING CVAE MODELS
+
+For modeling $\log P\left( {X \mid z,c}\right)$ , we use the decoder neural network to output the reconstructed image, ${X}_{rcn}$ where we utilize the condition $c$ which is the output class of the image to get the set of parameters, $\theta \left( c\right)$ for the neural network. We calculate Binary Cross Entropy (BCE) loss of the reconstructed image, ${X}_{rcn}$ with the input image, $X$ to model $\log P\left( {X \mid z,c}\right)$ . Similarly, we model $Q\left( {z \mid X,c}\right)$ with the encoder neural network which takes as input image $X$ and utilizes condition, $c$ to select model parameters, $\theta \left( c\right)$ and outputs mean, $\mu$ and $\log$ of variance, $\log {\sigma }^{2}$ as parameters assuming Gaussian distribution for the conditional distribution. We set the target distribution $P\left( {z \mid c}\right)$ as unit Gaussian distribution with mean 0 and variance 1 as $N\left( {0,1}\right)$ . The resultant loss function would be as follows,
+
+$$
+L\left( {X,c}\right) = \operatorname{BCE}\left\lbrack {X,\operatorname{Decoder}\left( {X,\theta \left( c\right) }\right) }\right\rbrack -
+$$
+
+$$
+\frac{1}{2}\left\lbrack {{\operatorname{Encoder}}_{\sigma }^{2}\left( {X,\theta \left( c\right) }\right) + {\operatorname{Encoder}}_{\mu }^{2}\left( {X,\theta \left( c\right) }\right) }\right.
+$$
+
+$$
+\left. {-1 - \log \left( {{\operatorname{Encoder}}_{\sigma }^{2}\left( {X,\theta \left( c\right) }\right) }\right) }\right\rbrack \tag{7}
+$$
+
+The model architecture weights, $\theta \left( c\right)$ are a function of the condition, $c$ . Hence, we learn separate weights for encoder and decoder layers of CVAE for all the classes. It implies learning different encoder and decoder for each individual class. The layers sizes are tabulated in Table 1. We train the Encoder and Decoder layers of CVAE on clean images with their ground truth labels and use the condition as the predicted class from the target classifier network during inference.
+
+max width=
+
+Attribute Layer Size
+
+1-3
+10*Encoder Conv2d Channels: (c, 32)
+
+2-3
+ X Kernel: (4,4, stride=2, padding=1)
+
+2-3
+ BatchNorm2d 32
+
+2-3
+ Relu X
+
+2-3
+ Conv2d Channels: (32, 64)
+
+2-3
+ X Kernel: (4,4, stride=2, padding=1)
+
+2-3
+ BatchNorm2d 64
+
+2-3
+ Relu X
+
+2-3
+ Conv2d Channels: (64, 128) Kernel: (4,4, stride=2, padding=1)
+
+2-3
+ BatchNorm2d 128
+
+1-3
+Mean Linear (1024, ${z}_{d\mathit{{im}}} = {128}$ )
+
+1-3
+Variance Linear (1024, ${z}_{d\;i\;m} =$ 128)
+
+1-3
+2*Project Linear $\left( {{z}_{dim} = {128},{1024}}\right)$
+
+2-3
+ Reshape (128,4,4)
+
+1-3
+10*Decoder ConvTranspose2d Channels: (128, 64) Kernel: (4,4, stride=2, padding=1)
+
+2-3
+ BatchNorm2d 64
+
+2-3
+ Relu X
+
+2-3
+ ConvTranspose2d Channels: (64, 32)
+
+2-3
+ X Kernel: (4,4, stride=2, padding=1)
+
+2-3
+ BatchNorm2d 64
+
+2-3
+ Relu X
+
+2-3
+ ConvTranspose2d Channels: (32, c)
+
+2-3
+ X Kernel: (4,4, stride=2, padding=1)
+
+2-3
+ Sigmoid X
+
+1-3
+
+TABLE I: CVAE Architecture Layer Sizes. $c =$ Number of Channels in the Input Image $(c = 3$ for CIIFAR-10 and $c = 1$ for MNIST).
+
+§ DETERMINING RECONSTRUCTION ERRORS
+
+Let $X$ be the input image and ${y}_{\text{ pred }}$ be the predicted class obtained from the target classifier network. ${X}_{{rcn},{y}_{pred}}$ is the reconstructed image obtained from the trained encoder and decoder networks with the condition ${y}_{\text{ pred }}$ . We define the reconstruction error or the reconstruction distance as in Equation 8. The network architectures for encoder and decoder layers are given in Figure 1.
+
+$$
+\operatorname{Recon}\left( {X,y}\right) = {\left( X - {X}_{{rcn},y}\right) }^{2} \tag{8}
+$$
+
+Two pertinent points to note here are:
+
+ * For clean test examples, the reconstruction error is bound to be less since the CVAE is trained on clean train images. As the classifier gives correct class for the clean examples, the reconstruction error with the correct class of the image as input is less.
+
+ * For the adversarial examples, as they fool the classifier network, passing the malicious output class, ${y}_{\text{ pred }}$ of the classifier network to the CVAE with the slightly perturbed input image, the reconstructed image tries to be closer to the input with class ${y}_{\text{ pred }}$ and hence, the reconstruction error is large.
+
+As an example, let the clean image be a cat and its slightly perturbed image fools the classifier network to believe it is a dog. Hence, the input to the CVAE will be the slightly perturbed cat image with the class dog. Now as the encoder and decoder layers are trained to output a dog image if the class inputted is dog, the reconstructed image will try to resemble a dog but since the input is a cat image, there will be large reconstruction error. Hence, we use reconstruction error as a measure to determine if the input image is adversarial. We first train the Conditional Variational AutoEncoder (CVAE) on clean images with the ground truth class as the condition. Examples of reconstructions for clean and adversarial examples are given in Figure 2 and Figure 3.
+
+ < g r a p h i c s >
+
+Fig. 2: Clean and Adversarial Attacked Images to CVAE from MNIST Dataset
+
+ < g r a p h i c s >
+
+Fig. 3: Clean and Adversarial Attacked Images to CVAE from CIFAR-10 Dataset.
+
+§ OBTAINING $P$ -VALUE
+
+As already discussed, the reconstruction error is used as a basis for detection of adversaries. We first obtain the reconstruction distances for the train dataset of clean images which is expected to be similar to that of the train images. On the other hand, for the adversarial examples, as the predicted class $y$ is incorrect, the reconstruction is expected to be worse as it will be more similar to the image of class $y$ as the decoder network is trained to generate such images. Also for random images, as they do not mostly fool the classifier network, the predicted class, $y$ is expected to be correct, hence reconstruction distance is expected to be less. Besides qualitative analysis, for the quantitative measure, we use the permutation test from (Efron and Tibshirani 1993). We can provide an uncertainty value for each input about whether it comes from the training distribution. Specifically, let the input ${X}^{\prime }$ and training images ${X}_{1},{X}_{2},\ldots ,{X}_{N}$ . We first compute the reconstruction distances denoted by $\operatorname{Recon}\left( {X,y}\right)$ for all samples with the condition as the predicted class $y =$ Classifier(X). Then, using the rank of $\operatorname{Recon}\left( {{X}^{\prime },{y}^{\prime }}\right)$ in $\{ \mathtt{{Recon}}({X}_{1},{y}_{1}),\mathtt{{Recon}}({X}_{2},{y}_{2}),\ldots ,\mathtt{{Recon}}({X}_{N},{y}_{N})\} \;$ as our test statistic, we get,
+
+$$
+T = T\left( {{X}^{\prime };{X}_{1},{X}_{2},\ldots ,{X}_{N}}\right)
+$$
+
+$$
+= \mathop{\sum }\limits_{{i = 1}}^{N}I\left\lbrack {\operatorname{Recon}\left( {{X}_{i},{y}_{i}}\right) \leq \operatorname{Recon}\left( {{X}^{\prime },{y}^{\prime }}\right) }\right\rbrack \tag{9}
+$$
+
+Where $I\left\lbrack .\right\rbrack$ is an indicator function which returns 1 if the condition inside brackets is true, and 0 if false. By permutation principle, $p$ -value for each sample will be,
+
+$$
+p = \frac{1}{N + 1}\left( {\mathop{\sum }\limits_{{i = 1}}^{N}I\left\lbrack {{T}_{i} \leq T}\right\rbrack + 1}\right) \tag{10}
+$$
+
+Larger $p$ -value implies that the sample is more probable to be a clean example. Let $t$ be the threshold on the obtained $p$ -value for the sample, hence if ${p}_{X,y} < t$ , the sample $X$ is classified as an adversary. Algorithm 1 presents the overall resulting procedure combining all above mentioned stages.
+
+Algorithm 1 Adversarial Detection Algorithm
+
+ function DETECT_ADVERSARIES $\left( {{X}_{\text{ train }},{Y}_{\text{ train }},X,t}\right)$
+
+ recon $\leftarrow \operatorname{Train}\left( {{X}_{\text{ train }},{Y}_{\text{ train }}}\right)$
+
+3: recon_dists $\leftarrow \operatorname{Recon}\left( {{X}_{\text{ train }},{Y}_{\text{ train }}}\right)$
+
+4: Adversaries $\leftarrow \phi$
+
+5: for $x$ in $X$ do
+
+6: ${y}_{\text{ pred }} \leftarrow$ Classifier(x)
+
+7: recon_dist_x $\leftarrow \operatorname{Recon}\left( {x,{y}_{\text{ pred }}}\right)$
+
+8: pval $\leftarrow p$ -value $\left( {\text{ recon\_dist\_x },\text{ recon\_dists }}\right)$
+
+9: if pval $\leq t$ then
+
+10: Adversaries.insert( $x$ )
+
+11: return Adversaries
+
+Algorithm 1 first trains the CVAE network with clean training samples (Line 2) and formulates the reconstruction distances (Line 3). Then, for each of the test samples which may contain clean, randomly perturbed as well as adversarial examples, first the output predicted class is obtained using a target classifier network, followed by finding it's reconstructed image from CVAE, and finally by obtaining it’s $p$ -value to be used for thresholding (Lines 5- 8). Images with $p$ -value less than given threshold(t)are classified as adversaries (Lines 9-10).
+
+§ EXPERIMENTAL RESULTS
+
+We experimented our proposed methodology over MNIST and CIFAR-10 datasets. All the experiments are performed in Google Colab GPU having ${0.82}\mathrm{{GHz}}$ frequency, ${12}\mathrm{{GB}}$ RAM and dual-core CPU having ${2.3}\mathrm{{GHz}}$ frequency, ${12}\mathrm{{GB}}$ RAM. An exploratory version of the code-base will be made public on github.
+
+§ DATASETS AND MODELS
+
+Two datasets are used for the experiments in this paper, namely MNIST (LeCun, Cortes, and Burges 2010) and CIFAR-10 (Krizhevsky 2009). MNIST dataset consists of hand-written images of numbers from 0 to 9 . It consists of 60,000 training examples and 10,000 test examples where each image is a ${28} \times {28}$ gray-scale image associated with a label from 1 of the 10 classes. CIFAR-10 is broadly used for comparison of image classification tasks. It also consists of 60,000 image of which 50,000 are used for training and the rest10,000are used for testing. Each image is a ${32} \times {32}$ coloured image i.e. consisting of 3 channels associated with a label indicating 1 out of 10 classes.
+
+We use state-of-the-art deep neural network image classifier, ResNet18 (He et al. 2015) as the target network for the experiments. We use the pre-trained model weights available from (Idelbayev) for both MNIST as well as CIFAR-10 datasets.
+
+§ PERFORMANCE OVER GREY-BOX ATTACKS
+
+If the attacker has the access only to the model parameters of the target classifier model and no information about the detector method or it's model parameters, then we call such attack setting as Grey-box. This is the most common attack setting used in previous works against which we evaluate the most common attacks with standard epsilon setting as used in other works for both the datasets. For MNIST, the value of $\epsilon$ is commonly used between 0.15-0.3 for FGSM attack and 0.1 for iterative attacks (Samangouei, Kabkab, and Chellappa 2018) (Gong, Wang, and Ku 2017) (Xu, Evans, and Qi 2017). While for CIFAR10, the value of $\epsilon$ is most commonly chosen to be $\frac{8}{255}$ as in (Song et al. 2017) (Xu, Evans, and Qi 2017) (Fidel, Bitton, and Shabtai 2020). For DeepFool (Moosavi-Dezfooli, Fawzi, and Frossard 2016) and Carlini Wagner (CW) (Carlini and Wagner 2017) attacks, the $\epsilon$ bound is not present. The standard parameters as used by default in (Li et al. 2020) have been used for these 2 attacks. For ${L}_{2}$ attacks, the $\epsilon$ bound is chosen such that success of the attack is similar to their ${L}_{\infty }$ counterparts as the values used are very different in previous works.
+
+Reconstruction Error Distribution: The histogram distribution of reconstruction errors for MNIST and CIFAR- 10 datasets for different attacks are given in Figure 4. For adversarial attacked examples, only examples which fool the network are included in the distribution for fair comparison. It may be noted that, the reconstruction errors for adversarial examples is higher than normal examples as expected. Also, reconstructions errors for randomly perturbed test samples are similar to those of normal examples but slightly larger as expected due to reconstruction error contributed from noise.
+
+ < g r a p h i c s >
+
+Fig. 4: Reconstruction Distances for different Grey-box attacks
+
+$p$ -value Distribution: From the reconstruction error values, the distribution histogram of p-values of test samples for MNIST and CIFAR-10 datasets are given in Figure 5. It may be noted that, in case of adversaries, most samples have $p$ -value close to 0 due to their high reconstruction error; whereas for the normal and randomly perturbed images, $p$ -value is nearly uniformly distributed as expected.
+
+ROC Characteristics: Using the $p$ -values, ROC curves can be plotted as shown in Figure 6. As can be observed from ROC curves, clean and randomly perturbed attacks can be very well classified from all adversarial attacks. The values of ${\epsilon }_{atk}$ were used such that the attack is able to fool the target detector for at-least ${45}\%$ samples. The percentage of samples on which the attack was successful for each attack is shown in Table 1
+
+Statistical Results and Discussions: The statistics for clean, randomly perturbed and adversarial attacked images for MNIST and CIFAR datasets are given in Table II. Error rate signifies the ratio of the number of examples which were misclassified by the target network. Last column (AUC) lists the area under the ROC curve. The area for adversaries is expected to be close to 1 ; whereas for the normal and randomly perturbed images, it is expected to be around 0.5 .
+
+It is worthy to note that, the obtained statistics are much comparable with the state-of-the-art results as tabulated in
+
+ < g r a p h i c s >
+
+(b) $p$ -values from CIFAR-10 dataset
+
+Fig. 5: Generated $p$ -values for different Grey-box attacks
+
+max width=
+
+2*Type 2|c|Error Rate (%) 2|c|Parameters 2|c|AUC
+
+2-7
+ MNIST CIFAR-10 MNIST CIFAR-10 MNIST CIFAR-10
+
+1-7
+NORMAL 2.2 8.92 - - 0.5 0.5
+
+1-7
+RANDOM 2.3 9.41 $\epsilon = {0.1}$ $\epsilon = \frac{8}{255}$ 0.52 0.514
+
+1-7
+FGSM 90.8 40.02 $\epsilon = {0.15}$ $\epsilon = \frac{8}{255}$ 0.99 0.91
+
+1-7
+FGSM-L2 53.3 34.20 $\epsilon = {1.5}$ $\epsilon = 1$ 0.95 0.63
+
+1-7
+R-FGSM 91.3 41.29 $\epsilon = \left( {{0.05},{0.1}}\right)$ $\epsilon = \left( {\frac{4}{255},\frac{8}{255}}\right)$ 0.99 0.91
+
+1-7
+R-FGSM-L2 54.84 34.72 $\epsilon = \left( {{0.05},{1.5}}\right)$ $\mathit{\epsilon }\mathrm{ = }\mathrm{(}\frac{\mathrm{4}}{\mathrm{{255}}}\mathrm{,}\mathrm{1}\mathrm{)}$ 0.95 0.64
+
+1-7
+PGD 82.13 99.17 $\epsilon = {0.1},n = {12}$ ${\epsilon }_{step} = {0.02}$ $\mathit{\epsilon }\mathrm{ = }\frac{\mathrm{8}}{\mathrm{{255}}}\mathrm{,}\mathit{n}\mathrm{ = }\mathrm{1}\mathrm{2}$ ${\epsilon }_{step} = \frac{1}{255}$ 0.974 0.78
+
+1-7
+CW 100 100 - - 0.98 0.86
+
+1-7
+DeepFool 97.3 93.89 - - 0.962 0.75
+
+1-7
+
+TABLE II: Image Statistics for MNIST and CIFAR-10. AUC : Area Under the ROC Curve. Error Rate (%) : Percentage of samples mis-classified or Successfully-attacked
+
+Table IV (Given in the Appendix). Interestingly, some of the methods (Song et al. 2017) explicitly report comparison results with randomly perturbed images and are ineffective in distinguishing adversaries from random noises, but most other methods do not report results with random noise added to the input image. Since other methods use varied experimental setting, attack models, different datasets as well as ${\epsilon }_{atk}$ values and network model, exact comparisons with other methods is not directly relevant primarily due to such varied experimental settings. However, the results reported within the Table IV (Given in the Appendix) are mostly similar to our results while our method is able to statistically differentiate from random noisy images.
+
+In addition to this, since our method does not use any adversarial examples for training, it is not prone to changes in value of $\epsilon$ or with change in attacks which network based methods face as they are explicitly trained with known values of $\epsilon$ and types of attacks. Moreover, among distribution and statistics based methods, to the best of our knowledge, utilization of the predicted class from target network has not been done before. Most of these methods either use the input image itself (Jha et al. 2018) (Song et al. 2017) (Xu, Evans, and Qi 2017), or the final logits layer (Feinman et al. 2017) (Hendrycks and Gimpel 2016), or some intermediate layer (Li and Li 2017) (Fidel, Bitton, and Shabtai 2020) from target architecture for inference, while we use the input image and the predicted class from target network to do the same.
+
+ < g r a p h i c s >
+
+(b) CIFAR-10 dataset
+
+Fig. 6: ROC Curves for different Grey-box attacks
+
+§ PERFORMANCE OVER WHITE-BOX ATTACKS
+
+In this case, we evaluate the attacks if the attacker has the information of both the defense method as well as the target classifier network. (Metzen et al. 2017) proposed a modified PGD method which uses the gradient of the loss function of the detector network assuming that it is differentiable along with the loss function of the target classifier network to generate the adversarial examples. If the attacker also has access to the model weights of the detector CVAE network, an attack can be devised to fool both the detector as well as the classifier network. The modified PGD can be expressed as follows :-
+
+$$
+{X}_{{adv},0} = X \tag{11a}
+$$
+
+$$
+{X}_{{adv},n + 1} = {\operatorname{Clip}}_{X}^{{\epsilon }_{atk}}\left\{ {{X}_{{adv},n} + }\right.
+$$
+
+$$
+\text{ }\alpha \text{ .sign }\left( {\text{ (1 } - \sigma ).{\Delta }_{X}{L}_{cls}\left( {{X}_{{adv},n},{y}_{\text{ target }}}\right) + }\right.
+$$
+
+$$
+\left. {\sigma .{\Delta }_{X}{L}_{\text{ det }}\left( {{X}_{\text{ adv },n},{y}_{\text{ target }}}\right) )}\right\} \tag{11b}
+$$
+
+Where ${y}_{\text{ target }}$ is the target class and ${L}_{\text{ det }}$ is the reconstruction distance from Equation 8. It is worthy to note that our proposed detector CVAE is differentiable only for the targeted attack setting. For the non-targeted attack, as the condition required for the CVAE is obtained from the target classifier output which is discrete, the differentiation operation is not valid. We set the target randomly as any class other than the true class for testing.
+
+Effect of $\sigma$ : To observe the effect of changing value of $\sigma$ , we keep the value of $\epsilon$ fixed at 0.1 . As can be observed in Figure 7, the increase in value of $\sigma$ implies larger weight on fooling the detector i.e. getting less reconstruction distance. Hence, as expected the attack becomes less successful with larger values of $\sigma \left\lbrack 8\right\rbrack$ and gets lesser AUC values [7], hence more effectively fooling the detector. For CIFAR-10 dataset, the detection model does get fooled for higher $c$ - values but however the error rate is significantly low for those values, implying that only a few samples get attacks on setting such value.
+
+ < g r a p h i c s >
+
+Fig. 7: ROC Curves for different values of $\sigma$ . More area under the curve implies better detectivity for that attack. With more $\sigma$ value, the attack, as the focus shifts to fooling the detector, it becomes difficult for the detector to detect.
+
+Effect of $\epsilon$ : With changing values of $\epsilon$ , there is more space available for the attack to act, hence the attack becomes more successful as more no of images are attacked as observed in Figure 10. At the same time, the trend for AUC curves is shown in Figure 9. The initial dip in the value is as expected as the detector tends to be fooled with larger $\epsilon$ bound. From both these trends, it can be noted that for robustly attacking both the detector and target classifier for significantly higher no of images require significantly larger attack to be made for both the datasets.
+
+ < g r a p h i c s >
+
+Fig. 8: Success rate for different values of $\sigma$ . More value of $\sigma$ means more focus on fooling the detector, hence success rate of fooling the detector decreases with increasing $\sigma$ .
+
+ < g r a p h i c s >
+
+Fig. 9: ROC Curves for different values of $\epsilon$ . With more $\epsilon$ value, due to more space available for the attack, attack becomes less detectable on average.
+
+§ RELATED WORKS
+
+There has been an active research in the direction of adversaries and the ways to avoid them, primarily these methods are statistical as well as machine learning (neural network) based which produces systematic identification and rectification of images into desired target classes.
+
+Statistical Methods: Statistical methods focus on exploiting certain characteristics of the input images and try to identify adversaries through their statistical inference. Some early works include use of PCA, softmax distribution of final layer logits (Hendrycks and Gimpel 2016), reconstruction from logits (Li and Li 2017) to identify adversaries. Carlini and Wagner (Carlini and Wagner 2017) showed how these methods are not robust against strong attacks and most of the methods work on some specific datasets but do not generalize on others as the same statistical thresholds do not work.
+
+ < g r a p h i c s >
+
+Fig. 10: Success rate for different values of $\epsilon$ . More value of $\epsilon$ means more space available for the attack, hence success rate increases
+
+Network based Methods: Network based methods aim at specifically training a neural network to identify the adversaries. Binary classification networks (Metzen et al. 2017) (Gong, Wang, and Ku 2017) are trained to output a confidence score on the presence of adversaries. Some methods propose addition of a separate classification node in the target network itself (Hosseini et al. 2017). The training is done in the same way with the augmented dataset. (Carrara et al. 2018) uses feature distant spaces of intermediate layer values in the target network to train an LSTM network for classifying adversaries. Major challenges faced by these methods is that the classification networks are differentiable, thus if the attacker has access to the weights of the model, a specifically targeted attack can be devised as suggested by Carlini and Wagner (Carlini and Wagner 2017) to fool both the target network as well as the adversary classifier. Moreover, these methods are highly sensitive to the perturbation threshold set for adversarial attack and fail to identify attacks beyond a preset threshold.
+
+Distribution based Methods: Distribution based methods aim at finding the probability distribution from the clean examples and try to find the probability of the input example to fall within the same distribution. Some of these methods include using Kernel Density Estimate on the logits from the final softmax layer (Feinman et al. 2017). (Gao et al. 2021) used Maximum mean discrepancy (MMD) from the distribution of the input examples to classify adversaries based on their probability of occurrence in the input distribution. PixelDefend (Song et al. 2017) uses PixelCNN to get the Bits Per Dimension (BPD) score for the input image. (Xu, Evans, and Qi 2017) uses the difference in the final logit vector for original and squeezed images as a medium to create distribution and use it for inference. (Jha et al. 2018) compares different dimensionality reduction techniques to get low level representations of input images and use it for bayesian inference to detect adversaries.
+
+Some other special methods include use of SHAP signatures (Fidel, Bitton, and Shabtai 2020) which are used for getting explanations on where the classifier network is focusing as an input for detecting adversaries.
+
+A detailed comparative study with all these existing approaches is summarized through Table IV in the Appendix.
+
+§ COMPARISON WITH STATE-OF-THE-ART USING GENERATIVE NETWORKS
+
+Finally we compare our work with these 3 works (Meng and Chen 2017) (Hwang et al. 2019) (Samangouei, Kabkab, and Chellappa 2018) proposed earlier which uses Generative networks for detection and purification of adversaries. We make our comparison on MNIST dataset which is used commonly in the 3 works (Table III). Our results are typically the best for all attacks or are off by short margin from the best. For the strongest attack, our performance is much better. This show how our method is more effective while not being confused with random perturbation as an adversary. More details are given in the Appendix.
+
+max width=
+
+2*Type 4|c|AUC
+
+2-5
+ MagNet PuVAE DefenseGAN CVAE (Ours)
+
+1-5
+RANDOM 0.61 0.72 0.52 0.52
+
+1-5
+FGSM 0.98 0.96 0.77 0.99
+
+1-5
+FGSM-L2 0.84 0.60 0.60 0.95
+
+1-5
+R-FGSM 0.989 0.97 0.78 0.987
+
+1-5
+R-FGSM-L2 0.86 0.61 0.62 0.95
+
+1-5
+PGD 0.98 0.95 0.65 0.97
+
+1-5
+CW 0.983 0.92 0.94 0.986
+
+1-5
+DeepFool 0.86 0.86 0.92 0.96
+
+1-5
+Strongest 0.84 0.60 0.60 0.95
+
+1-5
+
+TABLE III: Comparison in ROC AUC statistics with other methods. More AUC implies more detectablity. 0.5 value of AUC implies no detection. For RANDOM, value close to 0.5 is better while for adversaries, higher value is better.
+
+§ CONCLUSION
+
+In this work, we propose the use of Conditional Variational AutoEncoder (CVAE) for detecting adversarial attacks. We utilized statistical base methods to verify that the adversarial attacks usually lie outside of the training distribution. We demonstrate how our method can specifically differentiate between random perturbations and targeted attacks which is necessary for some applications where the raw camera image may contain random noises which should not be confused with an adversarial attack. Furthermore, we demonstrate how it takes huge targeted perturbation to fool both the detector as well as the target classifier. Our framework presents a practical, effective and robust adversary detection approach in comparison to existing state-of-the-art techniques which falter to differentiate noisy data from adversaries. As a possible future work, it would be interesting to see the use of Variational AutoEncoders for automatically purifying the adversarialy attacked images.
\ No newline at end of file
diff --git a/papers/AAAI/AAAI 2022/AAAI 2022 Workshop/AAAI 2022 Workshop AdvML/HbasA9ysA3/Initial_manuscript_md/Initial_manuscript.md b/papers/AAAI/AAAI 2022/AAAI 2022 Workshop/AAAI 2022 Workshop AdvML/HbasA9ysA3/Initial_manuscript_md/Initial_manuscript.md
new file mode 100644
index 0000000000000000000000000000000000000000..fe205fca8f18097c983be148a08c2dfb00e85740
--- /dev/null
+++ b/papers/AAAI/AAAI 2022/AAAI 2022 Workshop/AAAI 2022 Workshop AdvML/HbasA9ysA3/Initial_manuscript_md/Initial_manuscript.md
@@ -0,0 +1,419 @@
+## Optimal Robust Classification Trees
+
+## Abstract
+
+In many high-stakes domains, the data used to drive machine learning algorithms is noisy (due to e.g., the sensitive nature of the data being collected, limited resources available to validate the data, etc). This may cause a distribution shift to occur, where the distribution of the training data does not match the distribution of the testing data. In the presence of distribution shifts, any trained model can perform poorly in the testing phase. In this paper, motivated by the need for interpretability and robustness, we propose a mixed-integer optimization formulation and a tailored solution algorithm for learning optimal classification trees that are robust to adversarial perturbations in the data features. We evaluate the performance of our approach on numerous publicly available datasets, and compare the performance to a regularized, non-robust optimal tree. We show an increase of up to 14.16% in worst-case accuracy and increase of up to 4.72% in average-case accuracy across several data sets and distribution shifts from using our robust solution in comparison to the non-robust solution.
+
+## 1 Introduction
+
+Machine learning techniques are increasingly being used in high-stakes domains to assist humans in making important decisions. Within these applications, black box models that need explanation should be avoided as decisions made from these models may have a profound impact (Rudin 2019). That is, we need inherently interpretable models where decisions made can be simply understood and verified. One of the most interpretable models are classification trees, which are easily visualized and do not require extensive knowledge to use. Classification trees are a widely used model that takes the form of a binary tree. At each branching node, a test based off of the attributes of the given data sample is made, which dictates the next node visited. Then at an assignment node, a particular label is assigned to the data sample (Breiman et al. 2017).
+
+However, as with many other machine learning models, classification trees are susceptible to distribution shifts. That is, the distribution of the training data and the testing data may be different, causing poor performance in deployment (Quiñonero-Candela et al. 2009). In high-stakes domains where there is a need for interpretability, there must also be robustness against distribution shifts to ensure high-quality solutions under any realization of the training data.
+
+### 1.1 Background and Related Work
+
+Traditionally, classification trees are built using heuristic approaches since the problem of building optimal classification trees is $\mathcal{{NP}}$ -hard (Breiman et al. 2017). But in settings where the quality of solutions is important, heuristic approaches may yield suboptimal solutions that are unacceptable for use in applications. Thus, to ensure a high-quality decision tree, mathematical optimization techniques, like mixed-integer optimization (MIO), have been developed for building optimal trees. Namely, Bertsimas and Dunn (2017) were the first to use MIO to build optimal decision trees. To combat the long run times for making optimal decision trees on large data sets, Verwer and Zhang (2019) create a binary linear programming formulation that has a run time independent of the amount of training samples. Aghaei, Gómez, and Vayanos (2021) build a strong, "flow-based" MIO formulation that greatly improves on solving times in comparison to other state-of-the-art optimal classification tree algorithms. MIO approaches for constructing decision trees have also allowed for several extensions. For example, Mišić (2020) formulates the problem of creating tree ensembles as a MIO problem, Aghaei, Azizi, and Vayanos (2019) create optimal and fair decision trees using MIO, and Jo et al. (2021) use MIO to build optimal prescriptive trees from observational data.
+
+To account for the problem of distribution shifts, there exists both non-MIO and MIO approaches. One type of non-MIO method up-weights training samples that match the test set distribution and down-weights the training samples that differ from the test set (Shimodaira 2000; Bickel, Brückner, and Scheffer 2007). These methods usually define distribution shift as a biased sampling of training data, where assigning weights to training samples diminishes the effects of adversarial examples.
+
+Another way to define a distribution shift is as an adversarial perturbation of the trained data that makes it differ from the test data. Motivated by this viewpoint, there have been several optimization-based methods to deal with distribution shifts. One of these methods is distributionally robust optimization, which combats the effects of distribution shifts by performing well under an adversarial distribution of samples. Both Kuhn et al. (2019) and Sinha et al. (2020) in particular provide distributionally robust approaches to building machine learning models that perform well under an adversarial distribution of the training data, where the adversarial distribution is in some Wasserstein distance from the nominal distribution of the data.
+
+---
+
+Copyright © 2022, Association for the Advancement of Artificial Intelligence (www.aaai.org). All rights reserved.
+
+---
+
+Distributionally robust optimization requires an assumption on the distribution of the data available, which may not be a reasonable assumption to make. In the case where such an assumption cannot be reasonably made, robust optimization provides a framework to generate solutions that perform well in the worst-case perturbation, where the perturbation comes from a set of values without a probability distribution assumption imposed (Ben-Tal, El Ghaoui, and Nemirovski 2009). Many common machine learning models have been formulated as robust optimization problems to deal with uncertainty in data. For example, robust optimization has been used for creating robust support vector machines (Shivaswamy, Bhattacharyya, and Smola 2006; Bert-simas et al. 2019). Robust optimization has also been used to create artificial neural networks that are robust against adversarial perturbations of the data (Shaham, Yamada, and Negahban 2018).
+
+In a similar spirit to these previous works, we propose using robust optimization to create a classification tree robust to distribution shifts. In an adversarial setting, we must decide the tree structure before observing the perturbation of the data. The perturbation of a sample, once unveiled, reveals whether the given tree structure correctly classifies the realization of the sample. That is, the classification of samples in a decision tree is dependent on both the tree structure and the realization of the uncertain parameter. Decision variables that indicate the correct classification of samples are called second-stage decisions, which can be modeled through two-stage robust optimization (Ben-Tal et al. 2004).
+
+There have been several recent methods for robust classification trees. Namely, Vos and Verwer (2021) have a local search algorithm for decision trees robust against adversarial examples derived from a user-defined threat model. Bertsimas et al. (2019) have a robust optimization formulation for robust trees where the uncertainty set is modeled by restricting the norm of the perturbation parameter. Unlike our proposed method, Bertsimas et al. (2019) do not capture the dependent relationship between the perturbation of the covariates and the classification of training samples, as decisions made on the classification of training samples are made before the realization of the uncertain parameter. Thus, they cannot identify correctly classified data points in the realization of the worst-case perturbation. So, differing from previous work, we argue that the decision variables related to the classification of training samples should be modeled as second-stage decisions. And by modeling these variables as second-stage decisions, we obtain less conservative solutions than a single-stage approach to the same problem.
+
+With these motivating factors in mind, we propose a two-stage, MIO method for learning optimal classification trees robust to distribution shifts in the data. Namely, we present a flow-based optimization problem, where we model uncertainty through a cost-and-budget framework. We then present a tailored Benders decomposition algorithm that solves this two-stage formulation to optimality. We evaluate the performance of our formulation on publicly available data sets for several problem instances to measure the effectiveness of our method in mitigating the adverse effects of distribution shifts.
+
+## 2 Robust Tree Formulation
+
+In this section, we present our formulation for a robust classification tree. We describe the structure of the classification tree, present the proposed two-stage formulation, and discuss our model of uncertainty.
+
+### 2.1 Setup and Notation
+
+Let ${\left\{ {\mathbf{x}}^{i},{y}^{i}\right\} }_{i \in \mathcal{I}}$ be the training set, where $\mathcal{I}$ is the index set for our training samples. The covariates are ${\mathbf{x}}^{i} \in {\mathbb{Z}}^{\left| \mathcal{F}\right| }$ , where $\mathcal{F}$ is the set of features of our data, and ${y}^{i}$ is some label in a finite set $\mathcal{K}$ . With a slight abuse of notation, we will let $\mathbf{x}$ denote the the vector concatenation of the rows of the $\left| \mathcal{I}\right| \times \left| \mathcal{F}\right|$ matrix of all training covariates, and $\mathbf{y}$ the $\left| \mathcal{I}\right|$ -sized vector of all training labels. The training set ${\left\{ {\mathbf{x}}^{i},{y}^{i}\right\} }_{i \in \mathcal{I}}$ is used to determine the tree structure, which includes deciding what binary tests to perform and labels to predict. Thus, in the first stage of our problem, we decide the tree structure to maximize the number of correct classifications for the given training data.
+
+Let ${\mathbf{\xi }}^{i} \in {\mathbb{Z}}^{\left| \mathcal{F}\right| }$ represent a perturbation of the covariate ${\mathbf{x}}^{i}$ . We can only observe ${\mathbf{\xi }}^{i} \in {\mathbb{Z}}^{\left| \mathcal{F}\right| }$ after making our first stage decisions on the tree structure. So ${\mathbf{x}}^{i} + {\mathbf{\xi }}^{i}$ represent the realization of the training sample $i$ after determining the tree structure. We let the covariate and perturbation value at sample $i$ and feature $f$ be ${x}_{f}^{i}$ and ${\xi }_{f}^{i}$ respectively. Also, denote $\mathbf{\xi }$ as the vector concatenation of the rows of the $\left| \mathcal{I}\right| \times$ $\left| \mathcal{F}\right|$ matrix of perturbations, and let $\Xi$ be our perturbation set that defines all possible $\xi$ .
+
+As mentioned before, the second stage decisions are the classification of training samples, which occurs after deciding the tree structure and observing the worst-case perturbation. To classify sample $i$ after perturbation, we must perform the series of binary tests for covariate ${\mathbf{x}}^{i} + {\mathbf{\xi }}^{i}$ from the tree decided on in the first stage. The binary test uses a threshold $\theta$ such that if ${x}_{f}^{i} + {\xi }_{f}^{i} \leq \theta$ , then sample $i$ travels to the left child. Likewise, if ${x}_{f}^{i} + {\xi }_{f}^{i} \geq \theta + 1$ , then sample $i$ travels to the right child. Letting ${c}_{f}$ and ${d}_{f}$ be the lower and upper bound of realized values for feature $f$ respectively, we define
+
+$$
+\Theta \left( f\right) \mathrel{\text{:=}} \left\{ {\theta \in \mathbb{Z} \mid {c}_{f} \leq \theta < {d}_{f}}\right\}
+$$
+
+as the set of possible binary test threshold values for feature $f$ .
+
+### 2.2 The Two-Stage Problem
+
+We will set up our robust formulation based on the non-robust classification tree outlined by (Aghaei, Gómez, and Vayanos 2021), where a binary classification tree is represented by a directed graph. The model starts with a depth $d$ binary tree, where the internal nodes are in the set $\mathcal{N}$ and the leaf nodes are in the set $\mathcal{L}$ . A node in $\mathcal{N}$ can either be a branching node where a binary test is performed, or an assignment node where a classification of a sample is made. Nodes in $\mathcal{L}$ can only be assignment nodes. There are ${2}^{d} - 1$ nodes in $\mathcal{N}$ and ${2}^{d}$ nodes in $\mathcal{L}$ , and we number each node from 1 to ${2}^{d + 1} - 1$ in a breadth-first search pattern. We then augment this tree by adding a single source node $s$ connected to the root node of the tree, and a sink node $t$ connected to each node in $\mathcal{N} \cup \mathcal{L}$ . By adding a source and sink node, we say that any data sample $i$ travels from the source $s$ through the tree based on ${\mathbf{x}}^{i}$ and reaches the sink if and only if the datapoint is correctly classified. Lastly, we denote the left and right child of node $n \in \mathcal{N}$ as $l\left( n\right)$ and $r\left( n\right)$ respectively, and also denote the ancestor of any node $n \in \mathcal{N} \cup \mathcal{L}$ as $a\left( n\right)$ .
+
+
+
+Figure 1: The left graph shows a classification tree with depth 2. Nodes $s$ and $t$ are the source and sink nodes respectively, $\mathcal{N} = \{ 1,2,3\}$ and $\mathcal{L} = \{ 4,5,6,7\}$ . The right graph shows an example of induced graph of a particular sample, where the green, bold edges are the subset of edges included in the induced graph. For this particular induced graph, nodes 1 and 3 are branching nodes, where the sample would be routed left and right, respectively. Nodes 2 and 6 assign the correct label, and node 7 does not assign the correct label. The maximum flow from $s$ to $t$ is 1 in this induced graph, indicating a correct classification.
+
+To determine whether a data sample $i$ is correctly classified by a given tree, we consider an induced graph of the original directed graph for data sample $i$ . In this induced graph, we keep every node in $\mathcal{N} \cup \mathcal{L}$ , the source $s$ , and the sink $t$ . For every branching node, we remove the edge leading to the sink node $t$ and the edge that fails the binary test based on the value of ${\mathbf{x}}^{i} + {\mathbf{\xi }}^{i}$ . And for every assignment node, we include the edge leading to $t$ only if the assigned class of that node is ${y}^{i}$ , and exclude all other edges leaving the assignment node. Lastly, we include the edge from the source $s$ to the root node 1 . Therefore, a maximum flow of 1 from $s$ to $t$ of this induced graph means that data sample $i$ would be correctly classified. Figure 1 illustrates an induced graph.
+
+With the flow graph setup, we propose a two-stage formulation for creating robust classification trees. In the first stage, we decide the structure of the tree. Let ${b}_{nf\theta }$ , defined over all $n \in \mathcal{N}, f \in \mathcal{F}$ , and $\theta \in \Theta \left( f\right)$ be a binary variable that denotes the branching decisions. If ${b}_{nf\theta } = 1$ , then node $n$ is a branching node, where the binary test is on feature $f$ with threshold $\theta$ . We also let ${w}_{nk}$ , defined over all $n \in \mathcal{N} \cup \mathcal{L}$ and all $k \in \mathcal{K}$ , be a binary variable that denotes the assignment decisions. If ${w}_{nk} = 1$ , then node $n$ is an assignment node with assignment label $k$ . We will denote $\mathbf{b}$ and $\mathbf{w}$ as the collection of ${b}_{nf\theta }$ and ${w}_{nk}$ variables respectively.
+
+Given a value of $\mathbf{b}$ and $\mathbf{w}$ , we find the perturbation in $\Xi$ that results in the minimum number of correctly classified points, which we will call the worst-case perturbation. In the second stage, after observing the worst-case perturbation of our covariates $\xi$ from the set $\Xi$ given a certain tree structure, we classify each of our points based on our tree. Let ${z}_{n, m}^{i}$ indicate whether data point $i$ flows down the edge between $n$ and $m$ and is correctly classified by the tree for $n \in \mathcal{N} \cup \mathcal{L} \cup \{ s\}$ and $m \in \mathcal{N} \cup \mathcal{L} \cup \{ t\}$ under the worst-case perturbation. We will let $\mathbf{z}$ be the vector concatenation of the rows of the $\left| \mathcal{I}\right| \times \left( {{2}^{d + 2} - 2}\right)$ matrix of ${z}_{n, m}^{i}$ values with rows corresponding to data sample $i$ and columns representing edge(n, m)for $n = a\left( m\right)$ . Note that ${z}_{n, m}^{i}$ are the decision variables of a maximum flow problem, where in the induced graph from data sample $i,{z}_{n, m}^{i}$ is 1 if and only if the maximum flow is 1 and the flow goes from node $n$ to node $m$ . Therefore, if there exists an $n \in \mathcal{N} \cup \mathcal{L}$ such that ${z}_{n, t}^{i} = 1$ , then sample $i$ is correctly classified by our tree after observing the worst-case perturbation.
+
+Our two-stage approach to defining the variables $\mathbf{b},\mathbf{w}$ , $\xi$ , and $\mathbf{z}$ leads us to the following formulation for a robust classification tree:
+
+$$
+\mathop{\max }\limits_{{\mathbf{b},\mathbf{w}}}\mathop{\min }\limits_{{\mathbf{\xi } \in \Xi }}\mathop{\max }\limits_{{\mathbf{z} \in \mathcal{Z}\left( {\mathbf{b},\mathbf{w},\mathbf{\xi }}\right) }}\mathop{\sum }\limits_{{i \in \mathcal{I}}}\mathop{\sum }\limits_{{n \in \mathcal{N} \cup \mathcal{L}}}{z}_{n, t}^{i} \tag{1a}
+$$
+
+$$
+\text{ s.t. }\mathop{\sum }\limits_{{f \in \mathcal{F}}}\mathop{\sum }\limits_{{\theta \in \Theta \left( f\right) }}{b}_{nf\theta } + \mathop{\sum }\limits_{{k \in \mathcal{K}}}{w}_{nk} = 1\;\forall n \in \mathcal{N} \tag{1b}
+$$
+
+$$
+\mathop{\sum }\limits_{{k \in \mathcal{K}}}{w}_{nk} = 1\;\forall n \in \mathcal{L} \tag{1c}
+$$
+
+$$
+{b}_{nf\theta } \in \{ 0,1\} \;\forall n \in \mathcal{N}, f \in \mathcal{F},\theta \in \Theta \left( f\right) \tag{1d}
+$$
+
+$$
+{w}_{nk} \in \{ 0,1\} \;\forall n \in \mathcal{N} \cup \mathcal{L}, k \in \mathcal{K}, \tag{1e}
+$$
+
+where the set $\mathcal{Z}$ is defined as
+
+$$
+\mathcal{Z}\left( {\mathbf{b},\mathbf{w},\mathbf{\xi }}\right) \mathrel{\text{:=}} \{ \mathbf{z} \in \{ 0,1{\} }^{\left| \mathcal{I}\right| \times \left( {{2}^{d + 2} - 2}\right) } :
+$$
+
+$$
+{z}_{n, l\left( n\right) }^{i} \leq \mathop{\sum }\limits_{{f \in \mathcal{F}}}\mathop{\sum }\limits_{\substack{{\theta \in \Theta \left( f\right) : } \\ {{x}_{f}^{i} + {\xi }_{f}^{i} \leq \theta } }}{b}_{nf\theta }\;\forall i \in \mathcal{I}, n \in \mathcal{N}, \tag{2a}
+$$
+
+$$
+{z}_{n, r\left( n\right) }^{i} \leq \mathop{\sum }\limits_{{f \in \mathcal{F}}}\mathop{\sum }\limits_{\substack{{\theta \in \Theta \left( f\right) : } \\ {{x}_{f}^{i} + {\xi }_{f}^{i} \geq \theta + 1} }}{b}_{nf\theta }\;\forall i \in \mathcal{I}, n \in \mathcal{N}, \tag{2b}
+$$
+
+$$
+{z}_{a\left( n\right) , n}^{i} = {z}_{n, l\left( n\right) }^{i} + {z}_{n, r\left( n\right) }^{i} + {z}_{n, t}^{i}\;\forall i \in \mathcal{I}, n \in \mathcal{N}, \tag{2c}
+$$
+
+$$
+{z}_{a\left( n\right) , n}^{i} = {z}_{n, t}^{i}\;\forall i \in \mathcal{I}, n \in \mathcal{L}, \tag{2d}
+$$
+
+$$
+{z}_{n, t}^{i} \leq {w}_{n,{y}^{i}}\;\forall i \in \mathcal{I}, n \in \mathcal{N} \cup L \tag{2e}
+$$
+
+\}.
+
+The objective function in (1) maximizes the number of correctly classified training samples in the worst-case perturbation. The constraint (1b) states that each internal node must either classify a point or must be a binary test with some threshold $\theta$ . The constraint (1c) states that each leaf node must classify a point.
+
+The set (2) describes the maximum flow constraints for each sample's induced graph. Constraints (2a) and (2b) are capacity constraints that control the flow of samples in the induced graph based on $\mathbf{x} + \mathbf{\xi }$ and the tree structure. Constraints (2c) and (2d) are flow conservation constraints. Lastly, constraint (2e) blocks any flow to the sink if the node is either not an assignment node or the assignment is incorrect.
+
+### 2.3 The Uncertainty Set
+
+We consider uncertainty sets defined as follows. Let ${\gamma }_{f}^{i} \in \mathbb{R}$ be the cost of perturbing ${x}_{f}^{i}$ by one. Thus, ${\gamma }_{f}^{i}\left| {\xi }_{f}^{i}\right|$ is the total cost of perturbing ${x}_{f}^{i}$ to ${x}_{f}^{i} + {\xi }_{f}^{i}$ . Letting $\epsilon$ be the total allowable budget of uncertainty across data samples, we define the following uncertainty set:
+
+$$
+\Xi \mathrel{\text{:=}} \left\{ {\xi \in {\mathbb{Z}}^{\left| \mathcal{I}\right| \times \left| \mathcal{F}\right| } : \mathop{\sum }\limits_{{i \in \mathcal{I}}}\mathop{\sum }\limits_{{f \in \mathcal{F}}}{\gamma }_{f}^{i}\left| {\xi }_{f}^{i}\right| \leq \epsilon }\right\} . \tag{3}
+$$
+
+As we will show later, a tailored solution method of Formulation (1) can be made if uncertainty is defined by set (3), and there exists a connection between (3) and hypothesis testing.
+
+## 3 Solution Method
+
+We now present a method of solving problem (1) through a reformulation that can leverage existing, off-the-shelf mixed-integer linear programming solvers.
+
+### 3.1 Reformulating the Two-Stage Problem
+
+We solve our two-stage optimization problem by first taking the dual of the inner maximization problem. Recall that the inner maximization problem is a maximum flow problem; therefore, the dual of the inner maximization problem will yield an inner minimum cut problem (Vazirani 2001). Note that strong duality holds, and therefore taking the dual of the inner problem of (1) will yield a reformulation with equal optimal objective values, and thus optimal tree structure variables $\mathbf{b}$ and $\mathbf{w}$ for both problems.
+
+Let ${q}_{n, m}^{i}$ be the binary dual variable that equals 1 if and only if in the induced graph for data sample $i$ after perturbation, the edge that connects nodes $n \in \mathcal{N} \cup \{ s\}$ and $m \in \mathcal{N} \cup \mathcal{L} \cup \{ t\}$ is in the minimum cut. We write $\mathbf{q}$ as the vector concatenation of the rows of the $\left| \mathcal{I}\right| \times \left( {{2}^{d + 2} - 2}\right)$ matrix of ${q}_{n, m}^{i}$ values with rows corresponding to data sample $i$ and columns representing edge(n, m). We also define ${p}_{n}^{i}$ to be a binary variable that equals 1 if and only if in the induced graph of data sample $i \in \mathcal{I}$ , the node $n \in \mathcal{N} \cup \mathcal{L} \cup \{ s\}$ is in the source set. Letting $\mathcal{Q}$ be the set of all possible values of $\mathbf{q}$ , we then have
+
+$$
+\mathcal{Q} \mathrel{\text{:=}} \{ \mathbf{q} \in \{ 0,1{\} }^{\left| \mathcal{I}\right| \times \left( {{2}^{d + 2} - 2}\right) } :
+$$
+
+$$
+\exists {p}_{n}^{i} \in \{ 0,1\} \;\forall i \in \mathcal{I}, n \in \mathcal{N} \cup \mathcal{L} \cup \{ s\} , \tag{4a}
+$$
+
+$$
+{q}_{n, l\left( n\right) }^{i} - {p}_{n}^{i} + {p}_{l\left( n\right) }^{i} \geq 0\;\forall i \in \mathcal{I}, n \in \mathcal{N}, \tag{4b}
+$$
+
+$$
+{q}_{n, r\left( n\right) }^{i} - {p}_{n}^{i} + {p}_{r\left( n\right) }^{i} \geq 0\;\forall i \in \mathcal{I}, n \in \mathcal{N}, \tag{4c}
+$$
+
+$$
+{q}_{s,1}^{i} + {p}_{1}^{i} \geq 1\;\forall i \in \mathcal{I}, \tag{4d}
+$$
+
+$$
+- {p}_{n}^{i} + {q}_{n, t}^{i} \geq 0\;\forall i \in \mathcal{I}, n \in \mathcal{N} \cup \mathcal{L}, \tag{4e}
+$$
+
+\}.
+
+Constraints (4b) ensures that if the node $n \in \mathcal{N}$ is in the source set, then either its left child is also in the source set or the edge between $n$ and its left child are in the cut. Constraint (4c) is analogous to (4b), but with the right child of node $n \in \mathcal{N}$ . Constraint (4d) states that either the root node is in the source set or the edge from the source to the root node is in the cut. Lastly, constraint (4e) ensures that for any $n \in$ $\mathcal{N} \cup \mathcal{L}$ , if $n$ is in the source set, then the edge from $n$ to the sink must be in the cut.
+
+Then, taking the dual of the inner maximization problem in (1) gives the following single-stage formulation:
+
+$$
+\mathop{\max }\limits_{{\mathbf{b},\mathbf{w}}}\mathop{\min }\limits_{{\mathbf{q} \in \mathcal{Q},\mathbf{\xi } \in \Xi }}\mathop{\sum }\limits_{{i \in \mathcal{I}}}\mathop{\sum }\limits_{{n \in \mathcal{N}}}\mathop{\sum }\limits_{\substack{{\theta \in \Theta \left( f\right) : } \\ {{x}_{f}^{i} + {\xi }_{f}^{i} \leq \theta } }}\mathop{\sum }\limits_{{n, l\left( n\right) }}{q}_{n, l\left( n\right) }^{i}{b}_{nf\theta }
+$$
+
+$$
++ \mathop{\sum }\limits_{{i \in \mathcal{I}}}\mathop{\sum }\limits_{{n \in \mathcal{N}}}\mathop{\sum }\limits_{\substack{{f \in \mathcal{F}} \\ {{x}_{f}^{i} + {\xi }_{f}^{i} \geq \theta + 1} }}\mathop{\sum }\limits_{\substack{{\theta \in \Theta \left( f\right) } \\ {{x}_{f}^{i} + {\xi }_{f}^{i} \geq \theta + 1} }}{q}_{n, r\left( n\right) }^{i}{b}_{nf\theta }
+$$
+
+$$
++ \mathop{\sum }\limits_{{i \in \mathcal{I}}}\mathop{\sum }\limits_{{n \in \mathcal{N} \cup \mathcal{L}}}{q}_{n, t}^{i}{w}_{n,{y}^{i}} + \mathop{\sum }\limits_{{i \in \mathcal{I}}}{q}_{s,1}^{i} \tag{5a}
+$$
+
+$$
+\text{ s.t. }\mathop{\sum }\limits_{{f \in \mathcal{F}}}\mathop{\sum }\limits_{{\theta \in \Theta \left( f\right) }}{b}_{nf\theta } + \mathop{\sum }\limits_{{k \in \mathcal{K}}}{w}_{nk} = 1\;\forall n \in \mathcal{N} \tag{5b}
+$$
+
+$$
+\mathop{\sum }\limits_{{k \in \mathcal{K}}}{w}_{nk} = 1\;\forall n \in \mathcal{L} \tag{5c}
+$$
+
+$$
+{b}_{nf\theta } \in \{ 0,1\} \;\forall n \in \mathcal{N}, f \in \mathcal{F},\theta \in \Theta \left( f\right) \tag{5d}
+$$
+
+$$
+{w}_{nk} \in \{ 0,1\} \;\forall n \in \mathcal{N} \cup \mathcal{L}, k \in \mathcal{K} \tag{5e}
+$$
+
+where $\mathcal{Q}$ is defined by (4) and constraints (5b) and (5c) are the same as constraints (1b) and (1c) respectively. As mentioned before, strong duality holds between Formulations (1) and (5) since strong duality holds between the maximum flow and minimum cut problems.
+
+### 3.2 Solving the Single-Stage Reformulation
+
+We can obtain a mixed-integer linear program equivalent to (5) by doing a hypograph reformulation. However, a hypo-graph reformulation would introduce an extremely large of constraints. A common approach to solving the reformulation is to use a tailored Benders decomposition algorithm, which we describe here.
+
+The master problem decides the tree structure given its current constraints. We thus have the following initial master problem:
+
+$$
+\mathop{\max }\limits_{{\mathbf{b},\mathbf{w},\mathbf{t}}}\mathop{\sum }\limits_{{i \in \mathcal{I}}}{t}_{i} \tag{6a}
+$$
+
+$$
+\text{ s.t. }\mathop{\sum }\limits_{{f \in \mathcal{F}}}\mathop{\sum }\limits_{{\theta \in \Theta \left( f\right) }}{b}_{nf\theta } + \mathop{\sum }\limits_{{k \in \mathcal{K}}}{w}_{nk} = 1\;\forall n \in \mathcal{N} \tag{6b}
+$$
+
+$$
+\mathop{\sum }\limits_{{k \in \mathcal{K}}}{w}_{nk} = 1\;\forall n \in \mathcal{L} \tag{6c}
+$$
+
+$$
+{t}_{i} \leq 1\;\forall i \in \mathcal{I} \tag{6d}
+$$
+
+$$
+{b}_{nf\theta } \in \{ 0,1\} \;\forall n \in \mathcal{N}, f \in \mathcal{F},\theta \in \Theta \left( f\right) \tag{6e}
+$$
+
+$$
+{w}_{nk} \in \{ 0,1\} \;\forall n \in \mathcal{N} \cup \mathcal{L}, k \in \mathcal{K} \tag{6f}
+$$
+
+where ${t}_{i}$ comes from the hypograph of the inner sum of objective function (5a) for a particular $i \in \mathcal{I}$ . We add the constraint (6d) to ensure that the initial problem is bounded.
+
+The goal for the subproblem is, given certain values of $\mathbf{b}$ , $\mathbf{w}$ , and $\mathbf{t}$ that describe a specific tree structure, find a perturbation in $\Xi$ that reduces the number of correctly classified samples the most. After finding the minimum cut of the induced graph for each data sample after deciding the perturbation, we add a constraint of the form
+
+$$
+\mathop{\sum }\limits_{{i \in \mathcal{I}}}{t}_{i} \leq \mathop{\sum }\limits_{{i \in \mathcal{I}}}\mathop{\sum }\limits_{{n \in \mathcal{N}}}\mathop{\sum }\limits_{\substack{{f \in \mathcal{F}} \\ {f \in {\mathcal{F}}_{f} \leq \theta } }}\mathop{\sum }\limits_{\substack{{\theta \in \Theta \left( f\right) : } \\ {{x}_{f}^{i} + {\xi }_{f}^{i} \leq \theta } }}{q}_{n, l\left( n\right) }^{i}{b}_{nf\theta }
+$$
+
+$$
++ \mathop{\sum }\limits_{{i \in \mathcal{I}}}\mathop{\sum }\limits_{{n \in \mathcal{N}}}\mathop{\sum }\limits_{\substack{{f \in \mathcal{F}} \\ {{x}_{f}^{i} + {\xi }_{f}^{i} \geq \theta + 1} }}\mathop{\sum }\limits_{\substack{{\theta \in \Theta \left( f\right) } \\ {{x}_{f}^{i} + {\xi }_{f}^{i} \geq \theta + 1} }}{q}_{n, r}^{i}{b}_{nf\theta } \tag{7}
+$$
+
+$$
++ \mathop{\sum }\limits_{{i \in \mathcal{I}}}\mathop{\sum }\limits_{{n \in \mathcal{N} \cup \mathcal{L}}}{q}_{n, t}^{i}{w}_{n,{y}^{i}} + \mathop{\sum }\limits_{{i \in \mathcal{I}}}{q}_{s,1}^{i}
+$$
+
+where we substitute the variables $\mathbf{\xi }$ and $\mathbf{q}$ with the perturbation and minimum cuts.
+
+### 3.3 The Subproblem
+
+We will now describe the procedure for the subproblem to find the perturbation and minimum cuts that will yield a violated constraint of the form (7) if a violated constraint exists.
+
+For each data sample that is correctly classified by the tree given by the master problem (6), we first find the lowest-cost perturbation ${\xi }^{i}$ for the single sample that would cause it to be misclassified. To do this, we set up a shortest path problem. The weighted graph of the shortest path problem is created from the flow-based tree returned by the master problem, and is constructed with the following procedure:
+
+1. The edge from $s$ to 1 (the root of the decision tree) has path cost 0 .
+
+2. For each $n \in \mathcal{N} \cup \mathcal{L}$ , if there exists a $k \in \mathcal{K}$ such that ${w}_{nk} = 1$ , and $k \neq {y}^{i}$ , then we have a 0 path cost from $n$ to $t$ . All other edges coming into $t$ have infinite path cost.
+
+3. For each $n \in \mathcal{N}$ , if there exists an $f \in \mathcal{F}$ such that ${b}_{nf} = 1$ , then...
+
+(a) if ${x}_{f}^{i} = 0$ , add an edge from $n$ to $l\left( n\right)$ with 0 weight, and add an edge from $n$ to $r\left( n\right)$ with ${\gamma }_{f}$ weight.
+
+(b) if ${x}_{f}^{i} = 1$ , add an edge from $n$ to $r\left( n\right)$ with 0 weight, and add an edge from $n$ to $l\left( n\right)$ with ${\gamma }_{f}$ weight. By finding the shortest path from $s$ to $t$ for the weighted graph derived from data sample $i$ , we find the path with the smallest total cost of perturbation that would misclassify the point $i$ . That is, we use the shortest path to see what perturbation ${\mathbf{\xi }}^{i}$ would misclassify ${\mathbf{x}}^{i}$ with the smallest cost.
+
+Once we find the lowest-cost perturbation that would misclassify every sample, we choose the largest subset of these training samples whose total cost of perturbation to misclassify each sample is less than the allowed budget of uncertainty. Through this procedure, we find the value of $\xi$ that misclassifies the most number of points given the current tree.
+
+Note that the right hand side of the constraint (7) gives the count of the the number of correctly classified points for a certain $\mathbf{b},\mathbf{w},\mathbf{\xi }$ , and $\mathbf{q}$ . Therefore, for dataset $\mathbf{x} + \mathbf{\xi }$ , if the number of correctly classified points is less than the optimal value of $\mathop{\sum }\limits_{{i \in I}}{t}_{i}$ from the master problem, then we know that there exists a constraint of the form (7) that is violated. Otherwise, there are no violated constraints of the form (7), which indicates the optimality of the current solution.
+
+In the case of finding a violated constraint, we now would like to obtain the values of $\mathbf{q}$ , the variables associated with the minimum cut problem. To do this, we need to find for each sample $i \in \mathcal{I}$ the set of edges in a minimum cut given the path of the data point ${\mathbf{x}}^{i} + {\xi }^{i}$ , where the value of the cut is 1 if ${\mathbf{x}}^{i} + {\mathbf{\xi }}^{i}$ is correctly classified and 0 otherwise. The simplest way to construct this minimum cut is for each $i \in \mathcal{I}$ , we follow the path of ${\mathbf{x}}^{i} + {\mathbf{\xi }}^{i}$ . At each node visited in this path, we first include to the minimum cut any edges outgoing from that node that are not traversed. And at the assignment node, we also include the edge going from the assignment node to the sink $t$ . By doing this procedure for all training samples, we obtain the value of $\mathbf{q}$ describing all minimum cuts.
+
+By finding the value of $\xi$ and an associated $\mathbf{q}$ , we can use these values in (7) to obtain the most restrictive violated constraint for a given tree, which we add back to the master problem. We summarize our approach in Algorithm 1.
+
+## 4 Statistical Connections
+
+Here, we explore how the uncertainty set described in (3) connects to hypothesis testing. Let ${q}_{f}^{\zeta } \in (0,1\rbrack$ be the probability that the realization of the data at feature $f$ as decided by our uncertainty set perturbs the nominal data at feature $f$ by $\zeta \in \mathbb{Z}$ . We will impose the assumption that the perturbations follow a geometric distribution. More specifically,
+
+$$
+{q}_{f}^{\zeta } = {\left( {0.5}\right) }^{\mathbb{I}\left\lbrack {\zeta \neq 0}\right\rbrack }{q}_{f}{\left( 1 - {q}_{f}\right) }^{\left| \zeta \right| } \tag{8}
+$$
+
+for some ${q}_{f} \in (0,1\rbrack$ (where the ${\left( {0.5}\right) }^{\mathbb{I}\left\lbrack {\zeta \neq 0}\right\rbrack }$ multiplier imposes a symmetry between positive and negative values of the perturbation).
+
+We will set up a likelihood ratio test with threshold ${\lambda }^{\left| \mathcal{I}\right| }$ for $\lambda \in \left\lbrack {0,1}\right\rbrack$ , where we add the exponential of $\left| \mathcal{I}\right|$ for ease of comparison across different data sets with different number of training samples. Our null hypothesis will be that a given perturbation of our data comes from the distribution of perturbations given by the chosen ${q}_{f}^{\zeta } \in (0,1\rbrack$ . Then, we set up a likelihood ratio test where we fail to reject the null hypothesis if
+
+$$
+\frac{\mathop{\prod }\limits_{{i \in \mathcal{I}}}\mathop{\prod }\limits_{{f \in \mathcal{F}}}\mathop{\prod }\limits_{{\zeta = - \infty }}^{\infty }{\left( {q}_{f}^{\zeta }\right) }^{\mathbb{I}\left\lbrack {{\xi }_{f}^{i} = = \zeta }\right\rbrack }}{\mathop{\prod }\limits_{{i \in \mathcal{I}}}\left\lbrack {\mathop{\prod }\limits_{{f \in \mathcal{F}}}{q}_{f}^{0}}\right\rbrack } \geq {\lambda }^{\left| \mathcal{I}\right| }, \tag{9}
+$$
+
+Algorithm 1: Solution Method to formulation (5)
+
+---
+
+Input: training set indexed by $\mathcal{I}$ with features $\mathcal{F}$ and labels
+
+$\mathcal{K}$ , range of test thresholds $\Theta \left( f\right)$ , tree depth $d$ , uncertainty
+
+set parameters $\gamma$ and $\epsilon$
+
+Output: The optimal robust tree represented by ${\mathcal{T}}^{ * } =$
+
+$\left( {{\mathbf{b}}^{ * },{\mathbf{w}}^{ * }}\right)$
+
+ while no tree $\mathcal{T}$ returned do
+
+ Solve the master problem (6) with any added con-
+
+ straints, obtain tree $\mathcal{T} = \left( {{\mathbf{b}}^{ * },{\mathbf{w}}^{ * }}\right)$ , and ${\mathbf{t}}^{ * }$
+
+ Find the lowest cost $\xi$ that causes the most number of
+
+ samples to be misclassified in $\mathcal{T}$ to obtain ${\mathbf{\xi }}^{ * }$
+
+ if $\mathop{\sum }\limits_{{i \in \mathcal{I}}}{t}_{i} \leq$ number of correctly classified samples
+
+ of $\mathbf{x} + {\mathbf{\xi }}^{ * }$ given $\mathcal{T}$ then
+
+ return $\mathcal{T}$
+
+ else
+
+ Find ${\mathbf{q}}^{ * }$ by finding a minimum cut for each $i \in \mathcal{I}$
+
+ based on $\mathbf{x} + {\mathbf{\xi }}^{ * }$ and $\mathcal{T}$
+
+ Use values of ${\mathbf{\xi }}^{ * }$ and ${\mathbf{q}}^{ * }$ to create constraint (7) to
+
+ add to the master problem.
+
+ end if
+
+ end while
+
+---
+
+where the numerator of the left hand side is the maximum likelihood of a given perturbation $\xi$ , and the denominator of the left hand side is the likelihood under the null hypothesis. Using the assumption that ${q}_{f}^{\zeta }$ follows (8), we can reduce the hypothesis test in (9) into
+
+$$
+\mathop{\sum }\limits_{{i \in \mathcal{I}}}\mathop{\sum }\limits_{{f \in \mathcal{F}}}\left| {\xi }_{f}^{i}\right| \log \left( \frac{1}{1 - {q}_{f}}\right) \leq - \left| \mathcal{I}\right| \log \lambda . \tag{10}
+$$
+
+We say that if a particular $\xi$ lies within the region where we fail to reject the null hypothesis, then it is part of our perturbation set. That is, using the notation from the perturbation set defined in (3), letting ${\gamma }_{f}^{i} = \log \left( \frac{1}{1 - {q}_{f}}\right)$ and $\epsilon = - \left| \mathcal{I}\right| \log \lambda$ yields an uncertainty set with a direct relationship to the probabilities of certainty for each feature.
+
+## 5 Experiments
+
+We evaluate our approach on 12 datasets from the UCI Machine Learning Repository (Dua and Graff 2017). For each data set, we construct a robust classification tree from our method using a synthetic uncertainty set where for different problem instances, we choose different levels of uncertainty in the features and budgets of uncertainty. We utilize the hypothesis testing framework as described by (10), where we define ${q}_{f}$ by sampling the probability of certainty from a normal distribution with a particular mean we set and a standard deviation of 0.2 . The means of this normal distribution included0.6,0.7,0.8, and 0.9 . We also chose different values of our budget by setting $\lambda$ to be0.5,0.75,0.85,0.9, 0.95,0.97, and 0.99 . For every data set and uncertainty set, we tested with tree depths of2,3,4and 5 .
+
+
+
+Figure 2: This graph shows the number of instances solved across times and optimality gaps when the time limit of 7200 seconds is reached for several values of $\lambda$ . The case of $\lambda =$ 1.0 is the regularized tree with an empty uncertainty set.
+
+For each instance, we randomly split the data set into 80% training data, ${20}\%$ testing data. We then ran our algorithm to obtain a robust classification tree with a time limit of 7200 seconds. For comparison, we used our model to create a non-robust tree as well by setting the budget of uncertainty to 0 (i.e. $\lambda = 1$ ), and tuned a regularization parameter for the non-robust tree. The regularization term penalized the objective for every branching node to yield the following objective in the master problem of our algorithm:
+
+$$
+\mathop{\max }\limits_{{\mathbf{b},\mathbf{w},\mathbf{t}}}\left( {1 - R}\right) \mathop{\sum }\limits_{{i \in \mathcal{I}}}{t}_{i} - R\mathop{\sum }\limits_{{i \in \mathcal{I}}}\mathop{\sum }\limits_{{n \in \mathcal{N}}}\mathop{\sum }\limits_{{\Theta \left( f\right) }}{b}_{nf\theta }
+$$
+
+where $R \in \left\lbrack {0,1}\right\rbrack$ is the tuned regularization parameter. Note that we do not add a regularization parameter to our robust model, as robust optimization has an equivalence with regularization and so adding a regularization term is redundant (Bertsimas and Copenhaver 2018). We summarize the computation time across all instances in Figure 2. As we expected, the larger the uncertainty set, the longer it takes for the formulation to solve to optimality.
+
+To test our model's robustness against distribution shifts, we perturbed the test data in 5000 different ways, where for each perturbation we found the test accuracy from our robust tree. We first perturbed the data based on the expected distribution of perturbations. That is, for the collection of ${q}_{f}$ values for every $f \in \mathcal{F}$ used to construct an uncertainty set based off of (10), we perturb the data based on the distribution described in (8).
+
+In order to measure the robustness of our model based on unexpected perturbations of the data, we also repeat the same process but for values of ${q}_{f}$ different than what we gave our model. First, we shifted each ${q}_{f}$ value down 0.2, then perturb our test data in 5000 different ways based on these new values of ${q}_{f}$ . We do the same procedure but with ${q}_{f}$ shifted down by 0.1 and up by 0.1 . In a similar fashion, we also uniformly sampled a new ${q}_{f}$ value for each feature in a neighborhood of radius 0.05 of the original expected ${q}_{f}$ value, and perturbed the test data in 5000 different ways with the new ${q}_{f}$ values. We do the same procedure for the radii of the neighborhoods0.1,0.15, and 0.2,
+
+
+
+Figure 3: These boxplots show the distribution across problem instances of the gain in worst-case accuracy from using a robust tree versus a non-robust, regularized tree across different values of $\lambda$ . We also show the distribution of the gain in worst-case accuracy in the case where perturbations of our data are not as we expect.
+
+For each set of perturbations of the test data, we measure the worst-case accuracy by finding the lowest accuracy from all perturbations we made for a single set of ${q}_{f}$ values, and measure the average accuracy by averaging over the accuracy over all perturbations for a single set of ${q}_{f}$ values. We compile the gain in worst-case and average-case performance from using our robust tree versus using a regularized, non-robust tree for every problem instance and perturbation of our data, giving us a distribution of worst-case and average case gains in performance that are summarized in Figures 3 and 4 , respectively.
+
+From the figures, we see that our robust tree model in general has both higher worst-case and average-case accuracy than a non-robust model when there exists distribution shifts in the data. We also see that there is a range of values of $\lambda$ that seem to perform well over other values (namely 0.85). This shows us that if the budget of uncertainty is too small, then we do not allow enough room to hedge against distribution shifts in our uncertainty set. But if the budget of uncertainty is too large, then we become over-conservative and perform poorly for any perturbation of our test data. We also see that there is little difference between the gains in accuracy in instances where the perturbation of our data is as we expected versus when the perturbation is not as we expect. This indicates that even if we misspecify our model, we still obtain a classification tree robust to any kind of distribution shift within a reasonable range of our expected distribution shift. Overall, we see that an important factor in determining the performance of our model is the budget of uncertainty, which can be easily tuned to create an effective robust tree.
+
+
+
+Figure 4: These boxplots show the distribution across problem instances of the gain in average test accuracy from using a robust tree versus a non-robust, regularized tree across different values of $\lambda$ . We also show this gain in average accuracy in the case where perturbations of our data are not what we expect.
+
+## References
+
+Aghaei, S.; Azizi, M. J.; and Vayanos, P. 2019. Learning Optimal and Fair Decision Trees for Non-Discriminative Decision-Making. Proceedings of the AAAI Conference on Artificial Intelligence, 33: 1418-1426.
+
+Aghaei, S.; Gómez, A.; and Vayanos, P. 2021. Strong Optimal Classification Trees. arXiv:2103.15965.
+
+Ben-Tal, A.; El Ghaoui, L.; and Nemirovski, A. 2009. Robust Optimization. Princeton University Press. ISBN 9781400831050.
+
+Ben-Tal, A.; Goryashko, A.; Guslitzer, E.; and Nemirovski, A. 2004. Adjustable robust solutions of uncertain linear programs. Mathematical Programming, 99(2).
+
+Bertsimas, D.; and Copenhaver, M. S. 2018. Characterization of the equivalence of robustification and regularization in linear and matrix regression. European Journal of Operational Research, 270(3).
+
+Bertsimas, D.; and Dunn, J. 2017. Optimal classification trees. Machine Learning, 106(7): 1039-1082.
+
+Bertsimas, D.; Dunn, J.; Pawlowski, C.; and Zhuo, Y. D. 2019. Robust Classification. INFORMS Journal on Optimization, 1(1): 2-34.
+
+Bickel, S.; Brückner, M.; and Scheffer, T. 2007. Discriminative learning for differing training and test distributions. In Proceedings of the 24th international conference on Machine learning - ICML '07. New York, New York, USA: ACM Press. ISBN 9781595937933.
+
+Breiman, L.; Friedman, J. H.; Olshen, R. A.; and Stone, C. J. 2017. Classification And Regression Trees. Routledge. ISBN 9781315139470.
+
+Dua, D.; and Graff, C. 2017. UCI Machine Learning Repository.
+
+Jo, N.; Aghaei, S.; Gómez, A.; and Vayanos, P. 2021. Learning Optimal Prescriptive Trees from Observational Data. arXiv:2108.13628.
+
+Kuhn, D.; Esfahani, P. M.; Nguyen, V. A.; and Shafieezadeh-Abadeh, S. 2019. Wasserstein Distributionally Robust Optimization: Theory and Applications in Machine Learning. In Operations Research & Management Science in the Age of Analytics, 130-166. INFORMS.
+
+Mišić, V. V. 2020. Optimization of Tree Ensembles. Operations Research, 68(5): 1605-1624.
+
+Quiñonero-Candela, J.; Sugiyama, M.; Lawrence, N. D.; and Schwaighofer, A. 2009. Dataset shift in machine learning. Mit Press.
+
+Rudin, C. 2019. Stop explaining black box machine learning models for high stakes decisions and use interpretable models instead. Nature Machine Intelligence, 1(5).
+
+Shaham, U.; Yamada, Y.; and Negahban, S. 2018. Understanding adversarial training: Increasing local stability of supervised models through robust optimization. Neurocomput-ing, 307: 195-204.
+
+Shimodaira, H. 2000. Improving predictive inference under covariate shift by weighting the log-likelihood function. Journal of Statistical Planning and Inference, 90(2).
+
+Shivaswamy, P. K.; Bhattacharyya, C.; and Smola, A. J. 2006. Second Order Cone Programming Approaches for Handling Missing and Uncertain Data. Journal of Machine Learning Research, 7(47): 1283-1314.
+
+Sinha, A.; Namkoong, H.; Volpi, R.; and Duchi, J. 2020. Certifying Some Distributional Robustness with Principled Adversarial Training. arXiv:1710.10571.
+
+Vazirani, V. V. 2001. Approximation algorithm, volume 1. Springer.
+
+Verwer, S.; and Zhang, Y. 2019. Learning Optimal Classification Trees Using a Binary Linear Program Formulation. Proceedings of the AAAI Conference on Artificial Intelligence, 33.
+
+Vos, D.; and Verwer, S. 2021. Robust Optimal Classification Trees Against Adversarial Examples. arXiv:2109.03857.
\ No newline at end of file
diff --git a/papers/AAAI/AAAI 2022/AAAI 2022 Workshop/AAAI 2022 Workshop AdvML/HbasA9ysA3/Initial_manuscript_tex/Initial_manuscript.tex b/papers/AAAI/AAAI 2022/AAAI 2022 Workshop/AAAI 2022 Workshop AdvML/HbasA9ysA3/Initial_manuscript_tex/Initial_manuscript.tex
new file mode 100644
index 0000000000000000000000000000000000000000..ba20d3d39383438c8d5710cedc6fe5c3e782fb69
--- /dev/null
+++ b/papers/AAAI/AAAI 2022/AAAI 2022 Workshop/AAAI 2022 Workshop AdvML/HbasA9ysA3/Initial_manuscript_tex/Initial_manuscript.tex
@@ -0,0 +1,365 @@
+§ OPTIMAL ROBUST CLASSIFICATION TREES
+
+§ ABSTRACT
+
+In many high-stakes domains, the data used to drive machine learning algorithms is noisy (due to e.g., the sensitive nature of the data being collected, limited resources available to validate the data, etc). This may cause a distribution shift to occur, where the distribution of the training data does not match the distribution of the testing data. In the presence of distribution shifts, any trained model can perform poorly in the testing phase. In this paper, motivated by the need for interpretability and robustness, we propose a mixed-integer optimization formulation and a tailored solution algorithm for learning optimal classification trees that are robust to adversarial perturbations in the data features. We evaluate the performance of our approach on numerous publicly available datasets, and compare the performance to a regularized, non-robust optimal tree. We show an increase of up to 14.16% in worst-case accuracy and increase of up to 4.72% in average-case accuracy across several data sets and distribution shifts from using our robust solution in comparison to the non-robust solution.
+
+§ 1 INTRODUCTION
+
+Machine learning techniques are increasingly being used in high-stakes domains to assist humans in making important decisions. Within these applications, black box models that need explanation should be avoided as decisions made from these models may have a profound impact (Rudin 2019). That is, we need inherently interpretable models where decisions made can be simply understood and verified. One of the most interpretable models are classification trees, which are easily visualized and do not require extensive knowledge to use. Classification trees are a widely used model that takes the form of a binary tree. At each branching node, a test based off of the attributes of the given data sample is made, which dictates the next node visited. Then at an assignment node, a particular label is assigned to the data sample (Breiman et al. 2017).
+
+However, as with many other machine learning models, classification trees are susceptible to distribution shifts. That is, the distribution of the training data and the testing data may be different, causing poor performance in deployment (Quiñonero-Candela et al. 2009). In high-stakes domains where there is a need for interpretability, there must also be robustness against distribution shifts to ensure high-quality solutions under any realization of the training data.
+
+§ 1.1 BACKGROUND AND RELATED WORK
+
+Traditionally, classification trees are built using heuristic approaches since the problem of building optimal classification trees is $\mathcal{{NP}}$ -hard (Breiman et al. 2017). But in settings where the quality of solutions is important, heuristic approaches may yield suboptimal solutions that are unacceptable for use in applications. Thus, to ensure a high-quality decision tree, mathematical optimization techniques, like mixed-integer optimization (MIO), have been developed for building optimal trees. Namely, Bertsimas and Dunn (2017) were the first to use MIO to build optimal decision trees. To combat the long run times for making optimal decision trees on large data sets, Verwer and Zhang (2019) create a binary linear programming formulation that has a run time independent of the amount of training samples. Aghaei, Gómez, and Vayanos (2021) build a strong, "flow-based" MIO formulation that greatly improves on solving times in comparison to other state-of-the-art optimal classification tree algorithms. MIO approaches for constructing decision trees have also allowed for several extensions. For example, Mišić (2020) formulates the problem of creating tree ensembles as a MIO problem, Aghaei, Azizi, and Vayanos (2019) create optimal and fair decision trees using MIO, and Jo et al. (2021) use MIO to build optimal prescriptive trees from observational data.
+
+To account for the problem of distribution shifts, there exists both non-MIO and MIO approaches. One type of non-MIO method up-weights training samples that match the test set distribution and down-weights the training samples that differ from the test set (Shimodaira 2000; Bickel, Brückner, and Scheffer 2007). These methods usually define distribution shift as a biased sampling of training data, where assigning weights to training samples diminishes the effects of adversarial examples.
+
+Another way to define a distribution shift is as an adversarial perturbation of the trained data that makes it differ from the test data. Motivated by this viewpoint, there have been several optimization-based methods to deal with distribution shifts. One of these methods is distributionally robust optimization, which combats the effects of distribution shifts by performing well under an adversarial distribution of samples. Both Kuhn et al. (2019) and Sinha et al. (2020) in particular provide distributionally robust approaches to building machine learning models that perform well under an adversarial distribution of the training data, where the adversarial distribution is in some Wasserstein distance from the nominal distribution of the data.
+
+Copyright © 2022, Association for the Advancement of Artificial Intelligence (www.aaai.org). All rights reserved.
+
+Distributionally robust optimization requires an assumption on the distribution of the data available, which may not be a reasonable assumption to make. In the case where such an assumption cannot be reasonably made, robust optimization provides a framework to generate solutions that perform well in the worst-case perturbation, where the perturbation comes from a set of values without a probability distribution assumption imposed (Ben-Tal, El Ghaoui, and Nemirovski 2009). Many common machine learning models have been formulated as robust optimization problems to deal with uncertainty in data. For example, robust optimization has been used for creating robust support vector machines (Shivaswamy, Bhattacharyya, and Smola 2006; Bert-simas et al. 2019). Robust optimization has also been used to create artificial neural networks that are robust against adversarial perturbations of the data (Shaham, Yamada, and Negahban 2018).
+
+In a similar spirit to these previous works, we propose using robust optimization to create a classification tree robust to distribution shifts. In an adversarial setting, we must decide the tree structure before observing the perturbation of the data. The perturbation of a sample, once unveiled, reveals whether the given tree structure correctly classifies the realization of the sample. That is, the classification of samples in a decision tree is dependent on both the tree structure and the realization of the uncertain parameter. Decision variables that indicate the correct classification of samples are called second-stage decisions, which can be modeled through two-stage robust optimization (Ben-Tal et al. 2004).
+
+There have been several recent methods for robust classification trees. Namely, Vos and Verwer (2021) have a local search algorithm for decision trees robust against adversarial examples derived from a user-defined threat model. Bertsimas et al. (2019) have a robust optimization formulation for robust trees where the uncertainty set is modeled by restricting the norm of the perturbation parameter. Unlike our proposed method, Bertsimas et al. (2019) do not capture the dependent relationship between the perturbation of the covariates and the classification of training samples, as decisions made on the classification of training samples are made before the realization of the uncertain parameter. Thus, they cannot identify correctly classified data points in the realization of the worst-case perturbation. So, differing from previous work, we argue that the decision variables related to the classification of training samples should be modeled as second-stage decisions. And by modeling these variables as second-stage decisions, we obtain less conservative solutions than a single-stage approach to the same problem.
+
+With these motivating factors in mind, we propose a two-stage, MIO method for learning optimal classification trees robust to distribution shifts in the data. Namely, we present a flow-based optimization problem, where we model uncertainty through a cost-and-budget framework. We then present a tailored Benders decomposition algorithm that solves this two-stage formulation to optimality. We evaluate the performance of our formulation on publicly available data sets for several problem instances to measure the effectiveness of our method in mitigating the adverse effects of distribution shifts.
+
+§ 2 ROBUST TREE FORMULATION
+
+In this section, we present our formulation for a robust classification tree. We describe the structure of the classification tree, present the proposed two-stage formulation, and discuss our model of uncertainty.
+
+§ 2.1 SETUP AND NOTATION
+
+Let ${\left\{ {\mathbf{x}}^{i},{y}^{i}\right\} }_{i \in \mathcal{I}}$ be the training set, where $\mathcal{I}$ is the index set for our training samples. The covariates are ${\mathbf{x}}^{i} \in {\mathbb{Z}}^{\left| \mathcal{F}\right| }$ , where $\mathcal{F}$ is the set of features of our data, and ${y}^{i}$ is some label in a finite set $\mathcal{K}$ . With a slight abuse of notation, we will let $\mathbf{x}$ denote the the vector concatenation of the rows of the $\left| \mathcal{I}\right| \times \left| \mathcal{F}\right|$ matrix of all training covariates, and $\mathbf{y}$ the $\left| \mathcal{I}\right|$ -sized vector of all training labels. The training set ${\left\{ {\mathbf{x}}^{i},{y}^{i}\right\} }_{i \in \mathcal{I}}$ is used to determine the tree structure, which includes deciding what binary tests to perform and labels to predict. Thus, in the first stage of our problem, we decide the tree structure to maximize the number of correct classifications for the given training data.
+
+Let ${\mathbf{\xi }}^{i} \in {\mathbb{Z}}^{\left| \mathcal{F}\right| }$ represent a perturbation of the covariate ${\mathbf{x}}^{i}$ . We can only observe ${\mathbf{\xi }}^{i} \in {\mathbb{Z}}^{\left| \mathcal{F}\right| }$ after making our first stage decisions on the tree structure. So ${\mathbf{x}}^{i} + {\mathbf{\xi }}^{i}$ represent the realization of the training sample $i$ after determining the tree structure. We let the covariate and perturbation value at sample $i$ and feature $f$ be ${x}_{f}^{i}$ and ${\xi }_{f}^{i}$ respectively. Also, denote $\mathbf{\xi }$ as the vector concatenation of the rows of the $\left| \mathcal{I}\right| \times$ $\left| \mathcal{F}\right|$ matrix of perturbations, and let $\Xi$ be our perturbation set that defines all possible $\xi$ .
+
+As mentioned before, the second stage decisions are the classification of training samples, which occurs after deciding the tree structure and observing the worst-case perturbation. To classify sample $i$ after perturbation, we must perform the series of binary tests for covariate ${\mathbf{x}}^{i} + {\mathbf{\xi }}^{i}$ from the tree decided on in the first stage. The binary test uses a threshold $\theta$ such that if ${x}_{f}^{i} + {\xi }_{f}^{i} \leq \theta$ , then sample $i$ travels to the left child. Likewise, if ${x}_{f}^{i} + {\xi }_{f}^{i} \geq \theta + 1$ , then sample $i$ travels to the right child. Letting ${c}_{f}$ and ${d}_{f}$ be the lower and upper bound of realized values for feature $f$ respectively, we define
+
+$$
+\Theta \left( f\right) \mathrel{\text{ := }} \left\{ {\theta \in \mathbb{Z} \mid {c}_{f} \leq \theta < {d}_{f}}\right\}
+$$
+
+as the set of possible binary test threshold values for feature $f$ .
+
+§ 2.2 THE TWO-STAGE PROBLEM
+
+We will set up our robust formulation based on the non-robust classification tree outlined by (Aghaei, Gómez, and Vayanos 2021), where a binary classification tree is represented by a directed graph. The model starts with a depth $d$ binary tree, where the internal nodes are in the set $\mathcal{N}$ and the leaf nodes are in the set $\mathcal{L}$ . A node in $\mathcal{N}$ can either be a branching node where a binary test is performed, or an assignment node where a classification of a sample is made. Nodes in $\mathcal{L}$ can only be assignment nodes. There are ${2}^{d} - 1$ nodes in $\mathcal{N}$ and ${2}^{d}$ nodes in $\mathcal{L}$ , and we number each node from 1 to ${2}^{d + 1} - 1$ in a breadth-first search pattern. We then augment this tree by adding a single source node $s$ connected to the root node of the tree, and a sink node $t$ connected to each node in $\mathcal{N} \cup \mathcal{L}$ . By adding a source and sink node, we say that any data sample $i$ travels from the source $s$ through the tree based on ${\mathbf{x}}^{i}$ and reaches the sink if and only if the datapoint is correctly classified. Lastly, we denote the left and right child of node $n \in \mathcal{N}$ as $l\left( n\right)$ and $r\left( n\right)$ respectively, and also denote the ancestor of any node $n \in \mathcal{N} \cup \mathcal{L}$ as $a\left( n\right)$ .
+
+ < g r a p h i c s >
+
+Figure 1: The left graph shows a classification tree with depth 2. Nodes $s$ and $t$ are the source and sink nodes respectively, $\mathcal{N} = \{ 1,2,3\}$ and $\mathcal{L} = \{ 4,5,6,7\}$ . The right graph shows an example of induced graph of a particular sample, where the green, bold edges are the subset of edges included in the induced graph. For this particular induced graph, nodes 1 and 3 are branching nodes, where the sample would be routed left and right, respectively. Nodes 2 and 6 assign the correct label, and node 7 does not assign the correct label. The maximum flow from $s$ to $t$ is 1 in this induced graph, indicating a correct classification.
+
+To determine whether a data sample $i$ is correctly classified by a given tree, we consider an induced graph of the original directed graph for data sample $i$ . In this induced graph, we keep every node in $\mathcal{N} \cup \mathcal{L}$ , the source $s$ , and the sink $t$ . For every branching node, we remove the edge leading to the sink node $t$ and the edge that fails the binary test based on the value of ${\mathbf{x}}^{i} + {\mathbf{\xi }}^{i}$ . And for every assignment node, we include the edge leading to $t$ only if the assigned class of that node is ${y}^{i}$ , and exclude all other edges leaving the assignment node. Lastly, we include the edge from the source $s$ to the root node 1 . Therefore, a maximum flow of 1 from $s$ to $t$ of this induced graph means that data sample $i$ would be correctly classified. Figure 1 illustrates an induced graph.
+
+With the flow graph setup, we propose a two-stage formulation for creating robust classification trees. In the first stage, we decide the structure of the tree. Let ${b}_{nf\theta }$ , defined over all $n \in \mathcal{N},f \in \mathcal{F}$ , and $\theta \in \Theta \left( f\right)$ be a binary variable that denotes the branching decisions. If ${b}_{nf\theta } = 1$ , then node $n$ is a branching node, where the binary test is on feature $f$ with threshold $\theta$ . We also let ${w}_{nk}$ , defined over all $n \in \mathcal{N} \cup \mathcal{L}$ and all $k \in \mathcal{K}$ , be a binary variable that denotes the assignment decisions. If ${w}_{nk} = 1$ , then node $n$ is an assignment node with assignment label $k$ . We will denote $\mathbf{b}$ and $\mathbf{w}$ as the collection of ${b}_{nf\theta }$ and ${w}_{nk}$ variables respectively.
+
+Given a value of $\mathbf{b}$ and $\mathbf{w}$ , we find the perturbation in $\Xi$ that results in the minimum number of correctly classified points, which we will call the worst-case perturbation. In the second stage, after observing the worst-case perturbation of our covariates $\xi$ from the set $\Xi$ given a certain tree structure, we classify each of our points based on our tree. Let ${z}_{n,m}^{i}$ indicate whether data point $i$ flows down the edge between $n$ and $m$ and is correctly classified by the tree for $n \in \mathcal{N} \cup \mathcal{L} \cup \{ s\}$ and $m \in \mathcal{N} \cup \mathcal{L} \cup \{ t\}$ under the worst-case perturbation. We will let $\mathbf{z}$ be the vector concatenation of the rows of the $\left| \mathcal{I}\right| \times \left( {{2}^{d + 2} - 2}\right)$ matrix of ${z}_{n,m}^{i}$ values with rows corresponding to data sample $i$ and columns representing edge(n, m)for $n = a\left( m\right)$ . Note that ${z}_{n,m}^{i}$ are the decision variables of a maximum flow problem, where in the induced graph from data sample $i,{z}_{n,m}^{i}$ is 1 if and only if the maximum flow is 1 and the flow goes from node $n$ to node $m$ . Therefore, if there exists an $n \in \mathcal{N} \cup \mathcal{L}$ such that ${z}_{n,t}^{i} = 1$ , then sample $i$ is correctly classified by our tree after observing the worst-case perturbation.
+
+Our two-stage approach to defining the variables $\mathbf{b},\mathbf{w}$ , $\xi$ , and $\mathbf{z}$ leads us to the following formulation for a robust classification tree:
+
+$$
+\mathop{\max }\limits_{{\mathbf{b},\mathbf{w}}}\mathop{\min }\limits_{{\mathbf{\xi } \in \Xi }}\mathop{\max }\limits_{{\mathbf{z} \in \mathcal{Z}\left( {\mathbf{b},\mathbf{w},\mathbf{\xi }}\right) }}\mathop{\sum }\limits_{{i \in \mathcal{I}}}\mathop{\sum }\limits_{{n \in \mathcal{N} \cup \mathcal{L}}}{z}_{n,t}^{i} \tag{1a}
+$$
+
+$$
+\text{ s.t. }\mathop{\sum }\limits_{{f \in \mathcal{F}}}\mathop{\sum }\limits_{{\theta \in \Theta \left( f\right) }}{b}_{nf\theta } + \mathop{\sum }\limits_{{k \in \mathcal{K}}}{w}_{nk} = 1\;\forall n \in \mathcal{N} \tag{1b}
+$$
+
+$$
+\mathop{\sum }\limits_{{k \in \mathcal{K}}}{w}_{nk} = 1\;\forall n \in \mathcal{L} \tag{1c}
+$$
+
+$$
+{b}_{nf\theta } \in \{ 0,1\} \;\forall n \in \mathcal{N},f \in \mathcal{F},\theta \in \Theta \left( f\right) \tag{1d}
+$$
+
+$$
+{w}_{nk} \in \{ 0,1\} \;\forall n \in \mathcal{N} \cup \mathcal{L},k \in \mathcal{K}, \tag{1e}
+$$
+
+where the set $\mathcal{Z}$ is defined as
+
+$$
+\mathcal{Z}\left( {\mathbf{b},\mathbf{w},\mathbf{\xi }}\right) \mathrel{\text{ := }} \{ \mathbf{z} \in \{ 0,1{\} }^{\left| \mathcal{I}\right| \times \left( {{2}^{d + 2} - 2}\right) } :
+$$
+
+$$
+{z}_{n,l\left( n\right) }^{i} \leq \mathop{\sum }\limits_{{f \in \mathcal{F}}}\mathop{\sum }\limits_{\substack{{\theta \in \Theta \left( f\right) : } \\ {{x}_{f}^{i} + {\xi }_{f}^{i} \leq \theta } }}{b}_{nf\theta }\;\forall i \in \mathcal{I},n \in \mathcal{N}, \tag{2a}
+$$
+
+$$
+{z}_{n,r\left( n\right) }^{i} \leq \mathop{\sum }\limits_{{f \in \mathcal{F}}}\mathop{\sum }\limits_{\substack{{\theta \in \Theta \left( f\right) : } \\ {{x}_{f}^{i} + {\xi }_{f}^{i} \geq \theta + 1} }}{b}_{nf\theta }\;\forall i \in \mathcal{I},n \in \mathcal{N}, \tag{2b}
+$$
+
+$$
+{z}_{a\left( n\right) ,n}^{i} = {z}_{n,l\left( n\right) }^{i} + {z}_{n,r\left( n\right) }^{i} + {z}_{n,t}^{i}\;\forall i \in \mathcal{I},n \in \mathcal{N}, \tag{2c}
+$$
+
+$$
+{z}_{a\left( n\right) ,n}^{i} = {z}_{n,t}^{i}\;\forall i \in \mathcal{I},n \in \mathcal{L}, \tag{2d}
+$$
+
+$$
+{z}_{n,t}^{i} \leq {w}_{n,{y}^{i}}\;\forall i \in \mathcal{I},n \in \mathcal{N} \cup L \tag{2e}
+$$
+
+}.
+
+The objective function in (1) maximizes the number of correctly classified training samples in the worst-case perturbation. The constraint (1b) states that each internal node must either classify a point or must be a binary test with some threshold $\theta$ . The constraint (1c) states that each leaf node must classify a point.
+
+The set (2) describes the maximum flow constraints for each sample's induced graph. Constraints (2a) and (2b) are capacity constraints that control the flow of samples in the induced graph based on $\mathbf{x} + \mathbf{\xi }$ and the tree structure. Constraints (2c) and (2d) are flow conservation constraints. Lastly, constraint (2e) blocks any flow to the sink if the node is either not an assignment node or the assignment is incorrect.
+
+§ 2.3 THE UNCERTAINTY SET
+
+We consider uncertainty sets defined as follows. Let ${\gamma }_{f}^{i} \in \mathbb{R}$ be the cost of perturbing ${x}_{f}^{i}$ by one. Thus, ${\gamma }_{f}^{i}\left| {\xi }_{f}^{i}\right|$ is the total cost of perturbing ${x}_{f}^{i}$ to ${x}_{f}^{i} + {\xi }_{f}^{i}$ . Letting $\epsilon$ be the total allowable budget of uncertainty across data samples, we define the following uncertainty set:
+
+$$
+\Xi \mathrel{\text{ := }} \left\{ {\xi \in {\mathbb{Z}}^{\left| \mathcal{I}\right| \times \left| \mathcal{F}\right| } : \mathop{\sum }\limits_{{i \in \mathcal{I}}}\mathop{\sum }\limits_{{f \in \mathcal{F}}}{\gamma }_{f}^{i}\left| {\xi }_{f}^{i}\right| \leq \epsilon }\right\} . \tag{3}
+$$
+
+As we will show later, a tailored solution method of Formulation (1) can be made if uncertainty is defined by set (3), and there exists a connection between (3) and hypothesis testing.
+
+§ 3 SOLUTION METHOD
+
+We now present a method of solving problem (1) through a reformulation that can leverage existing, off-the-shelf mixed-integer linear programming solvers.
+
+§ 3.1 REFORMULATING THE TWO-STAGE PROBLEM
+
+We solve our two-stage optimization problem by first taking the dual of the inner maximization problem. Recall that the inner maximization problem is a maximum flow problem; therefore, the dual of the inner maximization problem will yield an inner minimum cut problem (Vazirani 2001). Note that strong duality holds, and therefore taking the dual of the inner problem of (1) will yield a reformulation with equal optimal objective values, and thus optimal tree structure variables $\mathbf{b}$ and $\mathbf{w}$ for both problems.
+
+Let ${q}_{n,m}^{i}$ be the binary dual variable that equals 1 if and only if in the induced graph for data sample $i$ after perturbation, the edge that connects nodes $n \in \mathcal{N} \cup \{ s\}$ and $m \in \mathcal{N} \cup \mathcal{L} \cup \{ t\}$ is in the minimum cut. We write $\mathbf{q}$ as the vector concatenation of the rows of the $\left| \mathcal{I}\right| \times \left( {{2}^{d + 2} - 2}\right)$ matrix of ${q}_{n,m}^{i}$ values with rows corresponding to data sample $i$ and columns representing edge(n, m). We also define ${p}_{n}^{i}$ to be a binary variable that equals 1 if and only if in the induced graph of data sample $i \in \mathcal{I}$ , the node $n \in \mathcal{N} \cup \mathcal{L} \cup \{ s\}$ is in the source set. Letting $\mathcal{Q}$ be the set of all possible values of $\mathbf{q}$ , we then have
+
+$$
+\mathcal{Q} \mathrel{\text{ := }} \{ \mathbf{q} \in \{ 0,1{\} }^{\left| \mathcal{I}\right| \times \left( {{2}^{d + 2} - 2}\right) } :
+$$
+
+$$
+\exists {p}_{n}^{i} \in \{ 0,1\} \;\forall i \in \mathcal{I},n \in \mathcal{N} \cup \mathcal{L} \cup \{ s\} , \tag{4a}
+$$
+
+$$
+{q}_{n,l\left( n\right) }^{i} - {p}_{n}^{i} + {p}_{l\left( n\right) }^{i} \geq 0\;\forall i \in \mathcal{I},n \in \mathcal{N}, \tag{4b}
+$$
+
+$$
+{q}_{n,r\left( n\right) }^{i} - {p}_{n}^{i} + {p}_{r\left( n\right) }^{i} \geq 0\;\forall i \in \mathcal{I},n \in \mathcal{N}, \tag{4c}
+$$
+
+$$
+{q}_{s,1}^{i} + {p}_{1}^{i} \geq 1\;\forall i \in \mathcal{I}, \tag{4d}
+$$
+
+$$
+- {p}_{n}^{i} + {q}_{n,t}^{i} \geq 0\;\forall i \in \mathcal{I},n \in \mathcal{N} \cup \mathcal{L}, \tag{4e}
+$$
+
+}.
+
+Constraints (4b) ensures that if the node $n \in \mathcal{N}$ is in the source set, then either its left child is also in the source set or the edge between $n$ and its left child are in the cut. Constraint (4c) is analogous to (4b), but with the right child of node $n \in \mathcal{N}$ . Constraint (4d) states that either the root node is in the source set or the edge from the source to the root node is in the cut. Lastly, constraint (4e) ensures that for any $n \in$ $\mathcal{N} \cup \mathcal{L}$ , if $n$ is in the source set, then the edge from $n$ to the sink must be in the cut.
+
+Then, taking the dual of the inner maximization problem in (1) gives the following single-stage formulation:
+
+$$
+\mathop{\max }\limits_{{\mathbf{b},\mathbf{w}}}\mathop{\min }\limits_{{\mathbf{q} \in \mathcal{Q},\mathbf{\xi } \in \Xi }}\mathop{\sum }\limits_{{i \in \mathcal{I}}}\mathop{\sum }\limits_{{n \in \mathcal{N}}}\mathop{\sum }\limits_{\substack{{\theta \in \Theta \left( f\right) : } \\ {{x}_{f}^{i} + {\xi }_{f}^{i} \leq \theta } }}\mathop{\sum }\limits_{{n,l\left( n\right) }}{q}_{n,l\left( n\right) }^{i}{b}_{nf\theta }
+$$
+
+$$
++ \mathop{\sum }\limits_{{i \in \mathcal{I}}}\mathop{\sum }\limits_{{n \in \mathcal{N}}}\mathop{\sum }\limits_{\substack{{f \in \mathcal{F}} \\ {{x}_{f}^{i} + {\xi }_{f}^{i} \geq \theta + 1} }}\mathop{\sum }\limits_{\substack{{\theta \in \Theta \left( f\right) } \\ {{x}_{f}^{i} + {\xi }_{f}^{i} \geq \theta + 1} }}{q}_{n,r\left( n\right) }^{i}{b}_{nf\theta }
+$$
+
+$$
++ \mathop{\sum }\limits_{{i \in \mathcal{I}}}\mathop{\sum }\limits_{{n \in \mathcal{N} \cup \mathcal{L}}}{q}_{n,t}^{i}{w}_{n,{y}^{i}} + \mathop{\sum }\limits_{{i \in \mathcal{I}}}{q}_{s,1}^{i} \tag{5a}
+$$
+
+$$
+\text{ s.t. }\mathop{\sum }\limits_{{f \in \mathcal{F}}}\mathop{\sum }\limits_{{\theta \in \Theta \left( f\right) }}{b}_{nf\theta } + \mathop{\sum }\limits_{{k \in \mathcal{K}}}{w}_{nk} = 1\;\forall n \in \mathcal{N} \tag{5b}
+$$
+
+$$
+\mathop{\sum }\limits_{{k \in \mathcal{K}}}{w}_{nk} = 1\;\forall n \in \mathcal{L} \tag{5c}
+$$
+
+$$
+{b}_{nf\theta } \in \{ 0,1\} \;\forall n \in \mathcal{N},f \in \mathcal{F},\theta \in \Theta \left( f\right) \tag{5d}
+$$
+
+$$
+{w}_{nk} \in \{ 0,1\} \;\forall n \in \mathcal{N} \cup \mathcal{L},k \in \mathcal{K} \tag{5e}
+$$
+
+where $\mathcal{Q}$ is defined by (4) and constraints (5b) and (5c) are the same as constraints (1b) and (1c) respectively. As mentioned before, strong duality holds between Formulations (1) and (5) since strong duality holds between the maximum flow and minimum cut problems.
+
+§ 3.2 SOLVING THE SINGLE-STAGE REFORMULATION
+
+We can obtain a mixed-integer linear program equivalent to (5) by doing a hypograph reformulation. However, a hypo-graph reformulation would introduce an extremely large of constraints. A common approach to solving the reformulation is to use a tailored Benders decomposition algorithm, which we describe here.
+
+The master problem decides the tree structure given its current constraints. We thus have the following initial master problem:
+
+$$
+\mathop{\max }\limits_{{\mathbf{b},\mathbf{w},\mathbf{t}}}\mathop{\sum }\limits_{{i \in \mathcal{I}}}{t}_{i} \tag{6a}
+$$
+
+$$
+\text{ s.t. }\mathop{\sum }\limits_{{f \in \mathcal{F}}}\mathop{\sum }\limits_{{\theta \in \Theta \left( f\right) }}{b}_{nf\theta } + \mathop{\sum }\limits_{{k \in \mathcal{K}}}{w}_{nk} = 1\;\forall n \in \mathcal{N} \tag{6b}
+$$
+
+$$
+\mathop{\sum }\limits_{{k \in \mathcal{K}}}{w}_{nk} = 1\;\forall n \in \mathcal{L} \tag{6c}
+$$
+
+$$
+{t}_{i} \leq 1\;\forall i \in \mathcal{I} \tag{6d}
+$$
+
+$$
+{b}_{nf\theta } \in \{ 0,1\} \;\forall n \in \mathcal{N},f \in \mathcal{F},\theta \in \Theta \left( f\right) \tag{6e}
+$$
+
+$$
+{w}_{nk} \in \{ 0,1\} \;\forall n \in \mathcal{N} \cup \mathcal{L},k \in \mathcal{K} \tag{6f}
+$$
+
+where ${t}_{i}$ comes from the hypograph of the inner sum of objective function (5a) for a particular $i \in \mathcal{I}$ . We add the constraint (6d) to ensure that the initial problem is bounded.
+
+The goal for the subproblem is, given certain values of $\mathbf{b}$ , $\mathbf{w}$ , and $\mathbf{t}$ that describe a specific tree structure, find a perturbation in $\Xi$ that reduces the number of correctly classified samples the most. After finding the minimum cut of the induced graph for each data sample after deciding the perturbation, we add a constraint of the form
+
+$$
+\mathop{\sum }\limits_{{i \in \mathcal{I}}}{t}_{i} \leq \mathop{\sum }\limits_{{i \in \mathcal{I}}}\mathop{\sum }\limits_{{n \in \mathcal{N}}}\mathop{\sum }\limits_{\substack{{f \in \mathcal{F}} \\ {f \in {\mathcal{F}}_{f} \leq \theta } }}\mathop{\sum }\limits_{\substack{{\theta \in \Theta \left( f\right) : } \\ {{x}_{f}^{i} + {\xi }_{f}^{i} \leq \theta } }}{q}_{n,l\left( n\right) }^{i}{b}_{nf\theta }
+$$
+
+$$
++ \mathop{\sum }\limits_{{i \in \mathcal{I}}}\mathop{\sum }\limits_{{n \in \mathcal{N}}}\mathop{\sum }\limits_{\substack{{f \in \mathcal{F}} \\ {{x}_{f}^{i} + {\xi }_{f}^{i} \geq \theta + 1} }}\mathop{\sum }\limits_{\substack{{\theta \in \Theta \left( f\right) } \\ {{x}_{f}^{i} + {\xi }_{f}^{i} \geq \theta + 1} }}{q}_{n,r}^{i}{b}_{nf\theta } \tag{7}
+$$
+
+$$
++ \mathop{\sum }\limits_{{i \in \mathcal{I}}}\mathop{\sum }\limits_{{n \in \mathcal{N} \cup \mathcal{L}}}{q}_{n,t}^{i}{w}_{n,{y}^{i}} + \mathop{\sum }\limits_{{i \in \mathcal{I}}}{q}_{s,1}^{i}
+$$
+
+where we substitute the variables $\mathbf{\xi }$ and $\mathbf{q}$ with the perturbation and minimum cuts.
+
+§ 3.3 THE SUBPROBLEM
+
+We will now describe the procedure for the subproblem to find the perturbation and minimum cuts that will yield a violated constraint of the form (7) if a violated constraint exists.
+
+For each data sample that is correctly classified by the tree given by the master problem (6), we first find the lowest-cost perturbation ${\xi }^{i}$ for the single sample that would cause it to be misclassified. To do this, we set up a shortest path problem. The weighted graph of the shortest path problem is created from the flow-based tree returned by the master problem, and is constructed with the following procedure:
+
+1. The edge from $s$ to 1 (the root of the decision tree) has path cost 0 .
+
+2. For each $n \in \mathcal{N} \cup \mathcal{L}$ , if there exists a $k \in \mathcal{K}$ such that ${w}_{nk} = 1$ , and $k \neq {y}^{i}$ , then we have a 0 path cost from $n$ to $t$ . All other edges coming into $t$ have infinite path cost.
+
+3. For each $n \in \mathcal{N}$ , if there exists an $f \in \mathcal{F}$ such that ${b}_{nf} = 1$ , then...
+
+(a) if ${x}_{f}^{i} = 0$ , add an edge from $n$ to $l\left( n\right)$ with 0 weight, and add an edge from $n$ to $r\left( n\right)$ with ${\gamma }_{f}$ weight.
+
+(b) if ${x}_{f}^{i} = 1$ , add an edge from $n$ to $r\left( n\right)$ with 0 weight, and add an edge from $n$ to $l\left( n\right)$ with ${\gamma }_{f}$ weight. By finding the shortest path from $s$ to $t$ for the weighted graph derived from data sample $i$ , we find the path with the smallest total cost of perturbation that would misclassify the point $i$ . That is, we use the shortest path to see what perturbation ${\mathbf{\xi }}^{i}$ would misclassify ${\mathbf{x}}^{i}$ with the smallest cost.
+
+Once we find the lowest-cost perturbation that would misclassify every sample, we choose the largest subset of these training samples whose total cost of perturbation to misclassify each sample is less than the allowed budget of uncertainty. Through this procedure, we find the value of $\xi$ that misclassifies the most number of points given the current tree.
+
+Note that the right hand side of the constraint (7) gives the count of the the number of correctly classified points for a certain $\mathbf{b},\mathbf{w},\mathbf{\xi }$ , and $\mathbf{q}$ . Therefore, for dataset $\mathbf{x} + \mathbf{\xi }$ , if the number of correctly classified points is less than the optimal value of $\mathop{\sum }\limits_{{i \in I}}{t}_{i}$ from the master problem, then we know that there exists a constraint of the form (7) that is violated. Otherwise, there are no violated constraints of the form (7), which indicates the optimality of the current solution.
+
+In the case of finding a violated constraint, we now would like to obtain the values of $\mathbf{q}$ , the variables associated with the minimum cut problem. To do this, we need to find for each sample $i \in \mathcal{I}$ the set of edges in a minimum cut given the path of the data point ${\mathbf{x}}^{i} + {\xi }^{i}$ , where the value of the cut is 1 if ${\mathbf{x}}^{i} + {\mathbf{\xi }}^{i}$ is correctly classified and 0 otherwise. The simplest way to construct this minimum cut is for each $i \in \mathcal{I}$ , we follow the path of ${\mathbf{x}}^{i} + {\mathbf{\xi }}^{i}$ . At each node visited in this path, we first include to the minimum cut any edges outgoing from that node that are not traversed. And at the assignment node, we also include the edge going from the assignment node to the sink $t$ . By doing this procedure for all training samples, we obtain the value of $\mathbf{q}$ describing all minimum cuts.
+
+By finding the value of $\xi$ and an associated $\mathbf{q}$ , we can use these values in (7) to obtain the most restrictive violated constraint for a given tree, which we add back to the master problem. We summarize our approach in Algorithm 1.
+
+§ 4 STATISTICAL CONNECTIONS
+
+Here, we explore how the uncertainty set described in (3) connects to hypothesis testing. Let ${q}_{f}^{\zeta } \in (0,1\rbrack$ be the probability that the realization of the data at feature $f$ as decided by our uncertainty set perturbs the nominal data at feature $f$ by $\zeta \in \mathbb{Z}$ . We will impose the assumption that the perturbations follow a geometric distribution. More specifically,
+
+$$
+{q}_{f}^{\zeta } = {\left( {0.5}\right) }^{\mathbb{I}\left\lbrack {\zeta \neq 0}\right\rbrack }{q}_{f}{\left( 1 - {q}_{f}\right) }^{\left| \zeta \right| } \tag{8}
+$$
+
+for some ${q}_{f} \in (0,1\rbrack$ (where the ${\left( {0.5}\right) }^{\mathbb{I}\left\lbrack {\zeta \neq 0}\right\rbrack }$ multiplier imposes a symmetry between positive and negative values of the perturbation).
+
+We will set up a likelihood ratio test with threshold ${\lambda }^{\left| \mathcal{I}\right| }$ for $\lambda \in \left\lbrack {0,1}\right\rbrack$ , where we add the exponential of $\left| \mathcal{I}\right|$ for ease of comparison across different data sets with different number of training samples. Our null hypothesis will be that a given perturbation of our data comes from the distribution of perturbations given by the chosen ${q}_{f}^{\zeta } \in (0,1\rbrack$ . Then, we set up a likelihood ratio test where we fail to reject the null hypothesis if
+
+$$
+\frac{\mathop{\prod }\limits_{{i \in \mathcal{I}}}\mathop{\prod }\limits_{{f \in \mathcal{F}}}\mathop{\prod }\limits_{{\zeta = - \infty }}^{\infty }{\left( {q}_{f}^{\zeta }\right) }^{\mathbb{I}\left\lbrack {{\xi }_{f}^{i} = = \zeta }\right\rbrack }}{\mathop{\prod }\limits_{{i \in \mathcal{I}}}\left\lbrack {\mathop{\prod }\limits_{{f \in \mathcal{F}}}{q}_{f}^{0}}\right\rbrack } \geq {\lambda }^{\left| \mathcal{I}\right| }, \tag{9}
+$$
+
+Algorithm 1: Solution Method to formulation (5)
+
+Input: training set indexed by $\mathcal{I}$ with features $\mathcal{F}$ and labels
+
+$\mathcal{K}$ , range of test thresholds $\Theta \left( f\right)$ , tree depth $d$ , uncertainty
+
+set parameters $\gamma$ and $\epsilon$
+
+Output: The optimal robust tree represented by ${\mathcal{T}}^{ * } =$
+
+$\left( {{\mathbf{b}}^{ * },{\mathbf{w}}^{ * }}\right)$
+
+ while no tree $\mathcal{T}$ returned do
+
+ Solve the master problem (6) with any added con-
+
+ straints, obtain tree $\mathcal{T} = \left( {{\mathbf{b}}^{ * },{\mathbf{w}}^{ * }}\right)$ , and ${\mathbf{t}}^{ * }$
+
+ Find the lowest cost $\xi$ that causes the most number of
+
+ samples to be misclassified in $\mathcal{T}$ to obtain ${\mathbf{\xi }}^{ * }$
+
+ if $\mathop{\sum }\limits_{{i \in \mathcal{I}}}{t}_{i} \leq$ number of correctly classified samples
+
+ of $\mathbf{x} + {\mathbf{\xi }}^{ * }$ given $\mathcal{T}$ then
+
+ return $\mathcal{T}$
+
+ else
+
+ Find ${\mathbf{q}}^{ * }$ by finding a minimum cut for each $i \in \mathcal{I}$
+
+ based on $\mathbf{x} + {\mathbf{\xi }}^{ * }$ and $\mathcal{T}$
+
+ Use values of ${\mathbf{\xi }}^{ * }$ and ${\mathbf{q}}^{ * }$ to create constraint (7) to
+
+ add to the master problem.
+
+ end if
+
+ end while
+
+where the numerator of the left hand side is the maximum likelihood of a given perturbation $\xi$ , and the denominator of the left hand side is the likelihood under the null hypothesis. Using the assumption that ${q}_{f}^{\zeta }$ follows (8), we can reduce the hypothesis test in (9) into
+
+$$
+\mathop{\sum }\limits_{{i \in \mathcal{I}}}\mathop{\sum }\limits_{{f \in \mathcal{F}}}\left| {\xi }_{f}^{i}\right| \log \left( \frac{1}{1 - {q}_{f}}\right) \leq - \left| \mathcal{I}\right| \log \lambda . \tag{10}
+$$
+
+We say that if a particular $\xi$ lies within the region where we fail to reject the null hypothesis, then it is part of our perturbation set. That is, using the notation from the perturbation set defined in (3), letting ${\gamma }_{f}^{i} = \log \left( \frac{1}{1 - {q}_{f}}\right)$ and $\epsilon = - \left| \mathcal{I}\right| \log \lambda$ yields an uncertainty set with a direct relationship to the probabilities of certainty for each feature.
+
+§ 5 EXPERIMENTS
+
+We evaluate our approach on 12 datasets from the UCI Machine Learning Repository (Dua and Graff 2017). For each data set, we construct a robust classification tree from our method using a synthetic uncertainty set where for different problem instances, we choose different levels of uncertainty in the features and budgets of uncertainty. We utilize the hypothesis testing framework as described by (10), where we define ${q}_{f}$ by sampling the probability of certainty from a normal distribution with a particular mean we set and a standard deviation of 0.2 . The means of this normal distribution included0.6,0.7,0.8, and 0.9 . We also chose different values of our budget by setting $\lambda$ to be0.5,0.75,0.85,0.9, 0.95,0.97, and 0.99 . For every data set and uncertainty set, we tested with tree depths of2,3,4and 5 .
+
+ < g r a p h i c s >
+
+Figure 2: This graph shows the number of instances solved across times and optimality gaps when the time limit of 7200 seconds is reached for several values of $\lambda$ . The case of $\lambda =$ 1.0 is the regularized tree with an empty uncertainty set.
+
+For each instance, we randomly split the data set into 80% training data, ${20}\%$ testing data. We then ran our algorithm to obtain a robust classification tree with a time limit of 7200 seconds. For comparison, we used our model to create a non-robust tree as well by setting the budget of uncertainty to 0 (i.e. $\lambda = 1$ ), and tuned a regularization parameter for the non-robust tree. The regularization term penalized the objective for every branching node to yield the following objective in the master problem of our algorithm:
+
+$$
+\mathop{\max }\limits_{{\mathbf{b},\mathbf{w},\mathbf{t}}}\left( {1 - R}\right) \mathop{\sum }\limits_{{i \in \mathcal{I}}}{t}_{i} - R\mathop{\sum }\limits_{{i \in \mathcal{I}}}\mathop{\sum }\limits_{{n \in \mathcal{N}}}\mathop{\sum }\limits_{{\Theta \left( f\right) }}{b}_{nf\theta }
+$$
+
+where $R \in \left\lbrack {0,1}\right\rbrack$ is the tuned regularization parameter. Note that we do not add a regularization parameter to our robust model, as robust optimization has an equivalence with regularization and so adding a regularization term is redundant (Bertsimas and Copenhaver 2018). We summarize the computation time across all instances in Figure 2. As we expected, the larger the uncertainty set, the longer it takes for the formulation to solve to optimality.
+
+To test our model's robustness against distribution shifts, we perturbed the test data in 5000 different ways, where for each perturbation we found the test accuracy from our robust tree. We first perturbed the data based on the expected distribution of perturbations. That is, for the collection of ${q}_{f}$ values for every $f \in \mathcal{F}$ used to construct an uncertainty set based off of (10), we perturb the data based on the distribution described in (8).
+
+In order to measure the robustness of our model based on unexpected perturbations of the data, we also repeat the same process but for values of ${q}_{f}$ different than what we gave our model. First, we shifted each ${q}_{f}$ value down 0.2, then perturb our test data in 5000 different ways based on these new values of ${q}_{f}$ . We do the same procedure but with ${q}_{f}$ shifted down by 0.1 and up by 0.1 . In a similar fashion, we also uniformly sampled a new ${q}_{f}$ value for each feature in a neighborhood of radius 0.05 of the original expected ${q}_{f}$ value, and perturbed the test data in 5000 different ways with the new ${q}_{f}$ values. We do the same procedure for the radii of the neighborhoods0.1,0.15, and 0.2,
+
+ < g r a p h i c s >
+
+Figure 3: These boxplots show the distribution across problem instances of the gain in worst-case accuracy from using a robust tree versus a non-robust, regularized tree across different values of $\lambda$ . We also show the distribution of the gain in worst-case accuracy in the case where perturbations of our data are not as we expect.
+
+For each set of perturbations of the test data, we measure the worst-case accuracy by finding the lowest accuracy from all perturbations we made for a single set of ${q}_{f}$ values, and measure the average accuracy by averaging over the accuracy over all perturbations for a single set of ${q}_{f}$ values. We compile the gain in worst-case and average-case performance from using our robust tree versus using a regularized, non-robust tree for every problem instance and perturbation of our data, giving us a distribution of worst-case and average case gains in performance that are summarized in Figures 3 and 4, respectively.
+
+From the figures, we see that our robust tree model in general has both higher worst-case and average-case accuracy than a non-robust model when there exists distribution shifts in the data. We also see that there is a range of values of $\lambda$ that seem to perform well over other values (namely 0.85). This shows us that if the budget of uncertainty is too small, then we do not allow enough room to hedge against distribution shifts in our uncertainty set. But if the budget of uncertainty is too large, then we become over-conservative and perform poorly for any perturbation of our test data. We also see that there is little difference between the gains in accuracy in instances where the perturbation of our data is as we expected versus when the perturbation is not as we expect. This indicates that even if we misspecify our model, we still obtain a classification tree robust to any kind of distribution shift within a reasonable range of our expected distribution shift. Overall, we see that an important factor in determining the performance of our model is the budget of uncertainty, which can be easily tuned to create an effective robust tree.
+
+ < g r a p h i c s >
+
+Figure 4: These boxplots show the distribution across problem instances of the gain in average test accuracy from using a robust tree versus a non-robust, regularized tree across different values of $\lambda$ . We also show this gain in average accuracy in the case where perturbations of our data are not what we expect.
\ No newline at end of file
diff --git a/papers/AAAI/AAAI 2022/AAAI 2022 Workshop/AAAI 2022 Workshop AdvML/HvRAM-dpmEv/Initial_manuscript_md/Initial_manuscript.md b/papers/AAAI/AAAI 2022/AAAI 2022 Workshop/AAAI 2022 Workshop AdvML/HvRAM-dpmEv/Initial_manuscript_md/Initial_manuscript.md
new file mode 100644
index 0000000000000000000000000000000000000000..04de71999c2c03c21e5c6837bb3197bc070c1b0d
--- /dev/null
+++ b/papers/AAAI/AAAI 2022/AAAI 2022 Workshop/AAAI 2022 Workshop AdvML/HvRAM-dpmEv/Initial_manuscript_md/Initial_manuscript.md
@@ -0,0 +1,603 @@
+# BiGrad: Differentiating through Bilevel Optimization Programming
+
+## Abstract
+
+Integrating mathematical programming, and in particular Bilevel Optimization Programming, within deep learning architectures has vast applications in various domains from machine learning to engineering. Bilevel programming is able to capture complex interactions when two actors have conflicting objectives. Previous approaches only consider single-level programming. In this paper, we thus propose Differentiating through Bilevel Optimization Programming (BiGrad) as approach for end-to-end learning of models that use Bilevel Programming as a layer. BiGrad has wide applicability and it can be used in modern machine learning frameworks. We focus on two classes of Bilevel Programming: continuous and combinatorial optimization problems. The framework extends existing approaches of single level optimization programming. We describe a class of gradient estimators for the combinatorial case which reduces the requirements in term of computation complexity; for the continuous variables case the gradient computation takes advantage of push-back approach (i.e. vector-jacobian product) for an efficient implementation. Experiments suggest that the proposed approach successfully extends existing single level approaches to Bilevel Programming.
+
+## 1 Introduction
+
+Neural networks provide unprecedented improvements in perception tasks, however, they struggle to learn basic logic operations (Garcez et al. 2015) or relationships. When modelling complex systems, for example decision systems, it is not only beneficial to integrate optimization components into larger differentiable system, but also to use general purpose solvers (e.g. for Integer Linear Programming or Nonlinear Programming (Bertsekas 1997; Boyd and Vanden-berghe 2004)) and problem specific implementation, to discover the governing discrete or continuous relationships. Recent approaches propose thus differentiable layers that incorporate either quadratic (Amos and Kolter 2017), convex (Agrawal et al. 2019a), cone (Agrawal et al. 2019b), equilibrium (Bai, Kolter, and Koltun 2019), SAT (Wang et al. 2019) or combinatorial (Pogančić et al. 2019; Mandi and Guns 2020; Berthet et al. 2020) programs. Use of optimization programming as layer of differentiable systems, requires to compute the gradients through these layers, which is either specific to the optimization problem or zero almost everywhere, when dealing with discrete variables. Proposed gradient estimates either relax the combinatorial problem (Mandi and Guns 2020), or perturb the input variables (Berthet et al. 2020; Domke 2010) or linearly approximate the loss function (Pogančić et al. 2019).
+
+These approaches though, do now allow to directly express models with conflicting objectives, for example in structural learning (Elsken, Metzen, and Hutter 2019) or adversarial system (Goodfellow et al. 2014). We thus consider the use of bilevel optimization programming as a layer. Bilevel Optimization Program (Kleinert et al. 2021; Colson, Marcotte, and Savard 2007; Dempe 2018; Stackelberg et al. 1952), also known as generalization of Stackelberg Games, is the extension of single-level optimization program, where the solution of one optimization problem (i.e. the outer problem) depends on the solution of another optimization problem (i.e. the inner problem). This class of problems can model interactions between two actors ${}^{1}$ , where the action of the first depends on the knowledge of the counter-action of the second. Bilevel Programming finds application in various domains, as in Electricity networks, Economics, Environmental policy, Chemical plant, defence and planning (Dempe 2018; Sinha, Malo, and Deb 2017). In general, Bilevel programs are NP-hard (Sinha, Malo, and Deb 2017), they require specialized solvers and it is not clear how to extend previous approaches, since standard chain rule is not directly applicable.
+
+By modelling the bilevel optimization problem as an implicit layer (Bai, Kolter, and Koltun 2019), we consider the more general case where 1) the solution of the bilevel problem is computed separately by a bilevel solver; thus leveraging on powerfully solver developed over various decades (Kleinert et al. 2021); and 2) the computation of the gradient is more efficient, since we do not have to propagate gradient through the solver. We thus propose Differentiating through Bilevel Optimization Programming (BiGrad):
+
+- BiGrad comprises of forward pass, where existing solvers can be used, and backward pass, where BiGrad estimates gradient for both continuous and combinatorial problems based on sensitivity analysis;
+
+- we show how the proposed gradient estimators relate to the single-level analogous and that the proposed approach is beneficial in both continuous and discrete cases.
+
+---
+
+Copyright © 2022, Association for the Advancement of Artificial Intelligence (www.aaai.org). All rights reserved.
+
+${}^{1}$ In the following section we provide concrete example of applications.
+
+---
+
+
+
+Figure 1: The Forward and backward passes of a Bilevel Programming layer: the larger system has input $d$ and output $u = {h}_{\psi } \circ H \circ {h}_{\theta }\left( d\right)$ ; the bilevel layer has input $z$ and output $x, y$ , which are solutions of a Bilevel optimization problem represented by the implicit function $H\left( {x, y, z}\right) = 0$ .
+
+## Examples of Bilevel Optimization Problems
+
+Physical System with control sub-system example Bilevel Programming is to model the interaction of a dynamical system(x)and its control sub-system(y), as for example an industrial plant or a physical process. The control sub-system changes based on the state of the underlying dynamical system, which itself solves a physics constraint optimization problem (Raissi, Perdikaris, and Karniadakis 2019; de Avila Belbute-Peres et al. 2018).
+
+Interdiction problem example Two actors discrete Interdiction problems (Fischetti et al. 2019), where one actor(x) tries to interdict the actions of another actors(y)under budget constraints, arise in various areas, from marketing, protecting critical infrastructure, preventing drug smuggling to hinder nuclear weapon proliferation.
+
+Min-max problem example Min-max problems are used to model robust optimization problems (Ben-Tal, El Ghaoui, and Nemirovski 2009), where a second variable represents the environment and is constrained to an uncertain set that captures the unknown variability of the environment.
+
+Adversarial attack in Machine Learning Bilevel pro-bram is used the represents the interaction between a machine learning model(y)and a potential attacker(x)(Gold-blum, Fowl, and Goldstein 2019) and is used to increase the resilience to intentional or unintended adversarial attacks.
+
+## 2 Differentiable Bilevel Optimization Layer
+
+We model the Bilevel Optimization Program as an Implicit Layer (Bai, Kolter, and Koltun 2019), i.e. as the solution of an implicit equation $H\left( {x, y, z}\right) = 0$ , in order to derive the gradient using the implicit function theorem, where $z$ is given and represents the parameters of our system we want to estimate, and $x, y$ are output variables (Fig.1). We also assume we have access ${}^{2}$ to a solver $\left( {x, y}\right) = {\operatorname{Solve}}_{H}\left( z\right)$ . The bilevel Optimization Program is then used a layer of a differentiable system, whose input is $d$ and output is given by $u = {h}_{\psi } \circ {\operatorname{Solve}}_{H} \circ {h}_{\theta }\left( d\right) = {h}_{\psi ,\theta }\left( d\right)$ , where $\circ$ is the function composition operator. We want to learn the parameters $\psi ,\theta$ of the function ${h}_{\psi ,\theta }\left( d\right)$ that minimize the loss function $L\left( {{h}_{\psi ,\theta }\left( d\right) , u}\right)$ , using the training data ${D}^{\mathrm{{tr}}} = \left\{ {\left( d, u\right) }_{i = 1}^{{N}^{\mathrm{{tr}}}}\right\}$ . In order to be able to perform the end-to-end training, we need to back-propagate the gradient of the Bilevel Optimization Program Layer, which can not be accomplish only using chain rule.
+
+### 2.1 Continuous Bilevel Programming
+
+We now present the definition of the continous Bilevel Optimization problem, which comprises of two non-linear function $f, g$ , as
+
+$$
+\mathop{\min }\limits_{{x \in X}}f\left( {x, y, z}\right) \;y \in \arg \mathop{\min }\limits_{{y \in Y}}g\left( {x, y, z}\right) \tag{1}
+$$
+
+where the left part problem is called outer optimization problem and resolves for the variable $x \in X$ , with $X = {\mathbb{R}}^{n}$ . The right problem is called the inner optimization problem and solves for the variable $y \in Y$ , with $Y = {\mathbb{R}}^{m}$ . The variable $z \in {\mathbb{R}}^{p}$ is the input variable and is a parameter for the bilevel problem. Min-max is special case of Bilevel optimization problem $\mathop{\min }\limits_{{y \in Y}}\mathop{\max }\limits_{{x \in X}}g\left( {x, y, z}\right)$ , where the minimization functions are equal and opposite in sign.
+
+### 2.2 Combinatorial Bilevel Programming
+
+When the variables are discrete, we restrict the objective functions to be multi-linear (Greub 1967). Various important combinatorial problems are linear in discrete variables (e.g. VRP, TSP, SAT ${}^{3}$ ), one example form is the following
+
+$$
+\mathop{\min }\limits_{{x \in X}}\langle z, x{\rangle }_{A} + \langle y, x{\rangle }_{B}, y \in \arg \mathop{\min }\limits_{{y \in Y}}\langle w, y{\rangle }_{C} + \langle x, y{\rangle }_{D}
+$$
+
+(2)
+
+The variables $x, y$ have domains in $x \in X, y \in Y$ , where $X, Y$ are convex polytopes that are constructed from a set of distinct points $\mathcal{X} \subset {\mathbb{R}}^{n},\mathcal{Y} \subset {\mathbb{R}}^{m}$ , as their convex hull. The outer and inner problems are Integer Linear Programs (ILPs). The multi-linear operator is represented by the inner product $\langle x, y{\rangle }_{A} = {x}^{T}{Ay}$ . We only consider the case where we have separate parameters for the outer and inner problems, $z \in {\mathbb{R}}^{p}$ and $w \in {\mathbb{R}}^{q}$ .
+
+## 3 BiGrad: Gradient estimation
+
+Even if the discrete and continuous variable cases share a similar structure, the approach is different when evaluating the gradients. We can identify the following common basic steps (Alg.1):
+
+1. In the forward pass, solve the combinatorial or continuous Bilevel Optimisation problem as defined in Eq.1(or Eq.2) using existing solver;
+
+2. During the backward pass, compute the gradient ${\mathrm{d}}_{z}L$ (and ${\mathrm{d}}_{w}L$ ) using the suggested gradients (Sec.3.1 and Sec.3.2) starting from the gradients on the output variables ${\nabla }_{x}L$ and ${\nabla }_{y}L$ .
+
+---
+
+${}^{2}$ Finding the solution of the bi-level problem is not in the scope of this work.
+
+${}^{3}$ Vehicle Routing Problem, Boolean satisfiability problem.
+
+---
+
+Algorithm 1: BiGrad Layer: Bilevel Optimization Programming Layer using BiGrad
+
+---
+
+1. Input: Training sample $\left( {\widetilde{d},\widetilde{u}}\right)$
+
+2. Forward Pass:
+
+(a) Compute $\left( {x, y}\right) \in \{ x, y : H\left( {x, y, z}\right) = 0\}$ using
+
+ Bilevel Solver: $\left( {x, y}\right) \in {\operatorname{Solve}}_{H}\left( z\right)$
+
+(b) Compute the loss function $L\left( {{h}_{\psi } \circ H \circ {h}_{\theta }\left( \widetilde{d}\right) ,\widetilde{u}}\right)$ ,
+
+(c) Save(x, y, z)for the backward pass
+
+3. Backward Pass:
+
+(a) update the parameter of the downstream layers $\psi$ using
+
+ back-propagation
+
+(b) For the continuous variable case, compute based on
+
+ Theorem 2 around the current solution(x, y, z), with-
+
+ out solving the Bilevel Problem
+
+(c) For the discrete variable case, use the gradient es-
+
+ timates of Theorem 3 or Section 3.2 (e.g. Eq. 11 or
+
+ Eq.12) by solving, when needed, for the two separate
+
+ problems
+
+ (d) Back-propagate the estimated gradient to the down-
+
+ stream parameters $\theta$
+
+---
+
+### 3.1 Continuous Optimization
+
+To evaluate the gradient of the variables $z$ versus the loss function $L$ , we need to propagate the gradients of the two output variables $x, y$ through the two optimization problems. We can use the implicit function theorem to approximate locally the function $z \rightarrow \left( {x, y}\right)$ . We have thus the following main results ${}^{4}$ .
+
+Theorem 1. Consider the bilevel problem of Eq.1, we can build the following set of equations that represent the equivalent problem around a given solution ${x}^{ * },{y}^{ * },{z}^{ * }$ :
+
+$$
+F\left( {x, y, z}\right) = 0\;G\left( {x, y, z}\right) = 0 \tag{3}
+$$
+
+where
+
+$$
+F\left( {x, y, z}\right) = {\nabla }_{x}f - {\nabla }_{y}f{\nabla }_{y}G{\nabla }_{x}G,\;G\left( {x, y, z}\right) = {\nabla }_{y}g \tag{4}
+$$
+
+where we used the short notation $f = f\left( {x, y, z}\right) , g =$ $g\left( {x, y, z}\right) , F = F\left( {x, y, z}\right) , G = G\left( {x, y, z}\right)$
+
+Theorem 2. Consider the problem defined in Eq.1, then the total gradient of the parameter $z$ w.r.t. the loss function $L\left( {x, y, z}\right)$ is computed from the partial gradients ${\nabla }_{x}L,{\nabla }_{y}L,{\nabla }_{z}L$ as
+
+$$
+{\mathrm{d}}_{z}L = {\nabla }_{z}L - \left| {{\nabla }_{x}L\;{\nabla }_{y}L}\right| {\left| \begin{array}{ll} {\nabla }_{x}F & {\nabla }_{y}F \\ {\nabla }_{x}G & {\nabla }_{y}G \end{array}\right| }^{-1}\left| \begin{array}{l} {\nabla }_{z}F \\ {\nabla }_{z}G \end{array}\right|
+$$
+
+(5)
+
+The implicit layer is thus defined by the two conditions $F\left( {x, y, z}\right) = 0$ and $G\left( {x, y, z}\right) = 0$ . We notice that Eq. 5 can be solved without explicitly computing the Jacobian matrices and inverting the system, but adopting the Vector-Jacobian product approach we can proceed from left to right to evaluate ${\mathrm{d}}_{z}L$ . In the following section we describe how affine equality constraints and nonlinear inequality can be used when modelling $f, g$ . We also notice that the solution of Eq. 5 does not require to solve the original problem, but only to apply matrix-vector products, i.e. linear algebra, and the evaluation of the gradient that can be computed using automatic differentiation.
+
+Linear Equality constraints To extend the model of Eq. 1 to include linear equality constraints of the form ${Ax} = b$ and ${By} = c$ on the outer and inner problem variables, we use the following change of variables
+
+$$
+x \rightarrow {x}_{0} + {A}^{ \bot }x, y \rightarrow {y}_{0} + {B}^{ \bot }y \tag{6}
+$$
+
+where ${A}^{ \bot },{B}^{ \bot }$ are the orthogonal space of $A$ and $B$ , i.e. $A{A}^{ \bot } = 0, B{B}^{ \bot } = 0$ , and ${x}_{0},{y}_{0}$ are one solution of the equations, i.e. $A{x}_{0} = b, B{y}_{0} = c$ .
+
+Non-linear Inequality constraints Similarly, to extend the model of Eq.1 when we have non-linear inequality constraints, we use the barrier method approach (Boyd and Van-denberghe 2004), where the variable is penalized with a logarithmic function to violate the constraints. Specifically, let us consider the case where ${f}_{i},{g}_{i}$ are inequality constraint functions, i.e. ${f}_{i} < 0,{g}_{i} < 0$ , for the outer and inner problems. We then define new functions
+
+$$
+f \rightarrow {tf} - \mathop{\sum }\limits_{{i = 1}}^{{k}_{x}}\ln \left( {-{f}_{i}}\right) , g \rightarrow {tg} - \mathop{\sum }\limits_{{i = 1}}^{{k}_{y}}\ln \left( {-{g}_{i}}\right) . \tag{7}
+$$
+
+where $t$ is a variable parameter, which depends on the violation of the constraints. The closer the solution is to violate the constraints, the larger the value of $t$ is.
+
+Bilevel Cone programming We show here how Theorem. 2 can be applied to bi-level cone programming extending single-level cone programming results (Agrawal et al. 2019b), where we can use efficient solvers for cone programs to compute a solution of the bilevel problem (Ouattara and Aswani 2018)
+
+$$
+\mathop{\min }\limits_{x}{c}^{T}x + {\left( Cy\right) }^{T}x
+$$
+
+$$
+\text{s.t.}{Ax} + z + R\left( y\right) \left( {x - r}\right) = b, s \in \mathcal{K} \tag{8a}
+$$
+
+$$
+y \in \arg \mathop{\min }\limits_{y}{d}^{T}y + {\left( Dx\right) }^{T}y
+$$
+
+$$
+\text{s.t.}{By} + u + P\left( x\right) \left( {y - p}\right) = f, u \in \mathcal{K} \tag{8b}
+$$
+
+In this bilevel cone programming, the inner and outer problem are both cone programs, where $R\left( y\right) , P\left( x\right)$ represents a linear transformation, while $C, r, D, p$ are new parameters of the problem, while $\mathcal{K}$ is the conic domain of the variables. In the hypothesis that a local minima of Eq. 8 exists, we can use an interior point method to find such point. To compute the bilevel gradient, we then use the residual maps (Busseti, Moursi, and Boyd 2019) of the outer and inner problems. Indeed, we can then apply Theorem 2, where $F = {N}_{1}\left( {x, Q, y}\right)$ and $G = {N}_{2}\left( {y, Q, x}\right)$ are the normalized residual maps defined in (Busseti, Moursi, and Boyd 2019; Agrawal et al. 2019a) of the outer and inner problems.
+
+---
+
+${}^{4}$ Proofs are in the Supplementary Material
+
+---
+
+### 3.2 Combinatorial Optimization
+
+When we consider discrete variables, the gradient is zero almost everywhere. We thus need to resort to estimate gradients. For the bilevel problem with discrete variables of Eq.2, when the solution of the bilevel problem exists and its solution is given (Kleinert et al. 2021), Thm. 3 gives the gradients of the loss function with respect to the input parameters.
+
+Theorem 3. Given the Eq. 2 problem, the partial variation of a cost function $L\left( {x, y, z, w}\right)$ on the input parameters has the following form:
+
+$$
+{\mathrm{d}}_{z}L = {\nabla }_{z}L + \left\lbrack {{\nabla }_{x}L + {\nabla }_{y}L{\nabla }_{x}y}\right\rbrack {\nabla }_{z}x \tag{9a}
+$$
+
+$$
+{\mathrm{d}}_{w}L = {\nabla }_{w}L + \left\lbrack {{\nabla }_{x}L{\nabla }_{y}x + {\nabla }_{y}L}\right\rbrack {\nabla }_{w}y \tag{9b}
+$$
+
+The ${\nabla }_{x}y,{\nabla }_{y}x$ terms capture the interaction between outer and inner problems. We could estimate the gradients in Thm. 3 using the perturbation approach suggested in (Berthet et al. 2020), which estimate the gradient as the expected value of the gradient of the problem after perturbing the input variable, but, similar to REINFORCE (Williams 1992), this introduces large variance. While it is possible to reduce variance in some cases (Grathwohl et al. 2017) with the use of additional trainable functions, we consider alternative approaches as described in the following.
+
+Differentiation of blackbox combinatorial solvers (Pogančić et al. 2019) propose a way to propagate the gradient through a single level combinatorial solver, where ${\nabla }_{z}L \approx \frac{1}{\tau }\left\lbrack {x\left( {z + \tau {\nabla }_{x}L}\right) - x\left( z\right) }\right\rbrack$ when $x\left( z\right) = \arg \mathop{\max }\limits_{{x \in X}}\langle x, z\rangle$ . We thus propose to compute the variation on the input variables from the two separate problems of the Bilevel Problem:
+
+$$
+{\nabla }_{z}L \approx 1/\tau \left\lbrack {x\left( {z + {\tau A}{\nabla }_{x}L, y}\right) - x\left( {z, y}\right) }\right\rbrack \tag{10a}
+$$
+
+$$
+{\nabla }_{w}L \approx 1/\tau \left\lbrack {y\left( {w + {\tau C}{\nabla }_{y}L, x}\right) - y\left( {w, x}\right) }\right\rbrack \tag{10b}
+$$
+
+or alternatively, if we have only access to the Bilevel solver and not to the separate ILP solvers, we can express
+
+$$
+{\nabla }_{z, w}L \approx 1/\tau \left\lbrack {s\left( {v + {\tau E}{\nabla }_{x, y}L}\right) - s\left( v\right) }\right\rbrack \tag{11}
+$$
+
+where $x\left( {z, y}\right)$ and $y\left( {w, x}\right)$ represent the solutions of the two problems separately, $s\left( v\right) = \left( {z, w}\right) \rightarrow \left( {x, y}\right)$ the complete solution to the Bilevel Problem, $\tau \rightarrow 0$ is a hyper-parameter and $E = \left\lbrack \begin{matrix} A & 0 \\ 0 & C \end{matrix}\right\rbrack$ . This form is more convenient than Eq.9, since it does not require to compute the cross terms, ignoring thus the interaction of the two levels.
+
+Straight-Through gradient In estimating the input variables $z, w$ of our model, we may not be interested in the interaction between the two variable $x, y$ . Let us consider, for example, the squared ${\ell }_{2}$ loss function defined over the output variables
+
+$$
+{L}^{2}\left( {x, y}\right) = {L}^{2}\left( x\right) + {L}^{2}\left( y\right)
+$$
+
+where ${L}^{2}\left( x\right) = \frac{1}{2}{\begin{Vmatrix}x - {x}^{ * }\end{Vmatrix}}_{2}^{2}$ and ${x}^{ * }$ is the true value. The loss is non zero only when the two vectors disagree, and with integer variables, it counts the difference squared or, in case of the binary variables, it counts the number of differences. If we compute ${\nabla }_{x}{L}^{2}\left( x\right) = \left( {x - {x}^{ * }}\right)$ in the binary case, we have that ${\nabla }_{{x}_{i}}{L}^{2}\left( x\right) = + 1$ if ${x}_{i}^{ * } = 0 \land {x}_{i} = 1,{\nabla }_{{x}_{i}}{L}^{2}\left( x\right) =$ -1if ${x}_{i}^{ * } = 1 \land {x}_{i} = 0$ , and 0 otherwise. This information can be directly used to update the ${z}_{i}$ variable in the linear term $\langle z, x\rangle$ , thus we can estimate the gradients of the input variables as ${\nabla }_{{z}_{i}}{L}^{2} = - \lambda {\nabla }_{{x}_{i}}{L}^{2}$ and ${\nabla }_{{w}_{i}}{L}^{2} = - \lambda {\nabla }_{{y}_{i}}{L}^{2}$ , with some weight $\lambda > 0$ . The intuition is that, the weight ${z}_{i}$ associated with the variable ${x}_{i}$ is increased, when the value of the variable ${x}_{i}$ reduces. In the general multilinear case we have additional multiplicative terms. Following this intuition (see Sec.A.3), we thus use as an estimate of the gradient of the variables
+
+$$
+{\nabla }_{z}L = - A{\nabla }_{x}L\;{\nabla }_{w}L = - C{\nabla }_{y}L \tag{12}
+$$
+
+This is equivalent in Eq. 2 where ${\nabla }_{z}x = {\nabla }_{w}y = - I$ and ${\nabla }_{y}x = 0$ , thus ${\nabla }_{x}y = 0$ . This update is also equivalent to Eq. 10, without the soluton computation. The advantage of this form is that it does not requires to solve for an additional solution in the backward pass. For the single level problem, gradient has the same form of the Straight-Through gradient proposed by (Bengio, Léonard, and Courville 2013), with surrogate gradient ${\nabla }_{z}x = - I$ .
+
+## 4 Related Work
+
+Bilevel Programming in machine learning Various papers model machine learning problem as Bilevel problems, for example in Hyper-parameter Optimization (MacKay et al. 2019; Franceschi et al. 2018), Meta-Feature Learning (Li and Malik 2016), Meta-Initialization Learning (Ra-jeswaran et al. 2019), Neural Architecture Search (Liu, Si-monyan, and Yang 2018), Adversarial Learning (Li et al. 2019), Deep Reinforcement Learning (Vahdat et al. 2020) and Multi-Task Learning (Alesiani et al. 2020). In these works the main focus is to compute the solution of the bilevel optimization problems. In (MacKay et al. 2019; Lorraine and Duvenaud 2018), the best response function is modeled as a neural network and the solution is found using iterative minimization, without attempting to estimate the complete gradient. Many bilevel approaches rely on the use of the implicit function to compute the hyper-gradient (Sec. 3.5 of (Colson, Marcotte, and Savard 2007)), but do not use bilevel as layer.
+
+Quadratic, Cone and Convex single-level Programming Various works have addressed the problem of differentiate through quadratic, convex or cone programming (Amos 2019; Amos and Kolter 2017; Agrawal et al. 2019b, a). In these approaches the optimization layer is modelled as an implicit layer and for the cone/convex case the normalized residual map is used to propagate the gradients. Contrary to our approach, these work only address single level problems. These approaches do not consider combinatorial optimization.
+
+Implicit layer Networks While classical deep neural neural networks perform a single pass through the network at inference time, a new class of systems performs inference by solving an optimization problem. Example of this are Deep Equilibrium Network (DEQ) (Bai, Kolter, and Koltun 2019) and NeurolODE (NODE) (Chen et al. 2018). Similar to our approach, the gradient is computed based on sensitivity analysis of the current solution. These methods only consider continuous optimization.
+
+
+
+Figure 2: (a) Visualization of the Optimal Control Learning network, where a disturbance ${\epsilon }_{t}$ is injected based on the control signal ${u}_{t}$ . (b) Comparison of the training performance for $N = 2$ , $T = {20}$ and epochs $= {10}$ of the BiGrad and the Adversarial version of the OptNet (Amos and Kolter 2017).
+
+Combinatorial optimization Various papers estimate gradients of single-level combinatorial problems using relaxation. (Wilder, Dilkina, and Tambe 2019; Elmachtoub and Grigas 2017; Ferber et al. 2020; Mandi and Guns 2020) for example use ${\ell }_{1},{\ell }_{2}$ or log barrier to relax the Integer Linear Programming (ILP) problem. Once relaxed the problem is solved using standard methods for continuous variable optimization. An alternative approach is suggested in other papers. For example in (Pogančić et al. 2019) the loss function is approximated with a linear function and this leads to an estimate of the gradient of the input variable similar to the implicit differentiation by perturbation form (Domke 2010). (Berthet et al. 2020) is another approach that uses also perturbation and change of variables to estimate the gradient in a ILP problem. SatNet (Wang et al. 2019) solves MAXSAT problems by solving a continuous semidefinite program (SDP) relaxation of the original problem. These works only consider single-level problems.
+
+Discrete latent variables Discrete random variables provide an effective way to model multi-modal distributions over discrete values, which can be used in various machine learning problems, e.g. in language models (Yang et al. 2017) or for conditional computation (Bengio, Léonard, and Courville 2013). Gradients of discrete distribution are not mathematical defined, thus, in order to use gradient based method, gradient estimations have been proposed. A class of methods is based on Gumbel-Softmax estimator (Jang, Gu, and Poole 2016; Maddison, Mnih, and Teh 2016; Paulus, Maddison, and Krause 2021).
+
+## 5 Experiments
+
+We evaluate BiGrad with continuous and combinatorial problems to shows that improves over single-level approaches. In the first experiment we compare the use of Bi-Grad versus the use of the implicit layer proposed in (Amos and Kolter 2017) for the design of Optimal Control with adversarial noise. In the second part, after experimenting with adversarial attack, we explore the performance of BiGrad with two combinatorial problems with Interdiction, where we adapted the experimental setup proposed in (Pogančić et al. 2019). In these latter experiments, we compare the formulation in Eq.11 (denoted by Bigrad(BB)) and the formulation of Eq.12 (denoted by Bigrad(PT)). In addition we compare with the single level BB-1 from (Pogančić et al. 2019) and single level straight-through (Bengio, Léonard, and Courville 2013; Paulus, Maddison, and Krause 2021), with the surrogate gradient ${\nabla }_{z}x = - I$ ,(PT-1) gradient estimations. We compare against Supervised learning (SL), which ignores the underlay structure of the problem and directly predicts the solution of the bilevel problem.
+
+Table 1: Optimal Control Average Cost; Bilevel approach improves (lower cost) over two-step approach, because is able to better capture the interaction between noise and control dynamics.
+
+| ${\mathcal{D}}_{\text{in }}^{\text{test }}$ | $\mathbf{{Method}}$ | $\mathbf{{FPR}}$ (95% TPR) ↓ | Detection Error ↓ | AUROC ↑ | $\mathbf{{FPR}}$ (95% TPR) ↓ | Detection Error ↓ | AUROC ↑ |
| without attack | with attack $(\epsilon = 1/{255}, m = {10}$ |
| GTSRB | MSP (Hendrycks and Gimpel 2016) | 1.13 | 2.42 | 98.45 | 97.59 | 26.02 | 73.27 |
| ODIN (Liang, Li, and Srikant 2017) | 1.42 | 2.10 | 98.81 | 75.94 | 24.87 | 75.41 |
| Mahalanobis (Lee et al. 2018) | 1.31 | 2.87 | 98.29 | 100.00 | 29.80 | 70.45 |
| OE (Hendrycks, Mazeika, and Dietterich 2018) | 0.02 | 0.34 | 99.92 | 25.85 | 5.90 | 96.09 |
| OE+ODIN | 0.02 | 0.36 | 99.92 | 14.14 | 5.59 | 97.18 |
| ADV (Madry et al. 2017) | 1.45 | 2.88 | 98.66 | 17.96 | 6.95 | 94.83 |
| AOE | 0.00 | 0.62 | 99.86 | 1.49 | 2.55 | 98.35 |
| ALOE (ours) | 0.00 | 0.44 | 99.76 | 0.66 | 1.80 | 98.95 |
| ALOE+ODIN (ours) | 0.01 | 0.45 | 99.76 | 0.69 | 1.80 | 98.98 |
| CIFAR- 10 | MSP (Hendrycks and Gimpel 2016) | 51.67 | 14.06 | 91.61 | 99.98 | 50.00 | 10.34 |
| ODIN (Liang, Li, and Srikant 2017) | 25.76 | 11.51 | 93.92 | 93.45 | 46.73 | 28.45 |
| Mahalanobis (Lee et al. 2018) | 31.01 | 15.72 | 88.53 | 89.75 | 44.30 | 32.54 |
| OE (Hendrycks, Mazeika, and Dietterich 2018) | 4.47 | 4.50 | 98.54 | 99.99 | 50.00 | 25.13 |
| OE+ODIN | 4.17 | 4.31 | 98.55 | 99.02 | 47.84 | 34.29 |
| ADV (Madry et al. 2017) | 66.99 | 19.22 | 87.23 | 98.44 | 31.72 | 66.73 |
| AOE | 10.46 | 6.58 | 97.76 | 88.91 | 26.02 | 78.39 |
| ALOE (ours) | 5.47 | 5.13 | 98.34 | 53.99 | 14.19 | 91.26 |
| ALOE+ODIN (ours) | 4.48 | 4.66 | 98.55 | 41.59 | 12.73 | 92.69 |
| CIFAR- 100 | MSP (Hendrycks and Gimpel 2016) | 81.72 | 33.46 | 71.89 | 100.00 | 50.00 | 2.39 |
| ODIN (Liang, Li, and Srikant 2017) | 58.84 | 22.94 | 83.63 | 98.87 | 49.87 | 21.02 |
| Mahalanobis (Lee et al. 2018) | 53.75 | 27.63 | 70.85 | 95.79 | 47.53 | 17.92 |
| OE (Hendrycks, Mazeika, and Dietterich 2018) | 56.49 | 19.38 | 87.73 | 100.00 | 50.00 | 2.94 |
| OE+ODIN | 47.59 | 17.39 | 90.14 | 99.49 | 50.00 | 20.02 |
| ADV (Madry et al. 2017) | 85.47 | 33.17 | 71.77 | 99.64 | 44.86 | 41.34 |
| AOE | 60.00 | 23.03 | 84.57 | 95.79 | 43.07 | 53.80 |
| ALOE (ours) | 61.99 | 23.56 | 83.72 | 92.01 | 40.09 | 61.20 |
| ALOE+ODIN (ours) | 58.48 | 21.38 | 85.75 | 88.50 | 36.20 | 66.61 |
+
+Table 1: Distinguishing in- and out-of-distribution test set data for image classification. We contrast performance on clean images (without attack) and PGD attacked images. $\uparrow$ indicates larger value is better, and $\downarrow$ indicates lower value is better. All values are percentages and are averaged over six OOD test datasets.
+
+| ${\mathcal{D}}_{\text{in }}^{\text{test }}$ | $\mathbf{{Method}}$ | $\mathbf{{FPR}}$ (95% TPR) ↓ | Detection Error ↓ | AUROC ↑ | $\mathbf{{FPR}}$ (95% TPR) ↓ | Detection Error ↓ | AUROC ↑ | $\mathbf{{FPR}}$ (95% TPR) ↓ | Detection Error ↓ | AUROC ↑ |
| with attack $\left( {\epsilon = 2/{255}, m = {10}}\right)$ | with attack $\left( {\epsilon = 3/{255}, m = {10}}\right)$ | with attack $\left( {\epsilon = 4/{255}, m = {10}}\right)$ |
| GTSRB | MSP (Hendrycks and Gimpel 2016) | 99.88 | 50.00 | 26.11 | 99.99 | 50.00 | 6.79 | 99.99 | 50.00 | 6.39 |
| ODIN (Liang, Li, and Srikant 2017) | 99.23 | 49.97 | 27.38 | 99.83 | 50.00 | 6.94 | 99.84 | 50.00 | 6.52 |
| Mahalanobis (Lee et al. 2018) | 100.00 | 49.97 | 26.37 | 100.00 | 50.00 | 8.27 | 100.00 | 50.00 | 7.82 |
| OE (Hendrycks, Mazeika, and Dietterich 2018) | 96.79 | 16.09 | 83.06 | 99.91 | 25.36 | 68.62 | 99.97 | 26.37 | 66.91 |
| OE+ODIN | 89.88 | 15.78 | 84.56 | 99.25 | 24.70 | 69.71 | 99.45 | 25.67 | 68.02 |
| ADV (Madry et al. 2017) | 92.17 | 11.51 | 89.92 | 99.65 | 18.59 | 80.85 | 99.49 | 18.68 | 81.17 |
| AOE | 7.94 | 5.36 | 94.82 | 16.16 | 10.38 | 88.72 | 38.05 | 17.95 | 83.84 |
| ALOE (ours) | 4.03 | 4.19 | 95.90 | 10.82 | 7.64 | 91.21 | 16.10 | 10.10 | 89.52 |
| ALOE+ODIN (ours) | 3.95 | 4.15 | 95.72 | 9.56 | 6.91 | 91.08 | 13.85 | 9.22 | 89.44 |
| CIFAR- 10 | MSP (Hendrycks and Gimpel 2016) | 100.00 | 50.00 | 1.16 | 100.00 | 50.00 | 0.13 | 100.00 | 50.00 | 0.12 |
| ODIN (Liang, Li, and Srikant 2017) | 99.73 | 49.99 | 5.67 | 99.98 | 50.00 | 1.14 | 99.99 | 50.00 | 1.06 |
| Mahalanobis (Lee et al. 2018) | 100.00 | 50.00 | 5.90 | 100.00 | 50.00 | 1.27 | 100.00 | 50.00 | 1.05 |
| OE (Hendrycks, Mazeika, and Dietterich 2018) | 100.00 | 50.00 | 5.99 | 100.00 | 50.00 | 1.52 | 100.00 | 50.00 | 1.48 |
| OE+ODIN | 100.00 | 50.00 | 8.89 | 100.00 | 50.00 | 2.76 | 100.00 | 50.00 | 2.69 |
| ADV (Madry et al. 2017) | 99.94 | 36.57 | 56.01 | 99.89 | 39.64 | 49.88 | 99.96 | 40.57 | 48.02 |
| AOE | 91.79 | 35.08 | 66.92 | 99.96 | 39.53 | 54.43 | 98.40 | 37.37 | 59.16 |
| ALOE (ours) | 75.90 | 23.36 | 83.26 | 83.14 | 31.54 | 73.46 | 82.53 | 29.92 | 75.52 |
| ALOE+ODIN (ours) | 68.80 | 20.31 | 85.92 | 79.19 | 28.04 | 77.88 | 78.46 | 27.55 | 78.83 |
+
+Table 3: Distinguishing in- and out-of-distribution test set data for image classification. $\uparrow$ indicates larger value is better, and $\downarrow$ indicates lower value is better. All values are percentages. The in-distribution datasets are GRSRB and CIFAR-10. All the values reported are averaged over six OOD test datasets.
+
+| Setting | Reference | Iteration Com- plexity |
| ${\mu }_{\mathbf{x}}$ -Strongly-Convex- ${\mu }_{y}$ -Strongly-Concave | (Tseng 1995) | $\widetilde{O}\left( {{\mu }_{\mathbf{x}} + {\mu }_{\mathbf{y}}}\right)$ |
| (Yurii Nesterov 2011) |
| (Gidel et al. 2020) |
| (Mokhtari, Ozdaglar, and Pattathil 2020) |
| (Alkousa et al. 2020) | $O(\min \left\{ {{\mu }_{\mathbf{x}}\sqrt{{\mu }_{\mathbf{y}}},}\right.$ $\left. \left. {{\mu }_{\mathbf{y}}\sqrt{{\mu }_{\mathbf{x}}}}\right\rbrack \right) \}$ |
| (Lin, Jin, and Jor- dan 2020b) | $\widetilde{O}\left( \sqrt{{\mu }_{\mathbf{x}}{\mu }_{\mathbf{y}}}\right)$ |
| (Ibrahim et al. 2019) | $\widetilde{\Omega }\left( \sqrt{{\mu }_{\mathbf{x}}{\mu }_{\mathbf{y}}}\right)$ |
| (Zhang, Hong, and Zhang 2020) |
| ${\mu }_{\mathbf{x}}$ -Strongly-Convex -Linear | (Juditsky, Ne- mirovski et al. 2011) | $O\left( \sqrt{{\mu }_{x}/\varepsilon }\right)$ |
| (Hamedani and Aybat 2018) |
| (Zhao 2019) |
| ${\mu }_{\mathbf{x}}$ -Strongly-Convex -Concave | (Thekumparampil et al. 2019) | $\widetilde{O}\left( {{\mu }_{x}/\sqrt{\varepsilon }}\right)$ |
| (Lin, Jin, and Jor- dan 2020b) | $\widetilde{O}\left( \sqrt{{\mu }_{x}/\varepsilon }\right)$ |
| (Ouyang and Xu 2018) | $\widetilde{\Omega }\left( \sqrt{{\mu }_{x}/\varepsilon }\right)$ |
| Convex -Concave | (Nemirovski 2004) | $O\left( {\varepsilon }^{-1}\right)$ |
| (Nesterov 2007) |
| (Tseng 2008) |
| (Lin, Jin, and Jor- dan 2020b) | $\widetilde{O}\left( {\varepsilon }^{-1}\right)$ |
| (Ouyang and Xu 2018) | $\Omega \left( {\varepsilon }^{-1}\right)$ |
+
+Table 2: Iteration complexities for min-max games with independent strategy sets in non-convex-concave settings. Note that although all these results assume that the objective function is Lipschitz-smooth, some authors make additional assumptions: e.g., (Nouiehed et al. 2019) obtain their result for objective functions that satisfy the Lojasiwicz condition.
+
+| Setting | Reference | Iteration Complexity |
| Nonconvex- ${\mu }_{{\mathbf{y}}^{ - }}$ Strongly-Concave, First Order Nash or Local Stackelberg Equilibrium | (Jin, Netrapalli, and Jor- dan 2020) (Rafique et al. 2019) | $\widetilde{O}\left( {{\mu }_{\mathbf{y}}^{2}{\varepsilon }^{-2}}\right)$ |
| (Lin, Jin, and Jordan 2020a) |
| (Lu, Tsaknakis, and Hong 2019) |
| (Lin, Jin, and Jordan 2020b) | $\widetilde{O}\left( {\sqrt{{\mu }_{\mathbf{y}}}{\varepsilon }^{-2}}\right)$ |
| Nonconvex- Concave, First Order Nash Equilibrium | (Lu, Tsaknakis, and Hong 2019) | $\widetilde{O}\left( {\varepsilon }^{-4}\right)$ |
| (Nouiehed et al. 2019) | $\widetilde{O}\left( {\varepsilon }^{-{3.5}}\right)$ |
| (Ostrovskii, Lowy, and Razaviyayn 2020) | $\widetilde{O}\left( {\varepsilon }^{-{2.5}}\right)$ |
| (Lin, Jin, and Jordan 2020b) |
| Nonconvex- Concave, Local Stackelberg Equilibrium | (Jin, Netrapalli, and Jor- dan 2020) | $\widetilde{O}\left( {\varepsilon }^{-6}\right)$ |
| (Nouiehed et al. 2019) |
| (Lin, Jin, and Jordan 2020b) |
| (Thekumparampil et al. 2019) | $\widetilde{O}\left( {\varepsilon }^{-3}\right)$ |
| (Zhao 2020) (Lin, Jin, and Jordan 2020b) |
+
+## C Omitted Proofs
+
+Proof of Theorem 3. Since pessimistic regret is bounded by $\varepsilon$ after $T$ iterations, it holds that:
+
+$$
+\mathop{\max }\limits_{{\mathbf{x} \in X}}{\operatorname{PesRegret}}_{X}^{\left( T\right) }\left( \mathbf{x}\right) \leq \varepsilon \tag{11}
+$$
+
+$$
+\frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}{V}_{X}^{\left( t\right) }\left( {\mathbf{x}}^{\left( t\right) }\right) - \mathop{\min }\limits_{{\mathbf{x} \in X}}\mathop{\sum }\limits_{{t = 1}}^{T}\frac{1}{T}{V}_{X}^{\left( t\right) }\left( \mathbf{x}\right) \leq \varepsilon \tag{12}
+$$
+
+Since the game is static, and it further holds that:
+
+$$
+\frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}{V}_{X}\left( {\mathbf{x}}^{\left( t\right) }\right) - \mathop{\min }\limits_{{\mathbf{x} \in X}}\mathop{\sum }\limits_{{t = 1}}^{T}\frac{1}{T}{V}_{X}\left( \mathbf{x}\right) \leq \varepsilon \tag{13}
+$$
+
+$$
+\frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}{V}_{X}\left( {\mathbf{x}}^{\left( t\right) }\right) - \mathop{\min }\limits_{{\mathbf{x} \in X}}{V}_{X}\left( \mathbf{x}\right) \leq \varepsilon \tag{14}
+$$
+
+Thus, by the convexity of ${V}_{X}$ (see Proposition 2), ${V}_{X}\left( {\overline{\mathbf{x}}}^{\left( T\right) }\right) - \mathop{\min }\limits_{{\mathbf{x} \in X}}{V}_{X}\left( \mathbf{x}\right) \leq \varepsilon$ . Now replacing ${V}_{X}$ by its definition, and setting ${\mathbf{y}}^{ * }\left( {\overline{\mathbf{x}}}^{\left( T\right) }\right) \in {\mathrm{{BR}}}_{Y}\left( {\overline{\mathbf{x}}}^{\left( T\right) }\right)$ , we obtain that $\left( {{\overline{\mathbf{x}}}^{\left( T\right) },{\mathbf{y}}^{ * }\left( {\overline{\mathbf{x}}}^{\left( T\right) }\right) }\right)$ is $\left( {\varepsilon ,0}\right)$ -Stackelberg equilibrium:
+
+$$
+{V}_{X}\left( {\overline{\mathbf{x}}}^{\left( T\right) }\right) \leq f\left( {{\overline{\mathbf{x}}}^{\left( T\right) },{\mathbf{y}}^{ * }\left( {\overline{\mathbf{x}}}^{\left( T\right) }\right) }\right) \leq \mathop{\min }\limits_{{\mathbf{x} \in X}}{V}_{X}\left( \mathbf{x}\right) + \varepsilon
+$$
+
+(15)
+
+$$
+\mathop{\max }\limits_{{\mathbf{y} \in Y : \mathbf{g}\left( {{\overline{\mathbf{x}}}^{\left( T\right) },\mathbf{y}}\right) }}f\left( {{\overline{\mathbf{x}}}^{\left( T\right) },\mathbf{y}}\right) \leq f\left( {{\overline{\mathbf{x}}}^{\left( T\right) },{\mathbf{y}}^{ * }\left( {\overline{\mathbf{x}}}^{\left( T\right) }\right) }\right) \leq \mathop{\min }\limits_{{\mathbf{x} \in X}}\mathop{\max }\limits_{{\mathbf{y} \in Y : \mathbf{g}\left( {\mathbf{x},\mathbf{y}}\right) }}f\left( {\mathbf{x},\mathbf{y}}\right)
+$$
+
+$$
++ \varepsilon \tag{16}
+$$
+
+Proof of Lemma 5. We can relax the inner player's payoff maximization problem via the problem's Lagrangian and since by assumption 1 , Slater's condition is satisfied, strong duality holds, giving us for all $\mathbf{x} \in X$ :
+
+$\mathop{\max }\limits_{{\mathbf{y} \in Y : \mathbf{g}\left( {\mathbf{x},\mathbf{y}}\right) \geq \mathbf{0}}}f\left( {\mathbf{x},\mathbf{y}}\right) = \mathop{\max }\limits_{{\mathbf{y} \in Y}}\mathop{\min }\limits_{{\mathbf{\lambda } \geq \mathbf{0}}}{\mathcal{L}}_{\mathbf{x}}\left( {\mathbf{y},\mathbf{\lambda }}\right)$ $= \mathop{\min }\limits_{{\mathbf{\lambda } > \mathbf{0}}}\mathop{\max }\limits_{{\mathbf{y} \in Y}}{\mathcal{L}}_{\mathbf{x}}\left( {\mathbf{y},\mathbf{\lambda }}\right)$ . We can then re-express the min-max game as: $\mathop{\min }\limits_{{\mathbf{x} \in X}}\mathop{\max }\limits_{{\mathbf{y} \in Y : \mathbf{g}\left( {\mathbf{x},\mathbf{y}}\right) \geq \mathbf{0}}}f\left( {\mathbf{x},\mathbf{y}}\right) =$ $\mathop{\min }\limits_{{\mathbf{\lambda } \geq \mathbf{0}}}\mathop{\min }\limits_{{\mathbf{x} \in X}}\mathop{\max }\limits_{{\mathbf{y} \in Y}}$
+
+${\mathcal{L}}_{\mathbf{x}}\left( {\mathbf{y},\mathbf{\lambda }}\right)$ . Letting ${\mathbf{\lambda }}^{ * }\; \in$
+
+$\arg \mathop{\min }\limits_{{\mathbf{\lambda } \geq \mathbf{0}}}\mathop{\min }\limits_{{\mathbf{x} \in X}}\mathop{\max }\limits_{{\mathbf{y} \in Y}}{\mathcal{L}}_{\mathbf{x}}\left( {\mathbf{y},\mathbf{\lambda }}\right)$ , we have $\mathop{\min }\limits_{{\mathbf{x} \in X}}$ $\mathop{\max }\limits_{{\mathbf{y} \in Y : \mathbf{g}\left( {\mathbf{x},\mathbf{y}}\right) \geq \mathbf{0}}}f\left( {\mathbf{x},\mathbf{y}}\right) = \mathop{\min }\limits_{{\mathbf{x} \in X}}\mathop{\max }\limits_{{\mathbf{y} \in Y}}{\mathcal{L}}_{\mathbf{x}}\left( {\mathbf{y},{\mathbf{\lambda }}^{ * }}\right) .$ Note that ${\mathcal{L}}_{\mathbf{x}}\left( {\mathbf{y},{\mathbf{\lambda }}^{ * }}\right)$ is convex-concave in(x, y). Hence, any Stackelberg equilibrium $\left( {{\mathbf{x}}^{ * },{\mathbf{y}}^{ * }}\right) \in X \times Y$ of (X, Y, f, g)is a saddle point of ${\mathcal{L}}_{\mathbf{x}}\left( {\mathbf{y},{\mathbf{\lambda }}^{ * }}\right)$ , i.e., $\forall \mathbf{x} \in$ $X,\mathbf{y} \in \widehat{Y},{\mathcal{L}}_{{\mathbf{x}}^{ * }}\left( {\mathbf{y},{\mathbf{\lambda }}^{ * }}\right) \leq {\mathcal{L}}_{{\mathbf{x}}^{ * }}\left( {{\mathbf{y}}^{ * },{\mathbf{\lambda }}^{ * }}\right) \leq {\mathcal{L}}_{\mathbf{x}}\left( {{\mathbf{y}}^{ * },{\mathbf{\lambda }}^{ * }}\right) .$
+
+Proof of Theorem 6. Since the Lagrangian regret is bounded for both players we have:
+
+$$
+\left\{ \begin{array}{l} \mathop{\max }\limits_{{\mathbf{x} \in X}}{\operatorname{LagrRegret}}_{X}^{\left( T\right) }\left( \mathbf{x}\right) \leq \varepsilon \\ \mathop{\max }\limits_{{\mathbf{y} \in Y}}{\operatorname{LagrRegret}}_{Y}^{\left( T\right) }\left( \mathbf{y}\right) \leq \varepsilon \end{array}\right. \tag{17}
+$$
+
+$$
+\left\{ \begin{array}{l} \frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}{\mathcal{L}}_{{\mathbf{x}}^{\left( t\right) }}^{\left( t\right) }\left( {{\mathbf{y}}^{\left( t\right) },{\mathbf{\lambda }}^{ * }}\right) - \mathop{\min }\limits_{{\mathbf{x} \in X}}\frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}{\mathcal{L}}_{\mathbf{x}}^{\left( t\right) }\left( {{\mathbf{y}}^{\left( t\right) },{\mathbf{\lambda }}^{ * }}\right) \leq \varepsilon \\ \mathop{\max }\limits_{{\mathbf{y} \in Y}}\frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}{\mathcal{L}}_{{\mathbf{x}}^{\left( t\right) }}^{\left( t\right) }\left( {\mathbf{y},{\mathbf{\lambda }}^{ * }}\right) - \frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}{\mathcal{L}}_{{\mathbf{x}}^{\left( t\right) }}^{\left( t\right) }\left( {{\mathbf{y}}^{\left( t\right) },{\mathbf{\lambda }}^{ * }}\right) \leq \varepsilon \end{array}\right.
+$$
+
+(18)
+
+$$
+\left\{ \begin{array}{l} \frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}{\mathcal{L}}_{{\mathbf{x}}^{\left( t\right) }}\left( {{\mathbf{y}}^{\left( t\right) },{\mathbf{\lambda }}^{ * }}\right) - \mathop{\min }\limits_{{\mathbf{x} \in X}}\frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}{\mathcal{L}}_{\mathbf{x}}\left( {{\mathbf{y}}^{\left( t\right) },{\mathbf{\lambda }}^{ * }}\right) \leq \varepsilon \\ \mathop{\max }\limits_{{\mathbf{y} \in Y}}\frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}{\mathcal{L}}_{{\mathbf{x}}^{\left( t\right) }}\left( {\mathbf{y},{\mathbf{\lambda }}^{ * }}\right) - \frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}{\mathcal{L}}_{{\mathbf{x}}^{\left( t\right) }}\left( {{\mathbf{y}}^{\left( t\right) },{\mathbf{\lambda }}^{ * }}\right) \leq \varepsilon \end{array}\right.
+$$
+
+(19)The last line follows because the min-max Stackelberg game is static.
+
+Summing the final two inequalities yields:
+
+$$
+\mathop{\max }\limits_{{\mathbf{y} \in Y}}\frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}{\mathcal{L}}_{{\mathbf{x}}^{\left( t\right) }}\left( {\mathbf{y},{\mathbf{\lambda }}^{ * }}\right) - \mathop{\min }\limits_{{\mathbf{x} \in X}}\frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}{\mathcal{L}}_{\mathbf{x}}\left( {{\mathbf{y}}^{\left( t\right) },{\mathbf{\lambda }}^{ * }}\right) \leq {2\varepsilon }
+$$
+
+(20)
+
+$$
+\frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}\mathop{\max }\limits_{{\mathbf{y} \in Y}}{\mathcal{L}}_{{\mathbf{x}}^{\left( t\right) }}\left( {\mathbf{y},{\mathbf{\lambda }}^{ * }}\right) - \frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}\mathop{\min }\limits_{{\mathbf{x} \in X}}{\mathcal{L}}_{\mathbf{x}}\left( {{\mathbf{y}}^{\left( t\right) },{\mathbf{\lambda }}^{ * }}\right) \leq {2\varepsilon }
+$$
+
+(21)
+
+where the second inequality was obtained by an application of Jensen's inequality on the first and second terms.
+
+Since $\mathcal{L}$ is convex in $\mathbf{x}$ and concave in $\mathbf{y}$ , we have that $\mathop{\max }\limits_{{\mathbf{y} \in Y}}\mathbf{y}$
+
+${\mathcal{L}}_{{\mathbf{x}}^{\left( t\right) }}\left( {\mathbf{y},{\mathbf{\lambda }}^{ * }}\right)$ is convex in $\mathbf{x}$ and $\mathop{\min }\limits_{{\mathbf{x} \in X}}{\mathcal{L}}_{\mathbf{x}}\left( {{\mathbf{y}}^{\left( t\right) },{\mathbf{\lambda }}^{ * }}\right)$ is convex in $\mathbf{y}$ , which implies that $\mathop{\max }\limits_{{\mathbf{y} \in Y}}{\mathcal{L}}_{{\bar{\mathbf{x}}}^{\left( T\right) }}\left( {\mathbf{y},{\mathbf{\lambda }}^{ * }}\right) -$ $\mathop{\min }\limits_{{\mathbf{x} \in X}}{\mathcal{L}}_{\mathbf{x}}\left( {{\overline{\mathbf{y}}}^{\left( T\right) },{\mathbf{\lambda }}^{ * }}\right) \leq {2\varepsilon }$ . By the max-min inequality ((Boyd, Boyd, and Vandenberghe 2004), Equation 5.46), it also holds that $\mathop{\min }\limits_{{\mathbf{x} \in X}}{\mathcal{L}}_{\mathbf{x}}\left( {{\overline{\mathbf{y}}}^{\left( T\right) },{\mathbf{\lambda }}^{ * }}\right) \leq$ $\mathop{\max }\limits_{{\mathbf{y} \in Y}}{\mathcal{L}}_{{\bar{\mathbf{x}}}^{\left( T\right) }}\left( {\mathbf{y},{\mathbf{\lambda }}^{ * }}\right)$ . Combining these two inequality yields the desired result.
+
+Proof of Theorem 10. The value function of the outer player in the game ${\left\{ \left( X, Y,{f}^{\left( t\right) }\right) \right\} }_{t = 1}^{T}$ at iteration $t \in \left\lbrack T\right\rbrack$ , is given by ${V}^{\left( t\right) }\left( \mathbf{x}\right) = \mathop{\max }\limits_{{\mathbf{y} \in Y}}{f}^{\left( t\right) }\left( {\mathbf{x},\mathbf{y}}\right)$ . Hence, for all $t \in \left\lbrack T\right\rbrack$ , as ${f}^{\left( t\right) }$ is $\mu$ -strongly-convex, ${V}^{\left( t\right) }$ is also strongly concave since the maximum preserves strong-convexity.
+
+Additionally, since for all $t \in \left\lbrack T\right\rbrack ,{f}^{\left( t\right) }$ is strictly concave in $\mathbf{y}$ , by Danskin’s theorem (Danskin 1966), for all $t \in \left\lbrack T\right\rbrack ,{V}^{\left( t\right) }$ is differentiable and its derivative is given by ${\nabla }_{\mathbf{x}}{V}^{\left( t\right) }\left( \mathbf{x}\right) = {\nabla }_{\mathbf{x}}f\left( {\mathbf{x},{\mathbf{y}}^{ * }\left( \mathbf{x}\right) }\right)$ where ${\mathbf{y}}^{ * }\left( \mathbf{x}\right) \in \mathop{\max }\limits_{{\mathbf{y} \in Y}}{f}^{\left( t\right) }\left( {\mathbf{x},\mathbf{y}}\right)$ . Thus, as ${\nabla }_{\mathbf{x}}f\left( {\mathbf{x},{\mathbf{y}}^{ * }\left( \mathbf{x}\right) }\right)$ is ${\ell }_{\nabla f}$ -lipschitz continuous, so is ${\nabla }_{\mathbf{x}}{V}^{\left( t\right) }\left( \mathbf{x}\right)$ . The result follows from Cheung, Hoefer, and Nakhe's bound for gradient descent on shifting strongly convex functions ((Cheung, Hoefer, and Nakhe 2019), Proposition 12).
+
+Proof of Theorem 11. By the assumptions of the theorem, the loss functions of the outer player ${\left\{ {f}^{\left( t\right) }\left( \cdot ,{\mathbf{y}}^{\left( t\right) }\right) \right\} }_{t = 1}^{T}$ are ${\mu }_{\mathbf{x}}$ -strongly-convex and ${\ell }_{\nabla f}$ -Lipschitz continuous functions. Similarly the loss functions of the inner player ${\left\{ -{f}^{\left( t\right) }\left( {\mathbf{x}}^{\left( t\right) }, \cdot \right) \right\} }_{t = 1}^{T}$ are ${\mu }_{\mathbf{y}}$ -strongly-convex and ${\ell }_{\nabla f}$ - Lipschitz continuous functions. Using Cheung, Hoefer, and Nakhe's Proposition 12 (Cheung, Hoefer, and Nakhe 2019), we then obtain the following bounds:
+
+$$
+\begin{Vmatrix}{{\mathbf{x}}^{{\left( T\right) }^{ * }} - {\mathbf{x}}^{\left( T\right) }}\end{Vmatrix} \leq {\left( 1 - {\delta }_{\mathbf{x}}\right) }^{T/2}\begin{Vmatrix}{{\mathbf{x}}^{{\left( 0\right) }^{ * }} - {\mathbf{x}}^{\left( 0\right) }}\end{Vmatrix}
+$$
+
+$$
++ \mathop{\sum }\limits_{{t = 1}}^{T}{\left( 1 - {\delta }_{\mathbf{x}}\right) }^{\frac{T - t}{2}}{\Delta }_{\mathbf{x}}^{\left( t\right) } \tag{22}
+$$
+
+$$
+\begin{Vmatrix}{{\mathbf{y}}^{{\left( T\right) }^{ * }} - {\mathbf{y}}^{\left( T\right) }}\end{Vmatrix} \leq {\left( 1 - {\delta }_{\mathbf{y}}\right) }^{T/2}\begin{Vmatrix}{{\mathbf{y}}^{{\left( 0\right) }^{ * }} - {\mathbf{y}}^{\left( 0\right) }}\end{Vmatrix}
+$$
+
+$$
++ \mathop{\sum }\limits_{{t = 1}}^{T}{\left( 1 - {\delta }_{\mathbf{y}}\right) }^{\frac{T - t}{2}}{\Delta }_{\mathbf{y}}^{\left( t\right) } \tag{23}
+$$
+
+Combining the two inequalities, we obtain:
+
+$$
+\begin{Vmatrix}{{\mathbf{x}}^{{\left( T\right) }^{ * }} - {\mathbf{x}}^{\left( T\right) }}\end{Vmatrix} + \begin{Vmatrix}{{\mathbf{y}}^{{\left( T\right) }^{ * }} - {\mathbf{y}}^{\left( T\right) }}\end{Vmatrix}
+$$
+
+$$
+\leq {\left( 1 - {\delta }_{\mathbf{x}}\right) }^{T/2}\begin{Vmatrix}{{\mathbf{x}}^{{\left( 0\right) }^{ * }} - {\mathbf{x}}^{\left( 0\right) }}\end{Vmatrix} + {\left( 1 - {\delta }_{\mathbf{y}}\right) }^{T/2}\begin{Vmatrix}{{\mathbf{y}}^{{\left( 0\right) }^{ * }} - {\mathbf{y}}^{\left( 0\right) }}\end{Vmatrix}
+$$
+
+$$
++ \mathop{\sum }\limits_{{t = 1}}^{T}{\left( 1 - {\delta }_{\mathbf{x}}\right) }^{\frac{T - t}{2}}{\Delta }_{\mathbf{x}}^{\left( t\right) } + \mathop{\sum }\limits_{{t = 1}}^{T}{\left( 1 - {\delta }_{\mathbf{y}}\right) }^{\frac{T - t}{2}}{\Delta }_{\mathbf{y}}^{\left( t\right) } \tag{24}
+$$
+
+The second part of the theorem follows by taking the sum of the geometric series.
+
+## D Pseudo-Code for Algorithms
+
+Algorithm 1: Max-Oracle Gradient Descent
+
+---
+
+Inputs: $X, Y, f,\mathbf{g},\mathbf{\eta }, T,{\mathbf{x}}^{\left( 0\right) }$
+
+Output: $\left( {{\mathbf{x}}^{ * },{\mathbf{y}}^{ * }}\right)$
+
+ for $t = 1,\ldots , T$ do
+
+ Find ${\mathbf{y}}^{ * }\left( {\mathbf{x}}^{\left( t - 1\right) }\right) \in {\mathrm{{BR}}}_{Y}\left( {\mathbf{x}}^{\left( t - 1\right) }\right)$
+
+ Set ${\mathbf{y}}^{\left( t - 1\right) } = {\mathbf{y}}^{ * }\left( {\mathbf{x}}^{\left( t - 1\right) }\right)$
+
+ Set ${\mathbf{\lambda }}^{\left( t - 1\right) } = {\mathbf{\lambda }}^{ * }\left( {{\mathbf{x}}^{\left( t - 1\right) },{\mathbf{y}}^{\left( t - 1\right) }}\right)$
+
+ Set ${\mathbf{x}}^{\left( t\right) } = {\Pi }_{X}\left\lbrack {{\mathbf{x}}^{\left( t - 1\right) } - {\eta }_{t}{\nabla }_{\mathbf{x}}{\mathcal{L}}_{{\mathbf{x}}^{\left( t - 1\right) }}\left( {{\mathbf{y}}^{\left( t - 1\right) },{\mathbf{\lambda }}^{\left( t - 1\right) }}\right) }\right\rbrack$
+
+ end for
+
+ Set ${\bar{\mathbf{x}}}^{\left( T\right) } = \frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}{\mathbf{x}}^{\left( t\right) }$
+
+ Set ${\mathbf{y}}^{ * }\left( {\overline{\mathbf{x}}}^{\left( T\right) }\right) \in {\mathrm{{BR}}}_{Y}\left( {\overline{\mathbf{x}}}^{\left( T\right) }\right)$
+
+ return $\left( {{\overline{\mathbf{x}}}^{\left( T\right) },{\mathbf{y}}^{ * }\left( {\overline{\mathbf{x}}}^{\left( T\right) }\right) }\right)$
+
+---
+
+Algorithm 2: Lagrangian Gradient Descent Ascent (LGDA)
+
+---
+
+Inputs: ${\mathbf{\lambda }}^{ * }, X, Y, f,\mathbf{g},{\mathbf{\eta }}^{\mathbf{x}},{\mathbf{\eta }}^{\mathbf{y}}, T,{\mathbf{x}}^{\left( 0\right) },{\mathbf{y}}^{\left( 0\right) }$
+
+Output: ${\mathbf{x}}^{ * },{\mathbf{y}}^{ * }$
+
+ for $t = 1,\ldots , T - 1$ do
+
+ Set ${\mathbf{x}}^{\left( t + 1\right) } = {\Pi }_{X}\left( {{\mathbf{x}}^{\left( t\right) } - {\eta }_{t}^{\mathbf{x}}{\nabla }_{\mathbf{x}}{\mathcal{L}}_{{\mathbf{x}}^{\left( t\right) }}\left( {{\mathbf{y}}^{\left( t\right) },{\mathbf{\lambda }}^{ * }}\right) }\right)$
+
+ Set ${\mathbf{y}}^{\left( t + 1\right) } = {\Pi }_{Y}\left( {{\mathbf{y}}^{\left( t\right) } + {\eta }_{t}^{\mathbf{y}}{\nabla }_{\mathbf{y}}{\mathcal{L}}_{{\mathbf{x}}^{\left( t\right) }}\left( {{\mathbf{y}}^{\left( t\right) },{\mathbf{\lambda }}^{ * }}\right) }\right)$
+
+ end for
+
+ return ${\left\{ \left( {\mathbf{x}}^{\left( t\right) },{\mathbf{y}}^{\left( t\right) }\right) \right\} }_{t = 1}^{T}$
+
+---
+
+Algorithm 3: Dynamic tâtonnement
+
+---
+
+Inputs: $T,{\left\{ \left( {U}^{\left( t\right) },{\mathbf{b}}^{\left( t\right) },{\mathbf{s}}^{\left( t\right) }\right) \right\} }_{t = 1}^{T},\mathbf{\eta },{\mathbf{p}}^{\left( 0\right) },\delta$
+
+Output: ${\mathbf{x}}^{ \star },{\mathbf{y}}^{ \star }$
+
+ for $t = 1,\ldots , T - 1$ do
+
+ For all $i \in \left\lbrack n\right\rbrack$ , find ${\mathbf{x}}_{i}^{\left( t\right) } \in$
+
+ ${\operatorname{argmax}}_{{\mathbf{x}}_{i} \in {\mathbb{R}}_{ + }^{m} : {\mathbf{x}}_{i} \cdot {\mathbf{p}}^{\left( t - 1\right) } \leq {b}_{i}^{\left( t\right) }}{u}_{i}\left( {\mathbf{x}}_{i}\right)$
+
+ Set ${\mathbf{p}}^{\left( t\right) } = {\Pi }_{{\mathbb{R}}_{ + }^{m}}\left( {{\mathbf{p}}^{\left( t - 1\right) } - {\eta }_{t}\left( {{\mathbf{s}}^{\left( t\right) } - \mathop{\sum }\limits_{{i \in \left\lbrack n\right\rbrack }}{\mathbf{x}}_{i}^{\left( t\right) }}\right) }\right)$
+
+ end for
+
+ return ${\left( {\mathbf{p}}^{\left( t\right) },{\mathbf{X}}^{\left( t\right) }\right) }_{t = 1}^{T}$
+
+---
+
+Algorithm 4: Dynamic Myopic Best-Response Dynamics
+
+---
+
+Inputs: ${\left\{ \left( {U}^{\left( t\right) },{\mathbf{b}}^{\left( t\right) },{\mathbf{s}}^{\left( t\right) }\right) \right\} }_{t = 1}^{T},{\mathbf{\eta }}^{\mathbf{p}},{\mathbf{\eta }}^{\mathbf{X}}, T,{\mathbf{X}}^{\left( 0\right) },{\mathbf{p}}^{\left( 0\right) }$
+
+Output: ${x}^{ \star },{y}^{ \star }$
+
+ for $t = 1,\ldots , T - 1$ do
+
+ Set ${\mathbf{p}}^{\left( t + 1\right) } = {\Pi }_{{\mathbb{R}}_{ + }^{m}}\left( {{\mathbf{p}}^{\left( t\right) } - {\eta }_{t}^{\mathbf{p}}\left( {{\mathbf{s}}^{\left( t\right) } - \mathop{\sum }\limits_{{i \in \left\lbrack n\right\rbrack }}{\mathbf{x}}_{i}^{\left( t\right) }}\right) }\right)$
+
+ For all $i \in \left\lbrack n\right\rbrack$ , set ${x}_{i}^{\left( t + 1\right) } =$
+
+ ${\Pi }_{{\mathbb{R}}_{ + }^{m}}\left( {{\mathbf{x}}_{i}^{\left( t\right) } + {\eta }_{t}^{\mathbf{X}}\left( {\frac{{b}_{i}^{\left( t\right) }}{{u}_{i}^{\left( t\right) }\left( {\mathbf{x}}_{i}^{\left( t\right) }\right) }{\nabla }_{{\mathbf{x}}_{i}}{u}_{i}^{\left( t\right) }\left( {\mathbf{x}}_{i}^{\left( t\right) }\right) - {\mathbf{p}}^{\left( t\right) }}\right) }\right)$
+
+ end for
+
+ return ${\left( {\mathbf{p}}^{\left( t\right) },{\mathbf{X}}^{\left( t\right) }\right) }_{t = 1}^{T}$
+
+---
+
+## E An Economic Application: Details
+
+Our experimental goal was to understand if Algorithm 3 and Algorithm 4 converges in terms of distance to equilibrium and if so how the rate of convergences changes under different utility structures, i.e. different smoothness and convexity properties of the value functions.
+
+To answer these questions, we ran multiple experiments, each time recording the prices and allocations computed by Algorithm 3, in pessimistic learning setting, and by Algorithm 4 , in optimistic learning setting, during each iteration $t$ of the loop. Moreover, at each iteration $t$ , we solve the competitive equilibrium $\left( {{\mathbf{p}}^{{\left( t\right) }^{ \star }},{\mathbf{X}}^{{\left( t\right) }^{ \star }}}\right)$ for the Fisher market $\left( {{U}^{\left( t\right) },{\mathbf{b}}^{\left( t\right) },{\mathbf{s}}^{\left( t\right) }}\right)$ . Finally, for each run of the algorithm on each market, we then computed distance between the computed prices, allocations and the equilibrium prices, allocations, which we plot in Figure 1 and Figure 2.
+
+Hyperparameters We set up 100 different linear, Cobb-Douglas, Leontief dynamic Fisher markets with random changing market parameters across time, each with 5 buyers and 8 goods, and we randomly pick one of these experiments to graph.
+
+In our execution of Algorithm 3, buyer $i$ ’s budget at iteration $t,{b}_{i}^{\left( t\right) }$ , was drawn randomly from a uniform distribution ranging from 10 to 20 (i.e., $U\left\lbrack {{10},{20}}\right\rbrack$ ), each buyer $i$ ’s valuation for good $j$ at iteration $t,{v}_{ij}^{\left( t\right) }$ , was drawn randomly from $U\left\lbrack {5,{15}}\right\rbrack$ , while each good $j$ ’s supply at iteration $t,{s}_{j}^{\left( t\right) }$ , was drawn randomly from $U\left\lbrack {{100},{110}}\right\rbrack$ . In our execution of Algorithm 4, buyer $i$ ’s budget at iteration $t,{b}_{i}^{\left( t\right) }$ , was drawn randomly from a uniform distribution ranging from 10 to 15 (i.e., $U\left\lbrack {{10},{15}}\right\rbrack$ ), each buyer $i$ ’s valuation for good $j$ at iteration $t,{v}_{ij}^{\left( t\right) }$ , was drawn randomly from $U\left\lbrack {{10},{20}}\right\rbrack$ , while each good $j$ ’s supply at iteration $t,{s}_{j}^{\left( t\right) }$ , was drawn randomly from $U\left\lbrack {{10},{15}}\right\rbrack$ .
+
+We ran both Algorithm 3 and Algorithm 4 for 1000 iterations on linear, Cobb-Douglas, and Leontief Fisher markets. We started the algorithm with initial prices drawn randomly from $U\left\lbrack {5,{55}}\right\rbrack$ . Our theoretical results assume fixed learning rates, but since those results apply to static games while our experiments apply to dynamic Fisher markets, we selected variable learning rates. After manual hyper-parameter tuning, for Algorithm 3, we chose a dynamic learning rate of ${\eta }_{t} = \frac{1}{\sqrt{t}}$ , while for Algorithm 4, we chose learning rates of ${\eta }_{t}^{\mathbf{x}} = \frac{5}{\sqrt{t}}$ and ${\eta }_{t}^{\mathbf{y}} = \frac{0.01}{\sqrt{t}}$ , for all $t \in \left\lbrack T\right\rbrack$ . For these choices of learning rates, we obtain empirical convergence rates close to what the theory predicts.
+
+Programming Languages, Packages, and Licensing We ran our experiments in Python 3.7 (Van Rossum and Drake Jr 1995), using NumPy (Harris et al. 2020), Pandas (pandas development team 2020), and CVXPY (Diamond and Boyd 2016). Figure 1 and Figure 2 were graphed using Matplotlib (Hunter 2007).
+
+Python software and documentation are licensed under the PSF License Agreement. Numpy is distributed under a liberal BSD license. Pandas is distributed under a new BSD license. Matplotlib only uses BSD compatible code, and its license is based on the PSF license. CVXPY is licensed under an APACHE license.
+
+Implementation Details In order to project each allocation computed onto the budget set of the consumers, i.e., $\left\{ {\mathbf{X} \in {\mathbb{R}}_{ + }^{n \times m} \mid \mathbf{X}\mathbf{p} \leq \mathbf{b}}\right\}$ , we used the alternating projection algorithm for convex sets, and alternatively projected onto the sets ${\mathbb{R}}_{ + }^{n \times m}$ and $\left\{ {\mathbf{X} \in {\mathbb{R}}^{n \times m} \mid \mathbf{X}\mathbf{p} \leq \mathbf{b}}\right\}$ .
+
+To compute the best-response for the inner play in Algorithm 3 , we used the ECOS solver, a CVXPY's first-order convex-program solvers, but if ever a runtime exception occurred, we ran the SCS solver.
+
+When computing the distance from the demands ${\mathbf{X}}^{\left( t\right) }$ computed by our algorithms to the equilibrium demands ${\mathbf{X}}^{{\left( t\right) }^{ \star }}$ , we normalize both demands to satisfy $\forall j \in$ $\left\lbrack m\right\rbrack ,\mathop{\sum }\limits_{{i \in \left\lbrack n\right\rbrack }}{x}_{ij} = {1}_{m}$ to reduce the noise caused by changing supplies.
+
+Computational Resources Our experiments were run on MacOS machine with 8GB RAM and an Apple M1 chip, and took about 2 hours to run. Only CPU resources were used.
+
+Code Repository The data our experiments generated, as well as the code used to produce our visualizations, can be found in our code repository (https://anonymous.4open.science/r/Dynamic-Minmax-Games-8153/).
\ No newline at end of file
diff --git a/papers/AAAI/AAAI 2022/AAAI 2022 Workshop/AAAI 2022 Workshop AdvML/u_lOumlm7mu/Initial_manuscript_tex/Initial_manuscript.tex b/papers/AAAI/AAAI 2022/AAAI 2022 Workshop/AAAI 2022 Workshop AdvML/u_lOumlm7mu/Initial_manuscript_tex/Initial_manuscript.tex
new file mode 100644
index 0000000000000000000000000000000000000000..a8aa965c2cd86186096fd76a2b4ae5e7a8b1dc85
--- /dev/null
+++ b/papers/AAAI/AAAI 2022/AAAI 2022 Workshop/AAAI 2022 Workshop AdvML/u_lOumlm7mu/Initial_manuscript_tex/Initial_manuscript.tex
@@ -0,0 +1,275 @@
+§ ROBUST NO-REGRET LEARNING IN MIN-MAX STACKELBERG GAMES
+
+Anonymous Author(s)
+
+§ ABSTRACT
+
+The behavior of no-regret learning algorithms is well understood in two-player min-max (i.e, zero-sum) games. In this paper, we investigate the behavior of no-regret learning in min-max games with dependent strategy sets, where the strategy of the first player constrains the behavior of the second. Such games are best understood as sequential, i.e., min-max Stackelberg, games. We consider two settings, one in which only the first player chooses their actions using a no-regret algorithm while the second player best responds, and one in which both players use no-regret algorithms. For the former case, we show that no-regret dynamics converge to a Stack-elberg equilibrium. For the latter case, we introduce a new type of regret, which we call Lagrangian regret, and show that if both players minimize their Lagrangian regrets, then play converges to a Stackelberg equilibrium. We then observe that online mirror descent (OMD) dynamics in these two settings correspond respectively to a known nested (i.e., sequential) gradient descent-ascent (GDA) algorithm and a new simultaneous GDA-like algorithm, thereby establishing convergence of these algorithms to Stackelberg equilibrium. Finally, we analyze the robustness of OMD dynamics to perturbations by investigating dynamic min-max Stackelberg games. We prove that OMD dynamics are robust for a large class of dynamic min-max games with independent strategy sets. In the dependent case, we demonstrate the robustness of OMD dynamics experimentally by simulating them in dynamic Fisher markets, a canonical example of a min-max Stackelberg game with dependent strategy sets.
+
+§ 1 INTRODUCTION
+
+Min-max optimization problems (i.e., zero-sum games) have been attracting a great deal of attention recently because of their applicability to problems in fairness in machine learning (Dai et al. 2019; Edwards and Storkey 2016; Madras et al. 2018; Sattigeri et al. 2018), generative adversarial imitation learning (Cai et al. 2019; Hamedani et al. 2018), reinforcement learning (Dai et al. 2018), generative adversarial learning (Sanjabi et al. 2018a), adversarial learning (Sinha et al. 2020), and statistical learning, e.g., learning parameters of exponential families (Dai et al. 2019). These problems are often modelled as min-max games, i.e., constrained min-max optimization problems of the form: $\mathop{\min }\limits_{{\mathbf{x} \in X}}\mathop{\max }\limits_{{\mathbf{y} \in Y}}f\left( {\mathbf{x},\mathbf{y}}\right)$ , where $f$ : $X \times Y \rightarrow \mathbb{R}$ is continuous, and $X \subset {\mathbb{R}}^{n}$ and $Y \subset$ ${\mathbb{R}}^{m}$ are non-empty and compact. In convex-concave min-max games, where $f$ is convex in $\mathbf{x}$ and concave in $\mathbf{y}$ , von Neumann and Morgenstern's seminal minimax theorem holds (Neumann 1928): i.e., $\mathop{\min }\limits_{{\mathbf{x} \in X}}\mathop{\max }\limits_{{\mathbf{y} \in Y}}f\left( {\mathbf{x},\mathbf{y}}\right) =$ $\mathop{\max }\limits_{{\mathbf{y} \in Y}}\mathop{\min }\limits_{{\mathbf{x} \in X}}f\left( {\mathbf{x},\mathbf{y}}\right)$ , guaranteeing the existence of a saddle point, i.e., a point that is simultaneously a minimum of $f$ in the $\mathbf{x}$ -direction and a maximum of $f$ in the $y$ -direction. This theorem allows us to interpret the optimization problem as a simultaneous-move, zero-sum game, where ${\mathbf{y}}^{ * }$ (resp. ${\mathbf{x}}^{ * }$ ) is a best-response of the outer (resp. inner) player to the other’s action ${\mathbf{x}}^{ * }$ (resp. ${\mathbf{y}}^{ * }$ ), in which case a saddle point is also called a minimax point or a Nash equilibrium.
+
+In this paper, we study min-max Stackelberg games (Goktas and Greenwald 2021), i.e., constrained min-max optimization problems with dependent feasible sets of the form: $\mathop{\min }\limits_{{\mathbf{x} \in X}}\mathop{\max }\limits_{{\mathbf{y} \in Y : \mathbf{g}\left( {\mathbf{x},\mathbf{y}}\right) \geq \mathbf{0}}}f\left( {\mathbf{x},\mathbf{y}}\right)$ , where $f : X \times$ $Y \rightarrow \mathbb{R}$ is continuous, $X \subset {\mathbb{R}}^{n}$ and $Y \subset {\mathbb{R}}^{m}$ are non-empty and compact, and $\mathbf{g}\left( {\mathbf{x},\mathbf{y}}\right) = {\left( {g}_{1}\left( \mathbf{x},\mathbf{y}\right) ,\ldots ,{g}_{K}\left( \mathbf{x},\mathbf{y}\right) \right) }^{T}$ with ${g}_{k} : X \times Y \rightarrow \mathbb{R}$ . Goktas and Greenwald observe that the minimax theorem does not hold in these games (2021). As a result, such games are more appropriately viewed as sequential, i.e., Stackelberg, games for which the relevant solution concept is the Stackelberg equilibrium, ${}^{1}$ where the outer player chooses $\widehat{\mathbf{x}} \in X$ before the inner player responds with their choice of $\mathbf{y}\left( \widehat{\mathbf{x}}\right) \in Y$ s.t. $\mathbf{g}\left( {\widehat{\mathbf{x}},\mathbf{y}\left( \widehat{\mathbf{x}}\right) }\right) \geq \mathbf{0}$ . In these games, the outer player seeks to minimize their loss, assuming the inner player chooses a feasible best response: i.e., the outer player's objective, also known as their value function in the economics literature (Milgrom and Segal 2002), is defined as ${V}_{X}\left( \mathbf{x}\right) = \mathop{\max }\limits_{{\mathbf{y} \in Y : \mathbf{g}\left( {\mathbf{x},\mathbf{y}}\right) \geq \mathbf{0}}}f\left( {\mathbf{x},\mathbf{y}}\right)$ . The inner player’s value function, ${V}_{Y} : X \rightarrow \mathbb{R}$ , which they seek to maximize, is simply the objective function given the outer player’s action $\widehat{\mathbf{x}}$ : i.e., ${V}_{Y}\left( {\mathbf{y};\widehat{\mathbf{x}}}\right) = f\left( {\widehat{\mathbf{x}},\mathbf{y}}\right)$ .
+
+Goktas and Greenwald (2021) proposed a polynomial-time first-order method by which to compute Stackelberg equilibria, which they called nested gradient descent ascent (GDA). This method can be understood as an algorithm a third party might run to find an equilibrium, or as a game dynamic that the players might employ if their long-run goal were to reach an equilibrium. Rather than assume that players are jointly working towards the goal of reaching an equilibrium, it is often more reasonable to assume that they play so as to not regret their decisions: i.e., that they employ a no-regret learning algorithm, which minimizes their loss in hindsight. It is well known that when both players in a min-max game are no-regret learners, the players' strategy profile over time converges to a Nash equilibrium in average iterates: i.e., empirical play converges to a Nash equilibrium (e.g., (Freund and Schapire 1996)).
+
+${}^{1}$ One could also view such games as pseudo-games (also known as abstract economies) (Arrow and Debreu 1954), in which players move simultaneously under the unreasonable assumption that the moves they make will satisfy the game's dependency constraints. Under this view, the relevant solution concept is generalized Nash equilibrium (Facchinei and Kanzow 2007, 2010).
+
+Copyright © 2022, Association for the Advancement of Artificial Intelligence (www.aaai.org). All rights reserved.
+
+In this paper, we investigate no-regret learning dynamics in min-max Stackelberg games. We assume both pessimistic and optimistic settings. In the pessimistic setting, the outer player is a no-regret learner while the inner player best responds; in the optimistic setting, both players are no-regret learners. In the pessimistic case, we show that if the outer player uses a no-regret algorithm that achieves $\varepsilon$ -pessimistic regret after $T$ iterations, then the outer player’s empirical play converges to their $\varepsilon$ -Stackelberg equilibrium strategy. In the optimistic case, we introduce a new type of regret, which we call Lagrangian regret, which assumes access to a solution oracle for the optimal KKT multipliers of the game's constraints. We then show that if both players use no-regret algorithms that achieve $\varepsilon$ -Lagrangian regret after $T$ iterations, the players’ empirical play converges to an $\varepsilon$ - Stackelberg equilibrium.
+
+We then restrict our attention to online mirror descent (OMD) dynamics, which yield two algorithms, namely max-oracle gradient descent (Jin, Netrapalli, and Jordan 2020) and nested GDA (Goktas and Greenwald 2021) in the pessimistic setting, and a new simultaneous GDA-like algorithm (Nedic and Ozdaglar 2009) in the optimistic setting, which we call Lagrangian GDA (LGDA). Convergence of the former two algorithms in $O\left( {1/{\varepsilon }^{2}}\right)$ iterations then follows from our previous theorems. Additionally, the iteration complexity of $O\left( {1/{\varepsilon }^{2}}\right)$ suggests the superiority of LGDA over nested-GDA when a Lagrangian solution oracle exists, since nested-GDA converges in $O\left( {1/{\varepsilon }^{3}}\right)$ iterations (Goktas and Greenwald 2021), while LGDA converges in $O\left( {1/{\varepsilon }^{2}}\right)$ iterations, assuming the objective function is only Lipschitz continuous.
+
+Finally, we analyze the robustness of OMD dynamics to perturbations by investigating dynamic min-max Stackel-berg games. We prove that OMD dynamics are robust, in that even when the game changes with each iteration of the algorithm, OMD dynamics track the changing equilibrium closely for a large class of dynamic min-max games with independent strategy sets. In the dependent strategy set case, we demonstrate the robustness of OMD dynamics experimentally by simulating them in dynamic Fisher markets, a canonical example of a min-max Stackelberg game (with dependent strategy sets). Even when the Fisher market changes with each iteration, our OMD dynamics are able to track the changing equilibria closely. Our findings can be summarized as follows:
+
+ * In min-max Stackelberg games, when the outer player is a no-regret learner and the inner-player best-responds, the average of the outer player's strategies converges to their Stackelberg equilibrium strategy.
+
+ * We introduce a new type of regret we call Lagrangian regret and show that in min-max Stackelberg games when both players minimize Lagrangian regret, the average of the players' strategies converge to a Stackelberg equilibrium.
+
+ * We provide novel convergence guarantees for two known algorithms, max-oracle gradient descent and nested gradient descent ascent, to an $\varepsilon$ -Stackelberg equilibrium in $O\left( {1/{\varepsilon }^{2}}\right)$ in average iterates.
+
+ * We introduce a new simultaneous GDA-like algorithm and prove that its average iterates converge to an $\varepsilon$ - Stackelberg equilibrium in $O\left( {1/{\varepsilon }^{2}}\right)$ iterations.
+
+ * We prove that max-oracle gradient descent and simultaneous GDA are robust to perturbations in a large class of min-max games (with independent strategy sets).
+
+ * We run experiments with Fisher markets which suggest that max-oracle gradient descent and simultaneous GDA are robust to perturbations in these min-max Stackelberg games (with dependent strategy sets).
+
+We provide a review of related work in Appendix BThis paper is organized as follows. In the next section, we present the requisite mathematical preliminaries. In Section 3, we present no-regret learning dynamics that converge in a large class of min-max Stackelberg games. In Section 4, we study the convergence and robustness properties of a particular no-regret learning algorithm, namely online mirror descent, in min-max Stackelberg games.
+
+§ 2 MATHEMATICAL PRELIMINARIES
+
+Our notational conventions can be found in Appendix A.
+
+Game Definitions A min-max Stackelberg game, (X, Y, f, g), is a two-player, zero-sum game, where one player, who we call the outer, or $\mathbf{x}$ -, player (resp. the inner, or $\mathbf{y}$ -, player), is trying to minimize their loss (resp. maximize their gain), defined by a continuous objective function $f : X \times Y \rightarrow \mathbb{R}$ , by taking an action from their strategy set $X \subset {\mathbb{R}}^{n}$ , and (resp. $Y \subset {\mathbb{R}}^{m}$ ) s.t. $\mathbf{g}\left( {\mathbf{x},\mathbf{y}}\right) \geq 0$ where $\mathbf{g}\left( {\mathbf{x},\mathbf{y}}\right) = {\left( {g}_{1}\left( \mathbf{x},\mathbf{y}\right) ,\ldots ,{g}_{K}\left( \mathbf{x},\mathbf{y}\right) \right) }^{T}$ with ${g}_{k} : X \times Y \rightarrow \mathbb{R}$ continuous. A strategy profile $\left( {\mathbf{x},\mathbf{y}}\right) \in X \times Y$ is said to be feasible iff for all $k \in \left\lbrack K\right\rbrack$ , ${g}_{k}\left( {\mathbf{x},\mathbf{y}}\right) \geq 0$ . The function $f$ maps a pair of actions taken by the players $\left( {\mathbf{x},\mathbf{y}}\right) \in X \times Y$ to a real value (i.e., a payoff), which represents the loss (resp. the gain) of the $\mathbf{x}$ -player (resp. the $\mathbf{y}$ -player). A min-max game is said to be convex-concave if the objective function $f$ is convex-concave.
+
+One way to see this game is as a Stackelberg game, i.e., a sequential game with two players, where WLOG, we assume that the minimizing player moves first and the maximizing player moves second. The relevant solution concept for Stackelberg games is the Stackelberg equilibrium: A strategy profile $\left( {{\mathbf{x}}^{ * },{\mathbf{y}}^{ * }}\right) \in X \times Y$ s.t. $\mathbf{g}\left( {{\mathbf{x}}^{ * },{\mathbf{y}}^{ * }}\right) \geq \mathbf{0}$ is an $\left( {\epsilon ,\delta }\right)$ -Stackelberg equilibrium if $\mathop{\max }\limits_{{\mathbf{y} \in Y : \mathbf{g}\left( {{\mathbf{x}}^{ * },\mathbf{y}}\right) \geq 0}}$ $f\left( {{\mathbf{x}}^{ * },\mathbf{y}}\right) - \delta \; \leq \;f\left( {{\mathbf{x}}^{ * },{\mathbf{y}}^{ * }}\right) \; \leq$ $\mathop{\min }\limits_{{\mathbf{x} \in X}}\mathop{\max }\limits_{{\mathbf{y} \in Y : \mathbf{g}\left( {\mathbf{x},\mathbf{y}}\right) \geq 0}}f\left( {\mathbf{x},\mathbf{y}}\right) + \epsilon$ . Intuitively, a $\left( {\varepsilon ,\delta }\right)$ -Stackelberg equilibrium is a point at which the $\mathbf{x}$ - player’s (resp. $\mathbf{y}$ -player’s) payoff is no more than $\varepsilon$ (resp. $\delta$ ) away from its optimum. A(0,0)-Stackelberg equilibrium is guaranteed to exist in min-max Stackelberg games (Goktas and Greenwald 2021). Note that when $\mathbf{g}\left( {\mathbf{x},\mathbf{y}}\right) \geq \mathbf{0}$ , for all $\mathbf{x} \in X$ and $\mathbf{y} \in Y$ , the game reduces to a min-max game (with independent strategy sets), for which, by the min-max theorem, a Nash equilibrium is guaranteed to exist (Neumann 1928).
+
+In a min-max Stackelberg game, the outer player’s best-response set ${\mathrm{{BR}}}_{X} \subset X$ , defined as ${\mathrm{{BR}}}_{X} = \arg \mathop{\min }\limits_{{\mathbf{x} \in X}}{V}_{X}\left( \mathbf{x}\right)$ , is independent of the inner player's strategy, while the inner player's best-response correspondence ${\mathrm{{BR}}}_{Y} : X \rightrightarrows Y$ , defined as ${\mathrm{{BR}}}_{Y}\left( \mathbf{x}\right) = \arg \mathop{\max }\limits_{{\mathbf{y} \in Y : \mathbf{g}\left( {\mathbf{x},\mathbf{y}}\right) \geq 0}}{V}_{Y}\left( {\mathbf{y};\mathbf{x}}\right)$ , depends on the outer player’s strategy. A(0,0)-Stackelberg equilibrium $\left( {{\mathbf{x}}^{ * },{\mathbf{y}}^{ * }}\right) \in X \times Y$ is then a tuple of strategies such that $\left( {{\mathbf{x}}^{ * },{\mathbf{y}}^{ * }}\right) \in {\mathrm{{BR}}}_{X} \times {\mathrm{{BR}}}_{Y}\left( {\mathbf{x}}^{ * }\right) .$
+
+A dynamic min-max Stackelberg game, ${\left\{ \left( X,Y,{f}^{\left( t\right) },{\mathbf{g}}^{\left( t\right) }\right) \right\} }_{t = 1}^{T}$ , is a sequence of min-max Stack-elberg games played for $T$ time periods. We define the players’ value functions at time $t$ in a dynamic min-max Stackelberg game in the obvious way. Note that when ${\mathbf{g}}^{\left( t\right) }\left( {\mathbf{x},\mathbf{y}}\right) \geq 0$ for all $\mathbf{x} \in X,\mathbf{y} \in Y$ and all time periods $t \in \left\lbrack T\right\rbrack$ , the game reduces to a dynamic min-max game (with independent strategy sets). Moreover, if $\forall t,{t}^{\prime } \in \left\lbrack T\right\rbrack ,{f}^{\left( t\right) } = {f}^{\left( {t}^{\prime }\right) }$ , and ${\mathbf{g}}^{\left( t\right) } = {\mathbf{g}}^{\left( {t}^{\prime }\right) }$ , then the game reduces to a (static) min-max Stackelberg game, which we denote simply by(X, Y, f, g).
+
+Mathematical Preliminaries Given $A \subset {\mathbb{R}}^{n}$ , the function $f : A \rightarrow \mathbb{R}$ is said to be ${\ell }_{f}$ -Lipschitz-continuous iff $\forall {\mathbf{x}}_{1},{\mathbf{x}}_{2} \in X,$
+
+$\begin{Vmatrix}{f\left( {\mathbf{x}}_{1}\right) - f\left( {\mathbf{x}}_{2}\right) }\end{Vmatrix} \leq {\ell }_{f}\begin{Vmatrix}{{\mathbf{x}}_{1} - {\mathbf{x}}_{2}}\end{Vmatrix}$ . If the gradient of $f$ , $\nabla f$ , is ${\ell }_{\nabla f}$ -Lipschitz-continuous, we refer to $f$ as ${\ell }_{\nabla f}$ - Lipschitz-smooth. We provide a review of online convex optimization in Appendix A.
+
+§ 3 NO-REGRET LEARNING DYNAMICS
+
+In this section we explore no-regret learning dynamics in min-max Stackelberg games, and prove the convergence of no-regret learning dynamics in two settings: a pessimistic setting in which the outer player is a no-regret learner while the inner player best-responds, and an optimistic setting in which both players are no-regret learners. All the results in this paper rely on the following assumptions:
+
+Assumption 1. 1. (Slater's condition (Slater 1959, 2014)) $\forall \mathbf{x} \in X,\exists \widehat{\mathbf{y}} \in Y$ s.t. ${g}_{k}\left( {\mathbf{x},\widehat{\mathbf{y}}}\right) > \mathbf{0}$ , for all $k = 1,\ldots ,K;2.f,{g}_{1},\ldots ,{g}_{K}$ are continuous and convex-concave; and 3. ${\nabla }_{\mathbf{x}}f,{\nabla }_{\mathbf{x}}{g}_{1},\ldots ,{\nabla }_{\mathbf{x}}{g}_{K}$ are well-defined for all $\left( {\mathbf{x},\mathbf{y}}\right) \in X \times Y$ and continuous in(x, y).
+
+We note that these assumptions are in line with previous work geared towards solving min-max Stackelberg games (Goktas and Greenwald 2021). Part 1 of Assumption 1, Slater's condition, is a standard constraint qualification condition (Boyd, Boyd, and Vandenberghe 2004), which is needed to derive the optimality conditions for the inner player's maximization problem; without it the problem becomes analytically intractable. Part 2 of Assumption 1 is is required for the value function of the outer player to be continuous and convex ((Goktas and Greenwald 2021), Proposition A1) so that the problem is solvable efficiently. Finally, we note that Part 3 of Assumption 1 can be replaced by a subgradient boundedness assumption instead; however, for simplicity, we assume this stronger condition.
+
+§ PESSIMISTIC LEARNING SETTING
+
+In Stackelberg games, the leader decides their strategy assuming that the inner player will best respond which leads us to first consider a repeated game setting in which the inner player always best responds to the strategy picked by the outer player. Such a setting also makes sense as in zero-sum Stackelberg games the outer player and inner player are adversaries, and in most applications of interest we are concerned by optimal strategies for the outer player; hence, assuming a strong adversary which always best-responds allows us to consider more robust strategies for the outer player.
+
+For any $\mathbf{x} \in X$ , denote ${\mathbf{y}}^{ * }\left( \mathbf{x}\right) \in {\mathrm{{BR}}}_{Y}\left( \mathbf{x}\right)$ , in such a setting, intuitively, the regret should be equal to the difference between the cumulative loss of the outer player w.r.t. to their sequence of actions to which the inner player best responds, and the smallest cumulative loss that the outer player can achieve by picking a fixed strategy to which the inner player best responds, i.e., $\frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}{f}^{\left( t\right) }\left( {{\mathbf{x}}^{\left( t\right) },{\mathbf{y}}^{ * }\left( {\mathbf{x}}^{\left( t\right) }\right) }\right) -$ $\mathop{\sum }\limits_{{t = 1}}^{T}\frac{1}{T}{f}^{\left( t\right) }\left( {\mathbf{x},{\mathbf{y}}^{ * }\left( \mathbf{x}\right) }\right)$ . We call this regret the pessimistic regret which can be more conveniently defined as the regret incurred by an action $\mathbf{x} \in X$ of the outer player w.r.t. a sequence of actions ${\left\{ \left( X,Y,{f}^{\left( t\right) },{\mathbf{g}}^{\left( t\right) }\right) \right\} }_{t = 1}^{T}$ and a dynamic min-max Stackelberg game ${\left\{ {G}_{t}\right\} }_{t \in T}$ w.r.t. to the loss given by their value function ${\left\{ {V}_{X}^{\left( t\right) }\right\} }_{t = 1}^{T}$ , i.e.:
+
+$$
+{\operatorname{PesRegret}}_{X}^{\left( T\right) }\left( \mathbf{x}\right) = \frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}{V}_{X}^{\left( t\right) }\left( {\mathbf{x}}^{\left( t\right) }\right) - \mathop{\sum }\limits_{{t = 1}}^{T}\frac{1}{T}{V}_{X}^{\left( t\right) }\left( \mathbf{x}\right)
+$$
+
+(1)
+
+That is, the pessimistic regret of the outer player compares the outer player's play history to the smallest cumulative loss the outer player could achieve by picking a fixed strategy assuming that the inner player best-responds. It is pessimistic in the sense that the outer player assumes the worst possible outcome for themself.
+
+The main theorem in this section states the following: assuming the inner player best responds to the actions of the outer player, if the outer player employs a no-regret algorithm, then the outer player's average strategy converges to a Stackelberg equilibrium. Before presenting this theorem, ${}^{2}$ we recall the following property of the outer player's value function.
+
+Proposition 2 ((Goktas and Greenwald 2021), Proposition A.1). In a min-max Stackelberg game(X, Y, f, g), the outer player’s value function, $V\left( \mathbf{x}\right) = \mathop{\max }\limits_{{\mathbf{y} \in Y : \mathbf{g}\left( {\mathbf{x},\mathbf{y}}\right) \geq \mathbf{0}}}f\left( {\mathbf{x},\mathbf{y}}\right)$ , is continuous and convex.
+
+${}^{2}$ The proofs of all mathematical claims in this section can be found in Appendix C.
+
+Theorem 3. Consider a min-max Stackelberg game (X, Y, f, g), and suppose the outer player plays a sequence of actions ${\left\{ {\mathbf{x}}^{\left( t\right) }\right\} }_{t = 1}^{T} \subset X$ . If, after $T$ iterations, the outer player’s pessimistic regret is bounded by $\varepsilon$ for all $\mathbf{x} \in X$ , then $\left( {{\overline{\mathbf{x}}}^{\left( T\right) },{\mathbf{y}}^{ * }\left( {\overline{\mathbf{x}}}^{\left( T\right) }\right) }\right)$ is a $\left( {\varepsilon ,0}\right)$ -Stackelberg equilibrium, where ${\mathbf{y}}^{ * }\left( {\overline{\mathbf{x}}}^{\left( T\right) }\right) \in {\mathrm{{BR}}}_{Y}\left( {\overline{\mathbf{x}}}^{\left( T\right) }\right)$ .
+
+We remark that even though the definition of pessimistic regret looks similar to the standard definition of regret, its structure is very different. In particular, without Proposition 2, it is not clear that the value $\mathop{\sum }\limits_{{t = 1}}^{T}\frac{1}{T}{f}^{\left( t\right) }\left( {\mathbf{x},{\mathbf{y}}^{ * }\left( \mathbf{x}\right) }\right) =$ $\mathop{\sum }\limits_{{t = 1}}^{T}{V}^{\left( t\right) }\left( \mathbf{x}\right)$ is convex in $\mathbf{x}$ .
+
+§ OPTIMISTIC LEARNING SETTING
+
+We now turn our attention to a learning setting in which both players are no-regret learners. The most straightforward way to define regret is by considering the outer and inner players’ "vanilla" regrets, respectively: ${\operatorname{Regret}}_{X}^{\left( T\right) }\left( \mathbf{x}\right) =$ $\frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}f\left( {{\mathbf{x}}^{\left( t\right) },{\mathbf{y}}^{\left( t\right) }}\right) \; - \;\frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}f\left( {\mathbf{x},{\mathbf{y}}^{\left( t\right) }}\right)$ and ${\operatorname{Regret}}_{Y}^{\left( T\right) }\left( \mathbf{y}\right) = \frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}f\left( {{\mathbf{x}}^{\left( t\right) },\mathbf{y}}\right) -$ $\frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}f\left( {{\mathbf{x}}^{\left( t\right) },{\mathbf{y}}^{\left( t\right) }}\right)$ . In convex-concave min-max games (with independent strategy sets), when both players minimize their vanilla regret, the players' average strategies converge to Nash equilibrium. In min-max Stackelberg games (with dependent strategy sets), however, convergence to a Stackelberg equilibrium in not guaranteed.
+
+Example 4. Consider the min-max Stackelberg game $\mathop{\min }\limits_{{x \in \left\lbrack {-1,1}\right\rbrack }}$
+
+$\mathop{\max }\limits_{{y \in \left\lbrack {-1,1}\right\rbrack : 0 \leq 1 - \left( {x + y}\right) }}{x}^{2} + y + 1$ . The Stackelberg equilibrium of this game is given by ${x}^{ * } = 1/2,{y}^{ * } = 1/2$ . Suppose both players employ no-regret algorithms that generate strategies ${\left\{ {\mathbf{x}}^{\left( t\right) },{\mathbf{y}}^{\left( t\right) }\right\} }_{t \in {\mathbb{N}}_{ + }}$ . Then at time $T \in {\mathbb{N}}_{ + }$ , there exists $\varepsilon > 0$ , s.t.
+
+$$
+\left\{ \begin{array}{l} \frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}\left\lbrack {{{x}^{\left( t\right) }}^{2} + {y}^{\left( t\right) } + 1}\right\rbrack - \frac{1}{T}\mathop{\min }\limits_{{x \in \left\lbrack {-1,1}\right\rbrack }}\mathop{\sum }\limits_{{t = 1}}^{T}\left\lbrack {{x}^{2} + {y}^{\left( t\right) } + 1}\right\rbrack \leq \varepsilon \\ \frac{1}{T}\mathop{\max }\limits_{{y \in \left\lbrack {-1,1}\right\rbrack }}\mathop{\sum }\limits_{{t = 1}}^{T}\left\lbrack {{{x}^{\left( t\right) }}^{2} + y + 1}\right\rbrack - \frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}\left\lbrack {{{x}^{\left( t\right) }}^{2} + {y}^{\left( t\right) } + 1}\right\rbrack \leq \varepsilon \end{array}\right.
+$$
+
+(2)
+
+Simplifying yields:
+
+$$
+\left\{ \begin{matrix} \frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}{x}^{{\left( t\right) }^{2}} - \mathop{\min }\limits_{{x \in \left\lbrack {-1,1}\right\rbrack }}{x}^{2} \leq \varepsilon \\ \mathop{\max }\limits_{{y \in \left\lbrack {-1,1}\right\rbrack }}y - \frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}{y}^{\left( t\right) } \leq \varepsilon \end{matrix}\right. \tag{3}
+$$
+
+Since both players are no-regret learners, there exists $T \in$ ${\mathbb{N}}_{ + }$ large enough s.t.
+
+$$
+\left\{ \begin{matrix} \frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}{x}^{{\left( t\right) }^{2}} \leq \mathop{\min }\limits_{{x \in \left\lbrack {-1,1}\right\rbrack }}{x}^{2} \\ \mathop{\max }\limits_{{y \in \left\lbrack {-1,1}\right\rbrack }}y \leq \frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}{y}^{\left( t\right) } \end{matrix}\right. = \left\{ \begin{matrix} \frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}{x}^{{\left( t\right) }^{2}} \leq 0 \\ 1 \leq \frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}{y}^{\left( t\right) } \end{matrix}\right.
+$$
+
+(4)
+
+In other words, the average iterates converge to $x = 0,y =$ 1, which is not the Stackelberg equilibrium of this game.
+
+If the inner player minimizes their vanilla regret without regard to the game's constraints, then their actions are not guaranteed to be feasible, and thus cannot converge to a Stackelberg equilibrium. To remedy this infeasibility, we introduce a new type of regret we call Lagrangian regret, and show that assuming access to a solution oracle for the optimal KKT multipliers of the game's constraints, if both players minimize their Lagrangian regret, then no-regret learning dynamics converge to a Stackelberg equilibrium.
+
+Define ${\mathcal{L}}_{\mathbf{x}}\left( {\mathbf{y},\mathbf{\lambda }}\right) = f\left( {\mathbf{x},\mathbf{y}}\right) + \mathop{\sum }\limits_{{k = 1}}^{K}{\lambda }_{k}{g}_{k}\left( {\mathbf{x},\mathbf{y}}\right)$ to be the Lagrangian associated with the outer player's value function, or equivalently, the inner player's maximization problem given the outer player’s strategy $\mathbf{x} \in X$ . If the optimal KKT multipliers ${\mathbf{\lambda }}^{ * } \in {\mathbb{R}}^{K}$ , which are guaranteed to exist by Slater's condition (Slater 1959), were known for the problem $\mathop{\min }\limits_{{\mathbf{x} \in X}}\mathop{\max }\limits_{{\mathbf{y} \in Y : \mathbf{g}\left( {\mathbf{x},\mathbf{y}}\right) \geq \mathbf{0}}}f\left( {\mathbf{x},\mathbf{y}}\right) =$ $\mathop{\min }\limits_{{\mathbf{x} \in X}}\mathop{\max }\limits_{{\mathbf{y} \in Y}}\mathop{\min }\limits_{{\mathbf{\lambda } \geq \mathbf{0}}}$
+
+${\mathcal{L}}_{\mathbf{x}}\left( {\mathbf{y},\mathbf{\lambda }}\right)$ , then one could plug them back into the Lagrangian to obtain a convex-concave saddle point problem given by $\mathop{\min }\limits_{{\mathbf{x} \in X}}\mathop{\max }\limits_{{\mathbf{y} \in Y}}$
+
+${\mathcal{L}}_{\mathbf{x}}\left( {\mathbf{y},{\mathbf{\lambda }}^{ * }}\right)$ . Note that a saddle point of this problem is guaranteed to exist by the minimax theorem (Neumann 1928), since ${\mathcal{L}}_{\mathbf{x}}\left( {\mathbf{y},{\mathbf{\lambda }}^{ * }}\right)$ is convex in $\mathbf{x}$ and concave in $\mathbf{y}$ . The next lemma states that the Stackelberg equilibria of a min-max Stackelberg game correspond to the saddle points of ${\mathcal{L}}_{\mathbf{x}}\left( {\mathbf{y},{\mathbf{\lambda }}^{ * }}\right)$ .
+
+Lemma 5. Any Stackelberg equilibrium $\left( {{\mathbf{x}}^{ * }{\mathbf{y}}^{ * }}\right) \in X \times$ $Y$ of any min-max Stackelberg game(X, Y, f, g)corresponds to a saddle point of ${\mathcal{L}}_{\mathbf{x}}\left( {\mathbf{y},{\mathbf{\lambda }}^{ * }}\right)$ , where ${\mathbf{\lambda }}^{ * } \in$ $\arg \mathop{\min }\limits_{{\mathbf{\lambda } \geq 0}}\mathop{\min }\limits_{{\mathbf{x} \in X}}\mathop{\max }\limits_{{\mathbf{y} \in Y}}{\mathcal{L}}_{\mathbf{x}}\left( {\mathbf{y},\mathbf{\lambda }}\right)$ .
+
+This lemma tells us that the function ${\mathcal{L}}_{\mathbf{x}}\left( {\mathbf{y},{\mathbf{\lambda }}^{ * }}\right)$ represents a new loss function that enforces the game's constraints. Based on this observation, we assume access to a Lagrangian solution oracle that provides us with ${\mathbf{\lambda }}^{ * } \in$ $\arg \mathop{\min }\limits_{{\mathbf{\lambda } > 0}}\mathop{\min }\limits_{{\mathbf{x} \in X}}\mathop{\max }\limits_{{\mathbf{y} \in Y}}{\mathcal{L}}_{\mathbf{x}}\left( {\mathbf{y},{\mathbf{\lambda }}^{ * }}\right)$ .
+
+Further, we define a new type of regret which we call Lagrangian regret. Given a sequence of actions ${\left\{ {\mathbf{x}}^{\left( t\right) },{\mathbf{y}}^{\left( t\right) }\right\} }_{t = 1}^{T}$ taken by the outer and inner players in a dynamic min-max Stackelberg game ${\left\{ \left( X,Y,{f}^{\left( t\right) },{\mathbf{g}}^{\left( t\right) }\right) \right\} }_{t = 1}^{T}$ , we define their Lagrangian regret, respectively, as LagrRegret ${}_{X}^{\left( T\right) }\left( \mathbf{x}\right) =$ $\frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}{\mathcal{L}}_{{x}^{\left( t\right) }}^{\left( t\right) }\left( {{\mathbf{y}}^{\left( t\right) },{\mathbf{\lambda }}^{ * }}\right) \; - \;\frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}{\mathcal{L}}_{\mathbf{x}}^{\left( t\right) }\left( {{\mathbf{y}}^{\left( t\right) },{\mathbf{\lambda }}^{ * }}\right)$ and ${\operatorname{LagrRegret}}_{Y}^{\left( T\right) }\left( \mathbf{y}\right) = \frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}{\mathcal{L}}_{{\mathbf{x}}^{\left( t\right) }}^{\left( t\right) }\left( {\mathbf{y},{\mathbf{\lambda }}^{ * }}\right) -$ $\begin{matrix} {\frac{1}{T}\mathop{\sum }\limits_{{t = 1}}^{T}{\mathcal{L}}_{{\mathbf{x}}^{(t)}}^{(t)}({\mathbf{y}}^{(t)},{\mathbf{\lambda }}^{ \ast }).} \end{matrix}$
+
+The saddle point residual of a point $\left( {{\mathbf{x}}^{ * },{\mathbf{y}}^{ * }}\right) \in X \times Y$ with respect to a convex-concave function $f : X \times Y \rightarrow \mathbb{R}$ is given by $\mathop{\max }\limits_{{\mathbf{y} \in Y}}f\left( {{\mathbf{x}}^{ * },\mathbf{y}}\right) - \mathop{\min }\limits_{{\mathbf{x} \in X}}f\left( {\mathbf{x},{\mathbf{y}}^{ * }}\right)$ . When the saddle point residual is 0, the saddle point is a(0,0)- Stackelberg equilibrium.
+
+The main theorem of this section now follows: if both players play so as to minimize their Lagrangian regret, then their average strategies converge to a Stackelberg equilibrium. The bound is given in terms of the saddle point residual of ${\mathcal{L}}_{\mathbf{x}}\left( {\mathbf{y},{\mathbf{\lambda }}^{ * }}\right)$ .
+
+Theorem 6. Consider a min-max Stackelberg game (X, Y, f, g), and suppose the outer and the players generate sequences of actions ${\left\{ \left( {\mathbf{x}}^{\left( t\right) },{\mathbf{y}}^{\left( t\right) }\right) \right\} }_{t = 1}^{T} \subset X$ using a no-Lagrangian-regret algorithm. If after $T$ iterations, the Lagrangian regret of both players is bounded by $\varepsilon$ for all $x \in X$ , the following convergence bound holds on the saddle point residual of $\left( {{\overline{\mathbf{x}}}^{\left( T\right) },{\overline{\mathbf{y}}}^{\left( T\right) }}\right)$ w.r.t. the Lagrangian: $0 \leq \mathop{\max }\limits_{{\mathbf{y} \in Y}}{\mathcal{L}}_{{\bar{\mathbf{x}}}^{\left( T\right) }}\left( {\mathbf{y},{\mathbf{\lambda }}^{ * }}\right) - \mathop{\min }\limits_{{\mathbf{x} \in X}}{\mathcal{L}}_{\mathbf{x}}\left( {{\overline{\mathbf{y}}}^{\left( T\right) },{\mathbf{\lambda }}^{ * }}\right) \leq {2\varepsilon }.$
+
+Having provided convergence to Stackelberg equilibrium of general no-regret learning dynamics in min-max Stack-elberg games, we now proceed to investigate the convergence and robustness properties of a specific example of a no-regret learning dynamic, namely online mirror descent (OMD) dynamics.
+
+§ 4 ONLINE MIRROR DESCENT
+
+In this section, we apply the results we have derived for no-regret learning dynamics to Online Mirror Descent (OMD) (Zinkevich 2003; Shalev-Shwartz et al. 2011). We apply the theorems we derived above to OMD, and then we study the robustness properties of OMD in min-max Stack-elberg games.
+
+§ CONVERGENCE ANALYSIS
+
+When the outer player is an OMD learner minimizing its pessimistic regret and the inner player best responds, we obtain the max-oracle gradient descent algorithm (Algorithm 1 - Appendix D) first proposed by Jin, Netrapalli, and Jordan (2020) for min-max games.
+
+Following Jin, Netrapalli, and Jordan (2020), Goktas and Greenwald extend the max-oracle gradient descent algorithm to min-max Stackelberg games and prove its convergence of in best iterates. The following corollary of Theorem 3, which concerns convergence of this algorithm in average iterates, complements their result: the max-oracle gradient descent algorithm is guaranteed to converge to an $\left( {\varepsilon ,0}\right)$ -Stackelberg equilibrium strategy of the outer player in average iterates after $O\left( {1/{\varepsilon }^{2}}\right)$ iterations, assuming the inner player best responds.
+
+We note that since ${V}_{X}$ is convex, by Proposition 2, ${V}_{X}$ is subdifferentiable. Moreover, for all $\widehat{\mathbf{x}} \in X,\widehat{\mathbf{y}} \in {\mathrm{{BR}}}_{Y}\left( \widehat{\mathbf{x}}\right)$ , ${\nabla }_{\mathbf{x}}f\left( {\widehat{\mathbf{x}},\widehat{\mathbf{y}}}\right) + \mathop{\sum }\limits_{{k = 1}}^{K}{\lambda }_{k}{g}_{k}\left( {\widehat{\mathbf{x}},\widehat{\mathbf{y}}}\right)$ is an arbitrary subgradi-ent of the value function at $\widehat{\mathbf{x}}$ by Goktas and Greenwald’s subdifferential envelope theorem (2021). We add that similar to Goktas and Greenwald, we assume that the optimal KKT multipliers ${\mathbf{\lambda }}^{ * }\left( {{\mathbf{x}}^{\left( t\right) },\widehat{\mathbf{y}}\left( {\mathbf{x}}^{\left( t\right) }\right) }\right)$ associated with a solution $\widehat{\mathbf{y}}\left( {\mathbf{x}}^{\left( t\right) }\right)$ ) can be computed in constant time.
+
+Corollary 7. Let $c = \mathop{\max }\limits_{{\mathbf{x} \in X}}\parallel \mathbf{x}\parallel$ and let ${\ell }_{f} =$ $\mathop{\max }\limits_{{\left( {\widehat{\mathbf{x}},\widehat{\mathbf{y}}}\right) \in X \times Y}}$
+
+$\begin{Vmatrix}{{\nabla }_{\mathbf{x}}f\left( {\widehat{\mathbf{x}},\widehat{\mathbf{y}}}\right) }\end{Vmatrix}$ . If Algorithm 1 (Appendix D) is run on a min-max Stackelberg game(X, Y, f, g)with ${\eta }_{t} = \frac{c}{{\ell }_{f}\sqrt{2T}}$ for all iteration $t \in \left\lbrack T\right\rbrack$ and any ${\mathbf{x}}^{\left( 0\right) } \in X$ , then $\left( {{\overline{\mathbf{x}}}^{\left( T\right) },{\mathbf{y}}^{ * }\left( {\overline{\mathbf{x}}}^{\left( T\right) }\right) }\right)$ is a $\left( {c{\ell }_{f}\sqrt{2}/\sqrt{T},0}\right)$ -Stackelberg equilibrium. Furthermore, for $\varepsilon \in \left( {0,1}\right)$ , if we choose $T \geq {N}_{T}\left( \varepsilon \right) \in O\left( {1/{\varepsilon }^{2}}\right)$ , then there exists an iteration ${T}^{ * } \leq T$ s.t. $\left( {{\overline{\mathbf{x}}}^{\left( T\right) },{\mathbf{y}}^{ * }\left( {\overline{\mathbf{x}}}^{\left( T\right) }\right) }\right)$ is an $\left( {\varepsilon ,0}\right)$ -Stackelberg equilibrium.
+
+Note that we can relax Theorem 3 to instead work with an approximate best response of the inner player, i.e., given the strategy of the outer player $\widehat{\mathbf{x}}$ , instead of playing an exact best-response, the inner player computes a $\widehat{\mathbf{y}}$ s.t. $f\left( {\widehat{\mathbf{x}},\widehat{\mathbf{y}}}\right) \geq$ $\mathop{\max }\limits_{{\mathbf{y} \in Y : \mathbf{g}\left( {\widehat{\mathbf{x}},\mathbf{y}}\right) \geq \mathbf{0}}}f\left( \widehat{\mathbf{x}}\right) - \varepsilon$ . Combine with results on the convergence of gradient ascent on smooth functions, the average iterates computed by Goktas and Greenwald's nested GDA algorithm converge to an $\left( {\varepsilon ,\varepsilon }\right)$ -Stackelberg equilibrium in $O\left( {1/{\varepsilon }^{3}}\right)$ iterations. If additionally, $f$ is strongly convex in $\mathbf{y}$ , then the iteration complexity can reduced to $O\left( {1/{\varepsilon }^{2}\log \left( {1/\varepsilon }\right) }\right)$ .
+
+Similarly, we can also consider the optimistic case, in which both the outer and inner players minimize their Lagrangian regrets, as OMD learners with access to a Lagrangian solution oracle that returns ${\mathbf{\lambda }}^{ * } \in$ $\arg \mathop{\min }\limits_{{\mathbf{\lambda } > 0}}\mathop{\min }\limits_{{\mathbf{x} \in X}}\mathop{\max }\limits_{{\mathbf{y} \in Y}}{\mathcal{L}}_{\mathbf{x}}\left( {\mathbf{y},{\mathbf{\lambda }}^{ * }}\right)$ . In this case, we obtain the Lagrangian GDA (LGDA) algorithm (Algorithm 2 - Appendix D). The following corollary of Theorem 6 states that LGDA converges in average iterates to an approximate-Stackelberg equilibrium in $O\left( {1/{\varepsilon }^{2}}\right)$ iterations.
+
+Corollary 8. Let $b = \mathop{\max }\limits_{{\mathbf{x} \in X}}\parallel \mathbf{x}\parallel ,c = \mathop{\max }\limits_{{\mathbf{y} \in Y}}\parallel \mathbf{y}\parallel$ , and ${\ell }_{\mathcal{L}} = \mathop{\max }\limits_{{\left( {\widehat{\mathbf{x}},\widehat{\mathbf{y}}}\right) \in X \times Y}}\begin{Vmatrix}{{\nabla }_{\mathbf{x}}{\mathcal{L}}_{\widehat{\mathbf{x}}}\left( {\widehat{\mathbf{y}},{\mathbf{\lambda }}^{ * }}\right) }\end{Vmatrix}$ . If Algorithm 2 (Appendix D) is run on a min-max Stackelberg game (X, Y, f, g)with ${\eta }_{t}^{\mathbf{x}} = \frac{b}{{\ell }_{\mathcal{L}}\sqrt{2T}}$ and ${\eta }_{t}^{\mathbf{y}} = \frac{c}{{\ell }_{\mathcal{L}}\sqrt{2T}}$ for all iterations $t \in \left\lbrack T\right\rbrack$ and any ${\mathbf{x}}^{\left( 0\right) } \in X$ , then the following convergence bound holds on the saddle point residual $\left( {{\overline{\mathbf{x}}}^{\left( T\right) },{\overline{\mathbf{y}}}^{\left( T\right) }}\right)$ w.r.t. the Lagrangian:
+
+$$
+0 \leq \mathop{\max }\limits_{{\mathbf{y} \in Y}}{\mathcal{L}}_{{\overline{\mathbf{x}}}^{\left( T\right) }}\left( {\mathbf{y},{\mathbf{\lambda }}^{ * }}\right) - \mathop{\min }\limits_{{\mathbf{x} \in X}}{\mathcal{L}}_{\mathbf{x}}\left( {{\overline{\mathbf{y}}}^{\left( T\right) },{\mathbf{\lambda }}^{ * }}\right) \leq \frac{2\sqrt{2}{\ell }_{\mathcal{L}}}{\sqrt{T}}\max \{ b,c\}
+$$
+
+(5)
+
+We remark that in certain rare cases the Lagrangian can become degenerate in $\mathbf{y}$ , in that the $\mathbf{y}$ terms in the Lagrangian might cancel out when ${\mathbf{\lambda }}^{ * }$ is plugged back into Lagrangian, leading LGDA to not update the $\mathbf{y}$ variables, as demonstrated by the following example:
+
+Example 9. Consider this min-max Stackelberg game: $\mathop{\min }\limits_{{x \in \left\lbrack {-1,1}\right\rbrack }}$
+
+$\mathop{\max }\limits_{{y \in \left\lbrack {-1,1}\right\rbrack : 0 \leq 1 - \left( {x + y}\right) }}{x}^{2} + y + 1$ . When we plug the optimal $\dot{K}{KT}$ multiplier ${\lambda }^{ * } = 1$ into the Lagrangian associated with the outer player's value function, we obtain ${\mathcal{L}}_{x}\left( {y,\lambda }\right) = {x}^{2} + y + 1 - \left( {x + y}\right) = {x}^{2} - x + 1$ , with $\frac{\partial \mathcal{L}}{\partial x} = {2x} - 1$ and $\frac{\partial \mathcal{L}}{\partial y} = 0$ . It follows that the $x$ iterate converges to $1/2$ , but the $\mathbf{y}$ iterate will never be updated, and hence unless $y$ is initialized to its Stackelberg equilibirium value, LGDA will not converge to a Stackelberg equilibrium.
+
+In general, this degeneracy issue occurs when $\forall \mathbf{x} \in$ $X,{\nabla }_{\mathbf{y}}f\left( {\mathbf{x},\mathbf{y}}\right) = - \mathop{\sum }\limits_{{k = 1}}^{K}{\lambda }_{k}^{ * }{\nabla }_{\mathbf{y}}{g}_{k}\left( {\mathbf{x},\mathbf{y}}\right)$ . We can sidestep the issue by restricting our attention to min-max Stack-elberg games with convex-strictly-concave objective functions, which is sufficient to ensure that the Lagrangian is not degenerate in $\mathbf{y}$ (Boyd, Boyd, and Vandenberghe 2004).
+
+§ ROBUSTNESS ANALYSIS
+
+Although the OMD dynamics we analyzed in the previous section describe a dynamic behavior in nature, they assume that the game and its properties, i.e., the objective function and constraints, are static and thus do not change over time. In many real-world games, however, the game itself is subject to perturbations, i.e., dynamic changes, in the sense that the agents' objectives and constraints might be perturbed by external influences. Analyzing and providing dynamics that are robust to ongoing changes in games is critical, since the real world is rarely static.
+
+This makes the study of dynamic min-max Stackelberg games and their associated optimal dynamic strategies for both players an important goal. Dynamic games bring with them a series of interesting issues; notably, even though the environment might change at each time period, in each period of time the game still exhibits a Stackelberg equilibrium. However, one cannot sensibly expect the players to play a Stackelberg equilibrium strategy at each time period since even in the static setting, known game dynamics require multiple time steps in order for players to reach even an approximate Stackelberg equilibrium. When players cannot directly best respond or pick the optimal strategy for themselves, they essentially become boundedly rational agents in that they can only take a step towards their optimal strategy but they cannot reach it in just one time step. Hence, in dynamic games, equilibria also become dynamic objects, which can never be reached unless the game stops changing significantly.
+
+Corollaries 8 and 7 tell us that OMD dynamics are effective equilibrium finding strategies in min-max Stackelberg games. However, they do not provide any intuition about the robustness of OMD dynamics to perturbations in the game. That is, we would like to know whether or not OMD dynamics are able to track the equilibrium even when the game changes slowly. Robustness is a desirable property for no-regret learning dynamics as many real-world applications of games involve changing environments. In this section, we provide theoretical guarantees that show that even when the game changes at each iteration, OMD dynamics closely track the changing equilibria of the dynamic game. Unfortunately, our theoretical results only concern min-max games (with independent strategy sets). Nevertheless, we provide experimental evidence that suggests that the results we prove may also apply more broadly to min-max Stackelberg games (with dependent strategy sets).
+
+We first consider the pessimistic setting in which the outer player is a no-regret learner and the inner player best-responds. In this setting, we show that when the outer player follows online projected gradient descent dynamics in a dynamic min-max game, i.e., a min-max game in which the objective function constantly changes, the outer player's strategies closely track their Stackelberg equilibrium strategy. Intuitively, the following result implies that irrespective of the initial strategy of the outer player, online projected gradient descent dynamics follow the Nash equilibrium strategy of the outer player s.t. the strategy determined by the outer player is always within a ${2d}/\delta$ radius of the outer player’s Nash equilibrium strategy.
+
+Theorem 10. Consider a dynamic min-max game ${\left\{ \left( X,Y,{f}^{\left( t\right) }\right) \right\} }_{t = 1}^{T}$ . Suppose that, for all $t \in \left\lbrack T\right\rbrack ,{f}^{\left( t\right) }$ is $\mu$ -strongly convex in $\mathbf{x}$ and strictly concave in $\mathbf{y}$ , and ${f}^{\left( t\right) }$ is ${\ell }_{\nabla f}$ -Lipschitz smooth. Suppose that the outer player generates a sequence of actions ${\left\{ {\mathbf{x}}^{\left( t\right) }\right\} }_{t = 1}^{T} \subset X$ by using an online projected gradient descent algorithm on the loss functions ${\left\{ {V}^{\left( t\right) }\right\} }_{t = 1}^{T}$ with learning rate $\eta \leq \frac{2}{\mu + {\ell }_{\nabla f}}$ and suppose that the inner player generates a sequence of best-responses to each iterate of the outer player ${\left\{ {\mathbf{y}}^{\left( t\right) }\right\} }_{t = 1}^{T} \subset Y$ . For all $t \in \left\lbrack T\right\rbrack$ , let ${\mathbf{x}}^{{\left( t\right) }^{ * }} \in \arg \mathop{\min }\limits_{{\mathbf{x} \in X}}{V}^{\left( t\right) }\left( \mathbf{x}\right)$ , ${\Delta }^{\left( t\right) } = \begin{Vmatrix}{{\mathbf{x}}^{{\left( t + 1\right) }^{ * }} - {\mathbf{x}}^{{\left( t\right) }^{ * }}}\end{Vmatrix}$ , and $\delta = \frac{{2\eta \mu }{\ell }_{\nabla f}}{{\ell }_{\nabla f} + \mu }$ , we then have:
+
+$$
+\begin{Vmatrix}{{\mathbf{x}}^{{\left( T\right) }^{ * }} - {\mathbf{x}}^{\left( T\right) }}\end{Vmatrix} \leq {\left( 1 - \delta \right) }^{T/2}\begin{Vmatrix}{{\mathbf{x}}^{{\left( 0\right) }^{ * }} - {\mathbf{x}}^{\left( 0\right) }}\end{Vmatrix} + \mathop{\sum }\limits_{{t = 1}}^{T}{\left( 1 - \delta \right) }^{\frac{T - t}{2}}{\Delta }^{\left( t\right) }
+$$
+
+(6)
+
+If additionally, for all $t \in \left\lbrack T\right\rbrack ,{\Delta }^{\left( t\right) } \leq d$ , then:
+
+$$
+\begin{Vmatrix}{{\mathbf{x}}^{{\left( T\right) }^{ * }} - {\mathbf{x}}^{\left( T\right) }}\end{Vmatrix} \leq {\left( 1 - \delta \right) }^{T/2}\begin{Vmatrix}{{\mathbf{x}}^{{\left( 0\right) }^{ * }} - {\mathbf{x}}^{\left( 0\right) }}\end{Vmatrix} + \frac{2d}{\delta } \tag{7}
+$$
+
+We can extend a similar robustness result to the setting in which the outer and inner players are both OMD learners. The following theorem implies that irrespective of the initial strategies of the two players, online projected gradient descent dynamics follow the Nash equilibrium of the game, always staying within a ${4d}/\delta$ radius.
+
+Theorem 11. Consider a dynamic min-max game ${\left\{ {G}_{t}\right\} }_{t = 0}^{T} = {\left\{ \left( X,Y,{f}^{\left( t\right) }\right) \right\} }_{t = 1}^{T}$ . Suppose that, for all $t \in \left\lbrack T\right\rbrack ,{f}^{\left( t\right) }$ is ${\mu }_{\mathbf{x}}$ -strongly convex in $\mathbf{x}$ and ${\mu }_{\mathbf{y}}$ - strongly concave in $\mathbf{y},{f}^{\left( t\right) }$ is ${\ell }_{\nabla f}$ -Lipschitz smooth. Let ${\left\{ \left( {\mathbf{x}}^{\left( t\right) },{\mathbf{y}}^{\left( t\right) }\right) \right\} }_{t = 1}^{T} \subset X \times Y$ be the strategies generated by the outer and inner players assuming that the outer player uses a online projected gradient descent algorithm on the losses ${\left\{ {f}^{\left( t\right) }\left( \cdot ,{\mathbf{y}}^{\left( t\right) }\right) \right\} }_{t = 1}^{T}$ with ${\eta }_{\mathbf{x}} = \frac{2}{{\mu }_{\mathbf{x}} + {\ell }_{\nabla f}}$ and that the inner player uses a online projected gradient descent algorithm on the losses ${\left\{ -{f}^{\left( t\right) }\left( {\mathbf{x}}^{\left( t\right) }, \cdot \right) \right\} }_{t = 1}^{T}$ with ${\eta }_{\mathbf{y}} = \frac{2}{{\mu }_{\mathbf{y}} + {\ell }_{\nabla f}}$ . For all $t \in \left\lbrack T\right\rbrack$ , let ${\mathbf{x}}^{{\left( t\right) }^{ * }} \in \arg \mathop{\min }\limits_{{\mathbf{x} \in X}}{f}^{\left( t\right) }\left( {\mathbf{x},{\mathbf{y}}^{\left( t\right) }}\right) ,{\mathbf{y}}^{{\left( t\right) }^{ * }} \in$ $\arg \mathop{\min }\limits_{{\mathbf{y} \in Y}}{f}^{\left( t\right) }\left( {{\mathbf{x}}^{\left( t\right) },\mathbf{y}}\right) .\;{\Delta }_{\mathbf{x}}^{\left( t\right) } = \begin{Vmatrix}{{\mathbf{x}}^{{\left( t + 1\right) }^{ * }} - {\mathbf{x}}^{{\left( t\right) }^{ * }}}\end{Vmatrix},$ ${\Delta }_{\mathbf{y}}^{\left( t\right) } = \begin{Vmatrix}{{\mathbf{y}}^{{\left( t + 1\right) }^{ * }} - {\mathbf{y}}^{{\left( t\right) }^{ * }}}\end{Vmatrix},{\delta }_{\mathbf{x}} = \frac{{2\eta }{\mu }_{\mathbf{x}}{\ell }_{\nabla f}}{{\ell }_{\nabla \mathbf{x}}f + {\mu }_{\mathbf{x}}}$ , and ${\delta }_{y} = \frac{{2\eta }{\mu }_{y}{\ell }_{\nabla f}}{{\ell }_{\nabla f} + {\mu }_{y}}$ we then have:
+
+$$
+\begin{Vmatrix}{{\mathbf{x}}^{{\left( T\right) }^{ * }} - {\mathbf{x}}^{\left( T\right) }}\end{Vmatrix} + \begin{Vmatrix}{{\mathbf{y}}^{{\left( T\right) }^{ * }} - {\mathbf{y}}^{\left( T\right) }}\end{Vmatrix}
+$$
+
+$$
+\leq {\left( 1 - {\delta }_{\mathbf{x}}\right) }^{T/2}\begin{Vmatrix}{{\mathbf{x}}^{{\left( 0\right) }^{ * }} - {\mathbf{x}}^{\left( 0\right) }}\end{Vmatrix} + {\left( 1 - {\delta }_{\mathbf{y}}\right) }^{T/2}\begin{Vmatrix}{{\mathbf{y}}^{{\left( 0\right) }^{ * }} - {\mathbf{y}}^{\left( 0\right) }}\end{Vmatrix}
+$$
+
+$$
++ \mathop{\sum }\limits_{{t = 1}}^{T}{\left( 1 - {\delta }_{\mathbf{x}}\right) }^{\frac{T - t}{2}}{\Delta }_{\mathbf{x}}^{\left( t\right) } + \mathop{\sum }\limits_{{t = 1}}^{T}{\left( 1 - {\delta }_{\mathbf{y}}\right) }^{\frac{T - t}{2}}{\Delta }_{\mathbf{y}}^{\left( t\right) }. \tag{8}
+$$
+
+If additionally, ${\Delta }_{\mathbf{x}}^{\left( t\right) } \leq d$ and ${\Delta }_{\mathbf{y}}^{\left( t\right) } \leq d$ for all $t \in \left\lbrack T\right\rbrack$ , and $\delta = \min \left\{ {{\delta }_{\mathbf{y}},{\delta }_{\mathbf{x}}}\right\}$ , then:
+
+$$
+\begin{Vmatrix}{{\mathbf{x}}^{{\left( T\right) }^{ * }} - {\mathbf{x}}^{\left( T\right) }}\end{Vmatrix} + \begin{Vmatrix}{{\mathbf{y}}^{{\left( T\right) }^{ * }} - {\mathbf{y}}^{\left( T\right) }}\end{Vmatrix}
+$$
+
+$$
+\leq 2{\left( 1 - \delta \right) }^{T/2}\left( {\begin{Vmatrix}{{\mathbf{x}}^{{\left( 0\right) }^{ * }} - {\mathbf{x}}^{\left( 0\right) }}\end{Vmatrix} + \begin{Vmatrix}{{\mathbf{y}}^{{\left( 0\right) }^{ * }} - {\mathbf{y}}^{\left( 0\right) }}\end{Vmatrix}}\right) + \frac{4d}{\delta }.
+$$
+
+(9)
+
+The proofs of the above theorems are relegated to Appendix C. The theorems we have proven in this section establish the robustness of OMD dynamics for min-max games in both the pessimistic and optimistic settings by showing that the dynamics closely track the Stackelberg equilibrium in a large class of min-max games. As we are not able to extend these theoretical robustness guarantees to min-max Stackelberg games (with dependent strategy sets), we instead ran a series of experiments on (dynamic) Fisher markets, which are canonical examples of min-max Stackel-berg games (Goktas and Greenwald 2021), to investigate the empirical robustness guarantees of OMD dynamics for this class of min-max Stackelberg games.
+
+§ DYNAMIC FISHER MARKETS
+
+The Fisher market model, attributed to Irving Fisher (Brainard, Scarf et al. 2000), has received a great deal of attention in the literature, especially by computer scientists, as it has proven useful in the design of online marketplaces. We now study OMD dynamics in dynamic Fisher markets, which are instances of min-max Stackelberg games (Goktas and Greenwald 2021).
+
+A Fisher market consists of $n$ buyers and $m$ divisible goods (Brainard, Scarf et al. 2000). Each buyer $i \in \left\lbrack n\right\rbrack$ has a budget ${b}_{i} \in {\mathbb{R}}_{ + }$ and a utility function ${u}_{i} : {\mathbb{R}}_{ + }^{m} \rightarrow \mathbb{R}$ . Each good $j \in \left\lbrack m\right\rbrack$ has supply ${s}_{j} \in {\mathbb{R}}_{ + }$ . A Fisher market is thus given by a tuple(n, m, U, b, s), where $U = \left\{ {{u}_{1},\ldots ,{u}_{n}}\right\}$ is a set of utility functions, one per buyer, $\mathbf{b} \in {\mathbb{R}}_{ + }^{n}$ is a vector of buyer budgets, and $s \in {\mathbb{R}}_{ + }^{m}$ is a vector of good supplies. We abbreviate as(U, b, s)when $n$ and $m$ are clear from context. A dynamic Fisher market is a sequence of Fisher markets ${\left( {U}^{\left( t\right) },{\mathbf{b}}^{\left( t\right) },{\mathbf{s}}^{\left( t\right) }\right) }_{t = 1}^{\left( \left\lbrack T\right\rbrack \right) }$ . An allocation $\mathbf{X} = {\left( {\mathbf{x}}_{1},\ldots ,{\mathbf{x}}_{n}\right) }^{T} \in {\mathbb{R}}_{ + }^{n \times m}$ is a map from goods to buyers, represented as a matrix s.t. ${x}_{ij} \geq 0$ denotes the amount of good $j \in \left\lbrack m\right\rbrack$ allocated to buyer $i \in \left\lbrack n\right\rbrack$ . Goods are assigned prices $\mathbf{p} = {\left( {p}_{1},\ldots ,{p}_{m}\right) }^{T} \in {\mathbb{R}}_{ + }^{m}$ . A tuple $\left( {{\mathbf{p}}^{ * },{\mathbf{X}}^{ * }}\right)$ is said to be a competitive (or Wal-rasian) equilibrium of Fisher market(U, b, s)if 1 . buyers are utility maximizing, constrained by their budget, i.e., $\forall i \in \left\lbrack n\right\rbrack ,{\mathbf{x}}_{i}^{ * } \in \arg \mathop{\max }\limits_{{\mathbf{x} : \mathbf{x} \cdot {\mathbf{p}}^{ * } \leq {b}_{i}}}{u}_{i}\left( \mathbf{x}\right)$ ; and 2. the market clears, i.e., $\forall j \in \left\lbrack m\right\rbrack ,{p}_{j}^{ * } > 0 \Rightarrow \mathop{\sum }\limits_{{i \in \left\lbrack n\right\rbrack }}{x}_{ij}^{ * } = {s}_{j}$ and ${p}_{j}^{ * } = 0 \Rightarrow \mathop{\sum }\limits_{{i \in \left\lbrack n\right\rbrack }}{x}_{ij}^{ * } \leq {s}_{j}.$
+
+Goktas and Greenwald (2021) observe that any competitive equilibrium $\left( {{\mathbf{p}}^{ * },{\mathbf{X}}^{ * }}\right)$ of a Fisher market(U, b)corresponds to a Stackelberg equilibrium of the following min-max Stackelberg game: ${}^{3}$
+
+$$
+\mathop{\min }\limits_{{\mathbf{p} \in {\mathbb{R}}_{ + }^{m}}}\mathop{\max }\limits_{{\mathbf{X} \in {\mathbb{R}}_{ + }^{n \times m} : \mathbf{X}\mathbf{p} \leq \mathbf{b}}}\mathop{\sum }\limits_{{j \in \left\lbrack m\right\rbrack }}{s}_{j}{p}_{j} + \mathop{\sum }\limits_{{i \in \left\lbrack n\right\rbrack }}{b}_{i}\log \left( {{u}_{i}\left( {\mathbf{x}}_{i}\right) }\right) .
+$$
+
+(10)
+
+Let $\mathcal{L} : {\mathbb{R}}_{ + }^{m} \times {\mathbb{R}}^{n \times m} \rightarrow {\mathbb{R}}_{ + }$ be the Lagrangian of the outer player's value function in Equation (10), i.e.,
+
+$\begin{array}{l} {\mathcal{L}}_{\mathbf{p}}\left( {\mathbf{X},\mathbf{\lambda }}\right) = \mathop{\sum }\limits_{{j \in \left\lbrack m\right\rbrack }}{s}_{j}{p}_{j} + \mathop{\sum }\limits_{{i \in \left\lbrack n\right\rbrack }}{b}_{i}\log \left( {{u}_{i}\left( {\mathbf{x}}_{i}\right) }\right) + \\ \end{array}$ $\mathop{\sum }\limits_{{i \in \left\lbrack n\right\rbrack }}{\lambda }_{i}\left( {{b}_{i} - {\mathbf{x}}_{i} \cdot \mathbf{p}}\right)$ . One can show the existence of a Lagrangian solution oracle for the Lagrangian of Equation (10) such that ${\mathbf{\lambda }}^{ * } = {\mathbf{1}}_{m}$ . We then have: 1. by Goktas and Greenwald's envelope theorem, the subdifferential of the outer player’s value function is given by ${\nabla }_{\mathbf{p}}V\left( \mathbf{p}\right) = s -$ $\mathop{\sum }\limits_{{i \in \left\lbrack n\right\rbrack }}{\mathbf{x}}_{i}^{ * }\left( \mathbf{p}\right)$ , where ${\mathbf{x}}_{i}^{ * }\left( \mathbf{p}\right) \in \arg \mathop{\max }\limits_{{\mathbf{x} \in {\mathbb{R}}_{ + }^{m}\mathbf{x} \cdot \mathbf{p} \leq {b}_{i}}}{u}_{i}\left( \mathbf{x}\right)$ , 2. the gradient of the Lagrangian w.r.t. the prices, given the Langrangian solution oracle, is ${\nabla }_{\mathbf{p}}{\mathcal{L}}_{\mathbf{p}}\left( {\mathbf{X},{\mathbf{\lambda }}^{ * }}\right) = s -$ $\mathop{\sum }\limits_{{i \in \left\lbrack n\right\rbrack }}{\mathbf{x}}_{i}$ and ${\nabla }_{{\mathbf{x}}_{i}}{\mathcal{L}}_{\mathbf{p}}\left( {\mathbf{X},{\mathbf{\lambda }}^{ * }}\right) ) = \frac{{b}_{i}}{{u}_{i}\left( {\mathbf{x}}_{i}\right) }{\nabla }_{{\mathbf{x}}_{i}}{u}_{i}\left( {\mathbf{x}}_{i}\right) - \mathbf{p}$ , where ${\mathbf{\lambda }}^{ * } = {\mathbf{1}}_{m}$ .
+
+We first consider OMD dynamics for Fisher markets in the pessimistic setting, in which the outer player determines their strategy via online projected gradient descent and the inner player best-responds. In this setting, we obtain a dynamic version of a natural price adjustment process known as tâtonnement (Walras 1969), which was first studied by Cheung, Hoefer, and Nakhe (2019) (Algorithm 3, Appendix D).
+
+We then consider OMD dynamics in the optimistic setting, in which case both the outer and inner players employ online projected gradient descent, which yields myopic best-response dynamics (Monderer and Shapley 1996) (Algorithm 4, Appendix D). In words, at each time step, the (fictional Walrasian) auctioneer takes a gradient descent step to minimize its regret, and then all the buyers take a gradient ascent step to minimize their Lagrangian regret. These gradient descent-ascent dynamics can be seen as myopic best-response dynamics for sellers and buyers who are both boundedly rational (Camerer 1998).
+
+Experiments In order to better understand the robustness properties of Algorithms 3 and 4 in a dynamic min-max Stackelberg game that is subject to perturbation across time, we ran a series of experiments with dynamic Fisher Markets assuming three different classes of utility functions. ${}^{4}$ Each utility structure endows Equation (10) with different smoothness properties, which allows us to compare the efficiency of the algorithms under varying conditions. Let ${\mathbf{v}}_{i} \in$ ${\mathbb{R}}^{m}$ be a vector of valuation parameters that describes the utility function of buyer $i \in \left\lbrack n\right\rbrack$ . We consider the following utility function classes: 1. linear: ${u}_{i}\left( {\mathbf{x}}_{i}\right) = \mathop{\sum }\limits_{{j \in \left\lbrack m\right\rbrack }}{v}_{ij}{x}_{ij}$ ; 2. Cobb-Douglas: ${u}_{i}\left( {\mathbf{x}}_{i}\right) = \mathop{\prod }\limits_{{j \in \left\lbrack m\right\rbrack }}{x}_{ij}^{{v}_{ij}}$ ; and 3. Leontief: ${u}_{i}\left( {\mathbf{x}}_{i}\right) = \mathop{\min }\limits_{{j \in \left\lbrack m\right\rbrack }}\left\{ \frac{{x}_{ij}}{{v}_{ij}}\right\}$ . To simulate the dynamic Fisher markets, we fix a range for every market parameter and draw from that range uniformly at random during each iteration. Our goal is to understand how closely OMD dynamics track the Stackelberg equilibria of the game as the latter varies with time. To do so, we compare the distance between the iterates $\left( {{\mathbf{p}}^{\left( t\right) },{\mathbf{X}}^{\left( t\right) }}\right)$ computed by the algorithms and the equilibrium of the game at each iteration $t$ . This distance is measured as ${\begin{Vmatrix}{\mathbf{p}}^{{\left( t\right) }^{ * }} - {\mathbf{p}}^{\left( t\right) }\end{Vmatrix}}_{2} + {\begin{Vmatrix}{\mathbf{X}}^{{\left( t\right) }^{ * }} - {\mathbf{X}}^{\left( t\right) }\end{Vmatrix}}_{2}$ , where $\left( {{\mathbf{p}}^{{\left( t\right) }^{ * }},{\mathbf{X}}^{{\left( t\right) }^{ * }}}\right)$ is the Stackelberg equilibrium of the Fisher market $\left( {{U}^{\left( t\right) },{\mathbf{b}}^{\left( t\right) },{\mathbf{s}}^{\left( t\right) }}\right)$ at time $t \in \left\lbrack T\right\rbrack$ .
+
+In our experiments, we ran Algorithms 3 and 4 on 100 randomly initialized dynamic Fisher markets. We depict the distance to equilibrium at each iteration for a randomly chosen experiment in Figures 1 and 2. In these figures, we observe that our OMD dynamics are closely tracking the Stackelberg equilibria as they vary with each iteration. A more detailed description of our experimental setup can be found in Appendix E.
+
+${}^{3}$ The first term in this program is slightly different than the first term in the program presented by Goktas and Greenwald (2021), since supply is assumed to be 1 their work.
+
+${}^{4}$ Our code can be found at https://anonymous.4open.science/r/ Dynamic-Minmax-Games-8153/.
+
+ < g r a p h i c s >
+
+Figure 1: In blue, we depict a trajectory of distances between computed allocation-price pairs and equilibrium allocation-price pairs, when Algorithm 3 is run on randomly initialized dynamic linear, Cobb-Douglas, and Leontief Fisher markets. In red, we plot an arbitrary $O\left( {1/\sqrt{T}}\right)$ function.
+
+Figure 2: In blue, we depict a trajectory of distances between computed allocation-price pairs and equilibrium allocation-price pairs, when Algorithm 4 is run on randomly initialized dynamic linear, Cobb-Douglas, and Leontief Fisher markets. In red, we plot an arbitrary $O\left( {1/\sqrt{T}}\right)$ function.
+
+We observe from Figures 1 and 2 that for both Algorithms 3 and 4, we obtain an empirical convergence rate relatively close to $O\left( {1/\sqrt{T}}\right)$ under Cobb-Douglas utilities, and a slightly slower empirical convergence rate under linear utilities. Recall that $O\left( {1/\sqrt{T}}\right)$ is the convergence rate guarantee we obtained for both algorithms, assuming a fixed learning rate in a static Fisher market (Corollaries 7 and 8).
+
+Dynamic Fisher markets with Leontief utilities, in which the objective function is not differentiable, are the hardest markets of the three for our algorithms to solve. Still, we only see a slightly slower than $O\left( {1/\sqrt{T}}\right)$ empirical convergence rate for both Algorithms 3 and 4. In these experiments, the convergence curve generated by Algorithm 4 has a less erratic behavior than the one generated by Algorithm 3. Due to the non-differentiability of the objective function, the gradient ascent step in Algorithm 4 for buyers with Leontief utilities is very small, effectively dampening any potentially erratic changes it the iterates.
+
+Our experiments suggest that even when the game changes at each iteration, OMD dynamics (Algorithms 3 and 4 - Appendix D) are robust enough to closely track the changing Stackelberg equilibria of dynamic Fisher markets. We note that tâtonnement dynamics (Algorithm 3) seem to be more robust than myopic best response dynamics (Algorithm 4), i.e., the distance to equilibrium allocations is smaller at each iteration of tâtonnement. This result is not surprising, as tâtonnement computes a utility-maximizing allocation for the buyers at each time step. Even though Theorems 10 and 11 only provide theoretical guarantees on the robustness of OMD dynamics in dynamic min-max games (with independent strategy sets), it seems like similar theoretical robustness results may be attainable in dynamic min-max Stackelberg games (with dependent strategy sets).
+
+§ 5 CONCLUSION
+
+We began this paper by considering no-regret learning dynamics for min-max Stackelberg games in two settings: a pessimistic setting in which the outer player is a no-regret learner and the inner player best responds, and an optimistic setting in which both players are no-regret learners. For both of these settings, we proved that no-regret learning dynamics converge to a Stackelberg equilibrium of the game. We then specialized the no-regret algorithm employed by the players to online mirror descent (OMD), which yielded two known algorithms, namely max-oracle gradient descent (Jin, Netrapalli, and Jordan 2020) and nested GDA (Goktas and Greenwald 2021) in the pessimistic setting, and a new simultaneous GDA-like algorithm (Nedic and Ozdaglar 2009), which we call Lagrangian GDA, in the optimistic setting. As these algorithms are no-regret learning algorithms, our previous theorems imply convergence to Stackelberg equilibria in $O\left( {1/{\varepsilon }^{2}}\right)$ iterations. Finally, we investigated the robustness of OMD dynamics to perturbations in the parameters of a min-max Stackelberg game. To do so, we analyzed how closely OMD dynamics track Stackelberg equilibria in dynamic min-max Stackelberg games. We proved that in min-max games (with independent strategy sets) OMD dynamics closely track the changing Stackelberg equilibria of a game. As we were not able to extend these theoretical robustness guarantees to min-max Stackelberg games (with dependent strategy sets), we instead ran a series of experiments on dynamic Fisher markets, which are canonical examples of min-max Stackelberg games. Our experiments suggest that OMD dynamics are robust for min-max Stackelberg games so that perhaps the robustness guarantees we have provided for OMD dynamics in min-max games can be extended to min-max Stackelberg games. The theory developed in this paper opens the door to extending the myriad applications of Stackelberg games in AI to incorporating dependent strategy sets. Such models promise to be more expressive, and as a result could provide decision makers with better solutions to problems in security, environmental protection, etc.
\ No newline at end of file
diff --git a/papers/AAAI/AAAI 2022/AAAI 2022 Workshop/AAAI 2022 Workshop AdvML/vKc1mLxBebP/Initial_manuscript_md/Initial_manuscript.md b/papers/AAAI/AAAI 2022/AAAI 2022 Workshop/AAAI 2022 Workshop AdvML/vKc1mLxBebP/Initial_manuscript_md/Initial_manuscript.md
new file mode 100644
index 0000000000000000000000000000000000000000..dc54d9676287dab3292d1645abfb6f69092cd9b2
--- /dev/null
+++ b/papers/AAAI/AAAI 2022/AAAI 2022 Workshop/AAAI 2022 Workshop AdvML/vKc1mLxBebP/Initial_manuscript_md/Initial_manuscript.md
@@ -0,0 +1,213 @@
+# Aliasing coincides with CNNs vulnerability towards adversarial attacks
+
+Anonymous
+
+## Abstract
+
+Many commonly well-performing convolutional neural network models have shown to be susceptible to input data perturbations, indicating a low model robustness. Adversarial attacks are thereby specifically optimized to reveal model weaknesses, by generating small, barely perceivable image perturbations that flip the model prediction. Robustness against attacks can be gained for example by using adversarial examples during training, which effectively reduces the measurable model attackability. In contrast, research on analyzing the source of a model's vulnerability is scarce. In this paper, we analyze adversarially trained, robust models in the context of a specifically suspicious network operation, the downsampling layer, and provide evidence that robust models have learned to downsample more accurately and suffer significantly less from aliasing than baseline models.
+
+## Introduction
+
+Convolutional Neural Networks (CNNs) provide highly accurate predictions in a wide range of applications. Yet, to allow for practical applicability, CNN models should not be fooled by small image perturbations, as they are realized by adversarial attacks (Goodfellow, Shlens, and Szegedy 2015a; Moosavi-Dezfooli, Fawzi, and Frossard 2016; Rony et al. 2019). Such attacks aim to fool the network by perturbing image pixels such that human observers would still easily recognize the correct class label, while the network makes incorrect predictions. Susceptibility to such perturbations is prohibitive for the applicability of CNN models in real world scenarios, as it indicates limited reliability and generalization of the model.
+
+To establish adversarial robustness many sophisticated methods have been developed (Goodfellow, Shlens, and Szegedy 2015a; Rony et al. 2019; Kurakin, Goodfellow, and Bengio 2017; Goodfellow, Shlens, and Szegedy 2015b). Some can defend only against one specific attack (Goodfel-low, Shlens, and Szegedy 2015a) while others propose more general defences against diverse attacks. Another way to protect CNNs against adversarial examples is to detect them. Harder et al. (2021) classify adversarial examples through inspecting each input image and its feature maps in the frequency domain. Similarly, Yin et al. (2020) showed that natural images and adversarial examples differ significantly in their frequency spectra.
+
+
+
+Figure 1: Illustration of down-sampling, with (top right) and without anti-aliasing filter (bottom right) as well as an adversarial example (bottom left). The top left image shows the original, on the top right, this image is correctly down-sampled with an anti-aliasing filter. In the bottom right, no filter is applied, leading to aliasing. The adversarial example (bottom left) shows visually similar artifacts. In this paper, we investigate the role of aliasing for adversarial robustness.
+
+In fact, when considering the architecture of commonly employed CNN models, one could wonder why these models perform so well although they ignore basic sampling theoretic foundations. Concretely, most architectures subsample feature maps without ensuring to sample above the Nyquist rate (Shannon 1949), such that, after each down-sampling operation, spectra of sub-sampled feature maps may overlap with their replica. This is called aliasing and implies that the network should be genuinely unable to fully restore an image from its feature maps. One can only hypothesize that common CNNs learn to (partially) compensate for this effect by learning appropriate filters. Following this line of thought, recently, several works suggest to improve CNNs by including anti-aliasing techniques during down-sampling in CNNs (Zhang 2019; Zou et al. 2020). They aim to make the models more robust against image-translations, such that the class prediction does not suffer from small vertical or horizontal shifts of the content.
+
+---
+
+Copyright © 2022, Association for the Advancement of Artificial Intelligence (www.aaai.org). All rights reserved.
+
+---
+
+In this paper, we further investigate the relationship between adversarial robustness and aliases. While previous works (Yin et al. 2020; Harder et al. 2021; Lorenz et al. 2021) focused on adversarial examples, we systematically analyze potential aliasing effects inside CNNs. Specifically, we compare several recently proposed adversarially robust models to models which result from conventional training schemes in terms of aliasing. We inspect intermediate feature maps before and after the down-sampling operation at inference. Our first observation is that these models indeed fail to sub-sample according to the Nyquist Shannon Theorem (Shannon 1949): we observe severe aliasing. Further, our experiments reveal that adversarially trained networks exhibit less aliasing than standard trained networks, indicating that adversarial training encourages CNNs to learn how to properly down-sample data without severe artifacts.
+
+In summary, our contributions are:
+
+- We introduce a measure for aliasing and show that common CNN down-sampling layers fail to sub-sample the feature maps in a Nyquist-Shannon conform way.
+
+- We analyze various adversarially trained models, that are robust against a strong ensemble of adversarial attacks, AutoAttack (Croce and Hein 2020), and show that they exhibit significantly less aliasing than standard models.
+
+## Aliasing in CNNs
+
+CNNs usually have a pyramidal structure in which the data is progressively sub-sampled in order to aggregate spatial information while the number of channels increases. During sub-sampling, no explicit precautions are taken to avoid aliases, which arise from under-sampling. Specifically, when sub-sampling with stride 2, any frequency larger than $N/2$ , where $N$ is the size of the original data, will cause pathological overlaps in the frequency spectra. Those overlaps in the frequency spectra cause ambiguities such that high frequency components appear as low frequency components. Hence, local image perturbations can become indistinguishable from global manipulations.
+
+## Aliasing Metric
+
+To measure the possible amount of aliasing appearing after down-sampling we compare each down-sampled feature map in the Fourier domain with its aliasing-free counterpart. To this end, we consider a feature map $f\left( x\right)$ of size ${2N} \times {2N}$ before down-sampling. We compute an "aliasing-free" down-sampling by extracting the $N$ lowest frequencies along both axes in Fourier space. W.l.o.G., we consider specifically down-sampling operations by strided convolutions, since these are predominantly used in adversarially robust models (Zagoruyko and Komodakis 2017).
+
+In each strided convolution, the input feature map $f\left( x\right)$ is convolved with the learned weights $w$ and downsampled by strides, thus potentially introducing frequency replica (i.e. aliases) in the downsampled signal ${\widehat{f}}_{s2}$ .
+
+$$
+{\widehat{f}}_{s2} = f\left( x\right) * g\left( {w,2}\right) \tag{1}
+$$
+
+To measure the amount of aliasing, we explicitly construct feature map frequency representations without such aliases. Therefore, the original feature map $f\left( x\right)$ is convolved with the learned weights $w$ of the strided convolution without applying the stride $g\left( {w,1}\right)$ to obtain ${\widehat{f}}_{s1}$ .
+
+$$
+{\widehat{f}}_{s1} = f\left( x\right) * g\left( {w,1}\right) \tag{2}
+$$
+
+Afterwards the 2D FFT of the new feature maps ${\widehat{f}}_{s2}$ is computed, which we denote ${F}_{s2}$ .
+
+$$
+{F}_{s2}\left( {k, l}\right) = \frac{1}{{N}^{2}}\mathop{\sum }\limits_{{m = 0}}^{{N - 1}}\mathop{\sum }\limits_{{n = 0}}^{{N - 1}}{\widehat{f}}_{s2}\left( {m, n}\right) {e}^{-{2\pi j}\left( {\frac{k}{M}m + \frac{l}{N}n}\right) }, \tag{3}
+$$
+
+for $k, l = 0,\ldots , N - 1$ . For the non-down-sampled feature maps ${\widehat{f}}_{s1}$ , we proceed similarly and compute for $k, l =$ $0,\ldots ,2 \cdot N - 1$
+
+$$
+{F}_{s1}^{ \uparrow }\left( {k, l}\right) = \frac{1}{4{N}^{2}}\mathop{\sum }\limits_{{m = 0}}^{{{2N} - 1}}\mathop{\sum }\limits_{{n = 0}}^{{{2N} - 1}}{\widehat{f}}_{s1}\left( {m, n}\right) {e}^{-{2\pi j}\left( {\frac{k}{2M}m + \frac{l}{2N}n}\right) }.
+$$
+
+(4)
+
+The aliasing free version ${F}_{s1}$ can be obtained by setting all frequencies above the Nyquist rate to zero before down-sampling,
+
+$$
+{F}_{s1}^{ \uparrow }\left( {k, l}\right) = 0 \tag{5}
+$$
+
+for $k \in \left\lbrack {N/2,{3N}/2}\right\rbrack$ and for $l \in \in \left\lbrack {N/2,{3N}/2}\right\rbrack$ . Then the down-sampled version in the frequency domain corresponds to extracting the four corners of ${F}_{s1}^{ \uparrow }$ and reassembling them as shown in Figure 2,
+
+$$
+{F}_{s1}\left( {k, l}\right) = {F}_{s1}^{ \uparrow }\left( {k, l}\right) \;\text{ for }k, l = 0,\ldots , N/2
+$$
+
+$$
+{F}_{s1}\left( {k, l}\right) = {F}_{s1}^{ \uparrow }\left( {k + N, l}\right) \;\text{ for }\;k = N/2,\ldots , N
+$$
+
+$$
+\text{and}l = 0,\ldots , N/2
+$$
+
+$$
+{F}_{s1}\left( {k, l}\right) = {F}_{s1}^{ \uparrow }\left( {k, l + N}\right) \;\text{ for }\;k = 0,\ldots , N/2
+$$
+
+$$
+\text{and}l = N/2,\ldots , N
+$$
+
+$$
+{F}_{s1}\left( {k, l}\right) = {F}_{s1}^{ \uparrow }\left( {k + N, l + N}\right) \;\text{ for }k, l = N/2,\ldots , N
+$$
+
+(6)
+
+This way we guarantee that there are no overlaps, i.e. aliases, in the frequency spectra. Figure 2 illustrates the computing process of the aliasing free down-sampling in the frequency domain. The aliasing free feature map can be compared to the actual feature map in the frequency domain to measure the degree of aliasing. The full procedure is shown in Figure 3 , where we start on the left with the original feature map. Then we obtain the two down-sampled versions (with and without aliases) and get the difference between both by taking the ${L}_{1}$ norm.
+
+The overall aliasing metric ${AM}$ for a down-sampling operation is calculated by taking the ${L}_{1}$ distance between downsampled and alias-free feature maps ${f}_{k}$ in the Fourier domain, averaged over $\mathrm{K}$ generated feature maps,
+
+$$
+{AM} = \frac{1}{K}\mathop{\sum }\limits_{{k = 0}}^{K}\left| {{F}_{{s1}, k} - {F}_{{s2}, k}}\right| . \tag{7}
+$$
+
+The proposed ${AM}$ measure is zero if aliasing is visible in none of the down-sampled feature maps, i.e. if sampling has been performed above the Nyquist rate. Whenever ${AM}$ is greater than 0 , this is not the case and we should, from a theoretic point of view, expect the model to be easy to attack since it can not reliably distinguish between fine details and coarse input structures.
+
+
+
+Figure 2: Step by step computation of the aliasing free version of a feature map. The left image shows the magnitude of the Fourier representation of a feature map with the zero-frequency in the upper left corner, i.e. high frequencies are in the center. Alias-free downsampling suppresses high frequencies prior to sampling. This can be implemented efficiently in the Fourier domain by cropping and reassembling the low-frequency regions of the Fourier representations, i.e. its four corners. Aliasing would correspond to folding the deleted high frequency components into the constructed representation.
+
+
+
+Figure 3: FFT (Fast Fourier Transformation) of a feature map in the original resolution (left). This feature map is downsampled by striding with a factor of two after aliasing suppression (middle left) and with aliasing (middle right). The difference between the original and aliasing-free FFT of the down-sampled feature map (right).
+
+## Experiments
+
+We conducted an extensive analysis of already existing ad-versarially robust models trained on CIFAR-10 (Krizhevsky 2012) with two different architectures, namely WideResNet- 28-10 (WRN-28-10) (Zagoruyko and Komodakis 2017) and Preact ResNet-18 (He et al. 2016). Both architectures are commonly supported by many adversarial training approaches. As baseline, we trained a plain WRN-28-10 and Preact ResNet-18, both with similar training schemes. All adversarially trained networks are pre-trained models provided by RobustBench (Croce et al. 2020).
+
+The WRN-28-10 networks have four operations in which down-sampling is performed. These operations are located in the second and third block of the network. In comparison, the Preact ResNet-18 networks have six down-sampling operations, located in the second, third and fourth layers of the network.
+
+Both architectures have similar building blocks and the key operations including down-sampling are shown abstractly in the appendix in Figure 6. Each block starts with a convolution with stride two followed by additional operations like ReLu and convolutions with stride one. The characteristic skip connection of ResNet architectures also needs to be implemented with stride two if down-sampling is applied in the according block. Consequently, we need to analyze all down-sampling units and skip connections before they are summed up to form the output feature map.
+
+WideResNet 28-10 In the following, differently trained WRN-28-10 networks are compared in terms of their robust accuracy against AutoAttack (Croce and Hein 2020) and the amount of aliasing in their down-sampling layer. The training procedure of the baseline can be found in the appendix.
+
+Figure 4 indicates significant differences between adver-sarially trained and standard trained networks. First, the standard trained networks are not able to reach any robust accuracy, meaning their accuracy under adversarial attacks is equal to zero. Second, and this is most interesting for our investigation, standard trained networks exhibit much more aliasing during their down-sampling layer than ad-versarially trained networks. Through all layers and operations in which down-sampling is applied, the adversarially trained networks (blue dots) have much higher robust accuracy and much less aliasing compared to the standard trained networks. Additionally, we can observe that the amount of aliasing in the second layer is much higher than in the third layer. This can be explained by the different feature map sizes in the two layers as we calculate the absolute ${L}_{1}$ norm.
+
+When comparing the conventionally trained network against each other it can be seen that also the specific training scheme used for training the network can have an influence on the amount of aliasing of the network. Concretely, the standard baseline model provided by Robust-Bench (Croce et al. 2020) exhibits less aliasing than the one trained by us. Unfortunately, there is no further information about the exact training schedule from RobustBench, such that we can not make any assumptions on the interplay between model hyperparameters and aliasing.
+
+
+
+Figure 4: Adversarial Robustness versus Aliasing exemplary evaluated on different pre-trained WRN-28-10 models from RobustBench (Croce et al. 2020) as well as two baseline models, one from RobustBench (Standard RB) and one trained by us (Baseline). All blue dots represent adversari-ally trained networks for the purpose of clarity we marked three popular models from Carmon et al. (2019), Wang et al. (2020) and Hendrycks, Lee, and Mazeika (2019) by name.
+
+Preact ResNet-18 We conducted the same measurements for the Preact ResNet-18 as we did for the WRN-28-10 and used the same training procedure described in the appendix. Additionally, we needed to account for one more layer with two additional down-sampling operations.
+
+The overall results, presented in Figure 5, are similar to the ones for the WRN-28-10 networks, most adversarially trained networks exhibit much less aliasing and higher robustness than conventionally trained ones. Yet, the additional down-sampling layer allows one further observation. While the absolute aliasing metric is overall lower, the robust networks reduce the aliasing predominantly in the earlier layers, the second and third layers. The aliasing in the fourth layer of adversarially robust models is not significantly different from the aliasing in conventionally trained models in the same layer.
+
+## Discussion
+
+Our experiments reveal that common CNNs fail to subsample their feature maps in a Nyquist-Shannon conform way and consequently introduce aliasing artifacts. Further, we can give strong evidence that aliasing and adversarial robustness are highly related. All evaluated robust models exhibit significantly less aliasing than standard trained models.
+
+After the application of down-sampling operations in standard CNNs all feature maps suffer from aliasing artifacts occurring due to insufficient sub-sampling.
+
+Adversarially trained networks exhibit significantly less aliasing in their feature maps than standard trained networks with the same architecture. As shown previously this is valid for different model architectures and training schemes, especially in the early layers, closer to the input layer. It raises the question whether models with a low amount of aliasing are necessarily more robust. It further entails the question whether there are additional factors that are relevant in this context such as padding techniques, for example. These aspects will be subject to future research.
+
+
+
+Figure 5: Adversarial robustness versus aliasing exemplary evaluated on different pre-trained Preact ResNet-18 models. The blue dots represent adversarial trained networks, trained with the training schemes of Wong, Rice, and Kolter (2020), Rice, Wong, and Kolter (2020) and Sehwag et al. (2021) provided by RobustBench (Croce et al. 2020). The orange dot is the baseline, trained by us without adversarial training.
+
+## Conclusion
+
+Concluding, we were able to show strong evidence that aliasing and adversarial robustness of CNNs are highly correlated. We hypothesize that aliasing is one of the main underlying factors that lead to the vulnerability of CNNs. Recent methods to increase model robustness rather heal the symptoms of the underlying problem than investigate its origins. To overcome this challenge we might need to start thinking about CNNs in a more signal processing manner and account for basic principles from this field, like the Nyquist-Shannon theorem, which gives us clear instructions on how to prevent aliasing. Still, it is not straight forward to incorporate this knowledge into the architecture and structure of common CNN designs. We aim to give a new and more traditional perspective on CNNs to help improve their performance and reliability to enable their application in real world use cases.
+
+## References
+
+Carmon, Y.; Raghunathan, A.; Schmidt, L.; Liang, P.; and Duchi, J. C. 2019. Unlabeled Data Improves Adversarial Robustness. arXiv:1905.13736.
+
+Croce, F.; Andriushchenko, M.; Sehwag, V.; Flammarion, N.; Chiang, M.; Mittal, P.; and Hein, M. 2020. Robust-Bench: a standardized adversarial robustness benchmark. arXiv preprint arXiv:2010.09670.
+
+Croce, F.; and Hein, M. 2020. Reliable evaluation of adversarial robustness with an ensemble of diverse parameter-free attacks. In ${ICML}$ .
+
+Goodfellow, I. J.; Shlens, J.; and Szegedy, C. 2015a. Explaining and Harnessing Adversarial Examples. arXiv:1412.6572.
+
+Goodfellow, I. J.; Shlens, J.; and Szegedy, C. 2015b. Explaining and Harnessing Adversarial Examples. arXiv:1412.6572.
+
+Harder, P.; Pfreundt, F.-J.; Keuper, M.; and Keuper, J. 2021. SpectralDefense: Detecting Adversarial Attacks on CNNs in the Fourier Domain. arXiv:2103.03000.
+
+He, K.; Zhang, X.; Ren, S.; and Sun, J. 2016. Identity Mappings in Deep Residual Networks. arXiv:1603.05027.
+
+Hendrycks, D.; Lee, K.; and Mazeika, M. 2019. Using PreTraining Can Improve Model Robustness and Uncertainty. arXiv:1901.09960.
+
+Krizhevsky, A. 2012. Learning Multiple Layers of Features from Tiny Images. University of Toronto.
+
+Kurakin, A.; Goodfellow, I.; and Bengio, S. 2017. Adversarial Machine Learning at Scale. arXiv:1611.01236.
+
+Lorenz, P.; Harder, P.; Straßel, D.; Keuper, M.; and Keuper, J. 2021. Detecting AutoAttack Perturbations in the Frequency Domain. In ICML 2021 Workshop on Adversarial Machine Learning.
+
+Moosavi-Dezfooli, S.-M.; Fawzi, A.; and Frossard, P. 2016. DeepFool: a simple and accurate method to fool deep neural networks.
+
+Rice, L.; Wong, E.; and Kolter, J. Z. 2020. Overfitting in adversarially robust deep learning. arXiv:2002.11569.
+
+Rony, J.; Hafemann, L. G.; Oliveira, L. S.; Ayed, I. B.; Sabourin, R.; and Granger, E. 2019. Decoupling Direction and Norm for Efficient Gradient-Based L2 Adversarial Attacks and Defenses.
+
+Sehwag, V.; Mahloujifar, S.; Handina, T.; Dai, S.; Xiang, C.; Chiang, M.; and Mittal, P. 2021. Improving Adversarial Robustness Using Proxy Distributions. arXiv:2104.09425.
+
+Shannon, C. 1949. Communication in the Presence of Noise. Proceedings of the IRE, 37(1): 10-21.
+
+Wang, Y.; Zou, D.; Yi, J.; Bailey, J.; Ma, X.; and Gu, Q. 2020. Improving Adversarial Robustness Requires Revisiting Misclassified Examples. In International Conference on Learning Representations.
+
+Wong, E.; Rice, L.; and Kolter, J. Z. 2020. Fast is better than free: Revisiting adversarial training. arXiv:2001.03994.
+
+Yin, D.; Lopes, R. G.; Shlens, J.; Cubuk, E. D.; and Gilmer, J. 2020. A Fourier Perspective on Model Robustness in Computer Vision. arXiv:1906.08988.
+
+Zagoruyko, S.; and Komodakis, N. 2017. Wide Residual Networks. arXiv:1605.07146.
+
+Zhang, R. 2019. Making Convolutional Networks Shift-Invariant Again. arXiv:1904.11486.
+
+Zou, X.; Xiao, F.; Yu, Z.; and Lee, Y. J. 2020. Delving Deeper into Anti-aliasing in ConvNets. In ${BMVC}$ .
+
+## A1: Downsampling Block Preact ResNet
+
+
+
+Figure 6: Abstract Illustration of a building block in Preact ResNet-18 and WRN-28-10. The first operation in a block is a convolution. This convolution is executed with a stride of either one or two. For a stride of one (left) the shortcut simply passes the identity of the feature maps forward. If the first convolution is done with a stride of two, the shortcut needs to have a stride of two (right) too, to guarantee that both representations can be added at the end of the building block.
+
+## A2: Trainings Procedure
+
+The baseline models for the Preact ResNet-18 and the WRN- 28-10 are both the same trained with the same schedule. Each model is trained with 200 epochs, a batch size of 512, cross entropy loss and stochastic gradient descent (SGD) with an adaptive learning rate starting by 0.1 and reducing it at 100 and 150 epochs by a factor of 10 , a momentum of 0.9 and a weight-decay of $5\mathrm{e} - 4$ .
\ No newline at end of file
diff --git a/papers/AAAI/AAAI 2022/AAAI 2022 Workshop/AAAI 2022 Workshop AdvML/vKc1mLxBebP/Initial_manuscript_tex/Initial_manuscript.tex b/papers/AAAI/AAAI 2022/AAAI 2022 Workshop/AAAI 2022 Workshop AdvML/vKc1mLxBebP/Initial_manuscript_tex/Initial_manuscript.tex
new file mode 100644
index 0000000000000000000000000000000000000000..34d719825be481ff0243ccd6cf3649325cecf0a4
--- /dev/null
+++ b/papers/AAAI/AAAI 2022/AAAI 2022 Workshop/AAAI 2022 Workshop AdvML/vKc1mLxBebP/Initial_manuscript_tex/Initial_manuscript.tex
@@ -0,0 +1,153 @@
+§ ALIASING COINCIDES WITH CNNS VULNERABILITY TOWARDS ADVERSARIAL ATTACKS
+
+Anonymous
+
+§ ABSTRACT
+
+Many commonly well-performing convolutional neural network models have shown to be susceptible to input data perturbations, indicating a low model robustness. Adversarial attacks are thereby specifically optimized to reveal model weaknesses, by generating small, barely perceivable image perturbations that flip the model prediction. Robustness against attacks can be gained for example by using adversarial examples during training, which effectively reduces the measurable model attackability. In contrast, research on analyzing the source of a model's vulnerability is scarce. In this paper, we analyze adversarially trained, robust models in the context of a specifically suspicious network operation, the downsampling layer, and provide evidence that robust models have learned to downsample more accurately and suffer significantly less from aliasing than baseline models.
+
+§ INTRODUCTION
+
+Convolutional Neural Networks (CNNs) provide highly accurate predictions in a wide range of applications. Yet, to allow for practical applicability, CNN models should not be fooled by small image perturbations, as they are realized by adversarial attacks (Goodfellow, Shlens, and Szegedy 2015a; Moosavi-Dezfooli, Fawzi, and Frossard 2016; Rony et al. 2019). Such attacks aim to fool the network by perturbing image pixels such that human observers would still easily recognize the correct class label, while the network makes incorrect predictions. Susceptibility to such perturbations is prohibitive for the applicability of CNN models in real world scenarios, as it indicates limited reliability and generalization of the model.
+
+To establish adversarial robustness many sophisticated methods have been developed (Goodfellow, Shlens, and Szegedy 2015a; Rony et al. 2019; Kurakin, Goodfellow, and Bengio 2017; Goodfellow, Shlens, and Szegedy 2015b). Some can defend only against one specific attack (Goodfel-low, Shlens, and Szegedy 2015a) while others propose more general defences against diverse attacks. Another way to protect CNNs against adversarial examples is to detect them. Harder et al. (2021) classify adversarial examples through inspecting each input image and its feature maps in the frequency domain. Similarly, Yin et al. (2020) showed that natural images and adversarial examples differ significantly in their frequency spectra.
+
+ < g r a p h i c s >
+
+Figure 1: Illustration of down-sampling, with (top right) and without anti-aliasing filter (bottom right) as well as an adversarial example (bottom left). The top left image shows the original, on the top right, this image is correctly down-sampled with an anti-aliasing filter. In the bottom right, no filter is applied, leading to aliasing. The adversarial example (bottom left) shows visually similar artifacts. In this paper, we investigate the role of aliasing for adversarial robustness.
+
+In fact, when considering the architecture of commonly employed CNN models, one could wonder why these models perform so well although they ignore basic sampling theoretic foundations. Concretely, most architectures subsample feature maps without ensuring to sample above the Nyquist rate (Shannon 1949), such that, after each down-sampling operation, spectra of sub-sampled feature maps may overlap with their replica. This is called aliasing and implies that the network should be genuinely unable to fully restore an image from its feature maps. One can only hypothesize that common CNNs learn to (partially) compensate for this effect by learning appropriate filters. Following this line of thought, recently, several works suggest to improve CNNs by including anti-aliasing techniques during down-sampling in CNNs (Zhang 2019; Zou et al. 2020). They aim to make the models more robust against image-translations, such that the class prediction does not suffer from small vertical or horizontal shifts of the content.
+
+Copyright © 2022, Association for the Advancement of Artificial Intelligence (www.aaai.org). All rights reserved.
+
+In this paper, we further investigate the relationship between adversarial robustness and aliases. While previous works (Yin et al. 2020; Harder et al. 2021; Lorenz et al. 2021) focused on adversarial examples, we systematically analyze potential aliasing effects inside CNNs. Specifically, we compare several recently proposed adversarially robust models to models which result from conventional training schemes in terms of aliasing. We inspect intermediate feature maps before and after the down-sampling operation at inference. Our first observation is that these models indeed fail to sub-sample according to the Nyquist Shannon Theorem (Shannon 1949): we observe severe aliasing. Further, our experiments reveal that adversarially trained networks exhibit less aliasing than standard trained networks, indicating that adversarial training encourages CNNs to learn how to properly down-sample data without severe artifacts.
+
+In summary, our contributions are:
+
+ * We introduce a measure for aliasing and show that common CNN down-sampling layers fail to sub-sample the feature maps in a Nyquist-Shannon conform way.
+
+ * We analyze various adversarially trained models, that are robust against a strong ensemble of adversarial attacks, AutoAttack (Croce and Hein 2020), and show that they exhibit significantly less aliasing than standard models.
+
+§ ALIASING IN CNNS
+
+CNNs usually have a pyramidal structure in which the data is progressively sub-sampled in order to aggregate spatial information while the number of channels increases. During sub-sampling, no explicit precautions are taken to avoid aliases, which arise from under-sampling. Specifically, when sub-sampling with stride 2, any frequency larger than $N/2$ , where $N$ is the size of the original data, will cause pathological overlaps in the frequency spectra. Those overlaps in the frequency spectra cause ambiguities such that high frequency components appear as low frequency components. Hence, local image perturbations can become indistinguishable from global manipulations.
+
+§ ALIASING METRIC
+
+To measure the possible amount of aliasing appearing after down-sampling we compare each down-sampled feature map in the Fourier domain with its aliasing-free counterpart. To this end, we consider a feature map $f\left( x\right)$ of size ${2N} \times {2N}$ before down-sampling. We compute an "aliasing-free" down-sampling by extracting the $N$ lowest frequencies along both axes in Fourier space. W.l.o.G., we consider specifically down-sampling operations by strided convolutions, since these are predominantly used in adversarially robust models (Zagoruyko and Komodakis 2017).
+
+In each strided convolution, the input feature map $f\left( x\right)$ is convolved with the learned weights $w$ and downsampled by strides, thus potentially introducing frequency replica (i.e. aliases) in the downsampled signal ${\widehat{f}}_{s2}$ .
+
+$$
+{\widehat{f}}_{s2} = f\left( x\right) * g\left( {w,2}\right) \tag{1}
+$$
+
+To measure the amount of aliasing, we explicitly construct feature map frequency representations without such aliases. Therefore, the original feature map $f\left( x\right)$ is convolved with the learned weights $w$ of the strided convolution without applying the stride $g\left( {w,1}\right)$ to obtain ${\widehat{f}}_{s1}$ .
+
+$$
+{\widehat{f}}_{s1} = f\left( x\right) * g\left( {w,1}\right) \tag{2}
+$$
+
+Afterwards the 2D FFT of the new feature maps ${\widehat{f}}_{s2}$ is computed, which we denote ${F}_{s2}$ .
+
+$$
+{F}_{s2}\left( {k,l}\right) = \frac{1}{{N}^{2}}\mathop{\sum }\limits_{{m = 0}}^{{N - 1}}\mathop{\sum }\limits_{{n = 0}}^{{N - 1}}{\widehat{f}}_{s2}\left( {m,n}\right) {e}^{-{2\pi j}\left( {\frac{k}{M}m + \frac{l}{N}n}\right) }, \tag{3}
+$$
+
+for $k,l = 0,\ldots ,N - 1$ . For the non-down-sampled feature maps ${\widehat{f}}_{s1}$ , we proceed similarly and compute for $k,l =$ $0,\ldots ,2 \cdot N - 1$
+
+$$
+{F}_{s1}^{ \uparrow }\left( {k,l}\right) = \frac{1}{4{N}^{2}}\mathop{\sum }\limits_{{m = 0}}^{{{2N} - 1}}\mathop{\sum }\limits_{{n = 0}}^{{{2N} - 1}}{\widehat{f}}_{s1}\left( {m,n}\right) {e}^{-{2\pi j}\left( {\frac{k}{2M}m + \frac{l}{2N}n}\right) }.
+$$
+
+(4)
+
+The aliasing free version ${F}_{s1}$ can be obtained by setting all frequencies above the Nyquist rate to zero before down-sampling,
+
+$$
+{F}_{s1}^{ \uparrow }\left( {k,l}\right) = 0 \tag{5}
+$$
+
+for $k \in \left\lbrack {N/2,{3N}/2}\right\rbrack$ and for $l \in \in \left\lbrack {N/2,{3N}/2}\right\rbrack$ . Then the down-sampled version in the frequency domain corresponds to extracting the four corners of ${F}_{s1}^{ \uparrow }$ and reassembling them as shown in Figure 2,
+
+$$
+{F}_{s1}\left( {k,l}\right) = {F}_{s1}^{ \uparrow }\left( {k,l}\right) \;\text{ for }k,l = 0,\ldots ,N/2
+$$
+
+$$
+{F}_{s1}\left( {k,l}\right) = {F}_{s1}^{ \uparrow }\left( {k + N,l}\right) \;\text{ for }\;k = N/2,\ldots ,N
+$$
+
+$$
+\text{ and }l = 0,\ldots ,N/2
+$$
+
+$$
+{F}_{s1}\left( {k,l}\right) = {F}_{s1}^{ \uparrow }\left( {k,l + N}\right) \;\text{ for }\;k = 0,\ldots ,N/2
+$$
+
+$$
+\text{ and }l = N/2,\ldots ,N
+$$
+
+$$
+{F}_{s1}\left( {k,l}\right) = {F}_{s1}^{ \uparrow }\left( {k + N,l + N}\right) \;\text{ for }k,l = N/2,\ldots ,N
+$$
+
+(6)
+
+This way we guarantee that there are no overlaps, i.e. aliases, in the frequency spectra. Figure 2 illustrates the computing process of the aliasing free down-sampling in the frequency domain. The aliasing free feature map can be compared to the actual feature map in the frequency domain to measure the degree of aliasing. The full procedure is shown in Figure 3, where we start on the left with the original feature map. Then we obtain the two down-sampled versions (with and without aliases) and get the difference between both by taking the ${L}_{1}$ norm.
+
+The overall aliasing metric ${AM}$ for a down-sampling operation is calculated by taking the ${L}_{1}$ distance between downsampled and alias-free feature maps ${f}_{k}$ in the Fourier domain, averaged over $\mathrm{K}$ generated feature maps,
+
+$$
+{AM} = \frac{1}{K}\mathop{\sum }\limits_{{k = 0}}^{K}\left| {{F}_{{s1},k} - {F}_{{s2},k}}\right| . \tag{7}
+$$
+
+The proposed ${AM}$ measure is zero if aliasing is visible in none of the down-sampled feature maps, i.e. if sampling has been performed above the Nyquist rate. Whenever ${AM}$ is greater than 0, this is not the case and we should, from a theoretic point of view, expect the model to be easy to attack since it can not reliably distinguish between fine details and coarse input structures.
+
+ < g r a p h i c s >
+
+Figure 2: Step by step computation of the aliasing free version of a feature map. The left image shows the magnitude of the Fourier representation of a feature map with the zero-frequency in the upper left corner, i.e. high frequencies are in the center. Alias-free downsampling suppresses high frequencies prior to sampling. This can be implemented efficiently in the Fourier domain by cropping and reassembling the low-frequency regions of the Fourier representations, i.e. its four corners. Aliasing would correspond to folding the deleted high frequency components into the constructed representation.
+
+ < g r a p h i c s >
+
+Figure 3: FFT (Fast Fourier Transformation) of a feature map in the original resolution (left). This feature map is downsampled by striding with a factor of two after aliasing suppression (middle left) and with aliasing (middle right). The difference between the original and aliasing-free FFT of the down-sampled feature map (right).
+
+§ EXPERIMENTS
+
+We conducted an extensive analysis of already existing ad-versarially robust models trained on CIFAR-10 (Krizhevsky 2012) with two different architectures, namely WideResNet- 28-10 (WRN-28-10) (Zagoruyko and Komodakis 2017) and Preact ResNet-18 (He et al. 2016). Both architectures are commonly supported by many adversarial training approaches. As baseline, we trained a plain WRN-28-10 and Preact ResNet-18, both with similar training schemes. All adversarially trained networks are pre-trained models provided by RobustBench (Croce et al. 2020).
+
+The WRN-28-10 networks have four operations in which down-sampling is performed. These operations are located in the second and third block of the network. In comparison, the Preact ResNet-18 networks have six down-sampling operations, located in the second, third and fourth layers of the network.
+
+Both architectures have similar building blocks and the key operations including down-sampling are shown abstractly in the appendix in Figure 6. Each block starts with a convolution with stride two followed by additional operations like ReLu and convolutions with stride one. The characteristic skip connection of ResNet architectures also needs to be implemented with stride two if down-sampling is applied in the according block. Consequently, we need to analyze all down-sampling units and skip connections before they are summed up to form the output feature map.
+
+WideResNet 28-10 In the following, differently trained WRN-28-10 networks are compared in terms of their robust accuracy against AutoAttack (Croce and Hein 2020) and the amount of aliasing in their down-sampling layer. The training procedure of the baseline can be found in the appendix.
+
+Figure 4 indicates significant differences between adver-sarially trained and standard trained networks. First, the standard trained networks are not able to reach any robust accuracy, meaning their accuracy under adversarial attacks is equal to zero. Second, and this is most interesting for our investigation, standard trained networks exhibit much more aliasing during their down-sampling layer than ad-versarially trained networks. Through all layers and operations in which down-sampling is applied, the adversarially trained networks (blue dots) have much higher robust accuracy and much less aliasing compared to the standard trained networks. Additionally, we can observe that the amount of aliasing in the second layer is much higher than in the third layer. This can be explained by the different feature map sizes in the two layers as we calculate the absolute ${L}_{1}$ norm.
+
+When comparing the conventionally trained network against each other it can be seen that also the specific training scheme used for training the network can have an influence on the amount of aliasing of the network. Concretely, the standard baseline model provided by Robust-Bench (Croce et al. 2020) exhibits less aliasing than the one trained by us. Unfortunately, there is no further information about the exact training schedule from RobustBench, such that we can not make any assumptions on the interplay between model hyperparameters and aliasing.
+
+ < g r a p h i c s >
+
+Figure 4: Adversarial Robustness versus Aliasing exemplary evaluated on different pre-trained WRN-28-10 models from RobustBench (Croce et al. 2020) as well as two baseline models, one from RobustBench (Standard RB) and one trained by us (Baseline). All blue dots represent adversari-ally trained networks for the purpose of clarity we marked three popular models from Carmon et al. (2019), Wang et al. (2020) and Hendrycks, Lee, and Mazeika (2019) by name.
+
+Preact ResNet-18 We conducted the same measurements for the Preact ResNet-18 as we did for the WRN-28-10 and used the same training procedure described in the appendix. Additionally, we needed to account for one more layer with two additional down-sampling operations.
+
+The overall results, presented in Figure 5, are similar to the ones for the WRN-28-10 networks, most adversarially trained networks exhibit much less aliasing and higher robustness than conventionally trained ones. Yet, the additional down-sampling layer allows one further observation. While the absolute aliasing metric is overall lower, the robust networks reduce the aliasing predominantly in the earlier layers, the second and third layers. The aliasing in the fourth layer of adversarially robust models is not significantly different from the aliasing in conventionally trained models in the same layer.
+
+§ DISCUSSION
+
+Our experiments reveal that common CNNs fail to subsample their feature maps in a Nyquist-Shannon conform way and consequently introduce aliasing artifacts. Further, we can give strong evidence that aliasing and adversarial robustness are highly related. All evaluated robust models exhibit significantly less aliasing than standard trained models.
+
+After the application of down-sampling operations in standard CNNs all feature maps suffer from aliasing artifacts occurring due to insufficient sub-sampling.
+
+Adversarially trained networks exhibit significantly less aliasing in their feature maps than standard trained networks with the same architecture. As shown previously this is valid for different model architectures and training schemes, especially in the early layers, closer to the input layer. It raises the question whether models with a low amount of aliasing are necessarily more robust. It further entails the question whether there are additional factors that are relevant in this context such as padding techniques, for example. These aspects will be subject to future research.
+
+ < g r a p h i c s >
+
+Figure 5: Adversarial robustness versus aliasing exemplary evaluated on different pre-trained Preact ResNet-18 models. The blue dots represent adversarial trained networks, trained with the training schemes of Wong, Rice, and Kolter (2020), Rice, Wong, and Kolter (2020) and Sehwag et al. (2021) provided by RobustBench (Croce et al. 2020). The orange dot is the baseline, trained by us without adversarial training.
+
+§ CONCLUSION
+
+Concluding, we were able to show strong evidence that aliasing and adversarial robustness of CNNs are highly correlated. We hypothesize that aliasing is one of the main underlying factors that lead to the vulnerability of CNNs. Recent methods to increase model robustness rather heal the symptoms of the underlying problem than investigate its origins. To overcome this challenge we might need to start thinking about CNNs in a more signal processing manner and account for basic principles from this field, like the Nyquist-Shannon theorem, which gives us clear instructions on how to prevent aliasing. Still, it is not straight forward to incorporate this knowledge into the architecture and structure of common CNN designs. We aim to give a new and more traditional perspective on CNNs to help improve their performance and reliability to enable their application in real world use cases.
\ No newline at end of file
diff --git a/papers/AAAI/AAAI 2022/AAAI 2022 Workshop/AAAI 2022 Workshop AdvML/wGkmGrDsco8/Initial_manuscript_md/Initial_manuscript.md b/papers/AAAI/AAAI 2022/AAAI 2022 Workshop/AAAI 2022 Workshop AdvML/wGkmGrDsco8/Initial_manuscript_md/Initial_manuscript.md
new file mode 100644
index 0000000000000000000000000000000000000000..a93c4b3908e9b991d710594e602f3b2cabf74197
--- /dev/null
+++ b/papers/AAAI/AAAI 2022/AAAI 2022 Workshop/AAAI 2022 Workshop AdvML/wGkmGrDsco8/Initial_manuscript_md/Initial_manuscript.md
@@ -0,0 +1,460 @@
+# Saliency Diversified Deep Ensemble for Robustness to Adversaries
+
+First Author Name, ${}^{1}$ Second Author Name, ${}^{2}$ Third Author Name ${}^{1}$
+
+${}^{1}$ Affiliation 1
+
+firstAuthor@affiliation1.com, secondAuthor@affilation2.com, thirdAuthor@affiliation1.com
+
+## Abstract
+
+Deep learning models have shown incredible performance on numerous image recognition, classification, and reconstruction tasks. Although very appealing and valuable due to their predictive capabilities, one common threat remains challenging to resolve. A specifically trained attacker can introduce malicious input perturbations to fool the network, thus causing potentially harmful mispredictions. Moreover, these attacks can succeed when the adversary has full access to the target model (white-box) and even when such access is limited (black-box setting). The ensemble of models can protect against such attacks but might be brittle under shared vulnerabilities in its members (attack transferability). To that end, this work proposes a novel diversity-promoting learning approach for the deep ensembles. The idea is to promote saliency map diversity (SMD) on ensemble members to prevent the attacker from targeting all ensemble members at once by introducing an additional term in our learning objective. During training, this helps us minimize the alignment between model saliencies to reduce shared member vulnerabilities and, thus, increase ensemble robustness to adversaries. We empirically show a reduced transferability between ensemble members and improved performance compared to the state-of-the-art ensemble defense against medium and high-strength white-box attacks. In addition, we demonstrate that our approach combined with existing methods outperforms state-of-the-art ensemble algorithms for defense under white-box and black-box attacks.
+
+## 1 Introduction
+
+Nowadays, deep learning models have shown incredible performance on numerous image recognition, classification, and reconstruction tasks (Krizhevsky, Sutskever, and Hinton 2012; Lee et al. 2015; LeCun, Bengio, and Hinton 2015; Chen et al. 2020). Due to their great predictive capabilities, they have found widespread use across many domains (Szegedy et al. 2016; Devlin et al. 2019; Deng, Hinton, and Kingsbury 2013). Although deep learning models are very appealing for many interesting tasks, their robustness to adversarial attacks remains a challenging problem to solve. A specifically trained attacker can introduce malicious input perturbations to fool the network, thus causing potentially harmful (Goodfellow, Shlens, and Szegedy 2015; Madry et al. 2018) mispredictions. Moreover, these attacks can succeed when the adversary has full access to the target model (white-box) (Athalye and Carlini 2018) and even when such access is limited (black-box) (Papernot et al. 2017), posing a hurdle in security- and trust-sensitive application domains.
+
+
+
+Figure 1: Left. An illustration of the proposed learning scheme for saliency-based diversification of deep ensemble consisting of 3 members. We use the cross-entropy losses ${\mathcal{L}}_{m}\left( x\right) , m \in \{ 1,2,3\}$ and regularization ${\mathcal{L}}_{SMD}\left( x\right)$ for saliency-based diversification. Right. An example of saliency maps for members of naively learned ensemble and learned ensemble with our approach. Red and blue pixels represent positive and negative saliency values respectively.
+
+The ensemble of deep models can offer protection against such attacks (Strauss et al. 2018). Commonly, an ensemble of models has proven to improve the robustness, reduce variance, increase prediction accuracy and enhance generalization compared to the individual models (LeCun, Bengio, and Hinton 2015). As such, ensembles were offered as a solution in many areas, including weather prediction (Palmer 2019), computer vision (Krizhevsky, Sutskever, and Hinton 2012), robotics and autonomous driving (Kober, Bagnell, and Peters 2013) as well as others, such as (Ganaie et al. 2021). However, 'naive' ensemble models are brittle due to shared vulnerabilities in their members (Szegedy et al. 2016). Thus an adversary can exploit attack transferability (Madry et al. 2018) to affect all members and the ensemble as a whole.
+
+In recent years, researchers tried to improve the adversarial robustness of the ensemble by maximizing different notions for diversity between individual networks (Pang et al. 2019; Kariyappa and Qureshi 2019; Yang et al. 2020). In this way, adversarial attacks that fool one network are much less likely to fool the ensemble as a whole (Chen et al. 2019b; Sen, Ravindran, and Raghunathan 2019; Tramèr et al. 2018; Zhang, Liu, and Yan 2020). The research focusing on ensemble diversity aims to diversely train the neural networks inside the ensemble model to withstand the deterioration caused by adversarial attacks. The works (Pang et al. 2019; Zhang, Liu, and Yan 2020; Kariyappa and Qureshi 2019) proposed improving the diversity of the ensemble constituents by training the model with diversity regularization in addition to the main learning objective. (Kariyappa and Qureshi 2019) showed that an ensemble of models with misaligned loss gradients can be used as a defense against black-box attacks and proposed uncorrelated loss functions for ensemble learning. (Pang et al. 2019) proposed an adaptive diversity promoting (ADP) regularizer to encourage diversity between non-maximal predictions. (Yang et al. 2020) minimize vulnerability diversification objective in order to suppress shared 'week' features across the ensemble members. However, some of these approaches only focused on white-box attacks (Pang et al. 2019), black-box attacks (Kariyappa and Qureshi 2019) or were evaluated on a single dataset (Yang et al. 2020).
+
+---
+
+Copyright © 2022, Association for the Advancement of Artificial Intelligence (www.aaai.org). All rights reserved.
+
+---
+
+In this paper, we propose a novel diversity-promoting learning approach for deep ensembles. The idea is to promote Saliency Map Diversity (SMD) to prevent the attacker from targeting all ensemble members at once.
+
+Saliency maps (SM) (Gu and Tresp 2019) represent the derivative of the network prediction for the actual true label with respect to the input image. They indicate the most 'sensitive' content of the image for prediction. Intuitively, we would like to learn an ensemble whose members have different sensitivity across the image content while not sacrificing the ensemble predictive power. Therefore, we introduce a saliency map diversity (SMD) regularization term in our learning objective. Given image data and an ensemble of models, we define the SMD using the inner products between all pairs of saliency maps (for one image data, one ensemble member has one saliency map). Different from our approach with SMD regularization, (Pang et al. 2019) defined the diversity measure using the non-maximal predictions of individual members, and as such might not be able to capture the possible shared sensitivity with respect to the image content related to the correct predictions.
+
+We jointly learn our ensemble members using cross-entropy losses (LeCun, Bengio, and Hinton 2015) for each member and our shared ${SMD}$ term. This helps us minimize the alignment between model SMDs and enforces the ensemble members to have misaligned and non-overlapping sensitivity for the different image content. Thus with our approach, we try to minimize possible shared sensitivity across the ensemble members that might be exploited as vulnerability, which is in contrast to (Yang et al. 2020) who try to minimize shared 'week' features across the ensemble members. It is also important to note that our regularization differs from (Kariyappa and Qureshi 2019), since it focuses on gradients coming from the correct class predictions (saliencies), which could also be seen as a loss agnostic approach. We illustrate our learning scheme in Fig. 1, left. Whereas in Fig. 1 on the right, we visualize the saliency maps with respect to one image sample for the members in naively trained ensemble and an ensemble trained with our approach.
+
+We perform an extensive numerical evaluation using the MNIST (Lecun et al. 1998), Fashion-MNIST (F-MNIST) (Xiao, Rasul, and Vollgraf 2017), and CIFAR-10 (Krizhevsky 2009) datasets to validate our approach. We use two neural networks architectures and conduct experiments for different known attacks and at different attack strengths. Our results show a reduced transferability between ensemble members and improved performance compared to the state-of-the-art ensemble defense against medium and high-strength white-box attacks. Since we minimize the shared sensitivity which could also be seen as the attention of a prediction important image content, we also suspected that our approach could go well with other existing methods. To that end, we show that our approach combined with the (Yang et al. 2020) method outperforms state-of-the-art ensemble algorithms for defense under adversarial attacks in both white-box and black-box settings. We summarize our main contributions in the following:
+
+- We propose a diversity-promoting learning approach for deep ensemble, where we introduce a saliency-based regularization that diversifies the sensitivity of ensemble members with respect to the image content.
+
+- We show improved performance compared to the state-of-the-art ensemble defense against medium and high strength white-box attacks as well as show on-pair performance for the black-box attacks.
+
+- We demonstrate that our approach combined with the (Yang et al. 2020) method outperforms state-of-the-art ensemble defense algorithms in white-box and black-box attacks.
+
+## 2 Related Work
+
+In this section, we overview the recent related work.
+
+### 2.1 Common Defense Strategies
+
+In the following, we describe the common defense strategies against adversarial attacks groping them into four categories.
+
+Adversarial Detection. These methods aim to detect the adversarial examples or to restore the adversarial input to be closer to the original image space. Adversarial Detection methods (Bhambri et al. 2020) include MagNet, Feature Squeezing, and Convex Adversarial Polytope. The MagNet (Meng and Chen 2017) method consists of two parts: detector and reformer. Detector aims to recognize and reject adversarial images. Reformer aims to reconstruct the image as closely as possible to the original image using an auto-encoder. The Feature Squeezing (Xu, Evans, and Qi 2018) utilizes feature transformation techniques such as squeezing color bits and spatial smoothing. These methods might be prone to reject clean examples and might have to severely modify the input to the model. This could reduce the performance on the clean data.
+
+Gradient Masking and Randomization Defenses. Gradient masking represents manipulation techniques that try to hide the gradient of the network model to robustify against attacks made with gradient direction techniques and includes distillation, obfuscation, shattering, use of stochastic and vanishing or exploding gradients (Papernot et al. 2017; Athalye, Carlini, and Wagner 2018; Carlini and Wagner 2017). The authors in (Papernot et al. 2016b) introduced a method based on distillation. It uses an additional neural network to 'distill' labels for the original neural network in order to reduce the perturbations due to adversarial samples. (Xie et al. 2018) used a randomization method during training that consists of random resizing and random padding for the training image data. Another example of such randomization can be noise addition at different levels of the system (You et al. 2019), injection of different types of randomization like, for example, random image resizing or padding (Xie et al. 2018) or randomized lossy compression (Das et al. 2018), etc. As a disadvantage, these approaches can reduce the accuracy since they may reduce useful information, which might also introduce instabilities during learning. As such, it was shown that often they can be easily bypassed by the adversary via expectation over transformation techniques (Athalye and Carlini 2018).
+
+Secrecy-based Defenses. The third group generalizes the defense mechanisms, which include randomization explicitly based on a secret key that is shared between training and testing stages. Notable examples are random projections (Vinh et al. 2016), random feature sampling (Chen et al. 2019a) and the key-based transformation (Taran, Rezaeifar, and Voloshynovskiy 2018), etc. As an example in (Taran et al. 2019) introduces randomized diversification in a special transform domain based on a secret key, which creates an information advantage to the defender. Nevertheless, the main disadvantage of the known methods in this group consists of the loss of performance due to the reduction of useful data that should be compensated by a proper diversification and corresponding aggregation with the required secret key.
+
+Adversarial Training (AT). (Goodfellow, Shlens, and Szegedy 2015; Madry et al. 2018) proposed one of the most common approaches to improve adversarial robustness. The main idea is to train neural networks on both clean and adversarial samples and force them to correctly classify such examples. The disadvantage of this approach is that it can significantly increase the training time and can reduce the model accuracy on the unaltered data (Tsipras et al. 2018).
+
+### 2.2 Diversifying Ensemble Training Strategies
+
+Even naively learned ensemble could add improvement towards adversarial robustness. Unfortunately, ensemble members may share a large portion of vulnerabilities (Dauphin et al. 2014) and do not provide any guarantees to adversarial robustness (Tramèr et al. 2018).
+
+(Tramèr et al. 2018) proposed Ensemble Adversarial Training (EAT) procedure. The main idea of EAT is to minimize the classification error against an adversary that maximizes the error (which also represents a min-max optimization problem (Madry et al. 2018)). However, this approach is very computationally expensive and according to the original author may be vulnerable to white-box attacks.
+
+Recently, diversifying the models inside an ensemble gained attention. Such approaches include a mechanism in the learning procedure that tries to minimize the adversarial subspace by making the ensemble members diverse and making the members less prone to shared weakness.
+
+(Pang et al. 2019) introduced ADP regularizer to diversify training of the ensemble model to increase adversarial robustness. To do so, they defined first an Ensemble Diversity ${ED} = {\operatorname{Vol}}^{2}\left( {\begin{Vmatrix}{f}_{m}^{\smallsetminus y}\left( x\right) \end{Vmatrix}}_{2}\right)$ , where ${f}_{m}^{\smallsetminus y}\left( x\right)$ is the order preserving prediction of $m$ -th ensemble member on $x$ without $y$ -th (maximal) element and $\operatorname{Vol}\left( \cdot \right)$ is a total volume of vectors span. The ADP regularizer is calculated as ${\operatorname{ADP}}_{\alpha ,\beta }\left( {x, y}\right) = \alpha \cdot \mathcal{H}\left( \mathcal{F}\right) + \beta \cdot \log \left( {ED}\right)$ , where $\mathcal{H}\left( \mathcal{F}\right) =$ $- \mathop{\sum }\limits_{i}{f}_{i}\left( x\right) \log \left( {{f}_{i}\left( x\right) }\right)$ is a Shannon entropy and $\alpha ,\beta > 0$ . The ADP regularizer is then subtracted from the original loss during training.
+
+The GAL regularizer (Kariyappa and Qureshi 2019) was intended to diversify the adversarial subspaces and reduce the overlap between the networks inside ensemble model. GAL is calculated using the cosine similarity (CS) between the gradients of two different models as ${CS}{\left( {\nabla }_{x}{\mathcal{J}}_{a},{\nabla }_{x}{\mathcal{J}}_{b}\right) }_{a \neq b} = \frac{ < {\nabla }_{x}{\mathcal{J}}_{a},{\nabla }_{x}{\mathcal{J}}_{b} > }{\left| {{\nabla }_{x}{\mathcal{J}}_{a}}\right| \cdot \left| {{\nabla }_{x}{\mathcal{J}}_{b}}\right| }$ , where ${\nabla }_{x}{\mathcal{J}}_{m}$ is the gradient of the loss of $m$ -th member with respect to x. During training, the authors added the term ${GAL} =$ $\log \left( {\mathop{\sum }\limits_{{1 \leq a < b \leq N}}\exp \left( {{CS}\left( {{\nabla }_{x}{\mathcal{J}}_{a},{\nabla }_{x}{\mathcal{J}}_{b}}\right) }\right) }\right)$ to the learning objective.
+
+With DVERGE (Yang et al. 2020), the authors aimed to maximize the vulnerability diversity together with the original loss. They defined a vulnerability diversity between pairs of ensemble members ${f}_{a}\left( x\right)$ and ${f}_{b}\left( x\right)$ using data consisting of the original data sample and its feature distilled version. In other words, they deploy an ensemble learning procedure where each ensemble member ${f}_{a}\left( x\right)$ is trained using adversarial samples generated by other members ${f}_{b}\left( x\right) , a \neq b$ .
+
+### 2.3 Adversarial Attacks
+
+The goal of the adversary is to craft an image ${x}^{\prime }$ that is very close to the original $x$ and would be correctly classified by humans but would fool the target model. Commonly, attackers can act as adversaries in white-box and black-box modes, depending on the gained access level over the target model.
+
+White-box and Black-box Attacks. In the white-box scenario, the attacker is fully aware of the target model's architecture and parameters and has access to the model's gradients. White-box attacks are very effective against the target model but they are bound to the extent of knowing the model. In the Black-box scenario, the adversary does not have access to the model parameters and may only know the training dataset and the architecture of the model (in grey-box setting). The attacks are crafted on a surrogate model but still work to some extent on the target due to transferability (Papernot et al. 2016a).
+
+An adversary can build a white-box or black-box attack using different approaches. In the following text, we briefly describe the methods commonly used for adversarial attacks.
+
+Fast Gradient Sign Method (FGSM). (Goodfellow, Shlens, and Szegedy 2015) generated adversarial attack ${x}^{\prime }$ by adding the sign of the gradient $\operatorname{sign}\left( {{\nabla }_{x}\mathcal{J}\left( {x, y}\right) }\right)$ as perturbation with $\epsilon$ strength, i.e., ${x}^{\prime } = x + \epsilon \cdot \operatorname{sign}\left( {{\nabla }_{x}\mathcal{J}\left( {x, y}\right) }\right)$ .
+
+Random Step-FGSM (R-FGSM). The method proposed in (Tramèr et al. 2018) is an extension of FGSM where a single random step is taken before FGSM due to the assumed non-smooth loss function in the neighborhood of data points.
+
+Projected Gradient Descent (PGD). (Madry et al. 2018) presented a similar attack to BIM, with the difference that they randomly selected the initialization of ${x}_{0}^{\prime }$ in a neighborhood $\dot{U}\left( {x,\epsilon }\right)$ .
+
+Basic Iterative Method (BIM). (Kurakin, Goodfellow, and Bengio 2017) proposed iterative computations of attack gradient for each smaller step. Thus, generating an attacks as ${x}_{i}^{\prime } = {\operatorname{clip}}_{x,\epsilon }\left( {{x}_{i - 1}^{\prime } + \frac{\epsilon }{r} \cdot \operatorname{sign}\left( {g}_{i - 1}\right) }\right)$ , where ${g}_{i} = {\nabla }_{x}\mathcal{J}\left( {{x}_{i}^{\prime }, y}\right)$ , ${x}_{0}^{\prime } = x$ and $r$ is the number of iterations.
+
+Momentum Iterative Method (MIM). (Dong et al. 2018) proposed extenuation of BIM. It proposes to update gradient with the momentum $\mu$ to ensure best local minima. Holding the momentum helps to avoid small holes and poor local minimum solution, ${g}_{i} = \mu {g}_{i - 1} + \frac{{\nabla }_{x}\mathcal{J}\left( {{x}_{i - 1}^{\prime }, y}\right) }{{\begin{Vmatrix}{\nabla }_{x}\mathcal{J}\left( {x}_{i - 1}^{\prime }, y\right) \end{Vmatrix}}_{1}}$ .
+
+## 3 Saliency Diversified Ensemble Learning
+
+In this section, we present our diversity-promoting learning approach for deep ensembles. In the first subsection, we introduce the saliency-based regularizer, while in the second subsection we describe our learning objective.
+
+### 3.1 Saliency Diversification Measure
+
+Saliency Map. In (Etmann et al. 2019), the authors investigated the connection between a neural network's robustness to adversarial attacks and the interpretability of the resulting saliency maps. They hypothesized that the increase in interpretability could be due to a higher alignment between the image and its saliency map. Moreover, they arrived at the conclusion that the strength of this connection is strongly linked to how locally similar the network is to a linear model. In (Mangla, Singh, and Balasubramanian 2020) authors showed that using weak saliency maps suffices to improve adversarial robustness with no additional effort to generate the perturbations themselves.
+
+We build our approach on prior work about saliency maps and adversarial robustness but in the context of deep ensemble models. In (Mangla, Singh, and Balasubramanian 2020) the authors try to decrease the sensitivity of the prediction with respect to the saliency map by using special augmentation during training. We also try to decrease the sensitivity of the prediction with respect to the saliency maps but for the ensemble. We do so by enforcing misalignment between the saliency maps for the ensemble members.
+
+We consider a saliency map for model ${f}_{m}$ with respect to data $x$ conditioned on the true class label $y$ . We calculate it as the first order derivative of the model output for the true class label with respect to the input, i.e.,
+
+$$
+{s}_{m} = \frac{\partial {f}_{m}\left( x\right) \left\lbrack y\right\rbrack }{\partial x}, \tag{1}
+$$
+
+where ${f}_{m}\left( x\right) \left\lbrack y\right\rbrack$ is the $y$ element from the predictions ${f}_{m}\left( x\right)$ .
+
+Shared Sensitivity Across Ensemble Members. Given image data $x$ and an ensemble of $M$ models ${f}_{m}$ , we define our SMD measure as:
+
+$$
+{\mathcal{L}}_{SMD}\left( x\right) = \log \left\lbrack {\mathop{\sum }\limits_{m}\mathop{\sum }\limits_{{l > m}}\exp \left( \frac{{s}_{m}^{T}{s}_{l}}{{\begin{Vmatrix}{s}_{m}\end{Vmatrix}}_{2}{\begin{Vmatrix}{s}_{l}\end{Vmatrix}}_{2}}\right) }\right\rbrack , \tag{2}
+$$
+
+where ${s}_{m} = \frac{\partial {f}_{m}\left( x\right) \left\lbrack y\right\rbrack }{\partial x}$ is the saliency map for ensemble model ${f}_{m}$ with respect to the image data $x$ . A high value of ${\mathcal{L}}_{SMD}\left( x\right)$ means alignment and similarity between the saliency maps ${s}_{m}$ of the models ${f}_{m}\left( x\right)$ with respect to the image data $x$ . Thus $\operatorname{SMD}\left( 2\right)$ indicates a possible shared sensitivity area in the particular image content common for all the ensemble members. A pronounced sensitivity across the ensemble members points to a vulnerability that might be targeted and exploited by an adversarial attack. To prevent this, we would like ${\mathcal{L}}_{SMD}\left( x\right)$ to be as small as possible, which means different image content is of different importance to the ensemble members.
+
+### 3.2 Saliency Diversification Objective
+
+We jointly learn our ensemble members using a common cross-entropy loss per member and our saliency based sensitivity measure described in the subsection above. We define our learning objective in the following:
+
+$$
+\mathcal{L} = \mathop{\sum }\limits_{x}\mathop{\sum }\limits_{m}{\mathcal{L}}_{m}\left( x\right) + \lambda \mathop{\sum }\limits_{x}{\mathcal{L}}_{SMD}\left( x\right) , \tag{3}
+$$
+
+where ${\mathcal{L}}_{m}\left( x\right)$ is the cross-entropy loss for ensemble member $m,{\mathcal{L}}_{SMD}\left( x\right)$ is our SMD measure for an image data $x$ and an ensemble of $M$ models ${f}_{m}$ , and $\lambda > 0$ is a Lagrangian parameter. By minimizing our learning objective that includes a saliency-based sensitivity measure, we enforce the ensemble members to have misaligned and non-overlapping sensitivity for the different image content. Our regularization enables us to strongly penalize small misalignments ${s}_{m}^{T}{s}_{l}$ between the saliency maps ${s}_{m}$ and ${s}_{l}$ . While at the same time it ensures that a large misalignment is not discarded. Additionally, since ${\mathcal{L}}_{SMD}\left( x\right)$ is a $\log \operatorname{SumExp}$ function it has good numerical properties (Kariyappa and Qureshi 2019). Thus, our approach offers to effectively minimize possible shared sensitivity across the ensemble members that might be exploited as vulnerability. In contrast to GAL regularizer (Kariyappa and Qureshi 2019) SMD is loss agnostic (can be used with loss functions other than cross-entropy) and does not focus on incorrect-class prediction (which are irrelevant for accuracy). Additionally it has a clear link to work in interpretability (Etmann et al. 2019) and produces diverse but meaningful saliency maps (see Fig. 1).
+
+Assuming unit one norm saliencies, the gradient based update for one data sample $x$ with respect to the parameters ${\theta }_{{f}_{m}}$ of a particular ensemble member can be written as:
+
+$$
+{\theta }_{{f}_{m}} = {\theta }_{{f}_{m}} - \alpha \left( {\frac{\partial {\mathcal{L}}_{m}\left( x\right) }{\partial {\theta }_{{f}_{m}}} + \lambda \frac{\partial {\mathcal{L}}_{SMD}\left( x\right) }{\partial {\theta }_{{f}_{m}}}}\right) =
+$$
+
+$$
+= {\theta }_{{f}_{m}} - \alpha \frac{\partial {\mathcal{L}}_{m}\left( x\right) }{\partial {\theta }_{{f}_{m}}} - {\alpha \lambda }\frac{\partial {f}_{m}\left( x\right) \left\lbrack y\right\rbrack }{\partial x\partial {\theta }_{{f}_{m}}}\mathop{\sum }\limits_{{j \neq m}}{\beta }_{j}\frac{\partial {f}_{j}\left( x\right) \left\lbrack y\right\rbrack }{\partial x}, \tag{4}
+$$
+
+where $\alpha$ is the learning rate and ${\beta }_{j} = \frac{\exp \left( {{s}_{m}^{T}{s}_{j}}\right) }{\mathop{\sum }\limits_{m}\mathop{\sum }\limits_{{k > m}}\exp \left( {{s}_{m}^{T}{s}_{k}}\right) }$ . The third term enforces the learning of the ensemble members to be on optimization paths where the gradient of their saliency maps $\frac{\partial {f}_{m}\left( x\right) \left\lbrack y\right\rbrack }{\partial x\partial {\theta }_{fm}}$ with respect to ${\theta }_{{f}_{m}}$ is misaligned with the weighted average of the remaining saliency maps $\mathop{\sum }\limits_{{j \neq m}}{\beta }_{j}\frac{\partial {f}_{j}\left( x\right) \left\lbrack y\right\rbrack }{\partial x}$ . Also,(4) reveals that by our approach the ensemble members can be learned in parallel provided that the saliency maps are shared between the models (we leave this direction for future work).
+
+## 4 Empirical Evaluation
+
+This section is devoted to empirical evaluation and performance comparison with state-of-the-art ensemble methods.
+
+### 4.1 Data Sets and Baselines
+
+We performed the evaluation using 3 classical computer vision data sets (MNIST (Lecun et al. 1998), FASHION-MNIST (Xiao, Rasul, and Vollgraf 2017) and CIFAR-10 (Krizhevsky 2009)) and include 4 baselines (naive ensemble, (Pang et al. 2019), (Kariyappa and Qureshi 2019), (Yang et al. 2020)) in our comparison.
+
+Datasets. The MNIST dataset (Lecun et al. 1998) consists of 70000 gray-scale images of handwritten digits with dimensions of 28x28 pixels. F-MNIST dataset (Xiao, Rasul, and Vollgraf 2017) is similar to MNIST dataset, has the same number of images and classes. Each image is in grayscale and has a size of ${28} \times {28}$ . It is widely used as an alternative to MNIST in evaluating machine learning models. CIFAR 10 dataset (Krizhevsky 2009) contains 60000 color images with 3 channels. It includes 10 real-life classes. Each of the 3 color channels has a dimension of ${32} \times {32}$ .
+
+Baselines. As the simplest baseline we compare against the performance of a naive ensemble, i.e., one trained without any defense mechanism against adversarial attacks. Additionally, we also consider state-of-the-art methods as baselines. We compare the performance of our approach with the following ones: Adaptive Diversity Promoting (ADP) method (Pang et al. 2019), Gradient Alignment Loss (GAL) method (Kariyappa and Qureshi 2019), and a Diversifying Vulnerabilities for Enhanced Robust Generation of Ensembles (DVERGE) or (DV.) method (Yang et al. 2020).
+
+### 4.2 Training and Testing Setup
+
+Used Neural Networks. To evaluate our approach, we use two neural networks LeNet-5 (Lecun et al. 1998) and ResNet-20 (He et al. 2016). LeNet-5 is a classical small neural network for vision tasks, while ResNet-20 is another widely used architecture in this domain.
+
+Training Setup. We run our training algorithm for 50 epochs on MNIST and F-MNIST and 200 epochs on CIFAR-10, using the Adam optimizer (Kingma and Ba 2015), a learning rate of 0.001 , weight decay of 0.0001 , and batch-sizes of 128. We use no data augmentation on MNIST and F-MNIST and use normalization, random cropping, and flipping on CIFAR-10. In all of our experiments, we use 86% of the data for training and 14% for testing.In the implemented regularizers from prior work, we used the $\lambda$ that was suggested by the respective authors. While we found out that the strength of the SMD regularizer (also $\lambda$ ) in the range $\left\lbrack {{0.5},2}\right\rbrack$ gives good results. Thus in all of our experiments, we take $\lambda = 1$ . We report all the results as an average over 5 independent trials (we include the standard deviations in the Appendix A). We report results for the ensembles of 3 members in the main paper, and for 5 and 8 in the Appendix C.
+
+We used the LeNet-5 neural network for MNIST and F-MNIST datasets and ResNet-20 for CIFAR-10. To have a fair comparison, we also train ADP (Pang et al. 2019), GAL (Kariyappa and Qureshi 2019) and DVERGE (Yang et al. 2020), under a similar training setup as described above. We made sure that the setup is consistent with the one given by the original authors with exception of using Adam optimizer for training DVERGE. We also used our approach and added it as a regularizer to the DVERGE algorithm. We named this combination SMD+ and ran it under the setup as described above. All models are implemented in PyTorch (Paszke et al. 2017). We use AdverTorch (Ding, Wang, and Jin 2019) library for adversarial attacks.
+
+In the setting of adversarial training, we follow the EAT approach (Tramèr et al. 2018) by creating adversarial examples on 3 holdout pre-trained ensembles with the same size and architecture as the baseline ensemble. The examples are created via PGD- ${L}_{\infty }$ attack with 10 steps and $\epsilon = {0.1}$ .
+
+Adversarial Attacks. To evaluate our proposed approach and compare its performance to baselines, we use a set of adversarial attacks described in Section 2.3 in both black-box and white-box settings. We construct adversarial examples from the images in the test dataset by modifying them using the respective attack method. We probe with white-box attacks on the ensemble as a whole (not on the individual models). We generate black-box attacks targeting our ensemble model by creating white-box adversarial attacks on a surrogate ensemble model (with the same architecture), trained on the same dataset with the same training routine. We use the following parameters for the attacks: for $\left( {{\mathrm{F}}_{GSM},\mathrm{{PGD}}}\right.$ , R-F., BIM, MIM) we use $\epsilon$ in range $\left\lbrack {0;{0.3}}\right\rbrack$ in 0.05 steps, which covers the range used in our baselines; we use 10 iterations with a step size equal to $\epsilon /{10}$ for PGD, BIM and MIM; we use ${L}_{\infty }$ variant of PGD attack; for R-F. we use random-step $\alpha = \epsilon /2$ .
+
+Computing Infrastructure and Run Time. As computing hardware, we use half of the available resources from NVIDIA DGX2 station with ${3.3}\mathrm{{GHz}}\mathrm{{CPU}}$ and ${1.5}\mathrm{\;{TB}}\mathrm{{RAM}}$ memory, which has a total of ${161.75}\mathrm{{GHz}}$ GPUs, each with 32GB memory. One experiment takes around 4 minutes to train the baseline ensemble of 3 LeNet-5 members on MNIST without any regularizer. Whereas it takes around 18 minutes to train the same ensemble under the SMD regularizer, 37 minutes under DVERGE regularize, and 48 minutes under their combination. To evaluate the same ensemble under all of the adversarial attacks takes approximately 1 hour. It takes approximately 3 days when ResNet-20 members are used on CIFAR-10 for the same experiment.
+
+
+
+Figure 2: Accuracy vs. attacks strength for white-box PGD attacks on an ensemble of 3 LeNet-5 models for MNIST and F-MNIST and on an ensemble of 3 ReNets-20 for CIFAR-10 dataset.
+
+