solubility.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from util import *\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import deepchem as dc\n",
    "import warnings\n",
    "import os\n",
    "\n",
    "warnings.filterwarnings('ignore')\n",
    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "results = {}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Graph Convolutional Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load esol dataset from csv\n",
    "tasks = ['measured log solubility in mols per litre']\n",
    "loader = dc.data.CSVLoader(tasks=tasks, feature_field=\"smiles\", featurizer=dc.feat.ConvMolFeaturizer())\n",
    "dataset = loader.create_dataset('esol.csv')\n",
    "\n",
    "# split esol dataset\n",
    "splitter = dc.splits.RandomSplitter()\n",
    "train_set, test_set = splitter.train_test_split(dataset, frac_train=0.8, seed=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hyper_params = {\n",
    "    'batch_size': [32, 16],\n",
    "    'graph_conv_layers': [[128, 128], [256, 256], [512, 512]],\n",
    "    'dense_layer_size': [512, 256, 128],\n",
    "    'dropout': [0.0],\n",
    "}\n",
    "\n",
    "search_results, (batch_size, conv_layers, layer_sizes, dropout_rate) = grid_search_graph_conv(train_set, hyper_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        rmse  batch_size conv_layers  layer_sizes  dropout_rate\n",
      "14  0.909815          16  [256, 256]          128           0.0\n",
      "16  0.925040          16  [512, 512]          256           0.0\n",
      "7   0.927719          32  [512, 512]          256           0.0\n",
      "17  0.932643          16  [512, 512]          128           0.0\n",
      "11  0.934425          16  [128, 128]          128           0.0\n",
      "5   0.939430          32  [256, 256]          128           0.0\n",
      "8   0.943036          32  [512, 512]          128           0.0\n",
      "10  0.945521          16  [128, 128]          256           0.0\n",
      "13  0.946772          16  [256, 256]          256           0.0\n",
      "2   0.949801          32  [128, 128]          128           0.0\n",
      "9   0.953160          16  [128, 128]          512           0.0\n",
      "3   0.961466          32  [256, 256]          512           0.0\n",
      "12  0.962208          16  [256, 256]          512           0.0\n",
      "4   0.966723          32  [256, 256]          256           0.0\n",
      "15  0.969348          16  [512, 512]          512           0.0\n",
      "0   0.987445          32  [128, 128]          512           0.0\n",
      "6   0.988186          32  [512, 512]          512           0.0\n",
      "1   0.990654          32  [128, 128]          256           0.0\n"
     ]
    }
   ],
   "source": [
    "print(search_results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train scores\n",
      "{'mean-rms_score': 0.39749705901679855, 'mean-mae_score': 0.32439183461783083, 'mean-pearson_r2_score': 0.9683124191242287}\n",
      "Test scores\n",
      "{'mean-rms_score': 0.7843367191956222, 'mean-mae_score': 0.6250962894537979, 'mean-pearson_r2_score': 0.867844137654933}\n"
     ]
    }
   ],
   "source": [
    "transformers = [dc.trans.NormalizationTransformer(transform_y=True, dataset=train_set, move_mean=True)]\n",
    "\n",
    "# preprocess data\n",
    "for transformer in transformers:\n",
    "    train_set = transformer.transform(train_set)\n",
    "    test_set = transformer.transform(test_set)\n",
    "\n",
    "# intantiate and fit model\n",
    "model = dc.models.GraphConvModel(1, mode='regression', batch_size=batch_size, graph_conv_layers=conv_layers, dense_layer_size=layer_sizes, dropout=dropout_rate)\n",
    "model.fit(train_set, nb_epoch=100)\n",
    "\n",
    "# evaluate model\n",
    "metric = [\n",
    "    dc.metrics.Metric(dc.metrics.rms_score, np.mean),\n",
    "    dc.metrics.Metric(dc.metrics.mae_score, np.mean),\n",
    "    dc.metrics.Metric(dc.metrics.pearson_r2_score, np.mean)\n",
    "]\n",
    "train_scores = model.evaluate(train_set, metric, transformers)\n",
    "test_scores = model.evaluate(test_set, metric, transformers)\n",
    "\n",
    "print(\"Train scores\")\n",
    "print(train_scores)\n",
    "\n",
    "print(\"Test scores\")\n",
    "print(test_scores)\n",
    "\n",
    "results['gcm'] = test_scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Message Passing Neural Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load esol dataset from csv\n",
    "tasks = ['measured log solubility in mols per litre']\n",
    "loader = dc.data.CSVLoader(tasks=tasks, feature_field=\"smiles\", featurizer=dc.feat.WeaveFeaturizer())\n",
    "dataset = loader.create_dataset('esol.csv')\n",
    "\n",
    "# split esol dataset\n",
    "splitter = dc.splits.RandomSplitter()\n",
    "train_set, test_set = splitter.train_test_split(dataset, frac_train=0.8, seed=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[####################                    ]"
     ]
    }
   ],
   "source": [
    "hyper_params = {\n",
    "    'batch_size': [32, 16],\n",
    "    'n_atom_feat': [75],\n",
    "    'n_pair_feat': [14],\n",
    "    'n_hidden': [100]\n",
    "}\n",
    "\n",
    "search_results, (batch_size, n_atom_feat, n_pair_feat, n_hidden) = grid_search_mpnn(train_set, hyper_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       rmse  batch_size  n_atom_feat  n_pair_feat  n_hidden\n",
      "0  0.679996          32           75           14       100\n",
      "1  0.686250          16           75           14       100\n"
     ]
    }
   ],
   "source": [
    "print(search_results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train scores\n",
      "{'mean-rms_score': 0.47224031965659397, 'mean-mae_score': 0.36102604904376745, 'mean-pearson_r2_score': 0.9631306808853515}\n",
      "Test scores\n",
      "{'mean-rms_score': 0.6103362570698991, 'mean-mae_score': 0.47893592794330364, 'mean-pearson_r2_score': 0.9197362733301125}\n"
     ]
    }
   ],
   "source": [
    "transformers = [dc.trans.NormalizationTransformer(transform_y=True, dataset=train_set, move_mean=True)]\n",
    "\n",
    "# preprocess data\n",
    "for transformer in transformers:\n",
    "    train_set = transformer.transform(train_set)\n",
    "    test_set = transformer.transform(test_set)\n",
    "\n",
    "# intantiate and fit model\n",
    "model = dc.models.MPNNModel(1, mode='regression', batch_size=batch_size, use_queue=False, n_atom_feat=n_atom_feat, n_pair_feat=n_pair_feat, n_hidden=n_hidden, learning_rate=0.0001, T=3, M=5)\n",
    "model.fit(train_set, nb_epoch=50, checkpoint_interval=100)\n",
    "\n",
    "# evaluate model\n",
    "metric = [\n",
    "    dc.metrics.Metric(dc.metrics.rms_score, np.mean),\n",
    "    dc.metrics.Metric(dc.metrics.mae_score, np.mean),\n",
    "    dc.metrics.Metric(dc.metrics.pearson_r2_score, np.mean)\n",
    "]\n",
    "train_scores = model.evaluate(train_set, metric, transformers)\n",
    "test_scores = model.evaluate(test_set, metric, transformers)\n",
    "\n",
    "print(\"Train scores\")\n",
    "print(train_scores)\n",
    "\n",
    "print(\"Test scores\")\n",
    "print(test_scores)\n",
    "\n",
    "results['mpnn'] = test_scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random Forest Regressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load esol dataset from csv\n",
    "tasks = ['measured log solubility in mols per litre']\n",
    "loader = dc.data.CSVLoader(tasks=tasks, feature_field=\"smiles\", featurizer=dc.feat.CircularFingerprint(size=2048, radius=4))\n",
    "dataset = loader.create_dataset('esol.csv')\n",
    "\n",
    "# split esol dataset\n",
    "splitter = dc.splits.RandomSplitter()\n",
    "train_set, test_set = splitter.train_test_split(dataset, frac_train=0.8, seed=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[####################      ]"
     ]
    }
   ],
   "source": [
    "hyper_params = {\n",
    "    'n_estimators': [250, 500, 1000],\n",
    "    'criterion': ['mse', 'mae'],\n",
    "    'max_features': ['auto']\n",
    "}\n",
    "\n",
    "search_results, (n_estimators, criterion, max_features) = grid_search_random_forest(train_set, hyper_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       rmse  n_estimators criterion max_features\n",
      "2  1.225431           500       mse         auto\n",
      "4  1.225469          1000       mse         auto\n",
      "0  1.226358           250       mse         auto\n",
      "1  1.233063           250       mae         auto\n",
      "3  1.235029           500       mae         auto\n",
      "5  1.235786          1000       mae         auto\n"
     ]
    }
   ],
   "source": [
    "print(search_results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train scores\n",
      "{'mean-rms_score': 0.4557074378032759, 'mean-mae_score': 0.32590803615678415, 'mean-pearson_r2_score': 0.965785107964993}\n",
      "Test scores\n",
      "{'mean-rms_score': 1.1422869134998823, 'mean-mae_score': 0.8716654813527174, 'mean-pearson_r2_score': 0.7005435810374528}\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestRegressor\n",
    "\n",
    "# intantiate and fit model\n",
    "sklearn_model = RandomForestRegressor(n_estimators=n_estimators, criterion=criterion, max_features=max_features, random_state=0)\n",
    "model = dc.models.SklearnModel(sklearn_model)\n",
    "model.fit(train_set)\n",
    "\n",
    "# evaluate model\n",
    "metric = [\n",
    "    dc.metrics.Metric(dc.metrics.rms_score, np.mean),\n",
    "    dc.metrics.Metric(dc.metrics.mae_score, np.mean),\n",
    "    dc.metrics.Metric(dc.metrics.pearson_r2_score, np.mean)\n",
    "]\n",
    "train_scores = model.evaluate(train_set, metric, [])\n",
    "test_scores = model.evaluate(test_set, metric, [])\n",
    "\n",
    "print(\"Train scores\")\n",
    "print(train_scores)\n",
    "\n",
    "print(\"Test scores\")\n",
    "print(test_scores)\n",
    "\n",
    "results['rfr'] = test_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0gAAAGrCAYAAAD6qLfeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAZS0lEQVR4nO3de2zV9R3w8U+hMkGNisKc1Nlhgw60Fj0KuMmmzqhMO5wXwAgSFHTDER06d3nmpgkqW9RtKov6EBE1VIdT3ES3iQM3560gInjBWxWIIrihMEVFz/OHH5shFUotnNbn9Uqa0PO7nM/JN+3pu7/TQ1mxWCwGAAAA0aHUAwAAALQVAgkAACAJJAAAgCSQAAAAkkACAABIAgkAACAJJAAAgCSQACi5ysrK6Ny5c2y//fax2267xciRI2PNmjURETFy5MgoKyuLGTNmrHfMueeeG2VlZTFlypSIiHjvvfdi/PjxUVFREdtvv31UVlbGOeec0+R9fPxx9tlnb62HCEA7IZAAaBP+9Kc/xZo1a2L+/Pnx+OOPx6WXXtq4rVevXjF16tTGz9etWxe33XZb7LXXXo23XXrppVFfXx+PPvporF69OmbPnh0HHHBAk/fx8cfVV1+95R8YAO1KeakHAID/tdtuu8VRRx0V8+fPb7ztuOOOi5tuuin+85//xM477xz33ntvVFdXx+rVqxv3eeyxx+L444+P3XffPSI+umJUWVm5lacHoL1zBQmANmXp0qVxzz33RFVVVeNt2267bXznO9+Jurq6iIiYOnVqjBgxYr3j+vfvH1dccUVMmjQpnnzyySgWi1t1bgA+HwQSAG3C4MGDY4cddog99tgjunfvHhdddNF620eMGBFTp06NVatWxZw5c2Lw4MHrbf/JT34SF1xwQdxyyy1RKBSiR48eceONN25wHzvttFPjx/XXX7+lHxYA7YxAAqBNuPPOOxv/duiZZ56JlStXrrf961//eqxYsSImTJgQxx57bHTu3Hm97R07doyxY8fGgw8+GKtWrYqf/exnMWrUqHj66afXu49Vq1Y1fowePXqrPDYA2g+BBECb8o1vfCNGjhwZ55133gbbTj311Lj88ss3eHndJ3Xu3DnGjh0bO++8czz11FNbalQAPoe8SQMAbc4555wTlZWV8cQTT6x3+7hx4+LQQw+NgQMHbnDMb37zm6ipqYl+/frFNttsE7fcckusXr06+vbtu7XGBuBzQCAB0OZ069YtRowYERdffHHssMMOjbd37do1jjjiiCaP6dKlS4wfPz6ef/75KCsri169esXtt98ePXv2bNznuOOOi44dOzZ+fuSRR8Ydd9yx5R4IAO1OWdHb/AAAAESEv0ECAABoJJAAAACSQAIAAEgCCQAAILW7d7Hbddddo7KystRjAAAAbVRDQ8MG/+F4c7W7QKqsrIz6+vpSjwEAALRRhUKhxcd6iR0AAEASSAAAAEkgAQAAJIEEAACQBBIAAEASSAAAAEkgAQAAJIEEAACQBBIAAEASSAAAAEkgAQAApPJSD7C55j//cux07JmlHgMAPrNVf7621CMA8AmuIAEAACSBBAAAkAQSAABAEkgAAABJIAEAACSBBAAAkAQSAABAEkgAAABJIAEAACSBBAAAkAQSAABAEkgAAABJIAEAACSBBAAAkAQSAABAEkgAAABJIAEAACSBBAAAkAQSAABAEkgAAABJIAEAACSBBAAAkAQSAABAEkgAAABJIAEAACSBBAAAkAQSAABAEkgAAABJIAEAACSBBAAAkAQSAABAEkgAAABJIAEAACSBBAAAkAQSAABAEkgAAABJIAEAACSBBAAAkAQSAABAEkgAAABJIAEAACSBBAAAkAQSAABAEkgAAABJIAEAACSBBAAAkAQSAABA+kyBtHz58jjllFOiZ8+eceCBB8aAAQPijjvuiIiIRx99NAYOHBh777139O3bN84444x4++23Y8qUKVFWVhb33Xdf43nuvPPOKCsri+nTp3+2RwMAAPAZtDiQisViDB48OAYOHBgvvvhizJ07N+rq6mLp0qWxfPnyOOmkk2LixInx7LPPxuOPPx5HH310rF69OiIi9ttvv6irq2s817Rp02L//ff/7I8GAADgMyhv6YH3339/dOrUKc4666zG2/bcc8/4wQ9+EBdeeGGcdtppMWDAgMZtJ554YuO/Dz300PjHP/4R77//frz77rvx/PPPR01NTUtHAQAAaBUtvoK0aNGiOOCAA5rctnDhwjjwwAM/9diysrL41re+FX/5y19ixowZUVtbu9H7uu6666JQKEShUIgP31vb0pEBAAA2qtXepGHs2LGx//77x0EHHdSs/YcOHRp1dXVRV1cXw4YN2+i+Y8aMifr6+qivr48OnbZtjXEBAAA20OJA6tOnT8ybN6/x82uuuSZmzZoVK1asiD59+sTcuXM3evzBBx8cTz75ZKxcuTJ69erV0jEAAABaTYsD6fDDD4+1a9fG73//+8bb3n777YiIOPvss+PGG2+MRx55pHHbH//4x1i+fPl657jsssvikksuaekIAAAArarFb9JQVlYWd955Z5x77rnxq1/9Krp16xbbbbddTJw4Mb74xS9GXV1dnHfeefH6669Hhw4dYuDAgXH00Uevd45jjjnmMz8AAACA1lJWLBaLpR5ic5Tv1C22//p3Sz0GAHxmq/58balHAPhcKhQKUV9f36JjW+1NGgAAANo7gQQAAJAEEgAAQBJIAAAASSABAAAkgQQAAJAEEgAAQBJIAAAASSABAAAkgQQAAJAEEgAAQBJIAAAASSABAAAkgQQAAJAEEgAAQBJIAAAASSABAAAkgQQAAJAEEgAAQBJIAAAASSABAAAkgQQAAJAEEgAAQBJIAAAASSABAAAkgQQAAJAEEgAAQBJIAAAASSABAAAkgQQAAJAEEgAAQBJIAAAASSABAAAkgQQAAJAEEgAAQBJIAAAASSABAAAkgQQAAJAEEgAAQBJIAAAASSABAAAkgQQAAJAEEgAAQBJIAAAAqbzUA2yumqo9o/7P15Z6DAAA4HPIFSQAAIAkkAAAAJJAAgAASAIJAAAgCSQAAIAkkAAAAJJAAgAASAIJAAAgCSQAAIAkkAAAAJJAAgAASAIJAAAgCSQAAIAkkAAAAJJAAgAASAIJAAAgCSQAAIAkkAAAAJJAAgAASAIJAAAgCSQAAIAkkAAAAJJAAgAASAIJAAAgCSQAAIBUXuoBNtdLDa/H8NN/V+oxANq9myaPK/UIANDmuIIEAACQBBIAAEASSAAAAEkgAQAAJIEEAACQBBIAAEASSAAAAEkgAQAAJIEEAACQBBIAAEASSAAAAEkgAQAAJIEEAACQBBIAAEASSAAAAEkgAQAAJIEEAACQBBIAAEASSAAAAEkgAQAAJIEEAACQBBIAAEASSAAAAEkgAQAAJIEEAACQBBIAAEASSAAAAEkgAQAAJIEEAACQBBIAAEASSAAAAEkgAQAAJIEEAACQBBIAAEASSAAAAEkgAQAAJIEEAACQBBIAAEASSAAAAEkgAQAAJIEEAACQBBIAAEASSAAAAEkgAQAAJIEEAACQBBIAAEDaZCCVlZXFqaee2vj5unXrolu3bnHsscdGRMSUKVOiW7duUVNTE717947rr7++8fYOHTrEggULGo/dd999o6GhISIiKisr44QTTmjcNn369Bg5cmRrPCYAAIAW2WQgbbfddrFw4cJ45513IiLib3/7W/To0WO9fYYMGRLz58+P2bNnx09/+tNYvnx5RERUVFTEhAkTPvXcc+fOjaeeeuqzzA8AANBqmvUSu0GDBsXdd98dERHTpk2LYcOGNblf9+7dY6+99oqXX345IiKOPfbYWLRoUTz77LNN7j9+/PiNBhQAAMDW1KxAGjp0aNTV1cXatWtjwYIF0a9fvyb3e/HFF+PFF1+Mqqqqj07eoUP86Ec/iksuuaTJ/U8++eSYN29ePP/88y0cHwAAoPU0K5Cqq6ujoaEhpk2bFoMGDdpg+6233ho1NTUxbNiwuPbaa6Nr166N20455ZR4+OGH46WXXtrguI4dO8b5558fl1566Ubv/7rrrotCoRCFQiHeXbumOSMDAABstma/i11tbW2cd955Tb687uO/QXrkkUfi+OOPX29beXl5jB8/PiZOnNjkeYcPHx4PPPBALFmy5FPve8yYMVFfXx/19fXxhW23b+7IAAAAm6XZgTRq1Kj4xS9+Efvtt99m38nIkSPjvvvuixUrVmywbZtttolzzz03rrzyys0+LwAAQGtqdiBVVFTEuHHjWnQnnTp1inHjxsXrr7/e5PbTTz891q1b16JzAwAAtJayYrFYLPUQm2OXXb8cg75zXqnHAGj3bprcsl96AUBbVygUor6+vkXHNvsKEgAAwOedQAIAAEgCCQAAIAkkAACAJJAAAACSQAIAAEgCCQAAIAkkAACAJJAAAACSQAIAAEgCCQAAIAkkAACAJJAAAACSQAIAAEgCCQAAIAkkAACAJJAAAACSQAIAAEgCCQAAIAkkAACAJJAAAACSQAIAAEgCCQAAIAkkAACAJJAAAACSQAIAAEgCCQAAIAkkAACAJJAAAACSQAIAAEgCCQAAIAkkAACAJJAAAACSQAIAAEgCCQAAIAkkAACAJJAAAACSQAIAAEgCCQAAIAkkAACAJJAAAACSQAIAAEgCCQAAIAkkAACAJJAAAABSeakH2FxfqeweN00eV+oxAACAzyFXkAAAAJJAAgAASAIJAAAgCSQAAIAkkAAAAJJAAgAASAIJAAAgCSQAAIAkkAAAAJJAAgAASAIJAAAgCSQAAIAkkAAAAJJAAgAASAIJAAAgCSQAAIAkkAAAAJJAAgAASAIJAAAgCSQAAIAkkAAAAJJAAgAASAIJAAAgCSQAAIAkkAAAAFJ5qQfYXCsbVsb/Pf36Uo8BAMAWdMbk0aUegf9PuYIEAACQBBIAAEASSAAAAEkgAQAAJIEEAACQBBIAAEASSAAAAEkgAQAAJIEEAACQBBIAAEASSAAAAEkgAQAAJIEEAACQBBIAAEASSAAAAEkgAQAAJIEEAACQBBIAAEASSAAAAEkgAQAAJIEEAACQBBIAAEASSAAAAEkgAQAAJIEEAACQBBIAAEASSAAAAEkgAQAAJIEEAACQBBIAAEASSAAAAEkgAQAAJIEEAACQBBIAAEASSAAAAEkgAQAAJIEEAACQBBIAAEASSAAAAEkgAQAAJIEEAACQBBIAAEASSAAAAEkgAQAAJIEEAACQBBIAAEBqtUDq2LFj1NTUxL777hvHHXdcrFq1KiIiGhoaonPnzlFTU9P48d5778WUKVOiW7duUVNTE/vss09ceeWVrTUKAABAi7RaIHXu3Dnmz58fCxcujK5du8Y111zTuG2vvfaK+fPnN3506tQpIiKGDBkS8+fPjwcffDAmTJgQS5Ysaa1xAAAANtsWeYndgAEDYtmyZc3ef5dddomqqqp49dVXt8Q4AAAAzdLqgfTBBx/ErFmzora2tvG2F154ofHldWPHjt3gmFdeeSXWrl0b1dXVTZ7zuuuui0KhEIVCIVavXd3aIwMAAERERHlrneidd96JmpqaWLZsWXz1q1+NI488snHbxy+x+6Rbb701HnjggXjmmWfi6quvjm233bbJc48ZMybGjBkTERGVu1a21sgAAADrafW/QXr55ZejWCyu9zdIn2bIkCGxYMGC+Ne//hU//vGP47XXXmutcQAAADZbq7/ErkuXLvG73/0uLr/88li3bl2zjikUCjF8+PD47W9/29rjAAAANNsWeZOGvn37RnV1dUybNq3Zx1xwwQVxww03xOrV/sYIAAAojbJisVgs9RCbo3LXyvg/3/lZqccAAGALOmPy6FKPQDtWKBSivr6+RcdukStIAAAA7ZFAAgAASAIJAAAgCSQAAIAkkAAAAJJAAgAASAIJAAAgCSQAAIAkkAAAAJJAAgAASAIJAAAgCSQAAIAkkAAAAJJAAgAASAIJAAAgCSQAAIAkkAAAAJJAAgAASAIJAAAgCSQAAIAkkAAAAJJAAgAASAIJAAAgCSQAAIAkkAAAAJJAAgAASAIJAAAgCSQAAIAkkAAAAJJAAgAASAIJAAAgCSQAAIAkkAAAAJJAAgAASAIJAAAgCSQAAIAkkAAAAJJAAgAASAIJAAAgCSQAAIAkkAAAAJJAAgAASAIJAAAgCSQAAIAkkAAAAFJ5qQfYXLtW7hpnTB5d6jEAAIDPIVeQAAAAkkACAABIAgkAACAJJAAAgCSQAAAAkkACAABIAgkAACAJJAAAgCSQAAAAkkACAABIAgkAACAJJAAAgFRWLBaLpR5ic2y//faxzz77lHoMWmDFihXRrVu3Uo9BC1m/9s36tV/Wrn2zfu2XtWvfnnnmmVizZk2Lji1v5Vm2uH322Sfq6+tLPQYtUCgUrF07Zv3aN+vXflm79s36tV/Wrn0rFAotPtZL7AAAAJJAAgAASO0ukMaMGVPqEWgha9e+Wb/2zfq1X9aufbN+7Ze1a98+y/q1uzdpAAAA2FLa3RUkAACALUUgAQAApDYbSPfee2/svffeUVVVFZdddtkG2999990YMmRIVFVVRb9+/aKhoWHrD0mTNrV2V1xxRfTu3Tuqq6vjiCOOiJdffrkEU/JpNrV+H7v99tujrKzMW6C2Ic1Zu9tuuy169+4dffr0iVNOOWUrT8jGbGr9XnnllTjssMOib9++UV1dHTNnzizBlDRl1KhR0b1799h3332b3F4sFmPcuHFRVVUV1dXVMW/evK08IRuzqfW75ZZborq6Ovbbb7845JBD4oknntjKE/JpNrV2H3vssceivLw8pk+f3rwTF9ugdevWFXv27Fl84YUXiu+++26xurq6uGjRovX2ueaaa4pnnnlmsVgsFqdNm1Y8+eSTSzEqn9Cctbv//vuL//3vf4vFYrE4adIka9eGNGf9isVi8a233ioeeuihxX79+hUfe+yxEkzKJzVn7RYvXlysqakp/vvf/y4Wi8Xi8uXLSzEqTWjO+o0ePbo4adKkYrFYLC5atKi45557lmBSmjJnzpzi3Llzi3369Gly+9133108+uijix9++GHxoYceKh588MFbeUI2ZlPr9+CDDzZ+35w5c6b1a0M2tXbF4kffXw877LDiMcccU/zDH/7QrPO2yStIjz76aFRVVUXPnj2jU6dOMXTo0JgxY8Z6+8yYMSNOO+20iIg48cQTY9asWVH0fhMl15y1O+yww6JLly4REdG/f/9YunRpKUalCc1Zv4iIn//853HBBRfEtttuW4IpaUpz1u7666+PsWPHxs477xwREd27dy/FqDShOetXVlYWb731VkREvPnmm7H77ruXYlSaMHDgwOjateunbp8xY0aMGDEiysrKon///rFq1ap49dVXt+KEbMym1u+QQw5p/L7p55a2ZVNrFxFx1VVXxQknnLBZz3ltMpCWLVsWe+yxR+PnFRUVsWzZsk/dp7y8PHbcccd44403tuqcbKg5a/e/Jk+eHMccc8zWGI1maM76zZs3L5YsWRLf/va3t/Z4bERz1m7x4sWxePHi+NrXvhb9+/ePe++9d2uPyadozvr98pe/jJtvvjkqKipi0KBBcdVVV23tMWmhzX1upO3yc0v7smzZsrjjjjvie9/73mYdV76F5oFNuvnmm6O+vj7mzJlT6lFopg8//DB++MMfxpQpU0o9Ci2wbt26eO6552L27NmxdOnSGDhwYDz55JOx0047lXo0mmHatGkxcuTIGD9+fDz00EMxfPjwWLhwYXTo0CZ/1wmfO3//+99j8uTJ8c9//rPUo9BM55xzTkycOHGzv0+2yUDq0aNHLFmypPHzpUuXRo8ePZrcp6KiItatWxdvvvlm7LLLLlt7VD6hOWsXEXHffffFhAkTYs6cOfGFL3xha47IRmxq/VavXh0LFy6Mb37zmxER8dprr0VtbW3cddddUSgUtva4/I/mfO1VVFREv379YptttomvfOUr0atXr3juuefioIMO2trj8gnNWb/Jkyc3XvUbMGBArF27NlauXOmlku1Ac58babsWLFgQZ5xxRtxzzz1+3mxH6uvrY+jQoRERsXLlypg5c2aUl5fH4MGDN3pcm/y100EHHRTPPfdcvPTSS/Hee+9FXV1d1NbWrrdPbW1t3HjjjRERMX369Dj88MOjrKysFOPyP5qzdo8//niceeaZcdddd3lib2M2tX477rhjrFy5MhoaGqKhoSH69+8vjtqI5nztDR48OGbPnh0RHz1RLF68OHr27FmCafmk5qzfl7/85Zg1a1ZERDz99NOxdu3a6NatWynGZTPV1tbG1KlTo1gsxsMPPxw77rhjfOlLXyr1WDTTK6+8Et/97nfjpptuil69epV6HDbDSy+91Pgzy4knnhiTJk3aZBxFtNErSOXl5XH11VfHUUcdFR988EGMGjUq+vTpExdeeGEUCoWora2N008/PYYPHx5VVVXRtWvXqKurK/XYRPPW7vzzz481a9bESSedFBEfPenfddddJZ6ciOatH21Tc9buqKOOir/+9a/Ru3fv6NixY/z617/2m9A2ojnrd/nll8fo0aPjyiuvjLKyspgyZYpfDLYRw4YNi9mzZ8fKlSujoqIiLrroonj//fcjIuKss86KQYMGxcyZM6Oqqiq6dOkSN9xwQ4kn5n9tav0uvvjieOONN+L73/9+RHz09eq/uGgbNrV2LVVW9NZvAAAAEdFGX2IHAABQCgIJAAAgCSQAAIAkkAAAAJJAAgAASAIJAAAgCSQAAID0/wD4rVf8mqLZeAAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1008x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1008x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1008x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "color_palette = ['#005075', '#535b9a', '#a459a3']\n",
    "score_keys = ['mean-rms_score', 'mean-mae_score', 'mean-pearson_r2_score']\n",
    "plot_titles = ['RMSE', 'MAE', 'R2']\n",
    "\n",
    "# draw bar plots\n",
    "for score_key, plot_title in zip(score_keys, plot_titles):\n",
    "\n",
    "    scores = [results['gcm'][score_key], results['mpnn'][score_key], results['rfr'][score_key]]\n",
    "    model_labels = ['GCM', 'MPNN', 'RFR']\n",
    "\n",
    "    fig = plt.figure(figsize=(14, 7), facecolor='w')\n",
    "    sns.barplot(scores, model_labels, orient='h', palette=color_palette)\n",
    "    plt.title(plot_title)\n",
    "    plt.xlim([0, 1.4])\n",
    "    plt.savefig('images/%s.png' % plot_title.lower())"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "cd4f712bdf0515c4096e7f378f6652de9b65133e68b219cf86da6448b555e669"
  },
  "kernelspec": {
   "display_name": "Python 3.9.2 64-bit",
   "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.9.2"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}