more polishing

Author: pat-alt

paper/.Rhistory

@@ -5,3 +5,49 @@ child_docs <- c(
 "sections/related.rmd",
 )
 install.packages("JuliaCall")
+knitr::include_graphics("www/synthetic_results.png")
+library(kable)
+tab <- data.frame(
+"Hidden Dim." = c(32,32),
+"Hidden Layers." = c(1,2),
+"Batch" = c("-",50),
+"Dropout" = c("-",0.25)
+)
+tab
+rownames(df, "Synthetic", "Real-World")
+rownames(df) <- c("Synthetic", "Real-World")
+rownames(tab) <- c("Synthetic", "Real-World")
+tab
+tab <- data.frame(
+"Hidden Dim." = c(32,32),
+"Hidden Layers." = c(1,2),
+"Batch" = c("-",50),
+"Dropout" = c("-",0.25)
+)
+rownames(tab) <- c("Synthetic", "Real-World")
+knitr::kable(
+tab, booktabs = TRUE,
+caption = 'MLP architecture and training parameters.'
+)
+tab <- data.frame(
+"Hidden Dim." = c(32,32),
+"Hidden Layers." = c(1,2),
+"Batch" = c("-",50),
+"Dropout" = c("-",0.25)
+)
+rownames(tab) <- c("Synthetic", "Real-World")
+knitr::kable(
+tab, booktabs = TRUE,
+caption = 'MLP architecture and training parameters.',
+col.names = c("Hidden Dim.","Hidden Layers", "Batch", "Dropout")
+)
+tab <- data.frame(
+"Hidden Dim." = c(2,8),
+"Epochs" = c(100,250)
+)
+rownames(tab) <- c("Synthetic", "Real-World")
+knitr::kable(
+tab, booktabs = TRUE,
+caption = 'VAE architecture and training parameters.',
+col.names = c("Hidden Dim.","Epochs")
+)

paper/paper.pdf

@@ -4,37 +4,33 @@ This section presents the exact ingredients and parameter choices describing the
 
 ## $M$ -- Classifiers and Generative Models {#empirical-classifiers}
 
-For each dataset and generator we look at three different types of classifiers all of them built and trained using `Flux.jl` [@innes2018fashionable]: firstly, a simple linear classifier - **Logistic Regression** - implemented as single linear layer with sigmoid activation; secondly, a multilayer perceptron (**MLP**); and finally, a **Deep Ensemble** composed of five MLPs following @lakshminarayanan2016simple that serves as our only probabilistic classifier. We have chosen to work with deep ensembles both for their simplicity and effectiveness at modelling predictive uncertainty. They are also the model of choice in @schut2021generating. The actual neural network architectures are kept simple (Table \@ref(tab:mlp)), since we are only marginally concerned with achieving good initial classifier performance. For the real-world datasets we using mini-batch training and dropout regularization. 
+For each dataset and generator we look at three different types of classifiers all of them built and trained using `Flux.jl` [@innes2018fashionable]: firstly, a simple linear classifier - **Logistic Regression** - implemented as single linear layer with sigmoid activation; secondly, a multilayer perceptron (**MLP**); and finally, a **Deep Ensemble** composed of five MLPs following @lakshminarayanan2016simple that serves as our only probabilistic classifier. We have chosen to work with deep ensembles both for their simplicity and effectiveness at modelling predictive uncertainty. They are also the model of choice in @schut2021generating. The actual neural network architectures are kept simple (top half of Table \@ref(tab:architecture)), since we are only marginally concerned with achieving good initial classifier performance.
 
-The Latent Space generator relies on a separate generative model. Following the authors of both REVISE and CLUE we use Variational Autoencoders (**VAE**) for this purpose. As with the classifiers, we deliberately choose to work with fairly simple architectures (Table \@ref(tab:vae)). More expressive generative models generally also lead to more meaningful counterfactuals produced by Latent Space generators. But in our view this should simply be considered as a vulnerability of counterfactual generators that rely on surrogate models to learn what realistic representations of the underlying data. 
+The Latent Space generator relies on a separate generative model. Following the authors of both REVISE and CLUE we use Variational Autoencoders (**VAE**) for this purpose. As with the classifiers, we deliberately choose to work with fairly simple architectures (bottom half of Table \@ref(tab:architecture)). More expressive generative models generally also lead to more meaningful counterfactuals produced by Latent Space generators. But in our view this should simply be considered as a vulnerability of counterfactual generators that rely on surrogate models to learn what realistic representations of the underlying data. 
 
