Ours_CIFAR10-ResNet18.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9f5faa18",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import packages \n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import matplotlib.pyplot as plt\n",
    "import torchvision.transforms as transforms\n",
    "import torchvision\n",
    "from torchvision.transforms import Compose, ToTensor, RandomHorizontalFlip, ToPILImage, Resize, Normalize\n",
    "from torchvision.datasets import DatasetFolder\n",
    "from torch.utils.data import random_split\n",
    "import core\n",
    "import numpy as np\n",
    "import copy\n",
    "import cv2\n",
    "from sklearn.metrics.pairwise import cosine_similarity\n",
    "import my_models\n",
    "import random\n",
    "import time\n",
    "from utils import*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8ac8f30e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Loaod a checkpoint\n",
    "model = my_models.ResNet(18)\n",
    "chk = torch.load('checkpoints/best_ckpt_IAD.pth')\n",
    "model.load_state_dict(chk)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "73c9d7aa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "# Load benign and poisoned data\n",
    "\n",
    "datasets_root_dir = './data'\n",
    "\n",
    "dataset = torchvision.datasets.CIFAR10\n",
    "\n",
    "transform_train = Compose([\n",
    "    Resize((32, 32)),\n",
    "    RandomHorizontalFlip(),\n",
    "    ToTensor(),\n",
    "    Normalize((0.485, 0.456, 0.406),\n",
    "                        (0.229, 0.224, 0.225))\n",
    "])\n",
    "transform_test = Compose([\n",
    "    Resize((32, 32)),\n",
    "    ToTensor(),\n",
    "    Normalize((0.485, 0.456, 0.406),\n",
    "                        (0.229, 0.224, 0.225))\n",
    "])\n",
    "\n",
    "trainset = dataset(datasets_root_dir, train=True, transform=transform_train, download=True)\n",
    "testset = dataset(datasets_root_dir, train=False, transform=transform_test, download=True)\n",
    "\n",
    "poisoned_testset = torch.load('./data/poisoned_testsets/poisoned_CIFAR10_IAD.t7')\n",
    "target_class = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c6ed3977",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1d045100310>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD5CAYAAADhukOtAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAe2klEQVR4nO2de4xlV5Xev3Vf9e6qrn5WP9zdfgA2BoynY8zgYbARxIOQjKWRByIhK7EwSgZlSMgfDpECiRKJiQYIkUZEzWCNCR4MwyOYxMkMY8jYHsB22WO33+52d7tf1dXdVX3rfZ9n5Y97LbU9+9tV3VV1y7C/n9Tqqr1qn7Puvmfdc+/+7lrL3B1CiN98cmvtgBCiMyjYhUgEBbsQiaBgFyIRFOxCJIKCXYhEKCxnspndDOBrAPIA/szdvxT7+/6hjb5h6+6gbaUlwNjxLvpMZGL8eEYtzfoCtdUrs/yIxo9ZKPUGx3OFUuR4kdd8fqo4bFEix4ud6mKvj1zuwh9Ao8HPlUXc8MiVYBaxkXuuRY7H1mPq7HEszEwGH/RFB7uZ5QH8KYAPATgO4HEzu9/dn2dzNmzdjbv+bDRoazbrF+xD0zNqqzea1BZ9wvghkTXDE7PIGySPXMIzp+hS4dhzD1NbsdhDbZv3vDM43j+866KOl+UjixWJI7aOrcsmTBc3oVapRNzgE7t7w8+NR14wJ87xa7FS4+tRy/i8QpHP68qFX4jNGnROvRa23fuFj9I5y3kbfx2Ag+5+yN1rAO4DcMsyjieEWEWWE+zbARw77/fj7TEhxJuQVd+gM7M7zWzUzEZny2dW+3RCCMJygv0EgJ3n/b6jPfY63H2fu+919739Q5uWcTohxHJYTrA/DuAKM9tjZiUAHwdw/8q4JYRYaS56N97dG2b2GQB/hZb0dre7PxedZEC+wHYlI3IH2T7PReSMQjGyQx7ZYG7yDVDkLLzD32hEztXkS9zfxW31+Vf4MSPnOzF/Ojg+sGkPnbNxG7cNbee2Zj6yi98M73bnI1LIcD9/XOs291NbV3eR2nK5sCxQnuVPdGRTHbPzc3weuALU19tNbU5cmZyq0jnzxMRiBVimzu7uDwB4YDnHEEJ0Bn2DTohEULALkQgKdiESQcEuRCIo2IVIhGXtxl8oOQO6usOSTNbg8kkzC0sazYiGFsmDQTOS1QTuBkDkpFyOJ2Lknb+eTpyaoLYDzz9JbQN5nsHWNzAcHJ+ZOBYcB4Azx3lCzqXvuIHaBrdeSW3N3EBwvEiSPgCgVOCLv36Y2woFvsb1RlhHy8pceqvVuLzWVeLzdu7Ywo9Z4Xre3Fz4mBmG+PGmasFxy/G10J1diERQsAuRCAp2IRJBwS5EIijYhUiEju7GmwF5csZIlSDkPLzbTXIcWrZIiaNGpNRSrh5JyKEGPqe3h+/CzuR4qaU92y+ltoMvv0htZ079gyxjAMDwcHiXHgB6IqnHr9Z5Lbzf/j0+zwaGguML81wmOTsZ3mEGgIVIckpXd+Se5eELa3KaH3CB7OADQH9vrKYdn1dv8MfWJGW1qrWIpMQuxojQpDu7EImgYBciERTsQiSCgl2IRFCwC5EICnYhEqGj0hsMKJAzRlQ0GGnhw2Q8AKhWuAYRaS4ClLi0km8QP4x7X+rm8olFtMNtEeltaGgDtT3/9GPB8YmJcG06ACjNTHNbxhdr9/Yuass2rguOHzs6Q+cUicQKAPU6X8dqk6+jIZx4k0UuuE3rB6lt3QC/PrKIvBZL1qnMhNe4Guk+UyCBFGsNpju7EImgYBciERTsQiSCgl2IRFCwC5EICnYhEmFZ0puZHQEwA6AJoOHue6N/D4CVyMpykUy0fFhOKMWSnSLHqxMpDwA8IgJ6IWwrEP8AYKo8RW1Hjo9RW3cpUmcOvBXSlVdfExz/1S8fpnNm5yI+HjpMbd+6+25qu/HjfxQc7ylx2XCol1+OzchzNnaWy4O1hbAc1tvFL55dI33U1k3blwEekWDLc9zH8nTYx2LkAs+axBZriUYtS+dGdz+7AscRQqwiehsvRCIsN9gdwF+b2RNmdudKOCSEWB2W+zb+Bnc/YWabAfzUzF5094fO/4P2i8CdALBx2yXLPJ0Q4mJZ1p3d3U+0/z8N4EcArgv8zT533+vue9et52WMhBCry0UHu5n1mdnAaz8D+DCAZ1fKMSHEyrKct/FbAPyonWVTAPAX7v5/F51FlAHPuLTCkpoW6lzqaERaPOUiLXLyiMly4TY9pSKfc/TgEWp79un91HbNZSPU1hVpk9Q/EM7Yuva3uCr6+GO/oLbjJ8ep7dBffpvazp0Lt1C69ZP/is6ZK+ygtul5/lxXGjxbLiP3s0Yk47CS8RZPEcUOAM966+FKKkY2h+XI7kjG5OR0NTiej0iUFx3s7n4IwLsudr4QorNIehMiERTsQiSCgl2IRFCwC5EICnYhEqGzBSfBe7pF1DA46aUWK1LpkQPGunXFFqRAspD6u7nM11fkXhadSysHDxyitrdcziUqs7CPQ+t5r7frf/t3qO2Rh39JbWdPHqW2v3/w+8Hx+Xme/fX7n/q31Na7YRe1ZTUulYFkJFYiU8bOLVCbDXZTW09EEm1G2rZVif/5PL92htaFtbx8JANTd3YhEkHBLkQiKNiFSAQFuxCJoGAXIhE63v6JbBbDIjXjWPZMbEaMXGRmozZLbdPzYdt8mSdAjB15idqu2MWTXQ68/CK1Pf/Sy/yYl4ZrBhRyPFlkYB1vd/TeG95HbY8/zLeYJ8ZPBcef/sUDdM5CpC/Xbf/0X1Pbxt1XUts8SYiqRRKlKhW+Cz7R5D4W83yN5yp1aqs3w7vxhUgrslKpN2yISE26swuRCAp2IRJBwS5EIijYhUgEBbsQiaBgFyIROp8IQyS2XC6SKUBekjwioeU8VouL27KMy2iohG2xVk293Tw5opLn2Ri7dm6ltgOHeJLMoSPh5JQ9u7bROc0aT/zo6+GJH+95343U9stf/F1wvD52kM45/ORfUdu98zPUdus/+5fU9rZ/9P7g+Fydr313kT/mSIcnVGoRMdj4MVm+SywmKo2wlOceiQlqEUL8RqFgFyIRFOxCJIKCXYhEULALkQgKdiESYVHpzczuBvBRAKfd/er22DCA7wLYDeAIgNvc/dzixwIKTHqLeMJq0MVSfDxiK0Re4vr6eAbYpo3rg+PNGj/g1e/h8tT+iOSVVV6gtssjstyLR8eC44fJOADs2cofc6MWbjMEAP2D66jtdz7wu8Hxn/1NuC0UAEyePU1tR198nNq+/V//I7X9wac/Fxy/9qYP0zn5ri5qm5nj0lYWkVItIukaaV/VzLj0lhG5LqK8LenO/ucAbn7D2F0AHnT3KwA82P5dCPEmZtFgb/dbn3zD8C0A7mn/fA+Aj62sW0KIleZiP7NvcffX3heeQqujqxDiTcyyN+i89f08+knBzO40s1EzG52eOLPc0wkhLpKLDfZxMxsBgPb/dGfF3fe5+15337tuw6aLPJ0QYrlcbLDfD+D29s+3A/jxyrgjhFgtliK9fQfABwBsNLPjAL4A4EsAvmdmdwB4FcBtSzqbO7IsLE9kEZmBS2+8wF9cluNkWSwjLuxjpcZ9LwzydzO/9f4PUduv/g9XMpuneNuly7dvDo4fOcrnHKxMU9slO7ZTW73Giy/29oblq9+9kT/mR/7uYWqbPBUuYAkA0yd5FuB3/vRPguMLc1N0zg3/+GPUljX7qK1a59ejR0LNo9cxmcMKtLL+alhCsLv7J4jpg0txSgjx5kDfoBMiERTsQiSCgl2IRFCwC5EICnYhEqGjBSfNgAJJOctYGg8AJ6ZI7T+aFQQAiPSVq9V45hKoPMiLStYjr6f9w/xbxv3bL6W2s2d4BttwTzi7qrB9mM7Zf5jLWrXDr1Lb5Xt2UVuxGF6TgYF+OuemD3KB529/9nNqO3P0GLVNnQ4XuPz2f/vPdM7Zkyep7cOf+BfU1lXaQG0LDV6UNCuEnzOPyNHFQliuiyhvurMLkQoKdiESQcEuRCIo2IVIBAW7EImgYBciETosvRlKJVZc78KPF5PX4oeLZbZFMpCIFNLM+GtmFpHlqg1ecLISyYTq38Qz0WqnwxlgWSTXb8cIlwDHTnAZ6mgkk27XrrAsxyQ5AOju66G2G2/ihTsff+QX1HZmnMhyxjP2fvaT+6htNtIj7ubb7qC24SGe/ThXCRd1mZ89S+e4keezyQuE6s4uRCIo2IVIBAW7EImgYBciERTsQiRCR3fjYUC+GN4J93rkG/xs9zzHEwUssuMee43LRWrQgey6x87kkZfTbJa3BOru4hNtyw5q6xkZCY4/9/hD/FxVvut7ybZwTTsAOHmKlwY/fvx4cHz37t10TqMeWY/eXmrb+573UtsLz4Zr4XXFyr4VeZ25kwd+RW1/+0O+E37ZpW+ltjNjYQXl3FmudtTmZ4Lj0xM8SUp3diESQcEuRCIo2IVIBAW7EImgYBciERTsQiTCUto/3Q3gowBOu/vV7bEvAvgUgNe0l8+7+wOLHateq+H4q+GaZps280SB7p6w7NKM9HGKtXiyWAINSzAAkOXCr40eOVtXRJebqc1RW39fN7XVI+2mdr/96uD44OAAnfPYT/6C2jzPL5Ht23gCzYljJ4LjhyN11XZdxmvaZc7XuNjLE2g2jWwLjp87O07nbNywjvsxw9tGHXzy/1Hb2HOPUVuzHm6/5VXeAmx+ajI4ziQ5YGl39j8HcHNg/Kvufk3736KBLoRYWxYNdnd/CED4ZUQI8WvDcj6zf8bM9pvZ3Wa2fsU8EkKsChcb7F8HcBmAawCMAfgy+0Mzu9PMRs1sdOac3iAIsVZcVLC7+7i7N909A/ANANdF/nafu+91970D63mjAiHE6nJRwW5m52db3Arg2ZVxRwixWixFevsOgA8A2GhmxwF8AcAHzOwatBSuIwA+vZST1Ws1jB8L1wQr5blG1bsjnOVVb/J6YF281Bksq1NbVuATMwvbsogU1lPk6VXlOf6xZnaWSzyFSIuqnlL49buc4091tcZ9LA1y22CBtzTC5rAsd+I0z8o6eoxfAzsvuYTaBoZ4llqDSH2zVX4NbIjIjV15/piH+7m82dMdzr4DgEYtrAU3wKXZfG/Yj3yOr+Giwe7unwgMf3OxeUKINxf6Bp0QiaBgFyIRFOxCJIKCXYhEULALkQgdLTjpWYbG/HzQduJQuOgeAPQT2SJX5JlQNZJJBABnTp2itslpnjU0VQ63a6pM8jmb1nM5pmRcsivMz1JbVuHySrEebms0FylEOH6KtEgCsK7Ovwi1vm+Q2vr7wnLYVpKFBgDHz5ymtsEh3q5p8waeIThVDstXWaSw6PwCb8s1Fbk+crFsyohMXKuEr9XJU7wQaNYIH6/R4DGhO7sQiaBgFyIRFOxCJIKCXYhEULALkQgKdiESoaPSW9aoY+ZMWAKqVLm00pwpB8d7I0UZz5UnqK1Y4A/78dFRajt0iEhUTS7jxHqK9ZK+dwCASOHLDT28MJAh3G9sfprLjTOTvGfb2Dhfx7fs2kNtg0PhIqFDg7yYI4r8+ezr4fMaPIENs3Ph/nG5HM9uzJHCoovZEJHX5ivcdmIsLLGVShvonP6hoeC4TfBsc93ZhUgEBbsQiaBgFyIRFOxCJIKCXYhE6OhufL1axakjB4O28ZM8UeNEb3hnF5Ed1abxWmFvvSrcIgkA6tM8m2F2Ipycsm7DRjpn4hxPZng1sgteqfBEmF3r+S7t2KkDwfFGlSdwNCJqwrohfq7JKf7YhgY3B8e9yu8vw4P8XBs3h48HAJW5cHIVAExNhWv5DQ310zmDgzzBJ6vzXfUsUteuEdmpbyJ8HeciqkujSOruWURJoBYhxG8UCnYhEkHBLkQiKNiFSAQFuxCJoGAXIhGW0v5pJ4BvAdiCVrunfe7+NTMbBvBdALvRagF1m7ufix2rWlnA4ZeeD9rqC+EEDgAAaauT7+aJE/ViD7UdPsrr3fX1R9r7DIZr4c2UeZJJNlumtt5cOEkDACzPpZoKqVnWcib8lPaU+Hps3soTWkrDPAFlbuIItZ0dD9u2beZtnLISkVgBRHKXUKlwWXFhIWwrRTpXTU/z9S0TKQ8AavM8masAXm9wR184W6oBLr96PVwnz5xfN0u5szcAfM7drwJwPYA/NLOrANwF4EF3vwLAg+3fhRBvUhYNdncfc/cn2z/PAHgBwHYAtwC4p/1n9wD42Cr5KIRYAS7oM7uZ7QbwbgCPAtji7q997e0UWm/zhRBvUpYc7GbWD+AHAD7r7q/7UOPujtbn+dC8O81s1MxG67XI53IhxKqypGA3syJagX6vu/+wPTxuZiNt+wiAYIV/d9/n7nvdfW+xxHtUCyFWl0WD3cwMrX7sL7j7V84z3Q/g9vbPtwP48cq7J4RYKZaS9fY+AJ8E8IyZPdUe+zyALwH4npndAeBVALctdiDPmqjPEJkk4zXXps6GJY3L3vkOOqd3E89Em5riUk13iWeAbVwfloZqs7xOm+e45FKp8Wyt3ojWlMvz1+jyZFg28nWRYngZl4xqp7n8M5BxpXXAw35UTvLHnN/GH1dlhme9lc/y9V+YC7d/6iEtxQBgboY/5kadP5/dkeesOs0lu1w97GORyGsAkCP1C2PS26LB7u6PAGAR8MHF5gsh3hzoG3RCJIKCXYhEULALkQgKdiESQcEuRCJ0tOBks9HEuUkikxiXvLaQYoOXX3EFnfPS4cPUNlfmklFhgBTyAzBL5JO5WS7VLESKIdYWeIHCDcPhTD8A6Oni2X6NRlgaGhjg2Wsbh4eprYiwLAQAtTO8YCYaROrr4s9zLpIZVj7NMwsnT49Tm9fCmYWxCz9HxScgn4/MrPNviGZ1nuEIIucVc7z4ab1JbBEJW3d2IRJBwS5EIijYhUgEBbsQiaBgFyIRFOxCJEJHpbdiVwk7L9sdtC1UeObVyPZtwfGDB16mc85NTFJbPlxnAwAwXubzjh4KF6osR6S8Ro1nIaHJpaZNw7zPVz7PpaGRreGCQddffz2dUyrxy+DEiZeo7ZWTvIhlXynct21wC++jluvhBSdLBf6YF+Z4Rll/b/ixNSIZZeVz/PnMPHJ/rPNruFrhEuwAkRxzFull6OH14Fe27uxCJIOCXYhEULALkQgKdiESQcEuRCJ0dDd+eMMw/uCfhEvVVat8J3N09Ing+E/+5/+mc9YP8xp0hchL3MQZnlQxNxeuq5Yv8PpuBePJDKUuvts6NXmW2mbneO+ikZGR4Pj+Z56icxoNnqQxfvYktRVzPGlovh6+tE6N8Z3z+vxRahvq7efnWojUtSuGn+zZmTKdM0vq1gGAG3+uSwW+F94dSVCp5cL18KqRnf86MXkkiUd3diESQcEuRCIo2IVIBAW7EImgYBciERTsQiTCotKbme0E8C20WjI7gH3u/jUz+yKATwF4rRDZ5939geixALAcju4uLiflLCxblHp5C5+pGS7xeJPXfmtm3FYkUlkp0vanUeWyVjPiRxZp8dRV4DXoZufCra2OH3uVzrGI/6UuLq/187J2qDbDMuXCDE8Mqi3wtZqZ4lJkTMKsEymqGckYqc5w6c1K/DpFV6TFFlfEUHHSVixyLRaKYUm3ETnRUnT2BoDPufuTZjYA4Akz+2nb9lV3/5MlHEMIscYspdfbGICx9s8zZvYCgO2r7ZgQYmW5oM/sZrYbwLsBPNoe+oyZ7Tezu82MJ2ALIdacJQe7mfUD+AGAz7r7NICvA7gMwDVo3fm/TObdaWajZjY6Mx3+HCeEWH2WFOxmVkQr0O919x8CgLuPu3vT3TMA3wBwXWiuu+9z973uvndgXWRHRwixqiwa7GZmAL4J4AV3/8p54+dnXNwK4NmVd08IsVIsZTf+fQA+CeAZM3uqPfZ5AJ8ws2vQkuOOAPj0YgfyLENjIZzdlmU8O2znlnAm17pIq6bJMv/IkIu0mvLY6x9RQpg0CAAN0n4IADZt2kRtC5HMq/lYVhZZx1qk/VBXjl8GzUgJvcx5u6OtW8Ptqw6/xLMKLccltKzIn7Nm7JZVCsuzuRqXtVpvVsm5IvOGR8J19wBgO8lGBICnXwlfqzM1/jyP9JPHleMtuZayG/8IwiphVFMXQry50DfohEgEBbsQiaBgFyIRFOxCJIKCXYhE6GjByazZxALJRms0uMbT3x3ONOqPtC0qN7ksdNWVb6O2WkRayZPikc0abyX0zDP86webt3DpbWqKZ7ZVa7xtVJOsoznPyPI6l5rm67wV0tDGcFsuAMiTYpRzVS4nocDbSaHB/bdYkUWiimYRec0iGYf93fx5iSW9vfXyndQ2NnksOL5wil/De7aEZb7Jo4fpHN3ZhUgEBbsQiaBgFyIRFOxCJIKCXYhEULALkQgdld6azQbK5XBWTlTyyoVfkzZvGKRzzkZ6ts2Uy9R2rsylptmZcHZStc4lkga4HvP8gYPUVsxHChsazw7rIgURu/v4WjUzLuXV5vljqyxwuTRnYYlqaD2XG8tTPFOxtsDlzVIvl+yMyIqNGve9dyCcsQcA73r7O6itvy/SB45k3wFANymYac4lxW1btgbHnynya0N3diESQcEuRCIo2IVIBAW7EImgYBciERTsQiRCZ7PePEOVZIhVKuFClACQz4cljbe//Uo6Z8PGjdQ2OTlJbf2R/nHlubAkMz07T+csLHDpqh7JNvNIM7JGxFavhte3WOBSXq3K135+lkteZ8Z5/7Xu7v7guEUuuWakL14tUmSzQaRZgF87uSJfj0iNTRx8NZyhBgA9XdyPE+NcCi5PhyW2epNLos+9eCA4HrvedGcXIhEU7EIkgoJdiERQsAuRCAp2IRJh0d14M+sG8BCArvbff9/dv2BmewDcB2ADgCcAfNLd+XYqWm1lzMK7o5GSYMgQ3n3u6uLuv+0tV1BbKZIsUG/whJxaM+zkbGQH9Mjho9Q2N8d3umuRRI0pkpADALMzM8HxZmRn14wnflQqvBnn/Dz3/xiphdYkawgAWY2rAh7pQ1Wt8fXvGxgKjnf1R+5zkd39ukds8/zaqda5/7NVckyiJABcAWpG2qgt5c5eBXCTu78LrfbMN5vZ9QD+GMBX3f1yAOcA3LGEYwkh1ohFg91bzLZ/Lbb/OYCbAHy/PX4PgI+thoNCiJVhqf3Z8+0OrqcB/BTAKwDK7v7ae5PjALaviodCiBVhScHu7k13vwbADgDXAeCF19+Amd1pZqNmNjoX+YwnhFhdLmg33t3LAH4O4L0AhszstR2yHQBOkDn73H2vu+/ti1QUEUKsLosGu5ltMrOh9s89AD4E4AW0gv732392O4Afr5KPQogVYCmJMCMA7rGWZpYD8D13/19m9jyA+8zsPwH4ewDfXOxA1WodRw6FEwlikldG5Jpcntfo6uqK1HCLtAuKyXKsLZAbP966Xu5HX8THQiRxZWKCP23VwXDbpe5I26Lubv6Oay6SnFKeCrfyAoAzZ8K1Bqem+ZzaApeNCgO91FbqCyfdAECuGH7cFqm7F1HekAdPlGrW+fPSiLQj6+oJr38plvDUCCcGufM5iwa7u+8H8O7A+CG0Pr8LIX4N0DfohEgEBbsQiaBgFyIRFOxCJIKCXYhEsNhW/YqfzOwMgFfbv24EwIuYdQ758Xrkx+v5dfNjl7sHe2x1NNhfd2KzUXffuyYnlx/yI0E/9DZeiERQsAuRCGsZ7PvW8NznIz9ej/x4Pb8xfqzZZ3YhRGfR23ghEmFNgt3Mbjazl8zsoJndtRY+tP04YmbPmNlTZjbawfPebWanzezZ88aGzeynZnag/f/6NfLji2Z2or0mT5nZRzrgx04z+7mZPW9mz5nZH7XHO7omET86uiZm1m1mj5nZ020//kN7fI+ZPdqOm++aWSy18x/i7h39ByCPVlmrSwGUADwN4KpO+9H25QiAjWtw3vcDuBbAs+eN/RcAd7V/vgvAH6+RH18E8G86vB4jAK5t/zwA4GUAV3V6TSJ+dHRN0MrB7m//XATwKIDrAXwPwMfb4/8dwD+/kOOuxZ39OgAH3f2Qt0pP3wfgljXwY81w94cAvLG75C1oFe4EOlTAk/jRcdx9zN2fbP88g1ZxlO3o8JpE/Ogo3mLFi7yuRbBvB3B+BYu1LFbpAP7azJ4wszvXyIfX2OLuY+2fTwHYsoa+fMbM9rff5q/6x4nzMbPdaNVPeBRruCZv8APo8JqsRpHX1DfobnD3awH8HoA/NLP3r7VDQOuVHSCdMVafrwO4DK0eAWMAvtypE5tZP4AfAPisu7+uE0Yn1yTgR8fXxJdR5JWxFsF+AsDO836nxSpXG3c/0f7/NIAfYW0r74yb2QgAtP8/vRZOuPt4+0LLAHwDHVoTMyuiFWD3uvsP28MdX5OQH2u1Ju1zl3GBRV4ZaxHsjwO4or2zWALwcQD3d9oJM+uzdt8jM+sD8GEAz8ZnrSr3o1W4E1jDAp6vBVebW9GBNTEzQ6uG4Qvu/pXzTB1dE+ZHp9dk1Yq8dmqH8Q27jR9Ba6fzFQD/bo18uBQtJeBpAM910g8A30Hr7WAdrc9ed6DVM+9BAAcA/A2A4TXy438AeAbAfrSCbaQDftyA1lv0/QCeav/7SKfXJOJHR9cEwDvRKuK6H60Xln9/3jX7GICDAP4SQNeFHFffoBMiEVLfoBMiGRTsQiSCgl2IRFCwC5EICnYhEkHBLkQiKNiFSAQFuxCJ8P8BpBGSCeSfvzoAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Show an example of benign data\n",
    "\n",
    "inv = transforms.Compose([transforms.Normalize(mean = [0., 0., 0. ],\n",
    "                                                     std = [1/0.229, 1/0.224, 1/0.225]),\n",
    "                                transforms.Normalize(mean = [-0.485, -0.456, -0.406 ],\n",
    "                                                     std = [1., 1., 1. ]),\n",
    "                               ])\n",
    "\n",
    "img_idx = 50\n",
    "clean_image, _ = testset[img_idx]\n",
    "clean_image = inv(clean_image)\n",
    "plt.imshow(clean_image.permute(1, 2, 0).numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1ef49874",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1d0451e6700>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Show an example of poisoned data\n",
    "\n",
    "poisoned_image, _ = poisoned_testset[img_idx]\n",
    "poisoned_image = inv(poisoned_image)\n",
    "plt.imshow(poisoned_image.permute(1, 2, 0).numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "74285d0a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sample 10% of the benign test data and extract their intermediate features\n",
    "t = 0\n",
    "current_time = time.time()\n",
    "num_classes = 10\n",
    "p = 0.1\n",
    "n = len(testset)\n",
    "m = int(n * p)\n",
    "sampleset, _ = random_split(testset, [m, n - m])\n",
    "\n",
    "sample_ftrs_dict, sample_labels, sample_preds = \\\n",
    "                    get_features(model, sampleset)\n",
    "\n",
    "t+= time.time() - current_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "65670308",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of layers: 10\n",
      "Class:0, Layer of maximum difference:9\n",
      "Class:1, Layer of maximum difference:8\n",
      "Class:2, Layer of maximum difference:9\n",
      "Class:3, Layer of maximum difference:9\n",
      "Class:4, Layer of maximum difference:9\n",
      "Class:5, Layer of maximum difference:9\n",
      "Class:6, Layer of maximum difference:8\n",
      "Class:7, Layer of maximum difference:9\n",
      "Class:8, Layer of maximum difference:9\n",
      "Class:9, Layer of maximum difference:8\n"
     ]
    }
   ],
   "source": [
    "# Identify the layer the layer of interest (LOI) for each class\n",
    "current_time = time.time()\n",
    "L = len(sample_ftrs_dict.keys())\n",
    "print('Number of layers:', L)\n",
    "canditae_layers = []\n",
    "for c in range(num_classes):\n",
    "    sim_sample = None\n",
    "    for l in range(L):\n",
    "        idxs = np.where(sample_preds == c)[0]\n",
    "        data = sample_ftrs_dict[l][idxs]\n",
    "        centroid = data.mean(axis = 0).reshape(1, -1)\n",
    "        cs = cosine_similarity(data, centroid)\n",
    "        if sim_sample is None:\n",
    "            sim_sample = cs\n",
    "        else:\n",
    "            sim_sample = np.hstack((sim_sample, cs))\n",
    "    mean_sim = sim_sample.mean(0)\n",
    "    h = int(L/2)\n",
    "    diff_sim = mean_sim[1:L] - mean_sim[0:L-1]\n",
    "    max_diff_l = h+diff_sim[h:].argmax()+1\n",
    "    print('Class:{}, Layer of maximum difference:{}'.format(c, max_diff_l+1))\n",
    "    # Add the three identified layers for each class\n",
    "    canditae_layers.append(np.arange(max_diff_l - 2, max_diff_l+1))\n",
    "t+= time.time() - current_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c265bf54",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exatrct the features of benign test set\n",
    "test_ftrs_dict, test_labels, test_preds = \\\n",
    "                    get_features(model, testset)\n",
    "\n",
    "# Extract the features of poisoned test set\n",
    "poisoned_ftrs_dict, poisoned_labels, poisoned_preds = \\\n",
    "                    get_features(model, poisoned_testset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "253b8e9c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tau:0.5\n",
      "TPR:100.00, FPR:33.73\n",
      "TPR-STD:0.00, FPR-STD:0.94\n",
      "---------------------------\n",
      "Tau:1\n",
      "TPR:99.99, FPR:19.41\n",
      "TPR-STD:0.01, FPR-STD:0.88\n",
      "---------------------------\n",
      "Tau:1.5\n",
      "TPR:99.87, FPR:9.00\n",
      "TPR-STD:0.04, FPR-STD:0.59\n",
      "---------------------------\n",
      "Tau:2\n",
      "TPR:99.74, FPR:3.42\n",
      "TPR-STD:0.10, FPR-STD:0.51\n",
      "---------------------------\n",
      "Tau:2.5\n",
      "TPR:99.46, FPR:1.22\n",
      "TPR-STD:0.18, FPR-STD:0.32\n",
      "---------------------------\n",
      "Tau:3\n",
      "TPR:95.28, FPR:0.24\n",
      "TPR-STD:1.79, FPR-STD:0.08\n",
      "---------------------------\n",
      "Average runtime:3.00\n"
     ]
    }
   ],
   "source": [
    "''' Approximate the distribution of benign samples in the identified layers for each class, \n",
    "        and filter out potential poisoned samples'''\n",
    "current_time = time.time()\n",
    "\n",
    "# Use different thresholds\n",
    "taus = [0.5, 1, 1.5, 2, 2.5, 3]\n",
    "\n",
    "# Use recommended threshold = 2.5\n",
    "# taus = [2.5]\n",
    "gt, pred = None, None\n",
    "num_exper = 5\n",
    "for tau in taus:\n",
    "    tprs, fprs = [], []\n",
    "    print('Tau:{}'.format(tau))\n",
    "    for i in range(num_exper):\n",
    "        gt, pred = None, None\n",
    "        for c in range(num_classes):\n",
    "#             if c != target_class:continue\n",
    "            idxs = np.where(test_labels == c)[0]\n",
    "            k = len(idxs)\n",
    "        \n",
    "            # Sample 10% from the benign features of the target class\n",
    "            idxs = np.random.choice(idxs, int(k*0.1), replace = False)\n",
    "            idxs_samples = idxs\n",
    "\n",
    "            sim_sample = None\n",
    "            sim_test = None\n",
    "            sim_poisoned = None\n",
    "            \n",
    "            # Select samples classified into the potential target class by the attacked model\n",
    "            idxs_test = np.where(test_preds == c)[0]\n",
    "            idxs_poisoned = np.where((poisoned_preds == c) & (test_labels != c))[0]\n",
    "\n",
    "            # Approximate the summed cosine similarities (sample-wise) for each class.\n",
    "            for l in canditae_layers[c]:\n",
    "                sample_data = test_ftrs_dict[l][idxs_samples]\n",
    "                test_data = test_ftrs_dict[l][idxs_test]\n",
    "                poisoned_data = poisoned_ftrs_dict[l][idxs_poisoned]\n",
    "                layer_centroid = np.mean(sample_data, axis = 0).reshape(1, -1)\n",
    "                cs_sample = cosine_similarity(sample_data, layer_centroid)*diff_sim[l]\n",
    "                cs_test = cosine_similarity(test_data, layer_centroid)*diff_sim[l]\n",
    "                f = 0\n",
    "                try:\n",
    "                    cs_poisoned = cosine_similarity(poisoned_data, layer_centroid)*diff_sim[l]\n",
    "                except:\n",
    "                    cs_poisoned = 0\n",
    "                    f = 1\n",
    "\n",
    "                if sim_sample is None:\n",
    "                    sim_sample = cs_sample\n",
    "                    sim_test = cs_test\n",
    "                    sim_poisoned = cs_poisoned\n",
    "                else:\n",
    "                    sim_sample+= cs_sample\n",
    "                    sim_test+= cs_test\n",
    "                    sim_poisoned+= cs_poisoned\n",
    "            \n",
    "            # Identity potential poisoned samples\n",
    "            if gt is None:\n",
    "                gt = np.array([0]*len(test_data)).reshape(-1, 1) \n",
    "            else:\n",
    "                gt= np.concatenate((gt, np.array([0]*len(test_data)).reshape(-1, 1)))\n",
    "            u, s = sim_sample.mean(),  sim_sample.std()\n",
    "            threshold = u - tau*s\n",
    "            pred_test = (sim_test<threshold) + 0\n",
    "            if pred is None:\n",
    "                pred = pred_test\n",
    "            else:\n",
    "                pred= np.concatenate((pred, pred_test))\n",
    "\n",
    "            if c == target_class:\n",
    "                gt= np.concatenate((gt, np.array([1]*len(poisoned_data)).reshape(-1, 1) ))\n",
    "                pred_poisoned = (sim_poisoned<threshold) + 0\n",
    "                pred= np.concatenate((pred, pred_poisoned))\n",
    "\n",
    "        tp = ((gt + pred) == 2).sum()\n",
    "        tn = ((gt + pred) == 0).sum()\n",
    "        fp = ((pred - gt) == 1).sum()\n",
    "        fn = ((gt - pred) == 1).sum()\n",
    "        tpr = tp/(tp + fn)*100\n",
    "        fpr = fp/(fp + tn)*100\n",
    "        tprs.append(tpr)\n",
    "        fprs.append(fpr)     \n",
    "    \n",
    "    print('TPR:{:0.2f}, FPR:{:0.2f}'.format(np.mean(tprs), np.mean(fprs)))   \n",
    "    print('TPR-STD:{:0.2f}, FPR-STD:{:0.2f}'.format(np.std(tprs), np.std(fprs)))\n",
    "    print('---------------------------')\n",
    "print('Average runtime:{:0.2f}'.format((time.time() - current_time)/(num_exper*len(taus))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dead964e",
   "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.8.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}