continue_training.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c1e8e381-ef64-4b84-a2ae-03b9abed3dde",
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "import torch\n",
    "import time\n",
    "import os\n",
    "import random \n",
    "import numpy as np\n",
    "import aux_funcs  as af\n",
    "import network_architectures as arcs\n",
    "\n",
    "from architectures.CNNs.VGG import VGG\n",
    "\n",
    "from train_networks import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "dea793a6-4719-4547-a614-740087a997d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random Seed: 1221\n",
      "Using PyTorch version: 1.12.1+cu116 CUDA: True\n",
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "Creating resnet56 untrained cifar10 models...\n",
      "Saving CNN...\n"
     ]
    }
   ],
   "source": [
    "random_seed = af.get_random_seed()\n",
    "af.set_random_seeds()\n",
    "print('Random Seed: {}'.format(random_seed))\n",
    "device = af.get_pytorch_device()\n",
    "models_path = 'networks/{}'.format(af.get_random_seed())\n",
    "af.create_path(models_path)\n",
    "af.set_logger('outputs/train_models'.format(af.get_random_seed()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "cb80f321-fdac-4d57-ad0d-b3649a09a73f",
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'init_rpf_pannel'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "Cell \u001b[0;32mIn [19], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m tasks \u001b[38;5;241m=\u001b[39m [\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcifar10\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[0;32m----> 3\u001b[0m cnns \u001b[38;5;241m=\u001b[39m [\u001b[43marcs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcreate_resnet56\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodels_path\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mcifar10\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msave_type\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mc\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m]\n\u001b[1;32m      4\u001b[0m train(models_path, cnns, sdn\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, device\u001b[38;5;241m=\u001b[39mdevice)\n",
      "File \u001b[0;32m/notebooks/Shallow-Deep-Networks/network_architectures.py:125\u001b[0m, in \u001b[0;36mcreate_resnet56\u001b[0;34m(models_path, task, save_type, get_params, in_memory)\u001b[0m\n\u001b[1;32m    122\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m get_params:\n\u001b[1;32m    123\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m model_params\n\u001b[0;32m--> 125\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43msave_networks\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel_params\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodels_path\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msave_type\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43min_memory\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m/notebooks/Shallow-Deep-Networks/network_architectures.py:45\u001b[0m, in \u001b[0;36msave_networks\u001b[0;34m(model_name, model_params, models_path, save_type, in_memory)\u001b[0m\n\u001b[1;32m     43\u001b[0m     model \u001b[38;5;241m=\u001b[39m WideResNet(model_params)\n\u001b[1;32m     44\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mresnet\u001b[39m\u001b[38;5;124m'\u001b[39m \u001b[38;5;129;01min\u001b[39;00m network_type:\n\u001b[0;32m---> 45\u001b[0m     model \u001b[38;5;241m=\u001b[39m \u001b[43mResNet\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel_params\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     46\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mvgg\u001b[39m\u001b[38;5;124m'\u001b[39m \u001b[38;5;129;01min\u001b[39;00m network_type:\n\u001b[1;32m     47\u001b[0m     model \u001b[38;5;241m=\u001b[39m VGG(model_params)\n",
      "File \u001b[0;32m/notebooks/Shallow-Deep-Networks/architectures/CNNs/ResNet.py:60\u001b[0m, in \u001b[0;36mResNet.__init__\u001b[0;34m(self, params)\u001b[0m\n\u001b[1;32m     56\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39min_channels \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m16\u001b[39m\n\u001b[1;32m     57\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_output \u001b[38;5;241m=\u001b[39m  \u001b[38;5;241m1\u001b[39m\n\u001b[0;32m---> 60\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minit_rpf_channels \u001b[38;5;241m=\u001b[39m \u001b[43mparams\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43minit_rpf_pannel\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\n\u001b[1;32m     61\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39muse_rpf \u001b[38;5;241m=\u001b[39m params[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124muse_rpf\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[1;32m     63\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mblock_type \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mbasic\u001b[39m\u001b[38;5;124m'\u001b[39m:\n",
      "\u001b[0;31mKeyError\u001b[0m: 'init_rpf_pannel'"
     ]
    }
   ],
   "source": [
    "tasks = ['cifar10']\n",
    "\n",
    "cnns = [arcs.create_resnet56(models_path, 'cifar10', save_type='c')]\n",
    "train(models_path, cnns, sdn=False, device=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "b8357226-5567-45b5-808b-165e4c2c11df",
   "metadata": {},
   "outputs": [],
   "source": [
    "cnn_model = arcs.load_model(models_path, \"cifar10_resnet56_rpf_cnn\", -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c082dd1e-e593-4477-9548-9486a344c84c",
   "metadata": {},
   "outputs": [],
   "source": [
    "sdn_model = arcs.load_model(models_path, \"cifar10_resnet56_rpf_sdn_sdn_training\", -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "086345fa-322b-49d1-9c2e-352ecb62d6bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torchattacks\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "\n",
    "def evaluate_sdn_attack(model, test_loader, atk):\n",
    "    atk.set_normalization_used(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n",
    "    test_acc = 0\n",
    "    n = 0\n",
    "    model.eval()\n",
    "    for i, (X, y) in enumerate(test_loader):\n",
    "        X, y = X.to('cuda'), y.to('cuda')\n",
    "\n",
    "        if model.use_rpf:\n",
    "          model.random_rp_matrix()\n",
    "\n",
    "        X_adv = atk(X, y)  # advtorch\n",
    "\n",
    "        if model.use_rpf:\n",
    "          model.random_rp_matrix()\n",
    "\n",
    "        with torch.no_grad():\n",
    "            output = model(X_adv)\n",
    "        test_acc += (output.max(1)[1] == y).sum().item()\n",
    "        n += y.size(0)\n",
    "\n",
    "    pgd_acc = test_acc / n\n",
    "    return pgd_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ecdd4835-2812-4e1d-9274-6a47db8a208b",
   "metadata": {},
   "outputs": [],
   "source": [
    "cifar = af.get_dataset(\"cifar10\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "3fba6b6c-353f-4dc2-be43-5b2a00b9edd2",
   "metadata": {},
   "outputs": [],
   "source": [
    "sdn_model[0].early_stop = True\n",
    "sdn_model[0].need_info = False\n",
    "sdn_model[0].confidence_threshold = 2\n",
    "sdn_model[0].use_rpf = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b137ca9d-aa90-4a4e-8846-98c6af12fde7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ResNet_SDN(\n",
       "  (init_conv): Sequential(\n",
       "    (0): Conv2d(3, 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "    (1): Conv2d(3, 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "    (2): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (3): ReLU()\n",
       "  )\n",
       "  (layers): ModuleList(\n",
       "    (0): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential()\n",
       "        (2): ReLU()\n",
       "      )\n",
       "    )\n",
       "    (1): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential()\n",
       "        (2): ReLU()\n",
       "      )\n",
       "    )\n",
       "    (2): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential()\n",
       "        (2): ReLU()\n",
       "      )\n",
       "    )\n",
       "    (3): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential()\n",
       "        (2): ReLU()\n",
       "      )\n",
       "      (output): InternalClassifier(\n",
       "        (max_pool): MaxPool2d(kernel_size=8, stride=8, padding=0, dilation=1, ceil_mode=False)\n",
       "        (avg_pool): AvgPool2d(kernel_size=8, stride=8, padding=0)\n",
       "        (linear): Linear(in_features=256, out_features=10, bias=True)\n",
       "      )\n",
       "    )\n",
       "    (4): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential()\n",
       "        (2): ReLU()\n",
       "      )\n",
       "    )\n",
       "    (5): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential()\n",
       "        (2): ReLU()\n",
       "      )\n",
       "    )\n",
       "    (6): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential()\n",
       "        (2): ReLU()\n",
       "      )\n",
       "    )\n",
       "    (7): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential()\n",
       "        (2): ReLU()\n",
       "      )\n",
       "      (output): InternalClassifier(\n",
       "        (max_pool): MaxPool2d(kernel_size=8, stride=8, padding=0, dilation=1, ceil_mode=False)\n",
       "        (avg_pool): AvgPool2d(kernel_size=8, stride=8, padding=0)\n",
       "        (linear): Linear(in_features=256, out_features=10, bias=True)\n",
       "      )\n",
       "    )\n",
       "    (8): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential()\n",
       "        (2): ReLU()\n",
       "      )\n",
       "    )\n",
       "    (9): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(16, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential(\n",
       "          (0): Conv2d(16, 32, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "          (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (2): ReLU()\n",
       "      )\n",
       "    )\n",
       "    (10): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential()\n",
       "        (2): ReLU()\n",
       "      )\n",
       "    )\n",
       "    (11): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential()\n",
       "        (2): ReLU()\n",
       "      )\n",
       "      (output): InternalClassifier(\n",
       "        (max_pool): MaxPool2d(kernel_size=4, stride=4, padding=0, dilation=1, ceil_mode=False)\n",
       "        (avg_pool): AvgPool2d(kernel_size=4, stride=4, padding=0)\n",
       "        (linear): Linear(in_features=512, out_features=10, bias=True)\n",
       "      )\n",
       "    )\n",
       "    (12): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential()\n",
       "        (2): ReLU()\n",
       "      )\n",
       "    )\n",
       "    (13): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential()\n",
       "        (2): ReLU()\n",
       "      )\n",
       "    )\n",
       "    (14): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential()\n",
       "        (2): ReLU()\n",
       "      )\n",
       "    )\n",
       "    (15): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential()\n",
       "        (2): ReLU()\n",
       "      )\n",
       "      (output): InternalClassifier(\n",
       "        (max_pool): MaxPool2d(kernel_size=4, stride=4, padding=0, dilation=1, ceil_mode=False)\n",
       "        (avg_pool): AvgPool2d(kernel_size=4, stride=4, padding=0)\n",
       "        (linear): Linear(in_features=512, out_features=10, bias=True)\n",
       "      )\n",
       "    )\n",
       "    (16): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential()\n",
       "        (2): ReLU()\n",
       "      )\n",
       "    )\n",
       "    (17): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential()\n",
       "        (2): ReLU()\n",
       "      )\n",
       "    )\n",
       "    (18): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(32, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential(\n",
       "          (0): Conv2d(32, 64, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "          (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (2): ReLU()\n",
       "      )\n",
       "    )\n",
       "    (19): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential()\n",
       "        (2): ReLU()\n",
       "      )\n",
       "      (output): InternalClassifier(\n",
       "        (max_pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "        (avg_pool): AvgPool2d(kernel_size=2, stride=2, padding=0)\n",
       "        (linear): Linear(in_features=1024, out_features=10, bias=True)\n",
       "      )\n",
       "    )\n",
       "    (20): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential()\n",
       "        (2): ReLU()\n",
       "      )\n",
       "    )\n",
       "    (21): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential()\n",
       "        (2): ReLU()\n",
       "      )\n",
       "    )\n",
       "    (22): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential()\n",
       "        (2): ReLU()\n",
       "      )\n",
       "    )\n",
       "    (23): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential()\n",
       "        (2): ReLU()\n",
       "      )\n",
       "      (output): InternalClassifier(\n",
       "        (max_pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "        (avg_pool): AvgPool2d(kernel_size=2, stride=2, padding=0)\n",
       "        (linear): Linear(in_features=1024, out_features=10, bias=True)\n",
       "      )\n",
       "    )\n",
       "    (24): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential()\n",
       "        (2): ReLU()\n",
       "      )\n",
       "    )\n",
       "    (25): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential()\n",
       "        (2): ReLU()\n",
       "      )\n",
       "    )\n",
       "    (26): BasicBlockWOutput(\n",
       "      (layers): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU()\n",
       "          (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "        (1): Sequential()\n",
       "        (2): ReLU()\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (end_layers): Sequential(\n",
       "    (0): AvgPool2d(kernel_size=8, stride=8, padding=0)\n",
       "    (1): Flatten()\n",
       "    (2): Linear(in_features=64, out_features=10, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sdn_model[0].cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "08cdbf91-1c3f-4c96-8a40-26ff2b104db5",
   "metadata": {},
   "outputs": [],
   "source": [
    "atk = torchattacks.FGSM(sdn_model[0], eps=8/255)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "17a55900-c41b-4e50-a5db-f8550651532e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6715"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evaluate_sdn_attack(sdn_model[0], cifar.test_loader, atk)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "b1c8b7e4-ca00-4474-b112-39ea85f79cf5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.57167"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(sdn_res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "9a1834a2-13d6-423d-ad25-a9caa3b652b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "cnn_model[0].cuda()\n",
    "atk = torchattacks.FGSM(cnn_model[0], eps=8/255)\n",
    "cnn_res = []\n",
    "for i in range(50):\n",
    "    acc = evaluate_sdn_attack(cnn_model[0], cifar.test_loader, atk)\n",
    "    cnn_res.append(acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "51c54ccc-0700-4635-88ef-944ab88c311b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.480906"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(cnn_res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "575876b2-d99e-477c-9bf0-96e7b9a9c63d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import model_funcs as mf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "cf83c02c-280e-4f84-8250-7e329709e4b8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(87.15, 99.43)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mf.cnn_test(sdn_model[0], cifar.test_loader, device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "cc025923-8e58-40cc-a11b-ea65971455e7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(86.799995, 99.43)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mf.cnn_test(cnn_model[0], cifar.test_loader, device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9168b677-e868-405b-aa57-d50485817b5e",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}