-```{r mlp}
+```{r architecture}
 tab <- data.frame(
-  "Hidden Dim." = c(32,32),
-  "Hidden Layers." = c(1,2),
-  "Batch" = c("-",50),
-  "Dropout" = c("-",0.25)
+  "Model" = c("MLP","MLP","VAE","VAE"),
+  "Data" = c("Synthetic", "Real-World", "Synthetic", "Real-World"),
+  "Hidden" = c(32,32,32,32),
+  "Latent" = c("-","-",2,8),
+  "Layers" = c(1,2,1,1),
+  "Batch" = c("-",50,"-","-"),
+  "Dropout" = c("-",0.25,"-","-"),
+  "Epochs" = c(100,100,100,250)
 )
-rownames(tab) <- c("Synthetic", "Real-World")
-knitr::kable(
+library(kableExtra)
+kbl(
   tab, booktabs = TRUE,
-  caption = 'MLP architecture and training parameters.',
-  col.names = c("Hidden Dim.","Hidden Layers", "Batch", "Dropout")
-)
+  caption = 'Neural network architectures and training parameters.',
+  col.names = c("Model","Data","Hidden Dim.","Latent Dim.","Hidden Layers", "Batch", "Dropout", "Epochs")
+) |> 
+  collapse_rows(1:2, row_group_label_position = 'stack') |>
+  kable_styling(latex_options = c("scale_down"))
 ```
 
-```{r vae}
-tab <- data.frame(
-  "Hidden Dim." = c(2,8),
-  "Epochs" = c(100,250)
-)
-rownames(tab) <- c("Synthetic", "Real-World")
-knitr::kable(
-  tab, booktabs = TRUE,
-  caption = 'VAE architecture and training parameters.',
-  col.names = c("Hidden Dim.","Epochs")
-)
-```
+
+
 
 ## $\mathcal{D}$ -- Data {#empirical-data}
 
@@ -56,9 +52,9 @@ plt = plot(plts..., layout=(1,4), size=(850,200))
 savefig(plt, "dev/paper/www/synthetic_data.png")
 ```
 
-We use four synthetic binary classification datasets consisting of 1000 samples each. The datasets are presented in Figure \@ref(fig:synthetic-data) (see also Appendix A for a formal description). Samples from the negative class are marked in blue while samples of the positive class are marked in orange.
+We use four synthetic binary classification datasets consisting of 1000 samples each: **Overlapping**, **Linearly Separable**, **Circles** and **Moons**. The datasets are presented in Figure \@ref(fig:synthetic-data). Samples from the negative class are marked in blue while samples of the positive class are marked in orange.
 
-```{r synthetic-data, fig.cap="Synthetic classification datasets used in our experiments."}
+```{r synthetic-data, fig.cap="Synthetic classification datasets used in our experiments. Samples from the negative class ($y=0$) are marked in blue while samples of the positive class ($y=1$) are marked in orange."}
 knitr::include_graphics("www/synthetic_data.png")
 ```
 

paper/paper.tex

@@ -52,3 +52,5 @@ Out-of-sample model performance also deteriorates across the board and substanti
 knitr::include_graphics("www/real_world_results.png")
 ```
 
+To recap, we can answer our research questions as follows: firstly, endogenous dynamics do emerge in our experiments and we find them substantial enough to be considered costly; secondly, the choice of the counterfactual generator does matter, with Latent Space search generally having a dampening effect. The observed dynamics therefore seem to be driven by a discrepancy between counterfactual outcomes that minimize costs to the individual and outcomes that comply with the data generating process. 
+

paper/sections/empirical.rmd

@@ -10,7 +10,7 @@ Research on Algorithmic Recourse has also so far typically addressed the issue f
 
 Figure \@ref(fig:poc) illustrates this idea for a binary problem involving a probabilistic classifier and the counterfactual generator proposed by @wachter2017counterfactual: the implementation of AR for a subset of individuals immediately leads to a visible domain shift in the (orange) target class (b), which in turn triggers a model shift (c). As this game of implementing AR and updating the classifier is repeated, the decision boundary moves away from training samples that were originally in the target class (d). We refer to these types of dynamics as **endogenous** because they are induced by the implementation of recourse itself. The term **macrodynamics** is borrowed from the economics literature and used to describe processes involving whole groups or societies.
 
