examples/1D_DoubleWell.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Adversarial attacks on 1D double well potential\n",
    "\n",
    "In this notebook, we reproduce the example of adversarial attacks on the asymetric 1D double well shown in the supporting information of [our paper](https://arxiv.org/abs/2101.11588).\n",
    "\n",
    "The notebook uses the models and the helper functions in the `robust` folder of this repo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.append('..')\n",
    "\n",
    "import robust as rb\n",
    "import torch as ch\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from scipy import stats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating the 1D double well\n",
    "\n",
    "Using the potentials available at the `robust` module, we created an asymetric 1D double well with the desired zeros, depth and offset. In particular, the equation for the potential is the following:\n",
    "\n",
    "$$E(x) = 5 x^4 - 10 x^2 + 1.5 x$$\n",
    "\n",
    "Then, the `potential` object creates the training set, the `true_potential` is used for the evaluation (e.g. the surrogate model, or analogous to a FF or DFT calculation). We also select the plotting range for the potentials, in order to achieve a better visualization for this work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "WELL_ZEROS = 1\n",
    "WELL_DEPTH = 5\n",
    "WELL_OFFSET = 3\n",
    "\n",
    "ENERGY_THRESHOLD = -5.5\n",
    "\n",
    "potential = rb.potentials.MaskedDoubleWell.from_zeros_and_depth(\n",
    "    zeros=WELL_ZEROS,\n",
    "    depth=WELL_DEPTH,\n",
    "    offset=WELL_OFFSET,\n",
    "    emax=ENERGY_THRESHOLD,\n",
    "    energy_noise=0.0,\n",
    ")\n",
    "\n",
    "true_potential = rb.potentials.DoubleWell.from_zeros_and_depth(\n",
    "    zeros=WELL_ZEROS,\n",
    "    depth=WELL_DEPTH,\n",
    "    offset=WELL_OFFSET,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "../robust/data.py:76: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  return ch.tensor(tensor).reshape(len(tensor), -1)\n",
      "../robust/data.py:77: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  return ch.tensor(tensor)\n"
     ]
    }
   ],
   "source": [
    "PLOT_RANGE = 1.65\n",
    "\n",
    "x = ch.linspace(-PLOT_RANGE * WELL_ZEROS, PLOT_RANGE * WELL_ZEROS, steps=500)\n",
    "\n",
    "dset = rb.PotentialDataset(*potential(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "xplot = ch.linspace(-PLOT_RANGE * WELL_ZEROS, PLOT_RANGE * WELL_ZEROS, steps=250)\n",
    "xplot, eplot, fplot = potential(xplot, clip=False, add_noise=False)\n",
    "dplot = rb.PotentialDataset(xplot, eplot, fplot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "\n",
    "ax.plot(dplot.x, dplot.e, c='#d62728', label='ground truth', zorder=-1)\n",
    "ax.scatter(dset.x, dset.e, alpha=0.8, c='w', edgecolor='k', linewidths=0.5, label='training data')\n",
    "\n",
    "ax.set_xlabel('r')\n",
    "ax.set_ylabel('V(r)')\n",
    "\n",
    "ax.legend(frameon=False, bbox_to_anchor=(1.0, 0.3))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training the models\n",
    "\n",
    "Now, we select all hyperparameters of the models. The NN ensemble is generated from the `model_params`. The `loss_params` are used both for the training and adversarial loss, although the latter uses only the temperature. `score_params` uses some deduplication strategies, as explained in Sec. II-C of the paper. Afterwards, the initial pipeline (i.e. one loop cycle) is created, and the model is trained."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_params = {\n",
    "    'energy_coef': 1,\n",
    "    'forces_coef': 10,\n",
    "    'temperature': 5,\n",
    "}\n",
    "\n",
    "model_params = {\n",
    "    'input_dim': 1,\n",
    "    'num_layers': 4,\n",
    "    'layer_dim': 1024,\n",
    "    'num_networks': 5\n",
    "}\n",
    "\n",
    "optim_params = {\n",
    "    'lr': 1e-3,\n",
    "}\n",
    "\n",
    "train_params = {\n",
    "    'max_epochs': 500,\n",
    "    'batch_size': 35,\n",
    "}\n",
    "\n",
    "attack_params = {\n",
    "    'delta_std': 1e-2,\n",
    "    'optim_kws': optim_params,\n",
    "}\n",
    "\n",
    "score_params = {\n",
    "    'UncertaintyPercentile': {'percentile': 80},\n",
    "    'RmsdScore': {'threshold': 0.05},\n",
    "    'ClusterScore': {'threshold': 0.01},\n",
    "}\n",
    "\n",
    "prefix = 'models_1D'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "../robust/data.py:76: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  return ch.tensor(tensor).reshape(len(tensor), -1)\n",
      "../robust/data.py:77: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  return ch.tensor(tensor)\n"
     ]
    }
   ],
   "source": [
    "pipeline = rb.ForwardPipeline(\n",
    "    dset,\n",
    "    model_params,\n",
    "    loss_params,\n",
    "    optim_params,\n",
    "    train_params,\n",
    "    attack_params,\n",
    "    name=f\"{prefix}/gen_1\",\n",
    ")\n",
    "\n",
    "# If you don't have a GPU, set DEVICE to 'cpu'\n",
    "DEVICE = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "loop = rb.actlearn.ActiveLearning(\n",
    "    pipeline,\n",
    "    true_potential,\n",
    "    device=DEVICE,\n",
    "    train_epochs=400,\n",
    "    attack_epochs=400,\n",
    "    scores=score_params,\n",
    "    num_generations=5,\n",
    "    name_prefix=prefix,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ACT_LEARN: GEN 1: training model\n",
      " Time | Epoch | Learning rate | Train loss | Validation loss | MAE Energy | MAE Forces | GPU Memory (MB)\n",
      "09:28 |    25 |     1.000e-03 |   295.2845 |        376.7279 |     2.8200 |    27.5332 |             110\n",
      "09:30 |    50 |     1.000e-03 |   284.9616 |        382.2017 |     1.7008 |    27.4558 |             110\n",
      "09:31 |    75 |     1.000e-03 |   283.4744 |        364.4057 |     1.4696 |    27.0801 |             110\n",
      "09:32 |   100 |     1.000e-03 |   181.2429 |        177.2878 |     2.5489 |    18.1723 |             110\n",
      "09:34 |   125 |     1.000e-03 |    15.6866 |         24.0649 |     0.9494 |     5.8052 |             110\n",
      "09:36 |   150 |     1.000e-03 |    10.3059 |         11.0350 |     0.5938 |     4.2531 |             110\n",
      "09:37 |   175 |     1.000e-03 |     6.0369 |          9.6108 |     0.7520 |     3.5627 |             110\n",
      "09:39 |   200 |     1.000e-03 |     4.4400 |          9.7781 |     0.3036 |     3.7872 |             110\n",
      "09:41 |   225 |     1.000e-03 |     2.2895 |          3.1145 |     0.1357 |     2.1311 |             110\n",
      "09:43 |   250 |     1.000e-03 |     1.7146 |          6.1765 |     0.4413 |     3.3545 |             110\n",
      "09:45 |   275 |     1.000e-03 |     0.9044 |          1.3616 |     0.2505 |     1.4003 |             110\n",
      "09:47 |   300 |     1.000e-03 |     1.4793 |          0.5295 |     0.1412 |     0.9922 |             110\n",
      "09:49 |   325 |     1.000e-03 |     0.8501 |          0.3972 |     0.1583 |     0.9019 |             110\n",
      "09:51 |   350 |     1.000e-03 |     0.2130 |          0.1159 |     0.0363 |     0.4021 |             110\n",
      "09:53 |   375 |     1.000e-03 |     0.2248 |          0.4622 |     0.0968 |     0.6727 |             110\n",
      "09:55 |   400 |     1.000e-03 |     0.2170 |          0.2045 |     0.0606 |     0.4945 |             110\n",
      "ACT_LEARN: GEN 1: evaluating\n",
      "ACT_LEARN: GEN 1: attacking\n",
      "ACT_LEARN: GEN 1: evaluating attack\n",
      "ACT_LEARN: GEN 2: training model\n",
      " Time | Epoch | Learning rate | Train loss | Validation loss | MAE Energy | MAE Forces | GPU Memory (MB)\n",
      "10:12 |    25 |     1.000e-03 |   279.0171 |        322.0359 |     3.1347 |    25.2663 |             237\n",
      "10:14 |    50 |     1.000e-03 |   178.5587 |        204.6974 |     3.4411 |    19.6161 |             237\n",
      "10:16 |    75 |     1.000e-03 |   141.3008 |        144.6605 |     2.4822 |    16.3865 |             237\n",
      "10:18 |   100 |     1.000e-03 |   126.2063 |         63.8595 |     0.8644 |    11.7722 |             237\n",
      "10:20 |   125 |     1.000e-03 |    29.9883 |         43.2612 |     4.3760 |     7.9039 |             237\n",
      "10:21 |   150 |     1.000e-03 |     1.6665 |          2.2340 |     0.7268 |     1.8385 |             237\n",
      "10:23 |   175 |     1.000e-03 |     3.0044 |          3.3956 |     0.7034 |     2.4849 |             237\n",
      "10:25 |   200 |     1.000e-03 |     2.5351 |          8.2526 |     1.0079 |     3.9744 |             237\n",
      "10:27 |   225 |     1.000e-03 |     0.9785 |          0.6286 |     0.1597 |     1.0208 |             237\n",
      "10:29 |   250 |     1.000e-03 |     0.6095 |          1.1251 |     0.0722 |     1.2368 |             237\n",
      "10:31 |   275 |     1.000e-03 |     1.4119 |          0.8587 |     0.2425 |     1.2196 |             237\n",
      "10:33 |   300 |     1.000e-03 |     1.6863 |          0.7712 |     0.2663 |     1.1188 |             237\n",
      "10:35 |   325 |     5.000e-04 |     0.4903 |          0.3639 |     0.1497 |     0.7561 |             237\n",
      "10:37 |   350 |     5.000e-04 |     0.4751 |          0.3788 |     0.3858 |     0.7965 |             237\n",
      "10:39 |   375 |     5.000e-04 |     0.4241 |          0.3750 |     0.0522 |     0.6775 |             237\n",
      "10:41 |   400 |     5.000e-04 |     0.5664 |          0.2589 |     0.1290 |     0.6664 |             237\n",
      "ACT_LEARN: GEN 2: evaluating\n",
      "ACT_LEARN: GEN 2: attacking\n",
      "ACT_LEARN: GEN 2: evaluating attack\n",
      "ACT_LEARN: GEN 3: training model\n",
      " Time | Epoch | Learning rate | Train loss | Validation loss | MAE Energy | MAE Forces | GPU Memory (MB)\n",
      "11:02 |    25 |     1.000e-03 |  1344.5215 |        269.0582 |     8.5189 |    22.2170 |             363\n",
      "11:04 |    50 |     1.000e-03 |   116.9960 |         78.6661 |     1.3147 |    11.9953 |             363\n",
      "11:06 |    75 |     1.000e-03 |    18.0399 |         11.1707 |     3.5924 |     3.6940 |             363\n",
      "11:08 |   100 |     1.000e-03 |     5.0096 |          2.6138 |     1.1709 |     2.3084 |             363\n",
      "11:10 |   125 |     1.000e-03 |     1.7389 |          1.8463 |     0.3902 |     1.6365 |             363\n",
      "11:12 |   150 |     1.000e-03 |     0.6429 |          0.5196 |     0.2811 |     0.8663 |             363\n",
      "11:14 |   175 |     1.000e-03 |     0.3895 |          0.2627 |     0.1577 |     0.6934 |             363\n",
      "11:17 |   200 |     1.000e-03 |     0.3358 |          0.3336 |     0.2146 |     0.7018 |             363\n",
      "11:19 |   225 |     1.000e-03 |     4.0220 |          0.9147 |     0.1679 |     1.1721 |             363\n",
      "11:21 |   250 |     1.000e-03 |     4.1894 |          4.9246 |     0.2678 |     2.0996 |             363\n",
      "11:23 |   275 |     5.000e-04 |     0.2203 |          0.3748 |     0.2351 |     0.7674 |             363\n",
      "11:25 |   300 |     5.000e-04 |     0.1962 |          0.1158 |     0.1987 |     0.4356 |             363\n",
      "11:27 |   325 |     5.000e-04 |     0.1428 |          0.1173 |     0.1773 |     0.4633 |             363\n",
      "11:29 |   350 |     5.000e-04 |     0.1125 |          0.0938 |     0.1774 |     0.3643 |             363\n",
      "11:31 |   375 |     5.000e-04 |     0.1006 |          0.0699 |     0.1975 |     0.3351 |             363\n",
      "11:33 |   400 |     5.000e-04 |     0.0923 |          0.0753 |     0.2070 |     0.3356 |             363\n",
      "ACT_LEARN: GEN 3: evaluating\n",
      "ACT_LEARN: GEN 3: attacking\n",
      "ACT_LEARN: GEN 3: evaluating attack\n",
      "ACT_LEARN: GEN 4: training model\n",
      " Time | Epoch | Learning rate | Train loss | Validation loss | MAE Energy | MAE Forces | GPU Memory (MB)\n",
      "11:51 |    25 |     1.000e-03 |  2678.4298 |        231.0238 |    26.5733 |    19.1989 |             489\n",
      "11:53 |    50 |     1.000e-03 |   214.8908 |          9.7085 |     3.8743 |     4.1105 |             489\n",
      "11:56 |    75 |     1.000e-03 |   180.7525 |          8.9499 |     4.4667 |     3.8595 |             489\n",
      "11:59 |   100 |     5.000e-04 |   188.2323 |         36.3038 |     2.0975 |     8.9219 |             489\n",
      "12:01 |   125 |     5.000e-04 |   198.3252 |         24.8399 |     2.4540 |     6.4368 |             489\n",
      "12:04 |   150 |     5.000e-04 |   166.2380 |         11.1422 |     2.8606 |     4.4495 |             489\n",
      "12:07 |   175 |     5.000e-04 |   183.0471 |         16.4645 |     1.0926 |     4.8746 |             489\n",
      "12:10 |   200 |     5.000e-04 |   162.2991 |         17.1638 |     0.5643 |     5.3090 |             489\n",
      "12:12 |   225 |     5.000e-04 |   172.3721 |         13.9690 |     1.1236 |     4.7408 |             489\n",
      "12:15 |   250 |     2.500e-04 |   142.7752 |         10.9522 |     0.5251 |     4.4207 |             489\n",
      "12:18 |   275 |     2.500e-04 |   205.8059 |         33.3740 |     1.1158 |     8.0428 |             489\n",
      "12:21 |   300 |     2.500e-04 |   131.4903 |          6.2427 |     1.5199 |     3.1738 |             489\n",
      "12:23 |   325 |     2.500e-04 |   130.8973 |         10.6776 |     1.4693 |     4.7778 |             489\n",
      "12:26 |   350 |     2.500e-04 |   131.3055 |          6.8869 |     2.2579 |     3.6810 |             489\n",
      "12:29 |   375 |     2.500e-04 |   102.7266 |          7.4441 |     3.4825 |     3.7683 |             489\n",
      "12:32 |   400 |     2.500e-04 |    85.9994 |          8.4274 |     3.4969 |     4.1512 |             489\n",
      "ACT_LEARN: GEN 4: evaluating\n",
      "ACT_LEARN: GEN 4: attacking\n",
      "ACT_LEARN: GEN 4: evaluating attack\n",
      "ACT_LEARN: GEN 5: training model\n",
      " Time | Epoch | Learning rate | Train loss | Validation loss | MAE Energy | MAE Forces | GPU Memory (MB)\n",
      "13:01 |    25 |     1.000e-03 |   470.0026 |         47.6512 |    10.1524 |     8.2301 |             616\n",
      "13:04 |    50 |     1.000e-03 |   141.4746 |         25.0628 |    11.5833 |     5.6506 |             616\n",
      "13:07 |    75 |     1.000e-03 |    51.1706 |         25.9619 |     1.9395 |     6.7815 |             616\n",
      "13:10 |   100 |     1.000e-03 |    21.7172 |          1.2421 |     0.5118 |     1.2925 |             616\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13:13 |   125 |     1.000e-03 |     2.9218 |          0.0893 |     0.3497 |     0.3443 |             616\n",
      "13:15 |   150 |     1.000e-03 |    21.2032 |          0.9422 |     0.1619 |     1.0922 |             616\n",
      "13:17 |   175 |     1.000e-03 |    11.7749 |          1.1008 |     0.3576 |     1.3047 |             616\n",
      "13:18 |   200 |     1.000e-03 |     2.8552 |          1.0912 |     0.3611 |     1.1982 |             616\n",
      "13:19 |   225 |     5.000e-04 |     1.0071 |          0.2924 |     0.1077 |     0.6020 |             616\n",
      "13:22 |   250 |     5.000e-04 |     0.2478 |          0.0316 |     0.0766 |     0.2118 |             616\n",
      "13:25 |   275 |     5.000e-04 |     0.2635 |          0.0145 |     0.1489 |     0.1568 |             616\n",
      "13:28 |   300 |     5.000e-04 |     0.0704 |          0.0091 |     0.1757 |     0.1209 |             616\n",
      "13:30 |   325 |     5.000e-04 |     0.0915 |          0.0103 |     0.1728 |     0.1225 |             616\n",
      "13:32 |   350 |     5.000e-04 |     0.2365 |          0.0066 |     0.2004 |     0.0989 |             616\n",
      "13:35 |   375 |     5.000e-04 |     0.0424 |          0.0059 |     0.1700 |     0.0930 |             616\n",
      "13:38 |   400 |     5.000e-04 |     0.0340 |          0.0060 |     0.1868 |     0.0860 |             616\n",
      "ACT_LEARN: GEN 5: evaluating\n",
      "ACT_LEARN: GEN 5: attacking\n",
      "ACT_LEARN: GEN 5: evaluating attack\n"
     ]
    }
   ],
   "source": [
    "loop.loop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting the evolution of the active learning loop\n",
    "\n",
    "This plot reproduces Fig. S3 of the paper. It essentially shows all adversarial attacks and the evolution of the uncertainty/loss across generations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "../robust/data.py:76: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  return ch.tensor(tensor).reshape(len(tensor), -1)\n",
      "../robust/data.py:77: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  return ch.tensor(tensor)\n",
      "../robust/data.py:76: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  return ch.tensor(tensor).reshape(len(tensor), -1)\n",
      "../robust/data.py:77: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  return ch.tensor(tensor)\n",
      "../robust/data.py:76: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  return ch.tensor(tensor).reshape(len(tensor), -1)\n",
      "../robust/data.py:77: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  return ch.tensor(tensor)\n",
      "../robust/data.py:76: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  return ch.tensor(tensor).reshape(len(tensor), -1)\n",
      "../robust/data.py:77: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  return ch.tensor(tensor)\n",
      "../robust/data.py:76: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  return ch.tensor(tensor).reshape(len(tensor), -1)\n",
      "../robust/data.py:77: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  return ch.tensor(tensor)\n",
      "../robust/data.py:76: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  return ch.tensor(tensor).reshape(len(tensor), -1)\n",
      "../robust/data.py:77: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  return ch.tensor(tensor)\n",
      "../robust/data.py:76: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  return ch.tensor(tensor).reshape(len(tensor), -1)\n",
      "../robust/data.py:77: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  return ch.tensor(tensor)\n",
      "../robust/data.py:76: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  return ch.tensor(tensor).reshape(len(tensor), -1)\n",
      "../robust/data.py:77: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  return ch.tensor(tensor)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x720 with 20 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "N_GENS = len(loop.generations)\n",
    "N_PLOTS = 4\n",
    "PERCENTILE = 80\n",
    "\n",
    "fig, ax_fig = plt.subplots(N_GENS, N_PLOTS, figsize=(N_PLOTS * 4, N_GENS * 2), sharex=True)\n",
    "\n",
    "for gen, ax_row in zip(loop.generations, ax_fig):\n",
    "    pipeline = gen['pipeline']\n",
    "    attacks = gen['attacks']\n",
    "    attacks_truth = rb.PotentialDataset(*true_potential(attacks.x))\n",
    "\n",
    "    train_model, _, _ = pipeline.evaluate(pipeline.train_loader, DEVICE)\n",
    "    dplot_model, _, _ = pipeline.evaluate(dplot.get_loader(train_params['batch_size']), DEVICE)\n",
    "    \n",
    "    ax = ax_row[0]\n",
    "    ax.plot(dplot.x, dplot.e, c='#d62728', label='ground truth', zorder=-1)\n",
    "    ax.plot(dplot_model.x, dplot_model.e.mean(-1), c='#2ca02c', label='prediction')\n",
    "    ax.scatter(\n",
    "        pipeline.dset.x,\n",
    "        pipeline.dset.e,\n",
    "        c='w',\n",
    "        linewidths=0.5,\n",
    "        edgecolor='k',\n",
    "        label='training data',\n",
    "    )\n",
    "    \n",
    "    ax.scatter(\n",
    "        pipeline.dset_train.x,\n",
    "        pipeline.dset_train.e,\n",
    "        c='w',\n",
    "        linewidths=0.5,\n",
    "        edgecolor='k',\n",
    "        label='training data',\n",
    "    )\n",
    "\n",
    "    if len(attacks) > 0:\n",
    "        ax.scatter(\n",
    "            attacks_truth.x,\n",
    "            attacks_truth.e,\n",
    "            c='k',\n",
    "            label='attacks',\n",
    "        )\n",
    "\n",
    "    ax = ax_row[1]\n",
    "    ax.semilogy(dplot_model.x, dplot_model.e.var(-1), alpha=0.8, c='#2ca02c', label='prediction')\n",
    "    ax.scatter(\n",
    "        train_model.x,\n",
    "        train_model.e.var(-1),\n",
    "        c='w',\n",
    "        linewidths=0.5,\n",
    "        edgecolor='k',\n",
    "        label='training data'\n",
    "    )\n",
    "        \n",
    "    if len(attacks) > 0:\n",
    "        ax.scatter(\n",
    "            attacks.x,\n",
    "            attacks.e.var(-1),\n",
    "            c='k',\n",
    "            label='attacks',\n",
    "        )\n",
    "\n",
    "    threshold = stats.scoreatpercentile(train_model.e.var(-1), PERCENTILE)\n",
    "\n",
    "    xlim = ax.get_xlim()\n",
    "    ax.plot(xlim, [threshold] * 2, 'k--', label=f'{PERCENTILE}th percentile')\n",
    "    ax.set_xlim(xlim)\n",
    "\n",
    "    ax = ax_row[2]\n",
    "    ax.semilogy(dplot_model.x, dplot_model.f.var(-1), alpha=0.8, c='#2ca02c', label='prediction')\n",
    "    ax.scatter(\n",
    "        train_model.x,\n",
    "        train_model.f.var(-1),\n",
    "        c='w',\n",
    "        linewidths=0.5,\n",
    "        edgecolor='k',\n",
    "        label='training data',\n",
    "        zorder=2,\n",
    "    )\n",
    "    \n",
    "    if len(attacks) > 0:\n",
    "        ax.scatter(\n",
    "            attacks.x,\n",
    "            attacks.f.var(-1),\n",
    "            c='k',\n",
    "            label='attacks',\n",
    "            zorder=2,\n",
    "        )\n",
    "\n",
    "    threshold = stats.scoreatpercentile(train_model.f.var(-1), PERCENTILE)\n",
    "    if gen['generation'] == 1:\n",
    "        first_gen_fthreshold = threshold\n",
    "    \n",
    "    xlim = ax.get_xlim()\n",
    "    ax.plot(xlim, [threshold] * 2, 'k--', label=f'{PERCENTILE}th percentile')\n",
    "    ax.set_xlim(xlim)\n",
    "\n",
    "    ax = ax_row[3]\n",
    "    adv_loss = pipeline.get_adv_loss()\n",
    "    \n",
    "    ax.semilogy(\n",
    "        dplot_model.x,\n",
    "        -adv_loss.loss_fn(dplot_model.x, dplot_model.e, dplot_model.f),\n",
    "        alpha=0.8,\n",
    "        c='#2ca02c',\n",
    "        label='prediction'\n",
    "    )\n",
    "    ax.scatter(\n",
    "        train_model.x,\n",
    "        -adv_loss.loss_fn(train_model.x, train_model.e, train_model.f),\n",
    "        c='w',\n",
    "        linewidths=0.5,\n",
    "        edgecolor='k',\n",
    "        label='training data'\n",
    "    )\n",
    "    \n",
    "    if len(attacks) > 0:\n",
    "        ax.scatter(\n",
    "            attacks.x,\n",
    "            -adv_loss.loss_fn(attacks.x, attacks.e, attacks.f),\n",
    "            c='k',\n",
    "            label='attacks',\n",
    "        )\n",
    "\n",
    "ax_fig[0, 0].set_title('E')\n",
    "ax_fig[0, 1].set_title('Var[E]')\n",
    "ax_fig[0, 2].set_title('Var[F]')\n",
    "ax_fig[0, 3].set_title('Adv Loss')\n",
    "\n",
    "for i, ax in enumerate(ax_fig[:, 0], 1):\n",
    "    ax.set_ylabel(f'Gen {i}')\n",
    "\n",
    "for ax in ax_fig[-1, :]:\n",
    "    ax.set_xlabel('r')\n",
    "\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "nff",
   "language": "python",
   "name": "nff"
  },
  "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.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}