Course 2/Week 2/Week 2 Bias.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gtuicEyI9znr"
   },
   "source": [
    "# Bias"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "CzKJcDsE93Ko"
   },
   "source": [
    "### Goals\n",
    "In this notebook, you're going to explore a way to identify some biases of a GAN using a classifier, in a way that's well-suited for attempting to make a model independent of an input. Note that not all biases are as obvious as the ones you will see here.\n",
    "\n",
    "### Learning Objectives\n",
    "1.  Be able to distinguish a few different kinds of bias in terms of demographic parity, equality of odds, and equality of opportunity (as proposed [here](http://m-mitchell.com/papers/Adversarial_Bias_Mitigation.pdf)).\n",
    "2. Be able to use a classifier to try and detect biases in a GAN by analyzing the generator's implicit associations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "a5Qyl-AnEww0"
   },
   "source": [
    "\n",
    "## Challenges\n",
    "\n",
    "One major challenge in assessing bias in GANs is that you still want your generator to be able to generate examples of different values of a protected class—the class you would like to mitigate bias against. While a classifier can be optimized to have its output be independent of a protected class, a generator which generates faces should be able to generate examples of various protected class values. \n",
    "\n",
    "When you generate examples with various values of a protected class, you don’t want those examples to correspond to any properties that aren’t strictly a function of that protected class. This is made especially difficult since many protected classes (e.g. gender or ethnicity) are social constructs, and what properties count as “a function of that protected class” will vary depending on who you ask. It’s certainly a hard balance to strike.\n",
    "\n",
    "Moreover, a protected class is rarely used to condition a GAN explicitly, so it is often necessary to resort to somewhat post-hoc methods (e.g. using a classifier trained on relevant features, which might be biased itself). \n",
    "\n",
    "In this assignment, you will learn one approach to detect potential bias, by analyzing correlations in feature classifications on the generated images. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "wEX6YjIbYLFC"
   },
   "source": [
    "## Getting Started\n",
    "\n",
    "As you have done previously, you will start by importing some useful libraries and defining a visualization function for your images. You will also use the same generator and basic classifier from previous weeks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_xe0xOhIQswC"
   },
   "source": [
    "#### Packages and Visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7_10LYXRsrWo"
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "from torch import nn\n",
    "from tqdm.auto import tqdm\n",
    "from torchvision import transforms\n",
    "from torchvision.utils import make_grid\n",
    "from torchvision.datasets import CelebA\n",
    "from torch.utils.data import DataLoader\n",
    "import matplotlib.pyplot as plt\n",
    "torch.manual_seed(0) # Set for our testing purposes, please do not change!\n",
    "\n",
    "def show_tensor_images(image_tensor, num_images=16, size=(3, 64, 64), nrow=3):\n",
    "    '''\n",
    "    Function for visualizing images: Given a tensor of images, number of images,\n",
    "    size per image, and images per row, plots and prints the images in an uniform grid.\n",
    "    '''\n",
    "    image_tensor = (image_tensor + 1) / 2\n",
    "    image_unflat = image_tensor.detach().cpu()\n",
    "    image_grid = make_grid(image_unflat[:num_images], nrow=nrow)\n",
    "    plt.imshow(image_grid.permute(1, 2, 0).squeeze())\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zv9hWdknQziZ"
   },
   "source": [
    "#### Generator and Noise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "3zYUIaz6Qz9_"
   },
   "outputs": [],
   "source": [
    "class Generator(nn.Module):\n",
    "    '''\n",
    "    Generator Class\n",
    "    Values:\n",
    "        z_dim: the dimension of the noise vector, a scalar\n",
    "        im_chan: the number of channels in the images, fitted for the dataset used, a scalar\n",
    "              (CelebA is rgb, so 3 is your default)\n",
    "        hidden_dim: the inner dimension, a scalar\n",
    "    '''\n",
    "    def __init__(self, z_dim=10, im_chan=3, hidden_dim=64):\n",
    "        super(Generator, self).__init__()\n",
    "        self.z_dim = z_dim\n",
    "        # Build the neural network\n",
    "        self.gen = nn.Sequential(\n",
    "            self.make_gen_block(z_dim, hidden_dim * 8),\n",
    "            self.make_gen_block(hidden_dim * 8, hidden_dim * 4),\n",
    "            self.make_gen_block(hidden_dim * 4, hidden_dim * 2),\n",
    "            self.make_gen_block(hidden_dim * 2, hidden_dim),\n",
    "            self.make_gen_block(hidden_dim, im_chan, kernel_size=4, final_layer=True),\n",
    "        )\n",
    "\n",
    "    def make_gen_block(self, input_channels, output_channels, kernel_size=3, stride=2, final_layer=False):\n",
    "        '''\n",
    "        Function to return a sequence of operations corresponding to a generator block of DCGAN;\n",
    "        a transposed convolution, a batchnorm (except in the final layer), and an activation.\n",
    "        Parameters:\n",
    "            input_channels: how many channels the input feature representation has\n",
    "            output_channels: how many channels the output feature representation should have\n",
    "            kernel_size: the size of each convolutional filter, equivalent to (kernel_size, kernel_size)\n",
    "            stride: the stride of the convolution\n",
    "            final_layer: a boolean, true if it is the final layer and false otherwise \n",
    "                      (affects activation and batchnorm)\n",
    "        '''\n",
    "        if not final_layer:\n",
    "            return nn.Sequential(\n",
    "                nn.ConvTranspose2d(input_channels, output_channels, kernel_size, stride),\n",
    "                nn.BatchNorm2d(output_channels),\n",
    "                nn.ReLU(inplace=True),\n",
    "            )\n",
    "        else:\n",
    "            return nn.Sequential(\n",
    "                nn.ConvTranspose2d(input_channels, output_channels, kernel_size, stride),\n",
    "                nn.Tanh(),\n",
    "            )\n",
    "\n",
    "    def forward(self, noise):\n",
    "        '''\n",
    "        Function for completing a forward pass of the generator: Given a noise tensor, \n",
    "        returns generated images.\n",
    "        Parameters:\n",
    "            noise: a noise tensor with dimensions (n_samples, z_dim)\n",
    "        '''\n",
    "        x = noise.view(len(noise), self.z_dim, 1, 1)\n",
    "        return self.gen(x)\n",
    "\n",
    "def get_noise(n_samples, z_dim, device='cpu'):\n",
    "    '''\n",
    "    Function for creating noise vectors: Given the dimensions (n_samples, z_dim)\n",
    "    creates a tensor of that shape filled with random numbers from the normal distribution.\n",
    "    Parameters:\n",
    "        n_samples: the number of samples to generate, a scalar\n",
    "        z_dim: the dimension of the noise vector, a scalar\n",
    "        device: the device type\n",
    "    '''\n",
    "    return torch.randn(n_samples, z_dim, device=device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KeSVrnG1RAy4"
   },
   "source": [
    "#### Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "VqF54g4qRD-X"
   },
   "outputs": [],
   "source": [
    "class Classifier(nn.Module):\n",
    "    '''\n",
    "    Classifier Class\n",
    "    Values:\n",
    "        im_chan: the number of channels in the images, fitted for the dataset used, a scalar\n",
    "              (CelebA is rgb, so 3 is your default)\n",
    "        n_classes: the total number of classes in the dataset, an integer scalar\n",
    "        hidden_dim: the inner dimension, a scalar\n",
    "    '''\n",
    "    def __init__(self, im_chan=3, n_classes=2, hidden_dim=64):\n",
    "        super(Classifier, self).__init__()\n",
    "        self.classifier = nn.Sequential(\n",
    "            self.make_classifier_block(im_chan, hidden_dim),\n",
    "            self.make_classifier_block(hidden_dim, hidden_dim * 2),\n",
    "            self.make_classifier_block(hidden_dim * 2, hidden_dim * 4, stride=3),\n",
    "            self.make_classifier_block(hidden_dim * 4, n_classes, final_layer=True),\n",
    "        )\n",
    "\n",
    "    def make_classifier_block(self, input_channels, output_channels, kernel_size=4, stride=2, final_layer=False):\n",
    "        '''\n",
    "        Function to return a sequence of operations corresponding to a classifier block; \n",
    "        a convolution, a batchnorm (except in the final layer), and an activation (except in the final layer).\n",
    "        Parameters:\n",
    "            input_channels: how many channels the input feature representation has\n",
    "            output_channels: how many channels the output feature representation should have\n",
    "            kernel_size: the size of each convolutional filter, equivalent to (kernel_size, kernel_size)\n",
    "            stride: the stride of the convolution\n",
    "            final_layer: a boolean, true if it is the final layer and false otherwise \n",
    "                      (affects activation and batchnorm)\n",
    "        '''\n",
    "        if not final_layer:\n",
    "            return nn.Sequential(\n",
    "                nn.Conv2d(input_channels, output_channels, kernel_size, stride),\n",
    "                nn.BatchNorm2d(output_channels),\n",
    "                nn.LeakyReLU(0.2, inplace=True),\n",
    "            )\n",
    "        else:\n",
    "            return nn.Sequential(\n",
    "                nn.Conv2d(input_channels, output_channels, kernel_size, stride),\n",
    "            )\n",
    "\n",
    "    def forward(self, image):\n",
    "        '''\n",
    "        Function for completing a forward pass of the classifier: Given an image tensor, \n",
    "        returns an n_classes-dimension tensor representing classes.\n",
    "        Parameters:\n",
    "            image: a flattened image tensor with im_chan channels\n",
    "        '''\n",
    "        class_pred = self.classifier(image)\n",
    "        return class_pred.view(len(class_pred), -1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ZKyIEkWnYZ6J"
   },
   "source": [
    "## Specifying Parameters\n",
    "You will also need to specify a few parameters before you begin training:\n",
    "  *   z_dim: the dimension of the noise vector\n",
    "  *   batch_size: the number of images per forward/backward pass\n",
    "  *   device: the device type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-GLwMw2v8Vat"
   },
   "outputs": [],
   "source": [
    "z_dim = 64\n",
    "batch_size = 128\n",
    "device = 'cuda'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HSNXcCTfYVzY"
   },
   "source": [
    "## Train a Classifier (Optional)\n",
    "\n",
    "You're welcome to train your own classifier with this code, but you are provide a pre-trained one based on this architecture here which you can load and use in the next section. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "HwBG8BGq64OJ"
   },
   "outputs": [],
   "source": [
    "# You can run this code to train your own classifier, but there is a provided pre-trained one \n",
    "# If you'd like to use this, just run \"train_classifier(filename)\"\n",
    "# To train and save a classifier on the label indices to that filename\n",
    "def train_classifier(filename):\n",
    "    import seaborn as sns\n",
    "    import matplotlib.pyplot as plt\n",
    "\n",
    "    # You're going to target all the classes, so that's how many the classifier will learn\n",
    "    label_indices = range(40)\n",
    "\n",
    "    n_epochs = 3\n",
    "    display_step = 500\n",
    "    lr = 0.001\n",
    "    beta_1 = 0.5\n",
    "    beta_2 = 0.999\n",
    "    image_size = 64\n",
    "\n",
    "    transform = transforms.Compose([\n",
    "        transforms.Resize(image_size),\n",
    "        transforms.CenterCrop(image_size),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\n",
    "    ])\n",
    "\n",
    "    dataloader = DataLoader(\n",
    "        CelebA(\".\", split='train', download=True, transform=transform),\n",
    "        batch_size=batch_size,\n",
    "        shuffle=True)\n",
    "\n",
    "    classifier = Classifier(n_classes=len(label_indices)).to(device)\n",
    "    class_opt = torch.optim.Adam(classifier.parameters(), lr=lr, betas=(beta_1, beta_2))\n",
    "    criterion = nn.BCEWithLogitsLoss()\n",
    "\n",
    "    cur_step = 0\n",
    "    classifier_losses = []\n",
    "    # classifier_val_losses = []\n",
    "    for epoch in range(n_epochs):\n",
    "        # Dataloader returns the batches\n",
    "        for real, labels in tqdm(dataloader):\n",
    "            real = real.to(device)\n",
    "            labels = labels[:, label_indices].to(device).float()\n",
    "\n",
    "            class_opt.zero_grad()\n",
    "            class_pred = classifier(real)\n",
    "            class_loss = criterion(class_pred, labels)\n",
    "            class_loss.backward() # Calculate the gradients\n",
    "            class_opt.step() # Update the weights\n",
    "            classifier_losses += [class_loss.item()] # Keep track of the average classifier loss\n",
    "\n",
    "            ### Visualization code ###\n",
    "            if cur_step % display_step == 0 and cur_step > 0:\n",
    "                class_mean = sum(classifier_losses[-display_step:]) / display_step\n",
    "                print(f\"Step {cur_step}: Classifier loss: {class_mean}\")\n",
    "                step_bins = 20\n",
    "                x_axis = sorted([i * step_bins for i in range(len(classifier_losses) // step_bins)] * step_bins)\n",
    "                sns.lineplot(x_axis, classifier_losses[:len(x_axis)], label=\"Classifier Loss\")\n",
    "                plt.legend()\n",
    "                plt.show()\n",
    "                torch.save({\"classifier\": classifier.state_dict()}, filename)\n",
    "            cur_step += 1\n",
    "\n",
    "# Uncomment the last line to train your own classfier - this line will not work in Coursera.\n",
    "# If you'd like to do this, you'll have to download it and run it, ideally using a GPU.\n",
    "# train_classifier(\"filename\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Iu1TcEA3aSSI"
   },
   "source": [
    "## Loading the Pre-trained Models\n",
    "\n",
    "You can now load the pre-trained generator (trained on CelebA) and classifier using the following code. If you trained your own classifier, you can load that one here instead. However, it is suggested that you first go through the assignment using the pre-trained one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "OgrLujk_tYDu",
    "outputId": "d6ba10d8-1579-44ee-a26a-a224b32a47c5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded the models!\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "gen = Generator(z_dim).to(device)\n",
    "gen_dict = torch.load(\"pretrained_celeba.pth\", map_location=torch.device(device))[\"gen\"]\n",
    "gen.load_state_dict(gen_dict)\n",
    "gen.eval()\n",
    "\n",
    "n_classes = 40\n",
    "classifier = Classifier(n_classes=n_classes).to(device)\n",
    "class_dict = torch.load(\"pretrained_classifier.pth\", map_location=torch.device(device))[\"classifier\"]\n",
    "classifier.load_state_dict(class_dict)\n",
    "classifier.eval()\n",
    "print(\"Loaded the models!\")\n",
    "\n",
    "opt = torch.optim.Adam(classifier.parameters(), lr=0.01)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "AspUMgXOMS1b"
   },
   "source": [
    "## Feature Correlation\n",
    "Now you can generate images using the generator. By also using the classifier, you will be generating images with different amounts of the \"male\" feature.\n",
    "\n",
    "You are welcome to experiment with other features as the target feature, but it is encouraged that you initially go through the notebook as is before exploring."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "kASNj6nLz7kh"
   },
   "outputs": [],
   "source": [
    "# First you generate a bunch of fake images with the generator\n",
    "n_images = 256\n",
    "fake_image_history = []\n",
    "classification_history = []\n",
    "grad_steps = 30 # How many gradient steps to take\n",
    "skip = 2 # How many gradient steps to skip in the visualization\n",
    "\n",
    "feature_names = [\"5oClockShadow\", \"ArchedEyebrows\", \"Attractive\", \"BagsUnderEyes\", \"Bald\", \"Bangs\",\n",
    "\"BigLips\", \"BigNose\", \"BlackHair\", \"BlondHair\", \"Blurry\", \"BrownHair\", \"BushyEyebrows\", \"Chubby\",\n",
    "\"DoubleChin\", \"Eyeglasses\", \"Goatee\", \"GrayHair\", \"HeavyMakeup\", \"HighCheekbones\", \"Male\", \n",
    "\"MouthSlightlyOpen\", \"Mustache\", \"NarrowEyes\", \"NoBeard\", \"OvalFace\", \"PaleSkin\", \"PointyNose\", \n",
    "\"RecedingHairline\", \"RosyCheeks\", \"Sideburn\", \"Smiling\", \"StraightHair\", \"WavyHair\", \"WearingEarrings\", \n",
    "\"WearingHat\", \"WearingLipstick\", \"WearingNecklace\", \"WearingNecktie\", \"Young\"]\n",
    "\n",
    "n_features = len(feature_names)\n",
    "# Set the target feature\n",
    "target_feature = \"Male\"\n",
    "target_indices = feature_names.index(target_feature)\n",
    "noise = get_noise(n_images, z_dim).to(device)\n",
    "new_noise = noise.clone().requires_grad_()\n",
    "starting_classifications = classifier(gen(new_noise)).cpu().detach()\n",
    "\n",
    "# Additive direction (more of a feature)\n",
    "for i in range(grad_steps):\n",
    "    opt.zero_grad()\n",
    "    fake = gen(new_noise)\n",
    "    fake_image_history += [fake]\n",
    "    classifications = classifier(fake)\n",
    "    classification_history += [classifications.cpu().detach()]\n",
    "    fake_classes = classifications[:, target_indices].mean()\n",
    "    fake_classes.backward()\n",
    "    new_noise.data += new_noise.grad / grad_steps\n",
    "\n",
    "# Subtractive direction (less of a feature)\n",
    "new_noise = noise.clone().requires_grad_()\n",
    "for i in range(grad_steps):\n",
    "    opt.zero_grad()\n",
    "    fake = gen(new_noise)\n",
    "    fake_image_history += [fake]\n",
    "    classifications = classifier(fake)\n",
    "    classification_history += [classifications.cpu().detach()]\n",
    "    fake_classes = classifications[:, target_indices].mean()\n",
    "    fake_classes.backward()\n",
    "    new_noise.data -= new_noise.grad / grad_steps\n",
    "\n",
    "classification_history = torch.stack(classification_history)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "z7sGUfJlDZst"
   },
   "source": [
    "You've now generated image samples, which have increasing or decreasing amounts of the target feature. You can visualize the way in which that affects other classified features. The x-axis will show you the amount of change in your target feature and the y-axis shows how much the other features change, as detected in those images by the classifier. Together, you will be able to see the covariance of \"male-ness\" and other features.\n",
    "\n",
    "You are started off with a set of features that have interesting associations with \"male-ness\", but you are welcome to change the features in `other_features` with others from `feature_names`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 349
    },
    "colab_type": "code",
    "id": "5Q0b24CHDX8A",
    "outputId": "e325ebc5-9f2e-44a5-ee7c-70d391880350"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "# Set the other features\n",
    "other_features = [\"Smiling\", \"Bald\", \"Young\", \"HeavyMakeup\", \"Attractive\"]\n",
    "classification_changes = (classification_history - starting_classifications[None, :, :]).numpy()\n",
    "fig, ax = plt.subplots(figsize = (16,10))\n",
    "for other_feature in other_features:\n",
    "    other_indices = feature_names.index(other_feature)\n",
    "    with sns.axes_style(\"darkgrid\"):\n",
    "        sns.regplot(\n",
    "            classification_changes[:, :, target_indices].reshape(-1), \n",
    "            classification_changes[:, :, other_indices].reshape(-1), \n",
    "            fit_reg=True,\n",
    "            truncate=True,\n",
    "            ci=99,\n",
    "            x_ci=99,\n",
    "            x_bins=len(classification_history),\n",
    "            label=other_feature,\n",
    "            ax = ax\n",
    "        )\n",
    "plt.xlabel(target_feature)\n",
    "plt.ylabel(\"Other Feature\")\n",
    "plt.title(f\"Generator Biases: Features vs {target_feature}-ness\")\n",
    "plt.legend(loc=1)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6QOuJWDfZzpK"
   },
   "source": [
    "This correlation detection can be used to reduce bias by penalizing this type of correlation in the loss during the training of the generator. However, currently there is no rigorous and accepted solution for debiasing GANs. A first step that you can take in the right direction comes before training the model: make sure that your dataset is inclusive and representative, and consider how you can mitigate the biases resulting from whatever data collection method you used—for example, getting a representative labelers for your task. \n",
    "\n",
    "It is important to note that, as highlighted in the lecture and by many researchers including [Timnit Gebru and Emily Denton](https://sites.google.com/view/fatecv-tutorial/schedule), a diverse dataset alone is not enough to eliminate bias. Even diverse datasets can reinforce existing structural biases by simply capturing common social biases. Mitigating these biases is an important and active area of research.\n",
    "\n",
    "#### Note on CelebA\n",
    "You may have noticed that there are obvious correlations between the feature you are using, \"male\", and other seemingly unrelates features, \"smiling\" and \"young\" for example. This is because the CelebA dataset labels had no serious consideration for diversity. The data represents the biases their labelers, the dataset creators, the social biases as a result of using a dataset based on American celebrities, and many others. Equipped with knowledge about bias, we trust that you will do better in the future datasets you create."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "yHXjgqehz4vn"
   },
   "source": [
    "## Quantification\n",
    "Finally, you can also quantitatively evaluate the degree to which these factors covary. Given a target index, for example corresponding to \"male,\" you'll want to return the other features that covary with that target feature the most. You'll want to account for both large negative and positive covariances, and you'll want to avoid returning the target feature in your list of covarying features (since a feature will often have a high covariance with itself). You'll complete some helper functions first, each of which should be one or two lines long.\n",
    "\n",
    "<details>\n",
    "\n",
    "<summary>\n",
    "<font size=\"3\" color=\"green\">\n",
    "<b>Optional hints for <code><font size=\"4\">covariance_matrix_from_examples</font></code></b>\n",
    "</font>\n",
    "</summary>\n",
    "\n",
    "1.   You will likely find the following function useful: [np.cov](https://numpy.org/doc/stable/reference/generated/numpy.cov.html). Note the `rowvar` parameter.\n",
    "2.   You will probably find it useful to [reshape](https://numpy.org/doc/stable/reference/generated/numpy.reshape.html) the input.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "covariance_matrix_from_examples works!\n"
     ]
    }
   ],
   "source": [
    "from torch.distributions import MultivariateNormal\n",
    "def covariance_matrix_from_examples(examples):\n",
    "    \"\"\"\n",
    "    Helper function for get_top_covariances to calculate a covariance matrix. \n",
    "    Parameter: examples: a list of steps corresponding to samples of shape (2 * grad_steps, n_images, n_features)\n",
    "    Returns: the (n_features, n_features) covariance matrix from the examples\n",
    "    \"\"\"\n",
    "    # Hint: np.cov will be useful here - note the rowvar argument!\n",
    "    ### START CODE HERE ###\n",
    "    return np.cov(examples.reshape(-1, examples.shape[2]), rowvar=False)\n",
    "    ### END CODE HERE ###\n",
    "mean = torch.Tensor([0, 0, 0, 0]) \n",
    "covariance = torch.Tensor( \n",
    "    [[10, 2, -0.5, -5],\n",
    "     [2, 11, 5, 4],\n",
    "     [-0.5, 5, 10, 2],\n",
    "     [-5, 4, 2, 11]]\n",
    ")\n",
    "samples = MultivariateNormal(mean, covariance).sample((60 * 128,))\n",
    "foo = samples.reshape(60, 128, samples.shape[-1]).numpy()\n",
    "assert np.all(np.abs(covariance_matrix_from_examples(foo) - covariance.numpy()) < 0.5)\n",
    "print(\"covariance_matrix_from_examples works!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you'll write a helper function to return the indices of a numpy array in order of magnitude.\n",
    "<details>\n",
    "<summary>\n",
    "<font size=\"3\" color=\"green\">\n",
    "<b>Optional hints for <code><font size=\"4\">get_top_magnitude_indices</font></code></b>\n",
    "</font>\n",
    "</summary>\n",
    "\n",
    "4.   Feel free to use any reasonable method to get the largest elements - you may find [np.argsort](https://numpy.org/doc/stable/reference/generated/numpy.argsort.html) useful here.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "get_top_magnitude_indices works!\n"
     ]
    }
   ],
   "source": [
    "def get_top_magnitude_indices(values):\n",
    "    \"\"\"\n",
    "    Helper function for get_top_covariances to get indices by magnitude. \n",
    "    Parameter: values, a list of values as a numpy array of shape (n_values)\n",
    "    Returns: numpy array of indices sorted from greatest to least by the magnitudes of their corresponding values\n",
    "    \"\"\"\n",
    "    # Hint: This can be done in one or two lines using np.argsort and np.abs!\n",
    "    ### START CODE HERE ###\n",
    "    top_indices = np.abs(values).argsort()[::-1]\n",
    "    ### END CODE HERE ###\n",
    "    return top_indices\n",
    "assert get_top_magnitude_indices([3, 2, 1, 0]).tolist() == [0, 1, 2, 3]\n",
    "assert get_top_magnitude_indices([-2, 0, 1]).tolist() == [0, 2, 1]\n",
    "print(\"get_top_magnitude_indices works!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you'll write a helper function to return a list with an element removed by the value, in an unchanged order. In this case, you won't have to remove any values multiple times, so don't worry about how you handle multiple examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "remove_from_list works!\n"
     ]
    }
   ],
   "source": [
    "def remove_from_list(indices, index_to_remove):\n",
    "    \"\"\"\n",
    "    Helper function for get_top_covariances to remove an index from an array. \n",
    "    Parameter: indices, a list of indices as a numpy array of shape (n_indices)\n",
    "    Returns: the numpy array of indices in the same order without index_to_remove\n",
    "    \"\"\"\n",
    "    # Hint: There are many ways to do this, but please don't edit the list in-place.\n",
    "    # If you're not very familiar with array indexing, you may find this page helpful:\n",
    "    # https://numpy.org/devdocs/reference/arrays.indexing.html (especially boolean indexing)\n",
    "    ### START CODE HERE ###\n",
    "    new_indices = np.delete(indices, np.where(indices == index_to_remove))\n",
    "    ### END CODE HERE ###\n",
    "    return new_indices\n",
    "assert remove_from_list(np.array([3, 2, 1, 0]), 1).tolist() == [3, 2, 0]\n",
    "print(\"remove_from_list works!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, you can put the above helper functions together.\n",
    "\n",
    "<details>\n",
    "<summary>\n",
    "<font size=\"3\" color=\"green\">\n",
    "<b>Optional hints for <code><font size=\"4\">get_top_covariances</font></code></b>\n",
    "</font>\n",
    "</summary>\n",
    "\n",
    "1.   Start by finding the covariance matrix\n",
    "3.   The target feature should not be included in the outputs.\n",
    "5.   It may be easiest to solve this if you find the `relevant_indices` first, and then use `relevant_indices` to calculate `highest_covariances`.\n",
    "6.   You want to sort by absolute value but return the actual values.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ZqoowVhFGzOH"
   },
   "outputs": [],
   "source": [
    "# UNQ_C1 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
    "# GRADED CELL: get_top_covariances\n",
    "def get_top_covariances(classification_changes, target_index, top_n=10):\n",
    "    '''\n",
    "    Function for getting the top n covariances: Given a list of classification changes\n",
    "    and the index of the target feature, returns \n",
    "    (1) relevant_indices: a list or tensor (numpy or torch) of the indices corresponding \n",
    "        to the n features that covary most with the target in terms of absolute covariance\n",
    "    (2) highest_covariances: a list or tensor of the degrees to which they covary.\n",
    "    Parameters:\n",
    "        classification_changes: relative changes in classifications of each generated image \n",
    "          resulting from optimizing the target feature (see above for a visualization)\n",
    "        target_index: the index of the target feature, a scalar\n",
    "        top_n: the top most number of elements to return, default is 10\n",
    "    '''\n",
    "    # Hint: Don't forget you also care about negative covariances!\n",
    "    # Note that classification_changes has a shape of (2 * grad_steps, n_images, n_features) \n",
    "    # where n_features is the number of features measured by the classifier, and you are looking\n",
    "    # for the covariance of the features based on the (2 * grad_steps * n_images) samples.\n",
    "    #### START CODE HERE ####\n",
    "    cov_mat = covariance_matrix_from_examples(classification_changes)\n",
    "    relevant_indices = get_top_magnitude_indices(cov_mat[target_index, :])\n",
    "    relevant_indices = remove_from_list(relevant_indices, target_index)\n",
    "    relevant_indices = relevant_indices[:top_n]\n",
    "    highest_covariances = cov_mat[:, relevant_indices][target_index]\n",
    "    #### END CODE HERE ####\n",
    "    return relevant_indices, highest_covariances"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All tests passed\n"
     ]
    }
   ],
   "source": [
    "# UNIT TEST\n",
    "from torch.distributions import MultivariateNormal\n",
    "mean = torch.Tensor([0, 0, 0, 0]) \n",
    "covariance = torch.Tensor( \n",
    "    [[10, 2, -0.5, -5],\n",
    "     [2, 11, 5, 4],\n",
    "     [-0.5, 5, 10, 2],\n",
    "     [-5, 4, 2, 11]]\n",
    ")\n",
    "independent_dist = MultivariateNormal(mean, covariance)\n",
    "samples = independent_dist.sample((60 * 128,))\n",
    "foo = samples.reshape(60, 128, samples.shape[-1])\n",
    "\n",
    "relevant_indices, highest_covariances = get_top_covariances(foo, 1, top_n=3)\n",
    "assert (tuple(relevant_indices) == (2, 3, 0)), \"Make sure you're getting the greatest, not the least covariances\"\n",
    "assert np.all(np.abs(highest_covariances - [5, 4, 2]) < 0.5 )\n",
    "\n",
    "relevant_indices, highest_covariances = get_top_covariances(foo, 0, top_n=3)\n",
    "assert (tuple(relevant_indices) == (3, 1, 2)), \"Make sure to consider the magnitude of negative covariances\"\n",
    "assert np.all(np.abs(highest_covariances - [-5, 2, -0.5]) < 0.5 )\n",
    "\n",
    "relevant_indices, highest_covariances = get_top_covariances(foo, 2, top_n=2)\n",
    "assert (tuple(relevant_indices) == (1, 3))\n",
    "assert np.all(np.abs(highest_covariances - [5, 2]) < 0.5 )\n",
    "\n",
    "relevant_indices, highest_covariances = get_top_covariances(foo, 3, top_n=2)\n",
    "assert (tuple(relevant_indices) == (0, 1))\n",
    "assert np.all(np.abs(highest_covariances - [-5, 4]) < 0.5 )\n",
    "\n",
    "print(\"All tests passed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "cRdY3D3Yndwr"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[36 18 24 30  0 22 16 38  9 34]\n",
      "WearingLipstick  -2.952804\n",
      "HeavyMakeup  -2.706007\n",
      "NoBeard  -2.559993\n",
      "Sideburn  2.049643\n",
      "5oClockShadow  2.006910\n",
      "Mustache  1.998547\n",
      "Goatee  1.859621\n",
      "WearingNecktie  1.583784\n",
      "BlondHair  -1.241803\n",
      "WearingEarrings  -1.207931\n"
     ]
    }
   ],
   "source": [
    "relevant_indices, highest_covariances = get_top_covariances(classification_changes, target_indices, top_n=10)\n",
    "print(relevant_indices)\n",
    "assert relevant_indices[9] == 34\n",
    "assert len(relevant_indices) == 10\n",
    "assert highest_covariances[8] - (-1.2418) < 1e-3\n",
    "for index, covariance in zip(relevant_indices, highest_covariances):\n",
    "    print(f\"{feature_names[index]}  {covariance:f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TYKG365iKCNR"
   },
   "source": [
    "One of the major sources of difficulty with identifying bias and fairness, as discussed in the lectures, is that there are many ways you might reasonably define these terms. Here are three ways that are computationally useful and [widely referenced](http://m-mitchell.com/papers/Adversarial_Bias_Mitigation.pdf). They are, by no means, the only definitions of fairness (see more details [here](https://developers.google.com/machine-learning/glossary/fairness)):\n",
    "\n",
    "\n",
    "1.   Demographic parity: the overall distribution of the predictions made by a predictor is the same for different values of a protected class. \n",
    "2.   Equality of odds: all else being equal, the probability that you predict correctly or incorrectly is the same for different values of a protected class. \n",
    "2.   Equality of opportunity: all else being equal, the probability that you predict correctly is the same for different valus of a protected class (weaker than equality of odds).\n",
    "\n",
    "With GANs also being used to help downstream classifiers (you will see this firsthand in future assignments), these definitions of fairness will impact, as well as depend on, your downstream task. It is important to work towards creating a fair GAN according to the definition you choose. Pursuing any of them is virtually always better than blindly labelling data, creating a GAN, and sampling its generations."
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "C2W2_3: Bias (Student).ipynb",
   "provenance": []
  },
  "coursera": {
   "schema_names": [
    "GANSC2-2A"
   ]
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}