examples/02_Optimizing_AUROC_with_ResNet20_on_Imbalanced_CIFAR10.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "02_Optimizing_AUROC_with_ResNet20_on_Imbalanced_CIFAR10.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm"
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PwsM2ciGpOE7"
      },
      "source": [
        "# **Optimizing AUROC loss on imbalanced dataset**\n",
        "\n",
        "**Author**: Zhuoning Yuan\n",
        "\n",
        "**Introduction**\n",
        "\n",
        "In this tutorial, you will learn how to quickly train a ResNet20 model by optimizing **AUROC** using our novel [AUCMLoss](https://arxiv.org/abs/2012.03173) and `PESG` optimizer on a 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",
        "\n",
        "**Useful Resources**:\n",
        "* Website: https://libauc.org\n",
        "* Github: https://github.com/Optimization-AI/LibAUC\n",
        "\n",
        "**Reference**:  \n",
        "\n",
        "If you find this tutorial helpful in your work,  please acknowledge our library and cite the following paper:\n",
        "<pre>\n",
        "@inproceedings{yuan2021large,\n",
        "  title={Large-scale robust deep auc maximization: A new surrogate loss and empirical studies on medical image classification},\n",
        "  author={Yuan, Zhuoning and Yan, Yan and Sonka, Milan and Yang, Tianbao},\n",
        "  booktitle={Proceedings of the IEEE/CVF International Conference on Computer Vision},\n",
        "  pages={3040--3049},\n",
        "  year={2021}\n",
        "}\n",
        "</pre>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "efaf1543"
      },
      "source": [
        "## **Installing LibAUC**\n",
        "\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": "0hQeospBloJU"
      },
      "outputs": [],
      "source": [
        "!pip install libauc==1.2.0"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TYTvudnlQMEX"
      },
      "source": [
        "# **Importing LibAUC**\n",
        "Import required libraries to use"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HBdrV5mOV9ze"
      },
      "source": [
        "from libauc.losses import AUCMLoss\n",
        "from libauc.optimizers import PESG\n",
        "from libauc.models import resnet20 as ResNet20\n",
        "from libauc.datasets import CIFAR10\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\n",
        "from sklearn.metrics import roc_auc_score"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c4gWa0Yisyoi"
      },
      "source": [
        "## **Reproducibility**\n",
        "\n",
        "These functions limit 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.)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "glsgJdAKsyoi"
      },
      "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": "QFmMHcdDsyoj"
      },
      "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`.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y7rC7aTuQ2cX"
      },
      "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"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Introduction for Loss and Optimizer**\n",
        "\n",
        "In this section, we will introduce how to utilize `AUCMLoss` function and `PESG` optimizer.  \n",
        "\n",
        "#### **AUCMLoss**\n",
        "The objective function for `AUCMLoss` is defined as\n",
        "\n",
        "\\begin{align} F(\\mathbf{w},a,b,\\alpha; \\mathbf{z}) &=(1-p)(h_w(x)-a)^2\\mathbf{I}_{[y=1]} +p(h_w(x)-b)^2\\mathbf{I}_{[y=-1]} \\\\\n",
        "&+2\\alpha(p(1-p)m+ p h_w(x)\\mathbf{I}_{[y=-1]}-(1-p)h_w(x)\\mathbf{I}_{[y=1]})\\\\\n",
        "&-p(1-p)\\alpha^2\n",
        "\\end{align}\n",
        "\n",
        "where $p$ is the ratio of positive samples to all samples in a mini-batch, $a$, $b$ are the running statistics of the positive and negative predictions, $\\alpha$ is the auxiliary variable derived from the problem formulation. For the derivation of the above formulation, please refer to the paper [[ref]](https://arxiv.org/abs/2012.03173).\n",
        "\n",
        "**PESG** is used for optimizing the AUC margin loss and the key update steps are sumarized as follow:\n",
        "1. Initialize $\\mathbf v_0= \\mathbf v_{ref}=\\{\\mathbf{w_0}, a_0, b_0\\}, \\alpha_0\\geq 0$\n",
        "2. For $t=1, \\ldots, T$:\n",
        "3. $\\hspace{0.2in}$ Compute $\\nabla_{\\mathbf v} F(\\mathbf v_t, \\alpha_t; z_t)$ and $\\nabla_\\alpha F(\\mathbf v_t, \\alpha_t; z_t)$.\n",
        "4. $\\hspace{0.2in}$ Update primal variables\n",
        "$$\n",
        "\\mathbf v_{t+1} = \\mathbf v_{t} - \\eta (\\nabla_{\\mathbf v} F(\\mathbf v_t, \\alpha_t; z_t)+ \\lambda_0 (\\mathbf v_t-\\mathbf v_{\\text{ref}})) - \\lambda \\eta\\mathbf v_t \n",
        "$$\n",
        "5. $\\hspace{0.2in}$ Update dual variable \n",
        "$$\\alpha_{t+1}=  [\\alpha_{t} + \\eta \\nabla_\\alpha F(\\mathbf v_t, \\alpha_t; z_t)]_+$$\n",
        "6.  $\\hspace{0.2in}$ Decrease $\\eta$ by a decay factor and update $\\mathbf v_{\\text{ref}}$ periodically \n",
        "\n",
        "where ${z_t}$ is the data pair $(x_t, y_t)$, $\\lambda_0$ is the epoch-level l2 penaty (i.e., `epoch_decay`) and $\\eta$ is the learning rate. For more details, please refer to the paper [[ref]](https://arxiv.org/abs/2012.03173)."
      ],
      "metadata": {
        "id": "VpHnyOLFEy5e"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Hyper-parameters**\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",
        "    \n",
        "**Optimizer**\n",
        "  * `lr`: learning rate\n",
        "  * `momentum`: momentum factor (default: 0.9)\n",
        "  * `weight_decay`: weight decay (L2 penalty) (default: 1e-5)\n",
        "  * `epoch_decay`: epoch decay (L2 penalty for epoch-level regularization) (default: 2e-3)\n",
        "\n",
        "## **Tips**\n",
        " - `sampling_ratio` can be tuned in (0, 0.5] based on different datasets\n",
        " - `epoch_decay` is a regularization parameter similar to `weight_decay` that can be tuned\n",
        " - `momentum` is similar to SGD-momentum and you can choose value in [0, 0.9]\n",
        " - `margin` can also be tuned in [0.5, 1.0] for better performance\n",
        "\n"
      ],
      "metadata": {
        "id": "I-RegPMrBH-i"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YjTW36iTQ60Q"
      },
      "source": [
        "# **Paramaters**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "STRhOR7YQ4_r"
      },
      "source": [
        "# HyperParameters\n",
        "SEED = 123\n",
        "BATCH_SIZE = 128\n",
        "imratio = 0.1 # for demo \n",
        "total_epochs = 100\n",
        "decay_epochs = [50, 75]\n",
        "\n",
        "lr = 0.1\n",
        "margin = 1.0\n",
        "epoch_decay = 0.003 # refers gamma in the paper\n",
        "weight_decay = 0.0001\n",
        "\n",
        "# oversampling minority class, you can tune it in (0, 0.5]\n",
        "# e.g., sampling_rate=0.2 is that num of positive samples in mini-batch is sampling_rate*batch_size=13\n",
        "sampling_rate = 0.2 "
      ],
      "execution_count": 43,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5fgzICg5Q-RE"
      },
      "source": [
        "# **Loading datasets**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nGbjRYxqQ9sv",
        "outputId": "d7da3726-1457-44ed-96e6-813fb6aa77bb"
      },
      "source": [
        "# load data as numpy arrays \n",
        "train_data, train_targets = CIFAR10(root='./data', train=True)\n",
        "test_data, test_targets  = CIFAR10(root='./data', train=False)\n",
        "\n",
        "# generate imbalanced data\n",
        "generator = ImbalancedDataGenerator(verbose=True, random_seed=0)\n",
        "(train_images, train_labels) = generator.transform(train_data, train_targets, imratio=imratio)\n",
        "(test_images, test_labels) = generator.transform(test_data, test_targets, imratio=0.5) \n",
        "\n",
        "# data augmentations \n",
        "trainSet = ImageDataset(train_images, train_labels)\n",
        "trainSet_eval = ImageDataset(train_images, train_labels, mode='test')\n",
        "testSet = ImageDataset(test_images, test_labels, mode='test')\n",
        "\n",
        "# dataloaders\n",
        "sampler = DualSampler(trainSet, BATCH_SIZE, sampling_rate=sampling_rate)\n",
        "trainloader = torch.utils.data.DataLoader(trainSet, batch_size=BATCH_SIZE, sampler=sampler, 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)"
      ],
      "execution_count": 44,
      "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"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_MrH548IRDIc"
      },
      "source": [
        "# **Creating models & AUC Optimizer**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cFxB8QblRCt5"
      },
      "source": [
        "# You can include sigmoid/l2 activations on model's outputs before computing loss\n",
        "model = ResNet20(pretrained=False, last_activation=None, num_classes=1)\n",
        "model = model.cuda()\n",
        "\n",
        "# You can also pass Loss.a, Loss.b, Loss.alpha to optimizer (for old version users)\n",
        "loss_fn = AUCMLoss()\n",
        "optimizer = PESG(model, \n",
        "                 loss_fn=loss_fn,\n",
        "                 lr=lr, \n",
        "                 momentum=0.9,\n",
        "                 margin=margin, \n",
        "                 epoch_decay=epoch_decay, \n",
        "                 weight_decay=weight_decay)"
      ],
      "execution_count": 45,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fG5VXXEIRfw3"
      },
      "source": [
        "# **Training**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H1nk8FK3Qygb",
        "outputId": "8ed7d468-6ace-4896-bc7c-4b245e4b3456"
      },
      "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) # 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",
        "         y_pred = torch.sigmoid(y_pred)\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)     "
      ],
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Start Training\n",
            "------------------------------\n",
            "epoch: 0, train_loss: 0.1494, train_auc: 0.6466, test_auc: 0.6599, lr: 0.1000\n",
            "epoch: 1, train_loss: 0.1321, train_auc: 0.6940, test_auc: 0.6875, lr: 0.1000\n",
            "epoch: 2, train_loss: 0.1201, train_auc: 0.6966, test_auc: 0.6886, lr: 0.1000\n",
            "epoch: 3, train_loss: 0.1129, train_auc: 0.7146, test_auc: 0.6921, lr: 0.1000\n",
            "epoch: 4, train_loss: 0.1063, train_auc: 0.7244, test_auc: 0.7042, lr: 0.1000\n",
            "epoch: 5, train_loss: 0.0999, train_auc: 0.7648, test_auc: 0.7498, lr: 0.1000\n",
            "epoch: 6, train_loss: 0.0961, train_auc: 0.7872, test_auc: 0.7664, lr: 0.1000\n",
            "epoch: 7, train_loss: 0.0902, train_auc: 0.7823, test_auc: 0.7479, lr: 0.1000\n",
            "epoch: 8, train_loss: 0.0880, train_auc: 0.8169, test_auc: 0.7931, lr: 0.1000\n",
            "epoch: 9, train_loss: 0.0835, train_auc: 0.8177, test_auc: 0.7858, lr: 0.1000\n",
            "epoch: 10, train_loss: 0.0801, train_auc: 0.8201, test_auc: 0.7912, lr: 0.1000\n",
            "epoch: 11, train_loss: 0.0789, train_auc: 0.8414, test_auc: 0.7987, lr: 0.1000\n",
            "epoch: 12, train_loss: 0.0751, train_auc: 0.8414, test_auc: 0.8080, lr: 0.1000\n",
            "epoch: 13, train_loss: 0.0731, train_auc: 0.8184, test_auc: 0.7852, lr: 0.1000\n",
            "epoch: 14, train_loss: 0.0711, train_auc: 0.8267, test_auc: 0.7953, lr: 0.1000\n",
            "epoch: 15, train_loss: 0.0698, train_auc: 0.8270, test_auc: 0.8029, lr: 0.1000\n",
            "epoch: 16, train_loss: 0.0674, train_auc: 0.8529, test_auc: 0.8102, lr: 0.1000\n",
            "epoch: 17, train_loss: 0.0660, train_auc: 0.8686, test_auc: 0.8331, lr: 0.1000\n",
            "epoch: 18, train_loss: 0.0647, train_auc: 0.8545, test_auc: 0.8194, lr: 0.1000\n",
            "epoch: 19, train_loss: 0.0633, train_auc: 0.8286, test_auc: 0.7963, lr: 0.1000\n",
            "epoch: 20, train_loss: 0.0612, train_auc: 0.8869, test_auc: 0.8457, lr: 0.1000\n",
            "epoch: 21, train_loss: 0.0594, train_auc: 0.8862, test_auc: 0.8439, lr: 0.1000\n",
            "epoch: 22, train_loss: 0.0580, train_auc: 0.8797, test_auc: 0.8399, lr: 0.1000\n",
            "epoch: 23, train_loss: 0.0575, train_auc: 0.8048, test_auc: 0.7714, lr: 0.1000\n",
            "epoch: 24, train_loss: 0.0561, train_auc: 0.8453, test_auc: 0.8158, lr: 0.1000\n",
            "epoch: 25, train_loss: 0.0556, train_auc: 0.8637, test_auc: 0.8260, lr: 0.1000\n",
            "epoch: 26, train_loss: 0.0534, train_auc: 0.8568, test_auc: 0.8139, lr: 0.1000\n",
            "epoch: 27, train_loss: 0.0526, train_auc: 0.8969, test_auc: 0.8525, lr: 0.1000\n",
            "epoch: 28, train_loss: 0.0515, train_auc: 0.8948, test_auc: 0.8541, lr: 0.1000\n",
            "epoch: 29, train_loss: 0.0515, train_auc: 0.8240, test_auc: 0.7953, lr: 0.1000\n",
            "epoch: 30, train_loss: 0.0501, train_auc: 0.9066, test_auc: 0.8637, lr: 0.1000\n",
            "epoch: 31, train_loss: 0.0503, train_auc: 0.9210, test_auc: 0.8802, lr: 0.1000\n",
            "epoch: 32, train_loss: 0.0500, train_auc: 0.9042, test_auc: 0.8634, lr: 0.1000\n",
            "epoch: 33, train_loss: 0.0485, train_auc: 0.9170, test_auc: 0.8783, lr: 0.1000\n",
            "epoch: 34, train_loss: 0.0480, train_auc: 0.9283, test_auc: 0.8793, lr: 0.1000\n",
            "epoch: 35, train_loss: 0.0477, train_auc: 0.8671, test_auc: 0.8246, lr: 0.1000\n",
            "epoch: 36, train_loss: 0.0464, train_auc: 0.8900, test_auc: 0.8454, lr: 0.1000\n",
            "epoch: 37, train_loss: 0.0455, train_auc: 0.9161, test_auc: 0.8732, lr: 0.1000\n",
            "epoch: 38, train_loss: 0.0459, train_auc: 0.9255, test_auc: 0.8822, lr: 0.1000\n",
            "epoch: 39, train_loss: 0.0462, train_auc: 0.8967, test_auc: 0.8527, lr: 0.1000\n",
            "epoch: 40, train_loss: 0.0455, train_auc: 0.8998, test_auc: 0.8543, lr: 0.1000\n",
            "epoch: 41, train_loss: 0.0457, train_auc: 0.9118, test_auc: 0.8626, lr: 0.1000\n",
            "epoch: 42, train_loss: 0.0442, train_auc: 0.8788, test_auc: 0.8337, lr: 0.1000\n",
            "epoch: 43, train_loss: 0.0439, train_auc: 0.9347, test_auc: 0.8850, lr: 0.1000\n",
            "epoch: 44, train_loss: 0.0430, train_auc: 0.9303, test_auc: 0.8816, lr: 0.1000\n",
            "epoch: 45, train_loss: 0.0428, train_auc: 0.7928, test_auc: 0.7546, lr: 0.1000\n",
            "epoch: 46, train_loss: 0.0430, train_auc: 0.8859, test_auc: 0.8386, lr: 0.1000\n",
            "epoch: 47, train_loss: 0.0427, train_auc: 0.8638, test_auc: 0.8212, lr: 0.1000\n",
            "epoch: 48, train_loss: 0.0422, train_auc: 0.8736, test_auc: 0.8332, lr: 0.1000\n",
            "epoch: 49, train_loss: 0.0413, train_auc: 0.8577, test_auc: 0.8165, lr: 0.1000\n",
            "Reducing learning rate to 0.01000 @ T=12100!\n",
            "Updating regularizer @ T=12100!\n",
            "epoch: 50, train_loss: 0.0270, train_auc: 0.9693, test_auc: 0.9109, lr: 0.0100\n",
            "epoch: 51, train_loss: 0.0220, train_auc: 0.9717, test_auc: 0.9129, lr: 0.0100\n",
            "epoch: 52, train_loss: 0.0206, train_auc: 0.9748, test_auc: 0.9139, lr: 0.0100\n",
            "epoch: 53, train_loss: 0.0185, train_auc: 0.9749, test_auc: 0.9108, lr: 0.0100\n",
            "epoch: 54, train_loss: 0.0175, train_auc: 0.9763, test_auc: 0.9123, lr: 0.0100\n",
            "epoch: 55, train_loss: 0.0169, train_auc: 0.9766, test_auc: 0.9124, lr: 0.0100\n",
            "epoch: 56, train_loss: 0.0157, train_auc: 0.9761, test_auc: 0.9114, lr: 0.0100\n",
            "epoch: 57, train_loss: 0.0148, train_auc: 0.9776, test_auc: 0.9118, lr: 0.0100\n",
            "epoch: 58, train_loss: 0.0148, train_auc: 0.9773, test_auc: 0.9093, lr: 0.0100\n",
            "epoch: 59, train_loss: 0.0138, train_auc: 0.9772, test_auc: 0.9064, lr: 0.0100\n",
            "epoch: 60, train_loss: 0.0133, train_auc: 0.9807, test_auc: 0.9124, lr: 0.0100\n",
            "epoch: 61, train_loss: 0.0129, train_auc: 0.9792, test_auc: 0.9089, lr: 0.0100\n",
            "epoch: 62, train_loss: 0.0125, train_auc: 0.9800, test_auc: 0.9111, lr: 0.0100\n",
            "epoch: 63, train_loss: 0.0119, train_auc: 0.9809, test_auc: 0.9077, lr: 0.0100\n",
            "epoch: 64, train_loss: 0.0114, train_auc: 0.9803, test_auc: 0.9051, lr: 0.0100\n",
            "epoch: 65, train_loss: 0.0113, train_auc: 0.9809, test_auc: 0.9069, lr: 0.0100\n",
            "epoch: 66, train_loss: 0.0107, train_auc: 0.9821, test_auc: 0.9090, lr: 0.0100\n",
            "epoch: 67, train_loss: 0.0106, train_auc: 0.9820, test_auc: 0.9074, lr: 0.0100\n",
            "epoch: 68, train_loss: 0.0100, train_auc: 0.9817, test_auc: 0.9054, lr: 0.0100\n",
            "epoch: 69, train_loss: 0.0097, train_auc: 0.9825, test_auc: 0.9043, lr: 0.0100\n",
            "epoch: 70, train_loss: 0.0097, train_auc: 0.9816, test_auc: 0.9019, lr: 0.0100\n",
            "epoch: 71, train_loss: 0.0092, train_auc: 0.9820, test_auc: 0.9021, lr: 0.0100\n",
            "epoch: 72, train_loss: 0.0091, train_auc: 0.9830, test_auc: 0.9044, lr: 0.0100\n",
            "epoch: 73, train_loss: 0.0090, train_auc: 0.9839, test_auc: 0.9044, lr: 0.0100\n",
            "epoch: 74, train_loss: 0.0087, train_auc: 0.9836, test_auc: 0.9044, lr: 0.0100\n",
            "Reducing learning rate to 0.00100 @ T=18150!\n",
            "Updating regularizer @ T=18150!\n",
            "epoch: 75, train_loss: 0.0078, train_auc: 0.9841, test_auc: 0.9020, lr: 0.0010\n",
            "epoch: 76, train_loss: 0.0075, train_auc: 0.9846, test_auc: 0.9020, lr: 0.0010\n",
            "epoch: 77, train_loss: 0.0074, train_auc: 0.9848, test_auc: 0.9019, lr: 0.0010\n",
            "epoch: 78, train_loss: 0.0071, train_auc: 0.9846, test_auc: 0.9009, lr: 0.0010\n",
            "epoch: 79, train_loss: 0.0071, train_auc: 0.9846, test_auc: 0.9004, lr: 0.0010\n",
            "epoch: 80, train_loss: 0.0071, train_auc: 0.9850, test_auc: 0.9007, lr: 0.0010\n",
            "epoch: 81, train_loss: 0.0070, train_auc: 0.9854, test_auc: 0.9013, lr: 0.0010\n",
            "epoch: 82, train_loss: 0.0072, train_auc: 0.9851, test_auc: 0.9003, lr: 0.0010\n",
            "epoch: 83, train_loss: 0.0072, train_auc: 0.9855, test_auc: 0.9003, lr: 0.0010\n",
            "epoch: 84, train_loss: 0.0069, train_auc: 0.9855, test_auc: 0.9003, lr: 0.0010\n",
            "epoch: 85, train_loss: 0.0071, train_auc: 0.9852, test_auc: 0.8997, lr: 0.0010\n",
            "epoch: 86, train_loss: 0.0069, train_auc: 0.9853, test_auc: 0.9005, lr: 0.0010\n",
            "epoch: 87, train_loss: 0.0070, train_auc: 0.9853, test_auc: 0.8992, lr: 0.0010\n",
            "epoch: 88, train_loss: 0.0069, train_auc: 0.9852, test_auc: 0.8988, lr: 0.0010\n",
            "epoch: 89, train_loss: 0.0071, train_auc: 0.9852, test_auc: 0.8987, lr: 0.0010\n",
            "epoch: 90, train_loss: 0.0069, train_auc: 0.9854, test_auc: 0.8991, lr: 0.0010\n",
            "epoch: 91, train_loss: 0.0069, train_auc: 0.9856, test_auc: 0.8987, lr: 0.0010\n",
            "epoch: 92, train_loss: 0.0065, train_auc: 0.9858, test_auc: 0.8992, lr: 0.0010\n",
            "epoch: 93, train_loss: 0.0066, train_auc: 0.9856, test_auc: 0.8973, lr: 0.0010\n",
            "epoch: 94, train_loss: 0.0064, train_auc: 0.9855, test_auc: 0.8966, lr: 0.0010\n",
            "epoch: 95, train_loss: 0.0065, train_auc: 0.9856, test_auc: 0.8961, lr: 0.0010\n",
            "epoch: 96, train_loss: 0.0067, train_auc: 0.9860, test_auc: 0.8981, lr: 0.0010\n",
            "epoch: 97, train_loss: 0.0067, train_auc: 0.9859, test_auc: 0.8975, lr: 0.0010\n",
            "epoch: 98, train_loss: 0.0067, train_auc: 0.9860, test_auc: 0.8987, lr: 0.0010\n",
            "epoch: 99, train_loss: 0.0066, train_auc: 0.9857, test_auc: 0.8970, lr: 0.0010\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Visualization**\n",
        "Now, let's see the learning curve of optimizing AUROC on train and tes sets. \n"
      ],
      "metadata": {
        "id": "7NgqDsqSxEcY"
      }
    },
    {
      "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('AUCMLoss (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": "kc3weEruvU-e",
        "outputId": "cf2bc402-66ce-4460-8743-920da86ef078"
      },
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 0, 'Epoch')"
            ]
          },
          "metadata": {},
          "execution_count": 48
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 648x360 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}