KRR - TotalEnergy.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "anaconda-cloud": {},
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.5.2"
    },
    "colab": {
      "name": "KRR - TotalEnergy.ipynb",
      "provenance": []
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UkZROARRR7G_"
      },
      "source": [
        "# Total Energy Prediction - Kernel Ridge Regression\n",
        "\n",
        "## Introduction\n",
        "\n",
        "In this notebook we will machine-learn the relationship between descriptors of molecules and their total energy using kernel regression.\n",
        "\n",
        "KRR is a one of the ML methods to perform regression (fitting).\n",
        "\n",
        "In practice, we use kernel function $d$ that measures the distance between two data points.\n",
        "With the function we build the kernel matrix:\n",
        "\n",
        "\\begin{equation}\n",
        "K_{ij} =  d(M_{i}, M_{j}) - \\alpha I_{ij}\n",
        "\\end{equation}\n",
        "\n",
        "for all pairs of samples $M_i$ and $M_j$ in the training set. $I_{ij}$ is the identity matrix and $\\alpha$ is a hyperparameter chosen between 0 and 1.\n",
        "\n",
        "When we want to predict the output of a new sample or set of samples that were not in the training set, we need to first evaluate the distance between them and the training samples:\n",
        "\n",
        "\\begin{equation}\n",
        "D_{ij} =  d(T_{i}, M_{j})\n",
        "\\end{equation}\n",
        "\n",
        "where $T_i$ is one of the new samples. The output prediction $\\mathbf{y_T}$ for the test set $T$ is obtained by:\n",
        "\n",
        "\\begin{equation}\n",
        "\\mathbf{y_T} = \\mathbf{y_M} \\cdot K^{-1} \\cdot D^T\n",
        "\\end{equation}\n",
        "\n",
        "where $\\mathbf{y_M}$ is the vector of known outputs for the training set $M$.\n",
        "\n",
        "The energy of ~134k molecules was calculated at the CCSD level."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C_8A7l_IR7HC"
      },
      "source": [
        "## Setup"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "76CIzwghR7HD",
        "outputId": "b868ee00-7de3-439d-8b56-61203a0704c5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "#resolve KRR dependency\n",
        "import os\n",
        "import os.path\n",
        "if os.path.exists('pyKRR.py'):\n",
        "    pass\n",
        "else:\n",
        "    !git clone https://github.com/reinimaurer1/ML-CSC-tutorial tut\n",
        "    !mv tut/data data\n",
        "    !mv tut/pyKRR.py ./\n",
        "# IMPORTS\n",
        "# INITIAL DEFINITIONS\n",
        "from pyKRR import KRRsolver  # import our KRR solver object\n",
        "import numpy, random\n",
        "import numpy, math, random\n",
        "import matplotlib.pyplot as plt\n",
        "from mpl_toolkits.mplot3d import Axes3D\n",
        "from scipy.sparse import load_npz"
      ],
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "rm: cannot remove 'pyKRR.py': No such file or directory\n",
            "Cloning into 'tut'...\n",
            "remote: Enumerating objects: 372, done.\u001b[K\n",
            "remote: Counting objects: 100% (55/55), done.\u001b[K\n",
            "remote: Compressing objects: 100% (50/50), done.\u001b[K\n",
            "remote: Total 372 (delta 25), reused 16 (delta 5), pack-reused 317\u001b[K\n",
            "Receiving objects: 100% (372/372), 543.04 MiB | 35.43 MiB/s, done.\n",
            "Resolving deltas: 100% (148/148), done.\n",
            "Checking out files: 100% (129/129), done.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YwGX4ucCR7HE"
      },
      "source": [
        "Let's pick a descriptor. Allowed types are:\n",
        "\n",
        "1. cnt: atom counts\n",
        "2. bob: bag of bonds\n",
        "4. soap: smooth overlap of atomic positions; choose from:\n",
        "    1. soap.sum - all atoms summed together\n",
        "    4. soap.mean - mean of all atom SOAP\n",
        "    4. soap.centre - computed at the central point\n",
        "5. mbtr: many-body tensor representation\n",
        "6. cm: Coulomb matrix"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xz8CYLUvR7HF",
        "outputId": "6a3888d7-f7b7-4ccb-a6ae-7584a8843414",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# TYPE is the descriptor type\n",
        "TYPE = \"cnt\"\n",
        "\n",
        "#show descriptor details\n",
        "print(\"\\nDescriptor details\")\n",
        "desc = open(\"./data/descriptor.\"+TYPE.split('.')[0]+\".txt\",\"r\").readlines()\n",
        "for l in desc: print(l.strip())\n",
        "print(\" \")"
      ],
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Descriptor details\n",
            "Atom counts:\n",
            "\n",
            "Each molecule is represented by the count of each atom type found in it.\n",
            "There will be 5 numbers for each molecule, giving the total H,C,N,O,F atoms.\n",
            "This is effectively the chemical formula. Probably not a great descriptor!\n",
            " \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hp2ife7HR7HG"
      },
      "source": [
        "and load the databases with the descriptors (input) and the correct charge densities (output). Databases are quite big, so we can decide how many samples to use for training."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EU430ZzOR7HH",
        "outputId": "1bcc7bcc-978f-41a2-944b-60626e6836cc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# load input/output data\n",
        "trainIn = load_npz(\"./data/energy.input.\"+TYPE+\".npz\").toarray()\n",
        "trainOut = numpy.load(\"./data/energy.output.npy\")\n",
        "trainIn = trainIn.astype(dtype=numpy.float64, casting='safe')\n",
        "\n",
        "# decide how many samples to take from the database\n",
        "samples  = min(trainIn.shape[0], 1000) # change the number here!\n",
        "vsamples = min(trainIn.shape[0]-samples,1000)\n",
        "print(\"training samples:   \"+str(samples))\n",
        "print(\"validation samples: \"+str(vsamples))\n",
        "\n",
        "# split between training and validation\n",
        "validIn = trainIn[samples:samples+vsamples]\n",
        "validOut = trainOut[samples:samples+vsamples]\n",
        "\n",
        "trainIn  = trainIn[0:samples]\n",
        "trainOut = trainOut[0:samples]\n",
        "\n",
        "# show the first few descriptors\n",
        "print(\"\\nDescriptors for the first 5 molecules:\")\n",
        "print(trainIn[0:5])"
      ],
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "training samples:   1000\n",
            "validation samples: 1000\n",
            "\n",
            "Descriptors for the first 5 molecules:\n",
            "[[10.  7.  2.  0.  0.]\n",
            " [ 9.  5.  3.  0.  0.]\n",
            " [ 4.  4.  1.  1.  3.]\n",
            " [ 7.  6.  1.  1.  0.]\n",
            " [ 9.  6.  1.  2.  0.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4i2xyDHmR7HI"
      },
      "source": [
        "## Training\n",
        "\n",
        "In the training phase we use the kernel function $d$ to measure the distance between all pairs of molecules in the dataset. The results for the kernel matrix:\n",
        "\n",
        "\\begin{equation}\n",
        "K_{ij} =  d\\left(M_{i}, M_{j}\\right) - \\alpha I_{ij}\n",
        "\\end{equation}\n",
        "\n",
        "$I_{ij}$ is the identity matrix and $\\alpha$ is a regularisation hyperparameter $\\in \\left[0,1\\right]$.\n",
        "The matrix is then inverted."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jRkVyf8qR7HJ",
        "outputId": "c563b02f-fcac-495b-d3fd-f728882a057d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# create a new solver\n",
        "solver = KRRsolver()\n",
        "\n",
        "# set the regularisation hyperparameter\n",
        "solver.alpha = 0.1\n",
        "\n",
        "# call its training function with the training inputs and outputs\n",
        "# WARNING: building the kernel matrix is O(N^2)\n",
        "# WARNING: inverting the kernel matris is O(N^3)\n",
        "# Keep the training set small\n",
        "solver.Train(trainIn, trainOut)"
      ],
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "KRR solver initialised.\n",
            "Training completed.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ImWghlcoR7HK"
      },
      "source": [
        "The evaluation function computes the distance between each validation sample $T_i$ and the training ones $M_i$:\n",
        "\n",
        "$$ D_{ij} =  d(T_{i}, M_{j}) $$\n",
        "\n",
        "The predicted energies $E\\left(T\\right)$ are then given by:\n",
        "\n",
        "$$ E\\left( T \\right) = E\\left( M \\right) \\cdot K^{-1} \\cdot D^T $$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q0_5gCT6R7HL",
        "outputId": "11610de7-d302-4d46-d34d-deec1e681a58",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 558
        }
      },
      "source": [
        "# get a list of predicted outputs for the validation inputs\n",
        "predict = solver.Evaluate(validIn)\n",
        "\n",
        "print(\"Mean Abs Error (validation): \" + str((numpy.abs(predict-validOut)).mean()))\n",
        "\n",
        "# do the regression plot\n",
        "plt.plot(validOut, predict, 'o')\n",
        "plt.plot([numpy.min(validOut),numpy.max(validOut)], [numpy.min(validOut),numpy.max(validOut)], '-')\n",
        "plt.xlabel('correct output')\n",
        "plt.ylabel('KRR output')\n",
        "plt.show()\n",
        "\n",
        "# check the distribution of energies in the training set\n",
        "plt.hist(validOut, bins=20, density=True, alpha=0.5, facecolor='gray')\n",
        "plt.hist(trainOut, bins=20, density=True, alpha=0.2, facecolor='red')\n",
        "plt.xlabel(\"Energy [H]\")\n",
        "plt.ylabel(\"Probability\")\n",
        "plt.show()"
      ],
      "execution_count": 59,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mean Abs Error (validation): 0.7001497583261415\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SvXlftwdR7HL"
      },
      "source": [
        "# Exercises"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3mD-q5coR7HM"
      },
      "source": [
        "### 1. Compare descriptors\n",
        "\n",
        "Using the same training and validation set size, find which descriptor gives the smallest error."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yt68jH_kR7HM"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L-DLCHMUR7HM"
      },
      "source": [
        "### 2. Training set size\n",
        "\n",
        "Choose a descriptor and investigate the effects of training set size on the quality of the model."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EMDyJj6_R7HN"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OhnwveP0R7HN"
      },
      "source": [
        "### 3. Combine with Principal Component Analysis - Advanced\n",
        "Reduce the descriptor size with PCA (check the PCA.ipynb notebook) and train again. Can you get similar accuracy with a reduced input size?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SGxC9cDMR7HN"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}