BadT_experiments.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_770922/2672079530.py:24: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from tqdm.autonotebook import tqdm\n"
     ]
    }
   ],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "%matplotlib inline\n",
    "import os\n",
    "os.environ['CUDA_DEVICE_ORDER']='PCI_BUS_ID'\n",
    "os.environ['CUDA_VISIBLE_DEVICES']='1'\n",
    "import variational\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from matplotlib.ticker import FuncFormatter\n",
    "from itertools import cycle\n",
    "import os\n",
    "import time\n",
    "import math\n",
    "import pandas as pd\n",
    "from collections import OrderedDict\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "    \n",
    "import copy\n",
    "import torch.nn as nn\n",
    "from torch.autograd import Variable\n",
    "from typing import List\n",
    "import itertools\n",
    "from tqdm.autonotebook import tqdm\n",
    "from models import *\n",
    "import models\n",
    "from logger import *\n",
    "import wandb\n",
    "import utils\n",
    "\n",
    "from thirdparty.repdistiller.helper.util import adjust_learning_rate as sgda_adjust_learning_rate\n",
    "from thirdparty.repdistiller.distiller_zoo import DistillKL, HintLoss, Attention, Similarity, Correlation, VIDLoss, RKDLoss\n",
    "from thirdparty.repdistiller.distiller_zoo import PKT, ABLoss, FactorTransfer, KDSVD, FSP, NSTLoss\n",
    "\n",
    "from thirdparty.repdistiller.helper.loops import train_distill, train_distill_hide, train_distill_linear, train_vanilla, train_negrad, train_bcu, train_bad_teacher, train_bcu_distill, validate\n",
    "from thirdparty.repdistiller.helper.pretrain import init"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pdb():\n",
    "    import pdb\n",
    "    pdb.set_trace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parameter_count(model):\n",
    "    count=0\n",
    "    for p in model.parameters():\n",
    "        count+=np.prod(np.array(list(p.shape)))\n",
    "    print(f'Total Number of Parameters: {count}')\n",
    "    return count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def vectorize_params(model):\n",
    "    param = []\n",
    "    for p in model.parameters():\n",
    "        param.append(p.data.view(-1).cpu().numpy())\n",
    "    return np.concatenate(param)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_param_shape(model):\n",
    "    for k,p in model.named_parameters():\n",
    "        print(k,p.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pre-training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#%run main.py --dataset cifar100 --dataroot=data/cifar-100-python --model resnet --filteers 0.4 --lr 0.1 --lossfn ce --num-classes 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def activations_predictions(model,dataloader,name):\n",
    "    criterion = torch.nn.CrossEntropyLoss()\n",
    "    metrics,activations,predictions=get_metrics(model,dataloader,criterion,128,True)\n",
    "    print(f\"{name} -> Loss:{np.round(metrics['loss'],3)}, Error:{metrics['error']}\")\n",
    "    log_dict[f\"{name}_loss\"]=metrics['loss']\n",
    "    log_dict[f\"{name}_error\"]=metrics['error']\n",
    "\n",
    "    return activations,predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predictions_distance(l1,l2,name):\n",
    "    dist = np.sum(np.abs(l1-l2))\n",
    "    print(f\"Predictions Distance {name} -> {dist}\")\n",
    "    log_dict[f\"{name}_predictions\"]=dist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def activations_distance(a1,a2,name):\n",
    "    dist = np.linalg.norm(a1-a2,ord=1,axis=1).mean()\n",
    "    print(f\"Activations Distance {name} -> {dist}\")\n",
    "    log_dict[f\"{name}_activations\"]=dist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Membership Inference Attack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"https://github.com/google-research/google-research/blob/master/learn_to_forget/membership_inference.py\"\"\"\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.model_selection import StratifiedShuffleSplit\n",
    "from sklearn.metrics import confusion_matrix\n",
    "import random\n",
    "\n",
    "def cm_score(estimator, X, y):\n",
    "    y_pred = estimator.predict(X)\n",
    "    cnf_matrix = confusion_matrix(y, y_pred)\n",
    "    \n",
    "    FP = cnf_matrix[0][1] \n",
    "    FN = cnf_matrix[1][0] \n",
    "    TP = cnf_matrix[0][0] \n",
    "    TN = cnf_matrix[1][1]\n",
    "\n",
    "\n",
    "    # Sensitivity, hit rate, recall, or true positive rate\n",
    "    TPR = TP/(TP+FN)\n",
    "    # Specificity or true negative rate\n",
    "    TNR = TN/(TN+FP) \n",
    "    # Precision or positive predictive value\n",
    "    PPV = TP/(TP+FP)\n",
    "    # Negative predictive value\n",
    "    NPV = TN/(TN+FN)\n",
    "    # Fall out or false positive rate\n",
    "    FPR = FP/(FP+TN)\n",
    "    # False negative rate\n",
    "    FNR = FN/(TP+FN)\n",
    "    # False discovery rate\n",
    "    FDR = FP/(TP+FP)\n",
    "\n",
    "    # Overall accuracy\n",
    "    ACC = (TP+TN)/(TP+FP+FN+TN)\n",
    "    print (f\"FPR:{FPR:.2f}, FNR:{FNR:.2f}, FP{FP:.2f}, TN{TN:.2f}, TP{TP:.2f}, FN{FN:.2f}\")\n",
    "    return ACC\n",
    "\n",
    "\n",
    "def evaluate_attack_model(sample_loss,\n",
    "                          members,\n",
    "                          n_splits = 5,\n",
    "                          random_state = None):\n",
    "  \"\"\"Computes the cross-validation score of a membership inference attack.\n",
    "  Args:\n",
    "    sample_loss : array_like of shape (n,).\n",
    "      objective function evaluated on n samples.\n",
    "    members : array_like of shape (n,),\n",
    "      whether a sample was used for training.\n",
    "    n_splits: int\n",
    "      number of splits to use in the cross-validation.\n",
    "    random_state: int, RandomState instance or None, default=None\n",
    "      random state to use in cross-validation splitting.\n",
    "  Returns:\n",
    "    score : array_like of size (n_splits,)\n",
    "  \"\"\"\n",
    "\n",
    "  unique_members = np.unique(members)\n",
    "  if not np.all(unique_members == np.array([0, 1])):\n",
    "    raise ValueError(\"members should only have 0 and 1s\")\n",
    "\n",
    "  attack_model = LogisticRegression()\n",
    "  cv = StratifiedShuffleSplit(\n",
    "      n_splits=n_splits, random_state=random_state)\n",
    "  return cross_val_score(attack_model, sample_loss, members, cv=cv, scoring=cm_score)\n",
    "\n",
    "def membership_inference_attack(model, t_loader, f_loader, seed):\n",
    "    import matplotlib.pyplot as plt\n",
    "    import seaborn as sns\n",
    "    \n",
    "\n",
    "    fgt_cls = list(np.unique(f_loader.dataset.targets))\n",
    "    indices = [i in fgt_cls for i in t_loader.dataset.targets]\n",
    "    t_loader.dataset.data = t_loader.dataset.data[indices]\n",
    "    t_loader.dataset.targets = t_loader.dataset.targets[indices]\n",
    "\n",
    "    \n",
    "    cr = nn.CrossEntropyLoss(reduction='none')\n",
    "    test_losses = []\n",
    "    forget_losses = []\n",
    "    model.eval()\n",
    "    mult = 0.5 if args.lossfn=='mse' else 1\n",
    "    dataloader = torch.utils.data.DataLoader(t_loader.dataset, batch_size=128, shuffle=False)\n",
    "    for batch_idx, (data, target) in enumerate(dataloader):\n",
    "        data, target = data.to(args.device), target.to(args.device)            \n",
    "        if args.lossfn=='mse':\n",
    "            target=(2*target-1)\n",
    "            target = target.type(torch.cuda.FloatTensor).unsqueeze(1)\n",
    "        if 'mnist' in args.dataset:\n",
    "            data=data.view(data.shape[0],-1)\n",
    "        output = model(data)\n",
    "        loss = mult*cr(output, target)\n",
    "        test_losses = test_losses + list(loss.cpu().detach().numpy())\n",
    "    del dataloader\n",
    "    dataloader = torch.utils.data.DataLoader(f_loader.dataset, batch_size=128, shuffle=False)\n",
    "    for batch_idx, (data, target) in enumerate(dataloader):\n",
    "        data, target = data.to(args.device), target.to(args.device)            \n",
    "        if args.lossfn=='mse':\n",
    "            target=(2*target-1)\n",
    "            target = target.type(torch.cuda.FloatTensor).unsqueeze(1)\n",
    "        if 'mnist' in args.dataset:\n",
    "            data=data.view(data.shape[0],-1)\n",
    "        output = model(data)\n",
    "        loss = mult*cr(output, target)\n",
    "        forget_losses = forget_losses + list(loss.cpu().detach().numpy())\n",
    "    del dataloader\n",
    "\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    if len(forget_losses) > len(test_losses):\n",
    "        forget_losses = list(random.sample(forget_losses, len(test_losses)))\n",
    "    elif len(test_losses) > len(forget_losses):\n",
    "        test_losses = list(random.sample(test_losses, len(forget_losses)))\n",
    "    \n",
    "  \n",
    "    sns.distplot(np.array(test_losses), kde=False, norm_hist=False, rug=False, label='test-loss', ax=plt)\n",
    "    sns.distplot(np.array(forget_losses), kde=False, norm_hist=False, rug=False, label='forget-loss', ax=plt)\n",
    "    plt.legend(prop={'size': 14})\n",
    "    plt.tick_params(labelsize=12)\n",
    "    plt.title(\"loss histograms\",size=18)\n",
    "    plt.xlabel('loss values',size=14)\n",
    "    plt.show()\n",
    "    print (np.max(test_losses), np.min(test_losses))\n",
    "    print (np.max(forget_losses), np.min(forget_losses))\n",
    "\n",
    "\n",
    "    test_labels = [0]*len(test_losses)\n",
    "    forget_labels = [1]*len(forget_losses)\n",
    "    features = np.array(test_losses + forget_losses).reshape(-1,1)\n",
    "    labels = np.array(test_labels + forget_labels).reshape(-1)\n",
    "    features = np.clip(features, -500, 500)\n",
    "    score = evaluate_attack_model(features, labels, n_splits=5, random_state=seed)\n",
    "\n",
    "    return score\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Finetune and Fisher Helper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils import *\n",
    "def get_metrics(model,dataloader,criterion,bs=128,samples_correctness=False,use_bn=False,delta_w=None,scrub_act=False):\n",
    "    activations=[]\n",
    "    predictions=[]\n",
    "    if use_bn:\n",
    "        model.train()\n",
    "        dataloader = torch.utils.data.DataLoader(retain_loader.dataset, batch_size=128, shuffle=True)\n",
    "        for i in range(10):\n",
    "            for batch_idx, (data, target) in enumerate(dataloader):\n",
    "                data, target = data.to(args.device), target.to(args.device)            \n",
    "                output = model(data)\n",
    "    dataloader = torch.utils.data.DataLoader(dataloader.dataset, batch_size=128, shuffle=False)\n",
    "    model.eval()\n",
    "    metrics = utils.AverageMeter()\n",
    "    mult = 0.5 if args.lossfn=='mse' else 1\n",
    "    for batch_idx, (data, target) in enumerate(dataloader):\n",
    "        data, target = data.to(args.device), target.to(args.device)            \n",
    "        if args.lossfn=='mse':\n",
    "            target=(2*target-1)\n",
    "            target = target.type(torch.cuda.FloatTensor).unsqueeze(1)\n",
    "        if 'mnist' in args.dataset:\n",
    "            data=data.view(data.shape[0],-1)\n",
    "        output = model(data)\n",
    "        if scrub_act:\n",
    "            G = []\n",
    "            for cls in range(num_classes):\n",
    "                grads = torch.autograd.grad(output[0,cls],model.parameters(),retain_graph=True)\n",
    "                grads = torch.cat([g.view(-1) for g in grads])\n",
    "                G.append(grads)\n",
    "            grads = torch.autograd.grad(output_sf[0,cls],model_scrubf.parameters(),retain_graph=False)\n",
    "            G = torch.stack(G).pow(2)\n",
    "            delta_f = torch.matmul(G,delta_w)\n",
    "            output += delta_f.sqrt()*torch.empty_like(delta_f).normal_()\n",
    "\n",
    "        loss = mult*criterion(output, target)\n",
    "        if samples_correctness:\n",
    "            #activations.append(torch.nn.functional.softmax(output,dim=1).cpu().detach().numpy().squeeze())\n",
    "            activations = activations + list(torch.nn.functional.softmax(output,dim=1).cpu().detach().numpy().squeeze())\n",
    "            predictions.append(get_error(output,target))\n",
    "        metrics.update(n=data.size(0), loss=loss.item(), error=get_error(output, target))\n",
    "    if samples_correctness:\n",
    "        return metrics.avg,np.stack(activations),np.array(predictions)\n",
    "    else:\n",
    "        return metrics.avg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def l2_penalty(model,model_init,weight_decay):\n",
    "    l2_loss = 0\n",
    "    for (k,p),(k_init,p_init) in zip(model.named_parameters(),model_init.named_parameters()):\n",
    "        if p.requires_grad:\n",
    "            l2_loss += (p-p_init).pow(2).sum()\n",
    "    l2_loss *= (weight_decay/2.)\n",
    "    return l2_loss\n",
    "\n",
    "def run_train_epoch(model: nn.Module, model_init, data_loader: torch.utils.data.DataLoader, \n",
    "                    loss_fn: nn.Module,\n",
    "                    optimizer: torch.optim.SGD, split: str, epoch: int, ignore_index=None,\n",
    "                    negative_gradient=False, negative_multiplier=-1, random_labels=False,\n",
    "                    quiet=False,delta_w=None,scrub_act=False):\n",
    "    model.eval()\n",
    "    metrics = utils.AverageMeter()    \n",
    "    num_labels = data_loader.dataset.targets.max().item() + 1\n",
    "    \n",
    "    with torch.set_grad_enabled(split != 'test'):\n",
    "        for idx, batch in enumerate(tqdm(data_loader, leave=False)):\n",
    "            batch = [tensor.to(next(model.parameters()).device) for tensor in batch]\n",
    "            input, target = batch\n",
    "            output = model(input)\n",
    "            if split=='test' and scrub_act:\n",
    "                G = []\n",
    "                for cls in range(num_classes):\n",
    "                    grads = torch.autograd.grad(output[0,cls],model.parameters(),retain_graph=True)\n",
    "                    grads = torch.cat([g.view(-1) for g in grads])\n",
    "                    G.append(grads)\n",
    "                grads = torch.autograd.grad(output_sf[0,cls],model_scrubf.parameters(),retain_graph=False)\n",
    "                G = torch.stack(G).pow(2)\n",
    "                delta_f = torch.matmul(G,delta_w)\n",
    "                output += delta_f.sqrt()*torch.empty_like(delta_f).normal_()\n",
    "            loss = loss_fn(output, target) + l2_penalty(model,model_init,args.weight_decay)\n",
    "            metrics.update(n=input.size(0), loss=loss_fn(output,target).item(), error=get_error(output, target))\n",
    "            \n",
    "            if split != 'test':\n",
    "                model.zero_grad()\n",
    "                loss.backward()\n",
    "                optimizer.step()\n",
    "    if not quiet:\n",
    "        log_metrics(split, metrics, epoch)\n",
    "    return metrics.avg\n",
    "\n",
    "def run_neggrad_epoch(model: nn.Module, model_init, data_loader: torch.utils.data.DataLoader, \n",
    "                    forget_loader: torch.utils.data.DataLoader,\n",
    "                    alpha: float,\n",
    "                    loss_fn: nn.Module,\n",
    "                    optimizer: torch.optim.SGD, split: str, epoch: int, ignore_index=None,\n",
    "                    quiet=False):\n",
    "    model.eval()\n",
    "    metrics = utils.AverageMeter()    \n",
    "    num_labels = data_loader.dataset.targets.max().item() + 1\n",
    "    \n",
    "    with torch.set_grad_enabled(split != 'test'):\n",
    "        for idx, (batch_retain,batch_forget) in enumerate(tqdm(zip(data_loader,cycle(forget_loader)), leave=False)):\n",
    "            batch_retain = [tensor.to(next(model.parameters()).device) for tensor in batch_retain]\n",
    "            batch_forget = [tensor.to(next(model.parameters()).device) for tensor in batch_forget]\n",
    "            input_r, target_r = batch_retain\n",
    "            input_f, target_f = batch_forget\n",
    "            output_r = model(input_r)\n",
    "            output_f = model(input_f)\n",
    "            loss = alpha*(loss_fn(output_r, target_r) + l2_penalty(model,model_init,args.weight_decay)) - (1-alpha)*loss_fn(output_f, target_f)\n",
    "            metrics.update(n=input_r.size(0), loss=loss_fn(output_r,target_r).item(), error=get_error(output_r, target_r))\n",
    "            if split != 'test':\n",
    "                model.zero_grad()\n",
    "                loss.backward()\n",
    "                optimizer.step()\n",
    "    if not quiet:\n",
    "        log_metrics(split, metrics, epoch)\n",
    "    return metrics.avg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def finetune(model: nn.Module, data_loader: torch.utils.data.DataLoader, lr=0.01, epochs=10, quiet=False):\n",
    "    loss_fn = nn.CrossEntropyLoss()\n",
    "    optimizer = torch.optim.SGD(model.parameters(), lr=lr, weight_decay=0.0)\n",
    "    model_init=copy.deepcopy(model)\n",
    "    for epoch in range(epochs):\n",
    "        #run_train_epoch(model, model_init, data_loader, loss_fn, optimizer, split='train', epoch=epoch, ignore_index=None, quiet=quiet)\n",
    "        train_vanilla(epoch, data_loader, model, loss_fn, optimizer, args)\n",
    "\n",
    "def negative_grad(model: nn.Module, data_loader: torch.utils.data.DataLoader, forget_loader: torch.utils.data.DataLoader, alpha: float, lr=0.01, epochs=10, quiet=False, args=None):\n",
    "    loss_fn = nn.CrossEntropyLoss()\n",
    "    optimizer = torch.optim.SGD(model.parameters(), lr=lr, weight_decay=0.0)\n",
    "    model_init=copy.deepcopy(model)\n",
    "    for epoch in range(epochs):\n",
    "        #run_neggrad_epoch(model, model_init, data_loader, forget_loader, alpha, loss_fn, optimizer, split='train', epoch=epoch, ignore_index=None, quiet=quiet)\n",
    "        train_negrad(epoch, data_loader, forget_loader, model, loss_fn, optimizer,  alpha, args)\n",
    "\n",
    "def fk_fientune(model: nn.Module, data_loader: torch.utils.data.DataLoader, args, lr=0.01, epochs=10, quiet=False):\n",
    "    loss_fn = nn.CrossEntropyLoss()\n",
    "    optimizer = torch.optim.SGD(model.parameters(), lr=lr, weight_decay=0.0)\n",
    "    model_init=copy.deepcopy(model)\n",
    "    for epoch in range(epochs):\n",
    "        sgda_adjust_learning_rate(epoch, args, optimizer)\n",
    "        #run_train_epoch(model, model_init, data_loader, loss_fn, optimizer, split='train', epoch=epoch, ignore_index=None, quiet=quiet)\n",
    "        train_vanilla(epoch, data_loader, model, loss_fn, optimizer, args)\n",
    "        #train_negrad(epoch, data_loader, forget_loader, model, loss_fn, optimizer,  alpha)\n",
    "def test(model, data_loader):\n",
    "    loss_fn = nn.CrossEntropyLoss()\n",
    "    model_init=copy.deepcopy(model)\n",
    "    return run_train_epoch(model, model_init, data_loader, loss_fn, optimizer=None, split='test', epoch=epoch, ignore_index=None, quiet=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def readout_retrain(model, data_loader, test_loader, lr=0.1, epochs=500, threshold=0.01, quiet=True):\n",
    "    torch.manual_seed(seed)\n",
    "    model = copy.deepcopy(model)\n",
    "    loss_fn = nn.CrossEntropyLoss()\n",
    "    optimizer = torch.optim.SGD(model.parameters(), lr=lr, weight_decay=0.0)\n",
    "    sampler = torch.utils.data.RandomSampler(data_loader.dataset, replacement=True, num_samples=500)\n",
    "    data_loader_small = torch.utils.data.DataLoader(data_loader.dataset, batch_size=data_loader.batch_size, sampler=sampler, num_workers=data_loader.num_workers)\n",
    "    metrics = []\n",
    "    model_init=copy.deepcopy(model)\n",
    "    for epoch in range(epochs):\n",
    "        metrics.append(run_train_epoch(model, model_init, test_loader, loss_fn, optimizer, split='test', epoch=epoch, ignore_index=None, quiet=quiet))\n",
    "        if metrics[-1]['loss'] <= threshold:\n",
    "            break\n",
    "        run_train_epoch(model, model_init, data_loader_small, loss_fn, optimizer, split='train', epoch=epoch, ignore_index=None, quiet=quiet)\n",
    "    return epoch, metrics\n",
    "\n",
    "def extract_retrain_time(metrics, threshold=0.1):\n",
    "    losses = np.array([m['loss'] for m in metrics])\n",
    "    return np.argmax(losses < threshold)\n",
    "\n",
    "def all_readouts(model,thresh=0.1,name='method',seed=0):\n",
    "    MIA = membership_inference_attack(model, copy.deepcopy(test_loader_full_full), forget_loader, seed)\n",
    "    #train_loader = torch.utils.data.DataLoader(train_loader_full.dataset, batch_size=128, shuffle=True)\n",
    "    retrain_time, _ = 0,0#readout_retrain(model, train_loader, forget_loader, epochs=100, lr=0.001, threshold=thresh)\n",
    "    test_error = test(model, test_loader_full)['error']*100\n",
    "    forget_error = test(model, forget_loader)['error']*100\n",
    "    retain_error = test(model, retain_loader)['error']*100\n",
    "    val_error = test(model, valid_loader_full)['error']*100\n",
    "    \n",
    "    print(f\"{name} ->\"\n",
    "          f\"\\tFull test error: {test_error:.2f}\"\n",
    "          f\"\\tForget error: {forget_error:.2f}\\tRetain error: {retain_error:.2f}\\tValid error: {val_error:.2f}\"\n",
    "          f\"\\tFine-tune time: {retrain_time+1} steps\\tMIA: {np.mean(MIA):.2f}±{np.std(MIA):0.1f}\")\n",
    "    \n",
    "    return(dict(test_error=test_error, forget_error=forget_error, retain_error=retain_error, val_error=val_error, retrain_time=retrain_time+1, MIA=np.mean(MIA)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def badt(gteacher, bteacher, student):\n",
    "    args.bt_optim = 'adam'\n",
    "    args.bt_alpha = 1\n",
    "    args.bt_beta = 1\n",
    "    args.bt_kd_T = 4\n",
    "    args.bt_distill = 'kd'\n",
    "\n",
    "    args.bt_epochs = 1\n",
    "    args.bt_learning_rate = 0.001\n",
    "    args.bt_lr_decay_epochs = [10,10,10]\n",
    "    args.bt_lr_decay_rate = 0.1\n",
    "    args.bt_weight_decay = 5e-4\n",
    "    args.bt_momentum = 0.9\n",
    "\n",
    "    model_gt = copy.deepcopy(gteacher)\n",
    "    model_bt = copy.deepcopy(bteacher)\n",
    "    model_s = copy.deepcopy(student)\n",
    "\n",
    "\n",
    "    module_list = nn.ModuleList([])\n",
    "    module_list.append(model_s)\n",
    "    trainable_list = nn.ModuleList([])\n",
    "    trainable_list.append(model_s)\n",
    "\n",
    "    criterion_cls = nn.CrossEntropyLoss()\n",
    "    criterion_div = DistillKL(args.bt_kd_T)\n",
    "    criterion_kd = DistillKL(args.bt_kd_T)\n",
    "\n",
    "\n",
    "    criterion_list = nn.ModuleList([])\n",
    "    criterion_list.append(criterion_cls)    # classification loss\n",
    "    criterion_list.append(criterion_div)    # KL divergence loss, original knowledge distillation\n",
    "    criterion_list.append(criterion_kd)     # other knowledge distillation loss\n",
    "\n",
    "    # optimizer\n",
    "    if args.bt_optim == \"sgd\":\n",
    "        optimizer = optim.SGD(trainable_list.parameters(),\n",
    "                              lr=args.bt_learning_rate,\n",
    "                              momentum=args.bt_momentum,\n",
    "                              weight_decay=args.bt_weight_decay)\n",
    "    elif args.bt_optim == \"adam\": \n",
    "        optimizer = optim.Adam(trainable_list.parameters(),\n",
    "                              lr=args.bt_learning_rate,\n",
    "                              weight_decay=args.bt_weight_decay)\n",
    "    elif args.bt_optim == \"rmsp\":\n",
    "        optimizer = optim.RMSprop(trainable_list.parameters(),\n",
    "                              lr=args.bt_learning_rate,\n",
    "                              momentum=args.bt_momentum,\n",
    "                              weight_decay=args.bt_weight_decay)\n",
    "\n",
    "    module_list.append(model_gt)\n",
    "    module_list.append(model_bt)\n",
    "\n",
    "    if torch.cuda.is_available():\n",
    "        module_list.cuda()\n",
    "        criterion_list.cuda()\n",
    "        import torch.backends.cudnn as cudnn\n",
    "        cudnn.benchmark = True\n",
    "\n",
    "\n",
    "    acc_rs = []\n",
    "    acc_fs = []\n",
    "    acc_vs = []\n",
    "    \n",
    "    print(\"==> Bad Teacher Unlearning ...\")\n",
    "    for epoch in range(1, args.bt_epochs + 1):\n",
    "\n",
    "        acc_r, acc5_r, loss_r = validate(retain_loader, model_s, criterion_cls, args, True)\n",
    "        acc_f, acc5_f, loss_f = validate(forget_loader, model_s, criterion_cls, args, True)\n",
    "        acc_v, acc5_v, loss_v = validate(valid_loader_full, model_s, criterion_cls, args, True)\n",
    "        acc_rs.append(100-acc_r.item())\n",
    "        acc_fs.append(100-acc_f.item())\n",
    "        acc_vs.append(100-acc_v.item())\n",
    "\n",
    "        lr = sgda_adjust_learning_rate(epoch, args, optimizer)\n",
    "        train_acc, loss = train_bad_teacher(epoch, retain_loader, forget_loader, module_list, criterion_list, optimizer, args)\n",
    "\n",
    "\n",
    "\n",
    "        print (\"loss: {:.2f}\\t train_acc: {}\".format(loss, train_acc))\n",
    "        \n",
    "\n",
    "    acc_r, acc5_r, loss_r = validate(retain_loader, model_s, criterion_cls, args, True)\n",
    "    acc_f, acc5_f, loss_f = validate(forget_loader, model_s, criterion_cls, args, True)\n",
    "    acc_v, acc5_v, loss_v = validate(valid_loader_full, model_s, criterion_cls, args, True)\n",
    "    acc_rs.append(100-acc_r.item())\n",
    "    acc_fs.append(100-acc_f.item())\n",
    "    acc_vs.append(100-acc_v.item())\n",
    "\n",
    "    from matplotlib import pyplot as plt\n",
    "    indices = list(range(0,len(acc_rs)))\n",
    "    plt.plot(indices, acc_rs, marker='*', color=u'#1f77b4', alpha=1, label='retain-set')\n",
    "    plt.plot(indices, acc_fs, marker='o', color=u'#ff7f0e', alpha=1, label='forget-set')\n",
    "    plt.plot(indices, acc_vs, marker='^', color=u'#2ca02c',alpha=1, label='validation-set')\n",
    "    plt.legend(prop={'size': 14})\n",
    "    plt.tick_params(labelsize=12)\n",
    "    #plt.title('sgda retain- and forget- set error',size=18)\n",
    "    plt.xlabel('epoch',size=14)\n",
    "    plt.ylabel('error',size=14)\n",
    "    plt.grid()\n",
    "    #plt.ylim(0,0.4)\n",
    "    #plt.xlim(-5,2)\n",
    "    #plt.savefig('Plots/small_cifar5_allcnn_forget0_num5_epochs25_'+title+'.png')\n",
    "    plt.show()\n",
    "    \n",
    "    \n",
    "    return model_s\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def scrub(teacher, student):\n",
    "    args.optim = 'sgd'\n",
    "    args.gamma = 0.99\n",
    "    args.alpha = 0.001\n",
    "    args.beta = 0\n",
    "    args.smoothing = 0.5\n",
    "    args.msteps = 2\n",
    "    args.clip = 0.2\n",
    "    args.sstart = 10\n",
    "    args.kd_T = 4\n",
    "    args.distill = 'kd'\n",
    "\n",
    "    args.sgda_epochs = 3\n",
    "    args.sgda_learning_rate = 0.0005\n",
    "    args.lr_decay_epochs = [3,5,9]\n",
    "    args.lr_decay_rate = 0.1\n",
    "    args.sgda_weight_decay = 5e-4\n",
    "    args.sgda_momentum = 0.9\n",
    "\n",
    "    model_t = copy.deepcopy(teacher)\n",
    "    model_s = copy.deepcopy(student)\n",
    "\n",
    "\n",
    "    module_list = nn.ModuleList([])\n",
    "    module_list.append(model_s)\n",
    "    trainable_list = nn.ModuleList([])\n",
    "    trainable_list.append(model_s)\n",
    "\n",
    "    criterion_cls = nn.CrossEntropyLoss()\n",
    "    criterion_div = DistillKL(args.kd_T)\n",
    "    criterion_kd = DistillKL(args.kd_T)\n",
    "\n",
    "\n",
    "    criterion_list = nn.ModuleList([])\n",
    "    criterion_list.append(criterion_cls)    # classification loss\n",
    "    criterion_list.append(criterion_div)    # KL divergence loss, original knowledge distillation\n",
    "    criterion_list.append(criterion_kd)     # other knowledge distillation loss\n",
    "\n",
    "    # optimizer\n",
    "    if args.optim == \"sgd\":\n",
    "        optimizer = optim.SGD(trainable_list.parameters(),\n",
    "                              lr=args.sgda_learning_rate,\n",
    "                              momentum=args.sgda_momentum,\n",
    "                              weight_decay=args.sgda_weight_decay)\n",
    "    elif args.optim == \"adam\": \n",
    "        optimizer = optim.Adam(trainable_list.parameters(),\n",
    "                              lr=args.sgda_learning_rate,\n",
    "                              weight_decay=args.sgda_weight_decay)\n",
    "    elif args.optim == \"rmsp\":\n",
    "        optimizer = optim.RMSprop(trainable_list.parameters(),\n",
    "                              lr=args.sgda_learning_rate,\n",
    "                              momentum=args.sgda_momentum,\n",
    "                              weight_decay=args.sgda_weight_decay)\n",
    "\n",
    "    module_list.append(model_t)\n",
    "\n",
    "    if torch.cuda.is_available():\n",
    "        module_list.cuda()\n",
    "        criterion_list.cuda()\n",
    "        import torch.backends.cudnn as cudnn\n",
    "        cudnn.benchmark = True\n",
    "\n",
    "\n",
    "    t1 = time.time()\n",
    "    acc_rs = []\n",
    "    acc_fs = []\n",
    "    acc_vs = []\n",
    "    acc_fvs = []\n",
    "    \n",
    "    \n",
    "    forget_validation_loader = copy.deepcopy(valid_loader_full)\n",
    "    fgt_cls = list(np.unique(forget_loader.dataset.targets))\n",
    "    indices = [i in fgt_cls for i in forget_validation_loader.dataset.targets]\n",
    "    forget_validation_loader.dataset.data = forget_validation_loader.dataset.data[indices]\n",
    "    forget_validation_loader.dataset.targets = forget_validation_loader.dataset.targets[indices]\n",
    "    \n",
    "    scrub_name = \"checkpoints/scrub_{}_{}_seed{}_step\".format(args.model, args.dataset, args.seed)\n",
    "    for epoch in range(1, args.sgda_epochs + 1):\n",
    "\n",
    "        lr = sgda_adjust_learning_rate(epoch, args, optimizer)\n",
    "\n",
    "        print(\"==> scrub unlearning ...\")\n",
    "\n",
    "        acc_r, acc5_r, loss_r = validate(retain_loader, model_s, criterion_cls, args, True)\n",
    "        acc_f, acc5_f, loss_f = validate(forget_loader, model_s, criterion_cls, args, True)\n",
    "        acc_v, acc5_v, loss_v = validate(valid_loader_full, model_s, criterion_cls, args, True)\n",
    "        acc_fv, acc5_fv, loss_fv = validate(forget_validation_loader, model_s, criterion_cls, args, True)\n",
    "        acc_rs.append(100-acc_r.item())\n",
    "        acc_fs.append(100-acc_f.item())\n",
    "        acc_vs.append(100-acc_v.item())\n",
    "        acc_fvs.append(100-acc_fv.item())\n",
    "\n",
    "        maximize_loss = 0\n",
    "        if epoch <= args.msteps:\n",
    "            maximize_loss = train_distill(epoch, forget_loader, module_list, None, criterion_list, optimizer, args, \"maximize\")\n",
    "        train_acc, train_loss = train_distill(epoch, retain_loader, module_list, None, criterion_list, optimizer, args, \"minimize\",)\n",
    "        \n",
    "        torch.save(model_s.state_dict(), scrub_name+str(epoch)+\".pt\")\n",
    "\n",
    "\n",
    "        print (\"maximize loss: {:.2f}\\t minimize loss: {:.2f}\\t train_acc: {}\".format(maximize_loss, train_loss, train_acc))\n",
    "    t2 = time.time()\n",
    "    print (t2-t1)\n",
    "\n",
    "    acc_r, acc5_r, loss_r = validate(retain_loader, model_s, criterion_cls, args, True)\n",
    "    acc_f, acc5_f, loss_f = validate(forget_loader, model_s, criterion_cls, args, True)\n",
    "    acc_v, acc5_v, loss_v = validate(valid_loader_full, model_s, criterion_cls, args, True)\n",
    "    acc_fv, acc5_fv, loss_fv = validate(forget_validation_loader, model_s, criterion_cls, args, True)\n",
    "    acc_rs.append(100-acc_r.item())\n",
    "    acc_fs.append(100-acc_f.item())\n",
    "    acc_vs.append(100-acc_v.item())\n",
    "    acc_fvs.append(100-acc_fv.item())\n",
    "\n",
    "    from matplotlib import pyplot as plt\n",
    "    indices = list(range(0,len(acc_rs)))\n",
    "    plt.plot(indices, acc_rs, marker='*', color=u'#1f77b4', alpha=1, label='retain-set')\n",
    "    plt.plot(indices, acc_fs, marker='o', color=u'#ff7f0e', alpha=1, label='forget-set')\n",
    "    plt.plot(indices, acc_vs, marker='^', color=u'#2ca02c',alpha=1, label='validation-set')\n",
    "    plt.plot(indices, acc_fvs, marker='.', color=u'#2ca02c',alpha=1, label='forget-validation-set')\n",
    "    plt.legend(prop={'size': 14})\n",
    "    plt.tick_params(labelsize=12)\n",
    "    plt.xlabel('epoch',size=14)\n",
    "    plt.ylabel('error',size=14)\n",
    "    plt.grid()\n",
    "    plt.show()\n",
    "    \n",
    "    \n",
    "    #selected_idx = list(filter(lambda i: i > acc_fvs[-1], acc_fs))[0]\n",
    "    print (acc_fs)\n",
    "    print (acc_fvs)\n",
    "    try:\n",
    "        selected_idx = next(x for x, val in enumerate(acc_fs) if val > acc_fvs[-1])\n",
    "    except:\n",
    "        selected_idx = len(acc_fs) - 1\n",
    "    print (\"the selected index is {}\".format(selected_idx))\n",
    "    selected_model = \"checkpoints/scrub_{}_{}_seed{}_step{}.pt\".format(args.model, args.dataset, args.seed, int(selected_idx))\n",
    "    model_s_final = copy.deepcopy(model_s)\n",
    "    model_s.load_state_dict(torch.load(selected_model))\n",
    "    \n",
    "    \n",
    "    return model_s, model_s_final\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def replace_loader_dataset(data_loader, dataset, batch_size=128, seed=1, shuffle=True):\n",
    "    manual_seed(seed)\n",
    "    loader_args = {'num_workers': 0, 'pin_memory': False}\n",
    "    def _init_fn(worker_id):\n",
    "        np.random.seed(int(seed))\n",
    "    return torch.utils.data.DataLoader(dataset, batch_size=batch_size,num_workers=0,pin_memory=True,shuffle=shuffle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cfk_unlearn(model):\n",
    "    args.lr_decay_epochs = [10,15,20]\n",
    "    args.cfk_lr = 0.01\n",
    "    args.cfk_epochs = 10\n",
    "    args.cfk_bs = 64\n",
    "    retain_loader = replace_loader_dataset(train_loader_full,retain_dataset, seed=seed, batch_size=args.cfk_bs, shuffle=True)\n",
    "\n",
    "    model_cfk = copy.deepcopy(model)\n",
    "\n",
    "    for param in model_cfk.parameters():\n",
    "        param.requires_grad_(False)\n",
    "\n",
    "    if args.model == 'allcnn':\n",
    "        layers = [9]\n",
    "        for k in layers:\n",
    "            for param in model_cfk.features[k].parameters():\n",
    "                param.requires_grad_(True)\n",
    "\n",
    "    elif args.model == \"resnet\":\n",
    "        for param in model_cfk.layer4.parameters():\n",
    "            param.requires_grad_(True)\n",
    "\n",
    "    else:\n",
    "        raise NotImplementedError\n",
    "\n",
    "\n",
    "    fk_fientune(model_cfk, retain_loader, args=args, epochs=args.cfk_epochs, quiet=True, lr=args.cfk_lr)\n",
    "    return model_cfk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def euk_unlearn(model, model_initial):\n",
    "    args.lr_decay_epochs = [10,15,20]\n",
    "    args.euk_lr = 0.01\n",
    "    args.euk_epochs = training_epochs\n",
    "    args.euk_bs = 64\n",
    "    retain_loader = replace_loader_dataset(train_loader_full,retain_dataset, seed=seed, batch_size=args.euk_bs, shuffle=True)\n",
    "    model_euk = copy.deepcopy(model)\n",
    "\n",
    "    for param in model_euk.parameters():\n",
    "        param.requires_grad_(False)\n",
    "\n",
    "    if args.model == 'allcnn':\n",
    "        with torch.no_grad():\n",
    "            for k in layers:\n",
    "                for i in range(0,3):\n",
    "                    try:\n",
    "                        model_euk.features[k][i].weight.copy_(model_initial.features[k][i].weight)\n",
    "                    except:\n",
    "                        print (\"block {}, layer {} does not have weights\".format(k,i))\n",
    "                    try:\n",
    "                        model_euk.features[k][i].bias.copy_(model_initial.features[k][i].bias)\n",
    "                    except:\n",
    "                        print (\"block {}, layer {} does not have bias\".format(k,i))\n",
    "            model_euk.classifier[0].weight.copy_(model_initial.classifier[0].weight)\n",
    "            model_euk.classifier[0].bias.copy_(model_initial.classifier[0].bias)\n",
    "\n",
    "        for k in layers:\n",
    "            for param in model_euk.features[k].parameters():\n",
    "                param.requires_grad_(True)\n",
    "\n",
    "    elif args.model == \"resnet\":\n",
    "        with torch.no_grad():\n",
    "            for i in range(0,2):\n",
    "                try:\n",
    "                    model_euk.layer4[i].bn1.weight.copy_(model_initial.layer4[i].bn1.weight)\n",
    "                except:\n",
    "                    print (\"block 4, layer {} does not have weight\".format(i))\n",
    "                try:\n",
    "                    model_euk.layer4[i].bn1.bias.copy_(model_initial.layer4[i].bn1.bias)\n",
    "                except:\n",
    "                    print (\"block 4, layer {} does not have bias\".format(i))\n",
    "                try:\n",
    "                    model_euk.layer4[i].conv1.weight.copy_(model_initial.layer4[i].conv1.weight)\n",
    "                except:\n",
    "                    print (\"block 4, layer {} does not have weight\".format(i))\n",
    "                try:\n",
    "                    model_euk.layer4[i].conv1.bias.copy_(model_initial.layer4[i].conv1.bias)\n",
    "                except:\n",
    "                    print (\"block 4, layer {} does not have bias\".format(i))\n",
    "\n",
    "                try:\n",
    "                    model_euk.layer4[i].bn2.weight.copy_(model_initial.layer4[i].bn2.weight)\n",
    "                except:\n",
    "                    print (\"block 4, layer {} does not have weight\".format(i))\n",
    "                try:\n",
    "                    model_euk.layer4[i].bn2.bias.copy_(model_initial.layer4[i].bn2.bias)\n",
    "                except:\n",
    "                    print (\"block 4, layer {} does not have bias\".format(i))\n",
    "                try:\n",
    "                    model_euk.layer4[i].conv2.weight.copy_(model_initial.layer4[i].conv2.weight)\n",
    "                except:\n",
    "                    print (\"block 4, layer {} does not have weight\".format(i))\n",
    "                try:\n",
    "                    model_euk.layer4[i].conv2.bias.copy_(model_initial.layer4[i].conv2.bias)\n",
    "                except:\n",
    "                    print (\"block 4, layer {} does not have bias\".format(i))\n",
    "\n",
    "            model_euk.layer4[0].shortcut[0].weight.copy_(model_initial.layer4[0].shortcut[0].weight)\n",
    "\n",
    "        for param in model_euk.layer4.parameters():\n",
    "            param.requires_grad_(True)\n",
    "\n",
    "    else:\n",
    "        raise NotImplementedError\n",
    "\n",
    "\n",
    "    fk_fientune(model_euk, retain_loader, epochs=args.euk_epochs, quiet=True, lr=args.euk_lr, args=args)\n",
    "    return model_euk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Checkpoint name: cifar10_allcnn_1_0_forget_None_lr_0_01_bs_128_ls_ce_wd_0_0005_seed_1\n",
      "[Logging in cifar10_allcnn_1_0_forget_None_lr_0_01_bs_128_ls_ce_wd_0_0005_seed_1_training]\n",
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "confuse mode: False\n",
      "split mode: train\n",
      "Number of Classes: 10\n",
      "Epoch: [0][0/313]\tTime 1.559 (1.559)\tData 0.026 (0.026)\tLoss 2.3881 (2.3881)\tAcc@1 11.719 (11.719)\tAcc@5 59.375 (59.375)\n",
      " * Acc@1 68.353 Acc@5 96.982\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.7571 (0.7571)\tAcc@1 71.094 (71.094)\tAcc@5 97.656 (97.656)\n",
      " * Acc@1 76.590 Acc@5 98.690\n",
      "Epoch Time: 12.58 sec\n",
      "Epoch: [1][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.6241 (0.6241)\tAcc@1 76.562 (76.562)\tAcc@5 99.219 (99.219)\n",
      " * Acc@1 80.402 Acc@5 99.215\n",
      "Epoch Time: 8.99 sec\n",
      "Epoch: [2][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.4661 (0.4661)\tAcc@1 85.156 (85.156)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 84.987 Acc@5 99.527\n",
      "Epoch Time: 8.99 sec\n",
      "Epoch: [3][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.3422 (0.3422)\tAcc@1 88.281 (88.281)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 88.493 Acc@5 99.700\n",
      "Epoch Time: 8.97 sec\n",
      "Epoch: [4][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.1815 (0.1815)\tAcc@1 94.531 (94.531)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 91.502 Acc@5 99.822\n",
      "Epoch Time: 8.99 sec\n",
      "Epoch: [5][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.1430 (0.1430)\tAcc@1 95.312 (95.312)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 94.267 Acc@5 99.890\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.5721 (0.5721)\tAcc@1 82.031 (82.031)\tAcc@5 98.438 (98.438)\n",
      " * Acc@1 83.360 Acc@5 99.160\n",
      "Epoch Time: 11.09 sec\n",
      "Epoch: [6][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.1197 (0.1197)\tAcc@1 95.312 (95.312)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 96.820 Acc@5 99.945\n",
      "Epoch Time: 9.05 sec\n",
      "Epoch: [7][0/313]\tTime 0.031 (0.031)\tData 0.023 (0.023)\tLoss 0.0965 (0.0965)\tAcc@1 97.656 (97.656)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 98.372 Acc@5 99.985\n",
      "Epoch Time: 9.02 sec\n",
      "Epoch: [8][0/313]\tTime 0.031 (0.031)\tData 0.023 (0.023)\tLoss 0.0580 (0.0580)\tAcc@1 99.219 (99.219)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.370 Acc@5 99.993\n",
      "Epoch Time: 8.97 sec\n",
      "Epoch: [9][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0249 (0.0249)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.770 Acc@5 99.995\n",
      "Epoch Time: 8.97 sec\n",
      "Epoch: [10][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0185 (0.0185)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.908 Acc@5 99.997\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.6343 (0.6343)\tAcc@1 83.594 (83.594)\tAcc@5 97.656 (97.656)\n",
      " * Acc@1 83.600 Acc@5 99.080\n",
      "Epoch Time: 11.04 sec\n",
      "Epoch: [11][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0170 (0.0170)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.978 Acc@5 99.997\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [12][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0104 (0.0104)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.993 Acc@5 100.000\n",
      "Epoch Time: 8.97 sec\n",
      "Epoch: [13][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0126 (0.0126)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.993 Acc@5 100.000\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [14][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0061 (0.0061)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.997 Acc@5 100.000\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [15][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0068 (0.0068)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.6164 (0.6164)\tAcc@1 83.594 (83.594)\tAcc@5 97.656 (97.656)\n",
      " * Acc@1 83.480 Acc@5 99.050\n",
      "Epoch Time: 11.02 sec\n",
      "Epoch: [16][0/313]\tTime 0.031 (0.031)\tData 0.023 (0.023)\tLoss 0.0073 (0.0073)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.97 sec\n",
      "Epoch: [17][0/313]\tTime 0.031 (0.031)\tData 0.023 (0.023)\tLoss 0.0071 (0.0071)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.97 sec\n",
      "Epoch: [18][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0229 (0.0229)\tAcc@1 99.219 (99.219)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.997 Acc@5 100.000\n",
      "Epoch Time: 8.97 sec\n",
      "Epoch: [19][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0056 (0.0056)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.98 sec\n",
      "Epoch: [20][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0047 (0.0047)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.5926 (0.5926)\tAcc@1 85.156 (85.156)\tAcc@5 98.438 (98.438)\n",
      " * Acc@1 83.480 Acc@5 99.050\n",
      "Epoch Time: 11.01 sec\n",
      "Epoch: [21][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0062 (0.0062)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [22][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0089 (0.0089)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [23][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0043 (0.0043)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [24][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0062 (0.0062)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [25][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0045 (0.0045)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.6125 (0.6125)\tAcc@1 85.156 (85.156)\tAcc@5 98.438 (98.438)\n",
      " * Acc@1 83.490 Acc@5 99.020\n",
      "Epoch Time: 11.0 sec\n",
      "Pure training time: 234.89999999999998 sec\n",
      "Checkpoint name: cifar10_allcnn_1_0_forget_[5]_lr_0_01_bs_128_ls_ce_wd_0_0005_seed_1\n",
      "[Logging in cifar10_allcnn_1_0_forget_[5]_lr_0_01_bs_128_ls_ce_wd_0_0005_seed_1_training]\n",
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "confuse mode: False\n",
      "split mode: forget\n",
      "Number of Classes: 10\n",
      "Epoch: [0][0/313]\tTime 0.032 (0.032)\tData 0.024 (0.024)\tLoss 2.3753 (2.3753)\tAcc@1 14.062 (14.062)\tAcc@5 61.719 (61.719)\n",
      " * Acc@1 72.202 Acc@5 98.007\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.6973 (0.6973)\tAcc@1 71.094 (71.094)\tAcc@5 98.438 (98.438)\n",
      " * Acc@1 71.950 Acc@5 89.260\n",
      "Epoch Time: 10.99 sec\n",
      "Epoch: [1][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.5193 (0.5193)\tAcc@1 79.688 (79.688)\tAcc@5 99.219 (99.219)\n",
      " * Acc@1 84.243 Acc@5 99.592\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [2][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.3580 (0.3580)\tAcc@1 88.281 (88.281)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 88.872 Acc@5 99.750\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [3][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.2778 (0.2778)\tAcc@1 89.844 (89.844)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 92.207 Acc@5 99.842\n",
      "Epoch Time: 8.94 sec\n",
      "Epoch: [4][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.1330 (0.1330)\tAcc@1 95.312 (95.312)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 95.132 Acc@5 99.908\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [5][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0924 (0.0924)\tAcc@1 96.875 (96.875)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 97.280 Acc@5 99.965\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.5820 (0.5820)\tAcc@1 82.812 (82.812)\tAcc@5 99.219 (99.219)\n",
      " * Acc@1 77.180 Acc@5 89.530\n",
      "Epoch Time: 10.99 sec\n",
      "Epoch: [6][0/313]\tTime 0.031 (0.031)\tData 0.023 (0.023)\tLoss 0.0425 (0.0425)\tAcc@1 99.219 (99.219)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 98.840 Acc@5 99.978\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [7][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0534 (0.0534)\tAcc@1 98.438 (98.438)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.500 Acc@5 99.995\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [8][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0400 (0.0400)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.822 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [9][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0126 (0.0126)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.910 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [10][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0141 (0.0141)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.957 Acc@5 100.000\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.6687 (0.6687)\tAcc@1 83.594 (83.594)\tAcc@5 100.000 (100.000)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * Acc@1 77.390 Acc@5 89.530\n",
      "Epoch Time: 10.99 sec\n",
      "Epoch: [11][0/313]\tTime 0.031 (0.031)\tData 0.023 (0.023)\tLoss 0.0094 (0.0094)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.985 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [12][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0099 (0.0099)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.995 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [13][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0072 (0.0072)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.990 Acc@5 100.000\n",
      "Epoch Time: 8.94 sec\n",
      "Epoch: [14][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0048 (0.0048)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [15][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0058 (0.0058)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.997 Acc@5 100.000\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.5925 (0.5925)\tAcc@1 82.812 (82.812)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 77.420 Acc@5 89.520\n",
      "Epoch Time: 11.0 sec\n",
      "Epoch: [16][0/313]\tTime 0.031 (0.031)\tData 0.023 (0.023)\tLoss 0.0063 (0.0063)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [17][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0075 (0.0075)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.997 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [18][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0185 (0.0185)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [19][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0057 (0.0057)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [20][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0035 (0.0035)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.6259 (0.6259)\tAcc@1 85.156 (85.156)\tAcc@5 99.219 (99.219)\n",
      " * Acc@1 77.460 Acc@5 89.480\n",
      "Epoch Time: 11.0 sec\n",
      "Epoch: [21][0/313]\tTime 0.032 (0.032)\tData 0.024 (0.024)\tLoss 0.0048 (0.0048)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [22][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0045 (0.0045)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.93 sec\n",
      "Epoch: [23][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0038 (0.0038)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 9.01 sec\n",
      "Epoch: [24][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0056 (0.0056)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.94 sec\n",
      "Epoch: [25][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0042 (0.0042)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.6486 (0.6486)\tAcc@1 84.375 (84.375)\tAcc@5 99.219 (99.219)\n",
      " * Acc@1 77.580 Acc@5 89.490\n",
      "Epoch Time: 11.01 sec\n",
      "Pure training time: 232.73999999999995 sec\n",
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "confuse mode: False\n",
      "split mode: train\n",
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "confuse mode: False\n",
      "split mode: train\n",
      "Forgetting by Fine-tuneing:\n",
      "Forgetting by NegGrad:\n",
      "Forgetting by CFK:\n",
      "Forgetting by EUK:\n",
      "==> Bad Teacher Unlearning ...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/meghdad/unlearning/SelectiveForgetting/myenv/lib/python3.9/site-packages/torch/nn/_reduction.py:42: UserWarning: size_average and reduce args will be deprecated, please use reduction='sum' instead.\n",
      "  warnings.warn(warning.format(ret))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: [1][0/282]\tTime 0.927 (0.927)\tData 0.112 (0.112)\tLoss 4.9458 (4.9458)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 94.067 Acc@5 99.958\n",
      "loss: 1.67\t train_acc: 94.06666564941406\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_770922/1431845755.py:115: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n",
      "  sns.distplot(np.array(test_losses), kde=False, norm_hist=False, rug=False, label='test-loss', ax=plt)\n",
      "/tmp/ipykernel_770922/1431845755.py:116: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n",
      "  sns.distplot(np.array(forget_losses), kde=False, norm_hist=False, rug=False, label='forget-loss', ax=plt)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.4221864 0.21221618\n",
      "3.6593797 0.3549391\n",
      "FPR:0.42, FNR:0.42, FP40.00, TN56.00, TP60.00, FN44.00\n",
      "FPR:0.46, FNR:0.45, FP48.00, TN57.00, TP52.00, FN43.00\n",
      "FPR:0.42, FNR:0.38, FP51.00, TN70.00, TP49.00, FN30.00\n",
      "FPR:0.40, FNR:0.41, FP37.00, TN56.00, TP63.00, FN44.00\n",
      "FPR:0.49, FNR:0.49, FP51.00, TN53.00, TP49.00, FN47.00\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                                                         \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BadT ->\tFull test error: 16.28\tForget error: 73.92\tRetain error: 5.44\tValid error: 22.19\tFine-tune time: 1 steps\tMIA: 0.57±0.0\n",
      "Checkpoint name: cifar10_allcnn_1_0_forget_None_lr_0_01_bs_128_ls_ce_wd_0_0005_seed_2\n",
      "[Logging in cifar10_allcnn_1_0_forget_None_lr_0_01_bs_128_ls_ce_wd_0_0005_seed_2_training]\n",
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "confuse mode: False\n",
      "split mode: train\n",
      "Number of Classes: 10\n",
      "Epoch: [0][0/313]\tTime 0.032 (0.032)\tData 0.024 (0.024)\tLoss 2.3378 (2.3378)\tAcc@1 10.156 (10.156)\tAcc@5 55.469 (55.469)\n",
      " * Acc@1 67.615 Acc@5 96.962\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.8013 (0.8013)\tAcc@1 71.094 (71.094)\tAcc@5 97.656 (97.656)\n",
      " * Acc@1 76.680 Acc@5 99.000\n",
      "Epoch Time: 11.09 sec\n",
      "Epoch: [1][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.7487 (0.7487)\tAcc@1 77.344 (77.344)\tAcc@5 99.219 (99.219)\n",
      " * Acc@1 80.022 Acc@5 99.175\n",
      "Epoch Time: 8.97 sec\n",
      "Epoch: [2][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.4677 (0.4677)\tAcc@1 84.375 (84.375)\tAcc@5 99.219 (99.219)\n",
      " * Acc@1 84.717 Acc@5 99.493\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [3][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.2931 (0.2931)\tAcc@1 89.844 (89.844)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 88.210 Acc@5 99.697\n",
      "Epoch Time: 8.98 sec\n",
      "Epoch: [4][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.2786 (0.2786)\tAcc@1 89.844 (89.844)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 91.397 Acc@5 99.800\n",
      "Epoch Time: 8.97 sec\n",
      "Epoch: [5][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.1901 (0.1901)\tAcc@1 93.750 (93.750)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 94.290 Acc@5 99.887\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.5995 (0.5995)\tAcc@1 81.250 (81.250)\tAcc@5 99.219 (99.219)\n",
      " * Acc@1 83.910 Acc@5 99.400\n",
      "Epoch Time: 11.01 sec\n",
      "Epoch: [6][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.1345 (0.1345)\tAcc@1 95.312 (95.312)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 96.658 Acc@5 99.952\n",
      "Epoch Time: 8.97 sec\n",
      "Epoch: [7][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0858 (0.0858)\tAcc@1 99.219 (99.219)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 98.442 Acc@5 99.982\n",
      "Epoch Time: 8.97 sec\n",
      "Epoch: [8][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0549 (0.0549)\tAcc@1 99.219 (99.219)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.357 Acc@5 99.997\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [9][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0208 (0.0208)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.777 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [10][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0215 (0.0215)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.927 Acc@5 100.000\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.5904 (0.5904)\tAcc@1 81.250 (81.250)\tAcc@5 98.438 (98.438)\n",
      " * Acc@1 83.820 Acc@5 99.190\n",
      "Epoch Time: 11.0 sec\n",
      "Epoch: [11][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0282 (0.0282)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.980 Acc@5 100.000\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [12][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0089 (0.0089)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.993 Acc@5 100.000\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [13][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0081 (0.0081)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.995 Acc@5 100.000\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [14][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0073 (0.0073)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.997 Acc@5 100.000\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [15][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0060 (0.0060)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.6429 (0.6429)\tAcc@1 82.031 (82.031)\tAcc@5 98.438 (98.438)\n",
      " * Acc@1 83.970 Acc@5 99.180\n",
      "Epoch Time: 11.01 sec\n",
      "Epoch: [16][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0078 (0.0078)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.97 sec\n",
      "Epoch: [17][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0150 (0.0150)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.97 sec\n",
      "Epoch: [18][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0070 (0.0070)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.97 sec\n",
      "Epoch: [19][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0054 (0.0054)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.97 sec\n",
      "Epoch: [20][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0074 (0.0074)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.6556 (0.6556)\tAcc@1 79.688 (79.688)\tAcc@5 98.438 (98.438)\n",
      " * Acc@1 83.900 Acc@5 99.140\n",
      "Epoch Time: 11.01 sec\n",
      "Epoch: [21][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0060 (0.0060)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.97 sec\n",
      "Epoch: [22][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0068 (0.0068)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.997 Acc@5 100.000\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [23][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0055 (0.0055)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [24][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0034 (0.0034)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.997 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [25][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0049 (0.0049)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.6340 (0.6340)\tAcc@1 79.688 (79.688)\tAcc@5 98.438 (98.438)\n",
      " * Acc@1 83.940 Acc@5 99.130\n",
      "Epoch Time: 11.01 sec\n",
      "Pure training time: 233.08000000000004 sec\n",
      "Checkpoint name: cifar10_allcnn_1_0_forget_[5]_lr_0_01_bs_128_ls_ce_wd_0_0005_seed_2\n",
      "[Logging in cifar10_allcnn_1_0_forget_[5]_lr_0_01_bs_128_ls_ce_wd_0_0005_seed_2_training]\n",
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "confuse mode: False\n",
      "split mode: forget\n",
      "Number of Classes: 10\n",
      "Epoch: [0][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 2.4056 (2.4056)\tAcc@1 7.031 (7.031)\tAcc@5 50.000 (50.000)\n",
      " * Acc@1 71.300 Acc@5 97.960\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.7759 (0.7759)\tAcc@1 71.875 (71.875)\tAcc@5 98.438 (98.438)\n",
      " * Acc@1 72.420 Acc@5 89.460\n",
      "Epoch Time: 11.03 sec\n",
      "Epoch: [1][0/313]\tTime 0.032 (0.032)\tData 0.024 (0.024)\tLoss 0.6439 (0.6439)\tAcc@1 80.469 (80.469)\tAcc@5 99.219 (99.219)\n",
      " * Acc@1 83.845 Acc@5 99.565\n",
      "Epoch Time: 8.97 sec\n",
      "Epoch: [2][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.3611 (0.3611)\tAcc@1 89.062 (89.062)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 88.620 Acc@5 99.737\n",
      "Epoch Time: 8.97 sec\n",
      "Epoch: [3][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.1965 (0.1965)\tAcc@1 95.312 (95.312)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 92.000 Acc@5 99.865\n",
      "Epoch Time: 8.97 sec\n",
      "Epoch: [4][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.1822 (0.1822)\tAcc@1 92.969 (92.969)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 94.915 Acc@5 99.912\n",
      "Epoch Time: 8.97 sec\n",
      "Epoch: [5][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.1167 (0.1167)\tAcc@1 97.656 (97.656)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 97.180 Acc@5 99.955\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.5596 (0.5596)\tAcc@1 82.031 (82.031)\tAcc@5 99.219 (99.219)\n",
      " * Acc@1 77.750 Acc@5 89.630\n",
      "Epoch Time: 11.04 sec\n",
      "Epoch: [6][0/313]\tTime 0.032 (0.032)\tData 0.024 (0.024)\tLoss 0.0680 (0.0680)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 98.625 Acc@5 99.982\n",
      "Epoch Time: 9.01 sec\n",
      "Epoch: [7][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0393 (0.0393)\tAcc@1 99.219 (99.219)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.438 Acc@5 99.997\n",
      "Epoch Time: 9.06 sec\n",
      "Epoch: [8][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0275 (0.0275)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.795 Acc@5 100.000\n",
      "Epoch Time: 9.01 sec\n",
      "Epoch: [9][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0137 (0.0137)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.892 Acc@5 100.000\n",
      "Epoch Time: 9.0 sec\n",
      "Epoch: [10][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0139 (0.0139)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * Acc@1 99.970 Acc@5 100.000\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.6090 (0.6090)\tAcc@1 80.469 (80.469)\tAcc@5 99.219 (99.219)\n",
      " * Acc@1 78.250 Acc@5 89.530\n",
      "Epoch Time: 11.03 sec\n",
      "Epoch: [11][0/313]\tTime 0.032 (0.032)\tData 0.024 (0.024)\tLoss 0.0193 (0.0193)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.982 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [12][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0075 (0.0075)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.993 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [13][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0088 (0.0088)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.993 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [14][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0059 (0.0059)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.997 Acc@5 100.000\n",
      "Epoch Time: 8.94 sec\n",
      "Epoch: [15][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0045 (0.0045)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.997 Acc@5 100.000\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.6191 (0.6191)\tAcc@1 83.594 (83.594)\tAcc@5 98.438 (98.438)\n",
      " * Acc@1 78.300 Acc@5 89.550\n",
      "Epoch Time: 11.0 sec\n",
      "Epoch: [16][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0059 (0.0059)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [17][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0090 (0.0090)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.997 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [18][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0056 (0.0056)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.94 sec\n",
      "Epoch: [19][0/313]\tTime 0.030 (0.030)\tData 0.024 (0.024)\tLoss 0.0046 (0.0046)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [20][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0041 (0.0041)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Test: [0/79]\tTime 0.027 (0.027)\tLoss 0.6158 (0.6158)\tAcc@1 83.594 (83.594)\tAcc@5 98.438 (98.438)\n",
      " * Acc@1 78.320 Acc@5 89.540\n",
      "Epoch Time: 11.0 sec\n",
      "Epoch: [21][0/313]\tTime 0.032 (0.032)\tData 0.025 (0.025)\tLoss 0.0055 (0.0055)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [22][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0057 (0.0057)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [23][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0040 (0.0040)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [24][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0035 (0.0035)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [25][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0061 (0.0061)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.6102 (0.6102)\tAcc@1 82.812 (82.812)\tAcc@5 98.438 (98.438)\n",
      " * Acc@1 78.310 Acc@5 89.580\n",
      "Epoch Time: 11.05 sec\n",
      "Pure training time: 233.14000000000001 sec\n",
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "confuse mode: False\n",
      "split mode: train\n",
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "confuse mode: False\n",
      "split mode: train\n",
      "Forgetting by Fine-tuneing:\n",
      "Forgetting by NegGrad:\n",
      "Forgetting by CFK:\n",
      "Forgetting by EUK:\n",
      "==> Bad Teacher Unlearning ...\n",
      "Epoch: [1][0/282]\tTime 0.182 (0.182)\tData 0.112 (0.112)\tLoss 4.9670 (4.9670)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/meghdad/unlearning/SelectiveForgetting/myenv/lib/python3.9/site-packages/torch/nn/_reduction.py:42: UserWarning: size_average and reduce args will be deprecated, please use reduction='sum' instead.\n",
      "  warnings.warn(warning.format(ret))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * Acc@1 94.222 Acc@5 99.953\n",
      "loss: 1.63\t train_acc: 94.22222137451172\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAG5CAYAAABoRvUVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB2VElEQVR4nO3dZ3hU1d6G8XvSE9LoJHSQpiCgNOmI0hELKHosIIgdUFGPvnoABREFLGBDBRQLKihNRIr0qlJUiii9IzU9mWTW+2HMkMkkkDozSZ7fuXLJLrPnP4uQPGettde2GGMMIiIiIsWUj6cLEBERESlMCjsiIiJSrCnsiIiISLGmsCMiIiLFmsKOiIiIFGsKOyIiIlKsKeyIiIhIsebn6QI8zWazcezYMcLCwrBYLJ4uR0RERHLAGENsbCzR0dH4+Fy676bEh51jx45RtWpVT5chIiIieXD48GGqVKlyyXNKfNgJCwsD7I0VHh5eoNe2Wq0sWbKELl264O/vX6DXlovUzu6hdnYPtbP7qK3do7DaOSYmhqpVqzp+j19KiQ876UNX4eHhhRJ2QkJCCA8P1z+kQqR2dg+1s3uond1Hbe0ehd3OOZmCognKIiIiUqwp7IiIiEixprAjIiIixZrCjoiIiBRrCjsiIiJSrCnsiIiISLFW4m89zyur1UpaWtplz/Hz8yMpKemy50reqZ3d43Lt7Ovrq9t3RcQrKezkUkxMDKdPnyY5Ofmy5xpjqFSpEocPH9ajKAqR2tk9ctLOgYGBlCtXrsDXrBIRyQ+FnVyIiYnh6NGjhIaGUq5cOfz9/S/5y9VmsxEXF0doaOhln9shead2do9LtbMxBqvVyoULFzh69CiAAo+IeA2FnVw4ffo0oaGhVKlSJUc9CDabjZSUFIKCgvRLuBCpnd3jcu0cHBxMWFgYR44c4fTp0wo7IgK2NCwH11L57AYsB8OhVnvw8XV7GQo7OWS1WklOTqZcuXIaKhHJhsViISIigqNHj2K1WjWHR6Qk2zkfFj+LX8wxmgEcfA/Co6HbeLjyJreWov8bnEPpEzL1w1vk0tL/jWiyuEgJtnM+fH0vxBxz3h9z3L5/53y3lqOwk0vq1RG5NP0bESnhbGmw+FnAZHHw332L/2s/z00UdkRERKTgHFzv2qPjxEDMUft5bqKwIyIiIgUn7mTBnlcAFHZERESk4FiTcnZeaMXCrSMD3Y0lxcLVV1+Nj48PBw4c8HQpIiIlkzGw5VNY9PRlTrTY78qq3totZYF6dsRDRo0ahcViYeXKlZ4uxeMsFgsdO3b0dBkiInmXHAvfPgALhkJaMlRsBFj+/cro3+1ur7p1vR317EixMG/ePEJDQz1dhohIyXP8N5g9EM78DRZfuP4FaDMcdi+035WVcbJyeLQ96Lh5nR2FHS/025HzjFu0m+d61OfqKpGeLqdIqFmzplbsFRFxJ2Pgl49h8fP23pzwynDbx1D9OvvxK2+C+j1J3beabWt+pEm7rvh5aAVlDWN5oW+3HGXDvjN8u+Wop0txsnLlSiwWC6NGjWL9+vV06dKFyMhIx7oqxhimTZtGmzZtCA8PJyQkhGbNmjFt2jSn63Ts2JHRo0cD0KlTJywWCxaLhRo1ajjOWbFiBffffz/16tUjNDSU0NBQmjVrxtSpU7Os7eqrr6ZWrVpO+zIOlX3xxRc0adKE4OBgoqKiGDZsGImJibn6/CtWrKB79+5ER0cTGBhIxYoVadeuXZY17d+/n8GDB1OtWjUCAwOJiopiwIABHDx40KU9AVatWuVoB4vFwowZM3JVm4iIWyVdsPfmfP+UPejU6QoPrb0YdNL5+GKqt+Vomesw1dt6JOiAenYKhDGGRKvr4kg2m43ElDT8UlIv+8ymo+cTOZ+QggUL87fbu/zmbz9Gr6ujMBgiQwKoHBmcrzqD/X0LZMG39evX88orr9CpUyeGDBnCoUOHMMbwn//8hy+//JI6depw1113ERAQwNKlSxk0aBA7d+5kwoQJAAwYMACw/4K/7777HCEnMjLS8R7jx4/n77//plWrVtxyyy2cP3+exYsX8+CDD/Lnn38yceLEHNc7ZcoUFi9eTJ8+fbj++utZvHgxb7/9NqdPn+bzzz/P0TW+//57evfuTWRkJH369CEqKop//vmH7du3M3PmTIYMGeI4d9OmTXTt2pX4+Hh69epFnTp1OHDgAJ9//jk//PADGzZsoFatWtSoUYORI0cyevRoqlev7mgXgCZNmuT484mIuNWxrfDNADh3AHz84IZR0OpR8OJnEyrsFIBEaxpX/u/HAr/u2fgU+r6/ocCut/OlroQE5P+vfOnSpUybNo2BAwc69n344Yd8+eWXDBw4kA8++MDxyICUlBT69u3LxIkTufPOO7n22msZMGAABw4cYNWqVQwYMCDLybnvvfceNWvWdNqXmppKjx49eOuttxg2bBjVqlXLUb3Lli3j119/pV69egCMHTuWJk2aMGvWLF5//XWio6Mve41p06ZhjGHFihU0btzY6diZM2ccf7ZarfTv3x+bzcbmzZtp2rSp49jatWvp2LEjw4YNY8GCBdSoUYNRo0YxevRox59FRLyWMbB5Kix5AdJSIKIa9J0GVZt7urLL8t4YJl7rmmuucQo6YO89KVWqFO+8847T88MCAgIYO3YsAF9++WWO3yNz0AHw8/PjoYceIi0tjRUrVuT4WsOGDXMEHbA/nfvOO+/EZrPx66+/5vg66a/NrGzZso4/L1y4kAMHDvD00087BR2Atm3b0qdPHxYtWkRMTEyu3ldExKMSz8FXd8MPz9iDTv1e8NDqIhF0QD07BSLY35edL3V12W+z2YiNiSUsPOyyw1gAO4/FZNmTM/uh67gyOv+Tb4P9C2astHlz52/uhIQEfv/9d6Kjoxk/frzL+VarFYDdu3fn+D1iY2OZMGECc+fOZe/evcTHxzsdP3bsUkuRO7v22mtd9lWpUgWA8+fPO/Zl1bMyfPhwIiMj6d+/P99++y2tWrXirrvuonPnzrRr145y5co5nb9x40YA/vzzzyyvd+LECWw2G3v27KFZs2Y5/gwiIh5z5Bf7/Jzzh8DHH7qMgZYPQhF6Dp5Xhp2//vqLF198kbVr13L27FmqVavGXXfdxYgRIwgJCXGct379ep555hm2bNlCeHg4t99+O6+88orbb0G2WCxZDg/ZbDZSA3wJCfDLUdgJ+jeMWCz23sL0/wb5+xbI8FNBqVjRedXLc+fOYYzh6NGjjonHWckcWLKTkpJCx44d2bJlC02bNuWee+6hbNmy+Pn5ceDAAT755BOSk5NzXG9Wd2n5+dnbM+OTubOqfcCAAURGRtKvXz/mzp3LpEmTeP/993nnnXewWCx06tSJiRMnOubYnD17FuCyc4Fy2hYiIh5jDGx4B5aNBFsqlK4BfadD5Ws8XVmuec9v0H8dPnyYFi1aEBERwWOPPUaZMmXYsGEDI0eO5Ndff2XevHkAbNu2jc6dO9OgQQMmTZrEkSNHmDBhAn/99Rc//PCDhz9F3pQNDaB8aCBRkUHc0bwqX/18mOPnkygbGuDp0pxknuScHiauvfZafvnll3xff968eWzZsoVBgwbx0UcfOR2bNWsWn3zySb7fIyvGZPWE3ov69OlDnz59iI2NZd26dXz77bd8/PHHdOvWjd27dxMZGeloiwULFtCrV69CqVNEpNAlnIW5D8OexfbtK/vATZMhKMKzdeWR14WdmTNncv78edauXctVV10FwJAhQ7DZbHz66aecO3eO0qVL8/zzz1O6dGlWrlzp+AVTo0YNHnjgAZYsWUKXLl08+THyJCoimLX/7USArw8Wi4W7WlQjJc1GoJ9nbtXLqbCwMBo0aMCuXbs4f/68011V2fH1tX+mjD0r6fbu3QvYw0Vma9asyV+xBSAsLIxu3brRrVs30tLSmDZtmuMOrJYtWwKwYcOGHIcdHx+fLNtBRMQjDm2E2YMg5gj4BkK3V6DZoCI1bJWZ101QTp+4mXmoJCoqCh8fHwICAoiJiWHp0qXcfffdTkMU9957L6GhoXz99ddurbkgBfpdvD3cYrF4fdBJN3ToUBISEnjggQeyHKLZv3+/03OrypQpA9h78jKrXr06YL97KaNVq1bx4YcfFmDVObd69eosA8mpU6cACAoKAuwBrVq1akyaNInVq1e7nG+1Wl0+V5kyZThy5EghVC0ikgs2G6yZBNN72INOmdoweBk0H1ykgw54Yc9Ox44dGT9+PIMGDWL06NGULVuW9evX89577zF06FBKlSrFunXrSE1NdZngGRAQQJMmTdi6dWu2109OTnaa75EerqxWq2MibVasVivGGGw2GzabLUefJX1YJP11RV36Z8jq8zzwwANs2LCBTz/9lHXr1tG5c2eio6M5efIkf/75J5s2beKzzz5z3C7eoUMHLBYLzz//PH/88QcRERFERkby6KOP0rNnT2rUqMFrr73G77//TsOGDfnzzz/5/vvvufnmm5kzZ45TDRmHnzLWlb4/q7+z9O2c/n0OHTqUY8eO0aZNG2rUqIHFYmHdunVs3ryZVq1a0bp1a2w2G/7+/nz99df07NmTDh06cP3119OwYUMsFgsHDx5k7dq1lC1blp07dzqu3alTJ7755hv69OlD06ZN8fX1pXfv3lx99dU5/rtxh5x+P9tsNowxWK1WRw+e5Fz6z6FL/TySgqG2ziD+NL7zH8Vn33IAbFfdSlr3iRAYBvlsn8Jq59xcz+vCTrdu3Xj55Zd55ZVXmD9/vmP///3f/zFmzBgAjh8/Dth7ezKLioq65FDHuHHjspyIumTJEqfJz5n5+flRqVIl4uLiSElJyfHnAfudRcVBQkICYA+MWd06/dZbb9GxY0c+/fRTFi5cSHx8POXLl6dWrVq8/PLLtGzZ0vG6KlWq8M477zBlyhSmTJlCcnIyVatW5Z577gFg7ty5/O9//2P9+vWsWrWK+vXrM3XqVCpUqMCcOXOyrMFmszntSw+1CQkJLucmJSU5/puT28CHDh3KwoUL2bZtG0uWLMHPz49q1aoxatQoBg0a5NSbVa9ePVavXs3kyZNZunQp69atIyAggOjoaHr06MFtt93m9J4vv/wyqamprF69moULF2Kz2ShbtqzTitLe5HLfzykpKSQmJrJ69WpSU1PdVFXxs3TpUk+XUGKU9LYuG7ebaw+8h7/1HGkWf36rcg+H/DvA8oKdNlDQ7Zz+OyknLOZyszI94LPPPuOzzz7jtttuo2zZsnz//fdMnz6dt99+m8cee4yZM2dy7733smnTJlq0aOH02nvvvZf58+c73VKcUVY9O1WrVuX06dOXfLZSUlIShw8fpkaNGo4hi8sxxhAbG0tYWFiBrFwsWVM7u0dO2zkpKYkDBw5QtWrVHP9bkYusVitLly7lxhtvdFqzSgpeiW9rWxo+69/EZ/V4LMaGKVuH1Fs/hgpXFujbFFY7x8TEUK5cOS5cuHDZZyN6Xc/OrFmzGDJkCHv27HGshXLrrbdis9l49tlnufPOOx0Lu2V1+3FSUlKWC7+lCwwMJDAw0GW/v7//Jf8S0tLSsFgs+Pj45Og2crg4VJL+Oikcamf3yGk7+/jYJ9hf7t+UXJraz31KZFvHnYI5g2H/Kvt247uw9JyAf0CpQnvLgm7n3FzL634zvPvuuzRt2tQRdNLddNNNJCQksHXrVsfwVfpwVkbHjx/P0fL/IiIiJdK+lfBeG3vQ8Q+Bm9+DW96DQgw6nuZ1YefkyZNZ3vWSPhEpNTWVhg0b4ufn57KmS0pKCtu2bdNDFEVERDKzpcGKV+DTmyH+FJRvAA+sgCZ3ebqyQud1Yadu3bps3bqVPXv2OO3/8ssv8fHx4eqrryYiIoIbbriBzz77zGmy5MyZM4mLi6Nfv37uLltERMR7xRyHT/vAqvGAgWvuhQd+ggr1PV2ZW3jdnJ2nn36aH374gXbt2vHYY49RtmxZFi5cyA8//MDgwYMdQ1Rjx46ldevWdOjQgSFDhnDkyBEmTpxIly5d6Natm4c/hYiIiJf4exl8+yAknIaAUOj1JlxdsjoFvK5np3379qxfv55rr72Wd999l+HDh7N3717Gjh3Le++95zjvmmuuYdmyZQQHB/PEE08wdepUBg0axOzZsz1YvYiIiJdIS4Vlo+Gz2+xBp2IjGLKqxAUd8MKeHYAWLVqwaNGiy57Xtm1b1q1b54aKREREipALR+yPfDi80b7d7H7oOg78S+ZyEF4ZdkRERCSP9vwI3z0IiecgIAxuehsa3urpqjxKYUdERKQ4SLPC8tGwfrJ9O6ox9JsBZWp5tCxvoLAjIiJS1J0/BN8MhKP/LsnS4kHo8jL4uS6iWxIp7IiIiBRluxbCvEcg6QIERUCfd6BBb09X5VUUdkRERIqi1BRY+j/Y9O+dypWvhb7ToXR1z9blhbzu1nPxblarlVGjRlGnTh0CAwOxWCzMnTvX02WJiJQsZ/fDtC4Xg851j8HAxQo62VDYkVyZOHEio0ePJjo6mhEjRjBy5Ejq1y9aK3AeOHAAi8XCgAEDPF2Kw8qVK7FYLIwaNcrTpYiIt9sxFz5oD8e2QnBpuHMWdB0LfgGersxraRhLcmXhwoWEhoaydOlSAgL0D0tExG2sSbDk/+Dnj+zbVVvCbR9DZFXP1lUEKOx4G1saHFwPcSchtCJUbw0+vp6uyuHYsWOULVtWQUdExJ3O7IVv7oMTv9u32wyH618AX3+PllVUaBjLm+ycD282hE96wZxB9v++2dC+38NGjRqFxWJh//79HDx4EIvFgsVioUaNGo5zpk+fTsuWLQkNDSU0NJSWLVsyY8YMl2tlHLJZv349Xbp0ITIyEovF4jjn9OnTDBkyhAoVKhASEkLz5s357rvvmDFjBhaLJcvr/vbbb/Tv35+oqCgCAgKoXr06jz/+OGfOnHGcM2PGDGrWrAnAJ5984vgcFouFlStXXrYdbDYbH330ES1atKBMmTIEBwdTpUoVevfuneXrV69eTe/evSlXrhyBgYHUqVOHF154gYSEBKe27dSpEwCjR492qunAgQOXrUlEirnfZ9uHrU78DiFl4T9z4MbRCjq5oJ4db7FzPnx9L2Cc98cct++//VO48iaPlAbQsWNHAN58800Ahg8fDkBkZCQAQ4cOZfLkyVSuXJlBgwYBMGfOHAYOHMjWrVt56623XK65fv16XnnlFTp16sSQIUM4dOgQAHFxcXTo0IGdO3fSunVr2rdvz5EjR+jfvz9du3bNsr5FixZx//334+PjQ58+fahatSo7d+5kypQp/Pjjj2zatInSpUvTpEkThg0bxltvvUXjxo25+eabHdfIGNyy89xzz/Haa69Ru3Zt7rrrLsLCwjh69Chr165l2bJljnYCeO+993j00UeJjIykd+/eVKhQgV9++YWxY8eyYsUKVqxYQUBAAB07duTAgQN88skndOjQweka6e0rIiWQNRF+eBa2fGLfrt4GbvsIwqM9W1dRZEq4CxcuGMBcuHDhkuclJiaanTt3msTERNeDNpsxyXEuX2mJMebcqaMmLTEmy+OOr8QLxkyoZ8zI8Gy+IoyZWN9+3qWuc7kvmy3f7VW9enVTvXp1p32rVq0ygGnQoIE5f/68Y//Zs2dN3bp1DWBWr17t2L9ixQqDPdWZadOmubzHCy+8YAAzZMgQp/3Lli1zvG769OmO/adOnTJhYWGmcuXK5sCBA06v+fLLLw1gHnvsMce+/fv3G8Dcd999uf78ZcqUMdHR0SY+Pt7l2JkzZxx/3rFjh/Hz8zONGzc2p0+fdjpv3LhxBjATJkxw7Etvk5EjR+a6JndJS0sz586dM2lpaZc875L/VuSyUlJSzNy5c01KSoqnSyn2vLqtT/1pzDutLv4OWP6yMalWT1eVJ4XVzjn9/W2MMerZKQjWBHjFNWn7AJEF8gYGYo7Bq/mchPb8MQgoVSAVZfTJJ/b/1zFq1CgiIiIc+0uXLs3IkSP5z3/+w4wZM2jXrp3T66655hoGDhzocr3PPvuMgIAAXnrpJaf9nTt3pkuXLixZssRp/8yZM4mNjWXy5MlUr+5822X//v15/fXXmTVrFpMnT87X50wXEBCAr6/rPKoyZco4/vzBBx+QmprK5MmTKVu2rNN5zzzzDJMmTeLLL7/kqaeeKpCaRKQY2fYlfP+k/XdLqQpw61So3cnTVRVpCjuSb1u3bgVwGn5Jlz4XZdu2bS7Hmjdv7rIvJiaGAwcOcOWVV1KxYkWX423atHEJOxs32p/qu3nzZvbv3+/ymqSkJE6fPs3p06cpV67cJT/LgQMHXOYDRUZGOobt+vfvz7vvvkvDhg3p378/nTp14rrrriM4ODjLmn788UeWL1/u8j7+/v7s3r37krWISAmTEg+LnoZtn9u3a7aHWz+CMNefhZI7CjsFwT/E3muSic1mIyY2lvCwMHx8LjEX/OB6+Lzv5d/nP7Ptd2flp85CEBMTg4+PD+XLl3c5VrFiRSwWCzExMVkey+paABUqVMjyvbJ6zdmzZwF49913L1lnfHx8jsLO6NGjnfZVr17dEXbeeustatasyfTp0xkzZgxjxowhKCiI22+/nYkTJzqun17T2LFjL/l+IiIAnNoF3wyAf3aDxQc6/Bfaj/Cqu3GLMoWdgmCxZD08ZLOBf5r92KXCTu3r7RPOYo7jMkHZ/gb247Wv98pv/PDwcGw2G//8849LSDl16hTGGMLDw11el/Huq4zXSn9dVk6ePJnta7Zv387VV1+d6/oz6tixI8Zk9Xdg5+fnx4gRIxgxYgTHjh1j1apVTJ8+nU8//ZQTJ07w448/OtUUExNDWFhYvmoSkWLMGNg6ExY9A6mJEFrJPgm5ZrvLv1ZyTLeeewMfX+g2/t+NzAHg3+1ur3pl0AFo2rQpQJa3Xqfva9KkSY6uFR4eTo0aNfj777+zDDzr16932deyZUsANmzYkKP3SJ9vk5aWlqPzsxMdHc2dd97J4sWLueKKK1i2bBmJiYlONaUPZ7mrJhEpQpJj4dshMP9xe9CpfT08tFZBpxAo7HiLK2+y314eHuW8Pzza47edX859990H2NeIyThcdeHCBceQUPo5OfGf//yHlJQURo4c6bR/5cqVjp6TjAYMGEBYWBgvvvgiO3bscDmekJDgFDpKly6NxWLh8OHDOa4JIDk5OcuwFR8fT1xcHP7+/o7hykceeQQ/Pz8ef/xxxy31GZ0/f94x1wkuTm7ObU0iUkSd+B2mdoTfvwaLL3T+n339nFDX6QCSfxrG8iZX3gT1e3r1CspZad++PY8//jiTJ0+mYcOG3HbbbRhjmDNnDkeOHGHo0KG0b98+x9d79tlnmTNnDu+//z5//PEH7dq148iRI3z99df07t2bBQsWOM2BKl++PB9++CEDBw6kcePGdOvWjfr165OcnMyBAwdYtWoVrVu3ZvHixQCEhobSvHlzVq9ezT333EOdOnXw8fHhnnvucbmbK6PExETatGlD3bp1ufbaa6lWrRpxcXEsXLiQEydOMGLECAIDAwFo2LAh7777Lg8//DD16tWjR48e1K5dm9jYWPbt28eqVasYMGAA77//PgD169cnOjqaWbNmERgYSJUqVbBYLDz++ONOd7iJSBFnDPw6HX74L6QlQ1g09J0G1a/zdGXFW4He9F4EFcg6O9nI6bokRUlW6+ykmzZtmmnevLkJCQkxISEhpnnz5lmuo5OTNWVOnTplBg0aZMqVK2eCgoLMtddea7799lszYcIEA5jvvvvOcW56O+/cudMMGjTIVK9e3QQEBJjSpUubRo0amaFDh5rNmzc7Xf/PP/80PXr0MJGRkcZisRjArFix4pKfPSUlxYwfP9506dLFVKlSxQQEBJiKFSua9u3bmy+++MLYsljHaPPmzaZ///4mOjra+Pv7m3LlyplrrrnG/Pe//zW7du1yOnfjxo2mQ4cOJiwszLGe0P79+y9ZkztpnR338Oq1X4oZt7d14gVjvr7v4hpqn/UzJu70ZV9W1HnDOjsWYy4xG7MEiImJISIiggsXLmQ5iTZdUlIS+/fvp2bNmgQFBeXo2jabjZiYGMLDwy99N5bk2N13383nn3/Ozp07adCgAaB2dpectnNe/q3IRVarlUWLFtGjRw/8/fU4gMLk1rY+thW+GQjn9oOPH3QeCdc9dumbV4qJwmrnnP7+Bg1jiZc6fvw4UVHO85dWrVrFrFmzqFevniPoiIh4NWNg81RY8gKkpUBENfuwVVXXdcak8CjsiFfq0aMHwcHBNGnShFKlSrFz504WL16Mr69vga2ELCJSqBLPw/zHYNcC+3a9nnDzOxBc2qNllUQKO+KV7rvvPj7//HNmzZpFbGys42Gazz33nOO2bhERr3XkV5g9AM4fAh9/6PIytHzIvi6buJ3Cjnil4cOHO1YtFhEpMoyBDe/AspFgS4XI6tBvOlS+1tOVlWgKOyIiIgUh4SzMfQT2/GDfvrIP3DQZgrR8hKcp7IiIiOTXoU0w+36IOQK+AdD1FWg+WMNWXkJhR0REJK9sNlj/Nix/CUwalKkF/WZAVGNPVyYZKOyIiIjkRfxp+O4h+HupfbthX+j9JgTq4b/eRmFHREQktw6sgzmDIPY4+AVB9/FwzX0atvJSCjsiIiI5ZUuDNZNg5StgbFCurn3YquJVnq5MLkFhR0REJCfiTsG3D8C+lfbtxndCjwkQGOrRsuTyFHZEREQuZ98qe9CJOwn+IfaQ0/Q/nq5KckhhR0REJDu2NFg1Hla9Bhgo38A+bFWhvqcrk1wo/o9blSKhY8eOWDJN7Fu5ciUWi4VRo0bl6zoFrUaNGtSoUaNQ30NEvEDMcfi0jz3sYKDpPfDATwo6RZDCjkgmAwYMwGKxcODAAU+X4nEWi4WOHTt6ugwR9/t7ObzfFg6sAf9ScOuH0GcKBIR4ujLJAw1jiddq0aIFu3btoly5cp4uxcny5cs9XYKIFJa0VPudVmsmAQYqNrQPW5Wr4+nKJB/Us+OFNhzbQJ+5fdhwbIOnS/GokJAQ6tev73Vhp3bt2tSuXdvTZYhIQbtwFD7pBWsmAgaa3Q+DlynoFAMKO17GGMNbW95i34V9vLXlLYwxni4JgDVr1mCxWLj//vuzPH7q1Cn8/f1p06YNAL/++iuPPfYYDRs2JCIiguDgYBo1asSrr76K1WrN0Xteas7O2rVr6dChA6VKlaJ8+fLcf//9HD58OMvrHDt2jJEjR9KqVSsqVKhAYGAgNWrU4JFHHuHUqVNO59aoUYNPPvkEgJo1a2KxWFyGcrKbsxMfH8/IkSOpX78+QUFBlClThp49e7Ju3TqXc0eNGoXFYmHlypV88cUXNGnShODgYKKiohg2bBiJiYk5aqN0K1asoHv37kRHRxMYGEjFihVp164dU6dOdTl3//79DB48mGrVqhEYGEhUVBQDBgzg4MGDjnPS2x5g1apVWCwWfH19KV26NDNmzMhVbSJFwp4l9mGrQxsgIAz6ToNeb4B/sKcrkwKgYawCYIwhMdX1l5PNZiMxNRE/qx8+PjnLlRuPbWTHmR0A7DizgxWHVtAqulWB1BnsF5znybtt27alRo0azJkzh3fffZegoCCn419++SWpqancc889AHz44YcsWLCA9u3b06NHDxISEli5ciXPPfccP//8M3PmzMnz51i+fDndu3fHx8eHO+64g6ioKJYuXUq7du0oXbq0y/mrV69m4sSJdO7cmZYtW+Lv78/WrVt57733+PHHH9myZQsREfanEg8fPpwZM2awfft2hg0bRmRkJMBlJyQnJSVx/fXXs3nzZq655hqGDx/OyZMn+eqrr/jxxx/58ssv6devn8vrpkyZwuLFi+nTpw/XX389ixcv5u233+b06dN8/vnnOWqP77//nt69exMZGUmfPn2Iiorin3/+Yfv27cycOZMhQ4Y4zt20aRNdu3YlPj6eXr16UadOHQ4cOMDnn3/ODz/8wIYNG6hVqxY1atRg5MiRjB49murVqzNgwACMMSQnJ9OkSZMc1SVSFFhMKj7LR8HGKfYdUY2h73Qoq97b4kRhpwAkpibS8ouWhXLtYSuHFdi1Nt21iRD/vE2us1gs3H333YwZM4b58+dz++23Ox2fOXMmAQEBjv3PP/8877zzDr6+vo5zjDEMHjyYadOmsW7dOkcvUG7YbDaGDBlCamoqq1evpm3btthsNp599lkeffRRvvzyS5fXXH/99Zw4cYLQUOeFvz799FPuu+8+pkyZwv/93/8B9rCzbds2tm/fzvDhw3N819Vrr73G5s2b+c9//sPMmTMdoXLo0KG0atWKIUOG0K1bN8LCnJ+Zs2zZMn799Vfq1asHwNixY2nSpAmzZs3i9ddfJzo6+rLvPW3aNIwxrFixgsaNnR8+eObMGcefrVYr/fv3x2azsXnzZpo2beo4tnbtWjp27MiwYcNYsGABNWrUYNSoUYwePdrxZ5vNRkxMDOHh4TlqExGvd+EwbfeMxTdhr327xYPQ5WXwC/RsXVLgNIwlOZbea/PZZ5857d+1axe//vorPXr0oEyZMgBUq1bNKeiAPTA9+uijgP2XfF6sXbuWffv20atXL9q2bet07bFjx7q8J0CFChVcgk765wkPD89zLRl98skn+Pv78+qrrzr1njVt2pT77ruP8+fPM3fuXJfXDRs2zBF0AIKDg7nzzjux2Wz8+uuvuaohONi1u71s2bKOPy9cuJADBw7w9NNPOwUdsPfc9enTh0WLFhETE5Or9xUpknZ/j99HnSiTsBcTGA63z4QerynoFFPq2SkAwX7BbLprk8t+m81GbGwsYWFhlx3GMsYw8MeB/HnuT2zG5tjvY/GhXul6TO86Pd/rxwT75W/suW7durRo0YLFixdz+vRpx8Th9PCTHoYAUlJSmDJlCrNmzWL37t3ExcU5zT86duxYnmrYvn07AO3atXM5Vr16dapWrZrlLePffvstH3zwAVu2bOHcuXOkpaXlu5Z0MTEx7Nu3jwYNGlClShWX4506deLDDz9k27ZtTm0EcO2117qcn36N8+fPO/ZlNW9p+PDhREZG0r9/f7799ltatWrFXXfdRefOnWnXrp3LxO6NGzcC8Oeff2Z5vRMnTmCz2dizZw/NmjW73McWKZpSU2Dp/2DTe1iAcyG1CB34Df7lr/B0ZVKIFHYKgMViyXJ4yGazkeqXSoh/yGXDzrqj69h1dpfrNYyNXWd3se2fbbSpnPthn4J2zz33sHnzZr766iseffRRjDF8/vnnlC5dmp49ezrO69u3LwsWLKBu3brccccdVKhQAX9/f86fP89bb71FcnJynt7/woULgL23JisVK1Z0CTsTJ05kxIgRlC9fni5dulClShVHL8ibb76Z51rSpfeEVKxYMcvjUVFRTudllNWQkJ+f/Z9lxkA2evRol/MGDBhAZGQk/fr1Y+7cuUyaNIn333+fd955B4vFQqdOnZg4caJjjs3Zs2cBLjsXKD4+/pLHRYqss/th9kA4thWAtJYPsyapOd0jq3u4MClsCjtewBjD5K2TsWDB4Hr3lQULk7dOpnV060JfHfhy+vfvz5NPPslnn33Go48+yurVqzl48CAPPvgggYH27t+ff/6ZBQsW0LVrV77//nunoaWNGzfy1ltv5fn90ycSZ76LKt3JkyedtlNTU3n55ZeJiopi27ZtTiHJGMNrr72W51rSpQeWzO+d7sSJE07n5cXl7srr06cPffr0ITY2lnXr1vHtt9/y8ccf061bN3bv3k1kZKTj/RcsWECvXr3yXItIkbRzHsx7DJJjICgSbnkfW60bMIsWeboycQPN2fECVpuVE/Ensgw6AAbDifgTWG05u2W7MJUrV45u3bqxceNG/v77b8cQ1t133+04Z+9e+2S/nj17usyhWbNmTb7eP30CblbXOXjwoMvt56dPn+bChQtcd911Lr1Bv/zyS5a3eKfXnLFn5VLCw8OpVasWf//9N0ePHnU5vnLlSgC33MUUFhZGt27dmDp1KgMGDODkyZNs2mQfYm3Z0j6JfsOGnK/f5OPjk+N2EPFK1iT4fgR8fa896FRpAQ+thXrdPV2ZuJHCjhcI8A1gVq9ZfNXrq2y/ZvWaRYBvgKdLBS7Ozfnoo4/45ptvqFmzptOdVdWr27uE165d6/S6HTt2MG7cuHy9d9u2balZsyYLFy50ur4xhv/7v/9z+cVcoUIFgoOD2bJlCwkJCY79586d4/HHH8/yPdInWWe3bk9W7rvvPqxWK88995xTL8xvv/3GjBkziIiI4Oabb87x9XJj9erVWQaS9N6v9GUC+vTpQ7Vq1Zg0aRKrV692Od9qtbr8nZUpU4YjR44UQtUibnBmL3x8I/z8oX27zTAYuAgiq3q2LnE7DWN5iUqlKlGpVCVPl5EjvXv3JiIigkmTJmG1Whk6dKjT8FqLFi1o0aIFX3/9NcePH6dVq1YcOnSI+fPn07NnT2bPnp3n9/bx8WHq1Kn06NGDG264wbHOzrJlyzh16hRXX301v/32m9P5jzzyCBMnTqRx48b07t2bmJgYfvjhB6pXr57lrd3XX389EyZMYMiQIdx2222UKlWK6tWru0wuzuiZZ57h+++/Z+bMmezatYvOnTtz6tQpvvrqK1JTU/nwww9dbjsvKEOHDuXYsWOOtZAsFgtr165l8+bNtGrVynHXWmBgILNnz6Z79+506NCB66+/nkaNGmGxWDh48CBr1qyhbNmy7N6926ktvv76a26++WaaNGlCamoqffv21Vo74v1+nw0LhkNKLISUhVs+gDo3eroq8RRTwl24cMEA5sKFC5c8LzEx0ezcudMkJibm+NppaWnm3LlzJi0tLb9lep3BgwcbwADmzz//dDl+6tQpc//995vo6GgTFBRkGjVqZN555x2zb98+A5j77rvP6fwOHTqYzN+OK1asMIAZOXKky/VXr15t2rdvb4KDg02ZMmXMzTffbPbv35/ldVJSUszYsWNNnTp1TGBgoKlWrZp56qmnTGxsrKlevbqpXr26y/Vfe+01U6dOHePv728A06FDB8ex7F4TFxdnXnzxRVO3bl0TEBBgIiMjTffu3c2aNWtczh05cqQBzIoVK1yOTZ8+3QBm+vTpLseyMmvWLHP77beb2rVrm5CQEBMREWEaN25sxo8fb2JjY13OP3LkiBk2bJijPcLDw02DBg3M4MGDzfLly53OPX78uLn99ttNuXLljI+PjwHMxx9/fMl68vJvRS5KSUkxc+fONSkpKZ4upWhKSTBm/lBjRobbvz7uZsyFo1mfqrZ2i8Jq55z+/jbGGIsxXvI8Ag+JiYkhIiKCCxcuXHICaVJSEvv376dmzZouqwdnJ+MibDldQVlyT+3sHjlt57z8W5GLrFYrixYtokePHvj7+3u6nKLlnz3wzQA4tQOwQPsR0OG/4Jv1IIba2j0Kq51z+vsbNIwlIiLFwfZZsPBJsMZDqfJw61Sofb2nqxIvobAjIiJFV0o8LHoGtv27snuNdnDbRxBWNOZAinso7IiISNF0apd92Oqf3WDxsQ9ZtR8BPq6PjZGSTWFHRESKFmNg62ew6GlITYTQinDbx1DT9TEyIqCwIyIiRUlyHHz/JPz2lX279vVwy1QILe/ZusSrKeyIiEjRcOIP+OY+OPO3fdiq0/9B2ydBd2HKZSjs5FIJv1Nf5LL0b0QKnDHw63T44b+Qlgxh0dD3Y6je2tOVSRGhsJND6c9Lslqtjidmi4grq9X+DLfMz0UTyZOkGFgwDHZ8a9+u0wVufh9KlfVsXVKkKOzkkL+/P4GBgVy4cIGwsDCPP31cxBsZY7hw4QKBgYFapE3y79g2mD0Qzu4DHz/oPBKue0zDVpJrCju5UK5cOY4ePcqRI0eIiIjA39//kqHHZrORkpJCUlKSVvYtRGpn97hUOxtjsFqtXLhwgbi4OCpXruyhKqVYMAY2fwhL/g/SUiCiKvSdBlVbeLoyKaIUdnIhfTnq06dPc/To0cueb4whMTGR4OBg9QQVIrWze+SknQMDA6lcufJll24XyVbieZj/OOyab9+u1wP6vAMhZTxalhRtCju5FB4eTnh4OFarlbS0tEuea7VaWb16Ne3bt1eXfiFSO7vH5drZ19dX7S/5c+RXmD0Azh8CH3/o8jK0fAj0f2IknxR28sjf3/+yP9h9fX1JTU0lKChIvwQKkdrZPdTOUmiMgY3vwtKRYLNCZHXoNx0qX+vpyqSYUNgRERHPSTgL8x6FPxfZtxvcBDdNhuBIj5YlxYvCjoiIeMbhzfDNQIg5Ar4B0PUVaD5Yw1ZS4BR2RETEvWw2WP82LH8JTBqUqQX9ZkBUY09XJsWU196nu2XLFm666SbKlClDSEgIDRs25O2333Y6Z/369bRt25aQkBAqVarE0KFDiYuL81DFIiJyWfFn4IvbYdlIe9BpeBsMWaWgI4XKK3t2lixZQu/evWnatCkvvvgioaGh7N27lyNHjjjO2bZtG507d6ZBgwZMmjSJI0eOMGHCBP766y9++OEHD1YvIiJZOrgeZg+C2GPgFwTdx8M192nYSgqd14WdmJgY7r33Xnr27Mns2bOzXSTu+eefp3Tp0qxcudKxpkeNGjV44IEHWLJkCV26dHFn2SIikh2bDdZOhBWvgLFB2Tr2YatKDT1dmZQQXjeM9cUXX3Dy5EnGjh2Lj48P8fHx2Gw2p3NiYmJYunQpd999t9PiZffeey+hoaF8/fXX7i5bRESyEncKPrsVfhpjDzpX94chKxV0xK28rmdn2bJlhIeHc/ToUW6++Wb27NlDqVKluOeee3jjjTcICgri999/JzU1lWbNmjm9NiAggCZNmrB169Zsr5+cnExycrJjOyYmBrAvmJb+AMOCkn69gr6uOFM7u4fa2T2KUztbDqzBd+6DWOJPYfyCSes2HnP1nfZhKy/4fMWprb1ZYbVzbq7ndWHnr7/+IjU1lT59+jBo0CDGjRvHypUrmTx5MufPn+fLL7/k+PHjAERFRbm8PioqijVr1mR7/XHjxjF69GiX/UuWLCEkJKTgPkgGS5cuLZTrijO1s3uond2jSLezsVHvxDzqnZiLBUNMUGV+qfEYsUcj4aj3zaks0m1dhBR0OyckJOT4XK8LO3FxcSQkJPDQQw857r669dZbSUlJ4YMPPuCll14iMTERsD+HJ7OgoCDH8aw899xzPPnkk47tmJgYqlatSpcuXQr8eT5Wq5WlS5dy4403asXZQqR2dg+1s3sU+XaOPYHvvIfwObEWAFvj/xDcdRzt/Avn/0zmR5Fv6yKisNo5fWQmJ7wu7AQHBwNw5513Ou2/6667+OCDD9iwYYOjBybjcFS6pKQkxzWyEhgYmGVIysnjH/KqMK8tF6md3UPt7B5Fsp33/gTfDoH4f8C/FPR6A5/Gd3jf5NBMimRbF0EF3c65uZbXfQ9GR0cDULFiRaf9FSpUAODcuXOO4av04ayMjh8/7riGiIi4QVoqLH8ZZt5qDzoVG9onITe+w9OViQBeGHauvdb+4LejR4867T927BgA5cuXp2HDhvj5+fHLL784nZOSksK2bdto0qSJW2oVESnxLhyFT3rDmgmAgWsHwuBlUL6upysTcfC6sHP77bcD8PHHHzvt/+ijj/Dz86Njx45ERERwww038NlnnxEbG+s4Z+bMmcTFxdGvXz+31iwiUiLtWQLvt4VD6yEgDPpOg95vgn/2UwlEPMHr5uw0bdqU+++/n2nTppGamkqHDh1YuXIl33zzDc8995xjiGrs2LG0bt2aDh06MGTIEI4cOcLEiRPp0qUL3bp18/CnEBEpxtKs9udarf/3ET5RjaHvdChb27N1iWTD68IOwPvvv0+1atWYPn063333HdWrV+eNN95g+PDhjnOuueYali1bxrPPPssTTzxBWFiY41Z1EREpJOcPw+z74chm+3aLIdBlDPi53vgh4i28Muz4+/szcuRIRo4cecnz2rZty7p169xUlYhICbd7Ecx9GJLOQ2AE9JkMV/bxdFUil+WVYUdERLxIagosGwUb37FvR18D/aZD6RqerEokxxR2REQke+cOwDcD4dgW+3arR+GGUeAX4MmqRHJFYUdERLK2cz7MewySL0BQJNz8HtTv4emqRHJNYUdERJxZk2Dpi7B5qn27Sgvo+zFEVvNsXSJ5pLAjIiIXndkL3wyAE7/Zt9sMg+tfBF89TkGKLoUdERGx+2MOzB8GKbEQXAZu+QDqdvF0VSL5prAjIlLSWRNh8XPw63T7drXWcNtHEFHZs3WJFBCFHRGRkuz0X/Zhq5N/ABZo9xR0fA589etBig99N4uIlFTbv4KFT4A1HkqVh1unQu3rPV2VSIFT2BERKWlSEuCHp2HrZ/btGu3sw1ZhlTxbl0ghUdgRESlJTu2Gb+6Df3YDFuj4X2j/NPj4eroykUKjsCMiUhIYA9s+h+9HQGoihFa09+bUbO/pykQKncKOiEhxlxwH3z8Fv82yb9fqZJ+fE1rBs3WJuInCjohIcXbiD5g9EE7vAYsPdPo/aPsk+Ph4ujIRt1HYEREpjoyBX2fA4v9CahKERdsf+VC9tacrE3E7hR0RkeImKQYWDreviAxwxY321ZBLlfVoWSKeorAjIlKcHN9uXyTw7D6w+MINI+G6xzVsJSWawo6ISHFgDPz8Efz4PKSlQERV6DsNqrbwdGUiHqewIyJS1CWehwVDYec8+3a9HtDnHQgp49GyRLyFwo6ISFF29Ff4ZiCcPwg+/nDjS9DqYbBYPF2ZiNdQ2BERKYqMgY3vwdL/gc0KkdWg3wyofK2nKxPxOgo7IiJFTcJZmPcY/Pm9fbtBb7hpCgRHerQsEW+lsCMiUpQc/tm+SOCFw+AbAF1fgeaDNWwlcgkKOyIiRYHNBhsmw/KXwJYKpWvah62im3i6MhGvp7AjIuLt4s/A3IfgryX27atuhd5vQVC4Z+sSKSIUdkREvNnB9TB7EMQeA99A6D4erh2gYSuRXFDYERHxRsYGqyfAilfApEHZOvZhq0oNPV2ZSJGjsCMi4mUCrDH4zroD9q2w77j6Dug5CQJDPVuYSBGlsCMi4kUsB9fSafcL+KSeB79g6DkBmvxHw1Yi+aCwIyLiDWxpsPp1fFeNx8/YMOXqYbn9E6jQwNOViRR5CjsiIp4WexK+HQz7V2MBDpZpR/TAz/AvFenpykSKBYUdERFP2rsCvn0A4v8B/1Kkdn+dbYdDiQ4o5enKRIoNH08XICJSIqWlwvKXYeYt9qBT4SoYshLT6HZPVyZS7KhnR0TE3WKOwZzBcHCdffvagdBtHPgHg9Xq2dpEiiGFHRERd/prKXz3ICScgYAw6P0mNOrr6apEijWFHRERd0izwk8vw7q37NuVrrYvEli2tkfLEikJFHZERArb+cMwZxAc3mTfbv4AdBkD/kGerUukhFDYEREpTH/+AN89BEnnITAC+kyGK/t4uiqREkVhR0SkMKSmwPLRsGGKfTv6Gug7DcrU9GxdIiWQwo6ISEE7dwBm3w9Hf7Vvt3oEbhgNfgEeLUukpFLYEREpSDvnw7zHIPkCBEXAze9B/Z6erkqkRFPYEREpCKnJsOQF2DzVvl2luX3YKrKaZ+sSEYUdEZF8O7MXZg+E49vt222GwfUvgq+/Z+sSESAfYeell16iZs2a3HPPPQVZj4hI0fLHtzB/KKTEQnAZuOUDqNvF01WJSAZ5fjbWmDFj+P333wuyFhGRosOaCAufsPfopMRCtevgobUKOiJeKM89O9WqVeP8+fMFWIqISBFx+i/4ZgCc/AOwQLsnoePz4KuZASLeKM//Mvv378+nn37KhQsXiIiIKMiaRES8129fw4LhYI2HkHJw61S4orOnqxKRS8jzMNaLL77I1VdfzfXXX8/333/PqVOnCrIuERHvkpJgv6X82wfsQadGO3h4nYKOSBGQ556dkJAQAIwx3HTTTdmeZ7FYSE1NzevbiIh43qnd9mGrf3YBFujwLHR4Bnx8PV2ZiORAnsNOu3btsFgsBVmLiIj32fo5LBoB1gQIrQi3fgi1Oni6KhHJhTyHnZUrVxZgGSIiXiY5zh5ytn9p367V0R50Qit4tCwRyT3dOiAiktnJHfZhq9N7wOIDnZ6Htk+BT56nOYqIBxVI2Dl69Cjbtm0jJiaG8PBwmjRpQuXKlQvi0iIi7mMMbPkEfngWUpMgLApu+xhqtPF0ZSKSD/kKO3///TcPP/wwP/30k8uxzp078+6773LFFVfk5y1ERNwjOdZ+S/kfs+3bV9wIt7wPpcp5tCwRyb88h53Dhw/Ttm1bTp06Rf369Wnfvj1RUVGcOHGC1atXs2zZMtq1a8fmzZupWrVqQdYsIlKwjm+3D1ud3QcWX+j8P2g9VMNWIsVEnsPO6NGjOXXqFO+++y4PPvigy51ZH3zwAQ8//DAvvfQSH374Yb4LFREpcMbAzx/Bj/8HackQXsX+pPJqLT1dmYgUoDyHnR9//JHevXvz0EMPZXn8wQcfZNGiRfzwww95Lk5EpNAkXYD5j8POefbtut3h5nchpIxn6xKRApfnPtpTp07RsGHDS57TsGFD/vnnn7y+hYhI4Ti6Bd5vZw86Pv7Q9RW480sFHZFiKs89O+XLl2fnzp2XPGfnzp2UL18+r28hIlKwjIFN78OSF8Fmhchq0HcGVLnW05WJSCHKc89O165dmT9/Ph9//HGWx6dNm8aCBQvo1q1bnosTESkwiefgq7th8X/tQadBb3hwjYKOSAmQ556dkSNHsmDBAoYMGcKbb75Jhw4dqFixIidPnmT16tXs2LGDcuXKMXLkyIKsV0Qk9w7/DLPvhwuHwDcAuoyFFg+AHnkjUiLkOexUq1aNtWvX8tBDD7Fy5Up27NjhdLxTp0689957uu1cRDzHZoMNU2D5aLClQuma0G8GRDfxdGUi4kb5WlSwbt26/PTTTxw+fNhlBWWFHBHxqISz8N1D8NeP9u2rboXeb0FQuGfrEhG3y3PYuf7662nTpg0vv/wyVatWVbgREe9xcAPMGQQxR8E3ELq/CtcO1LCVSAmV5wnKmzZtIi0trSBrERHJH5sN1kyEGT3tQafsFfDAcmh2v4KOSAmW556d+vXrc/DgwYKsRUQk7+L+ge8ehL3L7dtX3wE9J0FgqGfrEhGPy3PPzuOPP868efMuu9ZOfo0dOxaLxZLlAobr16+nbdu2hISEUKlSJYYOHUpcXFyh1iMiXujAWni/rT3o+AXDTVPglg8UdEQEyEfPTq1atejYsSOtWrXiwQcfpHnz5lSsWNHlGVkA7du3z9N7HDlyhFdeeYVSpUq5HNu2bRudO3emQYMGTJo0iSNHjjBhwgT++usvPaJCpKSwpcHqCbDqVTA2KFcPbv8EKjTwdGUi4kXyHHY6duyIxWLBGMPEiROzDDnp8jq3Z8SIEbRq1Yq0tDROnz7tdOz555+ndOnSrFy5kvBw+90VNWrU4IEHHmDJkiV06dIlT+8pIkVE7En4djDsX23fbnI39HgNAlz/z5GIlGx5Djv/+9//Lhlw8mv16tXMnj2brVu38vjjjzsdi4mJYenSpTzxxBOOoANw77338sQTT/D1118r7IgUZ3tXwLdDIP4U+JeCXpOgcX9PVyUiXirPYWfUqFEFWIaztLQ0Hn/8cQYPHkyjRo1cjv/++++kpqbSrFkzp/0BAQE0adKErVu3Znvt5ORkkpOTHdsxMTEAWK1WrFZrAX0CHNfM+F8pHGpn9/CKdral4rP6dXzWTcKCwVS4ktRbPoZydaCY/P17RTuXEGpr9yisds7N9fIcdnx9fenfvz+ff/55Xi+Rrffff5+DBw+ybNmyLI8fP34cgKioKJdjUVFRrFmzJttrjxs3jtGjR7vsX7JkCSEhIXms+NKWLl1aKNcVZ2pn9/BUOwelnOXag+9RLu5PAA6U7cTvUf/Btvkv4C+P1FSY9P3sPmpr9yjodk5ISMjxuXkOO+Hh4YWykOCZM2f43//+x4svvpjtE9MTExMBCAwMdDkWFBTkOJ6V5557jieffNKxHRMTQ9WqVenSpYvTkFhBsFqtLF26lBtvvBF/f/8CvbZcpHZ2D0+2s2Xvcnznv4wl4QwmoBRpPd6g8lW3UtmtVbiHvp/dR23tHoXVzukjMzmR57DTokULtm/fnteXZ+uFF16gTJkyLvN0MgoODgZwGo5Kl5SU5DielcDAwCxDkr+/f6F9sxfmteUitbN7uLWd06ywYiysfcO+XakRln6f4Fe2tnve34P0/ew+amv3KOh2zs218jVnp2PHjnz66afce++9eb2Mk7/++oupU6fy5ptvcuzYMcf+pKQkrFYrBw4cIDw83DF8lT6cldHx48eJjo4ukHpExIMuHLE/qfzwJvt28wegyxjwD/JsXSJS5OQ57CxdupSOHTsycOBAJk+enO06OxaLhRdffDFH1zx69Cg2m42hQ4cydOhQl+M1a9Zk2LBhjB49Gj8/P3755Rduv/12x/GUlBS2bdvmtE9EiqA/F8PchyDxHASGw02T4aqbPV2ViBRRBXI31q+//sqvv/6a5Xm5CTsNGzbku+++c9n/wgsvEBsby1tvvUXt2rWJiIjghhtu4LPPPuPFF18kLCwMgJkzZxIXF0e/fv1y/4FExPNSU2D5aNgwxb4d3RT6TocyNT1bl4gUaXkOOytWrCjIOgAoV64cN998s8v+N998E8Dp2NixY2ndujUdOnRgyJAhHDlyhIkTJ9KlSxe6detW4LWJSCE7dxBmD4Sj//4fp1aPwA2jwM91jp2ISG7kOex06NChIOvItWuuuYZly5bx7LPP8sQTTxAWFsagQYMYN26cR+sSkTzYtQDmPQpJFyAoAm5+D+r39HRVIlJM5DnsAKSmpjJ58mS+/PJLdu/eTUJCAqmpqYD92VVTp05l+PDh1K1bN19Frly5Msv9bdu2Zd26dfm6toh4UGoyLHkRNn9g367SHPpOg8hqnq1LRIqVPIedxMREunTpwvr16ylXrhzh4eHEx8c7jtesWZPp06dTpkwZxowZUyDFikgxcnYffDMQjm+zb7ceCp3/B766BVhECpZPXl/4yiuvsG7dOsaNG8eJEycYPHiw0/GIiAg6dOjAjz/+mO8iRaSY2fEdfNDBHnSCy8BdX0OXlxV0RKRQ5Lln56uvvqJTp04888wzAFk+FLRWrVqXfE6ViJQw1iT48Xn45WP7drXr4LaPIaI4roUsIt4iz2Hn0KFD3HLLLZc8JywsjAsXLuT1LUSkODn9N3wzAE7+bt9u+yR0+j/wzdfUQRGRy8rzT5mwsDBOnTp1yXP27t2b7fOtRKQE+e0bWDgcUuIgpBzc+gFccYOnqxKREiLPc3ZatWrFggULOH/+fJbHDx8+zKJFi2jfvn1e30JEirqUBJj/OHw72B50arSDh9Yq6IiIW+U57Dz99NOcO3eOzp07s27dOsct5wkJCSxfvpyuXbuSmprq9IRxESlB/vkTPuoMWz4FLNDhWbh3HoRHeboyESlh8jyM1b59e6ZMmcKwYcOcem/SH93g6+vLu+++y7XXXpv/KkWkaNn2BXz/FFgTILQi3Poh1PLsQqQiUnLla2bgww8/TMeOHXn//ffZtGkTZ8+eJTw8nJYtW/LII49w1VVXFVSdIlIUpMTbQ872L+3btTrag05oBY+WJSIlW75vg2jQoAFvvfVWQdQiIkXZyR32u61O7wGLD3R63n7HlY+vpysTkRJO93yKSP4YY5+X88MzkJoEYVH2tXNqtPF0ZSIigMKOiORHciwsfAJ+/8a+fcUNcMsHUKqcZ+sSEclAYUdE8ub4b/Zhq7N7weILnV+E1sPAJ883eYqIFAqFHRHJHWPg549g8fOQlgzhVexPKq/W0tOViYhkSWFHRHLMLy0B3+8Gw6559h11u8PN70JIGc8WJiJyCQo7IpIjlmNb6bj7f/iknAIfP7hhNFz3KGTxEGAREW+isCMil2YMbPoA3yUvUMpmxURUxdJvBlRp5unKRERyRGFHRLKXeA7mPQa7F2IBjkVcS/lBX+Efrgf8ikjRobAjIlk78gt8MxAuHALfANI6v8TPp6LoERzp6cpERHJF94iKiDNjYP1kmNbVHnRK14RBS7A1H6z5OSJSJKlnR0QuSjgLcx+GPYvt21fdAr3fgqAIsFo9W5uISB4p7IiI3aGNMPt+iDkKvoHQbRw0u1+9OSJS5CnsiJR0NhusexN+GgMmDcpeAf1mQKVGnq5MRKRAKOyIlGTxp+G7B+HvZfbtRrdDr0kQGObZukRECpDCjkhJdWAtzBkMscfBLxh6vAZN79GwlYgUOwo7IiWNLQ3WTISV48DYoFw9+7BVxSs9XZmISKFQ2BEpSWJPwrcPwP5V9u0m/4Eer0NAKc/WJSJSiBR2REqKfSthzgMQfwr8Q6DnJGhyp6erEhEpdAo7IsWdLQ1WjYdVrwEGKlwJ/T6B8nU9XZmIiFso7IgUZzHH7ZOQD661b19zH3QfD/7Bnq1LRMSNFHZEiqu/l8G3QyDhDASE2ldCbtTX01WJiLidwo5IcZOWCivGwNo37NuVGkHfGVDuCo+WJSLiKQo7IsXJhSMwexAc3mjfbj4YuowF/yDP1iUi4kEKOyLFxZ4f7ashJ56DwHC46W37gzxFREo4hR2Roi7NCstGwYYp9u2oJtBvOpSp5cmqRES8hsKOSFF27qD9SeVHf7Fvt3wYbhwNfoGerUtExIso7IgUVbsWwrxHIOkCBEVAn3ehQS9PVyUi4nUUdkSKmtRkWDoSNr1n367czD5sFVnNs3WJiHgphR2RouTsPvhmIBzfZt9u/Th0Hgm+/h4tS0TEmynsiBQVO76D+UMhOQaCS8MtH0Ddrp6uSkTE6ynsiHg7axL8+Dz88rF9u2or6PsxRFTxbF0iIkWEwo6INzuzF765D078bt9u+yR0+j/w1T9dEZGc0k9MEW/1+2xYMAxS4iCkHNz6AVxxg6erEhEpchR2RLyNNRF+eAa2fGrfrt4WbvsIwqM8W5eISBGlsCPiTf75E74ZAKd2Ahbo8Ay0f0bDViIi+aCfoCLeYtuX8P2TYE2AUhXgtg+hVkdPVyUiUuQp7Ih4Wko8LHoatn1u367ZAW79EMIqerYuEZFiQmFHxJNO7rQPW53+Eyw+0PF5aPck+Ph6ujIRkWJDYUfEE4yBrTNh0TOQmghhUfZJyDXaeroyEZFiR2FHxN2SY2Hhk/D71/btK26wr4Zcqpxn6xIRKaYUdkTc6cTv9mGrM3+DxRc6vwith4GPj6crExEpthR2RNzBGPhlGix+DtKSIbwy9J0G1Vp5ujIRkWJPYUeksCVdsK+EvOM7+3bdbnDzexBSxrN1iYiUEAo7IoXp2Fb4ZiCc2w8+fnDDaLjuUbBYPF2ZiEiJobAjUhiMgc1TYckLkJYCEdWg33So0szTlYmIlDgKOyIFLfEczHsMdi+0b9fvBX2mQHBpz9YlIlJCKeyIFKQjv8LsAXD+EPgGQJcx0GKIhq1ERDxIYUekIBgDG96BZSPBlgqla0C/GRDd1NOViYiUeAo7IvmVcBbmPgJ7frBvX3kz3PQ2BEV4tCwREbFT2BHJj0ObYPb9EHMEfAOh2zhodr+GrURE/rXpxCbeinmLsifK0raqZx6Jo2VbRfLCZoO1b8D07vagU6Y2DF4GzQcp6IiI/MsYw+Rtk/nH9g+Tt03GGOOROhR2RHIr/jR80Q+WjQKTBo36wYOrIOpqT1cmIuJV1h9bz86zOwHYeXYn64+t90gdGsYSyY0D62DOIIg9Dn5B0ON1aHqPenNEpEQxxpBiSyHeGk+8NZ4EawLx1njirHEX/5wSxyc7P8GCBYPBx+LD5K2TaR3dGoubf2Yq7IjkhC0N1kyCla+AsUG5eva7rSpe6enKRERyxGZsjiDi+Ep1DiuZvxJSs9lvTSDVpOb6/Xec2cH6Y+tpU7lNIX3KrCnsiFxO3Cn49gHYt9K+3fgu6DkBAkp5tCwRKd6y6z1xhJSUi3/OeCzBmkCcNc4lrCSmJhZKncF+wYT4hVDKvxSl/EsR4h9CKb9SbP9nOzEpMRguztPxVO+Owo7IpexbBXMGQ/wp8A+BnhOhyV2erkpEvJRT70lqpuCRqffkUr0m6T0uqbbc9Z7khK/F1x5I/EsR6h/qCCeOoPJvaHH68sv6WIhfCL4+vi7vse7oOlYfXZ1l+3iid8frws7PP//MJ598wooVKzhw4ABly5alVatWjBkzhrp16zqdu2vXLp544gnWrl1LQEAAPXv2ZNKkSZQvX95D1UuxYUuDVeNh1WuAgQpX2oetytfzdGUiUsBS0lKIS4tzmm+SVY9JdoEkY6Bxa+/JvyGkVECpXIWVQN/AQu1VMcYweetkx1ydzCxY3N6743VhZ/z48axbt45+/fpx9dVXc+LECaZMmcI111zDxo0badiwIQBHjhyhffv2RERE8MorrxAXF8eECRP4/fff2bx5MwEBAR7+JFJkxRy3D1sdWGPfvuZe6DYeAkI8W5eIAFn3nmQVSDL3nmTVyxKXEscLX71Q4DVm7D1JDyIuQSVD74hTL0umc0P8QvDz8bpf19my2qyciD+RZdABMBhOxJ/AarMS4Oue39Ve13pPPvkkX3zxhVNYueOOO2jUqBGvvvoqn332GQCvvPIK8fHx/Prrr1SrVg2AFi1acOONNzJjxgyGDBnikfqliPt7OXw7BBJOQ0Ao9HoTru7n6apEiryUtBSXEBKXEpflfBOnu3qymECbkJpQKDUG+QYR4h9CqH+oS++Jy7BPFmEl41dh9554swDfAGb1msXZpLMApKamsm7tOtq0bYOfnz12lAkq47agA14Ydlq3bu2yr06dOlx11VXs2rXLsW/OnDn06tXLEXQAbrjhBurWrcvXX3+tsCO5k5YKK8bC2kn27YqN7MNW5a7waFkinmIzNhJTE11uJ85qGMdlfxbzVQp77snlhnEyDwGF+ocSaAlk45qN9O7Sm/Dg8CLVe+LtKpWqRKVSlQCwWq3s99tPgzIN8Pf390g9ReJv1hjDyZMnueqqqwA4evQop06dolmzZi7ntmjRgkWLFmV7reTkZJKTkx3bMTExgP0vw2q1Fmjd6dcr6OuKs3y3c8wxfOcOwefwRgDSrhmI7caX7evo6O/OQd/P7pGfdk7vPUkfusn834whJfN/Mx8r7N6T9PDhFEIy7QvxDyHUz96Tkj6JNuN/g3yD8tV7YrVa2e2zmyBLECbNYE3T93ZhKKyfHbm5XpEIO59//jlHjx7lpZdeAuD48eMAREVFuZwbFRXF2bNnSU5OJjAw0OX4uHHjGD16tMv+JUuWEBJSOHMyli5dWijXFWd5aeeKF7bR9OBU/NPisPoEs63a/RwzLWHJT4VQYfGg7+eCYzM2rFhJNskkm2RSTIr9zySz7fttzvv+3Z/VvvTtNNIKvEYLFgIJJMASQJAliABLAIGWQAItgQRw8c+OfZYAAsm0bQl0XMPXkuHOHQNY//3KRhppxP77v8Ki72n3KOh2TkjIeSD3+rCze/duHn30Ua677jruu+8+ABIT7bPdswozQUFBjnOyOv7cc8/x5JNPOrZjYmKoWrUqXbp0ITw8vEBrt1qtLF26lBtvvNFjXXclQZ7aOc2Kz8ox+O57BwBbpcZw60c0KV2TJoVXapGm72c7a5rVaYjGpRfl316RjHNOMveYpB9LTE3MdhJnfmTXe5JlL0qmHpPM+/Lbe+LN9D3tHoXVzukjMznh1WHnxIkT9OzZk4iICGbPno2vr/3/EQQHBwM4DUelS0pKcjons8DAwCxDkL+/f6F9sxfmteWiHLfz+UP2J5Uf+dm+3fIhfG58CR8/1+8LcVXUvp8zzj3JdmG2rFaRzRhoMuy32gp+qMPH4uMIFyF+IVjjrUSXiyYsMCzL+SYuE2UzzVfR3JPcKWrf00VVQbdzbq7ltf8iLly4QPfu3Tl//jxr1qwhOjracSx9+Cp9OCuj48ePU6ZMmSwDjQi7v4e5D0PSBQiKgD7vQoNenq5KMrGmWbNcyv5S66BkPpaxN6Uwek8CfQMdQSQ0INTljpzcLNqWsffEarWyaNEienTuoV/AIgXEK8NOUlISvXv3Zs+ePSxbtowrr3R+/lDlypUpX748v/zyi8trN2/eTJMmTdxUqRQZqSmw9H+w6T37duVm0HcalK7u2bqKCWOMU+9J5mfvZLsOSjbHCrv3JPOy9i537mQMJFks2hbiH4K/j4KISFHhdWEnLS2NO+64gw0bNjBv3jyuu+66LM+77bbb+OSTTzh8+DBVq1YFYPny5ezZs4cnnnjCnSWLtzu7H2YPhGNb7dvXPQadR4JfyV54Mrvek+wCSWxyLPvj9jNv+Tyn+Snu6j3J8nbiTOuguKyPkmF+SrBfcLGdeyIil+Z1Yeepp55i/vz59O7dm7NnzzoWEUx39913A/D888/zzTff0KlTJ4YNG0ZcXByvv/46jRo1YuDAgZ4oXbzRjrkw/3FIjoHg0nDz+1Cvm6eryhOX3pP0OSVZLMyWk0XbUmwpeSvkZPaHLFic1jHJ3HuSm+fuqPdERAqK14Wdbdu2AbBgwQIWLFjgcjw97FStWpVVq1bx5JNP8t///tfxbKyJEydqvo6ANQmW/B/8/JF9u2or6PsxRFRxbxk2a/bzTTLcwZPlfJMMvS7p+wqj9yTAJ8BlzkmW80p8gti3ex8tm7YkPCg8y0Xb1HsiIt7I68LOypUrc3zuVVddxY8//lh4xUjRdGYvfDMATvxm3277BHT6P/C9fC9Bdr0neX3uTp57Ty4hY+9JTp+7ExoQmu/eE6vVyqL9i+heo7smzopIkeJ1YUckt6w2Kwm2BI7FHyNlz/fErx5PQloScaUrEH/tABLK1iB+x3SXUJK59yR9DRSbsRV4jQE+AVkP7+TwQYAZA416T0REckdhR9wuvfckuyGcjBNf41LiXJe6z9S74ug9mffvG5QPB/5dIHLvLNib+xqz6z3JyXN3sppEq7knIiKeo7AjOZJx7snlHgR4qYcBFmrvic1QytgICQinVFg0pQJCnXtSslgHJatJtOo9EREpXhR2CtGmE5t4K+Ytyp4oS9uqbd363pl7T7INJJdZtC399clprqtV55cFi9Oy9FkO7/x7PNtF2/5aTqllL1MqJR6/UhWw3DoVancq8FpFRKToUtgpJMYYJm+bzD+2f5i8bTJtqrS5bE9Bqi016+CR6tpjknnOSVZ3+RRG74m/j7/LvJLsFma73LEgvyB8LD55KyQlHhY9Dds+B+Cf0CuJHPQN/qXde7eViIh4P4WdQvLToZ/YeXYnADvP7uSJlU8QGRh5yTt63NF7kpNAkmUvy7/H/XNwR1OhO7XLfrfVP7vB4kNau2dYH1OfHqEVPV2ZiIh4IYWdQmCM4b3t7zntW35oeY5f7+/jn6NAktVzdzIfy1fvibcxBrZ+Zu/RSU2E0ErQ92NslVvCokWerk5ERLyUwk4hWH9sPX+e+9Nlf+9avbmy7JXZ39XjTb0n3iY5DhY+Ab9/bd+u3Rlu+QBCy4O14J+jJCIixYfCTgEzxjB562R8LD5Oc2Z8LD7su7CPsW3H6i6f3Drxu33Y6szfYPGF61+ANsPBp5j0WImISKHSb4sCtv7Yenac2eEyOdhmbOw4s4P1x9Z7qLIiyBj4ZRp82NkedMIrw4Dvod2TCjoiIpJj+o1RgNJ7dSxk3XNjwcLkrZMxpuCfb1TsJMXA7PvtQ1dpyVC3Gzy0Fqpf5+nKRESkiNEwVgGy2qyciD+R7cMaDYYT8Sew2qwE+Aa4uboi5Ng2+7DVuf3g4wc3jILrHgMN/4mISB4o7BSgAN8AZvWaxdmkswCkpqaybu062rRtg5+fvanLBJVR0MmOMbD5Q/vTytNSIKIa9J0GVZt7ujIRESnCFHYKWKVSlahUqhJgf0r0fr/9NCjTQE+JvpzE8zD/Mdi1wL5dvxf0mQLBpT1aloiIFH0KO+J5R36F2QPg/CHw8YcuY6Dlgxq2EhGRAqGwI55jDGx8F5aOBJsVSteAvtOh8jWerkxERIoRhR3xjISzMPcR2PODffvKPnDTZAiK8GxdIiJS7CjsiPsd2mS/rTzmCPgGQrdXoNkgDVuJiEihUNgR97HZYP3bsPwlMGlQpjb0mwFRV3u6MhERKcYUdsQ94k/Ddw/B30vt2436Qa83IDDMs3WJiEixp7Ajhe/gevuwVexx8AuC7q/BNfdq2EpERNxCYUcKj80GayfCilfA2KBcXfuwVcWrPF2ZiIiUIAo7UjjiTsG3Q2DfCvt247ug5wQIKOXZukREpMRR2JGCt28VfPsAxJ0E/xDoORGa3OXpqkREpIRS2JGCY0uDVa/BqvGAgfIN7MNWFep7ujIRESnBFHakYMSegDmD4cAa+/Y190K38RAQ4tm6RESkxFPYkfz7e7l9fk7CaQgIhV5vwtX9PF2ViIgIoLAj+ZGWCitfgTWTAAMVG9mHrcpd4enKREREHBR2JG8uHLUPWx1ab99udj90HQf+QZ6tS0REJBOFHcm9PUvguwch8SwEhMFNb0PDWz1dlYiISJYUdiTn0qz251qtf9u+HdUE+k2HMrU8WpaIiMilKOxIzpw/bH/kw5HN9u0WD0KXl8Ev0LN1iYiIXIbCjlze7kUw92FIOg9BEdDnHWjQ29NViYiI5IjCjmQvNQWWjYSN79q3K18LfadD6eqerUtERCQXFHYka+cOwDcD4dgW+/Z1j0HnkeAX4NGyREREckthR1ztnAfzHofkCxBcGm5+D+p193RVIiIieaKwIxdZk2DJC/Dzh/btqi3hto8hsqpn6xIREckHhR2xO7MXvhkAJ36zb7cZDte/AL7+nqxKREQk3xR2BH6fDQuGQ0oshJSFW6ZCnRs8XZWIiEiBUNgpyayJsPi/8OsM+3b1NnDbRxAe7dGyRERECpLCTkl1+i/7sNXJPwALtB8BHf4LvvqWEBGR4kW/2Uqi7V/BwifAGg+lKsCtU6F2J09XJSIiUigUdkqSlARY9DRs+8y+XbM93PoRhFX0bF0iIiKFSGGnpDi1yz5s9c9usPjYh6zajwAfX09XJiIiUqgUdoo7Y2Db5/D9CEhNhNBK9knINdt5ujIRERG3UNgpzpLj4Psn4bev7Nu1r7ffVh5a3rN1iYiIuJHCTnF14g/7sNWZv8DiC9f/H7R5Anx8PF2ZiIiIWynsFDfG2NfN+eFZSEuGsGjoOw2qX+fpykRERDxCYac4SYqBhcPhjzn27Tpd7Q/xLFXWo2WJiIh4ksJOcXF8u33Y6uw+8PGDziPhusc0bCUiIiWewk5RZwz8/BH8+DykpUBENfuwVdXmnq5MRETEKyjsFGWJ52H+47Brvn27Xk+4+R0ILu3RskRERNL9fvQCU3b4ULXxBa6pUc4jNWiMo6g6+it80N4edHz8odur0P9zBR0REfEq3207zl8xPszddtxjNahnp6gxBja+B0v/BzYrRFaHftOh8rWerkxEREo4m82QnGpj3z9xnIpNIiXNMH/7MQC+//0EtzevhjFQupQ/VUqHuK0uhZ2iJOEszHsU/lxk376yD9w0GYIiPFuXiIh4JZvNkJSaRpLVRpI17d8v27/70ki22kjMuN+a5jg/+d/9iU7HbP++7uJ1ElPSHMdSUm3Z1nImPoVek9c6tg+82tMdTQAo7BQdhzfD7PvhwmHwDYCur0DzwWCxeLoyERHJoczhI2PQSM4QNDKGj8T0cJGaKbCk70tJc4QXp1BzmfDhKX4+Fib0a+ze93Tru0nu2WywYTIsfwlsqVCmFvSbAVHu/UYRESmObAbik1NJS7a5hIlkl16Ni39ODx8ZezXSX5ucoeck4+uTrTZS0jwXPvx9LQT5+RIU4EuQv4/9z/7//tnfl0A/+5+D/Z33249d/HOw0zGff193cV/wv+fvPhHr1JOTbu6jbWhY2b0jEgo73iz+DMx9CP5aYt9u2Bd6vwmBYR4tS0SksKTZjFPPRHqYSM6ixyN9CCU5ux4Px76sA0uSNQ1rmh9s/MkjnzXA14fADKEhPXwE+/tm2O9LkJ+PS/jI/JqM4cPpnAwhxdfHMyMBFot9umn6fz1BYcdbHVwPswdB7DHwC4Lu4+Ga+zRsJSJulZrm2uORMXwkprgGiIzhw6lnxGr793WZh3EuDuFY0zz025CL4cOlZ8PPOXwEZwoigZnCR3CGnpPAzAHEz4fgAHsviqfCh7uUDQ2gfGgglSICaRB4jl3JpTlxIZmyoQFur0Vhx9vYbLB2Eqx4BUwalKtrH7aqeJWnKxMRL+AaPrLu8XCekJrdsYzzOzKFEm8IH34+Tj0T2fdaZOoFCfDNusfj3/CRPgzjZzGsWfkTvbp3ITQ4qNiHD3eLighm7X87YbGl8cMPPzCme0uMjz3ouZvCjjeJ+we+fQD2rbBvN74TekyAwFDP1iUi2bKmOQeHZJfJp84TRpMzhA+nu2BS7fNAElJSOX7Kl6kHN5Ccav4dprl4nVSbZ8NHcKYejyD/DD0b//ZapO8P8s/Qs5E+RBNw8c+Bma6TcU5IoJ8PPoUcPqxWK6H+EBLgp6BTSAL9fLFa7fOULBYLAR4IOqCw4z32r4Y5gyHuJPiH2ENO0/94uiqRIidz+Mh8q22OezxS0zLc5ZJp4mrqxbCSVijhwwKxsZc9KzBzz0b65NOs9mc13yNTEHEewsl0zA3hQ6SwKOx4mi0NVr8Oq8aDsUH5BvZhqwr1PV2ZSL4ZY7CmGTKu6ZExTGS+kyU5U/hITLG5vjZTz0lypp6TwgkfOROYXc9GhvCRMUwEZjHB1N8Hdv62jdYtm1EqKDBTSLn4+gBfhQ+RnFLY8aTYE/Zhq/2r7dtN74Hur0GA+1aVlJIlc/hISsmmxyOLOSEJyVZ2HfBhw/ydpKSZTIuRZRyKcZ6c6sHscYmejaz3O/VsZJorEvjv+cHZ3rbrg6UAbiCwWq34H91Kh7rl8ff3L4BWEBGFHU/Z+xN8OwTi/wH/UvZbyq++3dNViZsZY0hJs12cEJpxfY6U7NfuyDzfw3UxsjQSM6yAmvE6+QsfPnD8SJ5f7bw+h6/LMEzGu2Ayr93hmA+SYT2QzMMt6b0qgf4+BRY+RKToU9hxt7RUWDkO1kwEDFRsaB+2KlfH05UJzuHD9U6XS6zdkSmIXFyMLOMx5/CRPvHUUz0fFgvZz+XIIkz4+1g4dugAV9avQ6lA/0y9Gq5DNJlv21X4EBFPKdJhJzk5mf/973/MnDmTc+fOcfXVVzNmzBhuvPFGT5cGtjQsB9dS+ewGLAfDoVZ7+7DVnMFwaL39nGb32x/74B/s2Vq9mDH2h8pl7tXIuMx6fFIKv/xjIf7XI1htFpeej+QsJphmuxhZaprHFr2yWHAZQgnMFD4u9lxkPRST/WJkF8NI+msDfHMXPqxWK4sW7aNHp9oaXhGRIqVIh50BAwYwe/Zshg8fTp06dZgxYwY9evRgxYoVtG3b1nOF7ZwPi5/FL+YYzQAOvgchZSE1GVLiICAMbnobGt7quRrzKD18XHpNj0y9H5nOd12MLOMx5/keyam2HIYPX/h7Z4F+Vh8L2azd4Tp8knHtjksvRpbdbbu5Dx8iIpIzRTbsbN68mVmzZvH6668zYsQIAO69914aNmzIM888w/r16z1T2M758PW9QKbf0Aln7P+NrA73fAdlaxfI22UXPux3uVxcuyPzUEx60EjOosfDZb5Hxifk5jh8FDyfjD0fGe5kCfSzEHfhHFWiKhAS4J/N2h0ZezVcezxcekX8fPH3tSh8iIgUA0U27MyePRtfX1+GDBni2BcUFMSgQYN4/vnnOXz4MFWrVnVvUbY0Uhc9gy+GrH5FGiAxKYnVxwJJPHTEeb6H1Tl8JGbuJclmMbJkDz7R1tfHconVTV0XDgvOtD/LxcgyhZSchA/78MoievS4RsMrIiLiosiGna1bt1K3bl3Cw8Od9rdo0QKAbdu2ZRl2kpOTSU5OdmzHxMQA9l+YVqs1XzVZDq7FL+549seBkKSTzPjySzbarszXe2XFz8eSYd0OH+c7VjLc9eK07oefT6b5H1ns98t4S+7F6/r7+hT4Z8iWSSM1NetD6X9v+f37k0tTO7uH2tl91NbuUVjtnJvrFdmwc/z4caKiolz2p+87duxYlq8bN24co0ePdtm/ZMkSQkLyt75N5bMb7HN0LuOq4HOc9bMR4AP+mb7s+4zL/ksdS79OrrOHAaz/fmWS/O9XTC4v6UlLly71dAklgtrZPdTO7qO2do+CbueEhIQcn1tkw05iYiKBgYEu+4OCghzHs/Lcc8/x5JNPOrZjYmKoWrUqXbp0ceklyi3LwXD7ZOTLeO7OG/lvdQ9OoC5mrFYrS5cu5cYbb9QwViFSO7uH2tl91NbuUVjtnD4ykxNFNuwEBwc7DUelS0pKchzPSmBgYJYhyd/fP/9/CbXaQ3g0JuY4lswTlAGDBUt4NH612oOPZx6GVpwVyN+hXJba2T3Uzu6jtnaPgm7n3FzLjZMuClZUVBTHj7vOj0nfFx0d7e6S7AGm23gAMk8bdmx3e1VBR0RExI2KbNhp0qQJe/bscenG2rRpk+O4R1x5E5bbP8US5hy2LOGVsdz+KVx5k2fqEhERKaGKbNjp27cvaWlpTJ061bEvOTmZ6dOn07JlS/ffdp7RlTdheeIPUu+eyy/VHyb17rlYhv+uoCMiIuIBRXbOTsuWLenXrx/PPfccp06d4oorruCTTz7hwIEDfPzxx54uD3x8MdXbcnRHDI2rt9XQlYiIiIcU2bAD8Omnn/Liiy86PRtr4cKFtG/f3tOliYiIiJco0mEnKCiI119/nddff93TpYiIiIiXKrJzdkRERERyQmFHREREijWFHRERESnWFHZERESkWFPYERERkWJNYUdERESKNYUdERERKdaK9Do7BcEY+9PJc/Oo+JyyWq0kJCQQExOjJ+oWIrWze6id3UPt7D5qa/corHZO/72d/nv8Ukp82ImNjQXw7LO0REREJE9iY2OJiIi45DkWk5NIVIzZbDaOHTtGWFgYFoulQK8dExND1apVOXz4MOHh4QV6bblI7eweamf3UDu7j9raPQqrnY0xxMbGEh0djY/PpWfllPieHR8fH6pUqVKo7xEeHq5/SG6gdnYPtbN7qJ3dR23tHoXRzpfr0UmnCcoiIiJSrCnsiIiISLGmsFOIAgMDGTlyJIGBgZ4upVhTO7uH2tk91M7uo7Z2D29o5xI/QVlERESKN/XsiIiISLGmsCMiIiLFmsKOiIiIFGsKOyIiIlKsKezkQXJyMs8++yzR0dEEBwfTsmVLli5dmqPXHj16lNtvv53IyEjCw8Pp06cP+/btK+SKi6a8tvO3337LHXfcQa1atQgJCaFevXo89dRTnD9/vvCLLoLy8/2c0Y033ojFYuGxxx4rhCqLvvy281dffcV1111HqVKliIyMpHXr1vz000+FWHHRlZ+2XrZsGZ06daJcuXJERkbSokULZs6cWcgVF01xcXGMHDmSbt26UaZMGSwWCzNmzMjx68+fP8+QIUMoX748pUqVolOnTmzZsqVwijWSa/379zd+fn5mxIgR5oMPPjDXXXed8fPzM2vWrLnk62JjY02dOnVMhQoVzPjx482kSZNM1apVTZUqVczp06fdVH3Rkdd2Llu2rGnUqJF58cUXzYcffmiGDh1qAgICTP369U1CQoKbqi868trOGc2ZM8eUKlXKAObRRx8txGqLrvy088iRI43FYjH9+vUz77//vpk8ebJ58MEHzaeffuqGyouevLb1vHnzjMViMa1btzaTJ082U6ZMMe3btzeAmTRpkpuqLzr2799vAFOtWjXTsWNHA5jp06fn6LVpaWmmdevWplSpUmbUqFFmypQp5sorrzRhYWFmz549BV6rwk4ubdq0yQDm9ddfd+xLTEw0tWvXNtddd90lXzt+/HgDmM2bNzv27dq1y/j6+prnnnuu0GouivLTzitWrHDZ98knnxjAfPjhhwVdapGWn3bOeH6NGjXMSy+9pLCTjfy084YNG4zFYtEv2xzKT1vfeOONJjo62iQlJTn2Wa1WU7t2bXP11VcXWs1FVVJSkjl+/Lgxxpiff/45V2Hnq6++MoD55ptvHPtOnTplIiMjzZ133lngtWoYK5dmz56Nr68vQ4YMcewLCgpi0KBBbNiwgcOHD1/ytc2bN6d58+aOffXr16dz5858/fXXhVp3UZOfdu7YsaPLvltuuQWAXbt2FXitRVl+2jnda6+9hs1mY8SIEYVZapGWn3Z+8803qVSpEsOGDcMYQ1xcnDtKLrLy09YxMTGULl3aafE7Pz8/ypUrR3BwcKHWXRQFBgZSqVKlPL129uzZVKxYkVtvvdWxr3z58tx+++3MmzeP5OTkgioT0JydXNu6dSt169Z1eZhZixYtANi2bVuWr7PZbPz22280a9bM5ViLFi3Yu3cvsbGxBV5vUZXXds7OiRMnAChXrlyB1Fdc5LedDx06xKuvvsr48eP1y+AS8tPOy5cvp3nz5rz99tuUL1+esLAwoqKimDJlSmGWXGTlp607duzIjh07ePHFF/n777/Zu3cvL7/8Mr/88gvPPPNMYZZd4mzdupVrrrnG5WnlLVq0ICEhgT179hTo+5X4p57n1vHjx4mKinLZn77v2LFjWb7u7NmzJCcnX/a19erVK8Bqi668tnN2xo8fj6+vL3379i2Q+oqL/LbzU089RdOmTenfv3+h1Fdc5LWdz507x+nTp1m3bh0//fQTI0eOpFq1akyfPp3HH38cf39/HnzwwUKtvajJz/f0iy++yP79+xk7dixjxowBICQkhDlz5tCnT5/CKbiEOn78OO3bt3fZn/HvqVGjRgX2fgo7uZSYmJjl8z2CgoIcx7N7HZCn15ZEeW3nrHzxxRd8/PHHPPPMM9SpU6fAaiwO8tPOK1asYM6cOWzatKnQ6isu8trO6UNWZ86cYdasWdxxxx0A9O3bl0aNGjFmzBiFnUzy8z0dGBhI3bp16du3L7feeitpaWlMnTqVu+++m6VLl9KqVatCq7ukKcif8TmhsJNLwcHBWY4lJiUlOY5n9zogT68tifLazpmtWbOGQYMG0bVrV8aOHVugNRYHeW3n1NRUhg4dyj333OM0B02ylt+fG/7+/k69kj4+Ptxxxx2MHDmSQ4cOUa1atUKoumjKz8+Oxx57jI0bN7JlyxbH8Mrtt9/OVVddxbBhwxTsC1BB/YzPKc3ZyaWoqCiOHz/usj99X3R0dJavK1OmDIGBgXl6bUmU13bOaPv27dx00000bNiQ2bNn4+enbJ9ZXtv5008/5c8//+TBBx/kwIEDji+A2NhYDhw4QEJCQqHVXdTk5+dGUFAQZcuWxdfX1+lYhQoVAPtQl1yU17ZOSUnh448/pmfPnk7zSPz9/enevTu//PILKSkphVN0CVQQP+NzQ2Enl5o0acKePXuIiYlx2p+e+Js0aZLl63x8fGjUqBG//PKLy7FNmzZRq1YtwsLCCrzeoiqv7Zxu7969dOvWjQoVKrBo0SJCQ0MLq9QiLa/tfOjQIaxWK23atKFmzZqOL7AHoZo1a7JkyZJCrb0oyc/PjSZNmvDPP/+4/KJNn3tSvnz5gi+4CMtrW585c4bU1FTS0tJcjlmtVmw2W5bHJG+aNGnCli1bsNlsTvs3bdpESEgIdevWLdg3LPCb2Yu5jRs3uqzhkJSUZK644grTsmVLx76DBw+aXbt2Ob321VdfNYD5+eefHft2795tfH19zbPPPlv4xRch+Wnn48ePm1q1apno6Gizf/9+d5VcJOW1nXft2mW+++47ly/A9OjRw3z33Xfm2LFjbv0s3iw/389vvPGGAczUqVMd+xITE02tWrXMlVdeWfjFFzF5bevU1FQTGRlp6tata5KTkx37Y2NjTZUqVUz9+vXd8wGKqEuts3Ps2DGza9cuk5KS4tg3a9Ysl3V2/vnnHxMZGWnuuOOOAq9PYScP+vXrZ/z8/MzTTz9tPvjgA9O6dWvj5+dnVq1a5TinQ4cOJnOWjImJMbVr1zYVKlQwr732mnnjjTdM1apVTXR0tDl16pS7P4bXy2s7N27c2ADmmWeeMTNnznT6WrJkibs/htfLaztnBS0qmK28tnNCQoK56qqrjL+/vxkxYoR5++23TfPmzY2vr69ZtGiRuz9GkZDXth4zZowBTNOmTc0bb7xhJkyYYBo0aGAA89lnn7n7YxQJkydPNi+//LJ5+OGHDWBuvfVW8/LLL5uXX37ZnD9/3hhjzH333WcAp//zmZqaalq1amVCQ0PN6NGjzTvvvGOuuuoqExYWZnbv3l3gdSrs5EFiYqIZMWKEqVSpkgkMDDTNmzc3ixcvdjonu18Ohw8fNn379jXh4eEmNDTU9OrVy/z111/uKr1IyWs7A9l+dejQwY2foGjIz/dzZgo72ctPO588edLcd999pkyZMiYwMNC0bNnS5bVyUX7a+vPPPzctWrQwkZGRJjg42LRs2dLMnj3bXaUXOdWrV8/25216uMkq7BhjzNmzZ82gQYNM2bJlTUhIiOnQoYPTyEdBshhjTMEOjImIiIh4D01QFhERkWJNYUdERESKNYUdERERKdYUdkRERKRYU9gRERGRYk1hR0RERIo1hR0REREp1hR2REREpFhT2BEREZFiTWFHRCQHDhw4gMViYcCAAZ4uRURySWFHREREijWFHRERESnWFHZERESkWFPYERGPWL16Nb1796ZcuXIEBgZSp04dXnjhBRISEhznrFy5EovFwqhRo1i7di0dO3YkLCyMyMhIbrvtNv7+++8sr/3HH39w++23U6FCBQIDA6lZsybDhw/nzJkzWZ5/6tQpnnrqKerVq0dwcDBlypShZcuWTJgwIcvz//77b2655RZKly5NqVKluOGGG9i+fXv+G0VECoXFGGM8XYSIlCzvvfcejz76KJGRkfTu3ZsKFSrwyy+/sHLlSlq3bs2KFSsICAhg5cqVdOrUia5du7JixQq6devGVVddxY4dO1iwYAHlypVj48aN1KpVy3HttWvX0rVrV1JSUujbty81atRgw4YNrFq1itq1a7Nx40bKlSvnOP/PP/+kU6dOHD9+nLZt29K6dWvi4+PZsWMH27dv5+zZs4B9gnLNmjXp0KEDf/zxB1dddRXNmjVj7969zJs3j9KlS7Nr1y4qVqzo9vYUkcswIiJutGPHDuPn52caN25sTp8+7XRs3LhxBjATJkwwxhizYsUKAxjAvP/++07nvv/++wYwvXr1cuxLS0sztWvXNoBZvHix0/lPP/20Acz999/vtL9Zs2YGMFOnTnWp9fDhw44/79+/31HLq6++6nTeCy+8YAAzbty4XLSEiLiLwo6IuNXQoUMNYFavXu1yLC0tzZQvX95ce+21xpiLYadu3bomLS3N5dw6deoYi8ViTp06ZYwxZvXq1QYw3bt3d7l2bGysKVOmjAkKCjLJycnGGGM2bdpkANO+ffvL1p0edmrWrOlSS/qxW2+9NWeNICJu5ef+viQRKck2btwIwI8//sjy5ctdjvv7+7N7926nfW3atMHHx3mKoY+PD23atOGvv/5i+/bt3HDDDWzduhWAjh07ulw3NDSUZs2asWTJEv78808aNWrE5s2bAejSpUuO62/SpIlLLVWqVAHg/PnzOb6OiLiPwo6IuFX6HJixY8fm+DXZzYNJ33/hwgUAYmJiLnl+VFSU03npr6tcuXKOawkPD3fZ5+dn/1GalpaW4+uIiPvobiwRcav0sBATE4OxD6Vn+ZXRyZMns7xW+v6IiAina2d3/okTJ5zOi4yMBODo0aP5+EQi4u0UdkTErVq2bAlcHM7KiXXr1mGz2Zz22Ww21q9fj8VioXHjxgA0bdoUsN+ynll8fDy//PILwcHB1KtXD4AWLVoAsGTJklx/DhEpOhR2RMStHnnkEfz8/Hj88cc5dOiQy/Hz58875t6k27NnDx9++KHTvg8//JA9e/bQs2dPypcvD9jn9tSuXZsffviBZcuWOZ0/ZswYzpw5w5133klAQAAAzZs3p3nz5qxevdrl+qAeH5HiQnN2RMStGjZsyLvvvsvDDz9MvXr16NGjB7Vr1yY2NpZ9+/axatUqBgwYwPvvv+94TdeuXRk6dCiLFi1yWWfnrbfecpzn4+PDjBkz6Nq1Kz169KBfv35Ur16dDRs2sHLlSmrXrs2rr77qVM/nn39Ox44dGTJkCDNnzuS6664jKSmJHTt2sHXr1mwXIhSRokM9OyLidg888AAbNmzg5ptvZuPGjbz55pvMnj2b06dP88QTTzB8+HCn81u1asXy5cu5cOECb7/9NitXruTmm29mw4YNTgsKArRt25aNGzfSp08flixZwoQJE9i/fz/Dhg1j48aNjl6gdHXq1GHLli0MGzaMo0eP8uabb/LZZ58RFxfHCy+8UNhNISJuoBWURcRrpa+gPHLkSEaNGuXpckSkiFLPjoiIiBRrCjsiIiJSrCnsiIiISLGmOTsiIiJSrKlnR0RERIo1hR0REREp1hR2REREpFhT2BEREZFiTWFHREREijWFHRERESnWFHZERESkWFPYERERkWLt/wGtH52zRrXm4gAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_770922/1431845755.py:115: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n",
      "  sns.distplot(np.array(test_losses), kde=False, norm_hist=False, rug=False, label='test-loss', ax=plt)\n",
      "/tmp/ipykernel_770922/1431845755.py:116: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n",
      "  sns.distplot(np.array(forget_losses), kde=False, norm_hist=False, rug=False, label='forget-loss', ax=plt)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.754534 0.42855406\n",
      "3.3761232 0.4246457\n",
      "FPR:0.43, FNR:0.44, FP41.00, TN54.00, TP59.00, FN46.00\n",
      "FPR:0.39, FNR:0.37, FP41.00, TN65.00, TP59.00, FN35.00\n",
      "FPR:0.45, FNR:0.44, FP45.00, TN56.00, TP55.00, FN44.00\n",
      "FPR:0.42, FNR:0.41, FP45.00, TN62.00, TP55.00, FN38.00\n",
      "FPR:0.42, FNR:0.39, FP47.00, TN66.00, TP53.00, FN34.00\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                                                         \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BadT ->\tFull test error: 15.57\tForget error: 83.92\tRetain error: 4.01\tValid error: 21.84\tFine-tune time: 1 steps\tMIA: 0.58±0.0\n",
      "Checkpoint name: cifar10_allcnn_1_0_forget_None_lr_0_01_bs_128_ls_ce_wd_0_0005_seed_3\n",
      "[Logging in cifar10_allcnn_1_0_forget_None_lr_0_01_bs_128_ls_ce_wd_0_0005_seed_3_training]\n",
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "confuse mode: False\n",
      "split mode: train\n",
      "Number of Classes: 10\n",
      "Epoch: [0][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 2.5182 (2.5182)\tAcc@1 8.594 (8.594)\tAcc@5 44.531 (44.531)\n",
      " * Acc@1 67.485 Acc@5 96.825\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.8230 (0.8230)\tAcc@1 72.656 (72.656)\tAcc@5 98.438 (98.438)\n",
      " * Acc@1 76.970 Acc@5 98.860\n",
      "Epoch Time: 10.99 sec\n",
      "Epoch: [1][0/313]\tTime 0.032 (0.032)\tData 0.025 (0.025)\tLoss 0.5116 (0.5116)\tAcc@1 80.469 (80.469)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 79.997 Acc@5 99.217\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [2][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.5171 (0.5171)\tAcc@1 82.031 (82.031)\tAcc@5 99.219 (99.219)\n",
      " * Acc@1 84.762 Acc@5 99.497\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [3][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.4570 (0.4570)\tAcc@1 86.719 (86.719)\tAcc@5 99.219 (99.219)\n",
      " * Acc@1 88.298 Acc@5 99.702\n",
      "Epoch Time: 8.94 sec\n",
      "Epoch: [4][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.2635 (0.2635)\tAcc@1 92.188 (92.188)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 91.533 Acc@5 99.810\n",
      "Epoch Time: 8.97 sec\n",
      "Epoch: [5][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.1922 (0.1922)\tAcc@1 92.188 (92.188)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 94.245 Acc@5 99.890\n",
      "Test: [0/79]\tTime 0.027 (0.027)\tLoss 0.5127 (0.5127)\tAcc@1 84.375 (84.375)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 84.000 Acc@5 99.270\n",
      "Epoch Time: 11.03 sec\n",
      "Epoch: [6][0/313]\tTime 0.031 (0.031)\tData 0.023 (0.023)\tLoss 0.1072 (0.1072)\tAcc@1 97.656 (97.656)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 96.575 Acc@5 99.950\n",
      "Epoch Time: 9.0 sec\n",
      "Epoch: [7][0/313]\tTime 0.030 (0.030)\tData 0.024 (0.024)\tLoss 0.0980 (0.0980)\tAcc@1 98.438 (98.438)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 98.300 Acc@5 99.985\n",
      "Epoch Time: 8.99 sec\n",
      "Epoch: [8][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0378 (0.0378)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.292 Acc@5 99.993\n",
      "Epoch Time: 8.99 sec\n",
      "Epoch: [9][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0329 (0.0329)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.790 Acc@5 99.995\n",
      "Epoch Time: 8.99 sec\n",
      "Epoch: [10][0/313]\tTime 0.030 (0.030)\tData 0.024 (0.024)\tLoss 0.0325 (0.0325)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.945 Acc@5 99.995\n",
      "Test: [0/79]\tTime 0.027 (0.027)\tLoss 0.5076 (0.5076)\tAcc@1 87.500 (87.500)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 84.040 Acc@5 99.160\n",
      "Epoch Time: 11.06 sec\n",
      "Epoch: [11][0/313]\tTime 0.032 (0.032)\tData 0.024 (0.024)\tLoss 0.0114 (0.0114)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.965 Acc@5 100.000\n",
      "Epoch Time: 8.98 sec\n",
      "Epoch: [12][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0134 (0.0134)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.978 Acc@5 100.000\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [13][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0096 (0.0096)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.995 Acc@5 100.000\n",
      "Epoch Time: 8.98 sec\n",
      "Epoch: [14][0/313]\tTime 0.030 (0.030)\tData 0.024 (0.024)\tLoss 0.0126 (0.0126)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.995 Acc@5 100.000\n",
      "Epoch Time: 8.98 sec\n",
      "Epoch: [15][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0069 (0.0069)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.997 Acc@5 100.000\n",
      "Test: [0/79]\tTime 0.027 (0.027)\tLoss 0.5216 (0.5216)\tAcc@1 86.719 (86.719)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 84.230 Acc@5 98.990\n",
      "Epoch Time: 11.04 sec\n",
      "Epoch: [16][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0073 (0.0073)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.995 Acc@5 100.000\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [17][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0118 (0.0118)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.997 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [18][0/313]\tTime 0.030 (0.030)\tData 0.024 (0.024)\tLoss 0.0098 (0.0098)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 9.0 sec\n",
      "Epoch: [19][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0051 (0.0051)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.99 sec\n",
      "Epoch: [20][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0066 (0.0066)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.4910 (0.4910)\tAcc@1 86.719 (86.719)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 84.190 Acc@5 98.970\n",
      "Epoch Time: 11.03 sec\n",
      "Epoch: [21][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0036 (0.0036)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [22][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0058 (0.0058)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [23][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0042 (0.0042)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [24][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0042 (0.0042)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [25][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0060 (0.0060)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.4246 (0.4246)\tAcc@1 89.062 (89.062)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 84.140 Acc@5 98.980\n",
      "Epoch Time: 11.0 sec\n",
      "Pure training time: 233.25 sec\n",
      "Checkpoint name: cifar10_allcnn_1_0_forget_[5]_lr_0_01_bs_128_ls_ce_wd_0_0005_seed_3\n",
      "[Logging in cifar10_allcnn_1_0_forget_[5]_lr_0_01_bs_128_ls_ce_wd_0_0005_seed_3_training]\n",
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "confuse mode: False\n",
      "split mode: forget\n",
      "Number of Classes: 10\n",
      "Epoch: [0][0/313]\tTime 0.032 (0.032)\tData 0.024 (0.024)\tLoss 2.4540 (2.4540)\tAcc@1 8.594 (8.594)\tAcc@5 51.562 (51.562)\n",
      " * Acc@1 71.215 Acc@5 97.840\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.7868 (0.7868)\tAcc@1 73.438 (73.438)\tAcc@5 98.438 (98.438)\n",
      " * Acc@1 72.320 Acc@5 89.420\n",
      "Epoch Time: 11.04 sec\n",
      "Epoch: [1][0/313]\tTime 0.032 (0.032)\tData 0.024 (0.024)\tLoss 0.4121 (0.4121)\tAcc@1 85.938 (85.938)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 83.930 Acc@5 99.550\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [2][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.4168 (0.4168)\tAcc@1 88.281 (88.281)\tAcc@5 99.219 (99.219)\n",
      " * Acc@1 88.697 Acc@5 99.717\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [3][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.3523 (0.3523)\tAcc@1 86.719 (86.719)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 92.095 Acc@5 99.850\n",
      "Epoch Time: 8.94 sec\n",
      "Epoch: [4][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.1484 (0.1484)\tAcc@1 98.438 (98.438)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 95.022 Acc@5 99.923\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [5][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.1010 (0.1010)\tAcc@1 96.094 (96.094)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 97.197 Acc@5 99.967\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.5025 (0.5025)\tAcc@1 85.156 (85.156)\tAcc@5 99.219 (99.219)\n",
      " * Acc@1 77.830 Acc@5 89.570\n",
      "Epoch Time: 10.99 sec\n",
      "Epoch: [6][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0398 (0.0398)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 98.640 Acc@5 99.990\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [7][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0584 (0.0584)\tAcc@1 99.219 (99.219)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.427 Acc@5 99.997\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [8][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0174 (0.0174)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.772 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [9][0/313]\tTime 0.032 (0.032)\tData 0.024 (0.024)\tLoss 0.0250 (0.0250)\tAcc@1 99.219 (99.219)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.938 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [10][0/313]\tTime 0.030 (0.030)\tData 0.024 (0.024)\tLoss 0.0153 (0.0153)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * Acc@1 99.967 Acc@5 100.000\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.4683 (0.4683)\tAcc@1 87.500 (87.500)\tAcc@5 99.219 (99.219)\n",
      " * Acc@1 78.100 Acc@5 89.470\n",
      "Epoch Time: 11.01 sec\n",
      "Epoch: [11][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0107 (0.0107)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.982 Acc@5 100.000\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [12][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0125 (0.0125)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.993 Acc@5 100.000\n",
      "Epoch Time: 8.94 sec\n",
      "Epoch: [13][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0075 (0.0075)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.997 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [14][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0112 (0.0112)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [15][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0053 (0.0053)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.4375 (0.4375)\tAcc@1 88.281 (88.281)\tAcc@5 99.219 (99.219)\n",
      " * Acc@1 77.890 Acc@5 89.460\n",
      "Epoch Time: 11.0 sec\n",
      "Epoch: [16][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0051 (0.0051)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [17][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0093 (0.0093)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [18][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0070 (0.0070)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [19][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0041 (0.0041)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [20][0/313]\tTime 0.030 (0.030)\tData 0.023 (0.023)\tLoss 0.0040 (0.0040)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.4467 (0.4467)\tAcc@1 87.500 (87.500)\tAcc@5 99.219 (99.219)\n",
      " * Acc@1 78.070 Acc@5 89.440\n",
      "Epoch Time: 11.01 sec\n",
      "Epoch: [21][0/313]\tTime 0.032 (0.032)\tData 0.024 (0.024)\tLoss 0.0036 (0.0036)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.997 Acc@5 100.000\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [22][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0050 (0.0050)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.95 sec\n",
      "Epoch: [23][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0035 (0.0035)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Epoch Time: 8.96 sec\n",
      "Epoch: [24][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0033 (0.0033)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 99.997 Acc@5 100.000\n",
      "Epoch Time: 8.87 sec\n",
      "Epoch: [25][0/313]\tTime 0.031 (0.031)\tData 0.024 (0.024)\tLoss 0.0042 (0.0042)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 100.000 Acc@5 100.000\n",
      "Test: [0/79]\tTime 0.026 (0.026)\tLoss 0.3828 (0.3828)\tAcc@1 88.281 (88.281)\tAcc@5 100.000 (100.000)\n",
      " * Acc@1 77.940 Acc@5 89.440\n",
      "Epoch Time: 10.95 sec\n",
      "Pure training time: 232.67999999999998 sec\n",
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "confuse mode: False\n",
      "split mode: train\n",
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "confuse mode: False\n",
      "split mode: train\n",
      "Forgetting by Fine-tuneing:\n",
      "Forgetting by NegGrad:\n",
      "Forgetting by CFK:\n",
      "Forgetting by EUK:\n",
      "==> Bad Teacher Unlearning ...\n",
      "Epoch: [1][0/282]\tTime 0.181 (0.181)\tData 0.112 (0.112)\tLoss 4.9445 (4.9445)\tAcc@1 100.000 (100.000)\tAcc@5 100.000 (100.000)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/meghdad/unlearning/SelectiveForgetting/myenv/lib/python3.9/site-packages/torch/nn/_reduction.py:42: UserWarning: size_average and reduce args will be deprecated, please use reduction='sum' instead.\n",
      "  warnings.warn(warning.format(ret))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * Acc@1 94.131 Acc@5 99.939\n",
      "loss: 1.66\t train_acc: 94.13055419921875\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_770922/1431845755.py:115: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n",
      "  sns.distplot(np.array(test_losses), kde=False, norm_hist=False, rug=False, label='test-loss', ax=plt)\n",
      "/tmp/ipykernel_770922/1431845755.py:116: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n",
      "  sns.distplot(np.array(forget_losses), kde=False, norm_hist=False, rug=False, label='forget-loss', ax=plt)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.655567 0.36413506\n",
      "3.1591437 0.48954135\n",
      "FPR:0.42, FNR:0.42, FP42.00, TN58.00, TP58.00, FN42.00\n",
      "FPR:0.43, FNR:0.43, FP44.00, TN58.00, TP56.00, FN42.00\n",
      "FPR:0.41, FNR:0.42, FP38.00, TN55.00, TP62.00, FN45.00\n",
      "FPR:0.40, FNR:0.40, FP40.00, TN60.00, TP60.00, FN40.00\n",
      "FPR:0.41, FNR:0.39, FP43.00, TN63.00, TP57.00, FN37.00\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                                                         "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BadT ->\tFull test error: 15.86\tForget error: 80.87\tRetain error: 4.94\tValid error: 21.67\tFine-tune time: 1 steps\tMIA: 0.59±0.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    }
   ],
   "source": [
    "seeds = [1,2,3]\n",
    "chkpt = \"checkpoints/cifar100_allcnn_1_0_forget_None_lr_0_1_bs_128_ls_ce_wd_0_0005_seed_1_30.pt\"\n",
    "forget_class = '5'\n",
    "forget_num = 4000\n",
    "dataset = 'cifar10'\n",
    "modelname = 'allcnn'\n",
    "dataroot = '../image_data/cifar10'\n",
    "filters = 1.0\n",
    "\n",
    "errors = []\n",
    "for s in seeds:\n",
    "\n",
    "    %run train.py --dataset $dataset --model $modelname --dataroot=$dataroot --filters $filters --lr 0.01 \\\n",
    "    --resume $chkpt --disable-bn --weight-decay 0.0005 --batch-size 128 --epochs 26 --seed $s\n",
    "\n",
    "    m_name = args.name\n",
    "    %run train.py --dataset $dataset --model $modelname --split 'forget' --dataroot=$dataroot --filters $filters --lr 0.01 \\\n",
    "    --resume $chkpt --disable-bn --weight-decay 0.0005 --batch-size 128 --epochs 26 \\\n",
    "    --forget-class $forget_class --seed $s\n",
    "    m0_name = args.name\n",
    "\n",
    "    log_dict={}\n",
    "    training_epochs=25\n",
    "    model0 = copy.deepcopy(model)\n",
    "    model_initial = copy.deepcopy(model)\n",
    "\n",
    "    arch = args.model \n",
    "    filters=args.filters\n",
    "    arch_filters = arch +'_'+ str(filters).replace('.','_')\n",
    "    augment = False\n",
    "    dataset = args.dataset\n",
    "    class_to_forget = args.forget_class\n",
    "    init_checkpoint = f\"checkpoints/{args.name}_init.pt\"\n",
    "    num_classes=args.num_classes\n",
    "    num_to_forget = args.num_to_forget\n",
    "    num_total = len(train_loader.dataset)\n",
    "    num_to_retain = num_total - forget_num\n",
    "    seed = args.seed\n",
    "    unfreeze_start = None\n",
    "\n",
    "    learningrate=f\"lr_{str(args.lr).replace('.','_')}\"\n",
    "    batch_size=f\"_bs_{str(args.batch_size)}\"\n",
    "    lossfn=f\"_ls_{args.lossfn}\"\n",
    "    wd=f\"_wd_{str(args.weight_decay).replace('.','_')}\"\n",
    "    seed_name=f\"_seed_{args.seed}_\"\n",
    "\n",
    "    num_tag = '' if num_to_forget is None else f'_num_{num_to_forget}'\n",
    "    unfreeze_tag = '_' if unfreeze_start is None else f'_unfreeze_from_{unfreeze_start}_'\n",
    "    augment_tag = '' if not augment else f'augment_'\n",
    "\n",
    "    m_name = f'checkpoints/{m_name}_{training_epochs}.pt'#f'checkpoints/{dataset}_{arch_filters}_forget_None{unfreeze_tag}{augment_tag}{learningrate}{batch_size}{lossfn}{wd}{seed_name}{training_epochs}.pt'\n",
    "    m0_name = f'checkpoints/{m0_name}_{training_epochs}.pt'#f'checkpoints/{dataset}_{arch_filters}_forget_{class_to_forget}{num_tag}{unfreeze_tag}{augment_tag}{learningrate}{batch_size}{lossfn}{wd}{seed_name}{training_epochs}.pt'\n",
    "    \n",
    "\n",
    "    model.load_state_dict(torch.load(m_name))\n",
    "    model0.load_state_dict(torch.load(m0_name))\n",
    "    model_initial.load_state_dict(torch.load(init_checkpoint))\n",
    "\n",
    "    teacher = copy.deepcopy(model)\n",
    "    bad_teacher = model_dict[args.model](num_classes=num_classes).to(args.device)\n",
    "    student = copy.deepcopy(model)\n",
    "\n",
    "    model.cuda()\n",
    "    model0.cuda()\n",
    "\n",
    "\n",
    "    for p in model.parameters():\n",
    "        p.data0 = p.data.clone()\n",
    "    for p in model0.parameters():\n",
    "        p.data0 = p.data.clone()\n",
    "    #train('small_cifar6', 'data/cifar10/', 'allcnn', 1.0, chkpt, forget_class, forget_num, s)\n",
    "    #load_chkpts()\n",
    "    \n",
    "    log_dict={}\n",
    "    log_dict['args']=args\n",
    "    args.retain_bs = 128\n",
    "    args.forget_bs = 512\n",
    "\n",
    "    train_loader_full, valid_loader_full, test_loader_full_full, _ = datasets.get_loaders(args.dataset, batch_size=args.batch_size, seed=s, root=args.dataroot, augment=False, shuffle=True)\n",
    "    marked_loader, _, test_loader_full, _ = datasets.get_loaders(args.dataset, class_to_replace=args.forget_class, num_indexes_to_replace=args.num_to_forget, only_mark=True, batch_size=1, seed=s, root=args.dataroot, augment=False, shuffle=True)\n",
    "\n",
    "    forget_dataset = copy.deepcopy(marked_loader.dataset)\n",
    "    marked = forget_dataset.targets < 0\n",
    "    forget_dataset.data = forget_dataset.data[marked]\n",
    "    forget_dataset.targets = - forget_dataset.targets[marked] - 1\n",
    "    #forget_loader = torch.utils.data.DataLoader(forget_dataset, batch_size=args.forget_bs,num_workers=0,pin_memory=True,shuffle=True)\n",
    "    forget_loader = replace_loader_dataset(train_loader_full, forget_dataset, batch_size=args.forget_bs, seed=seed, shuffle=True)\n",
    "\n",
    "    retain_dataset = copy.deepcopy(marked_loader.dataset)\n",
    "    marked = retain_dataset.targets >= 0\n",
    "    retain_dataset.data = retain_dataset.data[marked]\n",
    "    retain_dataset.targets = retain_dataset.targets[marked]\n",
    "    #retain_loader = torch.utils.data.DataLoader(retain_dataset, batch_size=args.retain_bs,num_workers=0,pin_memory=True,shuffle=True)\n",
    "    retain_loader = replace_loader_dataset(train_loader_full, retain_dataset, batch_size=args.retain_bs, seed=seed, shuffle=True)\n",
    "\n",
    "    assert(len(forget_dataset) + len(retain_dataset) == len(train_loader_full.dataset))\n",
    "\n",
    "    \n",
    "    model_ft = copy.deepcopy(model)\n",
    "    model_ng = copy.deepcopy(model)\n",
    "    args.ft_lr = 0.04\n",
    "    args.ft_epochs = 10\n",
    "    args.ng_alpha = 0.9999\n",
    "    args.ng_epochs = 5\n",
    "    args.ng_lr = 0.01\n",
    "    \n",
    "    \"\"\"\n",
    "    bsn_blocks = [i for i in range(0,10) if i not in [3,7]]\n",
    "    for i in bsn_blocks:\n",
    "        for param in model_ft.features[i][0].parameters():\n",
    "            param.requires_grad_(False)          \n",
    "    for i in bsn_blocks:\n",
    "        for param in model_ng.features[i][0].parameters():\n",
    "            param.requires_grad_(False)\n",
    "    for i in bsn_blocks:\n",
    "        for param in student.features[i][0].parameters():\n",
    "            param.requires_grad_(False)\n",
    "    \"\"\"\n",
    "    print (\"Forgetting by Fine-tuneing:\")\n",
    "    #finetune(model_ft, retain_loader, epochs=args.ft_epochs, quiet=True, lr=args.ft_lr)\n",
    "    print (\"Forgetting by NegGrad:\")\n",
    "    #negative_grad(model_ng, retain_loader, forget_loader, alpha=args.ng_alpha, epochs=args.ng_epochs, quiet=True, lr=args.ng_lr, args=args)\n",
    "    print (\"Forgetting by CFK:\")\n",
    "    model_cfk = 1#cfk_unlearn(model)\n",
    "    print (\"Forgetting by EUK:\")\n",
    "    model_euk = 1#euk_unlearn(model, model_initial)\n",
    "    \n",
    "    model_s, model_s_final = 1,1#scrub(teacher, student)\n",
    "    model_bt = badt(teacher, bad_teacher, student)\n",
    "    \n",
    "\n",
    "            \n",
    "    readouts = {}\n",
    "    #_,_=activations_predictions(copy.deepcopy(model),forget_loader,'Original_Model_D_f')\n",
    "    thresh=0#og_dict['Original_Model_D_f_loss']+1e-5\n",
    "    #readouts[\"Original\"] = all_readouts(copy.deepcopy(model),thresh,'Original', seed)\n",
    "    #readouts[\"Retrain\"] = all_readouts(copy.deepcopy(model0),thresh,'Retrain', seed)\n",
    "    #readouts['Finetune'] = all_readouts(copy.deepcopy(model_ft),thresh,'Finetune', seed)\n",
    "    #readouts[\"NegGrad\"] = all_readouts(copy.deepcopy(model_ng),thresh,'NegGrad', seed)\n",
    "    #readouts[\"CFK\"] = all_readouts(copy.deepcopy(model_cfk),thresh,'CFK', seed)\n",
    "    #readouts[\"EUK\"] = all_readouts(copy.deepcopy(model_euk),thresh,'EUK', seed)\n",
    "    #readouts[\"SCRUBS\"] = all_readouts(copy.deepcopy(model_s),thresh,'SCRUBS', seed)\n",
    "    #readouts[\"SCRUBS_final\"] = all_readouts(copy.deepcopy(model_s_final),thresh,'SCRUBS_final', seed)\n",
    "    readouts[\"BadT\"] = all_readouts(copy.deepcopy(model_bt),thresh,'BadT', seed)\n",
    "    \n",
    "    \n",
    "    del model\n",
    "    del model0\n",
    "    del model_ft\n",
    "    del model_ng\n",
    "    del model_euk\n",
    "    del model_cfk\n",
    "    del model_s\n",
    "    del model_s_final\n",
    "    del retain_loader\n",
    "    del forget_loader\n",
    "    del test_loader_full\n",
    "    del train_loader_full\n",
    "\n",
    "    errors.append(readouts)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BadT  \t15.90±0.29\t79.57±4.18\t4.80±0.59\t57.87±0.97\n"
     ]
    }
   ],
   "source": [
    "tes = {}\n",
    "res = {}\n",
    "fes = {}\n",
    "ves = {}\n",
    "rlt = {}\n",
    "MIA = {}\n",
    "for key in errors[0].keys():\n",
    "    tes[key] = [errors[i][key]['test_error'] for i in range(len(errors))]\n",
    "    res[key] = [errors[i][key]['retain_error'] for i in range(len(errors))]\n",
    "    fes[key] = [errors[i][key]['forget_error'] for i in range(len(errors))]\n",
    "    ves[key] = [errors[i][key]['val_error'] for i in range(len(errors))]\n",
    "    rlt[key] = [errors[i][key]['retrain_time'] for i in range(len(errors))]\n",
    "    MIA[key] = [errors[i][key]['MIA']*100 for i in range(len(errors))]\n",
    "    \n",
    "    print (\"{}  \\t{:.2f}±{:.2f}\\t{:.2f}±{:.2f}\\t{:.2f}±{:.2f}\\t{:.2f}±{:.2f}\".format(key, \n",
    "                                                                np.mean(tes[key]), np.std(tes[key]),\n",
    "                                                                np.mean(fes[key]), np.std(fes[key]),\n",
    "                                                                np.mean(res[key]), np.std(res[key]),\n",
    "                                                                np.mean(MIA[key]), np.std(MIA[key])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\ntotal = parameter_count(model)\\nbsn_blocks = [i for i in range(0,10) if i not in [3,7]]\\ncount = 0\\nfor i in bsn_blocks:\\n    bn_params = 0\\n    conv_params = 0\\n    relu_params = 0\\n    for p in model.features[i][1].parameters():\\n        bn_params+=np.prod(np.array(list(p.shape)))\\n    for p in model.features[i][0].parameters():\\n        conv_params+=np.prod(np.array(list(p.shape)))\\n    count += bn_params + conv_params\\n    conv_frac = conv_params/total * 100\\n    bn_frac = bn_params/total * 100\\n    print (f'layer {i} Conv params&{conv_params}&{conv_frac:.2f}\\\\\\\\')\\n    print (f'layer {i} BN params&{bn_params}&{bn_frac:.2f}\\\\\\\\')\\n    print ('\\\\midrule')\\n\\ncls_params = 0\\nfor p in model.classifier.parameters():\\n    cls_params+=np.prod(np.array(list(p.shape)))\\ncls_frac = cls_params/total * 100\\nprint (f'classifier params&{cls_params}&{cls_frac:.2f}\\\\\\\\')\\n\""
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "total = parameter_count(model)\n",
    "bsn_blocks = [i for i in range(0,10) if i not in [3,7]]\n",
    "count = 0\n",
    "for i in bsn_blocks:\n",
    "    bn_params = 0\n",
    "    conv_params = 0\n",
    "    relu_params = 0\n",
    "    for p in model.features[i][1].parameters():\n",
    "        bn_params+=np.prod(np.array(list(p.shape)))\n",
    "    for p in model.features[i][0].parameters():\n",
    "        conv_params+=np.prod(np.array(list(p.shape)))\n",
    "    count += bn_params + conv_params\n",
    "    conv_frac = conv_params/total * 100\n",
    "    bn_frac = bn_params/total * 100\n",
    "    print (f'layer {i} Conv params&{conv_params}&{conv_frac:.2f}\\\\\\\\')\n",
    "    print (f'layer {i} BN params&{bn_params}&{bn_frac:.2f}\\\\\\\\')\n",
    "    print ('\\midrule')\n",
    "\n",
    "cls_params = 0\n",
    "for p in model.classifier.parameters():\n",
    "    cls_params+=np.prod(np.array(list(p.shape)))\n",
    "cls_frac = cls_params/total * 100\n",
    "print (f'classifier params&{cls_params}&{cls_frac:.2f}\\\\\\\\')\n",
    "\"\"\""
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "myenv",
   "language": "python",
   "name": "myenv"
  },
  "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}