002_Unlearnable.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "fbae74ae-2cd5-4cd7-9a33-9f8ec2117853",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ['CUDA_VISIBLE_DEVICES'] = '0'\n",
    "import sys\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "import time\n",
    "\n",
    "import torch\n",
    "\n",
    "from tqdm.auto import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "403b3846-9d50-4090-bde4-0409bd6df012",
   "metadata": {},
   "outputs": [],
   "source": [
    "from datasets import load_original_dataset, load_deleted_dataset\n",
    "from models import CNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2f070e1c-cde4-44db-8533-1aa4e940cdd4",
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_DIR = 'Datasets/Features/'\n",
    "BATCH_SIZE = 32\n",
    "EPOCHS = 5\n",
    "PERCENTAGES = [1, 10, 20, 30, 40, 50, 60, 70, 80, 90, 99]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "adc832b8-a9ba-4e86-8054-83c68fd4f80d",
   "metadata": {},
   "outputs": [],
   "source": [
    "sys.path.append(os.path.abspath('./libraries/Unlearnable-Examples/'))\n",
    "import toolbox"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "babdf70c-98e0-4d26-b3db-93a14227a649",
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://github.com/HanxunH/Unlearnable-Examples/blob/main/perturbation.py#L45\n",
    "\n",
    "EPSILON = 8\n",
    "NUM_STEPS = 1\n",
    "STEP_SIZE = 0.8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f7170876-46e4-49b0-ac7a-e4cbedeb0726",
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://github.com/HanxunH/Unlearnable-Examples/blob/main/perturbation.py#L51\n",
    "# https://github.com/HanxunH/Unlearnable-Examples/blob/main/perturbation.py#L446\n",
    "\n",
    "noise_generator = toolbox.PerturbationTool(\n",
    "    epsilon=EPSILON / 255,\n",
    "    num_steps=NUM_STEPS,\n",
    "    step_size=STEP_SIZE / 255\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "cc7b25b5-7572-4d3f-a999-78db6c9c4ba5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_random_noise(x):\n",
    "    \n",
    "    # https://github.com/HanxunH/Unlearnable-Examples/blob/main/dataset.py#L441\n",
    "    noise = noise_generator.random_noise(noise_shape=x.shape)\n",
    "    \n",
    "    # https://github.com/HanxunH/Unlearnable-Examples/blob/main/dataset.py#L448\n",
    "    noise = noise.mul(255).clamp_(0, 255)\n",
    "    \n",
    "    # https://github.com/HanxunH/Unlearnable-Examples/blob/main/perturbation.py#L451\n",
    "    x = x + noise.to(x.device)\n",
    "    x = torch.clamp(x, 0, 255)\n",
    "    \n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "c13a2159-60c2-4395-bb31-0fd7028ae9c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fit(model, save_dir, train_set, test_set, forget_set):\n",
    "    \n",
    "    os.makedirs(save_dir, exist_ok=True)\n",
    "    \n",
    "    train_x, train_y = train_set.tensors\n",
    "    forget_x, forget_y = forget_set.tensors\n",
    "    \n",
    "    forget_x = add_random_noise(forget_x)\n",
    "    \n",
    "    train_set = torch.utils.data.TensorDataset(\n",
    "        torch.concat([train_x, forget_x], dim=0), \n",
    "        torch.concat([train_y, forget_y], dim=0), \n",
    "    )\n",
    "    \n",
    "    optimizer = torch.optim.Adam(model.parameters())\n",
    "    error = torch.nn.CrossEntropyLoss()\n",
    "    \n",
    "    train_loader = torch.utils.data.DataLoader(train_set, batch_size = BATCH_SIZE, shuffle = True, drop_last=True)\n",
    "    \n",
    "    train_times = list()\n",
    "    train_accs, test_accs, forget_accs = list(), list(), list()\n",
    "    \n",
    "    for epoch in range(EPOCHS):\n",
    "        \n",
    "        # train\n",
    "        \n",
    "        accs = list()\n",
    "        \n",
    "        train_time = 0\n",
    "        \n",
    "        model.train()\n",
    "        \n",
    "        start_time = time.time()\n",
    "        \n",
    "        for x, y in train_loader:\n",
    "            optimizer.zero_grad()\n",
    "            output = model(x.cuda())\n",
    "            y = y.cuda()\n",
    "            loss = error(output, y)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            \n",
    "            train_time += time.time() - start_time\n",
    "            \n",
    "            predicted = torch.argmax(output.data, dim=-1)\n",
    "            accs.append((predicted == y).float().mean().detach().cpu().numpy())\n",
    "            \n",
    "            start_time = time.time()\n",
    "            \n",
    "        train_times.append(train_time)\n",
    "        train_accs.append(np.mean(accs))\n",
    "        \n",
    "        # test\n",
    "            \n",
    "        model.eval()\n",
    "        with torch.no_grad():\n",
    "            \n",
    "            x, y = test_set.tensors\n",
    "            \n",
    "            accs = list()\n",
    "            \n",
    "            for i in range(0, x.shape[0], BATCH_SIZE):\n",
    "            \n",
    "                output = model(x[i:i+BATCH_SIZE].cuda())\n",
    "\n",
    "                predicted = torch.argmax(output.data, dim=-1)\n",
    "                accs.append((predicted == y[i:i+BATCH_SIZE].cuda()).float().mean().detach().cpu().numpy())\n",
    "            \n",
    "            test_accs.append(np.mean(accs))\n",
    "            \n",
    "\n",
    "            x, y = forget_set.tensors\n",
    "            \n",
    "            accs = list()\n",
    "\n",
    "            for i in range(0, x.shape[0], BATCH_SIZE):\n",
    "\n",
    "                output = model(x[i:i+BATCH_SIZE].cuda())\n",
    "\n",
    "                predicted = torch.argmax(output.data, dim=-1)\n",
    "                accs.append((predicted == y[i:i+BATCH_SIZE].cuda()).float().mean().detach().cpu().numpy())\n",
    "\n",
    "            forget_accs.append(np.mean(accs))\n",
    "        \n",
    "        # save\n",
    "        torch.save(model.state_dict(), os.path.join(save_dir, f'{(epoch+1):03d}.pt'))\n",
    "\n",
    "    return train_times, train_accs, test_accs, forget_accs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "69f93ce0-4df5-41fe-ab4d-aef8c750ad58",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "eea959dd72f749978aa3ca109ff58d64",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/11 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "results = list()\n",
    "\n",
    "for percentage in tqdm(PERCENTAGES):\n",
    "    \n",
    "    model = CNN().cuda()\n",
    "        \n",
    "    model.load_state_dict(torch.load('./weights/init.pt'))\n",
    "    \n",
    "    train_set, test_set, forget_set = load_deleted_dataset(DATA_DIR, percentage)\n",
    "    \n",
    "    train_times, train_accs, test_accs, forget_accs = fit(model, f'weights/Unlearnable/{percentage}', train_set, test_set, forget_set)\n",
    "    \n",
    "    df = pd.DataFrame(zip(train_times, train_accs, test_accs, forget_accs), columns=['train_time', 'train_acc', 'test_acc', 'forget_acc'])\n",
    "    df['epoch'] = range(1, EPOCHS+1)\n",
    "    df['percentage'] = percentage\n",
    "    \n",
    "    results.append(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c1ea734a-a103-47f6-a272-6873307012d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "results = pd.concat(results).set_index(['percentage', 'epoch'])\n",
    "\n",
    "results.to_csv('results/Unlearnable.csv')\n",
    "\n",
    "results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "997af4e9-fcac-4e5d-ba73-8fafc33ef4b6",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "torch",
   "language": "python",
   "name": "torch"
  },
  "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.11.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}