-```{r poc, fig.cap="Dynamics in Algorithmic Recourse: we have a simple linear classifier trained for binary classification (a); the implementation of AR for a random subset of individuals leads to a noticable domain shift (b); as the classifier is retrained we observe a corresponding model shift (c); as this process is repeated, the decision boundary moves away from the target class (d)."}
+```{r poc, fig.cap="Dynamics in Algorithmic Recourse: (a) we have a simple linear classifier trained for binary classification where samples from the negative class ($y=0$) are marked in blue and samples of the positive class ($y=1$) are marked in orange; (b) the implementation of AR for a random subset of individuals leads to a noticable domain shift; (c) as the classifier is retrained we observe a corresponding model shift; (d) as this process is repeated, the decision boundary moves away from the target class."}
 knitr::include_graphics("www/poc.png")
 ```
 

paper/sections/empirical_2.rmd

@@ -10,27 +10,27 @@ As we will see next, all of them can be described by the following generalized f
 
 \begin{equation}
 \begin{aligned}
-\mathbf{s}^\prime &= \arg \min_{\mathbf{s}^\prime \in \mathcal{S}} \left\{ \sum_{k=1}^{K} {\text{yloss}(M(f(s_k^\prime)),y^*)}+ \lambda {\text{cost}(f(s_k^\prime)) }  \right\} (\#eq:general)
+\mathbf{s}^\prime &= \arg \min_{\mathbf{s}^\prime \in \mathcal{S}} \left\{  {\text{yloss}(M(f(\mathbf{s}^\prime)),y^*)}+ \lambda {\text{cost}(f(\mathbf{s}^\prime)) }  \right\} (\#eq:general)
 \end{aligned} 
 \end{equation}
 
 Here $\mathbf{s}^\prime=\left\{s_k^\prime\right\}_K$ is the stacked $K$-dimensional array of counterfactual states  and $f: \mathcal{S} \mapsto \mathcal{X}$ maps from the counterfactual state space to the feature space. In Wachter, the state space is the feature space: $f$ is just the identity function and the number of counterfactuals $K$ is equal to one. Both REVISE and CLUE search counterfactuals in some latent embedding $S \subset \mathcal{S}$ instead of the feature space directly. The latent embedding is learned by a separate generative model that is tasked with learning the data generating process (DGP) of $X$. In this case $f$ in Equation \@ref(eq:general) corresponds to the decoder part of the generative model, in other words the function that maps back from the latent embedding to the feature space. Provided the generative model is well-specified, traversing the latent embedding typically results in realistic and plausible counterfactuals, because they are implicitly generated by the (learned) DGP [@joshi2019towards]. 
 
 CLUE distinguishes itself from REVISE and other counterfactual generators in that it aims to minimize the predictive uncertainty of the model in question, $M$. To quantify predictive uncertainty the authors rely on entropy estimates for probabilistic models. The approach proposed by @schut2021generating, which we shall refer to as **Greedy**, also works with the subclass of models $\tilde{\mathcal{M}}\subset\mathcal{M}$ that can produce predictive uncertainty estimates. The authors show that in this setting the cost function $\text{cost}(\cdot)$ in Equation \@ref(eq:general) is redundant and meaningful counterfactuals can be generated in a fast and efficient manner through a modified Jacobian-based Saliency Map Attack (JSMA). Schut et al. [@schut2021generating] also show that by maximizing the predicted probability of $x^\prime$ being assigned to target class $y^*$ we also implicitly minimize predictive entropy - as in CLUE. In that sense, CLUE can be seen as equivalent to REVISE in the Bayesian context and we shall therefore refer to both approaches collectively as **Latent Space** generators^[In fact, there are a number of other recently proposed approaches to counterfactual search that also broadly fall in this same category. They largely differ with respect to the chosen generative model: for example, the generator proposed by @dombrowski2021diffeomorphic relies on normalizing flows.]. 
 
-Finally, DiCE [@mothilal2020explaining] distinguishes itself from all other generators considered here in that it aims to generate a diverse set of $K>1$ counterfactuals. Wachter et al. [@wachter2017counterfactual] show that diverse outcomes can in principal be achieved simply rerunning counterfactual search multiple times using stochastic gradient descent (or by randomly initializing the counterfactual). In @mothilal2020explaining diversity is explicitly proxied via Determinantal Point Processes (DDP): the authors simply introduce DDP as a component of the cost function $\text{cost}(\mathbf{s}^\prime)$ and therebt produce counterfactuals $s_1, ... , s_K$ that look as different from each other as possible. The implementation of DiCE in the our library of choice - `CounterfactualExplanations.jl` - uses that exact approach. It is worth noting that for $k=1$, DiCE reduces to Wachter since the DDP is constant and therefore does not affect the objective function in Equation \@ref(eq:general).
+Finally, DiCE [@mothilal2020explaining] distinguishes itself from all other generators considered here in that it aims to generate a diverse set of $K>1$ counterfactuals. Wachter et al. [@wachter2017counterfactual] show that diverse outcomes can in principal be achieved simply rerunning counterfactual search multiple times using stochastic gradient descent (or by randomly initializing the counterfactual)^[Note, in fact, that \@ref(eq:general) naturally lends itself to that idea: setting $K$ to some value greater than one and using the Wachter objective essentially boils down to computing multiple counterfactuals in parallel. Here, $yloss(\cdot)$ is first broadcasted over elements of $\mathbf{s}^\prime$ and then aggregated. This is exactly how counterfactual search is implemented in `CounterfactualExplanations.jl`.]. In @mothilal2020explaining diversity is explicitly proxied via Determinantal Point Processes (DDP): the authors simply introduce DDP as a component of the cost function $\text{cost}(\mathbf{s}^\prime)$ and thereby produce counterfactuals $s_1, ... , s_K$ that look as different from each other as possible. The implementation of DiCE in the our library of choice - `CounterfactualExplanations.jl` - uses that exact approach. It is worth noting that for $k=1$, DiCE reduces to Wachter since the DDP is constant and therefore does not affect the objective function in Equation \@ref(eq:general).
 
 ## ... towards collective recourse
 
 All of the different approaches introduced above tackle the problem of Algorithmic Recourse from the perspective of one single individual^[DiCE recognizes that different individuals may have different objective functions, but it does not address the interdependencies between different individuals.]. To explicitly address the issue that individual recourse may affect the outcome and prospect of other individuals, we propose to extend Equation \@ref(eq:general) as follows:
 
 \begin{equation}
 \begin{aligned}
-\mathbf{s}^\prime &= \arg \min_{\mathbf{s}^\prime \in \mathcal{S}}  \sum_{k=1}^{K} {\text{yloss}(M(f(s_k^\prime)),y^*)} \\ &+ \lambda_1 {\text{cost}(f(s_k^\prime))} + \lambda_2 {\text{extcost}(f(s_k^\prime))}  (\#eq:collective)
+\mathbf{s}^\prime &= \arg \min_{\mathbf{s}^\prime \in \mathcal{S}} \{ {\text{yloss}(M(f(\mathbf{s}^\prime)),y^*)} \\ &+ \lambda_1 {\text{cost}(f(\mathbf{s}^\prime))} + \lambda_2 {\text{extcost}(f(\mathbf{s}^\prime))} \}  (\#eq:collective)
 \end{aligned} 
 \end{equation}
 
-Here $\text{cost}(f(s_k^\prime))$ denotes the proxy for private costs faced by the individual as before and $\lambda_1$ governs to what extent that private cost ought to be penalized. The newly introduced term $\text{extcost}(f(s_k^\prime))$ is meant to capture and address external costs incurred by the collective of individuals in response to changes in $\mathbf{s}^\prime$. The underlying concept of private and external costs is borrowed from Economics and well-established in that field: when the decisions or actions by some individual market participant generate external costs, then the market is said to suffer from negative externalities and considered inefficient [@pindyck2014microeconomics]. We think that this concept describes the endogenous dynamics of algorithmic recourse oberserved here very well. As with individual recourse, the exact choice of $\text{extcost}(\cdot)$ is not obvious, nor do we intend to provide a definite answer in this work, if such even exists. That being said, we do propose a few potential mitigation strategies in Section \@ref(mitigate).
+Here $\text{cost}(f(\mathbf{s}^\prime))$ denotes the proxy for private costs faced by the individual as before and $\lambda_1$ governs to what extent that private cost ought to be penalized. The newly introduced term $\text{extcost}(f(\mathbf{s}^\prime))$ is meant to capture and address external costs incurred by the collective of individuals in response to changes in $\mathbf{s}^\prime$. The underlying concept of private and external costs is borrowed from Economics and well-established in that field: when the decisions or actions by some individual market participant generate external costs, then the market is said to suffer from negative externalities and considered inefficient [@pindyck2014microeconomics]. We think that this concept describes the endogenous dynamics of algorithmic recourse observed here very well. As with individual recourse, the exact choice of $\text{extcost}(\cdot)$ is not obvious, nor do we intend to provide a definite answer in this work, if such even exists. That being said, we do propose a few potential mitigation strategies in Section \@ref(mitigate).