za_local_linearity.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "65a5dc59-663b-4a6e-b272-297e25490f5e",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/data/vision/torralba/naturally_robust_models/.local/lib/python3.10/site-packages/matplotlib/projections/__init__.py:63: UserWarning: Unable to import Axes3D. This may be due to multiple versions of Matplotlib being installed (e.g. as a system package and as a pip package). As a result, the 3D projection is not available.\n",
      "  warnings.warn(\"Unable to import Axes3D. This may be due to multiple versions of \"\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8c949049-a5a2-49cd-840e-3b4177655a29",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/data/vision/torralba/naturally_robust_models/.local/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import timm\n",
    "import numpy as np\n",
    "import torchvision\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import robustbench\n",
    "\n",
    "device = torch.device('cuda', 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c2c5962",
   "metadata": {},
   "source": [
    "## Utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "47afd44f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def abs_normalize(x, q=None, start_dim=-3):\n",
    "  s = torch.quantile(x.abs().flatten(start_dim=start_dim), q=max(q, 1-q), dim=-1, keepdim=False)\n",
    "  x = 0.5 + 0.5 * x/s[(..., ) + (None,)*(-start_dim)]\n",
    "\n",
    "  x = torch.clamp(x, 0., 1.)\n",
    "  return x\n",
    "  \n",
    "def plot_side_by_side_normalize(*images, normalize):\n",
    "  plt.figure(figsize=(20,20))\n",
    "  assert len(images) == len(normalize)\n",
    "  columns = len(images)\n",
    "  for i, image in enumerate(images):\n",
    "      plt.subplot(len(images) // columns + 1, columns, i + 1)\n",
    "      image = image.detach()\n",
    "      with torch.no_grad():\n",
    "        if image.shape[-1] > 3:\n",
    "          image = image.permute(1, 2, 0)\n",
    "        if normalize[i]:\n",
    "          image = abs_normalize(image, q=0.01)\n",
    "        plt.imshow(image, cmap='gray')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6a8e1033",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Callable, Any\n",
    "\n",
    "def get_output(module, input, output):\n",
    "    return output\n",
    "\n",
    "def get_input(module, input, output):\n",
    "    return input\n",
    "\n",
    "def get_input_output(module, input, output):\n",
    "    return input, output\n",
    "\n",
    "def get_module_input_output(module, input, output):\n",
    "    return module, input, output\n",
    "\n",
    "def register_hook_fn_to_module(model: nn.Module, module_name: str, hook_fn: Callable[[nn.Module, torch.Tensor, torch.Tensor], Any]):\n",
    "    results_dict = {}\n",
    "    for name, m in model.named_modules():\n",
    "        if module_name == name:\n",
    "            handle = m.register_forward_hook(_hook_fn_cntr(name, results_dict, hook_fn))\n",
    "            return handle, results_dict\n",
    "\n",
    "def register_bkw_hook_fn_to_module(model: nn.Module, module_name: str, hook_fn: Callable[[nn.Module, torch.Tensor, torch.Tensor], Any]):\n",
    "    results_dict = {}\n",
    "    for name, m in model.named_modules():\n",
    "        if module_name == name:\n",
    "            handle = m.register_full_backward_hook(_hook_fn_cntr(name, results_dict, hook_fn))\n",
    "            return handle, results_dict\n",
    "\n",
    "def register_hook_fn_to_all_modules(model: nn.Module, hook_fn: Callable[[nn.Module, torch.Tensor, torch.Tensor], Any]):\n",
    "    results_dict = {}\n",
    "    for name, m in model.named_modules():\n",
    "        _ = m.register_forward_hook(_hook_fn_cntr(name, results_dict, hook_fn))\n",
    "    return results_dict\n",
    "\n",
    "def register_bkw_hook_fn_to_all_modules(model: nn.Module, hook_fn: Callable[[nn.Module, torch.Tensor, torch.Tensor], Any]):\n",
    "    results_dict = {}\n",
    "    for name, m in model.named_modules():\n",
    "        _ = m.register_full_backward_hook(_hook_fn_cntr(name, results_dict, hook_fn))\n",
    "    return results_dict\n",
    "\n",
    "def _hook_fn_cntr(name, activation_dict, hook_fn):\n",
    "    def hook(model, input, output):\n",
    "        activation_dict[name] = hook_fn(model, input, output)\n",
    "    return hook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f29a5164-3b97-40ee-952d-e01c4fca3181",
   "metadata": {},
   "outputs": [],
   "source": [
    "from timm.data import resolve_data_config\n",
    "from timm.data.transforms_factory import create_transform\n",
    "\n",
    "\n",
    "def replace_layers(model, old, new):\n",
    "    for n, module in model.named_children():\n",
    "        if len(list(module.children())) > 0:\n",
    "            ## compound module, go inside it\n",
    "            replace_layers(module, old, new)\n",
    "            \n",
    "        if isinstance(module, old):\n",
    "            ## simple module\n",
    "            setattr(model, n, new)\n",
    "\n",
    "def add_imagenet_normalization(model):\n",
    "  val_transform = create_transform(\n",
    "    **resolve_data_config(model.pretrained_cfg, model=model),\n",
    "    is_training=False,\n",
    "  )\n",
    "\n",
    "  normalize_transform = val_transform.transforms[-1]\n",
    "  model = nn.Sequential(normalize_transform, model)\n",
    "  return model\n",
    "\n",
    "def load_model(path, ema=False):\n",
    "    model_kwargs=dict({\n",
    "            'num_classes': 1000,\n",
    "            'drop_rate': 0.0,\n",
    "            'drop_path_rate': 0.0,\n",
    "            'drop_block_rate': None,\n",
    "            'global_pool': None,\n",
    "            'bn_momentum': None,\n",
    "            'bn_eps': None,\n",
    "    })\n",
    "    if '_resnet_' in path:\n",
    "      model = timm.models.create_model('resnet50', pretrained=False, **model_kwargs)\n",
    "      if '_gelu' in path:\n",
    "        replace_layers(model, nn.ReLU, nn.GELU())\n",
    "    elif '_swinb' in path:\n",
    "      model = timm.models.create_model('swin_base_patch4_window7_224', pretrained=False, **model_kwargs)\n",
    "    elif '_swins' in path:\n",
    "      model = timm.models.create_model('swin_small_patch4_window7_224', pretrained=False, **model_kwargs)\n",
    "    ckpt = torch.load(path, map_location='cpu')\n",
    "    if ema:\n",
    "      if 'state_dict_ema' in ckpt:\n",
    "        model.load_state_dict(ckpt['state_dict_ema'])\n",
    "      else:\n",
    "        return None\n",
    "    else:\n",
    "      model.load_state_dict(ckpt['state_dict'])\n",
    "\n",
    "    model = add_imagenet_normalization(model)\n",
    "    return model.eval().cpu()\n",
    "\n",
    "def load_public_model(model_name):\n",
    "  if model_name[0].isupper():\n",
    "    return robustbench.utils.load_model(model_name, dataset='imagenet', threat_model='Linf').eval().to(device)\n",
    "  else:\n",
    "    if 'random' in model_name:\n",
    "      return add_imagenet_normalization(timm.create_model(model_name[:-len('_random')], pretrained=False).eval()).cpu()\n",
    "    else:\n",
    "      return add_imagenet_normalization(timm.create_model(model_name, pretrained=True).eval()).cpu()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ec7616c",
   "metadata": {},
   "source": [
    "## Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4e02b94d",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = torch.load('analysis_data/240206_gen_imagenet_data_10k_noattack.pth', map_location='cpu')\n",
    "# xs = torch.load('/data/vision/torralba/naturally_robust_models/input_norm/outputs/inputs/train_png/inputs.pth')\n",
    "# ys = torch.load('/data/vision/torralba/naturally_robust_models/input_norm/outputs/inputs/train_png/targets.pth')\n",
    "# data = {'xs':xs, 'ys':ys}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a4510def",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['xs', 'ys', 'at_outs', 'at_grads', 'gn_outs', 'gn_grads', 'sampler_indices'])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "73674b5f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/data/vision/torralba/naturally_robust_models/.local/lib/python3.10/site-packages/torch/functional.py:507: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at ../aten/src/ATen/native/TensorShape.cpp:3549.)\n",
      "  return _VF.meshgrid(tensors, **kwargs)  # type: ignore[attr-defined]\n"
     ]
    }
   ],
   "source": [
    "xs = data['xs']\n",
    "ys = data['ys']\n",
    "\n",
    "N = 10000\n",
    "xs = xs[:N]\n",
    "ys = ys[:N]\n",
    "\n",
    "model = timm.create_model('swin_base_patch4_window7_224', pretrained=True)\n",
    "\n",
    "val_transform = create_transform(\n",
    "    **resolve_data_config(model.pretrained_cfg, model=model),\n",
    "    is_training=False,\n",
    "  )\n",
    "\n",
    "normalize_transform = val_transform.transforms[-1]\n",
    "\n",
    "if xs.min() < 0:\n",
    "  xs = xs*normalize_transform.std[None, :, None, None] + normalize_transform.mean[None, :, None, None]\n",
    "\n",
    "sampler_indices = range(N)\n",
    "ds = torch.utils.data.TensorDataset(xs, ys)\n",
    "\n",
    "from tqdm.auto import tqdm\n",
    "\n",
    "dataloader = torch.utils.data.DataLoader(\n",
    "    ds,\n",
    "    batch_size=10,\n",
    "    sampler=sampler_indices,\n",
    "    shuffle=False\n",
    ")\n",
    "\n",
    "def get_activations(module_name, model_path=None, model_name=None):\n",
    "  if model_path:\n",
    "    model = load_model(model_path)\n",
    "  elif model_name:\n",
    "    model = load_public_model(model_name)\n",
    "\n",
    "  model = model.to(device)\n",
    "\n",
    "  handle, act_dict = register_hook_fn_to_module(model, module_name, get_input_output)\n",
    "  \n",
    "  outs = []\n",
    "  grads = []\n",
    "  act_inputs = []\n",
    "  act_outputs = []\n",
    "\n",
    "  for ii, (x, y) in enumerate(tqdm(dataloader)):\n",
    "      x, y = x.to(device), y.to(device)\n",
    "      x.requires_grad_(True)\n",
    "\n",
    "      # Clean at\n",
    "      out = model(x)#.cpu()\n",
    "      loss = torch.nn.functional.cross_entropy(out, y)\n",
    "      act_input = act_dict[module_name][0][0].detach().cpu()\n",
    "      act_output = act_dict[module_name][1][0].detach().cpu() if isinstance(act_dict[module_name][1], tuple) else act_dict[module_name][1].detach().cpu()\n",
    "      grad_x = torch.autograd.grad(loss, x, create_graph=False, retain_graph=False)[0].detach().cpu() #.abs().sum(1, keepdim=True)\n",
    "      #logit = out[torch.arange(out.size(0)), y].sum()\n",
    "      #grad_x = torch.autograd.grad(logit, x, create_graph=False, retain_graph=False)[0].detach().cpu().abs().max(1, keepdim=True).values\n",
    "\n",
    "      outs.append(out.detach().cpu())\n",
    "      grads.append(grad_x)\n",
    "      act_inputs.append(act_input)\n",
    "      act_outputs.append(act_output)\n",
    "\n",
    "      if ii >= 2:\n",
    "        break\n",
    "  \n",
    "  outs = torch.cat(outs, 0)\n",
    "  grads = torch.cat(grads, 0)\n",
    "  act_inputs = torch.cat(act_inputs, 0)\n",
    "  act_outputs = torch.cat(act_outputs, 0)\n",
    "  handle.remove()\n",
    "\n",
    "  model = model.to('cpu')\n",
    "\n",
    "  return outs, grads, act_inputs, act_outputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "fb4599b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "random.seed(0)\n",
    "torch.manual_seed(0)\n",
    "np.random.seed(0)\n",
    "noise = torch.rand(2*xs.size(0), *xs.shape[1:])\n",
    "alpha = torch.rand((xs.size(0), 1, 1, 1))\n",
    "\n",
    "def measure_local_linearity(model, dataloader, eps=4./255.):\n",
    "  model.eval()\n",
    "  \n",
    "  lin_errs = []\n",
    "\n",
    "  for ii, (x, y) in enumerate(tqdm(dataloader)):\n",
    "      x, y = x.to(device), y.to(device)\n",
    "      bs = x.size(0)\n",
    "      noise_batch = noise[ii*2*bs:ii*2*bs + 2*bs].to(device)\n",
    "      alpha_batch = alpha[ii*bs:ii*bs + bs].to(device)\n",
    "      # print(alpha_batch.flatten(), y.flatten())\n",
    "\n",
    "      with torch.inference_mode():\n",
    "        # Get random triplet\n",
    "        x_ab = x.repeat([2,1,1,1]) \n",
    "        x_ab = x_ab + eps*(2*noise_batch - 1)\n",
    "        x_c = (1-alpha_batch)*x_ab[:bs] + alpha_batch*x_ab[bs:]\n",
    "        alpha_batch = alpha_batch.squeeze()\n",
    "\n",
    "        # Forward pass\n",
    "        criterion = torch.nn.CrossEntropyLoss(reduction='none')\n",
    "        losses = criterion(model(torch.cat((x_ab,x_c),dim=0)), y.repeat([3]))\n",
    "\n",
    "        # Regularization term\n",
    "        lin_err = torch.nn.functional.mse_loss(losses[2*bs:], (1-alpha_batch)*losses[:bs] + alpha_batch*losses[bs:2*bs], reduction='none')\n",
    "\n",
    "        lin_errs.append(lin_err)\n",
    "\n",
    "      # if ii >= 0:\n",
    "      #   break\n",
    "  \n",
    "  lin_errs = torch.cat(lin_errs, 0)\n",
    "\n",
    "  model = model.to('cpu')\n",
    "\n",
    "  return lin_errs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "a157f324",
   "metadata": {},
   "outputs": [],
   "source": [
    "def launch_measure_local_linearity(model_path=None, model_name=None):\n",
    "  if model_path:\n",
    "    model = load_model(model_path)\n",
    "    print(model_path)\n",
    "  elif model_name:\n",
    "    model = load_public_model(model_name)\n",
    "    print(model_name)\n",
    "\n",
    "  model = model.to(device)\n",
    "  model.eval()\n",
    "\n",
    "  lin_errs = measure_local_linearity(model, dataloader)\n",
    "  print(lin_errs.mean().item(), lin_errs.std().item())\n",
    "  return lin_errs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "8af3d068",
   "metadata": {},
   "outputs": [],
   "source": [
    "results_dict = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "9d88067a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def linear_stats(k):\n",
    "  x = results_dict[k]\n",
    "  return x.mean().item(), x.std().item()\n",
    "\n",
    "def log_stats(k):\n",
    "  x = results_dict[k] + 1e-17\n",
    "  return x.log10().mean().item(), x.log10().std().item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "56ea7f1f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "swin_base_patch4_window7_224\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1000/1000 [01:27<00:00, 11.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0035506850108504295 0.026853546500205994\n"
     ]
    }
   ],
   "source": [
    "results_dict['natural'] = launch_measure_local_linearity(model_name='swin_base_patch4_window7_224')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "28f7cad3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.0035506850108504295, 0.026853546500205994)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linear_stats('natural')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "f4fa1344",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-4.575085163116455, 1.6302542686462402)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log_stats('natural')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "0611f8c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "eccv_outputs/advtrain_swinb_orig/last.pth.tar\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1000/1000 [01:28<00:00, 11.33it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8.20592322270386e-06 5.080421396996826e-05\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "results_dict['advtrain'] = launch_measure_local_linearity(model_path=f'outputs/advtrain_swinb_orig/last.pth.tar')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "7f58811a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-6.843085765838623, 1.4834269285202026)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log_stats('advtrain')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "b053df81",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "eccv_outputs/gradnorm_swinb_variant/2024-02-14_11-30-41/last.pth.tar\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1000/1000 [01:27<00:00, 11.42it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.860778866102919e-05 0.0001646613236516714\n"
     ]
    }
   ],
   "source": [
    "results_dict['gradnorm_strong'] = launch_measure_local_linearity(model_path=f'outputs/gradnorm_swinb_variant/2024-02-14_11-30-41/last.pth.tar')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "d5a8d9f9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-6.604256629943848, 1.4254180192947388)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log_stats('gradnorm_strong')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "8323ee4d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "eccv_outputs/gradnorm_swinb_orig/last.pth.tar\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1000/1000 [01:27<00:00, 11.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.66052850545384e-05 0.00013138553185854107\n"
     ]
    }
   ],
   "source": [
    "results_dict['gradnorm_weak'] = launch_measure_local_linearity(model_path=f'outputs/gradnorm_swinb_orig/last.pth.tar')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "f3f91cce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-6.624663829803467, 1.422298550605774)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log_stats('gradnorm_weak')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "da1c1f06",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "swin_base_patch4_window7_224\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1000/1000 [01:27<00:00, 11.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0035506850108504295 0.026853546500205994\n"
     ]
    }
   ],
   "source": [
    "_ = launch_measure_local_linearity(model_name='swin_base_patch4_window7_224')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "fb2cbd2c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_fn(name, fn, *, index=Ellipsis, split=None, **kwargs):\n",
    "    _at_linerrs = results_dict['advtrain'][index].detach().cpu()\n",
    "    _gn_strong_linerrs = results_dict['gradnorm_strong'][index].detach().cpu()\n",
    "    _nat_linerrs = results_dict['natural'][index].detach().cpu()\n",
    "    print(_at_linerrs.shape, _gn_strong_linerrs.shape, _nat_linerrs.shape)\n",
    "    print(_at_linerrs.min(), _gn_strong_linerrs.min(), _nat_linerrs.min())\n",
    "    if split is None:\n",
    "        split = _at_linerrs.shape[0]\n",
    "    at_fn_v = torch.cat([fn(_x) for _x in _at_linerrs.split(split, dim=0)], 0)\n",
    "    gns_fn_v = torch.cat([fn(_x) for _x in _gn_strong_linerrs.split(split, dim=0)], 0)\n",
    "    nat_fn_v = torch.cat([fn(_x) for _x in _nat_linerrs.split(split, dim=0)], 0)\n",
    "    ax = sns.displot(data=pd.DataFrame(\n",
    "        {\n",
    "            name: torch.cat([at_fn_v, gns_fn_v, nat_fn_v], 0).numpy(),\n",
    "            \"Training\": (\n",
    "                ([f'Adversarial Training (PGD-3) (mean={at_fn_v.mean():.2e})'] * _at_linerrs.shape[0]) + \n",
    "                ([f'Gradient Norm Regularization (mean={gns_fn_v.mean():.2e})'] * _gn_strong_linerrs.shape[0]) + \n",
    "                ([f'Natural Training (mean={nat_fn_v.mean():.2e})'] * _nat_linerrs.shape[0])\n",
    "            )\n",
    "        }), kde=True, x=name, hue='Training', \n",
    "        palette = {\n",
    "            f'Adversarial Training (PGD-3) (mean={at_fn_v.mean():.2e})':'red', \n",
    "            f'Gradient Norm Regularization (mean={gns_fn_v.mean():.2e})':'blue',\n",
    "            f'Natural Training (mean={nat_fn_v.mean():.2e})':'orange'\n",
    "        }, **kwargs)\n",
    "    plt.gca().set_ylabel(f'Count (n={_at_linerrs.shape[0]})')\n",
    "    return ax.fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "5e4c14d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([10000]) torch.Size([10000]) torch.Size([10000])\n",
      "tensor(0.) tensor(0.) tensor(1.1746e-13)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 885.25x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plot_fn(r'Local linearity error', lambda x: x + 1e-16, \n",
    "        index=torch.arange(10000), log_scale=(True, False), alpha=0.4)\n",
    "fig.savefig('./figures_suppmat/local_linearity.pdf', facecolor='white')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "f2d3b9f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_fn(name, fn, *, index=Ellipsis, split=None, **kwargs):\n",
    "    _at_linerrs = results_dict['advtrain'][index].detach().cpu()\n",
    "    _gn_strong_linerrs = results_dict['gradnorm_strong'][index].detach().cpu()\n",
    "    print(_at_linerrs.shape, _gn_strong_linerrs.shape)\n",
    "    print(_at_linerrs.min(), _gn_strong_linerrs.min())\n",
    "    if split is None:\n",
    "        split = _at_linerrs.shape[0]\n",
    "    at_fn_v = torch.cat([fn(_x) for _x in _at_linerrs.split(split, dim=0)], 0)\n",
    "    gns_fn_v = torch.cat([fn(_x) for _x in _gn_strong_linerrs.split(split, dim=0)], 0)\n",
    "    ax = sns.displot(data=pd.DataFrame(\n",
    "        {\n",
    "            name: torch.cat([at_fn_v, gns_fn_v], 0).numpy(),\n",
    "            \"Training\": (\n",
    "                ([f'Adversarial Training (PGD-3) (mean={at_fn_v.mean():.2e})'] * _at_linerrs.shape[0]) + \n",
    "                ([f'Gradient Norm Regularization (mean={gns_fn_v.mean():.2e})'] * _gn_strong_linerrs.shape[0])\n",
    "            )\n",
    "        }), kde=True, x=name, hue='Training', \n",
    "        palette = {\n",
    "            f'Adversarial Training (PGD-3) (mean={at_fn_v.mean():.2e})':'red', \n",
    "            f'Gradient Norm Regularization (mean={gns_fn_v.mean():.2e})':'blue',\n",
    "        }, **kwargs)\n",
    "    plt.gca().set_ylabel(f'Count (n={_at_linerrs.shape[0]})')\n",
    "    return ax.fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "d9d8a233",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([10000]) torch.Size([10000])\n",
      "tensor(0.) tensor(0.)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 885.25x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plot_fn(r'Local linearity error', lambda x: x + 1e-16, \n",
    "        index=torch.arange(10000), log_scale=(True, False), alpha=0.4)\n",
    "fig.savefig('./figures_suppmat/local_linearity_nonat.pdf', facecolor='white')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.12 64-bit",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  },
  "vscode": {
   "interpreter": {
    "hash": "767d51c1340bd893661ea55ea3124f6de3c7a262a8b4abca0554b478b1e2ff90"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}