MultiplePerturbations.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend\n"
     ]
    }
   ],
   "source": [
    "import autokeras as ak\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.utils.data as data\n",
    "import torchvision.transforms as transforms\n",
    "from torch.autograd import Variable\n",
    "from torch.autograd import Function\n",
    "from tensorflow.keras.models import load_model\n",
    "import tensorflow as tf\n",
    "import medmnist\n",
    "from medmnist import INFO, Evaluator\n",
    "import torchvision.transforms as trn\n",
    "import torchvision.transforms.functional as trn_F\n",
    "import cv2\n",
    "from sklearn.metrics import accuracy_score, f1_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading https://zenodo.org/records/6496656/files/pneumoniamnist.npz to C:\\Users\\chube\\.medmnist\\pneumoniamnist.npz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████| 4170669/4170669 [00:01<00:00, 2545547.18it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using downloaded and verified file: C:\\Users\\chube\\.medmnist\\pneumoniamnist.npz\n",
      "Using downloaded and verified file: C:\\Users\\chube\\.medmnist\\pneumoniamnist.npz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "data_flag = 'pneumoniamnist'\n",
    "download = True\n",
    "\n",
    "#NUM_EPOCHS = 3\n",
    "#BATCH_SIZE = 128\n",
    "lr = 0.001\n",
    "\n",
    "info = INFO[data_flag]\n",
    "task = info['task']\n",
    "n_channels = info['n_channels']\n",
    "n_classes = len(info['label'])\n",
    "\n",
    "DataClass = getattr(medmnist, info['python_class'])\n",
    "\n",
    "# preprocessing\n",
    "data_transform = transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize(mean=[.5], std=[.5])\n",
    "])\n",
    "\n",
    "# load the data\n",
    "train_dataset = DataClass(split='train', transform=data_transform, download=download)\n",
    "validation_dataset = DataClass(split = 'val', transform = data_transform, download = download)\n",
    "test_dataset = DataClass(split='test', transform=data_transform, download=download)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train = train_dataset.imgs\n",
    "x_val = validation_dataset.imgs\n",
    "x_test = test_dataset.imgs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train = train_dataset.labels.reshape((len(train_dataset.labels),))\n",
    "y_val   = validation_dataset.labels.reshape((len(validation_dataset.labels),))\n",
    "y_test  = test_dataset.labels.reshape((len(test_dataset.labels),))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "proportion = [0.2, 0.4, 0.6, 0.8, 1]\n",
    "num_train  = len(y_train)\n",
    "num_test   = len(y_test)\n",
    "num_iter   = 1000\n",
    "perturbs   = ['noise', 'contrast', 'rotate', 'tilt', 'blur']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rotate(img, deg):\n",
    "    img = Image.fromarray(img)\n",
    "    if img.mode != 'L':\n",
    "        img = img.convert('L')\n",
    "    z = trn.CenterCrop(28)(trn_F.affine(img, angle=deg-15, translate=(0, 0), scale=1., shear=0))\n",
    "    return z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def disk(radius, alias_blur=0.1, dtype=np.float32):\n",
    "    if radius <= 8:\n",
    "        L = np.arange(-8, 8 + 1)\n",
    "        ksize = (3, 3)\n",
    "    else:\n",
    "        L = np.arange(-radius, radius + 1)\n",
    "        ksize = (5, 5)\n",
    "    X, Y = np.meshgrid(L, L)\n",
    "    aliased_disk = np.array((X ** 2 + Y ** 2) <= radius ** 2, dtype=dtype)\n",
    "    aliased_disk /= np.sum(aliased_disk)\n",
    "\n",
    "    # supersample disk to antialias\n",
    "    return cv2.GaussianBlur(aliased_disk, ksize=ksize, sigmaX=alias_blur)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tilt(img, deg):\n",
    "    x = np.array(img)\n",
    "    h, w = x.shape[0:2]\n",
    "    phi, theta = np.deg2rad(deg-15), np.deg2rad(deg-15)\n",
    "    f = np.sqrt(w**2+h**2)\n",
    "    P1 = np.array([[1,0,-w/2], [0,1,-h/2], [0,0,1], [0,0,1]])\n",
    "    RX = np.array([[1,0,0,0], [0, np.cos(theta), -np.sin(theta), 0],\n",
    "                  [0, np.sin(theta), np.cos(theta), 0], [0, 0, 0, 1]])\n",
    "    RY = np.array([[np.cos(phi), 0, -np.sin(phi), 0], [0,1,0,0],\n",
    "                  [np.sin(phi), 0, np.cos(phi), 0], [0, 0, 0, 1]])\n",
    "    T = np.array([[1, 0, 0, 0], [0, 1, 0, 0],\n",
    "                   [0, 0, 1, f], [0, 0, 0, 1]])\n",
    "    P2 = np.array([[f, 0, w / 2, 0], [0, f, h / 2, 0], [0, 0, 1, 0]])\n",
    "    mat = P2 @ T @ RX @ RY @ P1\n",
    "    z = trn.CenterCrop(28)(Image.fromarray(cv2.warpPerspective(x, mat, (w, h))))\n",
    "    return z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def contrast(img, factor, dim = 2):\n",
    "    \n",
    "    if dim == 3:\n",
    "        num = img.shape[0]\n",
    "        temp = np.zeros((num,img.shape[1], img.shape[2]))\n",
    "        for i in range(num):\n",
    "            tempi = img[i,:,:]\n",
    "            im = Image.fromarray(tempi)\n",
    "            if im.mode != 'L':\n",
    "                im = im.convert('L')\n",
    "            enhancer = ImageEnhance.Contrast(im)\n",
    "            im_output = enhancer.enhance(factor)\n",
    "            im_array = np.asarray(im_output)\n",
    "            temp[i,:,:] = im_array\n",
    "        return temp\n",
    "    else:\n",
    "        if type(img) == np.ndarray:\n",
    "            im = Image.fromarray(img)\n",
    "        else:\n",
    "            im = img\n",
    "        if im.mode != 'L':\n",
    "            im = im.convert('L')\n",
    "        enhancer = ImageEnhance.Contrast(im)\n",
    "        im_output = enhancer.enhance(factor)\n",
    "        im_array = np.asarray(im_output)\n",
    "        return im_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Egg\\anaconda3\\lib\\site-packages\\torchvision\\transforms\\functional.py:1135: UserWarning: The parameter 'resample' is deprecated since 0.12 and will be removed in 0.14. Please use 'interpolation' instead.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 144x144 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "image = contrast(x_test[0],3)\n",
    "plot(rotate(image, 45))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def defocus_blur(x, severity=1):\n",
    "    c = [(3, 0.1), (4, 0.5), (6, 0.5), (8, 0.5), (10, 0.5)][severity - 1]\n",
    "\n",
    "    x = np.array(x) / 255.\n",
    "    kernel = disk(radius=c[0], alias_blur=c[1])\n",
    "\n",
    "    channels = []\n",
    "    channels.append(cv2.filter2D(x[:, :], -1, kernel))\n",
    "    channels = np.array(channels).transpose((1, 2, 0))  # 3x224x224 -> 224x224x3\n",
    "    output = np.clip(channels, 0, 1) * 255\n",
    "    output = output.reshape((28,28))\n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(624, 28, 28)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gaussian_noise(x, c):\n",
    "    #c =[0.02, 0.04, 0.06, 0.08, 0.1][severity - 1]\n",
    "    \n",
    "    x = np.array(x)/255\n",
    "    np.random.seed(2)\n",
    "    x = np.clip(x+ np.random.normal(size = x.shape, scale = c), 0, 1 * 255)\n",
    "    return x.astype(np.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot(img):\n",
    "    plt.figure(figsize = (2,2))\n",
    "    plt.imshow(img, cmap = \"gray\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 200x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from PIL import Image, ImageEnhance\n",
    "img = x_test[1]\n",
    "im = Image.fromarray(img)\n",
    "enhancer = ImageEnhance.Contrast(im)\n",
    "\n",
    "factor = 3 #gives original image\n",
    "im_output = enhancer.enhance(factor)\n",
    "plt.figure(figsize = (2,2))\n",
    "plt.imshow(im_output, cmap = \"gray\")\n",
    "plt.show()\n",
    "#im_output.save('original-image.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 200x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 200x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot(gaussian_noise(img, 0.08))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 200x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot(contrast(img, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 200x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot(rotate(img, deg = 45))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 200x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot(tilt(img, deg = 45))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 200x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot(defocus_blur(img))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4708"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_perturb = 471\n",
    "x_train.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "from pprint import pprint\n",
    "import random\n",
    "\n",
    "def random_generator(seq, n, m):\n",
    "    rand_seq = seq[:]  # make a copy to avoid changing input argument\n",
    "    random.shuffle(rand_seq)\n",
    "    lists = []\n",
    "    limit = n-1\n",
    "    for i,group in enumerate(zip(*([iter(rand_seq)]*m))):\n",
    "        lists.append(group)\n",
    "        if i == limit: break  # have enough\n",
    "    return lists\n",
    "\n",
    "words = np.arange(x_train.shape[0])\n",
    "perturb_idxs = random_generator(words, 5, 471)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def perturb_data(samples, idx_corrupt, variant):\n",
    "    \n",
    "    num_total = samples.shape[0]\n",
    "    temp_set = np.zeros((samples.shape))\n",
    "    img_shape = samples[0].shape\n",
    "    \n",
    "    if variant == 'noise':\n",
    "        for k in range(num_total):\n",
    "            img = samples[k]\n",
    "            if k in idx_corrupt:\n",
    "                temp = gaussian_noise(img, 0.08)\n",
    "                temp_set[k] = temp*255\n",
    "            else:\n",
    "                temp = np.copy(img)\n",
    "                temp_set[k] = temp\n",
    "                \n",
    "    if variant == 'contrast':\n",
    "        for k in range(num_total):\n",
    "            img = samples[k]\n",
    "            if k in idx_corrupt:\n",
    "                temp = contrast(img, 3)\n",
    "                temp_set[k] = temp\n",
    "            else:\n",
    "                temp = np.copy(img)\n",
    "                temp_set[k] = temp\n",
    "    \n",
    "    if variant == 'tilt':\n",
    "        for k in range(num_total):\n",
    "            img = samples[k]\n",
    "            np.random.seed(k**2)\n",
    "            angle = np.random.randint(0, high = 90)\n",
    "            \n",
    "            if k in idx_corrupt:\n",
    "                temp = tilt(img, angle)\n",
    "                temp_set[k] = temp\n",
    "            else:\n",
    "                temp = np.copy(img)\n",
    "                temp_set[k] = temp\n",
    "    \n",
    "    if variant == 'blur':\n",
    "        for k in range(num_total):\n",
    "            img = samples[k]\n",
    "            if k in idx_corrupt:\n",
    "                temp = defocus_blur(img, severity = 1).reshape((28,28))\n",
    "                temp_set[k] = temp\n",
    "            else:\n",
    "                temp = np.copy(img)\n",
    "                temp_set[k] = temp\n",
    "    \n",
    "    if variant == 'rotate':\n",
    "        for k in range(num_total):\n",
    "            img = samples[k]\n",
    "            np.random.seed(k)\n",
    "            angle = np.random.randint(-90, high = 90)\n",
    "            if k in idx_corrupt:\n",
    "                temp        = rotate(img, angle)\n",
    "                temp_set[k] = temp\n",
    "            else:\n",
    "                temp = np.copy(img)\n",
    "                temp_set[k] = temp\n",
    "\n",
    "    return temp_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# all_perturb_idxs = np.concatenate((perturb_idxs[0], perturb_idxs[1], perturb_idxs[2], perturb_idxs[3], perturb_idxs[4]))\n",
    "# print(all_perturb_idxs.shape)\n",
    "\n",
    "# all_idxs = np.arange(x_train.shape[0])\n",
    "# no_noise_idxs = [item for item in all_idxs if item not in all_perturb_idxs]\n",
    "# no_noise_idxs = np.array(no_noise_idxs)\n",
    "# print(no_noise_idxs.shape[0] + all_perturb_idxs.shape[0] == all_idxs.shape[0])\n",
    "\n",
    "# clean_imgs = x_train[no_noise_idxs,:,:]\n",
    "# print(clean_imgs.shape)\n",
    "\n",
    "# new_train = []\n",
    "# for i in range(len(perturbs)):\n",
    "#     new_train.append(perturb_data(samples = x_train[perturb_idxs[i],:,:], idx_corrupt = np.arange(x_train[perturb_idxs[0],:,:].shape[0]), variant = perturbs[i]))\n",
    "\n",
    "# new_y = []\n",
    "# new_y.append(y_train[list(perturb_idxs[0])])\n",
    "# new_y.append(y_train[list(perturb_idxs[1])])\n",
    "# new_y.append(y_train[list(perturb_idxs[2])])\n",
    "# new_y.append(y_train[list(perturb_idxs[3])])\n",
    "# new_y.append(y_train[list(perturb_idxs[4])])\n",
    "# new_y.append(y_train[no_noise_idxs])\n",
    "# y_new = np.concatenate((new_y[0], new_y[1], new_y[2], new_y[3], new_y[4], new_y[5]))\n",
    "# print(y_new.shape)\n",
    "\n",
    "# new_data = np.concatenate((new_train[0], new_train[1], new_train[2], new_train[3], new_train[4], clean_imgs))\n",
    "# new_data.shape\n",
    "\n",
    "# created_model_list = []\n",
    "# pmodel_list = []\n",
    "# for i in range(len(omodel_list)):\n",
    "#     model_number = i\n",
    "#     OG_model = load_model(\"MODEL_\"+str(model_number)+\"_XRAY\", custom_objects = ak.CUSTOM_OBJECTS)\n",
    "            \n",
    "#     weights = OG_model.get_weights()\n",
    "#     np.random.seed(12345)\n",
    "#     weights = [np.random.permutation(w.flat).reshape(w.shape) for w in weights]\n",
    "#     OG_model.set_weights(weights)\n",
    "#     OG_model.fit(new_data, y_new, epochs = 5, batch_size = 8)\n",
    "#     try:\n",
    "#         OG_model.save(\"MODEL_\"+str(model_number)+\"_XRAY_\"+\"MIX\", save_format = \"tf\")\n",
    "#     except Exception:\n",
    "#         OG_model.save(\"MODEL_\"+str(model_number)+\"_XRAY_\"+\"MIX.h5\")\n",
    "        \n",
    "#     pmodel_list.append(OG_model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_models = 10\n",
    "omodel_list = []\n",
    "pmodel_list = []\n",
    "for i in tqdm(range(num_models)):\n",
    "    omodel_list.append(load_model(\"MODEL_\"+str(i)+\"_XRAY\", custom_objects = ak.CUSTOM_OBJECTS, compile = False))\n",
    "    pmodel_list.append(load_model(\"MODEL_\"+str(i)+\"_XRAY_MIX\", custom_objects = ak.CUSTOM_OBJECTS, compile = False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [04:24<00:00,  1.32s/it]\n",
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [03:27<00:00,  1.04s/it]\n",
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [03:07<00:00,  1.07it/s]\n",
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [03:02<00:00,  1.09it/s]\n",
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [03:45<00:00,  1.13s/it]\n",
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [03:38<00:00,  1.09s/it]\n",
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [03:48<00:00,  1.14s/it]\n",
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [06:09<00:00,  1.85s/it]\n",
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [04:20<00:00,  1.30s/it]\n",
      "100%|████████████████████████████████████████████████████████████████████████████████| 200/200 [04:23<00:00,  1.32s/it]\n"
     ]
    }
   ],
   "source": [
    "num_iter = 200\n",
    "pert_means = np.zeros((len(pmodel_list),))\n",
    "pert_var = np.zeros((len(pmodel_list),))\n",
    "cont_means = np.zeros((len(pmodel_list),))\n",
    "cont_var = np.zeros((len(pmodel_list),))\n",
    "for i in range(len(pmodel_list)):\n",
    "    current_model = pmodel_list[i]\n",
    "    unpert_model  = omodel_list[i]\n",
    "    temp_pert = np.zeros((num_iter,))\n",
    "    temp_cont = np.zeros((num_iter,))\n",
    "    for j in tqdm(range(num_iter)):\n",
    "        np.random.seed(j)\n",
    "        seeds = np.random.randint(low = 0, high = 999999, size = 5)\n",
    "        np.random.seed(seeds[0])\n",
    "        coin_noise = np.random.randint(low = 0, high = 2, size = x_test.shape[0])\n",
    "        np.random.seed(seeds[1])\n",
    "        coin_contrast = np.random.randint(low = 0, high = 2, size = x_test.shape[0])\n",
    "        np.random.seed(seeds[2])\n",
    "        coin_rotation = np.random.randint(low = 0, high = 2, size = x_test.shape[0])\n",
    "        np.random.seed(seeds[3])\n",
    "        coin_tilt  = np.random.randint(low = 0, high = 2, size = x_test.shape[0])\n",
    "        np.random.seed(seeds[4])\n",
    "        coin_blur  = np.random.randint(low = 0, high = 2, size = x_test.shape[0])\n",
    "    \n",
    "        idx_noise = np.where(coin_noise == 1)[0]\n",
    "        idx_contrast = np.where(coin_contrast == 1)[0]\n",
    "        idx_rotation = np.where(coin_rotation == 1)[0]\n",
    "        idx_tilt  = np.where(coin_tilt == 1)[0]\n",
    "        idx_blur  = np.where(coin_blur == 1)[0]\n",
    "    \n",
    "        temp_test_set_n = perturb_data(samples = x_test, idx_corrupt = idx_noise, variant = 'noise')\n",
    "        temp_test_set_c = perturb_data(samples = temp_test_set_n, idx_corrupt = idx_contrast, variant = 'contrast')\n",
    "        temp_test_set_r = perturb_data(samples = temp_test_set_c, idx_corrupt = idx_rotation, variant = 'rotate')\n",
    "        temp_test_set_t = perturb_data(samples = temp_test_set_r, idx_corrupt = idx_tilt, variant = 'tilt') \n",
    "        temp_test_set   = perturb_data(samples = temp_test_set_t, idx_corrupt = idx_blur, variant = 'blur')\n",
    "        performance = current_model.predict(temp_test_set, verbose = 0).round()\n",
    "        control     = unpert_model.predict(temp_test_set, verbose = 0).round()\n",
    "    \n",
    "        err_test = 1-accuracy_score(y_test, performance)\n",
    "        err_cont = 1-accuracy_score(y_test, control)\n",
    "        \n",
    "        temp_pert[j] = err_test\n",
    "        temp_cont[j] = err_cont\n",
    "        \n",
    "    pert_means[i] = np.mean(temp_pert)\n",
    "    pert_var[i]   = np.std(temp_pert)\n",
    "    cont_means[i] = np.mean(temp_cont)\n",
    "    cont_var[i]   = np.std(temp_cont)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "pert_df = pd.DataFrame(pert_means)\n",
    "pert_df.to_csv('pert_df_xray.csv')\n",
    "cont_df = pd.DataFrame(cont_means)\n",
    "cont_df.to_csv('cont_df_xray.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Error Rate (1-Accuracy)')"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "x = np.arange(10)\n",
    "y1 = pert_means\n",
    "y2 = cont_means\n",
    "width = 0.40\n",
    "fig = plt.figure()\n",
    "ax = plt.subplot(111)\n",
    "# plot data in grouped manner of bar type\n",
    "ax.bar(x-0.2, y1, width, label = 'Perturbed Classifier')\n",
    "ax.bar(x+0.2, y2, width, label = 'Unperturbed Classifier')\n",
    "box = ax.get_position()\n",
    "ax.set_position([box.x0, box.y0, box.width * 0.8, box.height])\n",
    "\n",
    "# Put a legend to the right of the current axis\n",
    "ax.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n",
    "plt.xlabel('Classifier Number')\n",
    "plt.ylabel('Error Rate (1-Accuracy)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Error Rate (1-Accuracy)')"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mean = np.zeros((10,))\n",
    "mean2 = np.zeros((10,))\n",
    "for i in range(10):\n",
    "    df = pd.read_csv('df2_pert'+str(i)+'.csv')\n",
    "    df2 = pd.read_csv('df2_cont'+str(i)+'.csv')\n",
    "    mean[i] = np.mean(df.iloc[:,1].values)\n",
    "    mean2[i] = np.mean(df2.iloc[:,1].values)\n",
    "\n",
    "x = np.arange(10)\n",
    "y1_1 = mean\n",
    "y2_1 = mean2\n",
    "width = 0.40\n",
    "fig = plt.figure()\n",
    "ax = plt.subplot(111)\n",
    "# plot data in grouped manner of bar type\n",
    "ax.bar(x-0.2, y1_1, width, label = 'Perturbed Classifier')\n",
    "ax.bar(x+0.2, y2_1, width, label = 'Unperturbed Classifier')\n",
    "box = ax.get_position()\n",
    "ax.set_position([box.x0, box.y0, box.width * 0.8, box.height])\n",
    "\n",
    "# Put a legend to the right of the current axis\n",
    "ax.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n",
    "plt.xlabel('Classifier Number')\n",
    "plt.ylabel('Error Rate (1-Accuracy)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "perturbs_capital = ['Noise', 'Contrast', 'Rotate', 'Tilt', 'Blur']\n",
    "fig= plt.figure(figsize = (8,4))\n",
    "gs = fig.add_gridspec(1,2)\n",
    "axs = [fig.add_subplot(gs[i]) for i in range(2)]\n",
    "letters = [\"A\",\"B\"]\n",
    "\n",
    "fig.canvas.draw()\n",
    "\n",
    "fig.text(0.5, 0, 'Classifier Number', ha='center', va='center')\n",
    "fig.text(-0.03, 0.5, 'Error Rate (% Incorrectly Classified)', va = 'center', rotation = 'vertical')\n",
    "fig.tight_layout()\n",
    "\n",
    "for ax, label in zip(axs, letters):\n",
    "    bbox = ax.get_tightbbox(fig.canvas.get_renderer())\n",
    "    fig.text(bbox.x0+30, bbox.y1+30, label, fontsize = 12, va = \"top\", ha = \"left\", fontweight = \"bold\", transform = None)\n",
    "\n",
    "axs[0].bar(x-0.2,y1, width, label = 'Perturbed Classifier')\n",
    "axs[0].bar(x+0.2,y2, width, label = 'Unperturbed Classifier')\n",
    "axs[1].bar(x-0.2, y1_1, width, label = 'Perturbed Classifier')\n",
    "axs[1].bar(x+0.2, y2_1, width, label = 'Unperturbed Classifier')\n",
    "\n",
    "\n",
    "#fig.supylabel('Error Rate (% Incorrectly Classified)')\n",
    "#fig.legend(handles, labels, loc=(0.70,0.25))\n",
    "fig.savefig('Followup.png', bbox_inches = 'tight')\n",
    "#fig.suptitle('Comparison of Unperturbed Classifier and 20% Perturbed Classifier Performance by Perturbation')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}