L2_recon.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from tqdm import tqdm\n",
    "import os\n",
    "import seaborn as sns\n",
    "\n",
    "import sys\n",
    "sys.path.insert(0,'/home/gsoc0/Adversarial_CapsNet_Pytorch/')\n",
    "from model.net import *\n",
    "from model.cnn_net import *\n",
    "from utils.training import *\n",
    "from data.data import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Experiment Config"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_path = os.path.join(os.getcwd(), \"weights\")\n",
    "\n",
    "args = {\n",
    "    'DATASET_NAME':'mnist',\n",
    "    'num_classes':10,\n",
    "    \n",
    "    'USE_CUDA': True if torch.cuda.is_available() else False,\n",
    "    'BATCH_SIZE': 512,\n",
    "#     'N_EPOCHS': 100,\n",
    "#     'LEARNING_RATE_1': 1e-2,\n",
    "#     'LEARNING_RATE_2': 1e-2,\n",
    "#     'WEIGHTDECAY':5e-6,\n",
    "#     #Scheduler\n",
    "#     'USE_SCHEDULER':True,\n",
    "#     'sched_milestones':[14,25,30,40,50],\n",
    "#     'sched_gamma':0.1,\n",
    "    \n",
    "#     #Loss Function\n",
    "#     'LAMBDA_recon': 0.5,\n",
    "#     'LAMBDA_class': 1,\n",
    "    \n",
    "    ##For Decoder\n",
    "    'num_features':160,\n",
    "    'LReLU_negative_slope':0.1,\n",
    "    'input_height':28,\n",
    "    'input_width':28,\n",
    "    'input_channel':1,\n",
    "    'type':'plusR',\n",
    "    \n",
    "}\n",
    "\n",
    "\n",
    "#Setting Default Cuda Device\n",
    "torch.cuda.set_device(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Loading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Modified Reconstructor\n",
    "\n",
    "class Reconstructor(nn.Module):\n",
    "    def __init__(self, net, args):\n",
    "        super(Reconstructor, self).__init__()\n",
    "        self.args = args\n",
    "        self.reconstraction_layers = net.decoder.reconstraction_layers\n",
    "        self.mean = torch.tensor(0.1307)\n",
    "        self.std = torch.tensor(0.3081)\n",
    "        if(args['USE_CUDA']):\n",
    "            self.mean = self.mean.cuda()\n",
    "            self.std = self.std.cuda()\n",
    "        self.unnormalize = UnNormalize(self.mean, self.std)\n",
    "        \n",
    "#     def forward(self, x, data):\n",
    "# #         classes = torch.sqrt((x ** 2).sum(2))\n",
    "# #         classes = F.softmax(classes.squeeze(), dim=1)\n",
    "# #         _, max_length_indices = classes.max(dim=1)\n",
    "#         eye = torch.sparse.torch.eye(10)\n",
    "#         if USE_CUDA:\n",
    "#             eye = eye.cuda()\n",
    "#         reconstructions_of_digits = []\n",
    "#         for i in range(0,x.size(1)):\n",
    "#             index_list = torch.ones((x.size(0), ),dtype=torch.int64).cuda()*i\n",
    "#             masked = eye.index_select(dim=0, index=index_list)\n",
    "#             reconstructions_of_digits.append(self.reconstraction_layers((x * masked[:, :, None, None]).view(x.size(0), 1, -1)))\n",
    "        \n",
    "#         reconstructions_of_digits = torch.cat(reconstructions_of_digits, dim=1) #shape = [B, 10, 28*28*1]\n",
    "#         expanded_data = data.view(x.size(0), 1, -1).expand(-1, 10, -1)\n",
    "#         unnormalized_data = self.unnormalize(expanded_data)\n",
    "#         l2_distances = torch.square((unnormalized_data - reconstructions_of_digits)).sum(dim=(list(range(0, len(expanded_data.shape)))[2:]))\n",
    "# #         reconstructions = reconstructions.view(-1, x.size(1), self.input_channel, self.input_width, self.input_height)\n",
    "#         return l2_distances\n",
    "\n",
    "    def forward(self, x, data):\n",
    "        with torch.no_grad():\n",
    "            classes = torch.sqrt((x ** 2).sum(2))\n",
    "            classes = F.softmax(classes.squeeze(), dim=1)\n",
    "            _, max_length_indices = classes.max(dim=1)\n",
    "            max_length_indices_incorrect = 9 - max_length_indices\n",
    "            eye = torch.sparse.torch.eye(10)\n",
    "            if USE_CUDA:\n",
    "                eye = eye.cuda()\n",
    "            reconstructions_of_digits = []\n",
    "            list_of_indices = [max_length_indices, max_length_indices_incorrect]\n",
    "            for i, index_list in enumerate(list_of_indices):\n",
    "                masked = eye.index_select(dim=0, index=index_list.squeeze().data)\n",
    "                reconstructions_of_digits.append(self.reconstraction_layers((x * masked[:, :, None, None]).view(x.size(0), 1, -1)))\n",
    "\n",
    "            reconstructions_of_digits = torch.cat(reconstructions_of_digits, dim=1) \n",
    "            expanded_data = data.view(x.size(0), 1, -1).expand(-1, len(list_of_indices), -1)\n",
    "            unnormalized_data = self.unnormalize(expanded_data)\n",
    "    #         img1 = data[0].reshape(28,28)\n",
    "    #         img2 = reconstructions_of_digits[0][0].reshape(28, 28)\n",
    "    #         img3 = reconstructions_of_digits[0][1].reshape(28, 28)\n",
    "    #         imshow(img1)\n",
    "    #         imshow(img2)\n",
    "    #         imshow(img3)\n",
    "            l2_distances = torch.square((unnormalized_data - reconstructions_of_digits)).sum(dim=(list(range(0, len(expanded_data.shape)))[2:]))\n",
    "            return l2_distances\n",
    "    \n",
    "    def adversarial_recon(self, x, data):\n",
    "        with torch.no_grad():\n",
    "            classes = torch.sqrt((x ** 2).sum(2))\n",
    "            classes = F.softmax(classes.squeeze(), dim=1)\n",
    "            _, max_length_indices = classes.max(dim=1)\n",
    "            eye = torch.sparse.torch.eye(10)\n",
    "            if USE_CUDA:\n",
    "                eye = eye.cuda()\n",
    "            reconstructions_of_digits = []\n",
    "            list_of_indices = [max_length_indices]\n",
    "            for i, index_list in enumerate(list_of_indices):\n",
    "                masked = eye.index_select(dim=0, index=index_list.squeeze().data)\n",
    "                reconstructions_of_digits.append(self.reconstraction_layers((x * masked[:, :, None, None]).view(x.size(0), 1, -1)))\n",
    "\n",
    "            reconstructions_of_digits = torch.cat(reconstructions_of_digits, dim=1)\n",
    "            expanded_data = data.view(x.size(0), 1, -1).expand(-1, len(list_of_indices), -1)\n",
    "            unnormalized_data = self.unnormalize(expanded_data)\n",
    "    #         img1 = data[0].reshape(28,28)\n",
    "    #         img2 = reconstructions_of_digits[0][0].reshape(28, 28)\n",
    "    #         img3 = reconstructions_of_digits[0][1].reshape(28, 28)\n",
    "    #         imshow(img1)\n",
    "    #         imshow(img2)\n",
    "    #         imshow(img3)\n",
    "            l2_distances = torch.square((unnormalized_data - reconstructions_of_digits)).sum(dim=(list(range(0, len(expanded_data.shape)))[2:]))\n",
    "            return l2_distances\n",
    "    \n",
    "def imshow(img):\n",
    "#     img = img * 0.3081 + 0.1307     # unnormalize\n",
    "    npimg = img.cpu().numpy()\n",
    "#     plt.imshow(np.transpose(npimg)#, (1, 2, 0)))\n",
    "    plt.imshow(npimg)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Config:\n",
    "    def __init__(self, dataset='mnist'):\n",
    "        # CNN (cnn)\n",
    "        self.cnn_in_channels = 1\n",
    "        self.cnn_out_channels = 12\n",
    "        self.cnn_kernel_size = 15\n",
    "\n",
    "        # Primary Capsule (pc)\n",
    "        self.pc_num_capsules = 1\n",
    "        self.pc_in_channels = 12\n",
    "        self.pc_out_channels = 16\n",
    "        self.pc_kernel_size = 8\n",
    "        self.pc_num_routes = 7 * 7\n",
    "\n",
    "        # Digit Capsule 1 (dc)\n",
    "        self.dc_num_capsules = 49\n",
    "        self.dc_num_routes = 7 * 7\n",
    "        self.dc_in_channels = 16\n",
    "        self.dc_out_channels = 16 #1\n",
    "        \n",
    "        # Digit Capsule 2 (dc)\n",
    "        self.dc_2_num_capsules = 10\n",
    "        self.dc_2_num_routes = 7 * 7\n",
    "        self.dc_2_in_channels = 16 #1\n",
    "        self.dc_2_out_channels = 16\n",
    "\n",
    "        # Decoder\n",
    "        self.input_width = 28\n",
    "        self.input_height = 28\n",
    "torch.manual_seed(1)\n",
    "config = Config()\n",
    "\n",
    "net = CapsNet(args, config)\n",
    "# capsule_net = torch.nn.DataParallel(capsule_net)\n",
    "if args['USE_CUDA']:\n",
    "    net = net.cuda()\n",
    "    \n",
    "net.load_state_dict(torch.load(os.path.join(model_path, 'CapsNet_mnist.pth'), map_location='cpu'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(-0.4242)\n",
      "tensor(2.8215)\n"
     ]
    }
   ],
   "source": [
    "trainloader, testloader = dataset(args)\n",
    "for data in trainloader:\n",
    "    print(data[0][0].min())\n",
    "    print(data[0][0].max())\n",
    "    break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  The histogram of L2 distances between the input and the reconstruction using the\n",
    "## correct capsule or other capsules in CapsNet on the real MNIST images. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from advertorch.attacks import LinfPGDAttack\n",
    "\n",
    "class Model_for_Adversary(nn.Module):\n",
    "    def __init__(self, net):\n",
    "        super(Model_for_Adversary, self).__init__()\n",
    "        self.net = net\n",
    "        \n",
    "    def forward(self, x):\n",
    "        output, recons, masked = self.net(x)\n",
    "        classes = torch.sqrt((output ** 2).sum(2)).squeeze()\n",
    "        return classes\n",
    "\n",
    "def L2_Distances(net, reconstructor, train_loader, adversary, args):\n",
    "    net.eval()\n",
    "    n_batch = len(train_loader)\n",
    "    l2_distances_correct_incorrect = []\n",
    "    l2_distances_clean_adversarial = []\n",
    "    \n",
    "    for batch_id, (data, target) in enumerate(tqdm(train_loader)):\n",
    "        if(args['USE_CUDA']):\n",
    "            data, target = data.cuda(), target.cuda()\n",
    "\n",
    "        adv_data = adversary.perturb(data, target)\n",
    "        output, _, _ = net(data)        \n",
    "        l2_distances_correct_incorrect.append(reconstructor(output, data).view(-1, ))\n",
    "        output, _, _ = net(adv_data)\n",
    "        l2_distances_clean_adversarial.append(reconstructor.adversarial_recon(output, adv_data).view(-1, ).detach())\n",
    "\n",
    "        \n",
    "    l2 = {}\n",
    "    l2['correct_incorrect'] = torch.cat(l2_distances_correct_incorrect, dim=0).cpu().numpy()\n",
    "    l2['clean_adversarial'] = torch.cat(l2_distances_clean_adversarial, dim=0).cpu().numpy()\n",
    "    \n",
    "    return l2['correct_incorrect'], l2['clean_adversarial']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████  | 16/20 [1:23:26<15:44, 236.10s/it]"
     ]
    }
   ],
   "source": [
    "recon = Reconstructor(net, args)\n",
    "model_for_adversary = Model_for_Adversary(net)\n",
    "    \n",
    "adversary = LinfPGDAttack(\n",
    "    model_for_adversary, loss_fn=nn.CrossEntropyLoss(reduction=\"sum\"), eps=0.3/0.3081,\n",
    "    nb_iter=200, eps_iter=0.01/0.3081, rand_init=True, clip_min=-0.4242, clip_max=2.8215,\n",
    "    targeted=False)\n",
    "\n",
    "l2_distances = L2_Distances(net, recon, testloader, adversary, args)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 200)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "correct_l2 = l2_distances[0][list(range(0,20000,2))]\n",
    "incorrect_l2 = l2_distances[0][list(range(1,19999,2))]\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "sns.set_theme()\n",
    "sns.histplot({'correct':correct_l2, 'incorrect':incorrect_l2}, bins=range(1, 200, 5), ax=ax, kde=False)\n",
    "ax.set_xlabel('l2_distances')\n",
    "ax.set_ylabel('Number of Samples')\n",
    "ax.set_title('L2 Distances of Input and Reconstructions')\n",
    "ax.set_xlim([0, 200])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 200)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "PGD_l2 = l2_distances[1]#[list(range(1,19999,2))]\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "sns.set_theme()\n",
    "sns.histplot({'clean':correct_l2, 'PGD':PGD_l2 }, bins=range(0, 200, 5), ax=ax, kde=False)\n",
    "ax.set_xlabel('l2_distances')\n",
    "ax.set_ylabel('Number of Samples')\n",
    "ax.set_title('L2 Distances of Input and Reconstructions')\n",
    "ax.set_xlim([0, 200])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Histograms for CNN + CR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "args = {\n",
    "    'DATASET_NAME':'mnist',\n",
    "    'num_classes':10,\n",
    "    \n",
    "    'USE_CUDA': True if torch.cuda.is_available() else False,\n",
    "    'BATCH_SIZE': 256,\n",
    "    'N_EPOCHS': 100,\n",
    "    'LEARNING_RATE_1': 1e-2,\n",
    "    'LEARNING_RATE_2': 1e-2,\n",
    "    'WEIGHTDECAY':5e-6,\n",
    "    \n",
    "    #Scheduler\n",
    "    'USE_SCHEDULER':True,\n",
    "    'sched_milestones':[8,20,30,40,50],\n",
    "    'sched_gamma':0.1,\n",
    "    \n",
    "    #Loss Function\n",
    "    'LAMBDA_recon': 0.5,\n",
    "    'LAMBDA_class': 1,\n",
    "    \n",
    "    #For Decoder\n",
    "    'num_features':160,\n",
    "    'LReLU_negative_slope':0.1,\n",
    "    'input_height':28,\n",
    "    'input_width':28,\n",
    "    'input_channel':1,\n",
    "    'type':'plusCR',\n",
    "    \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Config:\n",
    "    def __init__(self, dataset='mnist'):\n",
    "        # CONV1\n",
    "        self.conv1_in = 1\n",
    "        self.conv1_out = 12\n",
    "        self.conv1_kernel_size = 15\n",
    "\n",
    "        # CONV2\n",
    "        self.conv2_in = 12\n",
    "        self.conv2_out = 16\n",
    "        self.conv2_kernel_size = 8\n",
    "\n",
    "        # FC1\n",
    "        self.fc1_in = 7 * 7 * 16\n",
    "        self.fc1_out = 784\n",
    "        \n",
    "        # FC1\n",
    "        self.fc2_in = 784\n",
    "        self.fc2_out = 160\n",
    "\n",
    "torch.manual_seed(2)\n",
    "config = Config()\n",
    "\n",
    "net = CNNnet(args, config)\n",
    "\n",
    "# net = torch.nn.DataParallel(net)\n",
    "net.load_state_dict(torch.load(os.path.join(model_path, 'CNNplusCR_mnist.pth'), map_location='cpu'))\n",
    "    \n",
    "if args['USE_CUDA']:\n",
    "    net = net.cuda()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Modified Reconstructor\n",
    "\n",
    "class Reconstructor(nn.Module):\n",
    "    def __init__(self, net, args):\n",
    "        super(Reconstructor, self).__init__()\n",
    "        self.args = args\n",
    "        self.reconstraction_layers = net.decoder.reconstraction_layers\n",
    "        self.mean = torch.tensor(0.1307)\n",
    "        self.std = torch.tensor(0.3081)\n",
    "        if(args['USE_CUDA']):\n",
    "            self.mean = self.mean.cuda()\n",
    "            self.std = self.std.cuda()\n",
    "        self.unnormalize = UnNormalize(self.mean, self.std)\n",
    "\n",
    "    def forward(self, x, data):\n",
    "        with torch.no_grad():\n",
    "            classes = x.sum(2)\n",
    "            classes = F.softmax(classes.squeeze(), dim=1)\n",
    "            _, max_length_indices = classes.max(dim=1)\n",
    "\n",
    "            if(self.args['type']=='plusCR'):\n",
    "                masked = torch.sparse.torch.eye(10)\n",
    "                if USE_CUDA:\n",
    "                    masked = masked.cuda()\n",
    "                masked = masked.index_select(dim=0, index=max_length_indices.squeeze().data)\n",
    "                t = (x * masked[:, :, None]).view(x.size(0), -1)\n",
    "                reconstructions = self.reconstraction_layers(t)\n",
    "                reconstructions = reconstructions.view(-1, 1, self.args['input_channel']* self.args['input_width']* self.args['input_height'])\n",
    "\n",
    "            elif(self.args['type']=='plusR'):\n",
    "                x = x.view(x.size(0), -1)\n",
    "                reconstructions = self.reconstraction_layers(x)\n",
    "                reconstructions = reconstructions.view(-1, 1, self.args['input_channel']* self.args['input_width']* self.args['input_height'])\n",
    "            \n",
    "            expanded_data = data.view(x.size(0), 1, -1).expand(-1, 1, -1)\n",
    "            unnormalized_data = self.unnormalize(expanded_data)\n",
    "            l2_distances = torch.square((unnormalized_data - reconstructions)).sum(dim=(list(range(0, len(expanded_data.shape)))[2:]))\n",
    "            return l2_distances\n",
    "    \n",
    "    def adversarial_recon(self, x, data):\n",
    "        with torch.no_grad():\n",
    "            classes = x.sum(2)\n",
    "            classes = F.softmax(classes.squeeze(), dim=1)\n",
    "            _, max_length_indices = classes.max(dim=1)\n",
    "            if(self.args['type']=='plusCR'):\n",
    "                masked = torch.sparse.torch.eye(10)\n",
    "                if USE_CUDA:\n",
    "                    masked = masked.cuda()\n",
    "                masked = masked.index_select(dim=0, index=max_length_indices.squeeze().data)\n",
    "                t = (x * masked[:, :, None]).view(x.size(0), -1)\n",
    "                reconstructions = self.reconstraction_layers(t)\n",
    "                reconstructions = reconstructions.view(-1, 1, self.args['input_channel']* self.args['input_width']* self.args['input_height'])\n",
    "            \n",
    "                \n",
    "            elif(self.args['type']=='plusR'):\n",
    "                x = x.view(x.size(0), -1)\n",
    "                reconstructions = self.reconstraction_layers(x)\n",
    "                reconstructions = reconstructions.view(-1, 1, self.args['input_channel']* self.args['input_width']* self.args['input_height'])\n",
    "            \n",
    "            expanded_data = data.view(x.size(0), 1, -1).expand(-1, 1, -1)\n",
    "            unnormalized_data = self.unnormalize(expanded_data)\n",
    "            l2_distances = torch.square((unnormalized_data - reconstructions)).sum(dim=(list(range(0, len(expanded_data.shape)))[2:]))\n",
    "            return l2_distances\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model_for_Adversary(nn.Module):\n",
    "    def __init__(self, net):\n",
    "        super(Model_for_Adversary, self).__init__()\n",
    "        self.net = net\n",
    "        \n",
    "    def forward(self, x):\n",
    "        output, recons, masked = self.net(x)\n",
    "        classes = output.sum(2)\n",
    "        return classes\n",
    "    \n",
    "def L2_Distances(net, reconstructor, train_loader, adversary, args):\n",
    "    net.eval()\n",
    "    n_batch = len(train_loader)\n",
    "    l2_distances_clean = []\n",
    "    l2_distances_adversarial = []\n",
    "    \n",
    "    for batch_id, (data, target) in enumerate(tqdm(train_loader)):\n",
    "        if(args['USE_CUDA']):\n",
    "            data, target = data.cuda(), target.cuda()\n",
    "\n",
    "        adv_data = adversary.perturb(data, target)\n",
    "        output, _, _ = net(data)\n",
    "        l2_distances_clean.append(reconstructor.adversarial_recon(output, data).view(-1, ).detach())\n",
    "        output, _, _ = net(adv_data)\n",
    "        l2_distances_adversarial.append(reconstructor.adversarial_recon(output, adv_data).view(-1, ).detach())\n",
    "\n",
    "        \n",
    "    l2 = {}\n",
    "    l2['clean'] = torch.cat(l2_distances_clean, dim=0).cpu().numpy()\n",
    "    l2['adversarial'] = torch.cat(l2_distances_adversarial, dim=0).cpu().numpy()\n",
    "    \n",
    "    return l2['clean'], l2['adversarial']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 20/20 [00:58<00:00,  2.95s/it]\n"
     ]
    }
   ],
   "source": [
    "recon = Reconstructor(net, args)\n",
    "model_for_adversary = Model_for_Adversary(net)\n",
    "    \n",
    "adversary = LinfPGDAttack(\n",
    "    model_for_adversary, loss_fn=nn.CrossEntropyLoss(reduction=\"sum\"), eps=0.3/0.3081,\n",
    "    nb_iter=200, eps_iter=0.01/0.3081, rand_init=True, clip_min=-0.4242, clip_max=2.8215,\n",
    "    targeted=False)\n",
    "\n",
    "l2_distances = L2_Distances(net, recon, testloader, adversary, args)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 200)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "clean_l2 = l2_distances[0]#[list(range(0,20000,2))]\n",
    "adversarial_l2 = l2_distances[1]#[list(range(1,19999,2))]\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "sns.set_theme()\n",
    "sns.histplot({'clean':clean_l2, 'adversarial':adversarial_l2}, bins=range(1, 200, 5), ax=ax, kde=False)\n",
    "ax.set_xlabel('l2_distances')\n",
    "ax.set_ylabel('Number of Samples')\n",
    "ax.set_title('L2 Distances of Input and Reconstructions')\n",
    "ax.set_xlim([0, 200])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Histograms for CNN plus R"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "args = {\n",
    "    'DATASET_NAME':'mnist',\n",
    "    'num_classes':10,\n",
    "    \n",
    "    'USE_CUDA': True if torch.cuda.is_available() else False,\n",
    "    'BATCH_SIZE': 256,\n",
    "    'N_EPOCHS': 100,\n",
    "    'LEARNING_RATE_1': 1e-2,\n",
    "    'LEARNING_RATE_2': 1e-2,\n",
    "    'WEIGHTDECAY':5e-6,\n",
    "    \n",
    "    #Scheduler\n",
    "    'USE_SCHEDULER':True,\n",
    "    'sched_milestones':[8,20,30,40,50],\n",
    "    'sched_gamma':0.1,\n",
    "    \n",
    "    #Loss Function\n",
    "    'LAMBDA_recon': 0.5,\n",
    "    'LAMBDA_class': 1,\n",
    "    \n",
    "    #For Decoder\n",
    "    'num_features':160,\n",
    "    'LReLU_negative_slope':0.1,\n",
    "    'input_height':28,\n",
    "    'input_width':28,\n",
    "    'input_channel':1,\n",
    "    'type':'plusR',\n",
    "    \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Config:\n",
    "    def __init__(self, dataset='mnist'):\n",
    "        # CONV1\n",
    "        self.conv1_in = 1\n",
    "        self.conv1_out = 12\n",
    "        self.conv1_kernel_size = 15\n",
    "\n",
    "        # CONV2\n",
    "        self.conv2_in = 12\n",
    "        self.conv2_out = 16\n",
    "        self.conv2_kernel_size = 8\n",
    "\n",
    "        # FC1\n",
    "        self.fc1_in = 7 * 7 * 16\n",
    "        self.fc1_out = 784\n",
    "        \n",
    "        # FC1\n",
    "        self.fc2_in = 784\n",
    "        self.fc2_out = 160\n",
    "\n",
    "torch.manual_seed(2)\n",
    "config = Config()\n",
    "\n",
    "net = CNNnet(args, config)\n",
    "\n",
    "# net = torch.nn.DataParallel(net)\n",
    "net.load_state_dict(torch.load(os.path.join(model_path, 'CNNplusR_mnist.pth'), map_location='cpu'))\n",
    "    \n",
    "if args['USE_CUDA']:\n",
    "    net = net.cuda()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 20/20 [00:58<00:00,  2.91s/it]\n"
     ]
    }
   ],
   "source": [
    "recon = Reconstructor(net, args)\n",
    "model_for_adversary = Model_for_Adversary(net)\n",
    "    \n",
    "adversary = LinfPGDAttack(\n",
    "    model_for_adversary, loss_fn=nn.CrossEntropyLoss(reduction=\"sum\"), eps=0.3/0.3081,\n",
    "    nb_iter=200, eps_iter=0.01/0.3081, rand_init=True, clip_min=-0.4242, clip_max=2.8215,\n",
    "    targeted=False)\n",
    "\n",
    "l2_distances = L2_Distances(net, recon, testloader, adversary, args)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 200)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "clean_l2 = l2_distances[0]#[list(range(0,20000,2))]\n",
    "adversarial_l2 = l2_distances[1]#[list(range(1,19999,2))]\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "sns.set_theme()\n",
    "sns.histplot({'clean':clean_l2, 'adversarial':adversarial_l2}, bins=range(1, 200, 5), ax=ax, kde=False)\n",
    "ax.set_xlabel('l2_distances')\n",
    "ax.set_ylabel('Number of Samples')\n",
    "ax.set_title('L2 Distances of Input and Reconstructions')\n",
    "ax.set_xlim([0, 200])"
   ]
  },
  {
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}