first_gen_models.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/caer200/ocelotml_2d/blob/main/first_gen_models.ipynb)"
      ],
      "metadata": {
        "id": "lDK9eS-WGUKe"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ui5U-e0eykZy"
      },
      "source": [
        "# Install the required packages\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cDODiUjZyljL",
        "outputId": "1c676e49-29d4-45bb-ef7c-f6296bf058fa"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting rdkit\n",
            "  Downloading rdkit-2022.9.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (29.5 MB)\n",
            "\u001b[K     |████████████████████████████████| 29.5 MB 1.6 MB/s \n",
            "\u001b[?25hRequirement already satisfied: Pillow in /usr/local/lib/python3.7/dist-packages (from rdkit) (7.1.2)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from rdkit) (1.21.6)\n",
            "Installing collected packages: rdkit\n",
            "Successfully installed rdkit-2022.9.1\n"
          ]
        }
      ],
      "source": [
        "!pip install rdkit"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "vtsfONuczU1A"
      },
      "outputs": [],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import json\n",
        "from sklearn.svm import SVR\n",
        "from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error\n",
        "from sklearn.kernel_ridge import KernelRidge\n",
        "from sklearn.linear_model import Ridge\n",
        "import pandas as pd\n",
        "from tqdm import tqdm\n",
        "import rdkit.Chem as Chem\n",
        "import numpy as np\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uFqC5a9PyvBY"
      },
      "source": [
        "# Get the OCELOT ML library"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Nb6zhdi8yvkx",
        "outputId": "3223e81c-e44e-48e1-8b31-b240dd073411"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cloning into 'ocelotml_2d'...\n",
            "remote: Enumerating objects: 73, done.\u001b[K\n",
            "remote: Counting objects: 100% (5/5), done.\u001b[K\n",
            "remote: Compressing objects: 100% (4/4), done.\u001b[K\n",
            "remote: Total 73 (delta 4), reused 1 (delta 1), pack-reused 68\u001b[K\n",
            "Unpacking objects: 100% (73/73), done.\n"
          ]
        }
      ],
      "source": [
        "!git clone https://github.com/caer200/ocelotml_2d.git"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XEQUSyi4QgM4"
      },
      "source": [
        "# Get the model parameters "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "XP7T5BMDQsFf"
      },
      "outputs": [],
      "source": [
        "import requests, zipfile, io\n",
        "\n",
        "def get_models():\n",
        "  MODELS_URL = \"https://drive.google.com/uc?export=download&id=1FfGyJ-ZLfb_vdk6-05TsfH0W2ZIk9T4f&confirm=f\"\n",
        "  r = requests.get(MODELS_URL)\n",
        "  z = zipfile.ZipFile(io.BytesIO(r.content))\n",
        "  z.extractall(\"models\")\n",
        "\n",
        "get_models()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H9iHavYhy7WV"
      },
      "source": [
        "# Define training functions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "tUmYWxQ9y-I_"
      },
      "outputs": [],
      "source": [
        "from ocelotml_2d.mlp_features import *\n",
        "\n",
        "def plot_pred_true(true, pred):\n",
        "  plt.scatter(true, pred)\n",
        "  plt.xlabel(\"True values (eV)\")\n",
        "  plt.ylabel(\"Predicted values (eV)\")\n",
        "  plt.show()\n",
        "\n",
        "def prepare_data(model_name, data_frame, fp=None):\n",
        "  train = data_frame.sample(frac = 0.8)\n",
        "  test = data_frame.loc[~data_frame.index.isin(train.index)]\n",
        "  train_smiles = train.smiles\n",
        "  test_smiles = test.smiles\n",
        "  mtype = model_name.split(\"_\")[0]\n",
        "  #skip = F\"{mtype}_with_fp_\" if \"with\" in model_name else F\"{mtype}_no_fp_\"\n",
        "  data_name = model_name.split(\"_\")[0]\n",
        "  #data_name = model_name.replace(skip, \"\")\n",
        "  train_data = np.array(train[data_name])\n",
        "  test_data = np.array(test[data_name])\n",
        "  mol_train = [Chem.MolFromSmiles(mol) for mol in tqdm(train_smiles, desc = \"Making training molecules\")]\n",
        "  mol_test = [Chem.MolFromSmiles(mol) for mol in tqdm(test_smiles, desc = \"Making testing molecules\")]\n",
        "\n",
        "  train_feats = [molecule_descriptors(mol, fp=fp) for mol in tqdm(mol_train, desc = \"Making training features\")]\n",
        "  test_feats = [molecule_descriptors(mol, fp=fp) for mol in tqdm(mol_test, desc = \"Making training features\")]\n",
        "  return train_feats, test_feats, train_data, test_data\n",
        "\n",
        "\n",
        "\n",
        "def SVM_training(xtrain, xtest, ytrain, ytest, params, plot=True, return_fitted=False):\n",
        "  reg = SVR(**params)\n",
        "  reg.fit(xtrain, ytrain)\n",
        "  my_pred = reg.predict(xtest)\n",
        "  r2 = r2_score(ytest, my_pred)\n",
        "  MAE = mean_absolute_error(ytest, my_pred)\n",
        "  if plot:\n",
        "    plot_pred_true(ytest, my_pred)\n",
        "  if return_fitted:\n",
        "    return round(r2, 3), round(MAE, 3), reg\n",
        "  else:\n",
        "    return round(r2, 3), round(MAE, 3), None\n",
        "\n",
        "  \n",
        "def KRR_training(xtrain, xtest, ytrain, ytest, params, plot=True, return_fitted=False):\n",
        "  reg = KernelRidge(**params)\n",
        "  reg.fit(xtrain, ytrain)\n",
        "  my_pred = reg.predict(xtest)\n",
        "  r2 = r2_score(ytest, my_pred)\n",
        "  MAE = mean_absolute_error(ytest, my_pred)\n",
        "  if plot:\n",
        "    plot_pred_true(ytest, my_pred)\n",
        "  if return_fitted:\n",
        "    return round(r2, 3), round(MAE, 3), reg\n",
        "  else:\n",
        "    return round(r2, 3), round(MAE, 3), None\n",
        "\n",
        "def Ridge_regression_training(xtrain, xtest, ytrain, ytest, params, plot=True, return_fitted = False):\n",
        "  reg = Ridge(**params)\n",
        "  reg.fit(xtrain, ytrain)\n",
        "  my_pred = reg.predict(xtest)\n",
        "  r2 = r2_score(ytest, my_pred)\n",
        "  MAE = mean_absolute_error(ytest, my_pred)\n",
        "  if plot:\n",
        "    plot_pred_true(ytest, my_pred)\n",
        "  if return_fitted:\n",
        "    return round(r2, 3), round(MAE, 3), reg\n",
        "  else:\n",
        "    return round(r2, 3), round(MAE, 3), None\n",
        "\n",
        "def prediction_from_fitted_model(molecule, model, fp=None):\n",
        "  if model is None:\n",
        "    print(\"Needs a trained model, set get_back_trained_model to True\")\n",
        "    return None\n",
        "  mol = Chem.MolFromSmiles(molecule)\n",
        "  if mol is None:\n",
        "    print(F\"Molecule {molecule} is not valid!\")\n",
        "    return None\n",
        "  feats = np.array(molecule_descriptors(mol, fp = fp))\n",
        "  prediction = model.predict([feats])\n",
        "  return round(prediction[0], 3)\n",
        "  \n",
        "\n",
        "def define_model(name, plot=True, return_fitted=True, partial_amount = None):\n",
        "  try:\n",
        "    with open(F\"models/ocelotml_2d/{name}/params.json\", \"r\") as file:\n",
        "      param_d = json.load(file)\n",
        "  except FileNotFoundError:\n",
        "    print(F\"Model {name} does not exist\")\n",
        "    return (None, None, None), None\n",
        "  if \"FP\" in name:\n",
        "    fp = param_d.pop(\"fp_length\")\n",
        "  else:\n",
        "    fp = None\n",
        "  if partial_amount:\n",
        "\n",
        "    df = pd.read_csv(\"https://drive.google.com/uc?export=download&id=1zrb9HfWR-ydyf3WxoDMZQZxcSx3Q_JGh\", index_col=0).iloc[:partial_amount]\n",
        "  else:\n",
        "    df = pd.read_csv(\"https://drive.google.com/uc?export=download&id=1zrb9HfWR-ydyf3WxoDMZQZxcSx3Q_JGh\", index_col=0)\n",
        "  xtr, xt, ytr, yt = prepare_data(name, df, fp=fp)\n",
        "  if \"svm\" in name:\n",
        "    return SVM_training(xtr, xt, ytr, yt, param_d, plot, return_fitted), fp\n",
        "  elif \"krr\" in name:\n",
        "    return KRR_training(xtr, xt, ytr, yt, param_d, plot, return_fitted), fp\n",
        "  elif \"ridge\" in name:\n",
        "    return Ridge_regression_training(xtr, xt, ytr, yt, param_d, plot, return_fitted), fp\n",
        "  \n",
        "\n",
        "  \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7iRz80PVzZMw"
      },
      "source": [
        "# Train a model!\n",
        "\n",
        "A model can be chosen with the following architectures:\n",
        "\n",
        "\n",
        "1.   Support Vector Machine (svm)\n",
        "2.   Kernel Ridge Regression (krr)\n",
        "3.   Ridge Regression (ridge)\n",
        "\n",
        "Model names have the format {target}\\_1gen_\\{model}\\_{FP?}\n",
        "Example: \n",
        "\n",
        "\n",
        "*   Training a LUMO model without fingerprints with Ridge Regression\n",
        "      *   lumo\\_1gen\\_ridge \n",
        "*   Training a model for AEA with fingerprints using Support Vector Machine\n",
        "      *   aea\\_1gen\\_svm\\_FP\n",
        "\n",
        "It will take a bit to train these models! But relax, they're worth the wait 😎\n",
        "(KRR models may take very long)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 368
        },
        "id": "psuYXoynzaLA",
        "outputId": "fee6aa49-acc7-4281-eb02-3729bf5c2a79"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Making training molecules: 100%|██████████| 20201/20201 [00:07<00:00, 2796.92it/s]\n",
            "Making testing molecules: 100%|██████████| 5050/5050 [00:00<00:00, 5636.69it/s]\n",
            "Making training features: 100%|██████████| 20201/20201 [01:39<00:00, 202.66it/s]\n",
            "Making training features: 100%|██████████| 5050/5050 [00:24<00:00, 206.38it/s]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The r^2 for vea_1gen_ridge_FP is 0.815 and the MAE is 0.221 eV\n"
          ]
        }
      ],
      "source": [
        "model_selection = \"vea_1gen_ridge_FP\"\n",
        "\n",
        "plot_result = True\n",
        "get_back_trained_model = True\n",
        "\n",
        "partial_amount = None # set this equal to some number if you don't have the time to wait for the full set to train\n",
        "#ex: partial_amount = 1000 will only use the first 1,000 points from the ocelot_chromophore_v1 dataset\n",
        "#be warned, training on partial subsets of data will yield a worse model than training on the full set!\n",
        "\n",
        "training_output,fp_len = define_model(model_selection, plot_result, get_back_trained_model, partial_amount = partial_amount)\n",
        "r2, mae, trained_model = training_output\n",
        "\n",
        "\n",
        "print(F\"The r^2 for {model_selection} is {r2} and the MAE is {mae} eV\")\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GZoiRrXpCff-",
        "outputId": "78f1395f-a813-4448-9231-b9a2cd0f9b87"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "vea_1gen_ridge_FP predicts the value of 1.292 for c1ccccc1\n"
          ]
        }
      ],
      "source": [
        "\n",
        "my_molecule = \"c1ccccc1\"\n",
        "\n",
        "\n",
        "my_prediction = prediction_from_fitted_model(my_molecule, trained_model, fp_len)\n",
        "\n",
        "\n",
        "print(F\"{model_selection} predicts the value of {my_prediction} for {my_molecule}\")"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}