{ "cells": [ { "cell_type": "markdown", "id": "59dfa31a", "metadata": {}, "source": [ "## Example: Graph (small molecule) data\n", "\n", "For this example, we'll fit a model to predict atomization energy on\n", "the QM9 dataset, a widely used benchmark for this task with about 134,000\n", "molecules. The dataset needs some preprocessing to convert into\n", "a format we can use. We'll need the ase library to be\n", "installed for this.\n", "\n", "Molecules are a common form of graph data, and we can of course represent\n", "them in a variety of ways. Here we'll use a very simple approach: one-hot\n", "encode each atom type and weight it based on distance to a central atom.\n", "We then use a graph convolution kernel to pairwise compare all atomic\n", "environments in any two molecules.\n", "\n", "This is a *very* crude way to represent a molecule that discards a lot of information.\n", "Using more sophisticated\n", "representations, we can achieve performance competitive with state\n", "of the art. What's interesting about this simple representation,\n", "however, is that it can already achieve surprisingly good performance,\n", "with a mean absolute error of about 1 kcal / mol (the so-called\n", "\"chemical accuracy\" threshold), despite its simplicity, nicely\n", "demonstrating the usefulness of graph convolution kernels.\n", "\n", "All experiments here are using xGPR v0.4.8." ] }, { "cell_type": "code", "execution_count": 1, "id": "c0c0c565", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/ssd1/Documents/gp_proteins/venv_testing/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", " from .autonotebook import tqdm as notebook_tqdm\n" ] } ], "source": [ "import os\n", "import shutil\n", "import time\n", "import tarfile\n", "import wget\n", "import ase\n", "from ase.io import read\n", "import subprocess\n", "import random\n", "\n", "import pandas as pd\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from scipy.spatial import distance_matrix\n", "\n", "from xGPR import xGPRegression as xGPReg\n", "from xGPR import build_regression_dataset" ] }, { "cell_type": "markdown", "id": "666a8321-3f8e-4471-97be-39c641d7628f", "metadata": {}, "source": [ "The next step retrieves the raw data. QM9 is fairly large, so this will take a minute..." ] }, { "cell_type": "code", "execution_count": 2, "id": "214c5fa2", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "100% [.......................................................................] 86144227 / 86144227" ] } ], "source": [ "#Retrieving the raw data -- this might take a minute...\n", "qm9_yvals_url = \"https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/qm9.csv\"\n", "qm9_xyz_url = \"https://figshare.com/ndownloader/files/3195389\"\n", "fname = wget.download(qm9_yvals_url)\n", "fname = wget.download(qm9_xyz_url)\n", "tarball = tarfile.open(fname)\n", "tarball.extractall(\"qm9_mols\")\n", "os.remove(fname)\n", "\n", "#We have to clean up the downloaded files a little.\n", "os.chdir(\"qm9_mols\")\n", "for f in os.listdir():\n", " with open(f, \"r\") as fhandle:\n", " raw_file = fhandle.readlines()\n", " raw_file = [l.replace(\"*^\", \"e\") for l in raw_file]\n", " with open(f, \"w+\") as fhandle:\n", " for line in raw_file[:-3]:\n", " fhandle.write(line)\n", "\n", "os.chdir(\"..\")" ] }, { "cell_type": "code", "execution_count": 3, "id": "542c6c64", "metadata": {}, "outputs": [], "source": [ "os.chdir(\"qm9_mols\")\n", "xfiles = [os.path.abspath(f) for f in os.listdir()]\n", "xfiles.sort()\n", "\n", "#The common practice for this in the literature\n", "#has been to use 110,000 mols for training,\n", "#remainder for test & validation. We'll follow\n", "#that here.\n", "random.seed(123)\n", "random.shuffle(xfiles)\n", "\n", "train_x, test_x = xfiles[:110000], xfiles[110000:]\n", "\n", "os.chdir(\"..\")\n", "\n", "labels = pd.read_csv(\"qm9.csv\")\n", "mol_dict = { k.split(\"_\")[-1]:v for (k,v) in zip(labels.mol_id.tolist(), labels.u298_atom.tolist())} " ] }, { "cell_type": "markdown", "id": "3ccc1819", "metadata": {}, "source": [ "Here we encode each molecule as a matrix where each row is one atom; the features\n", "in that row are one-hot encodings of all other atoms (out to the nearest 15)\n", "weighted by how far away they are, using 1/r**6 weighting (this is\n", "used to construct a London matrix, which is why we use it here).\n", "This could easily be optimized for faster feature generation if desired,\n", "but again, our goal here is merely a simple demonstration. Notice that just as\n", "for sequences, we record the \"sequence length\" (i.e. number of nodes in the graph)\n", "for each molecule. This way, xGPR can mask the zero-padding we add to the end of\n", "each graph so that all are the same length. If we set the sequence length to be the\n", "same for every datapoint, however, then the zero-padding is not masked. In general, it's usually preferable to mask\n", "zero-padding, unless the size of an input communicates some useful information about that datapoint.\n", "\n", "For this example we'll save the encoded molecules to disk. We could also create a custom dataset where\n", "we encode them on the fly (although this would make fitting a little slower). If there are not many of\n", "them, we could also just store the encodings in memory." ] }, { "cell_type": "code", "execution_count": 4, "id": "b479ff9a", "metadata": {}, "outputs": [], "source": [ "def encode_mols(x_file_list, y_value_dict, chunk_size, ftype = \"train\"):\n", " x_batch, y_batch, seqlen_batch = [], [], []\n", " fcounter = 0\n", "\n", " atom_key = {\"H\":0, \"C\":1, \"O\":2, \"N\":3, \"F\":4}\n", " num_atom_types = len(atom_key)\n", " max_partners = 15\n", " \n", " for xfile in x_file_list:\n", " #Each molecule has up to 29 atoms\n", " output_mat = np.zeros((29, num_atom_types * max_partners), dtype=np.float32)\n", "\n", " mol = read(xfile)\n", " f_key = str(int(xfile.split(\"_\")[-1].split(\".xyz\")[0]))\n", " y_batch.append(y_value_dict[f_key])\n", "\n", " positions, symbols = mol.get_positions(), mol.get_chemical_symbols()\n", " dist_mat = distance_matrix(positions, positions)\n", " idx_by_dist = np.argsort(dist_mat, axis=1)\n", "\n", " for i, symbol in enumerate(symbols):\n", " #One-hot encode the central atom\n", " output_mat[i,atom_key[symbol]] = 1\n", " for j, idx in enumerate(idx_by_dist[i,1:max_partners].tolist()):\n", " atom_offset = (j + 1) * num_atom_types + atom_key[symbols[idx]]\n", " output_mat[i, atom_offset] = 1 / dist_mat[i,idx]**6\n", "\n", " x_batch.append(output_mat)\n", " seqlen_batch.append(len(symbols))\n", " \n", " if len(x_batch) >= chunk_size:\n", " np.save(f\"{ftype}_{fcounter}_xbatch.npy\", np.stack(x_batch))\n", " np.save(f\"{ftype}_{fcounter}_ybatch.npy\", np.asarray(y_batch))\n", " np.save(f\"{ftype}_{fcounter}_seqlen.npy\", np.array(seqlen_batch))\n", " x_batch, y_batch, seqlen_batch = [], [], []\n", " fcounter += 1" ] }, { "cell_type": "code", "execution_count": 5, "id": "7463430e", "metadata": {}, "outputs": [], "source": [ "#We now encode all the raw data...this might take a minute.\n", "encode_mols(train_x, mol_dict, chunk_size = 1000, ftype=\"train\")\n", "encode_mols(test_x, mol_dict, chunk_size = 1000, ftype=\"test\")" ] }, { "cell_type": "code", "execution_count": 6, "id": "2fc07b4e", "metadata": {}, "outputs": [], "source": [ "train_x_files = [f for f in os.listdir() if f.startswith(\"train\") and f.endswith(\"xbatch.npy\")]\n", "test_x_files = [f for f in os.listdir() if f.startswith(\"test\") and f.endswith(\"xbatch.npy\")]\n", "\n", "train_y_files = [f.replace(\"xbatch\", \"ybatch\") for f in train_x_files]\n", "test_y_files = [f.replace(\"xbatch\", \"ybatch\") for f in test_x_files]\n", "\n", "train_seqlen_files = [f.replace(\"xbatch\", \"seqlen\") for f in train_x_files]\n", "test_seqlen_files = [f.replace(\"xbatch\", \"seqlen\") for f in test_x_files]" ] }, { "cell_type": "markdown", "id": "b2e67227-56d8-41b8-a167-c882b9a41f69", "metadata": {}, "source": [ "Notice how we supply a third argument -- the list of files containing sequence lengths -- here. The third\n", "argument defaults to None, which is what we would supply if using a fixed-length vector kernel. For\n", "3d array data (sequences, graphs) by contrast, the third argument (sequence / graph lengths) is required.\n", "The chunk size just has to be an integer larger than the largest file in the dataset; the dataset builder\n", "will just check to make sure all our files contain <= that number of datapoints." ] }, { "cell_type": "code", "execution_count": 7, "id": "d0f973f0", "metadata": {}, "outputs": [], "source": [ "train_dset = build_regression_dataset(train_x_files, train_y_files, train_seqlen_files, chunk_size = 1000)" ] }, { "cell_type": "markdown", "id": "0bf0213c", "metadata": {}, "source": [ "We'll use GraphRBF as the kernel, a convolution kernel with a conv_width of 1 which just does pairwise comparisons between all the nodes in any two graphs. This is generally faster than the sequence convolution kernels but slower than Matern or RBF. As we did before, we'll use ``tune_hyperparams_crude`` to get a rough idea\n", "of where \"good\" hyperparameters are located and compare different kernels (if needed), then fine-tune.\n", "The GraphRBF kernel has a kernel setting we can use, \"averaging\", which is one of 'none' (default), 'sqrt', 'full'.\n", "See the available kernels page for more on what these do." ] }, { "cell_type": "code", "execution_count": 8, "id": "4f531299", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Grid point 0 acquired.\n", "Grid point 1 acquired.\n", "Grid point 2 acquired.\n", "Grid point 3 acquired.\n", "Grid point 4 acquired.\n", "Grid point 5 acquired.\n", "Grid point 6 acquired.\n", "Grid point 7 acquired.\n", "Grid point 8 acquired.\n", "Grid point 9 acquired.\n", "New hparams: [0.9146764]\n", "Additional acquisition 10.\n", "New hparams: [0.0392626]\n", "Additional acquisition 11.\n", "New hparams: [0.400479]\n", "Additional acquisition 12.\n", "New hparams: [0.4277992]\n", "Best score achieved: -283592.332\n", "Best hyperparams: [-5.0470805 0.400479 ]\n" ] } ], "source": [ "init_model = xGPReg(num_rffs = 1024, variance_rffs = 512,\n", " kernel_choice = \"GraphRBF\", verbose = True,\n", " device = \"cuda\", kernel_settings={\"averaging\":'none'})\n", "\n", "best_hparams, _, best_score = init_model.tune_hyperparams_crude(train_dset)" ] }, { "cell_type": "markdown", "id": "2880df88-5f9d-42a4-b659-4d6da811810f", "metadata": {}, "source": [ "Now let's fine tune this using more random features. We could use the built-in\n", "``model.tune_hyperparams`` as we did in the tabular data example or use Optuna as we did\n", "in the sequence example. Or we could just do simple grid search in the region around\n", "the best hyperparameters identified so far. For illustrative purposes here, we'll\n", "do a simple grid search.\n", "\n", "One helpful thing to keep in mind: We know this data is nearly noise-free, and the fact\n", "that crude tuning selected a small value for the first hyperparameter (lambda_) suggests\n", "we don't need much regularization, so optimal values for lambda_ are probably going to be\n", "small (depending on what sigma is). For regression, we don't usually want to set lambda_ to much below -7 for numerical\n", "stability reasons (for classification though as low as -10 can sometimes be helpful).\n", "These considerations will help us with our search." ] }, { "cell_type": "code", "execution_count": 9, "id": "b6602870", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Evaluated NMLL.\n", "-319093.1216160262\n", "Evaluated NMLL.\n", "-326097.49449996534\n", "Evaluated NMLL.\n", "-331101.4514573452\n", "Evaluated NMLL.\n", "-333512.70311764744\n", "Evaluated NMLL.\n", "-334653.93934065715\n", "Evaluated NMLL.\n", "-332053.80412010854\n", "Evaluated NMLL.\n", "-316201.51641733653\n", "Evaluated NMLL.\n", "-323820.59778274\n", "Evaluated NMLL.\n", "-329713.8900034793\n", "Evaluated NMLL.\n", "-333159.7500780296\n", "Evaluated NMLL.\n", "-335099.9976268808\n", "Evaluated NMLL.\n", "-333009.5351321114\n", "Evaluated NMLL.\n", "-309841.8789297951\n", "Evaluated NMLL.\n", "-318345.55931628036\n", "Evaluated NMLL.\n", "-325673.7924991411\n", "Evaluated NMLL.\n", "-331110.3054695079\n", "Evaluated NMLL.\n", "-335068.9419137342\n", "Evaluated NMLL.\n", "-334766.26367834426\n" ] } ], "source": [ "lambda_grid = [-6.25, -6., -5.5]\n", "sigma_grid = [0., 0.25, 0.5, 0.75, 1, 1.5]\n", "\n", "nmll_grid = np.zeros((len(lambda_grid), len(sigma_grid)))\n", "\n", "init_model.num_rffs = 4096\n", "\n", "for i, lambda_ in enumerate(lambda_grid):\n", " for j, sigma in enumerate(sigma_grid):\n", " nmll_grid[i,j] = init_model.exact_nmll(np.array([lambda_, sigma]), train_dset)\n", " print(nmll_grid[i,j])" ] }, { "cell_type": "markdown", "id": "8e99fbc0-77db-4078-ae73-6b857be291f9", "metadata": {}, "source": [ "Let's visualize the NMLL scores calculated by the gridsearch. Lower is better." ] }, { "cell_type": "code", "execution_count": 10, "id": "6cafb36d-ea48-47d6-a8d8-66f41e16f9a4", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.style.use(\"bmh\")\n", "\n", "plt.imshow(nmll_grid.T, aspect=\"auto\")\n", "plt.xticks(np.arange(len(lambda_grid)), lambda_grid)\n", "plt.yticks(np.arange(len(sigma_grid)), sigma_grid)\n", "plt.xlabel(\"Lambda values\")\n", "plt.ylabel(\"Sigma values\")\n", "plt.title(\"NMLL for different hyperparameter values\")\n", "plt.colorbar()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "40f9d49b-ec5b-4344-91e0-3021d60a66fb", "metadata": {}, "source": [ "We might be able to do even better by expanding the search slighly in that direction, by using the ```tune_hyperparams``` routine\n", "in xGPR with the Powell method to further fine-tune, or by using more RFFs to more accurately estimate the NMLL. For now, though, since this is just a demo, we'll just set to the best value we found and then fit." ] }, { "cell_type": "code", "execution_count": 11, "id": "34443400", "metadata": {}, "outputs": [], "source": [ "init_model.set_hyperparams(np.array([-6., 1.]), train_dset)" ] }, { "cell_type": "markdown", "id": "3fae07a4", "metadata": {}, "source": [ "We use a tighter tol than usual here, since the data is noise-free\n", "enough that small improvements in accuracy matter. (Note that\n", "tol = 1e-8 is usually overkill however; 1e-7 is generally\n", "tight enough)." ] }, { "cell_type": "code", "execution_count": 12, "id": "855cee2f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "starting fitting\n", "Chunk 0 complete.\n", "Chunk 10 complete.\n", "Chunk 20 complete.\n", "Chunk 30 complete.\n", "Chunk 40 complete.\n", "Chunk 50 complete.\n", "Chunk 60 complete.\n", "Chunk 70 complete.\n", "Chunk 80 complete.\n", "Chunk 90 complete.\n", "Chunk 100 complete.\n", "Chunk 0 complete.\n", "Chunk 10 complete.\n", "Chunk 20 complete.\n", "Chunk 30 complete.\n", "Chunk 40 complete.\n", "Chunk 50 complete.\n", "Chunk 60 complete.\n", "Chunk 70 complete.\n", "Chunk 80 complete.\n", "Chunk 90 complete.\n", "Chunk 100 complete.\n", "Chunk 0 complete.\n", "Chunk 10 complete.\n", "Chunk 20 complete.\n", "Chunk 30 complete.\n", "Chunk 40 complete.\n", "Chunk 50 complete.\n", "Chunk 60 complete.\n", "Chunk 70 complete.\n", "Chunk 80 complete.\n", "Chunk 90 complete.\n", "Chunk 100 complete.\n", "Chunk 0 complete.\n", "Chunk 10 complete.\n", "Chunk 20 complete.\n", "Chunk 30 complete.\n", "Chunk 40 complete.\n", "Chunk 50 complete.\n", "Chunk 60 complete.\n", "Chunk 70 complete.\n", "Chunk 80 complete.\n", "Chunk 90 complete.\n", "Chunk 100 complete.\n", "Chunk 0 complete.\n", "Chunk 10 complete.\n", "Chunk 20 complete.\n", "Chunk 30 complete.\n", "Chunk 40 complete.\n", "Chunk 50 complete.\n", "Chunk 60 complete.\n", "Chunk 70 complete.\n", "Chunk 80 complete.\n", "Chunk 90 complete.\n", "Chunk 100 complete.\n", "Using rank: 2560\n", "Chunk 0 complete.\n", "Chunk 10 complete.\n", "Chunk 20 complete.\n", "Chunk 30 complete.\n", "Chunk 40 complete.\n", "Chunk 50 complete.\n", "Chunk 60 complete.\n", "Chunk 70 complete.\n", "Chunk 80 complete.\n", "Chunk 90 complete.\n", "Chunk 100 complete.\n", "0 iterations complete.\n", "5 iterations complete.\n", "10 iterations complete.\n", "15 iterations complete.\n", "20 iterations complete.\n", "25 iterations complete.\n", "30 iterations complete.\n", "CG iterations: 35\n", "Now performing variance calculations...\n", "Fitting complete.\n", "Wallclock: 70.68398237228394\n" ] } ], "source": [ "init_model.num_rffs = 8192\n", "start_time = time.time()\n", "init_model.fit(train_dset, mode = 'cg', tol=1e-7)\n", "end_time = time.time()\n", "print(f\"Wallclock: {end_time - start_time}\")" ] }, { "cell_type": "code", "execution_count": 13, "id": "16eaf7cc", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Wallclock: 1.2675549983978271\n", "Mean absolute error:\n", "1.41659\n" ] } ], "source": [ "start_time = time.time()\n", "all_preds, ground_truth = [], []\n", "for xfile, yfile, sfile in zip(train_x_files, train_y_files, train_seqlen_files):\n", " ground_truth.append(np.load(yfile))\n", " preds = init_model.predict(np.load(xfile), np.load(sfile).astype(np.int32), get_var = False)\n", " all_preds.append(preds)\n", " \n", "all_preds, ground_truth = np.concatenate(all_preds), np.concatenate(ground_truth)\n", "end_time = time.time()\n", "print(f\"Wallclock: {end_time - start_time}\")\n", "\n", "\n", "print(\"Mean absolute error:\")\n", "print(np.round(np.mean(np.abs(all_preds - ground_truth)), 5))" ] }, { "cell_type": "code", "execution_count": null, "id": "869092ab-df04-4ee5-9e89-107e9ffb922c", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "7d3de4b7-5819-4670-a956-eda237713e5c", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "b376ffa6", "metadata": {}, "source": [ "Not bad...for a start. We're already at an MAE of about 1.4 (\"chemical accuracy\" is widely considered to be\n", "1 kcal/mol). We're already outperforming the deep learning models described in the MoleculeNet paper using a simple stupid approach\n", "(one-hot encoded atoms) that really shouldn't work as well as it did. Let's see how we can make this better using the existing features (without doing more feature engineering).\n", "\n", "We can increase the number of random features for fitting, and /or we can further fine-tune our hyperparameters using\n", "more RFFs. Let's do both. Normally we don't usually fine tune with significantly more RFFs than 8192 because gains\n", "in performance are just too small (although you can). For fitting, by contrast, going up to 16384 or even 32768 RFFs can\n", "yield some additional performance gains (although it will slow fitting down somewhat). Notice that we use the\n", "hyperparameters we found from the grid search as a starting point." ] }, { "cell_type": "code", "execution_count": 14, "id": "16a59b69-d662-4e8d-b24c-d60dda6f3899", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Evaluated NMLL.\n", "Evaluated NMLL.\n", "Evaluated NMLL.\n", "Evaluated NMLL.\n", "Evaluated NMLL.\n", "Evaluated NMLL.\n", "Evaluated NMLL.\n", "Evaluated NMLL.\n", "Evaluated NMLL.\n", "Evaluated NMLL.\n", "Evaluated NMLL.\n", "Evaluated NMLL.\n", "Evaluated NMLL.\n", "Evaluated NMLL.\n", "Evaluated NMLL.\n", "Evaluated NMLL.\n", "Evaluated NMLL.\n", "Evaluated NMLL.\n", "Evaluated NMLL.\n", "Evaluated NMLL.\n", "Evaluated NMLL.\n", "Best score: -355759.8832303471\n" ] }, { "data": { "text/plain": [ "(array([-6.67864433, 1.0367744 ]), 21, np.float64(-355759.8832303471))" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "init_model.num_rffs = 8192\n", "init_model.tune_hyperparams(train_dset, tuning_method=\"Powell\", nmll_method=\"exact\",\n", " max_iter = 40, starting_hyperparams = np.array([-6., 1.]) )" ] }, { "cell_type": "code", "execution_count": 15, "id": "b04e08ca", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "starting fitting\n", "Chunk 0 complete.\n", "Chunk 10 complete.\n", "Chunk 20 complete.\n", "Chunk 30 complete.\n", "Chunk 40 complete.\n", "Chunk 50 complete.\n", "Chunk 60 complete.\n", "Chunk 70 complete.\n", "Chunk 80 complete.\n", "Chunk 90 complete.\n", "Chunk 100 complete.\n", "Chunk 0 complete.\n", "Chunk 10 complete.\n", "Chunk 20 complete.\n", "Chunk 30 complete.\n", "Chunk 40 complete.\n", "Chunk 50 complete.\n", "Chunk 60 complete.\n", "Chunk 70 complete.\n", "Chunk 80 complete.\n", "Chunk 90 complete.\n", "Chunk 100 complete.\n", "Chunk 0 complete.\n", "Chunk 10 complete.\n", "Chunk 20 complete.\n", "Chunk 30 complete.\n", "Chunk 40 complete.\n", "Chunk 50 complete.\n", "Chunk 60 complete.\n", "Chunk 70 complete.\n", "Chunk 80 complete.\n", "Chunk 90 complete.\n", "Chunk 100 complete.\n", "Chunk 0 complete.\n", "Chunk 10 complete.\n", "Chunk 20 complete.\n", "Chunk 30 complete.\n", "Chunk 40 complete.\n", "Chunk 50 complete.\n", "Chunk 60 complete.\n", "Chunk 70 complete.\n", "Chunk 80 complete.\n", "Chunk 90 complete.\n", "Chunk 100 complete.\n", "Chunk 0 complete.\n", "Chunk 10 complete.\n", "Chunk 20 complete.\n", "Chunk 30 complete.\n", "Chunk 40 complete.\n", "Chunk 50 complete.\n", "Chunk 60 complete.\n", "Chunk 70 complete.\n", "Chunk 80 complete.\n", "Chunk 90 complete.\n", "Chunk 100 complete.\n", "Using rank: 3000\n", "Chunk 0 complete.\n", "Chunk 10 complete.\n", "Chunk 20 complete.\n", "Chunk 30 complete.\n", "Chunk 40 complete.\n", "Chunk 50 complete.\n", "Chunk 60 complete.\n", "Chunk 70 complete.\n", "Chunk 80 complete.\n", "Chunk 90 complete.\n", "Chunk 100 complete.\n", "Chunk 0 complete.\n", "Chunk 10 complete.\n", "Chunk 20 complete.\n", "Chunk 30 complete.\n", "Chunk 40 complete.\n", "Chunk 50 complete.\n", "Chunk 60 complete.\n", "Chunk 70 complete.\n", "Chunk 80 complete.\n", "Chunk 90 complete.\n", "Chunk 100 complete.\n", "0 iterations complete.\n", "5 iterations complete.\n", "10 iterations complete.\n", "15 iterations complete.\n", "20 iterations complete.\n", "CG iterations: 25\n", "Now performing variance calculations...\n", "Fitting complete.\n" ] } ], "source": [ "init_model.num_rffs = 16384\n", "init_model.fit(train_dset, mode = 'cg', tol=1e-7)" ] }, { "cell_type": "code", "execution_count": null, "id": "353a0c51", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": 16, "id": "eea04f43", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Wallclock: 0.4019808769226074\n", "Mean absolute error:\n", "1.3041\n" ] } ], "source": [ "start_time = time.time()\n", "all_preds, ground_truth = [], []\n", "for xfile, yfile, sfile in zip(test_x_files, test_y_files, test_seqlen_files):\n", " x, y, s = np.load(xfile), np.load(yfile), np.load(sfile)\n", " ground_truth.append(y)\n", " preds = init_model.predict(x, s, get_var = False)\n", " all_preds.append(preds)\n", " \n", "all_preds, ground_truth = np.concatenate(all_preds), np.concatenate(ground_truth)\n", "end_time = time.time()\n", "print(f\"Wallclock: {end_time - start_time}\")\n", "\n", "print(\"Mean absolute error:\")\n", "print(np.round(np.mean(np.abs(all_preds - ground_truth)), 4))" ] }, { "cell_type": "code", "execution_count": 17, "id": "f7d9b572", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0.5, 1.0, 'Predicted vs actual post fine-tuning,\\nfitting with 16384 random features')" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.style.use(\"bmh\")\n", "plt.scatter(all_preds, ground_truth, s = 5)\n", "plt.xlabel(\"Predictions\")\n", "plt.ylabel(\"Ground truth\")\n", "plt.title(\"Predicted vs actual post fine-tuning,\\nfitting with 16384 random features\")" ] }, { "cell_type": "markdown", "id": "351269ee", "metadata": {}, "source": [ "Retuning helped -- we're down to a mean absolute error of 1.3 kcal/mol, substantially better than any of the MoleculeNet deep learning models.\n", "\n", "Just for fun, let's see what happens if we fit with 2x more random features. This will result in slower fitting, and will make generating predictions slower. As always, remember that increasing the number of RFFs for either tuning or\n", "fitting provides diminishing returns -- going from 4096 to 8192 provides a more significant boost than going from 8192 to 16384 and so on." ] }, { "cell_type": "code", "execution_count": 18, "id": "54dd74fd", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "starting fitting\n", "Chunk 0 complete.\n", "Chunk 10 complete.\n", "Chunk 20 complete.\n", "Chunk 30 complete.\n", "Chunk 40 complete.\n", "Chunk 50 complete.\n", "Chunk 60 complete.\n", "Chunk 70 complete.\n", "Chunk 80 complete.\n", "Chunk 90 complete.\n", "Chunk 100 complete.\n", "Chunk 0 complete.\n", "Chunk 10 complete.\n", "Chunk 20 complete.\n", "Chunk 30 complete.\n", "Chunk 40 complete.\n", "Chunk 50 complete.\n", "Chunk 60 complete.\n", "Chunk 70 complete.\n", "Chunk 80 complete.\n", "Chunk 90 complete.\n", "Chunk 100 complete.\n", "Chunk 0 complete.\n", "Chunk 10 complete.\n", "Chunk 20 complete.\n", "Chunk 30 complete.\n", "Chunk 40 complete.\n", "Chunk 50 complete.\n", "Chunk 60 complete.\n", "Chunk 70 complete.\n", "Chunk 80 complete.\n", "Chunk 90 complete.\n", "Chunk 100 complete.\n", "Chunk 0 complete.\n", "Chunk 10 complete.\n", "Chunk 20 complete.\n", "Chunk 30 complete.\n", "Chunk 40 complete.\n", "Chunk 50 complete.\n", "Chunk 60 complete.\n", "Chunk 70 complete.\n", "Chunk 80 complete.\n", "Chunk 90 complete.\n", "Chunk 100 complete.\n", "Chunk 0 complete.\n", "Chunk 10 complete.\n", "Chunk 20 complete.\n", "Chunk 30 complete.\n", "Chunk 40 complete.\n", "Chunk 50 complete.\n", "Chunk 60 complete.\n", "Chunk 70 complete.\n", "Chunk 80 complete.\n", "Chunk 90 complete.\n", "Chunk 100 complete.\n", "Using rank: 3000\n", "Chunk 0 complete.\n", "Chunk 10 complete.\n", "Chunk 20 complete.\n", "Chunk 30 complete.\n", "Chunk 40 complete.\n", "Chunk 50 complete.\n", "Chunk 60 complete.\n", "Chunk 70 complete.\n", "Chunk 80 complete.\n", "Chunk 90 complete.\n", "Chunk 100 complete.\n", "Chunk 0 complete.\n", "Chunk 10 complete.\n", "Chunk 20 complete.\n", "Chunk 30 complete.\n", "Chunk 40 complete.\n", "Chunk 50 complete.\n", "Chunk 60 complete.\n", "Chunk 70 complete.\n", "Chunk 80 complete.\n", "Chunk 90 complete.\n", "Chunk 100 complete.\n", "0 iterations complete.\n", "5 iterations complete.\n", "10 iterations complete.\n", "15 iterations complete.\n", "20 iterations complete.\n", "25 iterations complete.\n", "30 iterations complete.\n", "35 iterations complete.\n", "CG iterations: 37\n", "Now performing variance calculations...\n", "Fitting complete.\n" ] } ], "source": [ "init_model.num_rffs = 32768\n", "init_model.fit(train_dset, mode = 'cg', tol=1e-7)" ] }, { "cell_type": "code", "execution_count": null, "id": "fc399188-5438-48a8-aa44-c001c8ad968a", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": 22, "id": "d7713206", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Wallclock: 0.7933559417724609\n", "Mean absolute error:\n", "1.1824\n" ] } ], "source": [ "start_time = time.time()\n", "all_preds, ground_truth = [], []\n", "for xfile, yfile, sfile in zip(test_x_files, test_y_files, test_seqlen_files):\n", " x, y, s = np.load(xfile), np.load(yfile), np.load(sfile)\n", " ground_truth.append(y)\n", " preds = init_model.predict(x, s, get_var = False)\n", " all_preds.append(preds)\n", " \n", "all_preds, ground_truth = np.concatenate(all_preds), np.concatenate(ground_truth)\n", "end_time = time.time()\n", "print(f\"Wallclock: {end_time - start_time}\")\n", "\n", "print(\"Mean absolute error:\")\n", "print(np.round(np.mean(np.abs(all_preds - ground_truth)), 4))" ] }, { "cell_type": "code", "execution_count": 23, "id": "a8d56dc4", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0.5, 1.0, 'Predicted vs actual post fine-tuning,\\nfitting with 32768 random features')" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.style.use(\"bmh\")\n", "plt.scatter(all_preds, ground_truth, s = 5)\n", "plt.xlabel(\"Predictions\")\n", "plt.ylabel(\"Ground truth\")\n", "plt.title(\"Predicted vs actual post fine-tuning,\\nfitting with 32768 random features\")" ] }, { "cell_type": "markdown", "id": "c73f4ca4", "metadata": {}, "source": [ "The mean absolute error is surprisingly close to 1 kcal/mol -- given that we're using a generic convolution kernel with one-hot encoded input. And we can still make predictions for 20,000 molecules in under a second on GPU.\n", "\n", "We can improve on this further by doing some more hyperparameter tuning\n", "or increasing the number of fitting RFFs, but these will just provides some incremental improvement (recall that\n", "increasing the number of random features provides diminishing returns). So, further tweaking might give us some additional small improvement, but it's very unlikely to get us down to 0.5 or 0.25 kcal/mol (if that was our goal). Once we've fine-tuned with 8192 RFFs and fitted using a decent number of RFFs (e.g. 16384), further improvements from \"tweaking\" are likely to be modest.\n", "\n", "To get a much larger improvement we need either a different kernel or (more likely) a more\n", "informative representation of the input molecules. The representation\n", "we used here discards all information about bond angles and is very uninformative.\n", "We've been able to reach < 0.17 kcal/mol using SOAP features\n", "(and there are other ways to do this as well). The same interestingly\n", "is true in this case for deep learning models -- deep learning models provided with\n", "uninformative representations (e.g. one hot encoding) often perform much worse than\n", "xGPR does here (see the MoleculeNet paper for example). So, for both deep learning and\n", "GPs, predicting energy with MAE << 1 kcal/mol seems to require informative features." ] }, { "cell_type": "code", "execution_count": null, "id": "a4d8e864", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "7f045079", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.10.12" } }, "nbformat": 4, "nbformat_minor": 5 }