Lesson7_BP_GPR_MLP.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/cc-ats/mlp_tutorial/blob/main/Lesson7_BP_GPR_MLP.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Lesson 7: Behler-Parrinello Gaussian Process Regression (BP-GPR) for Machine Learning Potentials\n",
        "\n",
        "\n",
        "$\\Delta$MLP with PyTorch for the Claisen Rearrangement reaction\n",
        "\n",
        "For this tutorial, we will be combining the Gaussian Process Regression (GPR) from Lesson 2 and the symmetry functions from the Behler-Parrinello and ANI models from Lesson 4 to train a $\\Delta$ Machine Learning Potential ($\\Delta$MLP) model to reproduce the energy and forces for the Claisen Rearrangement reaction. With a BP-GPR, we can use the BP symmetry functions for feature extraction and the GPR kernel for predicting observables. The goal of this model is to train with data that is from semiempirical (PM3) and DFT (B3LYP) levels of theory. The BP-GPR model will be used to correct the semiempirical values to obtain DFT level accuracy, that makes it a $\\Delta$MLP model."
      ],
      "metadata": {
        "id": "6ZczLhOzG8Wc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Importing PyTorch Lightning and Libraries\n",
        "\n",
        "We will first install PyTorch Lightning and import libraries needed to train our machine learning models"
      ],
      "metadata": {
        "id": "v208qXsE8h4F"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%capture\n",
        "!pip install pytorch-lightning > /dev/null\n",
        "!pip install gpytorch > /dev/null\n",
        "\n",
        "import math\n",
        "from typing import Sequence, Tuple\n",
        "\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "from torch import Tensor\n",
        "import gpytorch\n",
        "\n",
        "from torch.utils.data import TensorDataset, DataLoader, random_split\n",
        "import pytorch_lightning as pl\n",
        "from pytorch_lightning import loggers as pl_loggers"
      ],
      "metadata": {
        "id": "uuyTEvnmwHBc"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Defining Symmetry Functions\n",
        "\n",
        "Now we will define the radial symmetry functions:\n",
        "\n",
        "pairwise_vector: Distance function for calculating distances between each atom.\n",
        "\n",
        "symmetry_function_g1: BP radial symmetry function.\n",
        "\n",
        "symmetry_function_g2: BP angular symmetry function.\n",
        "\n",
        "symmetry_function_g2ani: ANI angular symmetry function"
      ],
      "metadata": {
        "id": "ng2talt98vmg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def pairwise_vector(coords: Tensor) -> Tensor:\n",
        "    num_batches, num_channels, _ = coords.size()\n",
        "    rij = coords[:, :, None] - coords[:, None]\n",
        "    mask = ~torch.eye(num_channels, dtype=torch.bool, device=coords.device) # remove self-interaction\n",
        "    rij = torch.masked_select(rij, mask.unsqueeze(2)).view(num_batches, num_channels, num_channels - 1, 3)\n",
        "    return rij\n",
        "\n",
        "def symmetry_function_g1(rij: Tensor, Rcr: float, EtaR: Tensor, ShfR: Tensor) -> Tensor:\n",
        "    dij = torch.norm(rij, dim=3)\n",
        "    fij = (torch.cos(dij / Rcr * math.pi) + 1) * 0.5 * (dij <= Rcr)\n",
        "    g1 = torch.sum(torch.exp(-EtaR.unsqueeze(dim=2) * (dij.unsqueeze(dim=-1) - ShfR.unsqueeze(dim=2))**2) * fij.unsqueeze(dim=-1), dim=2)\n",
        "    return g1\n",
        "\n",
        "def symmetry_function_g2(rij: Tensor, Rca: float, Zeta: Tensor, EtaA: Tensor, LamA: Tensor) -> Tensor:\n",
        "    c = torch.combinations(torch.arange(rij.size(2)), r=2)\n",
        "    #print(c)\n",
        "    rij = rij[:, :, c]\n",
        "    r12 = rij[:, :, :, 0]\n",
        "    r13 = rij[:, :, :, 1]\n",
        "    r23 = r12 - r13\n",
        "    d12 = torch.norm(r12, dim=3)\n",
        "    d13 = torch.norm(r13, dim=3)\n",
        "    d23 = torch.norm(r23, dim=3)\n",
        "    f12 = (torch.cos(d12 / Rca * math.pi) + 1) * 0.5\n",
        "    f13 = (torch.cos(d13 / Rca * math.pi) + 1) * 0.5\n",
        "    f23 = (torch.cos(d23 / Rca * math.pi) + 1) * 0.5\n",
        "    cosine = torch.einsum('ijkl,ijkl->ijk', r12, r13) / (d12 * d13)\n",
        "\n",
        "    g2 = torch.sum(2**(1 - Zeta.unsqueeze(dim=2)) * (1 + LamA.unsqueeze(dim=2) * cosine.unsqueeze(dim=-1))**Zeta.unsqueeze(dim=2) * torch.exp(-EtaA.unsqueeze(dim=2) * (d12**2 + d13**2 + d23**2).unsqueeze(dim=-1)) * (f12 * f13 * f23).unsqueeze(dim=-1), dim=2)\n",
        "    return g2\n",
        "\n",
        "def symmetry_function_g2ani(rij: Tensor, Rca: float, Zeta: Tensor, ShfZ: Tensor, EtaA: Tensor, ShfA: Tensor) -> Tensor:\n",
        "    c = torch.combinations(torch.arange(rij.size(2)), r=2)\n",
        "    rij = rij[:, :, c]\n",
        "    r12 = rij[:, :, :, 0]\n",
        "    r13 = rij[:, :, :, 1]\n",
        "\n",
        "    r23 = r12 - r13\n",
        "    d12 = torch.norm(r12, dim=3)\n",
        "    d13 = torch.norm(r13, dim=3)\n",
        "    f12 = (torch.cos(d12 / Rca * math.pi) + 1) * 0.5\n",
        "    f13 = (torch.cos(d13 / Rca * math.pi) + 1) * 0.5\n",
        "    cosine = torch.einsum('ijkl,ijkl->ijk', r12, r13) / (d12 * d13)\n",
        "    cosine = torch.cos(torch.acos(cosine).unsqueeze(dim=-1) - ShfA.unsqueeze(dim=2))\n",
        "    g2 = torch.sum(2**(1 - Zeta.unsqueeze(dim=2)) * (1 + cosine)**Zeta.unsqueeze(dim=2) * torch.exp(-EtaA.unsqueeze(dim=2) * (0.5 * (d12 + d13).unsqueeze(dim=-1) - ShfZ.unsqueeze(dim=2))**2) * (f12 * f13).unsqueeze(dim=-1), dim=2)\n",
        "    return g2"
      ],
      "metadata": {
        "id": "HGM0pzjQxA6J"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Defining Feature Extraction Classes"
      ],
      "metadata": {
        "id": "5BVuAjaQ83gz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Defining the BP Feature Class\n",
        "\n",
        "Now we will create the feature class, which takes input information and uses functions to extract characteristics unique to the called input features. Here we will be using the previously defined symmetry functions for feature extraction."
      ],
      "metadata": {
        "id": "JdnQPFmMsRo-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Feature(nn.Module):\n",
        "    def __init__(self, Rcr: float, EtaR: Tensor, ShfR: Tensor, Rca: float, Zeta: Tensor, EtaA: Tensor, LamA: Tensor) -> None:\n",
        "        super().__init__()\n",
        "        assert len(EtaR) == len(ShfR) == len(LamA)\n",
        "        assert len(Zeta) == len(EtaA)\n",
        "        self.Rcr = Rcr\n",
        "        self.Rca = Rca\n",
        "        self.EtaR = torch.Tensor(EtaR)\n",
        "        self.ShfR = torch.Tensor(ShfR)\n",
        "        self.Zeta = torch.Tensor(Zeta)\n",
        "        self.EtaA = torch.Tensor(EtaA)\n",
        "        self.LamA = torch.Tensor(LamA)\n",
        "\n",
        "    def forward(self, coords: Tensor, atom_types: Tensor) -> Tensor:\n",
        "        num_batches, num_channels, _ = coords.size()\n",
        "        rij = pairwise_vector(coords)\n",
        "        EtaR = self.EtaR.to(device=coords.device)[atom_types]\n",
        "        ShfR = self.ShfR.to(device=coords.device)[atom_types]\n",
        "        Zeta = self.Zeta.to(device=coords.device)[atom_types]\n",
        "        EtaA = self.EtaA.to(device=coords.device)[atom_types]\n",
        "        LamA = self.LamA.to(device=coords.device)[atom_types]\n",
        "        g1 = symmetry_function_g1(rij, self.Rcr, EtaR, ShfR)\n",
        "        g2 = symmetry_function_g2(rij, self.Rca, Zeta, EtaA, LamA)\n",
        "\n",
        "        return torch.concat((g1, g2), dim=2)\n",
        "\n",
        "    @property\n",
        "    def output_length(self) -> int:\n",
        "        return len(self.EtaR[0]) + len(self.EtaA[0])"
      ],
      "metadata": {
        "id": "FPztptTTxIFH"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Defining the ANI Feature Class\n",
        "\n",
        "We will create a similar feature class for ANI that uses the ANI angle symmetry function.\n"
      ],
      "metadata": {
        "id": "jLAoPesH87am"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class FeatureANI(nn.Module):\n",
        "    def __init__(self, Rcr: float, EtaR: Tensor, ShfR: Tensor, Rca: float, Zeta: Tensor, ShfZ: Tensor, EtaA: Tensor, ShfA: Tensor) -> None:\n",
        "        super().__init__()\n",
        "        assert len(EtaR) == len(ShfR)\n",
        "        assert len(Zeta) == len(ShfZ) == len(EtaA) == len(ShfA)\n",
        "        self.Rcr = Rcr\n",
        "        self.Rca = Rca\n",
        "        self.EtaR = torch.Tensor(EtaR)\n",
        "        self.ShfR = torch.Tensor(ShfR)\n",
        "        self.Zeta = torch.Tensor(Zeta)\n",
        "        self.ShfZ = torch.Tensor(ShfZ)\n",
        "        self.EtaA = torch.Tensor(EtaA)\n",
        "        self.ShfA = torch.Tensor(ShfA)\n",
        "\n",
        "    def forward(self, coords: Tensor, atom_types: Tensor) -> Tensor:\n",
        "        num_batches, num_channels, _ = coords.size()\n",
        "        rij = pairwise_vector(coords)\n",
        "        EtaR = self.EtaR.to(device=coords.device)[atom_types]\n",
        "        ShfR = self.ShfR.to(device=coords.device)[atom_types]\n",
        "        Zeta = self.Zeta.to(device=coords.device)[atom_types]\n",
        "        ShfZ = self.ShfZ.to(device=coords.device)[atom_types]\n",
        "        EtaA = self.EtaA.to(device=coords.device)[atom_types]\n",
        "        ShfA = self.ShfA.to(device=coords.device)[atom_types]\n",
        "        g1 = symmetry_function_g1(rij, self.Rcr, EtaR, ShfR)\n",
        "        g2 = symmetry_function_g2ani(rij, self.Rca, Zeta, ShfZ, EtaA, ShfA)\n",
        "\n",
        "        return torch.concat((g1, g2), dim=2)\n",
        "\n",
        "    @property\n",
        "    def output_length(self) -> int:\n",
        "        return len(self.EtaR[0]) + len(self.EtaA[0])"
      ],
      "metadata": {
        "id": "uLYEFnZexP4g"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Creating the BP-GPR Model\n"
      ],
      "metadata": {
        "id": "gyFHUEgp9CZy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Defining the BP-GPR Class\n",
        "\n",
        "This class will combine the symmetry functions with the GPR model."
      ],
      "metadata": {
        "id": "dL5HsXiEspio"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class BPGPR(gpytorch.models.ExactGP):\n",
        "    def __init__(self, descriptor: Tensor, Y: Tensor, likelihood, learning_rate=5e-4) -> None:\n",
        "        shape = descriptor.shape\n",
        "        X = descriptor #.reshape(shape[0], shape[1]*shape[2])\n",
        "        super(BPGPR, self).__init__(X, Y, likelihood)\n",
        "        self.mean_module = gpytorch.means.ConstantMean()\n",
        "        self.covar_module = gpytorch.kernels.ScaleKernel(gpytorch.kernels.RBFKernel())\n",
        "\n",
        "    def forward(self, x):\n",
        "        mean_x = self.mean_module(x)\n",
        "        covar_x = self.covar_module(x)\n",
        "        return gpytorch.distributions.MultivariateNormal(mean_x, covar_x)"
      ],
      "metadata": {
        "id": "lt8r5J9GxVpK"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Importing Data and Seeding\n",
        "\n",
        "We will now import our semiempirical and DFT calculation data."
      ],
      "metadata": {
        "id": "-7Tv-R5NJSuF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "ds = np.DataSource(None)\n",
        "\n",
        "qm_coord = np.array(np.load(ds.open(\"https://github.com/cc-ats/mlp_tutorial/raw/main/Claisen_Rearrangement/qm_coord.npy\", \"rb\")), dtype=\"float32\")\n",
        "atom_types = np.loadtxt(ds.open(\"https://github.com/cc-ats/mlp_tutorial/raw/main/Claisen_Rearrangement/qm_elem.txt\", \"r\"), dtype=int)\n",
        "\n",
        "elems = np.unique(atom_types).tolist()\n",
        "atom_types = np.array([[elems.index(i) for i in atom_types]])\n",
        "atom_types = atom_types.repeat(len(qm_coord), axis=0)\n",
        "\n",
        "energy = np.array((np.load(ds.open(\"https://github.com/cc-ats/mlp_tutorial/raw/main/Claisen_Rearrangement/energy.npy\", \"rb\")) - np.load(ds.open(\"https://github.com/cc-ats/mlp_tutorial/raw/main/Claisen_Rearrangement/energy_sqm.npy\", \"rb\"))) * 27.2114 * 23.061, dtype=\"float32\")\n",
        "energy = energy - energy.mean()\n",
        "qm_gradient = np.array((np.load(ds.open(\"https://github.com/cc-ats/mlp_tutorial/raw/main/Claisen_Rearrangement/qm_grad.npy\", \"rb\")) - np.load(ds.open(\"https://github.com/cc-ats/mlp_tutorial/raw/main/Claisen_Rearrangement/qm_grad_sqm.npy\", \"rb\"))) * 27.2114 * 23.061 / 0.529177249, dtype=\"float32\")\n",
        "\n",
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "\n",
        "qm_coord = torch.from_numpy(qm_coord).to(device)\n",
        "atom_types = torch.from_numpy(atom_types).to(device)\n",
        "energy = torch.from_numpy(energy).to(device)\n",
        "qm_gradient = torch.from_numpy(qm_gradient).to(device)"
      ],
      "metadata": {
        "id": "QTw4Jjy8tC6m"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Using ANI for Feature Extraction\n",
        "\n",
        "The ANI model is set to be used and the ANI parameters are defined.\n"
      ],
      "metadata": {
        "id": "s01tP30n9J1q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "ani = True\n",
        "\n",
        "if ani:\n",
        "  # From TorchANI\n",
        "  Rcr = 5.2000e+00\n",
        "  Rca = 3.5000e+00\n",
        "  EtaR = [1.6000000e+01]\n",
        "  ShfR = [9.0000000e-01,1.1687500e+00,1.4375000e+00,1.7062500e+00,1.9750000e+00,2.2437500e+00,2.5125000e+00,2.7812500e+00,3.0500000e+00,3.3187500e+00,3.5875000e+00,3.8562500e+00,4.1250000e+00,4.3937500e+00,4.6625000e+00,4.9312500e+00]\n",
        "  Zeta = [3.2000000e+01]\n",
        "  ShfZ = [1.9634954e-01,5.8904862e-01,9.8174770e-01,1.3744468e+00,1.7671459e+00,2.1598449e+00,2.5525440e+00,2.9452431e+00]\n",
        "  EtaA = [8.0000000e+00]\n",
        "  ShfA = [9.0000000e-01,1.5500000e+00,2.2000000e+00,2.8500000e+00]\n",
        "  EtaR, ShfR = np.array(np.meshgrid(EtaR, ShfR)).reshape(2, -1)\n",
        "  Zeta, ShfZ, EtaA, ShfA = np.array(np.meshgrid(Zeta, ShfZ, EtaA, ShfA)).reshape(4, -1)\n",
        "  EtaR = np.repeat([EtaR], 3, axis=0)\n",
        "  ShfR = np.repeat([ShfR], 3, axis=0)\n",
        "  Zeta = np.repeat([Zeta], 3, axis=0)\n",
        "  ShfZ = np.repeat([ShfZ], 3, axis=0)\n",
        "  EtaA = np.repeat([EtaA], 3, axis=0)\n",
        "  ShfA = np.repeat([ShfA], 3, axis=0)\n",
        "  descriptor = FeatureANI(Rcr, EtaR, ShfR, Rca, Zeta, ShfZ, EtaA, ShfA)\n",
        "else:\n",
        "  Rcr = 6.0\n",
        "  Rca = 6.0\n",
        "  ShfR = np.zeros((3,6)) # H, C, O\n",
        "  EtaR = [0.0, 0.04, 0.14, 0.32, 0.71, 1.79]\n",
        "  EtaR = np.repeat([EtaR], 3, axis=0) # H, C, O\n",
        "  Zeta = [1, 2, 4, 8, 16, 32, 1, 2, 4, 8, 16, 32]\n",
        "  Zeta = np.repeat([Zeta], 3, axis=0) # H, C, O\n",
        "  EtaA = [0.0, 0.04, 0.14, 0.32, 0.71, 1.79, 0.0, 0.04, 0.14, 0.32, 0.71, 1.79]\n",
        "  EtaA = np.repeat([EtaA], 3, axis=0) # H, C, O\n",
        "  LamA = [1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1]\n",
        "  LamA = np.repeat([LamA], 3, axis=0) # H, C, O\n",
        "  descriptor = Feature(Rcr, EtaR, ShfR, Rca, Zeta, EtaA, LamA)"
      ],
      "metadata": {
        "id": "lAfRrZy1xj1y"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## GPR Hyperparameters"
      ],
      "metadata": {
        "id": "LUjFyU0UwYmx"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Reshaping and Initializing\n",
        "\n",
        "The atom types and coordinates are reshaped with the energies for use in the regression kernel. Then the marginal likelihood function is initialized."
      ],
      "metadata": {
        "id": "1A--F-On9OFk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nskip = 1\n",
        "\n",
        "# Reshape Matrix inputs to vector\n",
        "X = descriptor.forward(qm_coord, atom_types)[::nskip,:,:]\n",
        "shape = X.shape\n",
        "X  = X.reshape(shape[0], shape[1]*shape[2])\n",
        "Y = energy[::nskip]\n",
        "\n",
        "# Initialize likelihood and model\n",
        "likelihood = gpytorch.likelihoods.GaussianLikelihood()\n",
        "model = BPGPR(X, Y, likelihood)"
      ],
      "metadata": {
        "id": "daVvWWblxpIT"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Training the GPR Hyperparameters\n",
        "\n",
        "Now we can begin training to optimize the GPR hyperparameters."
      ],
      "metadata": {
        "id": "0yjHzzd29UWG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "training_iter = 500\n",
        "\n",
        "# Find optimal model hyperparameters\n",
        "model.train()\n",
        "likelihood.train()\n",
        "\n",
        "# Use the adam optimizer\n",
        "optimizer = torch.optim.Adam(model.parameters(), lr=0.1)  # Includes GaussianLikelihood parameters\n",
        "\n",
        "# \"Loss\" for GPs - the marginal log likelihood\n",
        "mll = gpytorch.mlls.ExactMarginalLogLikelihood(likelihood, model)\n",
        "\n",
        "for i in range(training_iter):\n",
        "    # Zero gradients from previous iteration\n",
        "    optimizer.zero_grad()\n",
        "    # Output from model\n",
        "    output = model(X)\n",
        "    # Calc loss and backprop gradients\n",
        "    loss = -mll(output, Y)\n",
        "    loss.backward()\n",
        "    if (i+1) % 100 == 0:\n",
        "      print('Iter %d/%d - Loss: %.3f   outputscale: %.3f   lengthscale: %.3f   noise: %.3f' % (\n",
        "        i + 1, training_iter, loss.item(),\n",
        "        model.covar_module.outputscale.item(),\n",
        "        model.covar_module.base_kernel.lengthscale.item(),\n",
        "        model.likelihood.noise.item()\n",
        "    ))\n",
        "    optimizer.step()\n",
        "\n",
        "# Print Trained hyperparameters\n",
        "print('outputscale: ', model.covar_module.outputscale.item())\n",
        "print('lengthscale: ', model.covar_module.outputscale.item())\n",
        "print('noise: ', model.likelihood.noise.item())"
      ],
      "metadata": {
        "id": "WqSWoTHBxz7b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "141f2ef5-d0ed-410c-f65a-bd461df36a49"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Iter 100/500 - Loss: 1.699   outputscale: 2.948   lengthscale: 3.298   noise: 0.852\n",
            "Iter 200/500 - Loss: 1.521   outputscale: 4.563   lengthscale: 3.560   noise: 0.193\n",
            "Iter 300/500 - Loss: 1.454   outputscale: 5.943   lengthscale: 3.747   noise: 0.074\n",
            "Iter 400/500 - Loss: 1.411   outputscale: 7.173   lengthscale: 3.975   noise: 0.034\n",
            "Iter 500/500 - Loss: 1.389   outputscale: 8.236   lengthscale: 4.156   noise: 0.018\n",
            "outputscale:  8.24675464630127\n",
            "lengthscale:  8.24675464630127\n",
            "noise:  0.018305949866771698\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Evaluating the Model's Accuracy"
      ],
      "metadata": {
        "id": "OkKS46hBwoEi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Evaluation of the Predicted Energy (RMSE)\n",
        "We will now calculate the RMSE for the energy and forces predicted by the BP-GPR mode"
      ],
      "metadata": {
        "id": "DHcSnXUqvmit"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model.eval()\n",
        "likelihood.eval()\n",
        "\n",
        "# Prepare testing set\n",
        "qm_coord = torch.autograd.Variable(qm_coord, requires_grad=True)\n",
        "X_test = descriptor.forward(qm_coord, atom_types)\n",
        "shape = X_test.shape\n",
        "X_test = X_test.reshape(shape[0], shape[1]*shape[2])\n",
        "\n",
        "# Make predictions\n",
        "y_preds = likelihood(model(X_test))\n",
        "\n",
        "y_mean = y_preds.mean\n",
        "y_var = y_preds.variance\n",
        "y_covar = y_preds.covariance_matrix\n",
        "\n",
        "def eval(ref, pred):\n",
        "    rmse = torch.sqrt(torch.mean((ref-pred)**2))\n",
        "    q2 = 1 - torch.sum((ref-pred)**2)/torch.sum((ref-torch.mean(ref))**2)\n",
        "    return rmse, q2\n",
        "\n",
        "print(torch.mean(y_var))\n",
        "# Evaluate performance on energy predictions\n",
        "y_rmse, y_q2 = eval(energy ,y_mean)\n",
        "print(\"Energy Prediction RMSE: \", y_rmse.item(),\"Q^2: \", y_q2.item())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OLPc-bFlx6-t",
        "outputId": "f1deb89f-1a84-44d4-9146-d54e6f138d47"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/gpytorch/models/exact_gp.py:284: GPInputWarning: The input matches the stored training data. Did you forget to call model.train()?\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor(0.0539, grad_fn=<MeanBackward0>)\n",
            "Energy Prediction RMSE:  0.05070596560835838 Q^2:  0.9998157024383545\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Evaluation of the Predicted Forces (RMSE)"
      ],
      "metadata": {
        "id": "76P2oVOG9h1f"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "auto_grad, = torch.autograd.grad(y_mean.sum(), [qm_coord])\n",
        "rmse = torch.sqrt(torch.mean((auto_grad - qm_gradient)**2))\n",
        "q2 = 1 - torch.sum((qm_gradient-auto_grad)**2)/torch.sum((qm_gradient-torch.mean(qm_gradient))**2)\n",
        "print(\"Force RMSE: \", rmse.item(), \"Q^2\", q2.item())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UMcC9Uv4JhG1",
        "outputId": "69f6afac-7a27-4e1e-b23b-a46ffc25a889"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Force RMSE:  4.073883533477783 Q^2 0.8090454936027527\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Plotting RMSD for the BP-GPR Model\n",
        "\n",
        "Here we plot the RMSD for the predicted and reference energy and forces for the BP-GPR model."
      ],
      "metadata": {
        "id": "LelFo-t29mo0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "fig, ax = plt.subplots(1,2,figsize=(10,5))\n",
        "\n",
        "e1 = energy.cpu().detach().numpy() + np.load(ds.open(\"https://github.com/cc-ats/mlp_tutorial/raw/main/Claisen_Rearrangement/energy_sqm.npy\",\"rb\")) * 27.2114 * 23.061\n",
        "e2 = y_mean.cpu().detach().numpy() + np.load(ds.open(\"https://github.com/cc-ats/mlp_tutorial/raw/main/Claisen_Rearrangement/energy_sqm.npy\",\"rb\")) * 27.2114 * 23.061\n",
        "ax[0].plot(e1, e2, linestyle='none', marker='.', color='springgreen')\n",
        "ax[0].plot([np.max(np.concatenate((e1,e2))), -np.max(np.concatenate((e1,e2)))], [np.max(np.concatenate((e1,e2))), -np.max(np.concatenate((e1,e2)))], color=\"k\", linewidth=1.5)\n",
        "ax[0].set_xlabel(\"Reference Energy (kcal/mol)\", size=14)\n",
        "ax[0].set_ylabel(\"Predicted Energy (kcal/mol)\", size=14)\n",
        "ax[0].annotate('RMSD: %.3f' % np.sqrt(np.mean((e1 - e2)**2)), xy=(0.05, 0.95), xycoords='axes fraction', size=14)\n",
        "\n",
        "f1 = -qm_gradient.cpu().detach().numpy().reshape(-1) - np.load(ds.open(\"https://github.com/cc-ats/mlp_tutorial/raw/main/Claisen_Rearrangement/qm_grad_sqm.npy\",\"rb\")).reshape(-1) * 27.2114 * 23.061 / 0.529177249\n",
        "f2 = -auto_grad.cpu().detach().numpy().reshape(-1) - np.load(ds.open(\"https://github.com/cc-ats/mlp_tutorial/raw/main/Claisen_Rearrangement/qm_grad_sqm.npy\",\"rb\")).reshape(-1) * 27.2114 * 23.061 / 0.529177249\n",
        "\n",
        "ax[1].plot(f1, f2, linestyle='none', marker='.', color='springgreen')\n",
        "plt.plot([-np.abs(np.max(np.concatenate((f1,f2)))), np.max(np.concatenate((f1,f2)))], [-np.max(np.concatenate((f1,f2))), np.max(np.concatenate((f1,f2)))], color=\"k\", linewidth=1.5)\n",
        "ax[1].set_xlabel(r\"Reference Force (kcal/mol/%\\AA$)\", size=14)\n",
        "ax[1].set_ylabel(r\"Predicted Force (kcal/mol/$\\AA$)\", size=14)\n",
        "ax[1].annotate('RMSD: %.3f' % np.sqrt(np.mean((f1 - f2)**2)), xy=(0.05, 0.95), xycoords='axes fraction', size=14)\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.savefig('rmsd.png', dpi=300)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 507
        },
        "id": "NbC3Mh98aEnQ",
        "outputId": "f7ff2f7c-4ed2-4ed0-f37a-29803fd7ec6b"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x500 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Tabulating the RMSE for the BP-GPR Model\n",
        "\n",
        "Finally, we can tabulate the RMSE for the BP-GPR model."
      ],
      "metadata": {
        "id": "GnnzS2tH9yy9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "qm_coord_train = torch.autograd.Variable(qm_coord[::nskip,:,:], requires_grad=True)\n",
        "X_train = descriptor.forward(qm_coord_train, atom_types[::nskip,:])\n",
        "shape = X_train.shape\n",
        "X_train = X_train.reshape(shape[0], shape[1]*shape[2])\n",
        "\n",
        "# Make predictions\n",
        "y_preds = likelihood(model(X_train))\n",
        "\n",
        "y_mean = y_preds.mean\n",
        "y_var = y_preds.variance\n",
        "y_covar = y_preds.covariance_matrix\n",
        "\n",
        "def eval(ref, pred):\n",
        "    rmse = torch.sqrt(torch.mean((ref-pred)**2))\n",
        "    q2 = 1 - torch.sum((ref-pred)**2)/torch.sum((ref-torch.mean(ref))**2)\n",
        "    return rmse, q2\n",
        "\n",
        "# Evaluate performance on energy predictions\n",
        "y_rmse, y_q2 = eval(Y ,y_mean)\n",
        "print(f'Energy Prediction RMSE: {y_rmse.item():6>.4f}\\t Q^2: {y_q2.item():6>.4f}')\n",
        "\n",
        "\n",
        "# Evaluate Forces\n",
        "auto_grad, = torch.autograd.grad(y_mean.sum(), [qm_coord_train])\n",
        "rmse = torch.sqrt(torch.mean((auto_grad - qm_gradient[::nskip,:,:])**2))\n",
        "q2 = 1 - torch.sum((qm_gradient[::nskip,:,:]-auto_grad)**2)/torch.sum((qm_gradient[::nskip,:,:]-torch.mean(qm_gradient[::nskip,:,:]))**2)\n",
        "print(f'Force Prediction  RMSE: {rmse.item():6>.4f}\\t Q^2: {q2.item():6>.4f}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wHcFRm-p3b_H",
        "outputId": "5dacca93-576e-4d7e-c812-80562a22c8c6"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Energy Prediction RMSE: 0.0507\t Q^2: 0.9998\n",
            "Force Prediction  RMSE: 4.0739\t Q^2: 0.8090\n"
          ]
        }
      ]
    }
  ]
}