Lesson5_BP_FNN_MLP.ipynb

{
  "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/Lesson5_BP_FNN_MLP.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4QIfKc-Me5Ni"
      },
      "source": [
        "# Behler-Parrinello Fitting Neural Network with Machine Learning Potential (BP-FNN MLP) Models for the Claisen Rearrangement\n",
        "\n",
        "For this tutorial, we will be combining the Fitting Neural Network (FNN) from Lesson 1 and the Behler-Parrinello Neural Network (BPNN) from Lesson 3 to train a $\\Delta$ Machine Learning Potential ($\\Delta$MLP) model to reproduce the energy and forces for the claisen rearrangement reaction. With a BP-FNN, we can utilize the symmetry functions from the BPNN model for feature extraction and use the FNN for training. The goal of this model is to train with data that is from the semiempirical (PM3) and DFT (B3LYP) levels of theory. The BP-FNN will be used to correct the semiempirical values to obtain DFT level accuracy, which is what makes it a $\\Delta$MLP model."
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Defining the Reaction Coordinate and System Size\n",
        "\n",
        "The reaction coordinate is $d_1 -d_2$ with 21 windows.\n",
        "\n",
        "Total of 2100 frames (1 ps/window, frames are saved every 1 fs.)\n",
        "\n",
        "<img src='https://raw.githubusercontent.com/cc-ats/mlp_class/main/Claisen_Rearrangement/img/pent-4-enal.png' width=200px>\n",
        "\n"
      ],
      "metadata": {
        "id": "yreRHgT7u8Et"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from IPython.display import HTML\n",
        "\n",
        "HTML(f\"\"\"<video src=\"https://github.com/cc-ats/mlp_tutorial/raw/main/Claisen_Rearrangement/img/claisen.mp4\" width=300 controls/>\"\"\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 322
        },
        "id": "ljBOLgk-wLWI",
        "outputId": "9410be1e-12b8-43b6-b757-85fc725a3c0e"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "<video src=\"https://github.com/cc-ats/mlp_tutorial/raw/main/Claisen_Rearrangement/img/claisen.mp4\" width=300 controls/>"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "<video src='https://github.com/cc-ats/mlp_tutorial/raw/main/Claisen_Rearrangement/img/claisen.mp4'>\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "0eJ-_e68vLNO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Importing PyTorch Lightning and Libraries\n",
        "We will first install PyTorch Lightning and import libraries needed to train our machine learning models."
      ],
      "metadata": {
        "id": "BPuN7hFOFT5L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%capture\n",
        "!pip install pytorch-lightning > /dev/null\n",
        "import math\n",
        "import numpy as np\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"
      ],
      "metadata": {
        "id": "fPn6Q6URnYDN"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Importing data from GitHub (mlp_tutorial)\n",
        "We will now import our semiempirical and DFT calculation data.\n",
        "\n",
        "Files from GitHub:\n",
        "- **qm_coord.npy** (2100, 14, 3)\n",
        "- **qm_elem.txt** ([8, 6, 6, 6, 6, 6, 1, 1, 1, 1, 1, 1, 1, 1])\n",
        "- PM3\n",
        "- **energy_sqm.npy** (2100,)\n",
        "- **qm_grad_sqm.npy** (2100, 14, 3)\n",
        "\n",
        "- B3LYP/6-31+G*\n",
        "- **energy.npy**  (2100,)\n",
        "- **qm_grad.npy** (2100, 14, 3)"
      ],
      "metadata": {
        "id": "18XGhegFF5x2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Defining the Dense Neural Network\n",
        "\n",
        "The Dense class contains functions to describe a densely connected neural network.\n"
      ],
      "metadata": {
        "id": "bUhLB5Y4KXy6"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "WXspRElYvr5n"
      },
      "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",
      "source": [
        "## Creating the BP Symmetry Functions\n",
        "\n",
        "We will define the BP and ANI symmetry functions to ensure that our ML predictions are invariant to translations, rotations, and permutations.\n"
      ],
      "metadata": {
        "id": "peaU3jMrKxGP"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "8foxwRKw0rXP"
      },
      "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_g2(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\n",
        "    g2 = 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 g2\n",
        "\n",
        "\n",
        "def symmetry_function_g3(rij: Tensor, Rca: float, Zeta: Tensor, EtaA: 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",
        "    g3 = torch.sum(2**(1 - Zeta.unsqueeze(dim=1)) * (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 g3\n",
        "\n",
        "\n",
        "def symmetry_function_g3ani(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",
        "    g3 = 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 g3"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Creating the Feature Classes for BP and ANI"
      ],
      "metadata": {
        "id": "WNhwUvHFT131"
      }
    },
    {
      "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 input called features. Here we will be using the previously defined symmetry functions for feature extraction.\n"
      ],
      "metadata": {
        "id": "SUdKJjQLK4Wz"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "rRXofpIJkKnd"
      },
      "outputs": [],
      "source": [
        "class Feature(nn.Module):\n",
        "    def __init__(self, Rcr: float, EtaR: Tensor, ShfR: Tensor, Rca: float, Zeta: Tensor, EtaA: 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",
        "\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[atom_types].to(device=coords.device)\n",
        "        ShfR = self.ShfR[atom_types].to(device=coords.device)\n",
        "        Zeta = self.Zeta[atom_types].to(device=coords.device)\n",
        "        EtaA = self.EtaA[atom_types].to(device=coords.device)\n",
        "        g2 = symmetry_function_g2(rij, self.Rcr, EtaR, ShfR)\n",
        "        g3 = symmetry_function_g3(rij, self.Rca, Zeta, EtaA)\n",
        "\n",
        "        return torch.concat((g2, g3), dim=2)\n",
        "\n",
        "    @property\n",
        "    def output_length(self) -> int:\n",
        "        return len(self.EtaR[0]) + len(self.EtaA[0])"
      ]
    },
    {
      "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": "id6zvxx-K_yu"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "st4TXB2yeW6v"
      },
      "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",
        "        g2 = symmetry_function_g2(rij, self.Rcr, EtaR, ShfR)\n",
        "        g3 = symmetry_function_g3ani(rij, self.Rca, Zeta, ShfZ, EtaA, ShfA)\n",
        "\n",
        "        return torch.concat((g2, g3), dim=2)\n",
        "\n",
        "    @property\n",
        "    def output_length(self) -> int:\n",
        "        return len(self.EtaR[0]) + len(self.EtaA[0])"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Creating the Fitting Neural Network\n",
        "\n",
        "Now we create the Fitting class, which will use the dense neural network for fitting.\n"
      ],
      "metadata": {
        "id": "YJsBu7NoLFzC"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "02e3WPabvjIl"
      },
      "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))\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",
      "source": [
        "## The Behler-Parrinello Fitting Neural Network (BP-FNN)\n",
        "\n",
        "We create the BPNN class that can be used for feature extraction with the symmetry functions.\n"
      ],
      "metadata": {
        "id": "7YTxfJXgLKsy"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "Gw-8zbn_wPz5"
      },
      "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])\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('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",
      "source": [
        "## Importing Data and Seeding\n",
        "\n",
        "We will now import our semiempirical and DFT calculation data. We will then use seeding to generate random but reproducible training."
      ],
      "metadata": {
        "id": "-7Tv-R5NJSuF"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vuHEYr6CCf5u"
      },
      "outputs": [],
      "source": [
        "ds = np.DataSource(None)\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",
        "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)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "5fc0zx5YOn-y",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c32cb051-16ed-45c6-a7f6-f7afd26f52f1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:lightning_fabric.utilities.seed:Global seed set to 2\n"
          ]
        }
      ],
      "source": [
        "pl.seed_everything(2)\n",
        "dataset = TensorDataset(qm_coord, atom_types, energy, qm_gradient)\n",
        "train, val = random_split(dataset, [2016, 84])\n",
        "train_loader = DataLoader(train, batch_size=32)\n",
        "val_loader = DataLoader(val, batch_size=32)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Setting ANI Parameters\n",
        "\n",
        "Here we set the parameters for the ANI model and begin training our BP-FNN."
      ],
      "metadata": {
        "id": "L-g9rxO6LSu5"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "0FYCh2Le7jRr",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 312
        },
        "outputId": "16540ffd-e4e2-4c56-b41f-2c7a863ebbac"
      },
      "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=10` 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",
        "  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 = [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]] # H, C, O\n",
        "  EtaR = [[0.0, 0.04, 0.14, 0.32, 0.71, 1.79], [0.0, 0.04, 0.14, 0.32, 0.71, 1.79], [0.0, 0.04, 0.14, 0.32, 0.71, 1.79]] # H, C, O\n",
        "  Zeta = [[1, 2, 4, 8, 16, 32], [1, 2, 4, 8, 16, 32], [1, 2, 4, 8, 16, 32]] # 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], [0.0, 0.04, 0.14, 0.32, 0.71, 1.79]] # H, C, O\n",
        "  descriptor = Feature(Rcr, EtaR, ShfR, Rca, Zeta, EtaA)\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=300, logger=csv_logger, log_every_n_steps=20, accelerator='auto')\n",
        "trainer.fit(model, train_loader, val_loader)\n",
        "model.to(device)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Saving model to PyTorch file\n",
        "\n",
        "The following files are 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(' **1)** '))\n",
        "\n",
        "- torch.jit.load(' **2)** ')"
      ],
      "metadata": {
        "id": "UoCqvOvdLZ6H"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "wDsRamgOkdXY"
      },
      "outputs": [],
      "source": [
        "torch.save(model.state_dict(), 'model.pt')\n",
        "torch.jit.save(model.to_torchscript(), \"model_script.pt\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "cRMmWy9TPeJD"
      },
      "outputs": [],
      "source": [
        "ene_pred, grad_pred = model(qm_coord, atom_types[0])"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Plotting RMSD for $\\Delta$MLP Energy and Forces\n",
        "\n",
        "RMSD for predicted and reference energy and forces are calculated and displayed below."
      ],
      "metadata": {
        "id": "qnQCBYPZL7eF"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "JlF1V44dPibM",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 507
        },
        "outputId": "c8c2fde5-33b7-42e5-fa7d-c0d6d58cef70"
      },
      "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",
        "\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 = ene_pred.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",
        "\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 = -grad_pred.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)"
      ]
    },
    {
      "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": "Ifal2I5wMDU8"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "RLr5VkQCPoBO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f05bdf09-cd8a-4ccd-e1ff-a3088ed63d6b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model's state_dict:\n",
            "fitting_net.fitting_net.0.weight \t torch.Size([3, 240, 48])\n",
            "fitting_net.fitting_net.0.bias \t torch.Size([3, 240])\n",
            "fitting_net.fitting_net.1.weight \t torch.Size([3, 240, 240])\n",
            "fitting_net.fitting_net.1.bias \t torch.Size([3, 240])\n",
            "fitting_net.fitting_net.2.weight \t torch.Size([3, 240, 240])\n",
            "fitting_net.fitting_net.2.bias \t torch.Size([3, 240])\n",
            "fitting_net.fitting_net.3.weight \t torch.Size([3, 1, 240])\n",
            "fitting_net.fitting_net.3.bias \t torch.Size([3, 1])\n"
          ]
        }
      ],
      "source": [
        "print(\"Model's state_dict:\")\n",
        "for param_tensor in model.state_dict():\n",
        "    print(param_tensor, \"\\t\", model.state_dict()[param_tensor].size())"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Plotting Validation Error for $\\Delta$MLP\n",
        "\n",
        "Validation error for the $\\Delta$MLP is shown below."
      ],
      "metadata": {
        "id": "fnqPBH5iMI3p"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "xzYcSyS4PrE2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 855
        },
        "outputId": "4ddd1707-d231-4861-d4ee-e1ec37602196"
      },
      "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('logs_csv/lightning_logs/version_0/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)',size=14)\n",
        "ax[1].semilogy(x, y2, label='Force Validation Error (kcal/mol',color='dodgerblue')\n",
        "ax[1].set_xlabel('Epochs',size=14)\n",
        "ax[1].set_ylabel(r'Force Validation Error (kcal/mol/$\\AA$)',size=14)\n",
        "fig.savefig('loss.png', dpi=300)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Plotting Training and Validation Loss for $\\Delta$MLP\n",
        "\n",
        "The loss at each step of the training process is displayed below."
      ],
      "metadata": {
        "id": "0TF629ZDMPQ7"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "HCew0e4YnCaG",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 522
        },
        "outputId": "822453e0-7d0c-4df0-c262-9d032aaa0013"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1152\n",
            "365\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7f1c0d4e35e0>"
            ]
          },
          "metadata": {},
          "execution_count": 22
        },
        {
          "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('logs_csv/lightning_logs/version_0/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(len(y))\n",
        "plt.semilogy(y, label='Training Loss',color='dodgerblue')\n",
        "y = data['val_loss'][~data['val_loss'].isnull()]\n",
        "print(len(y))\n",
        "plt.semilogy(y, label='Validation Loss',color='k')\n",
        "plt.xlabel('Steps',size=14)\n",
        "plt.ylabel('Loss',size=14)\n",
        "plt.legend()"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    },
    "gpuClass": "standard"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}