docs/source/molecules.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d6d6567f",
   "metadata": {},
   "source": [
    "# Molecules"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0263619d",
   "metadata": {},
   "source": [
    "A molecular or chemical graph is a structural representation of molecule in which atoms are nodes and chemical bonds define the edges of the graph. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "92d4c820",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<rdkit.Chem.rdchem.Mol at 0x22d30637450>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import rdkit.Chem as Chem\n",
    "Chem.MolFromSmiles(\"CN1C=NC2=C1C(=O)N(C(=O)N2C)C\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2422d333",
   "metadata": {},
   "source": [
    "A chemical structure can be depicted in 2D with chemiformatics software such as [`RDKit`](https://www.rdkit.org/) or [`OpenBabel`](https://www.rdkit.org/). Both have similar class definitions of molecules, atoms and bonds classes and provide a large scope of methods to work with molecular structures.\n",
    "\n",
    "In `kgcnn.mol.base` a general interface `MolGraphInterface` is defined that should unify access to the chemical graph used for deep learning models. Both `RDKit` and `OpenBabel` can be used as backend (Note that `OpenBabel` must be installed manually since no complete pypi installation is yet available). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "086ae657",
   "metadata": {},
   "outputs": [],
   "source": [
    "from kgcnn.molecule.graph_rdkit import MolecularGraphRDKit\n",
    "from kgcnn.molecule.graph_babel import MolecularGraphOpenBabel"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc2dc71c",
   "metadata": {},
   "source": [
    "Main operations to generate a molecular graph from e.g. smiles or mol-tables as well as generating and optimizting conformation or compute charges are methods of the interface and can be used with both `RDKit` or `OpenBabel` backend. Specific kwargs for those methods, however, are handed to the specific functions of the backend and therefore require knowledge about the paramters of the backend."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "27eedfc3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<kgcnn.molecule.graph_rdkit.MolecularGraphRDKit at 0x22d5062b460>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mg = MolecularGraphRDKit(make_directed=False)\n",
    "mg.from_smiles(\"CN1C=NC2=C1C(=O)N(C(=O)N2C)C\")\n",
    "mg.add_hs()\n",
    "mg.make_conformer()\n",
    "mg.optimize_conformer(force_field=\"mmff94\")\n",
    "mg.compute_partial_charges(method=\"gasteiger\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18936a22",
   "metadata": {},
   "source": [
    "Note that the actual Mol-Class not privaate and accessible via `mol` ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "44b9d370",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<rdkit.Chem.rdchem.Mol object at 0x0000022D2F04A2D0>'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(mg.mol)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c6351a3",
   "metadata": {},
   "source": [
    "Most importantly are methods to generate graph properties from the mol-object. In the example below are node and edge types or numbers, for the first 4 atoms or bonds, respectively:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8e5648ce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[ 0,  1],\n",
       "        [ 0, 14],\n",
       "        [ 0, 15],\n",
       "        [ 0, 16]], dtype=int64),\n",
       " ['C', 'N', 'C', 'N'],\n",
       " array([[ 3.26735076,  0.61278444, -0.2364124 ],\n",
       "        [ 2.1264268 , -0.26661905, -0.26747634],\n",
       "        [ 2.15131889, -1.61634095, -0.50052716],\n",
       "        [ 0.94130742, -2.13852225, -0.46338622]]),\n",
       " [1, 1, 1, 1])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mg.edge_indices[:4], mg.node_symbol[:4], mg.node_coordinates[:4], mg.edge_number[1][:4]  # Indices and bond order"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da051053",
   "metadata": {},
   "source": [
    "For attributed graphs a feature vector for atoms, bonds and the total graph has been found to improve GNNs. The functions of the interface `node_attributes` , `edge_attributes` and `graph_attributes` and take a list of strings (predifined) or functions for each attributes. Here are the list of attributes for `RDKit` by name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6ea31450",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['NumBonds', 'AtomicNum', 'AtomMapNum', 'Idx', 'Degree', 'TotalDegree', 'Symbol', 'NumExplicitHs', 'NumImplicitHs', 'TotalNumHs', 'IsAromatic', 'Isotope', 'TotalValence', 'Mass', 'MassScaled', 'IsInRing', 'Hybridization', 'NoImplicit', 'ChiralTag', 'FormalCharge', 'ExplicitValence', 'ImplicitValence', 'NumRadicalElectrons', 'HasOwningMol', 'PDBResidueInfo', 'MonomerInfo', 'Smarts', 'CIPCode', 'CIPRank', 'ChiralityPossible', 'MolFileRLabel', 'GasteigerCharge', 'GasteigerHCharge', 'AtomFeatures', 'DescribeQuery', 'Rvdw', 'RvdwScaled', 'Rcovalent', 'RcovalentScaled'])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MolecularGraphRDKit.atom_fun_dict.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "32b3ae80",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['BondType', 'IsAromatic', 'IsConjugated', 'IsInRing', 'Stereo', 'Idx', 'BeginAtom', 'BeginAtomIdx', 'BondDir', 'BondTypeAsDouble', 'EndAtom', 'EndAtomIdx', 'Smarts', 'DescribeQuery'])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MolecularGraphRDKit.bond_fun_dict.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "400a2f8c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['C', 'N', 'O', 'H', 'S', 'F', 'Cl', 'NumAtoms', 'AtomsIsInRing', 'AtomsIsAromatic', 'NumBonds', 'BondsIsConjugated', 'BondsIsAromatic', 'NumRotatableBonds', 'ExactMolWt', 'FpDensityMorgan3', 'FractionCSP3', 'MolLogP', 'MolMR', 'fr_Al_COO', 'fr_Ar_COO', 'fr_Al_OH', 'fr_Ar_OH', 'fr_C_O_noCOO', 'fr_NH2', 'fr_SH', 'fr_sulfide', 'fr_alkyl_halide'])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MolecularGraphRDKit.mol_fun_dict.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3052c1ea",
   "metadata": {},
   "source": [
    "Then node attributes for the molecular graph can be generated from a list of attribute names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "5f1571e5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[4, 12.011, 'C', False, '0.012958350519987684'],\n",
       " [3, 14.007, 'N', True, '-0.32786346609948208'],\n",
       " [3, 12.011, 'C', True, '0.097502273308341464'],\n",
       " [2, 14.007, 'N', True, '-0.21837692759548705']]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mg.node_attributes([\"NumBonds\", \"Mass\", \"Symbol\", \"IsInRing\", \"GasteigerCharge\"], encoder={})[:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31817d9a",
   "metadata": {},
   "source": [
    "In order to have all features of a number data type an encoder can be added for each named feature:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7ba059df",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[4, 12.011, 1, 0, 0, 0, 0, False, 0.012958350519987684],\n",
       " [3, 14.007, 0, 0, 1, 0, 0, True, -0.3278634660994821],\n",
       " [3, 12.011, 1, 0, 0, 0, 0, True, 0.09750227330834146],\n",
       " [2, 14.007, 0, 0, 1, 0, 0, True, -0.21837692759548705]]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from kgcnn.molecule.encoder import OneHotEncoder\n",
    "mg.node_attributes([\"NumBonds\", \"Mass\", \"Symbol\", \"IsInRing\", \"GasteigerCharge\"], \n",
    "                   encoder={\"Symbol\": OneHotEncoder([\"C\", \"O\", \"N\", \"H\"], dtype=\"str\"), \"GasteigerCharge\": float})[:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbe8a9d4",
   "metadata": {},
   "source": [
    "If a feature is not in the list of named attributes, a function can be inserted in place. Note that the function should always return a single value or a list of values. Argument will be the bond, molecule or atom class of the backend, respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "9da6076c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[6], [7], [6], [7]]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def mol_feature(atom):\n",
    "    # Note that you can also get the mol object with e.g.\n",
    "    # mol = atom.GetOwningMol()\n",
    "    return atom.GetAtomicNum()\n",
    "\n",
    "mg.node_attributes([mol_feature], encoder={})[:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3b67397",
   "metadata": {},
   "source": [
    "The dataset `MoleculeNetDataset` uses the `MolGraphInterface` in `map_molecule_callbacks` , which specifies the used interface within `mol_interface_class` ."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27369250-f8a0-4f7e-9604-3affae60fe9e",
   "metadata": {},
   "source": [
    "### Training example\n",
    "\n",
    "Example with ESOLDataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "be422b65-c94d-41d5-ac04-0c063651b05f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:kgcnn.data.download:Checking and possibly downloading dataset with name ESOL\n",
      "INFO:kgcnn.data.download:Dataset directory located at C:\\Users\\patri\\.kgcnn\\datasets\n",
      "INFO:kgcnn.data.download:Dataset directory found. Done.\n",
      "INFO:kgcnn.data.download:Dataset found. Done.\n",
      "INFO:kgcnn.data.ESOL:Found SDF C:\\Users\\patri\\.kgcnn\\datasets\\ESOL\\delaney-processed.sdf of pre-computed structures.\n",
      "INFO:kgcnn.data.ESOL:Read molecules from mol-file.\n",
      "INFO:kgcnn.data.ESOL: ... process molecules 0 from 1128\n",
      "INFO:kgcnn.molecule.encoder:OneHotEncoder Symbol found ['O', 'C', 'N', 'S', 'Cl', 'P', 'F', 'I', 'Br']\n",
      "INFO:kgcnn.molecule.encoder:OneHotEncoder Hybridization found [rdkit.Chem.rdchem.HybridizationType.SP3, rdkit.Chem.rdchem.HybridizationType.SP, rdkit.Chem.rdchem.HybridizationType.SP2]\n",
      "INFO:kgcnn.molecule.encoder:OneHotEncoder TotalDegree found [2, 4, 1, 3]\n",
      "INFO:kgcnn.molecule.encoder:OneHotEncoder TotalNumHs found [1, 2, 0, 3, 4]\n",
      "INFO:kgcnn.molecule.encoder:OneHotEncoder CIPCode found [None, 'S', 'R']\n",
      "INFO:kgcnn.molecule.encoder:OneHotEncoder ChiralityPossible found [None, '1']\n",
      "INFO:kgcnn.molecule.encoder:OneHotEncoder BondType found [rdkit.Chem.rdchem.BondType.SINGLE, rdkit.Chem.rdchem.BondType.TRIPLE, rdkit.Chem.rdchem.BondType.AROMATIC, rdkit.Chem.rdchem.BondType.DOUBLE]\n",
      "INFO:kgcnn.molecule.encoder:OneHotEncoder Stereo found [rdkit.Chem.rdchem.BondStereo.STEREONONE, rdkit.Chem.rdchem.BondStereo.STEREOE, rdkit.Chem.rdchem.BondStereo.STEREOZ]\n"
     ]
    }
   ],
   "source": [
    "%%capture\n",
    "from kgcnn.data.datasets.ESOLDataset import ESOLDataset\n",
    "data = ESOLDataset()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0eecd520-4839-4bf3-b654-4cd1abc6e7be",
   "metadata": {},
   "source": [
    "The above descriptors can be passed to Molecule datasets via the `read_in_memory` or `set_attributes method`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "a1a578fc-4af3-4f0b-b1a5-d6746f44a5a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:kgcnn.data.ESOL:Read molecules from mol-file.\n",
      "INFO:kgcnn.data.ESOL: ... process molecules 0 from 1128\n",
      "INFO:kgcnn.molecule.encoder:OneHotEncoder Symbol found ['O', 'C', 'N', 'S', 'Cl', 'P', 'F', 'I', 'Br']\n",
      "INFO:kgcnn.molecule.encoder:OneHotEncoder Hybridization found [rdkit.Chem.rdchem.HybridizationType.SP3, rdkit.Chem.rdchem.HybridizationType.SP, rdkit.Chem.rdchem.HybridizationType.SP2]\n",
      "INFO:kgcnn.molecule.encoder:OneHotEncoder TotalDegree found [2, 4, 1, 3]\n",
      "INFO:kgcnn.molecule.encoder:OneHotEncoder TotalNumHs found [1, 2, 0, 3, 4]\n",
      "INFO:kgcnn.molecule.encoder:OneHotEncoder CIPCode found [None, 'S', 'R']\n",
      "INFO:kgcnn.molecule.encoder:OneHotEncoder ChiralityPossible found [None, '1']\n",
      "INFO:kgcnn.molecule.encoder:OneHotEncoder BondType found [rdkit.Chem.rdchem.BondType.SINGLE, rdkit.Chem.rdchem.BondType.TRIPLE, rdkit.Chem.rdchem.BondType.AROMATIC, rdkit.Chem.rdchem.BondType.DOUBLE]\n",
      "INFO:kgcnn.molecule.encoder:OneHotEncoder Stereo found [rdkit.Chem.rdchem.BondStereo.STEREONONE, rdkit.Chem.rdchem.BondStereo.STEREOE, rdkit.Chem.rdchem.BondStereo.STEREOZ]\n"
     ]
    }
   ],
   "source": [
    "%%capture\n",
    "from kgcnn.molecule.encoder import OneHotEncoder\n",
    "data.read_in_memory(\n",
    "    nodes = [\n",
    "        'Symbol', 'TotalDegree', 'FormalCharge', 'NumRadicalElectrons', 'Hybridization',\n",
    "        'IsAromatic', 'IsInRing', 'TotalNumHs', 'CIPCode', \"ChiralityPossible\", \"ChiralTag\"\n",
    "    ],\n",
    "    encoder_nodes = {\n",
    "        'Symbol': OneHotEncoder(\n",
    "            ['B', 'C', 'N', 'O', 'F', 'Si', 'P', 'S', 'Cl', 'As', 'Se', 'Br', 'Te', 'I', 'At'],\n",
    "            dtype=\"str\"\n",
    "        ),\n",
    "        'Hybridization': OneHotEncoder([2, 3, 4, 5, 6]),\n",
    "        'TotalDegree': OneHotEncoder([0, 1, 2, 3, 4, 5], add_unknown=False),\n",
    "        'TotalNumHs': OneHotEncoder([0, 1, 2, 3, 4], add_unknown=False),\n",
    "        'CIPCode': OneHotEncoder(['R', 'S'], add_unknown=False, dtype='str'),\n",
    "        \"ChiralityPossible\": OneHotEncoder([\"1\"], add_unknown=False, dtype='str'),\n",
    "    },\n",
    "    edges = ['BondType', 'IsAromatic', 'IsConjugated', 'IsInRing', 'Stereo'],\n",
    "    encoder_edges = {\n",
    "        'BondType': OneHotEncoder([1, 2, 3, 12], add_unknown=False),\n",
    "        'Stereo': OneHotEncoder([0, 1, 2, 3], add_unknown=False)\n",
    "    },\n",
    "    graph=['ExactMolWt', 'NumAtoms'],\n",
    "    encoder_graph = {},\n",
    "    add_hydrogen=False,\n",
    "    make_directed=False,\n",
    "    has_conformers=True,\n",
    "    sanitize=True,\n",
    "    compute_partial_charges=None,\n",
    "    label_column_name=\"measured log solubility in mols per litre\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78e5b78b-07a1-44ac-91d4-002471301421",
   "metadata": {},
   "source": [
    "Additional attributes and tensor properties can be generated with graph preprocessors. \n",
    "Note that there is also a graph preprocessor in `kgcnn.molecule.preprocessor` apart from `MoleculeNetDataset` ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "f843c838-6735-46c2-a392-eb26713370ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "from kgcnn.graph.preprocessor import SetRange, SetEdgeIndicesReverse\n",
    "data.map_list(SetRange(max_distance=5.0, in_place=True));\n",
    "data.map_list(SetEdgeIndicesReverse(in_place=True));\n",
    "data.map_list(method=\"count_nodes_and_edges\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "74c78957-4227-4011-a254-640f2ec54f65",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['node_symbol', 'node_number', 'edge_indices', 'edge_number', 'graph_size', 'node_coordinates', 'graph_labels', 'node_attributes', 'edge_attributes', 'graph_attributes', 'range_indices', 'range_attributes', 'edge_indices_reverse', 'total_nodes', 'total_edges'])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[0].keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "7c179749-ae23-45d5-b217-b0f96f04efe9",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:kgcnn.data.ESOL:Property 'edge_indices' is an empty list for graph '934'.\n",
      "WARNING:kgcnn.data.ESOL:Found invalid graphs for properties. Removing graphs '[934]'.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([934])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.clean(\"edge_indices\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89219e52-86c4-459b-a874-22d5af72d893",
   "metadata": {},
   "source": [
    "Prepare graph labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "4162fe35-e6c2-4e11-8ac5-b6507000701a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "labels = np.array(data.obtain_property(\"graph_labels\"))\n",
    "if len(labels.shape) <= 1:\n",
    "    labels = np.expand_dims(labels, axis=-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "783e45c7-2f22-44db-92cb-54766703e387",
   "metadata": {},
   "source": [
    "Train test indices with e.g. KFold."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "829e743a-73d2-4a7a-9a7f-deed5518f980",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import KFold\n",
    "kf = KFold(n_splits=5, random_state=42, shuffle=True)\n",
    "train_test_indices = [\n",
    "    [train_index, test_index] for train_index, test_index in kf.split(X=np.zeros((len(data), 1)), y=labels)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "3281d779-fda9-46e4-82cf-2fc96b7b2251",
   "metadata": {},
   "outputs": [],
   "source": [
    "model_config= {\n",
    "    \"class_name\": \"make_model\",\n",
    "    \"module_name\": \"kgcnn.literature.GIN\",\n",
    "    \"config\": {\n",
    "        \"name\": \"GIN\",\n",
    "        \"inputs\": [\n",
    "            {\"shape\": [None, 41], \"name\": \"node_attributes\", \"dtype\": \"float32\"},\n",
    "            {\"shape\": [None, 2], \"name\": \"edge_indices\", \"dtype\": \"int64\"},\n",
    "            {\"shape\": (), \"name\": \"total_nodes\", \"dtype\": \"int64\"},\n",
    "            {\"shape\": (), \"name\": \"total_edges\", \"dtype\": \"int64\"}\n",
    "        ],\n",
    "        \"verbose\": 50,\n",
    "        \"cast_disjoint_kwargs\": {\"padded_disjoint\": False},\n",
    "        \"input_node_embedding\": {\"input_dim\": 96, \"output_dim\": 64},\n",
    "        \"depth\": 5,\n",
    "        \"dropout\": 0.05,\n",
    "        \"gin_mlp\": {\"units\": [64, 64], \"use_bias\": True, \"activation\": [\"relu\", \"linear\"],\n",
    "                    \"use_normalization\": True, \"normalization_technique\": \"graph_batch\",\n",
    "                    \"padded_disjoint\": False},\n",
    "        \"gin_args\": {},\n",
    "        \"last_mlp\": {\"use_bias\": True, \"units\": [64, 32, 1], \"activation\": [\"relu\", \"relu\", \"linear\"]},\n",
    "        \"output_embedding\": \"graph\",\n",
    "        \"output_mlp\": {\"activation\": \"linear\", \"units\": 1}\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "c8945ebf-5eb4-48e5-97c5-db7157f19f96",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "import time\n",
    "from kgcnn.models.utils import get_model_class\n",
    "from keras.optimizers import Adam\n",
    "from kgcnn.training.scheduler import LinearLearningRateScheduler\n",
    "from kgcnn.literature.GIN import make_model\n",
    "from kgcnn.data.transform.scaler.molecule import QMGraphLabelScaler\n",
    "from kgcnn.data.transform.scaler.standard import StandardLabelScaler\n",
    "from kgcnn.metrics.metrics import ScaledMeanAbsoluteError, ScaledRootMeanSquaredError\n",
    "from datetime import timedelta\n",
    "\n",
    "history_list, test_indices_list = [], []\n",
    "model, hist, x_test, y_test, scaler, atoms_test = None, None, None, None, None, None\n",
    "splits_done = 0\n",
    "for i, (train_index, test_index) in enumerate(train_test_indices):\n",
    "    print(\"Running training on fold: %s\" % i)\n",
    "\n",
    "    # Make the model for current split using model kwargs from hyperparameter.\n",
    "    # They are always updated on top of the models default kwargs.\n",
    "    model = make_model(**model_config[\"config\"])\n",
    "\n",
    "    # First select training and test graphs from indices, then convert them into tensorflow tensor\n",
    "    # representation. Which property of the dataset and whether the tensor will be ragged is retrieved from the\n",
    "    # kwargs of the keras `Input` layers ('name' and 'ragged').\n",
    "    dataset_train, dataset_test = data[train_index], data[test_index]\n",
    "    x_train, y_train = dataset_train.tensor(model_config[\"config\"][\"inputs\"]), labels[train_index]\n",
    "    x_test, y_test = dataset_test.tensor(model_config[\"config\"][\"inputs\"]), labels[test_index]\n",
    "    \n",
    "    atoms_test = dataset_test.get(\"node_number\")\n",
    "    atoms_train = dataset_train.get(\"node_number\")\n",
    "    \n",
    "    scaler = StandardLabelScaler(with_std=True,with_mean=True, copy=True)\n",
    "    scaler.fit(y_train, atomic_number=atoms_train)\n",
    "    y_train = scaler.transform(y_train, atomic_number=atoms_train)\n",
    "    y_test = scaler.transform(y_test, atomic_number=atoms_test)\n",
    "\n",
    "    # If scaler was used we add rescaled standard metrics to compile.\n",
    "    scaler_scale = scaler.get_scaling()\n",
    "    mae_metric = ScaledMeanAbsoluteError(scaler_scale.shape, name=\"scaled_mean_absolute_error\")\n",
    "    rms_metric = ScaledRootMeanSquaredError(scaler_scale.shape, name=\"scaled_root_mean_squared_error\")\n",
    "    if scaler.scale_ is not None:\n",
    "        mae_metric.set_scale(scaler_scale)\n",
    "        rms_metric.set_scale(scaler_scale)\n",
    "    metrics = [mae_metric, rms_metric]\n",
    "\n",
    "    # Compile model with optimizer and loss\n",
    "    model.compile(loss=\"mean_absolute_error\", metrics=metrics, optimizer=Adam(learning_rate=5e-04))\n",
    "\n",
    "    # Build model with reasonable data.\n",
    "    model.predict(x_test, batch_size=2, steps=2)\n",
    "    model._compile_metrics.build(y_test, y_test)\n",
    "    model._compile_loss.build(y_test, y_test)\n",
    "\n",
    "    # Model summary\n",
    "    model.summary()\n",
    "    print(\" Compiled with jit: %s\" % model._jit_compile)  # noqa\n",
    "    print(\" Model is built: %s, with unbuilt: %s\" % (\n",
    "        all([layer.built for layer in model._flatten_layers()]),  # noqa\n",
    "        [layer.name for layer in model._flatten_layers() if not layer.built]\n",
    "    ))\n",
    "\n",
    "    # Start and time training\n",
    "    start = time.process_time()\n",
    "    hist = model.fit(x_train, y_train,\n",
    "                     validation_data=(x_test, y_test),\n",
    "                     batch_size=32, \n",
    "                     epochs=300, \n",
    "                     validation_freq=10, \n",
    "                     # Change to verbose = 2 to see progress\n",
    "                     verbose=0,\n",
    "                     callbacks= [\n",
    "                         LinearLearningRateScheduler(\n",
    "                             learning_rate_start=0.001, learning_rate_stop=1e-05, epo_min=100, epo=300)\n",
    "                     ])\n",
    "    stop = time.process_time()\n",
    "    print(\"Print Time for training: \", str(timedelta(seconds=stop - start)))\n",
    "\n",
    "    # Get loss from history\n",
    "    history_list.append(hist)\n",
    "    test_indices_list.append([train_index, test_index])\n",
    "    splits_done = splits_done + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1d196735-bacf-44bf-8f64-3aaabc95ff56",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from kgcnn.utils.plots import plot_train_test_loss, plot_predict_true\n",
    "\n",
    "plot_train_test_loss(history_list, loss_name=None, val_loss_name=None,\n",
    "                     model_name=\"GIN\", data_unit=\"mol/L\", dataset_name=\"esol\",\n",
    "                     filepath=\"\", file_name=f\"loss.png\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "d07fdaf1-7e82-4ae3-a039-90b4972b9664",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m8/8\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 27ms/step\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot prediction for the last split.\n",
    "predicted_y = model.predict(x_test)\n",
    "true_y = y_test\n",
    "\n",
    "# Predictions must be rescaled to original values.\n",
    "predicted_y = scaler.inverse_transform(predicted_y)\n",
    "true_y = scaler.inverse_transform(true_y)\n",
    "\n",
    "# Plotting the prediction vs. true test targets for last split. Note for classification this is also done but\n",
    "# can be ignored.\n",
    "plot_predict_true(predicted_y, true_y,\n",
    "                  filepath=\"\", data_unit=\"mol/L\",\n",
    "                  model_name=\"GIN\", dataset_name=\"ESOL\",\n",
    "                  file_name=f\"predict.png\");"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c90f4ffd",
   "metadata": {},
   "source": [
    "> **NOTE**: You can find this page as jupyter notebook in https://github.com/aimat-lab/gcnn_keras/tree/master/docs/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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}