{
  "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/Lesson3_BP.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i6I2_cWxgmpw"
      },
      "source": [
        "# Behler-Parrinello  Symmetry Functions\n",
        "\n",
        "In this tutorial, we will create Behler-Parrinello and ANI neural networks using atom-centered symmetry functions. The symmetry functions will allow us to ensure that the observables (such as energy) are invariant to translations and rotations."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q_oJF-Ssgmpx"
      },
      "source": [
        "## Importing PyTorch and Libraries\n",
        "\n",
        "We begin by importing PyTorch and required libraries.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TycsC-y6gmpz"
      },
      "outputs": [],
      "source": [
        "%%capture\n",
        "!pip install pytorch-lightning > /dev/null   #installing PyTorch lightning\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",
        "\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"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tWQM1h9ogmp0"
      },
      "source": [
        "## Symmetry Functions\n",
        "\n",
        "We have been using Cartesian coordinates $(x,y)$ with the Mueller-Brown potential as training data for the machine learning models. However, Cartesian coordinates are not ideal for use with neural networks because translating or rotating the molecule can change the neural network output. In the case of chemistry this would imply that translating a molecule in space changes the molecule's energy, which is incorrect.\n",
        "\n",
        "Instead, we can describe the Cartesian coordinates with symmetry functions and use the newly transformed coordinates as inputs, which will produce outputs that are invariant to translations and rotations.\n",
        "\n",
        "A cutoff function and several symmetry functions were introduced by Behler and Parrinello in 2007 (https://doi.org/10.1103/PhysRevLett.98.146401).\n",
        "\n",
        "The cutoff function is defined as:  \n",
        "\n",
        "$$\\begin{align}\n",
        "        f_c(R_{ij}) = \\left\\{\n",
        "        \\begin{array}{cl}\n",
        "        0.5\\times\\left[\\cos\\left(\\frac{\\pi R_{ij}}{R_c}\\right)+1\\right] & \\textrm{for } R_{ij} \\le R_c \\\\\n",
        "        0 & \\textrm{for } R_{ij} \\gt R_c\n",
        "        \\end{array}\n",
        "        \\right.\n",
        "\\end{align}$$\n",
        "\n",
        "where $R_{ij}$ is the distance between atoms $i$ and $j$ and $R_c$ is the cutoff distance.  \n",
        "The radial symmetry function can be defined as:\n",
        "\n",
        "$$\\begin{align}\n",
        "\\begin{array}{c}\n",
        "G_i^1 = \\sum_{j \\neq i}^{all} e^{-\\eta(R_{ij}-R_s)^2}f_c(R_{ij})\n",
        "\\end{array}\n",
        "\\end{align}$$\n",
        "\n",
        "Where $\\eta$ changes the width of the Gaussian distribution and $R_s$ shifts the center of the Gaussian peak.  \n",
        "\n",
        "The angular symmetry function can be defined as:\n",
        "\n",
        "$$\\begin{align}\n",
        "\\begin{array}{c}\n",
        "G_i^2 = 2^{1-\\zeta}\\sum_{j,k\\neq i}^{all} (1+\\lambda \\cos\\theta_{ijk})^\\zeta \\times e^{-\\eta(R_{ij}^2+R_{ik}^2+R_{jk}^2)}f_c(R_{ij}) f_c(R_{ik}) f_c(R_{jk})\n",
        "\\end{array}\n",
        "\\end{align}$$\n",
        "\n",
        "The angular terms are created for each set of 3 atoms as $\\cos\\theta_{ijk} = \\frac{\\mathbf{R_{ij}}\\cdot\\mathbf{R_{ik}}}{R_{ij}R_{ik}}$, where $\\mathbf{R_{ij}} = \\mathbf{R_{i}} - \\mathbf{R_{j}}$ and gives the distance vector between atoms i and j. The $\\lambda$ parameter is set to +1,-1 to allow exploration of the angular environment at the +1 and -1 positions. The parameter $\\eta$ changes the width of the Gaussian distribution and $\\zeta$ changes the width of the Gaussians in the angular environment.\n",
        "\n",
        "In 2017, Smith, Isayev, and Roitberg developed the ANAKIN-ME (Accurate NeurAl networK engINe for Molecular Energies), also referred to as ANI (https://doi.org/10.1039/C6SC05720A). ANI uses a modified angular symmetry function defined as:   \n",
        "\n",
        "$$\\begin{align}\n",
        "\\begin{array}{c}\n",
        "G_i^2 = 2^{1-\\zeta}\\sum_{j,k\\neq i}^{all} (1+\\cos(\\theta_{ijk}-\\theta_s))^\\zeta \\times e^{-\\eta\\left(\\frac{R_{ij}+R_{ik}}{2}-R_{s}\\right)^2}f_c(R_{ij}) f_c(R_{ik})\n",
        "\\end{array}\n",
        "\\end{align}$$\n",
        "\n",
        "Here, $\\theta_s$ is a parameter that allows for shifts in the angular environment and $R_s$ allows for calculating the angular environment in radial shells by shifting the center of the Gaussians. The result is probing the angular environment at different radial lengths and angles instead of only at $\\lambda$ values of +1,-1."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xJYltUL0gmp1"
      },
      "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.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_GAtzybPgmp1"
      },
      "outputs": [],
      "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",
        "\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=1) * (dij.unsqueeze(dim=-1) - ShfR.unsqueeze(dim=1))**2) * fij.unsqueeze(dim=-1), dim=2)\n",
        "    return g1\n",
        "\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",
        "    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=1)) * (1 + LamA.unsqueeze(dim=1) * cosine.unsqueeze(dim=-1))**Zeta.unsqueeze(dim=1) * torch.exp(-EtaA.unsqueeze(dim=1) * (d12**2 + d13**2 + d23**2).unsqueeze(dim=-1)) * (f12 * f13 * f23).unsqueeze(dim=-1), dim=2)\n",
        "    return g2\n",
        "\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",
        "    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=1))\n",
        "\n",
        "    g2 = torch.sum(2**(1 - Zeta.unsqueeze(dim=1)) * (1 + cosine)**Zeta.unsqueeze(dim=1) * torch.exp(-EtaA.unsqueeze(dim=1) * (0.5 * (d12 + d13).unsqueeze(dim=-1) - ShfZ.unsqueeze(dim=1))**2) * (f12 * f13).unsqueeze(dim=-1), dim=2)\n",
        "    return g2"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "826_ckjtgmp2"
      },
      "source": [
        "## Defining Neural Network and Feature Extraction Classes\n",
        "\n",
        "We will now define feature extraction classes which will be used in our Behler-Parrinello and ANI neural networks.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oCSkqkOrgmp2"
      },
      "source": [
        "### Defining Sequential and Dense Classes\n",
        "\n",
        "The Sequential class contains the function for the feed-forward aspect of our neural network.\n",
        "The Dense class contains functions to describe a densely connected neural network."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ScMtPuRbgmp2"
      },
      "outputs": [],
      "source": [
        "class Sequential(nn.Sequential):\n",
        "    def forward(self, input: Tuple[Tensor, Tensor]) -> Tuple[Tensor, Tensor]:\n",
        "        for module in self:\n",
        "            input = module(input)\n",
        "        return input\n",
        "\n",
        "class Dense(nn.Module):\n",
        "    def __init__(self, num_channels: int, in_features: int, out_features: int, bias: bool = True, activation: bool = False, residual: bool = False) -> None:\n",
        "        super().__init__()\n",
        "        self.num_channels = num_channels\n",
        "        self.in_features = in_features\n",
        "        self.out_features = out_features\n",
        "        self.weight = nn.Parameter(torch.Tensor(num_channels, out_features, in_features))\n",
        "        if bias:\n",
        "            self.bias = nn.Parameter(torch.Tensor(num_channels, out_features))\n",
        "        else:\n",
        "            self.register_parameter('bias', None)\n",
        "        self.activation = activation\n",
        "        self.residual = residual\n",
        "        self.reset_parameters()\n",
        "\n",
        "    def reset_parameters(self) -> None:\n",
        "        for w in self.weight:\n",
        "            nn.init.kaiming_uniform_(w, a=math.sqrt(5))\n",
        "        if self.bias is not None:\n",
        "            for b, w in zip(self.bias, self.weight):\n",
        "                fan_in, _ = nn.init._calculate_fan_in_and_fan_out(w)\n",
        "                bound = 1 / math.sqrt(fan_in)\n",
        "                nn.init.uniform_(b, -bound, bound)\n",
        "\n",
        "    def forward(self, input: Tuple[Tensor, Tensor]) -> Tuple[Tensor, Tensor]:\n",
        "        x, channels = input\n",
        "        weight: Tensor = self.weight[channels]\n",
        "        output: Tensor = torch.bmm(x.transpose(0, 1), weight.transpose(1, 2)).transpose(0, 1)\n",
        "\n",
        "        if self.bias is not None:\n",
        "            bias = self.bias[channels]\n",
        "            output = output + bias\n",
        "\n",
        "        if self.activation:\n",
        "            output = torch.tanh(output)\n",
        "\n",
        "        if self.residual:\n",
        "            if output.shape[2] == x.shape[2]:\n",
        "                output = output + x\n",
        "            elif output.shape[2] == x.shape[2] * 2:\n",
        "                output = output + torch.cat([x, x], dim=2)\n",
        "            else:\n",
        "                raise NotImplementedError(\"Not implemented\")\n",
        "\n",
        "        return output, channels\n",
        "\n",
        "    def extra_repr(self) -> str:\n",
        "        return 'num_channels={}, in_features={}, out_features={}, bias={}, activation={}, residual={}'.format(\n",
        "            self.num_channels, self.in_features, self.out_features, self.bias is not None, self.activation, self.residual\n",
        "        )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wS-XlSoigmp3"
      },
      "source": [
        "### Creating the 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."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "t9qFVtzXgmp4"
      },
      "outputs": [],
      "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)\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])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cK6Z2Nougmp4"
      },
      "source": [
        "### Creating the Feature Class for ANI\n",
        "\n",
        "We will create a similar feature class for ANI that uses the ANI angle symmetry function."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6HzNe9zngmp5"
      },
      "outputs": [],
      "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])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aIV9rNKOgmp5"
      },
      "source": [
        "### Creating the Fitting Class\n",
        "\n",
        "Now we create the fitting class, which will use the dense neural network for fitting.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "S6PolFOFgmp6"
      },
      "outputs": [],
      "source": [
        "class Fitting(nn.Module):\n",
        "    def __init__(self, n_types: int, in_features: int, neuron: Sequence[int] = [240, 240, 240]) -> None:\n",
        "        super().__init__()\n",
        "        layers = [Dense(n_types, in_features, neuron[0], activation=True)]\n",
        "        for i in range(len(neuron)-1):\n",
        "            layers.append(Dense(n_types, neuron[i], neuron[i+1], activation=True, residual=True))  # iterating through the neurons\n",
        "        layers.append(Dense(n_types, neuron[-1], 1))\n",
        "        self.fitting_net = Sequential(*layers)\n",
        "\n",
        "    def forward(self, input : Tuple[Tensor, Tensor]) -> Tensor:\n",
        "        output, _ = self.fitting_net(input)\n",
        "        return output"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t0sfXOCpgmp6"
      },
      "source": [
        "### Create the Behler-Parrinello Neural Network (BPNN) Class\n",
        "\n",
        "Finally, we will now create the BPNN class that can be used for training with the symmetry functions."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "R6UFiQZwgmp6"
      },
      "outputs": [],
      "source": [
        "class BPNN(pl.LightningModule):\n",
        "    def __init__(self, descriptor: nn.Module, fitting_net: nn.Module, learning_rate=5e-4) -> None:\n",
        "        super().__init__()\n",
        "        self.descriptor = descriptor\n",
        "        self.fitting_net = fitting_net\n",
        "        self.learning_rate = learning_rate\n",
        "\n",
        "    def forward(self, coords: torch.Tensor, atom_types: torch.Tensor):\n",
        "        coords.requires_grad_()\n",
        "        descriptors = self.descriptor(coords, atom_types)\n",
        "        atomic_energies = self.fitting_net((descriptors, atom_types))\n",
        "        energy = torch.unbind(torch.sum(atomic_energies, dim=1))\n",
        "        gradient, = torch.autograd.grad(energy, [coords], create_graph=True)\n",
        "        return torch.hstack(energy), gradient\n",
        "\n",
        "    def training_step(self, batch, batch_idx):\n",
        "        qm_coord, atom_types, energy, gradient = batch\n",
        "        ene_pred, grad_pred = self(qm_coord, atom_types[0]) # training the energy and gradient predictions\n",
        "        ene_loss = F.mse_loss(ene_pred, energy)   # defining loss functions for energy and gradient predictions\n",
        "        grad_loss = F.mse_loss(grad_pred, gradient)\n",
        "\n",
        "        lr = self.optimizers().optimizer.param_groups[0]['lr']\n",
        "        start_lr = self.optimizers().optimizer.param_groups[0]['initial_lr']\n",
        "        w_ene = 1\n",
        "        w_grad = 1 + 99 * (lr / start_lr)\n",
        "\n",
        "        loss = w_ene / (w_ene + w_grad) * ene_loss + w_grad / (w_ene + w_grad) * grad_loss\n",
        "        self.log('train_loss', loss)\n",
        "        self.log('l2_trn', torch.sqrt(loss))\n",
        "        self.log('l2_e_trn', torch.sqrt(ene_loss))\n",
        "        self.log('l2_f_trn', torch.sqrt(grad_loss))\n",
        "        return loss\n",
        "\n",
        "    def validation_step(self, batch, batch_idx):\n",
        "        torch.set_grad_enabled(True)\n",
        "        qm_coord, atom_types, energy, gradient = batch\n",
        "        ene_pred, grad_pred = self(qm_coord, atom_types[0])\n",
        "        ene_loss = F.mse_loss(ene_pred, energy)\n",
        "        grad_loss = F.mse_loss(grad_pred, gradient)\n",
        "\n",
        "        lr = self.optimizers().optimizer.param_groups[0]['lr']\n",
        "        start_lr = self.optimizers().optimizer.param_groups[0]['initial_lr']\n",
        "        w_ene = 1\n",
        "        w_grad = 1 + 99 * (lr / start_lr)\n",
        "\n",
        "        loss = w_ene / (w_ene + w_grad) * ene_loss + w_grad / (w_ene + w_grad) * grad_loss\n",
        "        self.log('val_loss', loss)\n",
        "        self.log('l2_tst', torch.sqrt(loss))\n",
        "        self.log('l2_e_tst', torch.sqrt(ene_loss))\n",
        "        self.log('l2_f_tst', torch.sqrt(grad_loss))\n",
        "        self.log('lr', lr)\n",
        "        return loss\n",
        "\n",
        "    def configure_optimizers(self):\n",
        "        optimizer = torch.optim.Adam(self.parameters(), lr=self.learning_rate)\n",
        "        scheduler = {'scheduler': torch.optim.lr_scheduler.ExponentialLR(optimizer, 0.95),\n",
        "                     'interval': 'epoch',\n",
        "                     'frequency': 10,\n",
        "                    }\n",
        "        return [optimizer], [scheduler]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6VYcubbIgmp7"
      },
      "source": [
        "## Loading Data\n",
        "\n",
        " Files from GitHub:\n",
        " - Coordinates and atom types:\n",
        "- **qm_coord.npy** (1800, 14, 3)\n",
        "- **qm_elem.txt** ([6, 6, 6, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])\n",
        " - PM3 energies and gradients:\n",
        "- **energy_sqm.npy** (1800,)\n",
        "- **qm_grad_sqm.npy** (1800, 14, 3)\n",
        "\n",
        " - B3LYP/6-31+G* energies and gradients:\n",
        "- **energy.npy**  (1800,)\n",
        "- **qm_grad.npy** (1800, 14, 3)\n",
        "\n",
        "These files will provide us with semi-empirical (PM3) and QM (B3LYP/6-31+G*) data to train our machine learning model."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EquY5VXYgmp7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d7707cf5-5ce3-4e16-c034-d428ed87d41e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:lightning_fabric.utilities.seed:Global seed set to 2\n"
          ]
        }
      ],
      "source": [
        "import numpy as np\n",
        "\n",
        "ds = np.DataSource(None)\n",
        "qm_coord = np.array(np.load(ds.open(\"https://github.com/cc-ats/mlp_tutorial/raw/main/Butane/qm_coord.npy\", \"rb\")), dtype=\"float32\")\n",
        "atom_types = np.loadtxt(ds.open(\"https://github.com/cc-ats/mlp_tutorial/raw/main/Butane/qm_elem.txt\", \"r\"), dtype=int)\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/Butane/energy.npy\", \"rb\")) - np.load(ds.open(\"https://github.com/cc-ats/mlp_tutorial/raw/main/Butane/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/Butane/qm_grad.npy\", \"rb\")) - np.load(ds.open(\"https://github.com/cc-ats/mlp_tutorial/raw/main/Butane/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)\n",
        "\n",
        "pl.seed_everything(2)\n",
        "dataset = TensorDataset(qm_coord, atom_types, energy, qm_gradient)\n",
        "train, val = random_split(dataset, [1728, 72])\n",
        "# Training Set Size: 1728 (96%)\n",
        "# Test Set Size:       72 ( 4%)\n",
        "# Data Set Size:     1780\n",
        "train_loader = DataLoader(train, batch_size=32)\n",
        "val_loader = DataLoader(val, batch_size=32)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4cJKjECsgmp8"
      },
      "source": [
        "## Using ANI for Feature Extraction\n",
        "\n",
        "Here is an example where we use the ANI model for feature extraction. We will use values for the symmetry function parameters from the ASE_ANI model references (https://github.com/isayev/ASE_ANI), which serves as an interface for the TorchANI (https://doi.org/10.1021/acs.jcim.0c00451) software package. The BP parameters in this tutorial are not optimized for this system. The parameters can be optimized following the procedures outlined in https://doi.org/10.1002/qua.24890.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "f0Vf6S6egmp8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 306
        },
        "outputId": "866112fd-35a0-4beb-c53a-2831cdb97c75"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:lightning_fabric.utilities.seed:Global seed set to 2\n",
            "INFO:pytorch_lightning.utilities.rank_zero:GPU available: True (cuda), used: True\n",
            "INFO:pytorch_lightning.utilities.rank_zero:TPU available: False, using: 0 TPU cores\n",
            "INFO:pytorch_lightning.utilities.rank_zero:IPU available: False, using: 0 IPUs\n",
            "INFO:pytorch_lightning.utilities.rank_zero:HPU available: False, using: 0 HPUs\n",
            "INFO:pytorch_lightning.accelerators.cuda:LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
            "INFO:pytorch_lightning.callbacks.model_summary:\n",
            "  | Name        | Type       | Params\n",
            "-------------------------------------------\n",
            "0 | descriptor  | FeatureANI | 0     \n",
            "1 | fitting_net | Fitting    | 383 K \n",
            "-------------------------------------------\n",
            "383 K     Trainable params\n",
            "0         Non-trainable params\n",
            "383 K     Total params\n",
            "1.532     Total estimated model params size (MB)\n",
            "INFO:pytorch_lightning.utilities.rank_zero:`Trainer.fit` stopped: `max_epochs=500` reached.\n"
          ]
        }
      ],
      "source": [
        "%%capture\n",
        "%%time\n",
        "pl.seed_everything(2)\n",
        "\n",
        "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",
        "  # Make every combination of EtaR and ShfR with meshgrid\n",
        "  EtaR, ShfR = np.array(np.meshgrid(EtaR, ShfR)).reshape(2, -1)\n",
        "  # Make every combination of Zeta, ShfZ, EtaA, and ShfA with meshgrid\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)\n",
        "\n",
        "fitting_net = Fitting(3, descriptor.output_length, neuron=[240, 240, 240])\n",
        "model = BPNN(descriptor, fitting_net, learning_rate=5e-4)\n",
        "csv_logger = pl_loggers.CSVLogger('logs_csv/')\n",
        "trainer = pl.Trainer(max_epochs=500, logger=csv_logger, log_every_n_steps=20, accelerator='auto')\n",
        "\n",
        "trainer.fit(model, train_loader, val_loader)\n",
        "model.to(device)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6rXGJqmygmp8"
      },
      "source": [
        "## Saving the Model with PyTorch Files and Evaluating the Model's Accuracy Using RMSD\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Saving the Model with PyTorch\n",
        "\n",
        "The following files will be saved:\n",
        "\n",
        "**1) model.pt**\n",
        "- torch.save saves tensors to model.pt\n",
        "\n",
        "**2) model_script.pt**\n",
        "- torch.jit.save attempts to preserve the behavior of some operators across PyTorch versions.\n",
        "\n",
        "Previously saved models can be loaded with:\n",
        " - model.load_state_dict(torch.load(\"model.pt\"))\n",
        " - torch.jit.load(\"model_script.pt\")\n"
      ],
      "metadata": {
        "id": "kGybmhYghF-8"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Y9pQYh2Bgmp9"
      },
      "outputs": [],
      "source": [
        "torch.save(model.state_dict(), 'model.pt')\n",
        "torch.jit.save(model.to_torchscript(), \"model_script.pt\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SHvZFE4Fgmp9"
      },
      "outputs": [],
      "source": [
        "ene_pred, grad_pred = model(qm_coord, atom_types[0])"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Plotting RMSD to Evaluate the Energy and Force Predictions of the Model\n",
        "RMSD for predicted and reference energy and forces are calculated and displayed below."
      ],
      "metadata": {
        "id": "1Q-zQhNGhdJP"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Qg2tueuMgmp9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 507
        },
        "outputId": "17c8e487-5769-48a6-938d-1cad13de74d1"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x500 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "fig, ax = plt.subplots(1,2,figsize=(10,5))\n",
        "ds = np.DataSource(None)\n",
        "e1 = energy.cpu().detach().numpy() + np.load(ds.open(\"https://github.com/cc-ats/mlp_tutorial/raw/main/Butane/energy_sqm.npy\",\"rb\")) * 27.2114 * 23.061\n",
        "e2 = ene_pred.cpu().detach().numpy() + np.load(ds.open(\"https://github.com/cc-ats/mlp_tutorial/raw/main/Butane/energy_sqm.npy\",\"rb\")) * 27.2114 * 23.061\n",
        "ax[0].plot(e1, e2, linestyle='none', marker='.',color='mediumspringgreen')\n",
        "ax[0].plot([np.max(e1), np.min(e1)], [np.max(e2), np.min(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/Butane/qm_grad_sqm.npy\",\"rb\")).reshape(-1) * 27.2114 * 23.061 / 0.529177249\n",
        "f2 = -grad_pred.cpu().detach().numpy().reshape(-1) - np.load(ds.open(\"https://github.com/cc-ats/mlp_tutorial/raw/main/Butane/qm_grad_sqm.npy\",\"rb\")).reshape(-1) * 27.2114 * 23.061 / 0.529177249\n",
        "\n",
        "ax[1].plot(f1, f2, linestyle='none', marker='.',color='mediumspringgreen')\n",
        "ax[1].plot([np.max(f1), np.min(f1)], [np.max(f2), np.min(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)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### The Model Weights and Biases Dictionary\n",
        "\n",
        "This cell prints the size of the weights and biases used in the trained model for reference."
      ],
      "metadata": {
        "id": "9Nd2cLjlrK1L"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "peKDL7Ufgmp-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0ce9dc66-8be8-497e-a542-ae291281d57e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model's state_dict:\n",
            "fitting_net.fitting_net.0.weight \ttorch.Size([3, 240, 48])\n",
            "fitting_net.fitting_net.0.bias   \ttorch.Size([3, 240])\n",
            "fitting_net.fitting_net.1.weight \ttorch.Size([3, 240, 240])\n",
            "fitting_net.fitting_net.1.bias   \ttorch.Size([3, 240])\n",
            "fitting_net.fitting_net.2.weight \ttorch.Size([3, 240, 240])\n",
            "fitting_net.fitting_net.2.bias   \ttorch.Size([3, 240])\n",
            "fitting_net.fitting_net.3.weight \ttorch.Size([3, 1, 240])\n",
            "fitting_net.fitting_net.3.bias   \ttorch.Size([3, 1])\n"
          ]
        }
      ],
      "source": [
        "print(\"Model's state_dict:\")\n",
        "for param_tensor in model.state_dict():\n",
        "    print(f'{param_tensor:<33}\\t{model.state_dict()[param_tensor].size()}')"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Plotting the Minimization of the Loss Function\n"
      ],
      "metadata": {
        "id": "IlNd8jjOetRg"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fsotMUSxgmp-",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 883
        },
        "outputId": "a28fcf00-fc8e-4571-d6bf-0558bd362462"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 600x1000 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "import pandas as pd\n",
        "\n",
        "data = pd.read_csv(f'logs_csv/lightning_logs/version_{csv_logger.version}/metrics.csv')\n",
        "fig, ax = plt.subplots(2, figsize=(6,10))\n",
        "x = data['epoch'][~data['l2_e_tst'].isnull()]\n",
        "y = data['l2_e_tst'][~data['l2_e_tst'].isnull()]\n",
        "y2 = data['l2_f_tst'][~data['l2_f_tst'].isnull()]\n",
        "ax[0].semilogy(x, y,color='dodgerblue')\n",
        "ax[0].set_ylabel('Energy Validation Error (kcal/mol)', fontsize=14)\n",
        "ax[0].set_title('Energy Loss Function', fontsize=16)\n",
        "ax[1].semilogy(x, y2, label='Force Validation Error (kcal/mol',color='dodgerblue')\n",
        "ax[1].set_xlabel('Epoch', fontsize=14)\n",
        "ax[1].set_ylabel(r'Force Validation Error (kcal/mol/$\\AA$)', fontsize=14)\n",
        "ax[1].set_title('Force Loss Function', fontsize=16)\n",
        "plt.xticks(fontsize=12)\n",
        "plt.yticks(fontsize=12)\n",
        "fig.savefig('loss.png', dpi=300)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Plotting Training and Validation Loss\n",
        "\n",
        "The loss at each step of the training process is displayed below."
      ],
      "metadata": {
        "id": "g7mlW3IsrrFX"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Jcd1TkxZgmp-",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 532
        },
        "outputId": "3afea3ee-a1de-44e5-d8be-3adb2e8bf097"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Size of the Training Set: 1350\n",
            "Size of the Validation Set: 500\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 600x500 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "data = pd.read_csv(f'logs_csv/lightning_logs/version_{csv_logger.version}/metrics.csv')\n",
        "fig, ax = plt.subplots(figsize=(6,5))\n",
        "x = data['epoch'][~data['epoch'].isnull()]\n",
        "y = data['train_loss'][~data['train_loss'].isnull()]\n",
        "print('Size of the Training Set:', len(y))\n",
        "plt.semilogy(y, label='Training Loss',color='dodgerblue')\n",
        "y = data['val_loss'][~data['val_loss'].isnull()]\n",
        "print('Size of the Validation Set:', len(y))\n",
        "plt.semilogy(y, label='Validation Loss',color='k')\n",
        "plt.xlabel('Steps', fontsize=14)\n",
        "plt.ylabel('Loss', fontsize=14)\n",
        "plt.xticks(fontsize=12)\n",
        "plt.yticks(fontsize=12)\n",
        "plt.title('BPNN Training Data Loss', fontsize=16)\n",
        "plt.legend()\n",
        "plt.show()"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}