examples/09_Optimizing_CompositionalAUC_Loss_with_ResNet20_on_CIFAR10.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# **Optimizing Compositional AUROC loss on imbalanced dataset**\n",
        " **Author**: Zhuoning Yuan"
      ],
      "metadata": {
        "id": "sEpAVQ2Fwhk1"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zUv-WIY5h1Dh"
      },
      "source": [
        "**Introduction**\n",
        "\n",
        "In this tutorial, we will learn how to quickly train a ResNet20 model by optimizing AUC score using our novel compositional training framework [[Ref]](https://openreview.net/forum?id=gPvB4pdu_Z) on an binary image classification task on Cifar10. After completion of this tutorial, you should be able to use LibAUC to train your own models on your own datasets.  \n",
        "\n",
        "**Useful Resources**\n",
        "\n",
        "* Website: https://libauc.org\n",
        "* Github: https://github.com/Optimization-AI/LibAUC\n",
        "\n",
        "\n",
        "**References**\n",
        "\n",
        "If you find this tutorial helpful in your work,  please acknowledge our library and cite the following papers:\n",
        "<pre>\n",
        "@inproceedings{yuan2022compositional,\n",
        "    title={Compositional Training for End-to-End Deep AUC Maximization},\n",
        "    author={Zhuoning Yuan and Zhishuai Guo and Nitesh Chawla and Tianbao Yang},\n",
        "    booktitle={International Conference on Learning Representations},\n",
        "    year={2022},\n",
        "    url={https://openreview.net/forum?id=gPvB4pdu_Z}\n",
        "}\n",
        "</pre>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DEavjKBdh8hF"
      },
      "source": [
        "# **Installing LibAUC**\n",
        "Let's start with install our library here. In this tutorial, we will use version `1.2.0`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6zYjONxCh5Gz"
      },
      "outputs": [],
      "source": [
        "!pip install libauc==1.2.0"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6m-DLkddiPT9"
      },
      "source": [
        "# **Importing LibAUC**\n",
        "\n",
        "Import required packages to use\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7oZv1TakiUBF"
      },
      "outputs": [],
      "source": [
        "from libauc.losses import CompositionalAUCLoss\n",
        "from libauc.optimizers import PDSCA\n",
        "from libauc.models import resnet20 as ResNet20\n",
        "from libauc.datasets import CIFAR10, CIFAR100, STL10, CAT_VS_DOG\n",
        "from libauc.utils import ImbalancedDataGenerator\n",
        "from libauc.sampler import DualSampler\n",
        "from libauc.metrics import auc_roc_score\n",
        "\n",
        "import torch \n",
        "from PIL import Image\n",
        "import numpy as np\n",
        "import torchvision.transforms as transforms\n",
        "from torch.utils.data import Dataset"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Kd57DCDOilVL"
      },
      "source": [
        "# **Reproducibility**"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The following function `set_all_seeds` limits the number of sources of randomness behaviors, such as model intialization, data shuffling, etcs. However, completely reproducible results are not guaranteed across PyTorch releases [[Ref]](https://pytorch.org/docs/stable/notes/randomness.html#:~:text=Completely%20reproducible%20results%20are%20not,even%20when%20using%20identical%20seeds.)."
      ],
      "metadata": {
        "id": "ndENFEtPKJk4"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-dUoQpz5imKD"
      },
      "outputs": [],
      "source": [
        "def set_all_seeds(SEED):\n",
        "    # REPRODUCIBILITY\n",
        "    torch.manual_seed(SEED)\n",
        "    np.random.seed(SEED)\n",
        "    torch.backends.cudnn.deterministic = True\n",
        "    torch.backends.cudnn.benchmark = False"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y2wT1qzXiqCg"
      },
      "source": [
        "# **Image Dataset**\n",
        "\n",
        "\n",
        "Now that we defined the data input pipeline such as data augmentations. In this tutorials, we use `RandomCrop`, `RandomHorizontalFlip` as stated in the original paper. \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kCEq4vNairrd"
      },
      "outputs": [],
      "source": [
        "class ImageDataset(Dataset):\n",
        "    def __init__(self, images, targets, image_size=32, crop_size=30, mode='train'):\n",
        "       self.images = images.astype(np.uint8)\n",
        "       self.targets = targets\n",
        "       self.mode = mode\n",
        "       self.transform_train = transforms.Compose([                                                \n",
        "                              transforms.ToTensor(),\n",
        "                              transforms.RandomCrop((crop_size, crop_size), padding=None),\n",
        "                              transforms.RandomHorizontalFlip(),\n",
        "                              transforms.Resize((image_size, image_size)),\n",
        "                              ])\n",
        "       self.transform_test = transforms.Compose([\n",
        "                             transforms.ToTensor(),\n",
        "                             transforms.Resize((image_size, image_size)),\n",
        "                              ])\n",
        "    def __len__(self):\n",
        "        return len(self.images)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        image = self.images[idx]\n",
        "        target = self.targets[idx]\n",
        "        image = Image.fromarray(image.astype('uint8'))\n",
        "        if self.mode == 'train':\n",
        "            image = self.transform_train(image)\n",
        "        else:\n",
        "            image = self.transform_test(image)\n",
        "        return image, target"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J3FgOKRPivmD"
      },
      "source": [
        "## **Introduction for Loss and Optimizer**\n",
        "\n",
        "In this section, we will introduce how to utilize `CompositonalAUCLoss` function and `PDSCA` optimizer.  \n",
        "\n",
        "#### **CompositonalAUCLoss**\n",
        "The objective function for `CompositonalAUCLoss` is defined as\n",
        "\n",
        "$$\\min _{\\mathbf{w}} L_{\\mathrm{AUC}}\\left(\\mathbf{w}-\\alpha \\nabla L_{\\mathrm{CE}}(\\mathbf{w})\\right)$$\n",
        "which is implemented as `CompositionalAUCLoss()` function that consists of two loss `CrossEntropyLoss` (with sigmoid) and `AUCMLoss`. For the details of `AUCMLoss`, please refer to this [tutorial](https://github.com/Optimization-AI/LibAUC/blob/main/examples/02_Optimizing_AUROC_with_ResNet20_on_Imbalanced_CIFAR10.ipynb) and the [paper](https://arxiv.org/pdf/2012.03173.pdf).\n",
        "\n",
        "**PDSCA** is proposed and used to optimize the above objective function. For itearton $t$, the key updates are as follows: \n",
        "\n",
        "1.  $ \\mathbf{u}_{t+1}=(1-\\beta_{0}) \\mathbf{u}_{t}+\\beta_{0}(\\mathbf{w}_{\\mathbf{t}}-\\eta_0 \\nabla L_{CE}(\\mathbf{w}_{\\mathbf{t}}) ; a ; b)$ \n",
        "2. $ \\mathbf{z}_{t+1}=(1-\\beta_{1}) \\mathbf{z}_{t}+\\beta_{1} \\nabla_{\\mathbf{u}} L_{AUC}(\\mathbf{u}_{t+1})$ \n",
        "3. $ \\mathbf{v}_{t+1}=\\mathbf{v}_{t}-\\eta_{1} (\\mathbf{z}_{t+1}$ + $λ_0(\\mathbf{w}_t-\\mathbf{v}_{ref})+ λ_1\\mathbf{v}_t$) \n",
        "4. $ \\theta_{t+1}=\\theta_{t}+\\eta_{1} \\nabla_{\\theta} L_{AUC}(\\theta_{t})$\n",
        "\n",
        "where $\\lambda_0,\\lambda$ refer to `epoch_decay` and `weight_decay`, $\\eta_0,\\eta$ refer to learning rates for inner updates ($L_{CE}$) and outer updates ($L_{AUC}$), and $\\mathbf v_t$ refers to $\\{\\mathbf w_t, a_t, b_t\\}$ and $θ$ refers to dual variable in `AUCMLoss`. For more details, please refer to the paper [[ref]](https://openreview.net/pdf?id=gPvB4pdu_Z)."
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Hyper-parameters**\n",
        "\n",
        "**DualSampler**\n",
        "  - `batch_size`: how many samples per mini-batch used for training model \n",
        "  - `sampling_rate`: the oversampling ratio for the positive minority class (default: 0.0)\n",
        "  \n",
        "**Loss**\n",
        " - `margin`: margin for surrogate loss (i.e., squred hinge loss). It is intergrated with optimizer (default: 1.0)\n",
        " - `last_activation`: activation function on model's outputs for AUC loss, i.e., 'sigmoid', 'l2', None (default: 'sigmoid')\n",
        " \n",
        "**Optimizer**\n",
        "  - `lr`: learning rate\n",
        "  - `lr0`: learning rate refers to $\\alpha$ in step (1) (default: `lr`)\n",
        "  - `epoch_decay`: epoch decay (L2 penalty for epoch-level regularization) (default: 2e-3)\n",
        "  - `weight_decay`: weight decay (L2 penalty) (default: 1e-4)\n",
        "  - `beta0`: parameter for moving average in step (1) (Default: 0.9)\n",
        "  - `beta1`: parameter for moving average in step (2) (Default: 0.999)\n",
        "\n",
        "## **Useful Tips**\n",
        "- You can tune `sampling_rate` in (0, 0.5] when data is imbalanced\n",
        "- Use smaller `lr0` and larger `lr` can achieve good performance in some cases, e.g., `lr0=0.05`, `lr=0.1`\n",
        "- Don not include `sigmoid` activation before computing loss. The `CompositionalAUCLoss()` already includes `sigmoid`, `l2` activation \n",
        "- To manually update `lr` you can do `optimizer.param_groups[0]['lr'] = self.param_groups[0]['lr']/decay_factor`. Similar to `lr0`, you can modify `optimizer.param_groups[0]['lr0']`"
      ],
      "metadata": {
        "id": "NGF-rGhjIoSY"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "g8ReDBxeixFw"
      },
      "outputs": [],
      "source": [
        "# HyperParameters\n",
        "SEED = 123\n",
        "dataset = 'C10'\n",
        "imratio = 0.1\n",
        "BATCH_SIZE = 128\n",
        "total_epochs = 100 \n",
        "decay_epochs=[int(total_epochs*0.5), int(total_epochs*0.75)]\n",
        "\n",
        "margin = 1.0\n",
        "lr = 0.1  \n",
        "#lr0 = 0.1 # (default: lr0=lr unless you specify the value and pass it to optimizer)\n",
        "epoch_decay = 2e-3 \n",
        "weight_decay = 1e-4\n",
        "beta0 = 0.9   # e.g., [0.999, 0.99, 0.9]\n",
        "beta1 = 0.9   # e.g., [0.999, 0.99, 0.9] \n",
        "\n",
        "sampling_rate = 0.2"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Mmv9mBdvjA4l"
      },
      "source": [
        "# **Loading datasets**"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "In this step, we will use the [CIFAR10](http://yann.lecun.com/exdb/mnist/) as benchmark dataset. Before importing data to `dataloader`, we construct imbalanced version for CIFAR10 by `ImbalanceGenerator`. Specifically, it first randomly splits the training data by class ID (e.g., 10 classes) into two even portions as the positive and negative classes, and then it randomly removes some samples from the positive class to make\n",
        "it imbalanced. We keep the testing set untouched. We refer `imratio` to the ratio of number of positive examples to number of all examples. "
      ],
      "metadata": {
        "id": "QqzyXxLvInZ1"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O7fCXryRjB1Z",
        "outputId": "346bd007-43d4-4ba9-c147-1a8da8fc1703"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Files already downloaded and verified\n",
            "Files already downloaded and verified\n",
            "#SAMPLES: [27777], POS:NEG: [2777 : 25000], POS RATIO: 0.1000\n",
            "#SAMPLES: [10000], POS:NEG: [5000 : 5000], POS RATIO: 0.5000\n"
          ]
        }
      ],
      "source": [
        "if dataset == 'C10':\n",
        "    IMG_SIZE = 32\n",
        "    train_data, train_targets = CIFAR10(root='./data', train=True)\n",
        "    test_data, test_targets  = CIFAR10(root='./data', train=False)\n",
        "elif dataset == 'C100':\n",
        "    IMG_SIZE = 32\n",
        "    train_data, train_targets = CIFAR100(root='./data', train=True)\n",
        "    test_data, test_targets  = CIFAR100(root='./data', train=False)\n",
        "elif dataset == 'STL10':\n",
        "    BATCH_SIZE = 32\n",
        "    IMG_SIZE = 96\n",
        "    train_data, train_targets = STL10(root='./data/', split='train')\n",
        "    test_data, test_targets = STL10(root='./data/', split='test')\n",
        "elif dataset == 'C2':\n",
        "    IMG_SIZE = 50\n",
        "    train_data, train_targets  = CAT_VS_DOG('./data/', train=True)\n",
        "    test_data, test_targets = CAT_VS_DOG('./data/', train=False)\n",
        "\n",
        "(train_images, train_labels) = ImbalancedDataGenerator(verbose=True, random_seed=0).transform(train_data, train_targets, imratio=imratio)\n",
        "(test_images, test_labels) = ImbalancedDataGenerator(verbose=True, random_seed=0).transform(test_data, test_targets, imratio=0.5) \n",
        "\n",
        "trainSet = ImageDataset(train_images, train_labels, image_size=IMG_SIZE, crop_size=IMG_SIZE-2)\n",
        "trainSet_eval = ImageDataset(train_images, train_labels, image_size=IMG_SIZE, crop_size=IMG_SIZE-2, mode='test')\n",
        "testSet = ImageDataset(test_images, test_labels, image_size=IMG_SIZE, crop_size=IMG_SIZE-2, mode='test')\n",
        "\n",
        "# parameters for sampler\n",
        "sampler = DualSampler(trainSet, batch_size=BATCH_SIZE, sampling_rate=sampling_rate)\n",
        "trainloader = torch.utils.data.DataLoader(trainSet, batch_size=BATCH_SIZE, sampler=sampler, shuffle=False, num_workers=2)\n",
        "trainloader_eval = torch.utils.data.DataLoader(trainSet_eval, batch_size=BATCH_SIZE, shuffle=False, num_workers=2)\n",
        "testloader = torch.utils.data.DataLoader(testSet, batch_size=BATCH_SIZE, shuffle=False, num_workers=2)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Model, Loss & Optimizer**\n",
        "Before training, we need to define **model**, **loss function**, **optimizer**. "
      ],
      "metadata": {
        "id": "6GCtKxlBZnGl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "set_all_seeds(123)\n",
        "model = ResNet20(pretrained=False, last_activation=None, activations='relu', num_classes=1)\n",
        "model = model.cuda()\n",
        "    \n",
        "# Compositional Training\n",
        "loss_fn = CompositionalAUCLoss()  \n",
        "optimizer = PDSCA(model, \n",
        "                  loss_fn=loss_fn,\n",
        "                  lr=lr,\n",
        "                  beta1=beta0,\n",
        "                  beta2=beta1, \n",
        "                  margin=margin, \n",
        "                  epoch_decay=epoch_decay, \n",
        "                  weight_decay=weight_decay)"
      ],
      "metadata": {
        "id": "rUmU3E60Zqzi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yreaM0sSjQj0"
      },
      "source": [
        "# **Training**\n",
        "Now it's time for training\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print ('Start Training')\n",
        "print ('-'*30)\n",
        "\n",
        "train_log = []\n",
        "test_log = []\n",
        "for epoch in range(total_epochs):\n",
        "     if epoch in decay_epochs:\n",
        "         optimizer.update_regularizer(decay_factor=10, decay_factor0=10) # decrease learning rate by 10x & update regularizer\n",
        "   \n",
        "     train_loss = []\n",
        "     model.train()    \n",
        "     for data, targets in trainloader:\n",
        "         data, targets  = data.cuda(), targets.cuda()\n",
        "         y_pred = model(data)\n",
        "         loss = loss_fn(y_pred, targets)\n",
        "         optimizer.zero_grad()\n",
        "         loss.backward()\n",
        "         optimizer.step()\n",
        "         train_loss.append(loss.item())\n",
        "    \n",
        "     # evaluation on train & test sets\n",
        "     model.eval()\n",
        "     train_pred_list = []\n",
        "     train_true_list = []\n",
        "     for train_data, train_targets in trainloader_eval:\n",
        "         train_data = train_data.cuda()\n",
        "         train_pred = model(train_data)\n",
        "         train_pred_list.append(train_pred.cpu().detach().numpy())\n",
        "         train_true_list.append(train_targets.numpy())\n",
        "     train_true = np.concatenate(train_true_list)\n",
        "     train_pred = np.concatenate(train_pred_list)\n",
        "     train_auc = auc_roc_score(train_true, train_pred)\n",
        "     train_loss = np.mean(train_loss)\n",
        "  \n",
        "     test_pred_list = []\n",
        "     test_true_list = [] \n",
        "     for test_data, test_targets in testloader:\n",
        "         test_data = test_data.cuda()\n",
        "         test_pred = model(test_data)\n",
        "         test_pred_list.append(test_pred.cpu().detach().numpy())\n",
        "         test_true_list.append(test_targets.numpy())\n",
        "     test_true = np.concatenate(test_true_list)\n",
        "     test_pred = np.concatenate(test_pred_list)\n",
        "     val_auc =  auc_roc_score(test_true, test_pred) \n",
        "     model.train()\n",
        " \n",
        "     # print results\n",
        "     print(\"epoch: %s, train_loss: %.4f, train_auc: %.4f, test_auc: %.4f, lr: %.4f\"%(epoch, train_loss, train_auc, val_auc, optimizer.lr ))    \n",
        "     train_log.append(train_auc) \n",
        "     test_log.append(val_auc)     "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ygp4goXjXxMG",
        "outputId": "cc615326-cebe-4ff5-8482-a04e26695aa9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Start Training\n",
            "------------------------------\n",
            "epoch: 0, train_loss: 0.3187, train_auc: 0.6465, test_auc: 0.6550, lr: 0.1000\n",
            "epoch: 1, train_loss: 0.2997, train_auc: 0.6989, test_auc: 0.6943, lr: 0.1000\n",
            "epoch: 2, train_loss: 0.2904, train_auc: 0.7293, test_auc: 0.7111, lr: 0.1000\n",
            "epoch: 3, train_loss: 0.2812, train_auc: 0.7472, test_auc: 0.7395, lr: 0.1000\n",
            "epoch: 4, train_loss: 0.2711, train_auc: 0.7793, test_auc: 0.7615, lr: 0.1000\n",
            "epoch: 5, train_loss: 0.2611, train_auc: 0.7584, test_auc: 0.7404, lr: 0.1000\n",
            "epoch: 6, train_loss: 0.2546, train_auc: 0.7873, test_auc: 0.7587, lr: 0.1000\n",
            "epoch: 7, train_loss: 0.2464, train_auc: 0.7959, test_auc: 0.7642, lr: 0.1000\n",
            "epoch: 8, train_loss: 0.2387, train_auc: 0.8436, test_auc: 0.8097, lr: 0.1000\n",
            "epoch: 9, train_loss: 0.2336, train_auc: 0.7974, test_auc: 0.7664, lr: 0.1000\n",
            "epoch: 10, train_loss: 0.2257, train_auc: 0.8126, test_auc: 0.7795, lr: 0.1000\n",
            "epoch: 11, train_loss: 0.2202, train_auc: 0.8521, test_auc: 0.8198, lr: 0.1000\n",
            "epoch: 12, train_loss: 0.2171, train_auc: 0.8106, test_auc: 0.7712, lr: 0.1000\n",
            "epoch: 13, train_loss: 0.2111, train_auc: 0.8175, test_auc: 0.7745, lr: 0.1000\n",
            "epoch: 14, train_loss: 0.2042, train_auc: 0.8060, test_auc: 0.7705, lr: 0.1000\n",
            "epoch: 15, train_loss: 0.1992, train_auc: 0.8312, test_auc: 0.7921, lr: 0.1000\n",
            "epoch: 16, train_loss: 0.1922, train_auc: 0.8749, test_auc: 0.8361, lr: 0.1000\n",
            "epoch: 17, train_loss: 0.1879, train_auc: 0.9031, test_auc: 0.8655, lr: 0.1000\n",
            "epoch: 18, train_loss: 0.1829, train_auc: 0.8448, test_auc: 0.8061, lr: 0.1000\n",
            "epoch: 19, train_loss: 0.1778, train_auc: 0.7757, test_auc: 0.7457, lr: 0.1000\n",
            "epoch: 20, train_loss: 0.1767, train_auc: 0.8791, test_auc: 0.8503, lr: 0.1000\n",
            "epoch: 21, train_loss: 0.1687, train_auc: 0.8780, test_auc: 0.8406, lr: 0.1000\n",
            "epoch: 22, train_loss: 0.1662, train_auc: 0.8603, test_auc: 0.8218, lr: 0.1000\n",
            "epoch: 23, train_loss: 0.1625, train_auc: 0.8961, test_auc: 0.8480, lr: 0.1000\n",
            "epoch: 24, train_loss: 0.1594, train_auc: 0.8743, test_auc: 0.8338, lr: 0.1000\n",
            "epoch: 25, train_loss: 0.1579, train_auc: 0.9217, test_auc: 0.8697, lr: 0.1000\n",
            "epoch: 26, train_loss: 0.1543, train_auc: 0.9286, test_auc: 0.8914, lr: 0.1000\n",
            "epoch: 27, train_loss: 0.1539, train_auc: 0.8745, test_auc: 0.8271, lr: 0.1000\n",
            "epoch: 28, train_loss: 0.1478, train_auc: 0.9127, test_auc: 0.8684, lr: 0.1000\n",
            "epoch: 29, train_loss: 0.1464, train_auc: 0.9223, test_auc: 0.8782, lr: 0.1000\n",
            "epoch: 30, train_loss: 0.1468, train_auc: 0.9367, test_auc: 0.8897, lr: 0.1000\n",
            "epoch: 31, train_loss: 0.1409, train_auc: 0.9235, test_auc: 0.8734, lr: 0.1000\n",
            "epoch: 32, train_loss: 0.1385, train_auc: 0.9412, test_auc: 0.8947, lr: 0.1000\n",
            "epoch: 33, train_loss: 0.1378, train_auc: 0.8753, test_auc: 0.8213, lr: 0.1000\n",
            "epoch: 34, train_loss: 0.1370, train_auc: 0.9350, test_auc: 0.8884, lr: 0.1000\n",
            "epoch: 35, train_loss: 0.1324, train_auc: 0.9185, test_auc: 0.8727, lr: 0.1000\n",
            "epoch: 36, train_loss: 0.1337, train_auc: 0.9443, test_auc: 0.8964, lr: 0.1000\n",
            "epoch: 37, train_loss: 0.1302, train_auc: 0.9431, test_auc: 0.8895, lr: 0.1000\n",
            "epoch: 38, train_loss: 0.1305, train_auc: 0.9199, test_auc: 0.8711, lr: 0.1000\n",
            "epoch: 39, train_loss: 0.1285, train_auc: 0.8819, test_auc: 0.8242, lr: 0.1000\n",
            "epoch: 40, train_loss: 0.1250, train_auc: 0.9289, test_auc: 0.8809, lr: 0.1000\n",
            "epoch: 41, train_loss: 0.1262, train_auc: 0.9172, test_auc: 0.8623, lr: 0.1000\n",
            "epoch: 42, train_loss: 0.1261, train_auc: 0.9420, test_auc: 0.8904, lr: 0.1000\n",
            "epoch: 43, train_loss: 0.1214, train_auc: 0.8908, test_auc: 0.8408, lr: 0.1000\n",
            "epoch: 44, train_loss: 0.1236, train_auc: 0.9487, test_auc: 0.9009, lr: 0.1000\n",
            "epoch: 45, train_loss: 0.1177, train_auc: 0.9498, test_auc: 0.8933, lr: 0.1000\n",
            "epoch: 46, train_loss: 0.1203, train_auc: 0.8434, test_auc: 0.7921, lr: 0.1000\n",
            "epoch: 47, train_loss: 0.1187, train_auc: 0.9518, test_auc: 0.8970, lr: 0.1000\n",
            "epoch: 48, train_loss: 0.1167, train_auc: 0.9500, test_auc: 0.8954, lr: 0.1000\n",
            "epoch: 49, train_loss: 0.1155, train_auc: 0.9478, test_auc: 0.8937, lr: 0.1000\n",
            "Reducing learning rate to 0.01000 @ T=12100!\n",
            "Reducing learning rate (inner) to 0.01000 @ T=12100!\n",
            "Updating regularizer @ T=12100!\n",
            "epoch: 50, train_loss: 0.0823, train_auc: 0.9807, test_auc: 0.9219, lr: 0.0100\n",
            "epoch: 51, train_loss: 0.0658, train_auc: 0.9854, test_auc: 0.9270, lr: 0.0100\n",
            "epoch: 52, train_loss: 0.0608, train_auc: 0.9863, test_auc: 0.9249, lr: 0.0100\n",
            "epoch: 53, train_loss: 0.0577, train_auc: 0.9873, test_auc: 0.9247, lr: 0.0100\n",
            "epoch: 54, train_loss: 0.0537, train_auc: 0.9886, test_auc: 0.9234, lr: 0.0100\n",
            "epoch: 55, train_loss: 0.0495, train_auc: 0.9892, test_auc: 0.9238, lr: 0.0100\n",
            "epoch: 56, train_loss: 0.0472, train_auc: 0.9904, test_auc: 0.9255, lr: 0.0100\n",
            "epoch: 57, train_loss: 0.0452, train_auc: 0.9902, test_auc: 0.9232, lr: 0.0100\n",
            "epoch: 58, train_loss: 0.0438, train_auc: 0.9911, test_auc: 0.9221, lr: 0.0100\n",
            "epoch: 59, train_loss: 0.0411, train_auc: 0.9919, test_auc: 0.9236, lr: 0.0100\n",
            "epoch: 60, train_loss: 0.0379, train_auc: 0.9922, test_auc: 0.9225, lr: 0.0100\n",
            "epoch: 61, train_loss: 0.0359, train_auc: 0.9929, test_auc: 0.9202, lr: 0.0100\n",
            "epoch: 62, train_loss: 0.0376, train_auc: 0.9923, test_auc: 0.9176, lr: 0.0100\n",
            "epoch: 63, train_loss: 0.0338, train_auc: 0.9914, test_auc: 0.9164, lr: 0.0100\n",
            "epoch: 64, train_loss: 0.0329, train_auc: 0.9925, test_auc: 0.9192, lr: 0.0100\n",
            "epoch: 65, train_loss: 0.0304, train_auc: 0.9932, test_auc: 0.9205, lr: 0.0100\n",
            "epoch: 66, train_loss: 0.0304, train_auc: 0.9937, test_auc: 0.9194, lr: 0.0100\n",
            "epoch: 67, train_loss: 0.0274, train_auc: 0.9938, test_auc: 0.9192, lr: 0.0100\n",
            "epoch: 68, train_loss: 0.0271, train_auc: 0.9947, test_auc: 0.9215, lr: 0.0100\n",
            "epoch: 69, train_loss: 0.0253, train_auc: 0.9945, test_auc: 0.9148, lr: 0.0100\n",
            "epoch: 70, train_loss: 0.0239, train_auc: 0.9953, test_auc: 0.9183, lr: 0.0100\n",
            "epoch: 71, train_loss: 0.0233, train_auc: 0.9954, test_auc: 0.9162, lr: 0.0100\n",
            "epoch: 72, train_loss: 0.0218, train_auc: 0.9938, test_auc: 0.9093, lr: 0.0100\n",
            "epoch: 73, train_loss: 0.0216, train_auc: 0.9954, test_auc: 0.9159, lr: 0.0100\n",
            "epoch: 74, train_loss: 0.0225, train_auc: 0.9955, test_auc: 0.9161, lr: 0.0100\n",
            "Reducing learning rate to 0.00100 @ T=18150!\n",
            "Reducing learning rate (inner) to 0.00100 @ T=18150!\n",
            "Updating regularizer @ T=18150!\n",
            "epoch: 75, train_loss: 0.0195, train_auc: 0.9960, test_auc: 0.9170, lr: 0.0010\n",
            "epoch: 76, train_loss: 0.0185, train_auc: 0.9966, test_auc: 0.9186, lr: 0.0010\n",
            "epoch: 77, train_loss: 0.0166, train_auc: 0.9965, test_auc: 0.9176, lr: 0.0010\n",
            "epoch: 78, train_loss: 0.0175, train_auc: 0.9962, test_auc: 0.9171, lr: 0.0010\n",
            "epoch: 79, train_loss: 0.0162, train_auc: 0.9965, test_auc: 0.9176, lr: 0.0010\n",
            "epoch: 80, train_loss: 0.0177, train_auc: 0.9964, test_auc: 0.9178, lr: 0.0010\n",
            "epoch: 81, train_loss: 0.0155, train_auc: 0.9963, test_auc: 0.9171, lr: 0.0010\n",
            "epoch: 82, train_loss: 0.0153, train_auc: 0.9967, test_auc: 0.9179, lr: 0.0010\n",
            "epoch: 83, train_loss: 0.0156, train_auc: 0.9965, test_auc: 0.9171, lr: 0.0010\n",
            "epoch: 84, train_loss: 0.0149, train_auc: 0.9966, test_auc: 0.9164, lr: 0.0010\n",
            "epoch: 85, train_loss: 0.0156, train_auc: 0.9967, test_auc: 0.9176, lr: 0.0010\n",
            "epoch: 86, train_loss: 0.0153, train_auc: 0.9965, test_auc: 0.9172, lr: 0.0010\n",
            "epoch: 87, train_loss: 0.0155, train_auc: 0.9966, test_auc: 0.9170, lr: 0.0010\n",
            "epoch: 88, train_loss: 0.0147, train_auc: 0.9965, test_auc: 0.9174, lr: 0.0010\n",
            "epoch: 89, train_loss: 0.0151, train_auc: 0.9966, test_auc: 0.9169, lr: 0.0010\n",
            "epoch: 90, train_loss: 0.0150, train_auc: 0.9966, test_auc: 0.9174, lr: 0.0010\n",
            "epoch: 91, train_loss: 0.0149, train_auc: 0.9966, test_auc: 0.9164, lr: 0.0010\n",
            "epoch: 92, train_loss: 0.0149, train_auc: 0.9966, test_auc: 0.9162, lr: 0.0010\n",
            "epoch: 93, train_loss: 0.0148, train_auc: 0.9967, test_auc: 0.9169, lr: 0.0010\n",
            "epoch: 94, train_loss: 0.0144, train_auc: 0.9967, test_auc: 0.9174, lr: 0.0010\n",
            "epoch: 95, train_loss: 0.0139, train_auc: 0.9965, test_auc: 0.9163, lr: 0.0010\n",
            "epoch: 96, train_loss: 0.0142, train_auc: 0.9969, test_auc: 0.9175, lr: 0.0010\n",
            "epoch: 97, train_loss: 0.0140, train_auc: 0.9967, test_auc: 0.9172, lr: 0.0010\n",
            "epoch: 98, train_loss: 0.0136, train_auc: 0.9968, test_auc: 0.9165, lr: 0.0010\n",
            "epoch: 99, train_loss: 0.0139, train_auc: 0.9967, test_auc: 0.9169, lr: 0.0010\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Visualization**\n",
        "\n",
        "Now, let's see the change of AUC scores on training and testing set. \n"
      ],
      "metadata": {
        "id": "VVGuukZ0FpfN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "plt.rcParams[\"figure.figsize\"] = (9,5)\n",
        "x=np.arange(len(train_log))\n",
        "plt.figure()\n",
        "plt.plot(x, train_log, LineStyle='-', label='Train Set', linewidth=3)\n",
        "plt.plot(x, test_log,  LineStyle='-', label='Test Set', linewidth=3)\n",
        "plt.title('CompositionalAUCLoss (10% CIFAR10)',fontsize=25)\n",
        "plt.legend(fontsize=15)\n",
        "plt.ylabel('AUROC', fontsize=25)\n",
        "plt.xlabel('Epoch', fontsize=25)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 391
        },
        "id": "CoM4Tnl0LmfY",
        "outputId": "20a8a868-4ac3-4948-9f17-af831e08bf05"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 0, 'Epoch')"
            ]
          },
          "metadata": {},
          "execution_count": 14
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 648x360 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "background_execution": "on",
      "collapsed_sections": [],
      "machine_shape": "hm",
      "name": "09_Optimizing_CompositionalAUC_Loss_with_ResNet20_on_CIFAR10.ipynb",
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}