From fceb684982598f8dc926419300c7ae5d69b618a8 Mon Sep 17 00:00:00 2001 From: maclandrol Date: Wed, 20 Dec 2023 23:15:09 -0500 Subject: [PATCH 1/3] add example for representation --- .../extracting-representation-molfeat.ipynb | 336 ++++++++++++++++++ mkdocs.yml | 1 + 2 files changed, 337 insertions(+) create mode 100644 docs/tutorials/extracting-representation-molfeat.ipynb diff --git a/docs/tutorials/extracting-representation-molfeat.ipynb b/docs/tutorials/extracting-representation-molfeat.ipynb new file mode 100644 index 0000000..43e1b7d --- /dev/null +++ b/docs/tutorials/extracting-representation-molfeat.ipynb @@ -0,0 +1,336 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import safe\n", + "import torch\n", + "import datamol as dm\n", + "import types\n", + "from molfeat.trans.pretrained import PretrainedMolTransformer\n", + "from molfeat.trans.pretrained import PretrainedHFTransformer\n", + "\n", + "from molfeat.trans.pretrained.hf_transformers import HFModel\n", + "from safe.trainer.model import SAFEDoubleHeadsModel\n", + "from safe.tokenizer import SAFETokenizer\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading the SAFE-GPT model into molfeat\n", + "\n", + "Because the SAFE model is not a standard HuggingFace `transformers` model, we need to wrap it.\n", + "\n", + "Why are we doing this ? Because we want to leverage the structure of `molfeat` and not have to write our own pooling for the model. This can be done by using the huggingface molecule transformer `PretrainedHFTransformer` rather than the general purpose pretrained model class `PretrainedMolTransformer` where we will have to define our own `_embed` and `_convert` function." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "safe_model = SAFEDoubleHeadsModel.from_pretrained(\"datamol-io/safe-gpt\")\n", + "safe_tokenizer = SAFETokenizer.from_pretrained(\"datamol-io/safe-gpt\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now need to build the `molfeat`'s `HFModel` instance by wrapping our model." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "safe_hf_model = HFModel.from_pretrained(safe_model, safe_tokenizer.get_pretrained())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can put the above process in the `__init__` of the `SAFEMolTransformer` if you wish as we will be doing below." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Building the SAFE Molecule Transformers\n", + "\n", + "We have multiple options here, we can override the `_convert` method or even the `_embed` method but the best thing about `molfeat` is how flexible it is and all the shortcuts it provides. \n", + "\n", + "In this case, we just need to change the custom \n", + "# so really we just need our custom converter" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-12-20 22:57:39.310\u001b[0m | \u001b[33m\u001b[1mWARNING \u001b[0m | \u001b[36mmolfeat.trans.base\u001b[0m:\u001b[36m__init__\u001b[0m:\u001b[36m51\u001b[0m - \u001b[33m\u001b[1mThe 'SAFEMolTransformer' interaction has been superseded by a new class with id 0x2ad77d6a0\u001b[0m\n" + ] + } + ], + "source": [ + "class SAFEMolTransformer(PretrainedHFTransformer):\n", + " \"\"\"Build the SAFE Molecule transformers, the only thing we need to define is \n", + " how we convert the input molecules into the safe format\"\"\"\n", + " def __init__(self, kind=None, notation=\"safe\", **kwargs):\n", + " if kind is None:\n", + " # we load the default SAFE model if the exact SAFE GPT model \n", + " # to use is not provided\n", + " safe_model = SAFEDoubleHeadsModel.from_pretrained(\"datamol-io/safe-gpt\")\n", + " safe_tokenizer = SAFETokenizer.from_pretrained(\"datamol-io/safe-gpt\")\n", + " kind = HFModel.from_pretrained(safe_model, safe_tokenizer.get_pretrained())\n", + " super().__init__(kind, notation=None, **kwargs)\n", + " # now we change the internal converter\n", + " # overriding the internal converter of SmilesConverter leverages the exception handling\n", + " # The SAFE-GPT model was trained on a slightly different splitting algorithm compared to the default BRICS\n", + " # this does not change anything in theory, it just try harder to break bonds even if there are no BRICS bonds.\n", + " self.converter.converter = types.SimpleNamespace(decode=safe.decode, encode=safe.utils.convert_to_safe)\n", + " # you could also do any of the following:\n", + " # self.converter = types.SimpleNamespace(decode=safe.decode, encode=safe.encode)\n", + " # self.converter = safe # the safe module\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's use the GPT pooler which uses the last non padding token (often `eos`) since the model is GPT2 like. For other options, see: https://molfeat-docs.datamol.io/stable/api/molfeat.utils.html#pooling" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
SAFEMolTransformer(dtype=np.float32)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "SAFEMolTransformer(dtype=np.float32)" + ] + }, + "execution_count": 98, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Let's use the GPT pooling method\n", + "safe_transformers = SAFEMolTransformer(pooling=\"gpt\")\n", + "safe_transformers" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": {}, + "outputs": [], + "source": [ + "mols = dm.data.freesolv().iloc[:10].smiles.values" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.05216356, 0.10754181, 0.07509107, ..., 0.04756968,\n", + " -0.08228929, -0.11568106],\n", + " [ 0.02449008, 0.04048932, 0.14489463, ..., 0.11410899,\n", + " -0.02203353, 0.08706839],\n", + " [-0.07425696, 0.11859665, 0.19010407, ..., 0.10526019,\n", + " 0.08878426, -0.06609854],\n", + " ...,\n", + " [ 0.07867863, 0.19300285, 0.23054805, ..., -0.00737952,\n", + " 0.07542405, 0.00289541],\n", + " [ 0.12092628, -0.01785688, 0.19791883, ..., 0.13796932,\n", + " 0.11520796, -0.15333697],\n", + " [-0.02005584, 0.13946685, 0.18568742, ..., 0.07080407,\n", + " 0.06991849, -0.07151204]], dtype=float32)" + ] + }, + "execution_count": 100, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "safe_transformers(mols)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Basic Test" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.ensemble import RandomForestRegressor\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.pipeline import Pipeline\n", + "\n", + "df = dm.data.freesolv()\n", + "df[\"safe\"] = df[\"smiles\"].apply(safe_transformers.converter.encode)\n", + "df = df.dropna(subset=\"safe\")\n", + "# we have to remove the molecules that cannot be converted \n", + "# (no breakable bonds with our default methodology)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "X, y = df[\"smiles\"].values, df[\"expt\"].values\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=25, test_size=0.2)\n", + "\n", + "# The Molfeat transformer seemingly integrates with Scikit-learn Pipeline!\n", + "pipe = Pipeline([(\"feat\", safe_transformers), (\"rf\", RandomForestRegressor())])" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [], + "source": [ + "with dm.without_rdkit_log():\n", + " pipe.fit(X_train, y_train)\n", + " score = pipe.score(X_test, y_test)\n", + " y_pred = pipe.predict(X_test)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R2 score 0.5082630204054333\n" + ] + } + ], + "source": [ + "print(\"R2 score\", score)" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Preds')" + ] + }, + "execution_count": 105, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.scatter(y_test, y_pred)\n", + "ax.set_xlabel(\"Target\")\n", + "ax.set_ylabel(\"Preds\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Not really a great result. Any other model in `molfeat` would do better." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Tips\n", + "\n", + "1. Make sure that your inputs are SMILES or RDKit Molecules.\n", + "2. If you are getting an error coming from some tokenization step, that means that you are likely getting `None` molecules at some steps in the conversion to SAFE. This can happen if there your slicing algorithm of choice is not working. In that case, please filter your datasets to remove molecules that fails the encoding steps first. You can always use the very robus `safe.utils.convert_to_safe`, which augment default BRICS slicing with some graph partitioning algorithm.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "safe", + "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.11.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/mkdocs.yml b/mkdocs.yml index d302e8d..379083b 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -16,6 +16,7 @@ nav: - Getting Started: tutorials/getting-started.ipynb - Molecular design: tutorials/design-with-safe.ipynb - How it works: tutorials/how-it-works.ipynb + - Extracting representation (molfeat): tutorials/extracting-representation-molfeat.ipynb - API: - SAFE: api/safe.md - Visualization: api/safe.viz.md From 529003341ea75a50c172a9592307b1cc2f46b595 Mon Sep 17 00:00:00 2001 From: maclandrol Date: Wed, 20 Dec 2023 23:23:11 -0500 Subject: [PATCH 2/3] wip --- .../extracting-representation-molfeat.ipynb | 34 +++++++++---------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/docs/tutorials/extracting-representation-molfeat.ipynb b/docs/tutorials/extracting-representation-molfeat.ipynb index 43e1b7d..17977c2 100644 --- a/docs/tutorials/extracting-representation-molfeat.ipynb +++ b/docs/tutorials/extracting-representation-molfeat.ipynb @@ -128,32 +128,32 @@ }, { "cell_type": "code", - "execution_count": 98, + "execution_count": 116, "metadata": {}, "outputs": [ { "data": { "text/html": [ - "
SAFEMolTransformer(dtype=np.float32)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + "
SAFEMolTransformer(dtype=np.float32)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" ], "text/plain": [ "SAFEMolTransformer(dtype=np.float32)" ] }, - "execution_count": 98, + "execution_count": 116, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# Let's use the GPT pooling method\n", - "safe_transformers = SAFEMolTransformer(pooling=\"gpt\")\n", + "# Let's use the GPT pooling method and only take the last hidden layer\n", + "safe_transformers = SAFEMolTransformer(pooling=\"gpt\", concat_layers=[-1])\n", "safe_transformers" ] }, { "cell_type": "code", - "execution_count": 99, + "execution_count": 117, "metadata": {}, "outputs": [], "source": [ @@ -162,7 +162,7 @@ }, { "cell_type": "code", - "execution_count": 100, + "execution_count": 118, "metadata": {}, "outputs": [ { @@ -183,7 +183,7 @@ " 0.06991849, -0.07151204]], dtype=float32)" ] }, - "execution_count": 100, + "execution_count": 118, "metadata": {}, "output_type": "execute_result" } @@ -201,7 +201,7 @@ }, { "cell_type": "code", - "execution_count": 101, + "execution_count": 119, "metadata": {}, "outputs": [], "source": [ @@ -218,7 +218,7 @@ }, { "cell_type": "code", - "execution_count": 102, + "execution_count": 120, "metadata": {}, "outputs": [], "source": [ @@ -232,7 +232,7 @@ }, { "cell_type": "code", - "execution_count": 103, + "execution_count": 121, "metadata": {}, "outputs": [], "source": [ @@ -244,24 +244,24 @@ }, { "cell_type": "code", - "execution_count": 104, + "execution_count": 122, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "R2 score 0.5082630204054333\n" + "R2 score: 0.4971483821661925\n" ] } ], "source": [ - "print(\"R2 score\", score)" + "print(\"R2 score:\", score)" ] }, { "cell_type": "code", - "execution_count": 105, + "execution_count": 123, "metadata": {}, "outputs": [ { @@ -270,13 +270,13 @@ "Text(0, 0.5, 'Preds')" ] }, - "execution_count": 105, + "execution_count": 123, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From 527dbf633ccdafd6896857ae5ebf1ddd67bda0bf Mon Sep 17 00:00:00 2001 From: maclandrol Date: Wed, 20 Dec 2023 23:29:41 -0500 Subject: [PATCH 3/3] do not run the features notebook --- tests/test_notebooks.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_notebooks.py b/tests/test_notebooks.py index e4e4d9d..23a0ab5 100644 --- a/tests/test_notebooks.py +++ b/tests/test_notebooks.py @@ -13,7 +13,7 @@ NOTEBOOK_PATHS = list(filter(lambda x: x.name not in DISABLE_NOTEBOOKS, NOTEBOOK_PATHS)) # Discard some notebooks -NOTEBOOKS_TO_DISCARD = ["Basic_Concepts.ipynb"] +NOTEBOOKS_TO_DISCARD = ["extracting-representation-molfeat.ipynb"] NOTEBOOK_PATHS = list(filter(lambda x: x.name not in NOTEBOOKS_TO_DISCARD, NOTEBOOK_PATHS))