From 1f7b6bee00f5c17c207783f5a8052c13106d1de0 Mon Sep 17 00:00:00 2001 From: Maxim Ziatdinov <34245227+ziatdinovmax@users.noreply.github.com> Date: Mon, 24 Feb 2025 16:25:37 -0800 Subject: [PATCH] Add example with Partially Bayesian Transformer --- .../PartialBayesianTransformer_esol.ipynb | 943 ++++++++++++++++++ 1 file changed, 943 insertions(+) create mode 100644 examples/PartialBayesianTransformer_esol.ipynb diff --git a/examples/PartialBayesianTransformer_esol.ipynb b/examples/PartialBayesianTransformer_esol.ipynb new file mode 100644 index 0000000..b92f9a8 --- /dev/null +++ b/examples/PartialBayesianTransformer_esol.ipynb @@ -0,0 +1,943 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "machine_shape": "hm", + "gpuType": "A100", + "authorship_tag": "ABX9TyOQTGOXN/O7bazRtzBSfsXD", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU" + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Partially Bayesian Transformer - Molecular Property Prediction from SMILES\n", + "\n", + "*Prepared by Maxim Ziatdinov (February 2025)*\n", + "\n", + "This notebook demonstrates the application of Partially Bayesian Transformers to predict molecular solubility from SMILES representations using the NeuroBayes framework. It starts with a deterministic transformer model for the ESOL dataset, then converts it into partially Bayesian models by making different components probabilistic - specifically the token embedding layer, final dense layer, and attention layer." + ], + "metadata": { + "id": "UIsh9MppMDBx" + } + }, + { + "cell_type": "markdown", + "source": [ + "Install NeuroBayes:" + ], + "metadata": { + "id": "4o119a2WNZ37" + } + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "e-uTgq6lvyRJ", + "outputId": "102b4fa2-3351-4764-be46-18a5c9b5f7de" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/ziatdinovmax/NeuroBayes\n", + " Cloning https://github.com/ziatdinovmax/NeuroBayes to /tmp/pip-req-build-350_dh23\n", + " Running command git clone --filter=blob:none --quiet https://github.com/ziatdinovmax/NeuroBayes /tmp/pip-req-build-350_dh23\n", + " Resolved https://github.com/ziatdinovmax/NeuroBayes to commit 668d10d3130362e74dba9221bcdc887b76b1951d\n", + " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "Collecting jax<=0.4.31,>=0.4.0 (from NeuroBayes==0.0.12)\n", + " Downloading jax-0.4.31-py3-none-any.whl.metadata (22 kB)\n", + "Collecting jaxlib<=0.4.31,>=0.4.0 (from NeuroBayes==0.0.12)\n", + " Downloading jaxlib-0.4.31-cp311-cp311-manylinux2014_x86_64.whl.metadata (983 bytes)\n", + "Collecting numpyro>=0.13.0 (from NeuroBayes==0.0.12)\n", + " Downloading numpyro-0.17.0-py3-none-any.whl.metadata (37 kB)\n", + "Requirement already satisfied: flax>=0.8.4 in /usr/local/lib/python3.11/dist-packages (from NeuroBayes==0.0.12) (0.10.3)\n", + "Requirement already satisfied: numpy>=1.23.2 in /usr/local/lib/python3.11/dist-packages (from flax>=0.8.4->NeuroBayes==0.0.12) (1.26.4)\n", + "Requirement already satisfied: msgpack in /usr/local/lib/python3.11/dist-packages (from flax>=0.8.4->NeuroBayes==0.0.12) (1.1.0)\n", + "Requirement already satisfied: optax in /usr/local/lib/python3.11/dist-packages (from flax>=0.8.4->NeuroBayes==0.0.12) (0.2.4)\n", + "Requirement already satisfied: orbax-checkpoint in /usr/local/lib/python3.11/dist-packages (from flax>=0.8.4->NeuroBayes==0.0.12) (0.6.4)\n", + "Requirement already satisfied: tensorstore in /usr/local/lib/python3.11/dist-packages (from flax>=0.8.4->NeuroBayes==0.0.12) (0.1.71)\n", + "Requirement already satisfied: rich>=11.1 in /usr/local/lib/python3.11/dist-packages (from flax>=0.8.4->NeuroBayes==0.0.12) (13.9.4)\n", + "Requirement already satisfied: typing_extensions>=4.2 in /usr/local/lib/python3.11/dist-packages (from flax>=0.8.4->NeuroBayes==0.0.12) (4.12.2)\n", + "Requirement already satisfied: PyYAML>=5.4.1 in /usr/local/lib/python3.11/dist-packages (from flax>=0.8.4->NeuroBayes==0.0.12) (6.0.2)\n", + "Requirement already satisfied: treescope>=0.1.7 in /usr/local/lib/python3.11/dist-packages (from flax>=0.8.4->NeuroBayes==0.0.12) (0.1.9)\n", + "Requirement already satisfied: ml-dtypes>=0.2.0 in /usr/local/lib/python3.11/dist-packages (from jax<=0.4.31,>=0.4.0->NeuroBayes==0.0.12) (0.4.1)\n", + "Requirement already satisfied: opt-einsum in /usr/local/lib/python3.11/dist-packages (from jax<=0.4.31,>=0.4.0->NeuroBayes==0.0.12) (3.4.0)\n", + "Requirement already satisfied: scipy>=1.10 in /usr/local/lib/python3.11/dist-packages (from jax<=0.4.31,>=0.4.0->NeuroBayes==0.0.12) (1.13.1)\n", + "Requirement already satisfied: multipledispatch in /usr/local/lib/python3.11/dist-packages (from numpyro>=0.13.0->NeuroBayes==0.0.12) (1.0.0)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.11/dist-packages (from numpyro>=0.13.0->NeuroBayes==0.0.12) (4.67.1)\n", + "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.11/dist-packages (from rich>=11.1->flax>=0.8.4->NeuroBayes==0.0.12) (3.0.0)\n", + "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.11/dist-packages (from rich>=11.1->flax>=0.8.4->NeuroBayes==0.0.12) (2.18.0)\n", + "Requirement already satisfied: absl-py>=0.7.1 in /usr/local/lib/python3.11/dist-packages (from optax->flax>=0.8.4->NeuroBayes==0.0.12) (1.4.0)\n", + "Requirement already satisfied: chex>=0.1.87 in /usr/local/lib/python3.11/dist-packages (from optax->flax>=0.8.4->NeuroBayes==0.0.12) (0.1.88)\n", + "Requirement already satisfied: etils[epy] in /usr/local/lib/python3.11/dist-packages (from optax->flax>=0.8.4->NeuroBayes==0.0.12) (1.12.0)\n", + "Requirement already satisfied: nest_asyncio in /usr/local/lib/python3.11/dist-packages (from orbax-checkpoint->flax>=0.8.4->NeuroBayes==0.0.12) (1.6.0)\n", + "Requirement already satisfied: protobuf in /usr/local/lib/python3.11/dist-packages (from orbax-checkpoint->flax>=0.8.4->NeuroBayes==0.0.12) (4.25.6)\n", + "Requirement already satisfied: humanize in /usr/local/lib/python3.11/dist-packages (from orbax-checkpoint->flax>=0.8.4->NeuroBayes==0.0.12) (4.11.0)\n", + "Requirement already satisfied: toolz>=0.9.0 in /usr/local/lib/python3.11/dist-packages (from chex>=0.1.87->optax->flax>=0.8.4->NeuroBayes==0.0.12) (0.12.1)\n", + "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.11/dist-packages (from markdown-it-py>=2.2.0->rich>=11.1->flax>=0.8.4->NeuroBayes==0.0.12) (0.1.2)\n", + "Requirement already satisfied: fsspec in /usr/local/lib/python3.11/dist-packages (from etils[epath,epy]->orbax-checkpoint->flax>=0.8.4->NeuroBayes==0.0.12) (2024.10.0)\n", + "Requirement already satisfied: importlib_resources in /usr/local/lib/python3.11/dist-packages (from etils[epath,epy]->orbax-checkpoint->flax>=0.8.4->NeuroBayes==0.0.12) (6.5.2)\n", + "Requirement already satisfied: zipp in /usr/local/lib/python3.11/dist-packages (from etils[epath,epy]->orbax-checkpoint->flax>=0.8.4->NeuroBayes==0.0.12) (3.21.0)\n", + "Downloading jax-0.4.31-py3-none-any.whl (2.0 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.0/2.0 MB\u001b[0m \u001b[31m30.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading jaxlib-0.4.31-cp311-cp311-manylinux2014_x86_64.whl (88.1 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m88.1/88.1 MB\u001b[0m \u001b[31m24.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading numpyro-0.17.0-py3-none-any.whl (360 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m360.8/360.8 kB\u001b[0m \u001b[31m21.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hBuilding wheels for collected packages: NeuroBayes\n", + " Building wheel for NeuroBayes (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for NeuroBayes: filename=NeuroBayes-0.0.12-py3-none-any.whl size=70460 sha256=cf31aa2fe9178eba0000e6d45ad05fa218692d940c8e21e90a5a1aae49a1381c\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-xdg9khda/wheels/52/f4/85/0e45c139ca1e184850945237cf19f7edb55c1ff7afbd82a351\n", + "Successfully built NeuroBayes\n", + "Installing collected packages: jaxlib, jax, numpyro, NeuroBayes\n", + " Attempting uninstall: jaxlib\n", + " Found existing installation: jaxlib 0.4.33\n", + " Uninstalling jaxlib-0.4.33:\n", + " Successfully uninstalled jaxlib-0.4.33\n", + " Attempting uninstall: jax\n", + " Found existing installation: jax 0.4.33\n", + " Uninstalling jax-0.4.33:\n", + " Successfully uninstalled jax-0.4.33\n", + "Successfully installed NeuroBayes-0.0.12 jax-0.4.31 jaxlib-0.4.31 numpyro-0.17.0\n" + ] + } + ], + "source": [ + "!pip install git+https://github.com/ziatdinovmax/NeuroBayes" + ] + }, + { + "cell_type": "markdown", + "source": [ + "Download dataset:" + ], + "metadata": { + "id": "Jxh7l0oeMgbc" + } + }, + { + "cell_type": "code", + "source": [ + "!wget https://raw.githubusercontent.com/deepchem/deepchem/master/datasets/delaney-processed.csv" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "scfe_zjFwl88", + "outputId": "928289dd-0dff-4060-d04f-93db70abeb2d" + }, + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "--2025-02-24 18:29:02-- https://raw.githubusercontent.com/deepchem/deepchem/master/datasets/delaney-processed.csv\n", + "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.111.133, 185.199.110.133, 185.199.109.133, ...\n", + "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.111.133|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 96699 (94K) [text/plain]\n", + "Saving to: ‘delaney-processed.csv’\n", + "\n", + "\rdelaney-processed.c 0%[ ] 0 --.-KB/s \rdelaney-processed.c 100%[===================>] 94.43K --.-KB/s in 0.02s \n", + "\n", + "2025-02-24 18:29:02 (4.06 MB/s) - ‘delaney-processed.csv’ saved [96699/96699]\n", + "\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Check that GPU is available:" + ], + "metadata": { + "id": "9TKlZJrxH5XF" + } + }, + { + "cell_type": "code", + "source": [ + "!nvidia-smi" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "1CoIPWp3H4Vm", + "outputId": "92c49564-13f4-4972-83d2-e23d35f58756" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mon Feb 24 18:29:02 2025 \n", + "+-----------------------------------------------------------------------------------------+\n", + "| NVIDIA-SMI 550.54.15 Driver Version: 550.54.15 CUDA Version: 12.4 |\n", + "|-----------------------------------------+------------------------+----------------------+\n", + "| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |\n", + "| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |\n", + "| | | MIG M. |\n", + "|=========================================+========================+======================|\n", + "| 0 NVIDIA A100-SXM4-40GB Off | 00000000:00:04.0 Off | 0 |\n", + "| N/A 29C P0 45W / 400W | 0MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-----------------------------------------+------------------------+----------------------+\n", + " \n", + "+-----------------------------------------------------------------------------------------+\n", + "| Processes: |\n", + "| GPU GI CI PID Type Process name GPU Memory |\n", + "| ID ID Usage |\n", + "|=========================================================================================|\n", + "| No running processes found |\n", + "+-----------------------------------------------------------------------------------------+\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Import neccessary libraries:" + ], + "metadata": { + "id": "3oQdV6SUMjHq" + } + }, + { + "cell_type": "code", + "source": [ + "import neurobayes as nb\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import r2_score" + ], + "metadata": { + "id": "7oxHwcB3x5Ym" + }, + "execution_count": 1, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Preprocess data:" + ], + "metadata": { + "id": "KZU2yj8vwjjA" + } + }, + { + "cell_type": "code", + "source": [ + "class SMILESTokenizer:\n", + " def __init__(self):\n", + " self.chars = set(' ()[]{}=-#@+/\\\\.%$NH?OSCFIBrclnop0123456789')\n", + " self.char_to_idx = {char: idx for idx, char in enumerate(self.chars)}\n", + " self.idx_to_char = {idx: char for char, idx in self.char_to_idx.items()}\n", + " self.vocab_size = len(self.chars)\n", + "\n", + " def encode(self, smiles):\n", + " return [self.char_to_idx.get(c, self.char_to_idx['?']) for c in smiles]\n", + "\n", + " def decode(self, tokens):\n", + " return ''.join([self.idx_to_char[t] for t in tokens])\n", + "\n", + "\n", + "def load_esol_data(file_path):\n", + " \"\"\"Load ESOL dataset from CSV\"\"\"\n", + " df = pd.read_csv(file_path)\n", + "\n", + " smiles_col = [col for col in df.columns if 'SMILES' in col.upper()][0]\n", + " solubility_col = [col for col in df.columns if 'SOLUBILITY' in col.upper()][0]\n", + "\n", + " return df[smiles_col].values, df[solubility_col].values\n", + "\n", + "def prepare_dataset(smiles_list, solubility_values, max_length=128):\n", + " \"\"\"Prepare entire dataset\"\"\"\n", + " tokenizer = SMILESTokenizer()\n", + " encoded = [tokenizer.encode(s) for s in smiles_list]\n", + " padded = [seq + [0] * (max_length - len(seq)) if len(seq) < max_length\n", + " else seq[:max_length] for seq in encoded]\n", + " return {\n", + " 'input_ids': np.array(padded, dtype=np.int32),\n", + " 'solubility': np.array(solubility_values, dtype=np.float32)\n", + " }\n", + "\n", + "smiles_list, solubility_values = load_esol_data('delaney-processed.csv')\n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(\n", + " smiles_list, solubility_values, test_size=0.5, random_state=1\n", + ")\n", + "\n", + "train_data = prepare_dataset(X_train.tolist(), y_train.tolist())\n", + "test_data = prepare_dataset(X_test.tolist(), y_test.tolist())" + ], + "metadata": { + "id": "hKkBrNTcwnFn" + }, + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Initialize and train a deterministic transformer model:" + ], + "metadata": { + "id": "RHvxayUPzXDg" + } + }, + { + "cell_type": "code", + "source": [ + "tokenizer = SMILESTokenizer()\n", + "model = nb.flax_nets.FlaxTransformer(\n", + " vocab_size=tokenizer.vocab_size,\n", + " d_model=16,\n", + " nhead=4,\n", + " num_layers=2,\n", + " dim_feedforward=64)\n", + "\n", + "nn_model = nb.DeterministicNN(\n", + " architecture=model,\n", + " input_shape=128,\n", + " learning_rate=1e-3,\n", + " map=False,\n", + " swa_config={'schedule': 'constant', 'start_pct': 0.90},\n", + " collect_gradients=False\n", + ")\n", + "\n", + "\n", + "nn_model.train(\n", + " train_data['input_ids'],\n", + " train_data['solubility'],\n", + " epochs=50,\n", + " batch_size=32\n", + ")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "l38QDaHXv2NL", + "outputId": "a180fe00-096e-4eb2-e8ec-3ab6323e8aed" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "Training Progress: 100%|██████████| 50/50 [00:17<00:00, 2.80it/s, Epoch 50/50, LR: 0.001000, Loss: 0.2789 ]\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Make a prediction with the trained deterministic transformer:" + ], + "metadata": { + "id": "LvibYUtXWpiL" + } + }, + { + "cell_type": "code", + "source": [ + "# Get predictions on test set\n", + "predictions = nn_model.predict(test_data['input_ids']).squeeze()\n", + "\n", + "# Compute RMSE and R^2\n", + "test_rmse = np.sqrt(np.mean((test_data['solubility'] - predictions) ** 2))\n", + "test_r2 = r2_score(test_data['solubility'], predictions)\n", + "\n", + "print(\"\\nModel Performance:\")\n", + "print(f\"Test RMSE: {test_rmse:.4f}\")\n", + "print(f\"Test R²: {test_r2:.4f}\")\n", + "\n", + "# Show example predictions\n", + "print(\"\\nExample Predictions:\")\n", + "for i in range(min(5, len(X_test))):\n", + " pred = float(nn_model.predict(test_data['input_ids'][i:i+1])[0, 0]) # Access the scalar value\n", + " print(f\"SMILES: {X_test[i]}\")\n", + " print(f\"True Solubility: {y_test[i]:.2f}\")\n", + " print(f\"Predicted Solubility: {pred:.2f}\\n\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "dVgPGKO00MaI", + "outputId": "280ed6e2-1bb1-4c80-9c5a-3c592f0e9217" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "Model Performance:\n", + "Test RMSE: 0.5376\n", + "Test R²: 0.8925\n", + "\n", + "Example Predictions:\n", + "SMILES: CCCCCCCCCC(=O)OC\n", + "True Solubility: -3.32\n", + "Predicted Solubility: -2.62\n", + "\n", + "SMILES: Cc1cc(ccc1NS(=O)(=O)C(F)(F)F)S(=O)(=O)c2ccccc2\n", + "True Solubility: -4.95\n", + "Predicted Solubility: -4.49\n", + "\n", + "SMILES: Nc1nc[nH]n1\n", + "True Solubility: -0.67\n", + "Predicted Solubility: -0.31\n", + "\n", + "SMILES: Clc1ccc(c(Cl)c1)c2cc(Cl)c(Cl)c(Cl)c2Cl \n", + "True Solubility: -7.34\n", + "Predicted Solubility: -7.07\n", + "\n", + "SMILES: CCOC(=O)c1ccccc1\n", + "True Solubility: -2.77\n", + "Predicted Solubility: -2.88\n", + "\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Next, we convert our deterministic Transformer model into a partially Bayesian Transformer. We will test three types of layers: token embedding, attention, and final (fully connected) layer. Since making even a single layer probabilistic introduces substantial computational overhead, we will select only a subset of weights from that layer for Bayesian treatment. There are multiple ways to select this subset of probabilistic weights - based on magnitude, variance, and changes in gradient. At this point, it's not entirely clear to me which method should be used in which situation. For this tutorial notebook, we'll stick to 'variance', but feel free to explore other options, including completely random selection.\n", + "\n", + "If you see the sampling seriously struggling (very small step size and acceptance probability close to zero) after more than 20% of warmup steps, I recommend stopping it and changing the probabilistic weights selection strategy." + ], + "metadata": { + "id": "UU4PBhBoWxev" + } + }, + { + "cell_type": "markdown", + "source": [ + "NeuroBayes has a utility function for printing each layer name and specs, which makes the selection and assignment process easier:" + ], + "metadata": { + "id": "lReOsn-jjua2" + } + }, + { + "cell_type": "code", + "source": [ + "nb.print_layer_configs(nn_model.model)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "RUXStModj3iY", + "outputId": "0e797533-bfe8-4d8b-8558-c1078c6e1a10" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "================================================================================\n", + "Model Architecture: FlaxTransformer\n", + "================================================================================\n", + "\n", + "layer_name layer_type features num_embeddings\n", + "-------------------------------------------------------\n", + "TokenEmbed embedding 16 42 \n", + "PosEmbed embedding 16 1024 \n", + "Block0_Attention attention 16 \n", + "Block0_LayerNorm1 layernorm - \n", + "Block0_MLP_dense1 fc 64 \n", + "Block0_MLP_dense2 fc 16 \n", + "Block0_LayerNorm2 layernorm - \n", + "Block1_Attention attention 16 \n", + "Block1_LayerNorm1 layernorm - \n", + "Block1_MLP_dense1 fc 64 \n", + "Block1_MLP_dense2 fc 16 \n", + "Block1_LayerNorm2 layernorm - \n", + "FinalDense1 fc 64 \n", + "FinalDense2 fc 1 \n", + "\n", + "================================================================================\n", + "Total layers: 14\n", + "================================================================================\n", + "\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Select probabilistic layer(s), a corresponding subset of probabilistic weights, and train a partially Bayesian Transformer:" + ], + "metadata": { + "id": "D4NDkdZVj0YK" + } + }, + { + "cell_type": "code", + "source": [ + "# Specify probabilistic layers\n", + "probabilistic_layers = ['TokenEmbed']\n", + "\n", + "# Select a subset of weights for the selected probabilistic layers\n", + "prob_indices = nb.select_bayesian_components(\n", + " nn_model,\n", + " layer_names=probabilistic_layers,\n", + " method='variance',\n", + " num_pairs_per_layer=100\n", + ")\n", + "\n", + "# Initialize a partially Bayesian Transformer\n", + "pbnn_model = nb.PartialBayesianTransformer(\n", + " nn_model.model,\n", + " deterministic_weights=nn_model.get_params(),\n", + " probabilistic_layer_names=probabilistic_layers,\n", + " probabilistic_neurons=prob_indices\n", + ")\n", + "\n", + "# Train\n", + "pbnn_model.fit(\n", + " train_data[\"input_ids\"],\n", + " train_data['solubility'],\n", + " num_warmup=1000,\n", + " num_samples=1000,\n", + ")" + ], + "metadata": { + "id": "5CF0IxasA-5A", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "4818ca8b-5f09-47e9-e0ff-ee801349dd1a" + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "sample: 100%|██████████| 2000/2000 [10:14<00:00, 3.25it/s, 63 steps of size 8.25e-02. acc. prob=0.91]\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Compute prediction accuracy and uncertaintyu metrics:" + ], + "metadata": { + "id": "fGZMz7XrOCyI" + } + }, + { + "cell_type": "code", + "source": [ + "# Get predictions on test set\n", + "predictions, variance = pbnn_model.predict(test_data['input_ids'])\n", + "predictions = predictions.squeeze()\n", + "variance = variance.squeeze()\n", + "\n", + "# Compute RMSE and R^2\n", + "test_rmse_emb = np.sqrt(np.mean((test_data['solubility'] - predictions) ** 2))\n", + "test_r2_emb = r2_score(test_data['solubility'], predictions)\n", + "\n", + "print(\"Model Performance:\")\n", + "print(f\"Test RMSE: {test_rmse_emb:.4f}\")\n", + "print(f\"Test R²: {test_r2_emb:.4f}\")\n", + "\n", + "# Compute negative log predictive density and coverage probability\n", + "test_nlpd_emb = nb.utils.nlpd(test_data['solubility'], predictions, variance)\n", + "test_coverage_emb = nb.utils.coverage(test_data['solubility'], predictions, variance)\n", + "\n", + "print(f\"NLPD: {test_nlpd_emb:.4f}\")\n", + "print(f\"Coverage probability: {test_coverage_emb:.4f}\")" + ], + "metadata": { + "id": "pjKelSZG35xi", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "3a40d473-5363-416f-dc12-97922b0c9baf" + }, + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Model Performance:\n", + "Test RMSE: 0.5399\n", + "Test R²: 0.8915\n", + "NLPD: 0.8274\n", + "Coverage probability: 0.9096\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Now let's do the same for the final learnable layer in the architecture:" + ], + "metadata": { + "id": "OQ3lWS7WVtzZ" + } + }, + { + "cell_type": "code", + "source": [ + "probabilistic_layers = ['FinalDense1']\n", + "\n", + "prob_indices = nb.select_bayesian_components(\n", + " nn_model,\n", + " layer_names=probabilistic_layers,\n", + " method='variance',\n", + " num_pairs_per_layer=100\n", + ")\n", + "\n", + "pbnn_model = nb.PartialBayesianTransformer(\n", + " nn_model.model,\n", + " deterministic_weights=nn_model.get_params(),\n", + " probabilistic_layer_names=probabilistic_layers,\n", + " probabilistic_neurons=prob_indices\n", + ")\n", + "\n", + "pbnn_model.fit(\n", + " train_data[\"input_ids\"],\n", + " train_data['solubility'],\n", + " num_warmup=1000,\n", + " num_samples=1000,\n", + ")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ZOaFYIy9-Hz6", + "outputId": "94cab34e-e94c-466a-aded-996508e13471" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "sample: 100%|██████████| 2000/2000 [09:50<00:00, 3.39it/s, 127 steps of size 2.92e-02. acc. prob=0.89]\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Get predictions on test set\n", + "predictions, variance = pbnn_model.predict(test_data['input_ids'])\n", + "predictions = predictions.squeeze()\n", + "variance = variance.squeeze()\n", + "\n", + "# Compute RMSE and R^2\n", + "test_rmse_fin = np.sqrt(np.mean((test_data['solubility'] - predictions) ** 2))\n", + "test_r2_fin = r2_score(test_data['solubility'], predictions)\n", + "print(\"\\nModel Performance:\")\n", + "print(f\"Test RMSE: {test_rmse_fin:.4f}\")\n", + "print(f\"Test R²: {test_r2_fin:.4f}\")\n", + "\n", + "\n", + "# Compute negative log predictive density and coverage probability\n", + "test_nlpd_fin = nb.utils.nlpd(test_data['solubility'], predictions, variance)\n", + "test_coverage_fin = nb.utils.coverage(test_data['solubility'], predictions, variance)\n", + "print(f\"NLPD: {test_nlpd_fin:.4f}\")\n", + "print(f\"Coverage probability: {test_coverage_fin:.4f}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "U__IKNPsf0JB", + "outputId": "217198be-1650-409f-e675-c87a889a6cf1" + }, + "execution_count": 9, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "Model Performance:\n", + "Test RMSE: 0.5389\n", + "Test R²: 0.8920\n", + "NLPD: 0.8323\n", + "Coverage probability: 0.9149\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Now let's make one of the attention layers partially probabilisitc. We will also do a 'data thinning', i.e. select only a subset of traning data points, to speed up the computations:" + ], + "metadata": { + "id": "scS4sMXzd4Ek" + } + }, + { + "cell_type": "code", + "source": [ + "probabilistic_layers = ['Block0_Attention']\n", + "\n", + "prob_indices = nb.select_bayesian_components(\n", + " nn_model,\n", + " probabilistic_layers,\n", + " method='variance',\n", + " num_pairs_per_layer=32)\n", + "\n", + "pbnn_model = nb.PartialBayesianTransformer(\n", + " nn_model.model,\n", + " deterministic_weights=nn_model.get_params(),\n", + " probabilistic_layer_names=probabilistic_layers,\n", + " probabilistic_neurons=prob_indices\n", + ")\n", + "\n", + "pbnn_model.fit(\n", + " train_data[\"input_ids\"][::10], # data thinning\n", + " train_data['solubility'][::10],\n", + " num_warmup=1000,\n", + " num_samples=1000,\n", + ")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "M-_r3wPld9wA", + "outputId": "4fa209fb-545c-4cc0-9d38-32868c5af755" + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "sample: 100%|██████████| 2000/2000 [05:10<00:00, 6.43it/s, 127 steps of size 3.00e-02. acc. prob=0.94]\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Get predictive metrics:" + ], + "metadata": { + "id": "anHmlcSIet6Z" + } + }, + { + "cell_type": "code", + "source": [ + "# Get predictions on test set\n", + "predictions, variance = pbnn_model.predict(test_data['input_ids'])\n", + "predictions = predictions.squeeze()\n", + "variance = variance.squeeze()\n", + "\n", + "# Compute RMSE and R^2\n", + "test_rmse_att = np.sqrt(np.mean((test_data['solubility'] - predictions) ** 2))\n", + "test_r2_att = r2_score(test_data['solubility'], predictions)\n", + "print(\"\\nModel Performance:\")\n", + "print(f\"Test RMSE: {test_rmse_att:.4f}\")\n", + "print(f\"Test R²: {test_r2_att:.4f}\")\n", + "\n", + "\n", + "# Compute negative log predictive density and coverage probability\n", + "test_nlpd_att = nb.utils.nlpd(test_data['solubility'], predictions, variance)\n", + "test_coverage_att = nb.utils.coverage(test_data['solubility'], predictions, variance)\n", + "print(f\"NLPD: {test_nlpd_att:.4f}\")\n", + "print(f\"Coverage probability: {test_coverage_att:.4f}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "FFrNKZzqd9yf", + "outputId": "a2d39157-75b6-4a85-a0d0-78115a3a21fc" + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "Model Performance:\n", + "Test RMSE: 0.5456\n", + "Test R²: 0.8892\n", + "NLPD: 0.8067\n", + "Coverage probability: 0.9291\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Finally, let's comppare predictive metrics for the three cases, as well as against Gaussian process baseline (computed in this separate [notebook](https://github.com/ziatdinovmax/NeuroBayes/blob/main/examples/GPyTorch_esol.ipynb)):" + ], + "metadata": { + "id": "gUHLNSV0d90q" + } + }, + { + "cell_type": "code", + "source": [ + "# GP results\n", + "test_rmse_gp = 0.6887\n", + "test_nlpd_gp = 0.9575\n", + "test_coverage_gp = 0.9291\n", + "\n", + "# Labels for the bars\n", + "labels = [\"Partially Bayesian\\nToken Embedding\",\n", + " \"Partially Bayesian\\nFinal Layer\",\n", + " \"Partially Bayesian\\nAttention\",\n", + " \"Gaussian\\nProcess\"]\n", + "\n", + "# RMSE, NLPD, and Coverage values\n", + "rmse_values = [test_rmse_emb, test_rmse_fin, test_rmse_att, test_rmse_gp]\n", + "nlpd_values = [test_nlpd_emb, test_nlpd_fin, test_nlpd_att, test_nlpd_gp]\n", + "coverage_values = [test_coverage_emb, test_coverage_fin, test_coverage_att, test_coverage_gp]\n", + "\n", + "# Colors for each model\n", + "colors = ['green', 'red', 'blue', 'purple']\n", + "\n", + "# Create figure and axes with more width for the labels\n", + "plt.figure(figsize=(20, 6))\n", + "_, (ax0, ax1, ax2) = plt.subplots(1, 3, figsize=(20, 6))\n", + "\n", + "# Function to create bars with error bars\n", + "def create_bar_plot(ax, values, title, ylabel, colors, labels):\n", + " bars = ax.bar(np.arange(len(values)), values, color=colors)\n", + " ax.set_xticks(np.arange(len(values)))\n", + " ax.set_xticklabels(labels, rotation=45, ha='right')\n", + " ax.set_ylabel(ylabel)\n", + " ax.set_title(title)\n", + " # Add value labels on top of bars\n", + " for bar in bars:\n", + " height = bar.get_height()\n", + " ax.text(bar.get_x() + bar.get_width()/2., height,\n", + " f'{height:.3f}',\n", + " ha='center', va='bottom')\n", + " return bars\n", + "\n", + "# Create the three plots\n", + "create_bar_plot(ax0, rmse_values,\n", + " \"Root Mean Squared Error\\n(lower is better)\",\n", + " \"Root Mean Squared Error\",\n", + " colors, labels)\n", + "\n", + "create_bar_plot(ax1, nlpd_values,\n", + " \"Negative Log Predictive Density\\n(lower is better)\",\n", + " \"Negative Log Predictive Density\",\n", + " colors, labels)\n", + "\n", + "create_bar_plot(ax2, coverage_values,\n", + " \"Coverage Probability\\n(higher is better)\",\n", + " \"Coverage Probability\",\n", + " colors, labels)\n", + "\n", + "# Set y-axis limits for NLPD and Coverage as in original\n", + "ax1.set_ylim(0.7, 1.1)\n", + "ax2.set_ylim(0.7, 1.0)\n", + "\n", + "# Adjust layout to prevent label overlap\n", + "plt.tight_layout()\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 464 + }, + "id": "PPfJvSQymyBL", + "outputId": "fe6bd733-f99d-4613-bd17-dc1543c8cfb7" + }, + "execution_count": 12, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "oV6FH65VvPYC" + }, + "execution_count": 12, + "outputs": [] + } + ] +} \ No newline at end of file