ResNet_Cifar100.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center><h1>ResNet: Cifar100</h1></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import division,print_function\n",
    "\n",
    "%matplotlib inline\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "import sys\n",
    "from tqdm import tqdm_notebook as tqdm\n",
    "\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import torch.nn.init as init\n",
    "from torch.autograd import Variable, grad\n",
    "from torchvision import datasets, transforms\n",
    "from torch.nn.parameter import Parameter\n",
    "\n",
    "import calculate_log as callog\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.cuda.set_device(1) #Select the GPU"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model definition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done\n"
     ]
    }
   ],
   "source": [
    "def conv3x3(in_planes, out_planes, stride=1):\n",
    "    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride, padding=1, bias=False)\n",
    "\n",
    "class BasicBlock(nn.Module):\n",
    "    expansion = 1\n",
    "\n",
    "    def __init__(self, in_planes, planes, stride=1):\n",
    "        super(BasicBlock, self).__init__()\n",
    "        self.conv1 = conv3x3(in_planes, planes, stride)\n",
    "        self.bn1 = nn.BatchNorm2d(planes)\n",
    "        self.conv2 = conv3x3(planes, planes)\n",
    "        self.bn2 = nn.BatchNorm2d(planes)\n",
    "\n",
    "        self.shortcut = nn.Sequential()\n",
    "        if stride != 1 or in_planes != self.expansion*planes:\n",
    "            self.shortcut = nn.Sequential(\n",
    "                nn.Conv2d(in_planes, self.expansion*planes, kernel_size=1, stride=stride, bias=False),\n",
    "                nn.BatchNorm2d(self.expansion*planes)\n",
    "            )\n",
    "    \n",
    "    def forward(self, x):\n",
    "        t = self.conv1(x)\n",
    "        out = F.relu(self.bn1(t))\n",
    "        torch_model.record(t)\n",
    "        torch_model.record(out)\n",
    "        t = self.conv2(out)\n",
    "        out = self.bn2(self.conv2(out))\n",
    "        torch_model.record(t)\n",
    "        torch_model.record(out)\n",
    "        t = self.shortcut(x)\n",
    "        out += t\n",
    "        torch_model.record(t)\n",
    "        out = F.relu(out)\n",
    "        torch_model.record(out)\n",
    "        \n",
    "        return out\n",
    "\n",
    "class ResNet(nn.Module):\n",
    "    def __init__(self, block, num_blocks, num_classes=10):\n",
    "        super(ResNet, self).__init__()\n",
    "        self.in_planes = 64\n",
    "\n",
    "        self.conv1 = conv3x3(3,64)\n",
    "        self.bn1 = nn.BatchNorm2d(64)\n",
    "        self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1)\n",
    "        self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2)\n",
    "        self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2)\n",
    "        self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2)\n",
    "        self.linear = nn.Linear(512*block.expansion, num_classes)\n",
    "        \n",
    "        self.collecting = False\n",
    "    \n",
    "    def _make_layer(self, block, planes, num_blocks, stride):\n",
    "        strides = [stride] + [1]*(num_blocks-1)\n",
    "        layers = []\n",
    "        for stride in strides:\n",
    "            layers.append(block(self.in_planes, planes, stride))\n",
    "            self.in_planes = planes * block.expansion\n",
    "        return nn.Sequential(*layers)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        out = F.relu(self.bn1(self.conv1(x)))\n",
    "        out = self.layer1(out)\n",
    "        out = self.layer2(out)\n",
    "        out = self.layer3(out)\n",
    "        out = self.layer4(out)\n",
    "        out = F.avg_pool2d(out, 4)\n",
    "        out = out.view(out.size(0), -1)\n",
    "        y = self.linear(out)\n",
    "        return y\n",
    "    \n",
    "    def record(self, t):\n",
    "        if self.collecting:\n",
    "            self.gram_feats.append(t)\n",
    "    \n",
    "    def gram_feature_list(self,x):\n",
    "        self.collecting = True\n",
    "        self.gram_feats = []\n",
    "        self.forward(x)\n",
    "        self.collecting = False\n",
    "        temp = self.gram_feats\n",
    "        self.gram_feats = []\n",
    "        return temp\n",
    "    \n",
    "    def load(self, path=\"resnet_cifar100.pth\"):\n",
    "        tm = torch.load(path,map_location=\"cpu\")        \n",
    "        self.load_state_dict(tm)\n",
    "    \n",
    "    def get_min_max(self, data, power):\n",
    "        mins = []\n",
    "        maxs = []\n",
    "        \n",
    "        for i in range(0,len(data),128):\n",
    "            batch = data[i:i+128].cuda()\n",
    "            feat_list = self.gram_feature_list(batch)\n",
    "            for L,feat_L in enumerate(feat_list):\n",
    "                if L==len(mins):\n",
    "                    mins.append([None]*len(power))\n",
    "                    maxs.append([None]*len(power))\n",
    "                \n",
    "                for p,P in enumerate(power):\n",
    "                    g_p = G_p(feat_L,P)\n",
    "                    \n",
    "                    current_min = g_p.min(dim=0,keepdim=True)[0]\n",
    "                    current_max = g_p.max(dim=0,keepdim=True)[0]\n",
    "                    \n",
    "                    if mins[L][p] is None:\n",
    "                        mins[L][p] = current_min\n",
    "                        maxs[L][p] = current_max\n",
    "                    else:\n",
    "                        mins[L][p] = torch.min(current_min,mins[L][p])\n",
    "                        maxs[L][p] = torch.max(current_max,maxs[L][p])\n",
    "        \n",
    "        return mins,maxs\n",
    "    \n",
    "    def get_deviations(self,data,power,mins,maxs):\n",
    "        deviations = []\n",
    "        \n",
    "        for i in range(0,len(data),128):            \n",
    "            batch = data[i:i+128].cuda()\n",
    "            feat_list = self.gram_feature_list(batch)\n",
    "            batch_deviations = []\n",
    "            for L,feat_L in enumerate(feat_list):\n",
    "                dev = 0\n",
    "                for p,P in enumerate(power):\n",
    "                    g_p = G_p(feat_L,P)\n",
    "                    \n",
    "                    dev +=  (F.relu(mins[L][p]-g_p)/torch.abs(mins[L][p]+10**-6)).sum(dim=1,keepdim=True)\n",
    "                    dev +=  (F.relu(g_p-maxs[L][p])/torch.abs(maxs[L][p]+10**-6)).sum(dim=1,keepdim=True)\n",
    "                batch_deviations.append(dev.cpu().detach().numpy())\n",
    "            batch_deviations = np.concatenate(batch_deviations,axis=1)\n",
    "            deviations.append(batch_deviations)\n",
    "        deviations = np.concatenate(deviations,axis=0)\n",
    "        \n",
    "        return deviations\n",
    "\n",
    "\n",
    "torch_model = ResNet(BasicBlock, [3,4,6,3], num_classes=100)\n",
    "torch_model.load()\n",
    "torch_model.cuda()\n",
    "torch_model.params = list(torch_model.parameters())\n",
    "torch_model.eval()\n",
    "print(\"Done\")    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Datasets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>In-distribution Datasets</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "batch_size = 128\n",
    "mean = np.array([[0.4914, 0.4822, 0.4465]]).T\n",
    "\n",
    "std = np.array([[0.2023, 0.1994, 0.2010]]).T\n",
    "normalize = transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))\n",
    "\n",
    "transform_train = transforms.Compose([\n",
    "        transforms.RandomCrop(32, padding=4),\n",
    "        transforms.RandomHorizontalFlip(),\n",
    "        transforms.ToTensor(),\n",
    "        normalize\n",
    "        \n",
    "    ])\n",
    "\n",
    "transform_test = transforms.Compose([\n",
    "    transforms.CenterCrop(size=(32, 32)),\n",
    "        transforms.ToTensor(),\n",
    "        normalize\n",
    "    ])\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(\n",
    "    datasets.CIFAR100('data', train=True, download=True,\n",
    "                   transform=transform_train),\n",
    "    batch_size=batch_size, shuffle=True)\n",
    "test_loader = torch.utils.data.DataLoader(\n",
    "    datasets.CIFAR100('data', train=False, transform=transform_test),\n",
    "    batch_size=batch_size)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "data_train = list(torch.utils.data.DataLoader(\n",
    "        datasets.CIFAR100('data', train=True, download=True,\n",
    "                       transform=transform_test),\n",
    "        batch_size=1, shuffle=False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "data = list(torch.utils.data.DataLoader(\n",
    "    datasets.CIFAR100('data', train=False, download=True,\n",
    "                   transform=transform_test),\n",
    "    batch_size=1, shuffle=False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.7834\n"
     ]
    }
   ],
   "source": [
    "torch_model.eval()\n",
    "correct = 0\n",
    "total = 0\n",
    "for x,y in test_loader:\n",
    "    x = x.cuda()\n",
    "    y = y.numpy()\n",
    "    correct += (y==np.argmax(torch_model(x).detach().cpu().numpy(),axis=1)).sum()\n",
    "    total += y.shape[0]\n",
    "print(\"Accuracy: \",correct/total)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Out-of-distribution Datasets</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "cifar10 = list(torch.utils.data.DataLoader(\n",
    "    datasets.CIFAR10('data', train=False, download=True,\n",
    "                   transform=transform_test),\n",
    "    batch_size=1, shuffle=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using downloaded and verified file: data/test_32x32.mat\n"
     ]
    }
   ],
   "source": [
    "svhn = list(torch.utils.data.DataLoader(\n",
    "    datasets.SVHN('data', split=\"test\", download=True,\n",
    "                   transform=transform_test),\n",
    "    batch_size=1, shuffle=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "isun = list(torch.utils.data.DataLoader(\n",
    "    datasets.ImageFolder(\"iSUN/\",transform=transform_test),batch_size=1,shuffle=False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "lsun_c = list(torch.utils.data.DataLoader(\n",
    "    datasets.ImageFolder(\"LSUN/\",transform=transform_test),batch_size=1,shuffle=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "lsun_r = list(torch.utils.data.DataLoader(\n",
    "    datasets.ImageFolder(\"LSUN_resize/\",transform=transform_test),batch_size=1,shuffle=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "tinyimagenet_c = list(torch.utils.data.DataLoader(\n",
    "    datasets.ImageFolder(\"Imagenet/\",transform=transform_test),batch_size=1,shuffle=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "tinyimagenet_r = list(torch.utils.data.DataLoader(\n",
    "    datasets.ImageFolder(\"Imagenet_resize/\",transform=transform_test),batch_size=1,shuffle=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code for Detecting OODs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b> Extract predictions for train and test data </b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done\n",
      "Done\n"
     ]
    }
   ],
   "source": [
    "train_preds = []\n",
    "train_confs = []\n",
    "train_logits = []\n",
    "for idx in range(0,len(data_train),128):\n",
    "    batch = torch.squeeze(torch.stack([x[0] for x in data_train[idx:idx+128]]),dim=1).cuda()\n",
    "    \n",
    "    logits = torch_model(batch)\n",
    "    confs = F.softmax(logits,dim=1).cpu().detach().numpy()\n",
    "    preds = np.argmax(confs,axis=1)\n",
    "    logits = (logits.cpu().detach().numpy())#**2)#.sum(axis=1)\n",
    "\n",
    "    train_confs.extend(np.max(confs,axis=1))    \n",
    "    train_preds.extend(preds)\n",
    "    train_logits.extend(logits)\n",
    "print(\"Done\")\n",
    "\n",
    "test_preds = []\n",
    "test_confs = []\n",
    "test_logits = []\n",
    "\n",
    "for idx in range(0,len(data),128):\n",
    "    batch = torch.squeeze(torch.stack([x[0] for x in data[idx:idx+128]]),dim=1).cuda()\n",
    "    \n",
    "    logits = torch_model(batch)\n",
    "    confs = F.softmax(logits,dim=1).cpu().detach().numpy()\n",
    "    preds = np.argmax(confs,axis=1)\n",
    "    logits = (logits.cpu().detach().numpy())#**2)#.sum(axis=1)\n",
    "\n",
    "    test_confs.extend(np.max(confs,axis=1))    \n",
    "    test_preds.extend(preds)\n",
    "    test_logits.extend(logits)\n",
    "print(\"Done\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b> Code for detecting OODs by identifying anomalies in correlations </b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "import calculate_log as callog\n",
    "\n",
    "def detect(all_test_deviations,all_ood_deviations, verbose=True, normalize=True):\n",
    "    average_results = {}\n",
    "    for i in range(1,11):\n",
    "        random.seed(i)\n",
    "        \n",
    "        validation_indices = random.sample(range(len(all_test_deviations)),int(0.1*len(all_test_deviations)))\n",
    "        test_indices = sorted(list(set(range(len(all_test_deviations)))-set(validation_indices)))\n",
    "        \n",
    "        validation = all_test_deviations[validation_indices]\n",
    "        test_deviations = all_test_deviations[test_indices]\n",
    "\n",
    "        t95 = validation.mean(axis=0)+10**-7\n",
    "        if not normalize:\n",
    "            t95 = np.ones_like(t95)\n",
    "        test_deviations = (test_deviations/t95[np.newaxis,:]).sum(axis=1)\n",
    "        ood_deviations = (all_ood_deviations/t95[np.newaxis,:]).sum(axis=1)\n",
    "        \n",
    "        results = callog.compute_metric(-test_deviations,-ood_deviations)\n",
    "        for m in results:\n",
    "            average_results[m] = average_results.get(m,0)+results[m]\n",
    "    \n",
    "    for m in average_results:\n",
    "        average_results[m] /= i\n",
    "    if verbose:\n",
    "        callog.print_results(average_results)\n",
    "    return average_results\n",
    "\n",
    "\n",
    "def cpu(ob):\n",
    "    for i in range(len(ob)):\n",
    "        for j in range(len(ob[i])):\n",
    "            ob[i][j] = ob[i][j].cpu()\n",
    "    return ob\n",
    "\n",
    "def cuda(ob):\n",
    "    for i in range(len(ob)):\n",
    "        for j in range(len(ob[i])):\n",
    "            ob[i][j] = ob[i][j].cuda()\n",
    "    return ob\n",
    "\n",
    "class Detector:\n",
    "    def __init__(self):\n",
    "        self.all_test_deviations = None\n",
    "        self.mins = {}\n",
    "        self.maxs = {}\n",
    "        \n",
    "        self.classes = range(100)\n",
    "    \n",
    "    def compute_minmaxs(self,data_train,POWERS=[10]):\n",
    "        for PRED in tqdm(self.classes):\n",
    "            train_indices = np.where(np.array(train_preds)==PRED)[0]\n",
    "            train_PRED = torch.squeeze(torch.stack([data_train[i][0] for i in train_indices]),dim=1)\n",
    "            mins,maxs = torch_model.get_min_max(train_PRED,power=POWERS)\n",
    "            self.mins[PRED] = cpu(mins)\n",
    "            self.maxs[PRED] = cpu(maxs)\n",
    "            torch.cuda.empty_cache()\n",
    "    \n",
    "    def compute_test_deviations(self,POWERS=[10]):\n",
    "        all_test_deviations = None\n",
    "        for PRED in tqdm(self.classes):\n",
    "            test_indices = np.where(np.array(test_preds)==PRED)[0]\n",
    "            test_PRED = torch.squeeze(torch.stack([data[i][0] for i in test_indices]),dim=1)\n",
    "            test_confs_PRED = np.array([test_confs[i] for i in test_indices])\n",
    "            mins = cuda(self.mins[PRED])\n",
    "            maxs = cuda(self.maxs[PRED])\n",
    "            test_deviations = torch_model.get_deviations(test_PRED,power=POWERS,mins=mins,maxs=maxs)/test_confs_PRED[:,np.newaxis]\n",
    "            cpu(mins)\n",
    "            cpu(maxs)\n",
    "            if all_test_deviations is None:\n",
    "                all_test_deviations = test_deviations\n",
    "            else:\n",
    "                all_test_deviations = np.concatenate([all_test_deviations,test_deviations],axis=0)\n",
    "            torch.cuda.empty_cache()\n",
    "        self.all_test_deviations = all_test_deviations\n",
    "    \n",
    "    def compute_ood_deviations(self,ood,POWERS=[10]):\n",
    "        ood_preds = []\n",
    "        ood_confs = []\n",
    "        \n",
    "        for idx in range(0,len(ood),128):\n",
    "            batch = torch.squeeze(torch.stack([x[0] for x in ood[idx:idx+128]]),dim=1).cuda()\n",
    "            logits = torch_model(batch)\n",
    "            confs = F.softmax(logits,dim=1).cpu().detach().numpy()\n",
    "            preds = np.argmax(confs,axis=1)\n",
    "            \n",
    "            ood_confs.extend(np.max(confs,axis=1))\n",
    "            ood_preds.extend(preds)  \n",
    "            torch.cuda.empty_cache()\n",
    "        print(\"Done\")\n",
    "        \n",
    "        all_ood_deviations = None\n",
    "        for PRED in tqdm(self.classes):\n",
    "            ood_indices = np.where(np.array(ood_preds)==PRED)[0]\n",
    "            if len(ood_indices)==0:\n",
    "                continue\n",
    "            ood_PRED = torch.squeeze(torch.stack([ood[i][0] for i in ood_indices]),dim=1)\n",
    "            ood_confs_PRED =  np.array([ood_confs[i] for i in ood_indices])\n",
    "            mins = cuda(self.mins[PRED])\n",
    "            maxs = cuda(self.maxs[PRED])\n",
    "            ood_deviations = torch_model.get_deviations(ood_PRED,power=POWERS,mins=mins,maxs=maxs)/ood_confs_PRED[:,np.newaxis]\n",
    "            cpu(self.mins[PRED])\n",
    "            cpu(self.maxs[PRED])            \n",
    "            if all_ood_deviations is None:\n",
    "                all_ood_deviations = ood_deviations\n",
    "            else:\n",
    "                all_ood_deviations = np.concatenate([all_ood_deviations,ood_deviations],axis=0)\n",
    "            torch.cuda.empty_cache()\n",
    "        average_results = detect(self.all_test_deviations,all_ood_deviations)\n",
    "        return average_results, self.all_test_deviations, all_ood_deviations\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center><h1> Results </h1></center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b356f59735b74cccbf45df07cd7a9a50",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "16234970aabe4b4daccf0dc1e74a0f79",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "iSUN\n",
      "Done\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "326d25cb5b24408e870cd8d64513b538",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " TNR    AUROC  DTACC  AUIN   AUOUT \n",
      " 94.756 98.814 94.976 98.755 98.803\n",
      "LSUN (R)\n",
      "Done\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3cc2523b5d4b4d3cbecaa37e04ad9b2a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " TNR    AUROC  DTACC  AUIN   AUOUT \n",
      " 96.606 99.202 95.969 99.171 99.189\n",
      "LSUN (C)\n",
      "Done\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f5b3b69bc8a44dbebb3dcf663abb0fd0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " TNR    AUROC  DTACC  AUIN   AUOUT \n",
      " 64.800 92.132 84.186 90.995 93.004\n",
      "TinyImgNet (R)\n",
      "Done\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "837ccf6cbff94839b97117303d56ceb2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " TNR    AUROC  DTACC  AUIN   AUOUT \n",
      " 94.789 98.898 94.960 98.771 98.956\n",
      "TinyImgNet (C)\n",
      "Done\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5afe4ee2584e4c17bb24768b1419df3d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " TNR    AUROC  DTACC  AUIN   AUOUT \n",
      " 88.478 97.661 92.167 97.392 97.891\n",
      "SVHN\n",
      "Done\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "77a2d847101143f187a8376fb47f8242",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " TNR    AUROC  DTACC  AUIN   AUOUT \n",
      " 80.752 96.049 89.610 90.480 98.487\n",
      "CIFAR-10\n",
      "Done\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d7e39e3b74c44ca4b80409baddbe0207",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " TNR    AUROC  DTACC  AUIN   AUOUT \n",
      " 12.196 67.951 63.475 66.102 66.957\n"
     ]
    }
   ],
   "source": [
    "def G_p(ob, p):\n",
    "    temp = ob.detach()\n",
    "    \n",
    "    temp = temp**p\n",
    "    temp = temp.reshape(temp.shape[0],temp.shape[1],-1)\n",
    "    temp = ((torch.matmul(temp,temp.transpose(dim0=2,dim1=1)))).sum(dim=2) \n",
    "    temp = (temp.sign()*torch.abs(temp)**(1/p)).reshape(temp.shape[0],-1)\n",
    "    \n",
    "    return temp\n",
    "\n",
    "\n",
    "detector = Detector()\n",
    "detector.compute_minmaxs(data_train,POWERS=range(1,11))\n",
    "\n",
    "detector.compute_test_deviations(POWERS=range(1,11))\n",
    "\n",
    "print(\"iSUN\")\n",
    "isun_results = detector.compute_ood_deviations(isun,POWERS=range(1,11))\n",
    "print(\"LSUN (R)\")\n",
    "lsunr_results = detector.compute_ood_deviations(lsun_r,POWERS=range(1,11))\n",
    "print(\"LSUN (C)\")\n",
    "lsunc_results = detector.compute_ood_deviations(lsun_c,POWERS=range(1,11))\n",
    "print(\"TinyImgNet (R)\")\n",
    "timr_results = detector.compute_ood_deviations(tinyimagenet_r,POWERS=range(1,11))\n",
    "print(\"TinyImgNet (C)\")\n",
    "timc_results = detector.compute_ood_deviations(tinyimagenet_c,POWERS=range(1,11))\n",
    "print(\"SVHN\")\n",
    "svhn_results = detector.compute_ood_deviations(svhn,POWERS=range(1,11))\n",
    "print(\"CIFAR-10\")\n",
    "c10_results = detector.compute_ood_deviations(cifar10,POWERS=range(1,11))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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": 2
}