diff --git a/C2W2_GAN_Debiasing_(Optional).ipynb b/C2W2_GAN_Debiasing_(Optional).ipynb
new file mode 100644
index 0000000..98944a3
--- /dev/null
+++ b/C2W2_GAN_Debiasing_(Optional).ipynb
@@ -0,0 +1,521 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "name": "C2W2: GAN Debiasing (Optional).ipynb",
+ "provenance": [],
+ "collapsed_sections": [],
+ "include_colab_link": true
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "1V63oGS63NGk"
+ },
+ "source": [
+ "# Using GANs to augment and de-bias datasets\n",
+ "\n",
+ "*Please note that this is an optional notebook that is meant to introduce more advanced concepts, if you're up for a challenge. So, don't worry if you don't completely follow every step!*\n",
+ "\n",
+ "[*Fair Attribute Classification through Latent Space De-biasing*](https://princetonvisualai.github.io/gan-debiasing/). Vikram V. Ramaswamy, Sunnie S. Y. Kim, Olga Russakovsky. CVPR 2021."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "x8Lvg_dC3Zqo"
+ },
+ "source": [
+ "### Goals\n",
+ "\n",
+ "Fairness in visual recognition is becoming a prominent and critical topic of discussion as recognition systems are deployed at scale in the real world. Models trained from data in which target labels are correlated with protected attributes (i.e. gender, race) are known to learn and perpetuate those correlations. \n",
+ "\n",
+ "In this notebook, you will learn about *Fair Attribute Classification through Latent Space De-biasing* (Ramaswamy et al. 2020) that introduces a method for training accurate target classifiers while mitigating biases that stem from these correlations. Specifically, this work uses GANs to generate realistic-looking images and perturb these images in the underlying latent space to generate training data that is balanced for each protected attribute. They augment the original dataset with this perturbed generated data, and empirically demonstrate that target classifiers trained on the augmented dataset exhibit a number of both quantitative and qualitative benefits. \n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "VkQK-bFQeMuG"
+ },
+ "source": [
+ "## Problem\n",
+ "\n",
+ "Suppose you want to train a visual recognition model that recognizes the presence of an attribute, such as **wearing a hat**. However, in the real world, wearing a hat can be correlated with **wearing glasses**, for example, because people often wear both hats and sunglasses outside and take them off inside. This correlation may be reflected in the training data, and a classifier trained to recognize a hat may rely on the presence of glasses. Consequently, the classifier may fail to recognize a hat in the absence of glasses, and vice versa."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Q6pdA7WS3aso"
+ },
+ "source": [
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "fE7Nrv24eHOt"
+ },
+ "source": [
+ "Ramaswamy et al. propose using a GAN to generate more images with hats but not glasses and images with glasses but not hats, such that **wearing a hat** is de-correlated from **wearing glasses** in the training data, by making perturbations in the latent space. Building on work by [Denton et al. (2019)](https://arxiv.org/abs/1906.06439), which demonstrates a method for learning interpretable image manipulation directions, they propose an improved latent vector perturbation method that allows you to preserve the **wearing a hat** attribute while changing the **wearing glasses** attribute. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "6q9QmWxX3avR"
+ },
+ "source": [
+ "## Perturbing GAN latent vectors\n",
+ "\n",
+ "Suppose a class of problems where a protected attribute is correlated with a target label in the data $\\mathcal{X}$, influencing target label prediction. Let $t$ be the target label (e.g., **wearing a hat**) and $g$ be the protected attribute (e.g., **wearing glasses**) with $t,g\\in\\{-1,1\\}$. To mitigate the effect of unwanted dataset bias, you'd want generate a balanced set of synthetic images $\\mathcal{X_\\textit{syn}}$ where the protected attribute and target label are de-correlated.\n",
+ "\n",
+ "Concretely, let $f_t$ be a function from images to binary labels that approximates the target label $t$, and $f_g$ be a function from images to binary labels that approximates the protected attribute $g$. They learn these classifiers, $f_t$ and $f_g$, in a supervised fashion with the original data $\\mathcal{X}$. The synthetic dataset $\\mathcal{X_\\textit{syn}}$ should have the property that for $\\mathbf{x} \\in \\mathcal{X_\\textit{syn}}$:\n",
+ "\n",
+ "$$P\\left[{f_t}(\\mathbf{x}) = 1 | {f_g}(\\mathbf{x}) = 1 \\right] = P\\left[{f_t}(\\mathbf{x}) =1 \\right],$$\n",
+ "\n",
+ "such that attributes $t$ and $g$ are de-correlated. \n",
+ "\n",
+ "$\\mathcal{X_\\textit{syn}}$ can be generated with GAN trained on $\\mathcal{X}$, whose generator $G$ generates a synthetic image $\\mathbf{x}$ from a random latent vector $\\mathbf{z} \\in \\mathcal{Z}$. Then, ${f_t}(\\mathbf{x})$ and ${f_g}(\\mathbf{x})$ can be trained to assign semantic attribute labels to these images and augment the real-world dataset. However, as the GAN inherits correlations from its training data, a random sampling of $\\mathbf{z}$ will produce a $\\mathcal{X_\\textit{syn}}$ with similar correlations and biases as $\\mathcal{X}$. To get around this, the authors propose a latent vector perturbation method that allows generation of a de-biased $\\mathcal{X_\\textit{syn}}$."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "O3lwKa3W3ax5"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "s4HzXtCf3a0y"
+ },
+ "source": [
+ "The approach is motivated by the assumption that the latent space is approximately linearly separable in the semantic attributes (Denton et al. 2019). Essentially, this means that it's possible to construct linear functions that map biased $\\mathbf{z}$ vectors to de-biased $\\mathbf{z'}$ vectors by learning hyperplanes that separate the two attributes in latent space.\n",
+ "\n",
+ "To do so, first sample a random set of biased latent vectors $Z \\subseteq \\mathcal{Z}$ and train classifiers $h_t, h_g \\colon \\mathcal{Z} \\rightarrow [-1, 1]$ in the latent space that approximate ${f_t} \\circ G$ and ${f_g} \\circ G$, respectively. In other words, you to learn classifiers such that\n",
+ "\n",
+ "\\begin{align*}\n",
+ " h_t(\\mathbf{z}) &\\triangleq f_t(G(\\mathbf{z})) \\\\\n",
+ " h_g(\\mathbf{z}) &\\triangleq f_g(G(\\mathbf{z}))\n",
+ "\\end{align*}\n",
+ "\n",
+ "Now, you can use your classifiers to map a given a latent vector $\\mathbf{z}$, to a complementary vector $\\mathbf{z}'$ with the same predicted target label, but the opposite predicted protected attribute label.\n",
+ "\n",
+ "\\begin{align*}\n",
+ " h_t(\\mathbf{z}') &\\triangleq h_t(\\mathbf{z}) \\\\\n",
+ " h_g(\\mathbf{z}') &\\triangleq -h_g(\\mathbf{z})\n",
+ "\\end{align*}\n",
+ "\n",
+ "Note that this data generation method is agnostic to the type of classifier used to compute $h$, but following (Denton et al. 2019), you can represent $h_t(\\mathbf{z}) = \\mathbf{w}_t^\\top\\mathbf{z}$ and $h_g(\\mathbf{z}) = \\mathbf{w}_g^\\top\\mathbf{z}$ as linear models for the target and protected attributes with intercepts $b_t$ and $b_g$, respectively. With $\\|\\mathbf{w}_t\\| = \\|\\mathbf{w}_g\\| = 1$ constrained to the hypersphere, there is a closed-form solution for $\\mathbf{z}'$:\n",
+ "\n",
+ "$$\\mathbf{z}' = \\mathbf{z} - 2\\left(\\frac{\\mathbf{w}_g^T \\mathbf{z} +b_g}{1 - (\\mathbf{w}_g^T \\mathbf{w}_t)^2}\\right) \\left(\\mathbf{w}_g - (\\mathbf{w}_g^T \\mathbf{w}_t) \\mathbf{w}_t \\right).$$\n",
+ "\n",
+ "\n",
+ "You now have a sampling process that results in a de-biased synthetic image for every biased synthetic image:\n",
+ "- $\\mathbf{x}=G(\\mathbf{z})$ with target label ${f_t}(G(\\mathbf{z}))$ and protected attribute label ${f_g}(G(\\mathbf{z}))$\n",
+ "- $\\mathbf{x}'=G(\\mathbf{z}')$ with target label ${f_t}(G(\\mathbf{z}))$ and protected attribute label $-{f_g}(G(\\mathbf{w}))$."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "5BQfvRnPvrfe"
+ },
+ "source": [
+ "## Demonstration: How to find $\\mathbf{z}'$ from $\\mathbf{z}$\n",
+ "\n",
+ "This section walks through the proposed latent vector perturbation with a toy example, where latent vectors for each $(t, g)$ group are sampled from slightly different distributions.\n",
+ "\n",
+ "In practice, $\\mathbf{z}$ would be a latent vector sampled from a trained GAN, $t$ would be the target attribute label for $G(\\mathbf{z})$ predicted by $f_t$, and $g$ would be the protected attribute label for $G(\\mathbf{z})$ predicted by $f_g$. Like always, begin by first importing some useful libraries."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "wutEWPNDu9Kl"
+ },
+ "source": [
+ "# Import libraries.\n",
+ "import numpy as np\n",
+ "np.random.seed(123)\n",
+ "from sklearn import svm\n",
+ "import matplotlib.pyplot as plt"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "bMFKLm4kRNda"
+ },
+ "source": [
+ "Next, generate a dataset of $\\mathbf{z}$ noise vectors and label them with whether they exhibit attributes $t$ and/or $g$."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "lH3E0lpZzAfT"
+ },
+ "source": [
+ "# Randomly sample 512-dimensional latent vectors.\n",
+ "z_t0g0 = np.random.normal(0.1, 1, size=(6000, 512)) # contains neither t or g\n",
+ "z_t0g1 = np.random.normal(0.2, 1, size=(1000, 512)) # contains g, but not t \n",
+ "z_t1g0 = np.random.normal(-0.1, 1, size=(1000, 512)) # contains t, but not g\n",
+ "z_t1g1 = np.random.normal(-0.2, 1, size=(2000, 512)) # contains both t and g\n",
+ "\n",
+ "# Stack everything so that all properties can be indexed from the array.\n",
+ "z = np.vstack((z_t0g0, z_t0g1, z_t1g0, z_t1g1))\n",
+ "\n",
+ "# Label the examples with whether they contain t.\n",
+ "t = np.zeros(10000)\n",
+ "t[:7000] = 0\n",
+ "t[7000:] = 1\n",
+ "\n",
+ "# Label the examples with whether they contain g.\n",
+ "g = np.zeros(10000)\n",
+ "g[:6000] = 0\n",
+ "g[6000:7000] = 1\n",
+ "g[7000:8000] = 0\n",
+ "g[8000:] = 1"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 221
+ },
+ "id": "MnrGoi272e_p",
+ "outputId": "79d8236f-0926-4b7b-f2ea-4221ed0db6fa"
+ },
+ "source": [
+ "# Visualize the distribution of the target and protected attributes.\n",
+ "plt.title('Distribution of t and g')\n",
+ "plt.bar(np.arange(2), [np.logical_and(t==0, g==0).sum(), np.logical_and(t==1, g==0).sum()], width=0.3, label='g=0')\n",
+ "plt.bar(np.arange(2)+0.3, [np.logical_and(t==0, g==1).sum(), np.logical_and(t==1, g==1).sum()], width=0.3, label='g=1')\n",
+ "plt.xticks((0.15, 1.15), ('t=0', 't=1'))\n",
+ "plt.legend(loc='best')\n",
+ "plt.show()"
+ ],
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "display_data",
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": [],
+ "needs_background": "light"
+ }
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "ZRSI__8twAFr"
+ },
+ "source": [
+ "# Split the data into training and validation sets.\n",
+ "train_indices = np.random.choice(10000, size=4000, replace=False)\n",
+ "val_indices = np.random.choice(list(set(np.arange(10000))-set(train_indices)), size=1000, replace=False)\n",
+ "test_indices = np.array(list(set(np.arange(10000)) - set(train_indices) - set(val_indices)))\n",
+ "\n",
+ "z_train = z[train_indices]\n",
+ "t_train = t[train_indices]\n",
+ "g_train = g[train_indices]\n",
+ "\n",
+ "z_val = z[val_indices]\n",
+ "t_val = t[val_indices]\n",
+ "g_val = g[val_indices]\n",
+ "\n",
+ "z_test = z[test_indices]\n",
+ "t_test = t[test_indices]\n",
+ "g_test = g[test_indices]"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "5lVzrw3bRfov"
+ },
+ "source": [
+ "After creating training, validation, and test splits, you can now train your latent space attribute classifiers $h_t$ and $h_g$ to learn the attributes of $\\mathbf{z}$s in the training set. Don't forget to normalize both $\\mathbf{w}_t$ and $\\mathbf{w}_g$ so that there's a closed-form solution to $\\mathbf{z} \\mapsto \\mathbf{z}'$."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "nqt7W85wxRO9"
+ },
+ "source": [
+ "# Fit a target attribute classifier in the latent space using a linear SVM.\n",
+ "h_t = svm.LinearSVC(max_iter=50000)\n",
+ "h_t.fit(z_train, t_train)\n",
+ "\n",
+ "# Normalize so that w_t has norm 1.\n",
+ "w_t_norm = np.linalg.norm(h_t.coef_)\n",
+ "h_t.coef_ = h_t.coef_ / (w_t_norm) # w_t\n",
+ "h_t.intercept_ = h_t.intercept_ / w_t_norm # b_t"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "JykVRbYqwN0v"
+ },
+ "source": [
+ "# Fit a protected attribute classifier in the latent space using a linear SVM.\n",
+ "h_g = svm.LinearSVC(max_iter=50000) \n",
+ "h_g.fit(z_train, g_train)\n",
+ "\n",
+ "# Normalize so that w_g has norm 1.\n",
+ "w_g_norm = np.linalg.norm(h_g.coef_)\n",
+ "h_g.coef_ = h_g.coef_ / (w_g_norm)\n",
+ "h_g.intercept_ = h_g.intercept_ / w_g_norm"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "rkMYCdKASDiB"
+ },
+ "source": [
+ "You should then check the accuracy of your trained classifiers to see how well they perform on the validation set."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "xOAqQpMo0cCD",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "outputId": "4d9c6fe9-3891-4802-edee-a9713ff4b0cd"
+ },
+ "source": [
+ "# Run inference with h(z) = w^T z + b.\n",
+ "t_val_prediction = np.sum(h_t.coef_ * z_val, axis=1) + h_t.intercept_\n",
+ "g_val_prediction = np.sum(h_g.coef_ * z_val, axis=1) + h_g.intercept_\n",
+ "\n",
+ "# Calculate prediction accuracy\n",
+ "t_val_correct = np.logical_and(t_val == 1, t_val_prediction >= 0).sum() + np.logical_and(t_val == 0, t_val_prediction < 0).sum()\n",
+ "g_val_correct = np.logical_and(g_val == 1, g_val_prediction >= 0).sum() + np.logical_and(g_val == 0, g_val_prediction < 0).sum()\n",
+ "print('Accuracy of t classification: {}%'.format(t_val_correct / 1000 * 100))\n",
+ "print('Accuracy of g classification: {}%'.format(g_val_correct / 1000 * 100))"
+ ],
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "text": [
+ "Accuracy of t classification: 98.3%\n",
+ "Accuracy of g classification: 78.5%\n"
+ ],
+ "name": "stdout"
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "X99egM1ZStXd"
+ },
+ "source": [
+ "Now that you have your trained classifiers, it's now possible to derive the closed form solution to $\\mathbf{z}'$. Recall that the equation for this is\n",
+ "\n",
+ "\\begin{align*}\n",
+ " \\mathbf{z}' = \\mathbf{z} - 2\\left(\\frac{\\mathbf{w}_g^T \\mathbf{z} +b_g}{1 - (\\mathbf{w}_g^T \\mathbf{w}_t)^2}\\right) \\left(\\mathbf{w}_g - (\\mathbf{w}_g^T \\mathbf{w}_t) \\mathbf{w}_t \\right).\n",
+ "\\end{align*}\n",
+ "\n",
+ "Note that you can pre-compute some of the terms in this equation that don't depend on $\\mathbf{z}$ so that you don't have to re-compute them. Specifically,\n",
+ "\n",
+ "\\begin{align*}\n",
+ " \\mathbf{w}_{g\\perp t} &\\triangleq \\mathbf{w}_g - (\\mathbf{w}_g^T \\mathbf{w}_t) \\mathbf{w}_t \\\\\n",
+ " \\sin^2(\\angle \\mathbf{w}_g\\mathbf{w}_t) &\\triangleq 1 - (\\mathbf{w}_g^T \\mathbf{w}_t)^2\n",
+ "\\end{align*}"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "hIQBahM2xxo2"
+ },
+ "source": [
+ "# Calculate useful information.\n",
+ "g_perp_t = h_g.coef_ - (np.sum(h_g.coef_* h_t.coef_)) * h_t.coef_\n",
+ "g_perp_t = g_perp_t / np.linalg.norm(g_perp_t)\n",
+ " \n",
+ "cos_theta = np.sum(h_g.coef_ * h_t.coef_)\n",
+ "sin_theta = np.sqrt(1 - cos_theta * cos_theta) # cos(theta)^2 + sin(theta)^2 = 1\n",
+ " \n",
+ "# For every z, find z' with flipped protected attribute.\n",
+ "z_prime = np.zeros((5000, 512))\n",
+ "for j in range(5000):\n",
+ " dist = np.sum(h_g.coef_ * z_test[j]) + h_g.intercept_ # w_g^T z_j + b_g\n",
+ " z_prime[j] = z_test[j] - ((2 * dist) / sin_theta) * g_perp_t # closed form solution for z'"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ZCjAGbDrV4J2"
+ },
+ "source": [
+ "Now that you've computed $\\mathbf{z}' \\in \\mathcal{X}_{syn}$ for each $\\mathbf{z} \\in \\mathcal{X}$, you can plot the classifier scores for each $(\\mathbf{z}, \\mathbf{z}')$ and visualize the distribution of scores across both of your datasets."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 84
+ },
+ "id": "gknxA5fQuzkT",
+ "outputId": "b763a084-b41c-4c19-946f-a38097553009"
+ },
+ "source": [
+ "# Compare target attribute score distributions.\n",
+ "fig, axs = plt.subplots(1, 4, figsize=(20, 4))\n",
+ " \n",
+ "# Distribution of initial target attribute scores with z.\n",
+ "z_test_g0 = z_test[np.where(g_test == 0)]\n",
+ "z_test_g1 = z_test[np.where(g_test == 1)]\n",
+ "scores_g0 = np.sum(h_t.coef_ * z_test_g0, axis=1) + h_t.intercept_\n",
+ "scores_g1 = np.sum(h_t.coef_ * z_test_g1, axis=1) + h_t.intercept_\n",
+ " \n",
+ "axs[0].hist(scores_g0, bins=50, color='red', alpha=0.5)\n",
+ "axs[0].axvline(x=0)\n",
+ "axs[0].title.set_text('Target score distributions for z (g=0)')\n",
+ "axs[1].hist(scores_g1, bins=50, color='blue', alpha=0.5)\n",
+ "axs[1].axvline(x=0)\n",
+ "axs[1].title.set_text('Target score distributions for z (g=1)')\n",
+ " \n",
+ "# Distribution of target attribute scores with z_prime.\n",
+ "z_test_g0 = np.concatenate([z_test[np.where(g_test == 0)], z_prime[np.where(g_test == 1)]])\n",
+ "z_test_g1 = np.concatenate([z_test[np.where(g_test == 1)], z_prime[np.where(g_test == 0)]])\n",
+ "scores_g0 = np.sum(h_t.coef_ * z_test_g0, axis=1) + h_t.intercept_\n",
+ "scores_g1 = np.sum(h_t.coef_ * z_test_g1, axis=1) + h_t.intercept_\n",
+ " \n",
+ "axs[2].hist(scores_g0, bins=50, color='red', alpha=0.5)\n",
+ "axs[2].axvline(x=0)\n",
+ "axs[2].title.set_text('Target score distributions for z\\' (g=0)')\n",
+ "axs[3].hist(scores_g1, bins=50, color='blue', alpha=0.5)\n",
+ "axs[3].axvline(x=0)\n",
+ "axs[3].title.set_text('Target score distributions for z\\' (g=1)')\n",
+ " \n",
+ "plt.show()"
+ ],
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "display_data",
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": [],
+ "needs_background": "light"
+ }
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "xn-OE9KP5K-E"
+ },
+ "source": [
+ "On the left, you can see that $\\mathbf{z}$'s target attribute score distributions are different for $g=0$ and $g=1$ samples. In contrast, on the right you can see that for $\\mathbf{z}'$, the target attribute score distributions are similar for the two protected attribute classes. What the identical distributions for $g$ from $\\mathbf{z}'$ means is that even though attributes $(t, g)$ may be correlated to some extent in your original dataset $\\mathcal{X}$, your classifier trained on the de-biased $\\mathcal{z}'$ does not pick up on any of the correlation."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "D1KNxxksi5aR"
+ },
+ "source": [
+ "## Results\n",
+ "\n",
+ "Below is a comparison of the classifier trained with $\\mathcal{X}$ and $\\mathcal{X}_{syn}$ with a baseline model trained on $\\mathcal{X}$. The models are evaluated with average precision (AP) and three fairness metrics: difference in equality of opportunity ([DEO](https://papers.nips.cc/paper/2016/hash/9d2682367c3935defcb1f9e247a97c0d-Abstract.html)), bias amplification ([BA](https://arxiv.org/abs/1707.09457)), and KL divergence between score histograms ([KL](http://proceedings.mlr.press/v124/chen20b.html)). Specifically, the authors conduct experiments with 26 (target) attributes in the [CelebA](http://mmlab.ie.cuhk.edu.hk/projects/CelebA.html) dataset. For all experiments, the protected attribute is gender expression. The results are averaged for each target attribute category: inconsistently labeled, gender-dependent, and gender-independent.\n",
+ "\n",
+ "The classifier trained with $\\mathcal{X}$ and $\\mathcal{X}_{syn}$ performs better on all three fairness metrics (DEO, BA, KL) while maintaining comparable AP. The paper contains an in-depth analysis of the method and comparison to existing literature. Their findings show the promise of augmenting data in the GAN latent space in a variety of settings."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "nYPeOAibjT3m"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "q0CFVK_038Zf"
+ },
+ "source": [
+ "## Discussion\n",
+ "\n",
+ "The authors state that the goal of their work is to examine and mitigate biases of sensitive attributes such as gender expression, race, or age in visual classifiers. However, visual manipulations or explicit classifications along these dimensions have the potential to perpetuate harmful stereotypes. Hence for illustrations, they use **wearing glasses** as the protected attribute, as it has a clear visual signal. \n",
+ "\n",
+ "Furthermore, they choose not to show examples of image manipulations. Manipulating images in order to change sensitive attributes is inherently problematic, as it suggests that these attributes can be learned from images and that there is a clear delineation between having and not having the attribute. This is simply not true for multiple reasons. For example, consider the sensitive attribute **gender**. **Gender** is an innate sense of self and is not dependent on presentation. Even considering **gender expression** as the sensitive attribute is flawed (although a little less so) since things that are considered \"masculine\" are heavily dependent on social and cultural contexts. Moreover, neither **gender** nor **gender expression** are binary attributes, although they are labeled as such in most present-day image datasets. Finally, generated images are likely to preserve several stereotypes, even if the image generation process tries to eradicate others. For example, images labeled as \"masculine\" might often have short hair.\n",
+ "\n",
+ "For these reasons, they suggest treating the manipulated images as part of the model's learned representation and using them only as an intermediate step for training de-biased attribute classifiers. \n",
+ "\n",
+ "With this in mind, try out their method at [github.com/princetonvisualai/gan-debiasing](https://github.com/princetonvisualai/gan-debiasing)!\n",
+ "\n"
+ ]
+ }
+ ]
+}
\ No newline at end of file
![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\"){kind=icon}