vgg_coverage.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "vgg_coverage.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "xPVvGmiYNpG-"
      },
      "source": [
        "from __future__ import print_function\n",
        "from __future__ import division\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "import numpy as np\n",
        "import torchvision\n",
        "import matplotlib.pyplot as plt\n",
        "import time\n",
        "import os\n",
        "import copy\n",
        "from typing import Union, List, Dict, Any, cast"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9tiBbtInQFu1"
      },
      "source": [
        "from torch.hub import load_state_dict_from_url\n",
        "\n",
        "class VGG(nn.Module):\n",
        "\n",
        "    def __init__(\n",
        "        self,\n",
        "        features: nn.Module,\n",
        "        num_classes: int = 1000,\n",
        "        init_weights: bool = True,\n",
        "        eps: float = 0.3,\n",
        "        bin_size : int = 6\n",
        "    ) -> None:\n",
        "        super(VGG, self).__init__()\n",
        "        self.features = features\n",
        "        self.avgpool = nn.AdaptiveAvgPool2d((7, 7))\n",
        "        self.classifier = nn.Sequential(\n",
        "            nn.Linear(512 * 7 * 7, 4096),\n",
        "            nn.ReLU(True),\n",
        "            nn.Dropout(),\n",
        "            nn.Linear(4096, 4096),\n",
        "            nn.ReLU(True),\n",
        "            nn.Dropout(),\n",
        "            nn.Linear(4096, num_classes),\n",
        "        )\n",
        "        \n",
        "        self.bin_size = bin_size\n",
        "        self.eps = eps\n",
        "        self.max_record = torch.full([512 * 7 * 7], float('-inf'))\n",
        "        self.min_record = torch.full([512 * 7 * 7], float('inf'))\n",
        "\n",
        "        self.neuron_covered = torch.full([512 * 7 * 7], True)\n",
        "        self.bin_covered = torch.full([512 * 7 * 7, self.bin_size], True)\n",
        "        self.upper_covered = torch.full([512 * 7 * 7], True)\n",
        "        self.lower_covered = torch.full([512 * 7 * 7], True)\n",
        "        \n",
        "        if init_weights:\n",
        "            self._initialize_weights()\n",
        "\n",
        "    def forward(self, x: torch.Tensor, isTrain: bool) -> torch.Tensor:\n",
        "        x = self.features(x)\n",
        "        x = x.view(-1, 512 * 7 * 7)\n",
        "\n",
        "        if isTrain:\n",
        "            self.max_record = torch.max(self.max_record, torch.max(x, 0).values)\n",
        "            self.min_record = torch.min(self.max_record, torch.min(x, 0).values)\n",
        "        else:\n",
        "            self.neuron_covered = self.neuron_covered.logical_and(torch.min(x >= self.eps, 0).values)\n",
        "            self.upper_covered = self.upper_covered.logical_and(torch.min(x >= self.max_record, 0).values)\n",
        "            self.lower_covered = self.lower_covered.logical_and(torch.min(x <= self.min_record, 0).values)\n",
        "            \n",
        "            min_bound = self.min_record\n",
        "            diff = (self.max_record - self.min_record) / self.bin_size\n",
        "            max_bound = self.min_record + diff\n",
        "            for i in range(self.bin_size):\n",
        "                self.bin_covered[:, i] = self.bin_covered[:, i].logical_and(torch.min(x >= min_bound, 0).values).logical_and(torch.min(x <= max_bound, 0).values)\n",
        "                min_bound = min_bound + diff\n",
        "                max_bound = max_bound + diff\n",
        "        x = x.view(-1, 512, 7, 7)\n",
        "        x = self.avgpool(x)\n",
        "        x = torch.flatten(x, 1)\n",
        "        x = self.classifier(x)\n",
        "        return x\n",
        "\n",
        "    def _initialize_weights(self) -> None:\n",
        "        for m in self.modules():\n",
        "            if isinstance(m, nn.Conv2d):\n",
        "                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')\n",
        "                if m.bias is not None:\n",
        "                    nn.init.constant_(m.bias, 0)\n",
        "            elif isinstance(m, nn.BatchNorm2d):\n",
        "                nn.init.constant_(m.weight, 1)\n",
        "                nn.init.constant_(m.bias, 0)\n",
        "            elif isinstance(m, nn.Linear):\n",
        "                nn.init.normal_(m.weight, 0, 0.01)\n",
        "                nn.init.constant_(m.bias, 0)\n",
        "\n",
        "\n",
        "def make_layers(cfg: List[Union[str, int]], batch_norm: bool = False) -> nn.Sequential:\n",
        "    layers: List[nn.Module] = []\n",
        "    in_channels = 3\n",
        "    for v in cfg:\n",
        "        if v == 'M':\n",
        "            layers += [nn.MaxPool2d(kernel_size=2, stride=2)]\n",
        "        else:\n",
        "            v = cast(int, v)\n",
        "            conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)\n",
        "            if batch_norm:\n",
        "                layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]\n",
        "            else:\n",
        "                layers += [conv2d, nn.ReLU(inplace=True)]\n",
        "            in_channels = v\n",
        "    return nn.Sequential(*layers)\n",
        "\n",
        "def get_vgg(arch: str, cfg: str, **kwargs: Any) -> VGG:\n",
        "    kwargs['init_weights'] = False\n",
        "    model = VGG(make_layers(torchvision.models.vgg.cfgs[cfg]), **kwargs)\n",
        "    state_dict = load_state_dict_from_url(torchvision.models.vgg.model_urls[arch], progress=True)\n",
        "    model.load_state_dict(state_dict)\n",
        "    return model"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NHwG2ez_jEat"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FCFl_TdEj44a"
      },
      "source": [
        "model = get_vgg(\"vgg11\", 'A')\n",
        "images = torch.rand([128, 3, 224, 224])\n",
        "tests = torch.rand([16, 3, 224, 224])\n",
        "model(images, True)\n",
        "model(tests, False)\n",
        "print(model.neuron_covered)\n",
        "print(model.upper_covered)\n",
        "print(model.lower_covered)\n",
        "print(model.bin_covered)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zn2Hx7WTw8Ua"
      },
      "source": [
        "print(model.neuron_covered.count_nonzero())\n",
        "print(model.upper_covered.count_nonzero())\n",
        "print(model.lower_covered.count_nonzero())\n",
        "print(model.bin_covered.count_nonzero())\n",
        "print(model.neuron_covered.shape)\n",
        "print(model.upper_covered.shape)\n",
        "print(model.lower_covered.shape)\n",
        "print(model.bin_covered.shape)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "emZ7PHVWzglp"
      },
      "source": [
        "```\n",
        "uname = input()\n",
        "!git config --global user.email '$uname@gmail.com'\n",
        "!git config --global user.name '$uname'\n",
        "\n",
        "from getpass import getpass\n",
        "password = getpass('Password:')\n",
        "!git clone https://github.com/HyunjoonCho/cs453-project-21s\n",
        "%cd myrepo\n",
        "# create a file, then add it to stage\n",
        "!git add tester.ipynb\n",
        "!git commit -m 'commit message'  # commit in Colab\n",
        "!git push origin master          # push to github\n",
        "```"
      ]
    }
  ]
}