examples/notebooks/featurization.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "\n",
    "Extracting features from molecules is a common task in machine learning. There are 4 different types of features: 0D, 1D, 2D, 3D, or 4D.\n",
    "\n",
    "- 0D features are descriptors that describe the individual parts of the molecule together as a whole, such as the number of atoms, bond counts or the molecular weight.\n",
    "- 1D features are descriptors that describe substructures in the molecule (e.g. molecular fingerprints).\n",
    "- 2D features are descriptors that describe the molecular topology based on the graph representation of the molecules, e.g. the number of rings or the number of rotatable bonds.\n",
    "- 3D features are descriptors geometrical descriptors that describe the molecule as a 3D structure.\n",
    "- 4D features are descriptors that describe the molecule as a 4D structure. A new dimension is added to characterize the interactions between the molecule and the active site of a receptor or the multiple conformational states of the molecule, e.g. the molecular dynamics of the molecule.\n",
    "\n",
    "\n",
    "![features_image.png](features_image.png)\n",
    "\n",
    "Source : Molecular Descriptors for Structure–Activity Applications: A Hands-On Approach.\n",
    "\n",
    "As we increase the level of information about a molecule (from 0D to 4D), we also increase the computational cost of calculating the features. For example, calculating 3D features requires the generation of 3D conformers, which can be computationally expensive for large molecules. In addition, some features may not be available for certain molecules, e.g. 3D features cannot be calculated for molecules that do not have a 3D structure. Fortunately, DeepMol provides methods for generating compound 3D structures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generating features using DeepMol\n",
    "\n",
    "DeepMol provides a number of featurization methods for generating features from molecules. These features can be used for a variety of tasks, such as virtual screening, drug design, and toxicity prediction. The featurization methods are implemented as classes in the deepmol.compound_featurization module. Each class has a featurize method that takes a dataset as input and returns a featurized dataset. The featurize method can be called directly on a dataset object or used in a pipeline with other featurization methods.\n",
    "\n",
    "The following featurization methods are currently available in DeepMol:\n",
    "   - MorganFingerprint\n",
    "    - AtomPairFingerprint\n",
    "    - LayeredFingerprint\n",
    "    - RDKFingerprint\n",
    "    - MACCSkeysFingerprint\n",
    "    - TwoDimensionDescriptors\n",
    "    - WeaveFeat\n",
    "    - CoulombFeat\n",
    "    - CoulombEigFeat\n",
    "    - ConvMolFeat\n",
    "    - MolGraphConvFeat\n",
    "    - SmileImageFeat\n",
    "    - SmilesSeqFeat\n",
    "    - MolGanFeat\n",
    "    - All3DDescriptors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Import packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-06T15:43:53.713337582Z",
     "start_time": "2023-06-06T15:43:51.392833123Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-11-09 15:38:40.747302: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2024-11-09 15:38:40.747392: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2024-11-09 15:38:40.749760: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2024-11-09 15:38:40.762854: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX512F FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2024-11-09 15:38:42.377128: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/jcapela/miniforge3/envs/deepmol/lib/python3.10/site-packages/tensorflow/python/util/deprecation.py:588: calling function (from tensorflow.python.eager.polymorphic_function.polymorphic_function) with experimental_relax_shapes is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "experimental_relax_shapes is deprecated, use reduce_retracing instead\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Skipped loading modules with pytorch-lightning dependency, missing a dependency. No module named 'pytorch_lightning'\n",
      "Skipped loading some Jax models, missing a dependency. No module named 'jax'\n",
      "Failed to find the pandas get_adjustment() function to patch\n",
      "Failed to patch pandas - PandasTools will have limited functionality\n"
     ]
    }
   ],
   "source": [
    "from deepmol.loaders import CSVLoader, SDFLoader\n",
    "from deepmol.compound_featurization import MorganFingerprint, TwoDimensionDescriptors, MACCSkeysFingerprint, \\\n",
    "    AtomPairFingerprint, LayeredFingerprint, RDKFingerprint\n",
    "\n",
    "from deepmol.compound_featurization import WeaveFeat, CoulombFeat, CoulombEigFeat, ConvMolFeat, MolGraphConvFeat, \\\n",
    "        SmileImageFeat, SmilesSeqFeat, MolGanFeat, All3DDescriptors, generate_conformers_to_sdf_file\n",
    "\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-06T15:43:55.578005190Z",
     "start_time": "2023-06-06T15:43:53.714286775Z"
    }
   },
   "outputs": [],
   "source": [
    "dataset = CSVLoader(\"../data/CHEMBL217_reduced.csv\", id_field=\"Original_Entry_ID\",\n",
    "                    smiles_field=\"SMILES\", labels_fields=[\"Activity_Flag\"]).create_dataset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Featurize the dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1D features: fingerprints and structural keys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![fingerprints.png](fingerprints.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are special codes called \"structural keys\" that have been created for various purposes in the field of chemistry.\n",
    "\n",
    "They help with tasks like finding similar molecules or exploring different chemical structures. One specific type of structural keys is called the Molecular ACCess System (MACCS) keys.\n",
    "\n",
    "These keys use binary digits (bits) to show whether certain parts of a molecule are present or not. For example, if a specific structural fragment exists in a molecule, the corresponding bit will be set to 1, and if it's not present, the bit will be set to 0. There are different versions of MACCS keys, but the most common ones are either 166 or 960 bits long. These keys provide a simplified representation of molecules, which is useful for various chemical analyses and comparisons. [1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hashed fingerprints are a type of chemical fingerprint that use a special function to convert patterns in molecules into a series of bits. The length of the fingerprint can be predetermined.\n",
    "\n",
    "There are different types of fingerprints used in chemistry. Topological or path-based fingerprints, like Daylight fingerprints, provide information about how atoms are connected in a molecule. Circular fingerprints, such as ECFP, give information about the neighborhoods of atoms. These fingerprints are useful for quickly comparing similarities between molecules, studying the relationship between chemical structures and activities, and creating maps of chemical space.\n",
    "\n",
    "Most fingerprints have been designed for small molecules and may not work well with larger ones. For example, ECFP4 is effective for virtual screening [2] and target prediction [3] with small molecules but may not accurately represent the overall features or structural differences of larger molecules [4].\n",
    "\n",
    "On the other hand, atom-pair fingerprints, which describe molecular shape, are better suited for larger molecules [4]. However, they don't provide detailed structural information and may perform poorly in benchmarking studies with small molecules compared to substructure fingerprints like ECFP4 [4].\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[1] L. David et al. “Molecular representations in AI-driven drug discovery: a review and practical guide”. In: Journal of Cheminformatics 12 (1 2020-12), p. 56\n",
    "\n",
    "[2] S. Riniker and G. A. Landrum. “Open-source platform to benchmark fingerprints for ligand-based virtual screening”. In: Journal of cheminformatics 5.1 (2013), pp. 1–17\n",
    "\n",
    "[3] M. Awale and J.-L. Reymond. “Polypharmacology browser PPB2: target prediction combining nearest neighbors with machine learning”. In: Journal of chemical information and modeling 59.1 (2018), pp. 10–17\n",
    "\n",
    "[4] A. Capecchi, D. Probst, and J.-L. Reymond. “One molecular fingerprint to rule them all: drugs, biomolecules, and the metabolome”. In: Journal of cheminformatics 12.1 (2020), pp. 1–15\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate fingerprints and fragment keys with DeepMol"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Morgan Fingerprint"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Morgan fingerprints, also known as circular fingerprints or Morgan/Circular fingerprints, are a type of molecular fingerprint that encodes the structural information of a molecule as a series of binary bitstrings.\n",
    "\n",
    "These fingerprints are generated using the Morgan algorithm, which iteratively applies a circular pattern to a molecule, generating a series of concentric circles around each atom. The resulting bitstring is a binary representation of the presence or absence of certain substructures within a certain radius of each atom.\n",
    "\n",
    "Morgan fingerprints are widely used in cheminformatics and computational chemistry for tasks such as molecular similarity analysis, virtual screening, and quantitative structure-activity relationship (QSAR) modeling. They are also computationally efficient and can be generated quickly for large sets of molecules, making them useful for high-throughput screening applications."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-26T09:42:00.921585227Z",
     "start_time": "2023-05-26T09:41:56.428212686Z"
    }
   },
   "outputs": [],
   "source": [
    "MorganFingerprint(n_jobs=10).featurize(dataset, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-26T09:42:09.598548202Z",
     "start_time": "2023-05-26T09:42:09.593641093Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(16645, 2048)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-26T09:45:48.186436353Z",
     "start_time": "2023-05-26T09:45:48.177846334Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 0., ..., 0., 0., 0.], dtype=float32)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.X[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0., 1.], dtype=float32), array([2006,   42]))"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unique(dataset.X[0], return_counts=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Atom Pair Fingerprint"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Atom pair fingerprint is a type of molecular fingerprinting method used in cheminformatics and computational chemistry. It encodes the presence or absence of pairs of atoms in a molecule, as well as the distance between them.\n",
    "\n",
    "The method involves dividing a molecule into atom pairs and then counting the frequency of each pair in the molecule. The result is a binary bitstring that represents the presence or absence of each atom pair in the molecule. The bitstring is usually truncated to a fixed length to facilitate comparison and analysis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-26T09:43:15.990080592Z",
     "start_time": "2023-05-26T09:43:11.481448026Z"
    }
   },
   "outputs": [],
   "source": [
    "AtomPairFingerprint(n_jobs=10).featurize(dataset, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-26T09:43:21.342106926Z",
     "start_time": "2023-05-26T09:43:21.337592541Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(16645, 2048)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., ..., 0., 0., 0.], dtype=float32)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.X[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0., 1.], dtype=float32), array([1841,  207]))"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unique(dataset.X[0], return_counts=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Layered Fingerprint"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Layered fingerprints, also known as topological fingerprints, are a type of molecular fingerprinting method used in cheminformatics and computational chemistry. They encode the presence or absence of certain substructures or functional groups in a molecule, which are represented as binary bitstrings.\n",
    "\n",
    "The method involves dividing a molecule into a series of layers, where each layer contains a different set of substructures or functional groups. The bitstring for each layer is generated by hashing the presence or absence of the substructures or functional groups in the layer. The final fingerprint is generated by concatenating the bitstrings for all layers, resulting in a binary bitstring that represents the presence or absence of all substructures or functional groups in the molecule."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "LayeredFingerprint(n_jobs=10).featurize(dataset, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(16645, 2048)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., ..., 0., 0., 0.], dtype=float32)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.X[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0., 1.], dtype=float32), array([1485,  563]))"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unique(dataset.X[0], return_counts=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## RDK Fingerprint"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fingerprints from rdkit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "RDKFingerprint(n_jobs=10).featurize(dataset, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(16645, 2048)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 0., 1., ..., 0., 1., 1.], dtype=float32)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.X[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0., 1.], dtype=float32), array([1255,  793]))"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unique(dataset.X[0], return_counts=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MACCS Keys Fingerprint"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "MACCS (Molecular ACCess System) keys are a type of binary molecular fingerprint used in cheminformatics and computational chemistry. They were developed by Molecular Design Limited (now part of Elsevier) and are widely used in the field.\n",
    "\n",
    "The MACCS keys encode the presence or absence of certain molecular fragments or substructures in a molecule as a binary bitstring. The fragments used are based on a predefined set of SMARTS patterns, which represent specific substructures or features of a molecule.\n",
    "\n",
    "The MACCS keys consist of 166 bit positions, with each bit representing the presence or absence of a specific fragment in the molecule. The bitstring can be used to compare the similarity of two molecules or to search a large database of molecules for compounds with similar structures or properties."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "MACCSkeysFingerprint(n_jobs=10).featurize(dataset, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(16645, 167)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 1., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1., 0., 0., 1., 0.,\n",
       "       1., 0., 1., 0., 0., 0., 0., 1., 1., 0., 0., 1., 1., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 1., 0., 0., 1., 0., 0., 1., 0., 0., 0., 1., 0.,\n",
       "       0., 0., 1., 1., 0., 0., 1., 1., 1., 0., 0., 0., 1., 0., 1., 1., 1.,\n",
       "       0., 1., 0., 1., 0., 0., 1., 1., 1., 1., 1., 0., 1., 0., 1., 1., 1.,\n",
       "       0., 0., 0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0.],\n",
       "      dtype=float32)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.X[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0., 1.], dtype=float32), array([120,  47]))"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unique(dataset.X[0], return_counts=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 0D and 2D Descriptors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We provide all 0D, 2D descriptors and some 1D descriptors from rdkit in only one function. These include: \n",
    "- **EState index descriptors**: The EState indices are calculated based on a set of predefined atomic parameters, such as electronegativity, atomic polarizability, and resonance effects. These indices quantify the electronic characteristics of individual atoms in a molecule.\n",
    "    - **MaxAbsEStateIndex (MAEstate)**: Maximum absolute EState index - The MAEstate specifically represents the highest absolute EState index value among all the atoms in a molecule. It indicates the atom with the largest charge magnitude, reflecting its potential reactivity or contribution to chemical properties.\n",
    "    - **MaxEStateIndex:**: Maximum EState Index - The MaxEStateIndex specifically represents the highest EState index value among all the atoms in a molecule. It indicates the atom with the largest charge or electronic density, reflecting its potential reactivity or significance in the molecule's properties.\n",
    "    - **MinAbsEStateIndex**: Minimum absolute EState index - The MinAbsEStateIndex specifically represents the lowest absolute EState index value among all the atoms in a molecule.\n",
    "    - **MinEStateIndex**: Minimum EState index - The MinEStateIndex represents the lowest EState index value among all the atoms in a molecule.\n",
    "- **QED**: quantitative estimation of drug-likeness - ADS (Atom-based Descriptors) are a set of descriptors used in chemoinformatics and computational chemistry to characterize the properties of individual atoms within a molecule. These descriptors provide valuable information about the local atomic environment and contribute to understanding the molecular properties and behavior. ADS descriptors are typically calculated based on quantum chemical calculations.\n",
    "- **Molecular weight descriptors**:\n",
    "    - **MolWt**: Molecular weight. \n",
    "    - **HeavyAtomMolWt**: The average molecular weight of the molecule ignoring hydrogens.\n",
    "    - **ExactMolWt**: The exact molecular weight of the molecule.\n",
    "- **Electron descriptors**:\n",
    "    - **NumValenceElectrons**: The number of valence electrons the molecule has.\n",
    "    - **NumRadicalElectrons**: The number of radical electrons the molecule has.\n",
    "- **Charge descriptors**:\n",
    "    - **MaxPartialCharge**: Maximum partial charge;\n",
    "    - **MinPartialCharge**: Minimum partial charge;\n",
    "    - **MaxAbsPartialCharge**: Maximum absolute partial charge;\n",
    "    - **MinAbsPartialCharge**: Minimum absolute partial charge;\n",
    "    \n",
    "- **Morgan fingerprint density** - quantify the frequency of occurrence of specific substructures within the molecule at a local level, taking into account their immediate surroundings. Higher values of density indicate a higher density of unique substructures in the molecule, while lower values indicate fewer unique substructures or a more uniform distribution of substructures.\n",
    "    - **FpDensityMorgan1**: Fingerprint Density for Morgan Radius 1.\n",
    "    - **FpDensityMorgan2**: Fingerprint Density for Morgan Radius 2.\n",
    "    - **FpDensityMorgan3**: Fingerprint Density for Morgan Radius 3.\n",
    "- **BCUT2D descriptors**: BCUT2D descriptors are a set of descriptors that capture the electronic properties of a molecule based on the distribution of atom-centered fragments  \n",
    "    - **BCUT2D_MWHI**: BCUT2D descriptor related to molecular weight (high range). It captures information about the electronic properties of the molecule based on the distribution of atom-centered fragments.\n",
    "\n",
    "    - **BCUT2D_MWLOW**: BCUT2D descriptor related to molecular weight (low range). It provides information about the electronic properties of the molecule based on the distribution of atom-centered fragments.\n",
    "\n",
    "    - **BCUT2D_CHGHI**: BCUT2D descriptor related to atom charge (high range). It describes the electronic properties of the molecule based on the distribution of atom-centered fragments and their charges.\n",
    "\n",
    "    - **BCUT2D_CHGLO**: BCUT2D descriptor related to atom charge (low range). It provides information about the electronic properties of the molecule based on the distribution of atom-centered fragments and their charges.\n",
    "\n",
    "- **AvgIpc**: Average Burden Eigenvalue. It is a descriptor that measures the topological complexity of the molecule by considering the eigenvalues of the Burden matrix, which encodes the connectivity information of the molecule.\n",
    "\n",
    "- **BalabanJ**: Balaban's J index. It quantifies the molecular topological structure by considering the connectivity of atoms and bonds in the molecule.\n",
    "\n",
    "- **BertzCT**: Bertz complexity index. It measures the complexity or branching of a molecule based on its structural connectivity.\n",
    "\n",
    "- **Chi0, Chi1, Chi2n, Chi3v, etc.**: Chi indices are topological descriptors that characterize the molecular shape and size. Each Chi index captures a different aspect of the connectivity and branching patterns in the molecule.\n",
    "\n",
    "- **HallKierAlpha**: Hall-Kier alpha shape index. It describes the shape of a molecule based on the distribution of bond lengths and angles.\n",
    "\n",
    "- **MolLogP**: Molar logarithm of the partition coefficient (logP). It quantifies the lipophilicity or hydrophobicity of a molecule, which is important for its distribution and permeability properties.\n",
    "\n",
    "- **TPSA**: Topological polar surface area. It estimates the surface area of a molecule that is involved in polar interactions, which is relevant for its solubility and biological activity.\n",
    "\n",
    "- **NumHAcceptors, NumHDonors, NumHeteroatoms, etc.**: These descriptors count the number of hydrogen bond acceptor groups, hydrogen bond donor groups, heteroatoms (non-carbon atoms), etc., present in the molecule. They provide information about the potential for specific molecular interactions.\n",
    "\n",
    "- **RingCount**: Number of rings in the molecule. It indicates the level of molecular complexity and rigidity.\n",
    "\n",
    "- **fr_Al_COO, fr_ArN, fr_COO, fr_Ph_OH, etc**.: These descriptors represent the count of specific functional groups or substructures in the molecule. They provide information about the presence of particular chemical moieties."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "TwoDimensionDescriptors(n_jobs=10).featurize(dataset, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['MaxAbsEStateIndex', 'MaxEStateIndex', 'MinAbsEStateIndex',\n",
       "       'MinEStateIndex', 'qed', 'MolWt', 'HeavyAtomMolWt', 'ExactMolWt',\n",
       "       'NumValenceElectrons', 'NumRadicalElectrons', 'MaxPartialCharge',\n",
       "       'MinPartialCharge', 'MaxAbsPartialCharge', 'MinAbsPartialCharge',\n",
       "       'FpDensityMorgan1', 'FpDensityMorgan2', 'FpDensityMorgan3',\n",
       "       'BCUT2D_MWHI', 'BCUT2D_MWLOW', 'BCUT2D_CHGHI', 'BCUT2D_CHGLO',\n",
       "       'BCUT2D_LOGPHI', 'BCUT2D_LOGPLOW', 'BCUT2D_MRHI', 'BCUT2D_MRLOW',\n",
       "       'AvgIpc', 'BalabanJ', 'BertzCT', 'Chi0', 'Chi0n', 'Chi0v', 'Chi1',\n",
       "       'Chi1n', 'Chi1v', 'Chi2n', 'Chi2v', 'Chi3n', 'Chi3v', 'Chi4n',\n",
       "       'Chi4v', 'HallKierAlpha', 'Ipc', 'Kappa1', 'Kappa2', 'Kappa3',\n",
       "       'LabuteASA', 'PEOE_VSA1', 'PEOE_VSA10', 'PEOE_VSA11', 'PEOE_VSA12',\n",
       "       'PEOE_VSA13', 'PEOE_VSA14', 'PEOE_VSA2', 'PEOE_VSA3', 'PEOE_VSA4',\n",
       "       'PEOE_VSA5', 'PEOE_VSA6', 'PEOE_VSA7', 'PEOE_VSA8', 'PEOE_VSA9',\n",
       "       'SMR_VSA1', 'SMR_VSA10', 'SMR_VSA2', 'SMR_VSA3', 'SMR_VSA4',\n",
       "       'SMR_VSA5', 'SMR_VSA6', 'SMR_VSA7', 'SMR_VSA8', 'SMR_VSA9',\n",
       "       'SlogP_VSA1', 'SlogP_VSA10', 'SlogP_VSA11', 'SlogP_VSA12',\n",
       "       'SlogP_VSA2', 'SlogP_VSA3', 'SlogP_VSA4', 'SlogP_VSA5',\n",
       "       'SlogP_VSA6', 'SlogP_VSA7', 'SlogP_VSA8', 'SlogP_VSA9', 'TPSA',\n",
       "       'EState_VSA1', 'EState_VSA10', 'EState_VSA11', 'EState_VSA2',\n",
       "       'EState_VSA3', 'EState_VSA4', 'EState_VSA5', 'EState_VSA6',\n",
       "       'EState_VSA7', 'EState_VSA8', 'EState_VSA9', 'VSA_EState1',\n",
       "       'VSA_EState10', 'VSA_EState2', 'VSA_EState3', 'VSA_EState4',\n",
       "       'VSA_EState5', 'VSA_EState6', 'VSA_EState7', 'VSA_EState8',\n",
       "       'VSA_EState9', 'FractionCSP3', 'HeavyAtomCount', 'NHOHCount',\n",
       "       'NOCount', 'NumAliphaticCarbocycles', 'NumAliphaticHeterocycles',\n",
       "       'NumAliphaticRings', 'NumAromaticCarbocycles',\n",
       "       'NumAromaticHeterocycles', 'NumAromaticRings', 'NumHAcceptors',\n",
       "       'NumHDonors', 'NumHeteroatoms', 'NumRotatableBonds',\n",
       "       'NumSaturatedCarbocycles', 'NumSaturatedHeterocycles',\n",
       "       'NumSaturatedRings', 'RingCount', 'MolLogP', 'MolMR', 'fr_Al_COO',\n",
       "       'fr_Al_OH', 'fr_Al_OH_noTert', 'fr_ArN', 'fr_Ar_COO', 'fr_Ar_N',\n",
       "       'fr_Ar_NH', 'fr_Ar_OH', 'fr_COO', 'fr_COO2', 'fr_C_O',\n",
       "       'fr_C_O_noCOO', 'fr_C_S', 'fr_HOCCN', 'fr_Imine', 'fr_NH0',\n",
       "       'fr_NH1', 'fr_NH2', 'fr_N_O', 'fr_Ndealkylation1',\n",
       "       'fr_Ndealkylation2', 'fr_Nhpyrrole', 'fr_SH', 'fr_aldehyde',\n",
       "       'fr_alkyl_carbamate', 'fr_alkyl_halide', 'fr_allylic_oxid',\n",
       "       'fr_amide', 'fr_amidine', 'fr_aniline', 'fr_aryl_methyl',\n",
       "       'fr_azide', 'fr_azo', 'fr_barbitur', 'fr_benzene',\n",
       "       'fr_benzodiazepine', 'fr_bicyclic', 'fr_diazo',\n",
       "       'fr_dihydropyridine', 'fr_epoxide', 'fr_ester', 'fr_ether',\n",
       "       'fr_furan', 'fr_guanido', 'fr_halogen', 'fr_hdrzine', 'fr_hdrzone',\n",
       "       'fr_imidazole', 'fr_imide', 'fr_isocyan', 'fr_isothiocyan',\n",
       "       'fr_ketone', 'fr_ketone_Topliss', 'fr_lactam', 'fr_lactone',\n",
       "       'fr_methoxy', 'fr_morpholine', 'fr_nitrile', 'fr_nitro',\n",
       "       'fr_nitro_arom', 'fr_nitro_arom_nonortho', 'fr_nitroso',\n",
       "       'fr_oxazole', 'fr_oxime', 'fr_para_hydroxylation', 'fr_phenol',\n",
       "       'fr_phenol_noOrthoHbond', 'fr_phos_acid', 'fr_phos_ester',\n",
       "       'fr_piperdine', 'fr_piperzine', 'fr_priamide', 'fr_prisulfonamd',\n",
       "       'fr_pyridine', 'fr_quatN', 'fr_sulfide', 'fr_sulfonamd',\n",
       "       'fr_sulfone', 'fr_term_acetylene', 'fr_tetrazole', 'fr_thiazole',\n",
       "       'fr_thiocyan', 'fr_thiophene', 'fr_unbrch_alkane', 'fr_urea'],\n",
       "      dtype='<U24')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.feature_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.2915942e+01,  1.2915942e+01,  1.5547052e-02, -1.0479454e+00,\n",
       "        6.2784576e-01,  3.2834299e+02,  3.1120700e+02,  3.2812231e+02,\n",
       "        1.2400000e+02,  0.0000000e+00,  1.9552433e-01, -4.9668738e-01,\n",
       "        4.9668738e-01,  1.9552433e-01,  1.1250000e+00,  1.8750000e+00,\n",
       "        2.5833333e+00,  1.9142143e+01,  1.0232034e+01,  2.1378713e+00,\n",
       "       -2.1238039e+00,  2.2726576e+00, -2.0836904e+00,  5.4712963e+00,\n",
       "        2.0794968e-01,  2.9879730e+00,  1.8310844e+00,  8.3053522e+02,\n",
       "        1.7104084e+01,  1.2978706e+01,  1.2978706e+01,  1.1562881e+01,\n",
       "        7.3246827e+00,  7.3246827e+00,  5.2568851e+00,  5.2568851e+00,\n",
       "        3.6155939e+00,  3.6155939e+00,  2.3750753e+00,  2.3750753e+00,\n",
       "       -2.9900000e+00,  3.7483522e+05,  1.5888650e+01,  6.6362123e+00,\n",
       "        3.3332713e+00,  1.3811201e+02,  2.0266706e+01,  1.1566732e+01,\n",
       "        1.2107889e+01,  0.0000000e+00,  0.0000000e+00,  0.0000000e+00,\n",
       "        4.5670996e+00,  4.3904152e+00,  0.0000000e+00,  0.0000000e+00,\n",
       "        6.0663671e+00,  3.6398201e+01,  2.9580416e+01,  1.2797184e+01,\n",
       "        1.9340332e+01,  5.6873865e+00,  0.0000000e+00,  4.5670996e+00,\n",
       "        0.0000000e+00,  6.2279010e+00,  1.2426586e+01,  7.2174820e+01,\n",
       "        0.0000000e+00,  1.7316887e+01,  1.0053652e+01,  1.0077802e+01,\n",
       "        1.1629500e+01,  0.0000000e+00,  2.1889952e+01,  0.0000000e+00,\n",
       "        5.8172207e+00,  1.1791352e+01,  6.0794147e+01,  0.0000000e+00,\n",
       "        5.6873865e+00,  0.0000000e+00,  6.6650002e+01,  6.2279010e+00,\n",
       "        1.4603470e+01,  0.0000000e+00,  1.1697209e+01,  2.2687737e+01,\n",
       "        0.0000000e+00,  3.4898933e+01,  3.1505743e+01,  6.0663671e+00,\n",
       "        5.3167887e+00,  4.7368631e+00,  1.9622860e+01,  0.0000000e+00,\n",
       "        0.0000000e+00,  2.3247818e+01,  1.7400438e+00,  2.9371008e-01,\n",
       "        1.4294580e+01,  5.6842041e-01,  0.0000000e+00,  1.5659007e+00,\n",
       "        1.1111111e-01,  2.4000000e+01,  3.0000000e+00,  5.0000000e+00,\n",
       "        0.0000000e+00,  0.0000000e+00,  0.0000000e+00,  2.0000000e+00,\n",
       "        1.0000000e+00,  3.0000000e+00,  5.0000000e+00,  3.0000000e+00,\n",
       "        6.0000000e+00,  5.0000000e+00,  0.0000000e+00,  0.0000000e+00,\n",
       "        0.0000000e+00,  3.0000000e+00,  3.4335999e+00,  8.8968300e+01,\n",
       "        0.0000000e+00,  1.0000000e+00,  1.0000000e+00,  0.0000000e+00,\n",
       "        0.0000000e+00,  1.0000000e+00,  0.0000000e+00,  1.0000000e+00,\n",
       "        0.0000000e+00,  0.0000000e+00,  0.0000000e+00,  0.0000000e+00,\n",
       "        0.0000000e+00,  0.0000000e+00,  0.0000000e+00,  1.0000000e+00,\n",
       "        1.0000000e+00,  0.0000000e+00,  0.0000000e+00,  0.0000000e+00,\n",
       "        0.0000000e+00,  0.0000000e+00,  0.0000000e+00,  0.0000000e+00,\n",
       "        0.0000000e+00,  0.0000000e+00,  0.0000000e+00,  0.0000000e+00,\n",
       "        0.0000000e+00,  1.0000000e+00,  0.0000000e+00,  0.0000000e+00,\n",
       "        0.0000000e+00,  0.0000000e+00,  2.0000000e+00,  0.0000000e+00,\n",
       "        0.0000000e+00,  0.0000000e+00,  0.0000000e+00,  0.0000000e+00,\n",
       "        0.0000000e+00,  1.0000000e+00,  0.0000000e+00,  0.0000000e+00,\n",
       "        1.0000000e+00,  0.0000000e+00,  0.0000000e+00,  0.0000000e+00,\n",
       "        0.0000000e+00,  0.0000000e+00,  0.0000000e+00,  0.0000000e+00,\n",
       "        0.0000000e+00,  0.0000000e+00,  0.0000000e+00,  1.0000000e+00,\n",
       "        0.0000000e+00,  0.0000000e+00,  0.0000000e+00,  0.0000000e+00,\n",
       "        0.0000000e+00,  0.0000000e+00,  0.0000000e+00,  0.0000000e+00,\n",
       "        0.0000000e+00,  0.0000000e+00,  0.0000000e+00,  0.0000000e+00,\n",
       "        0.0000000e+00,  0.0000000e+00,  0.0000000e+00,  0.0000000e+00,\n",
       "        0.0000000e+00,  0.0000000e+00,  0.0000000e+00,  0.0000000e+00,\n",
       "        0.0000000e+00,  0.0000000e+00,  0.0000000e+00,  0.0000000e+00,\n",
       "        0.0000000e+00,  0.0000000e+00,  0.0000000e+00,  0.0000000e+00,\n",
       "        0.0000000e+00], dtype=float32)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.X[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3D descriptors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generating Conformers and exporting to a SDF file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3D structures can be generated with DeepMol and being exported to a file.\n",
    "\n",
    "We start by generating conformers with **ETKDG** (Efficient Conformer Generation) algorithm. The ETKDG method is a widely used algorithm for generating low-energy conformers of small organic molecules. It is an extension of the original **KDG** (Knowledge-Embedded Stochastic Conformer Generation) method and incorporates additional efficiency enhancements. \n",
    "\n",
    "The **ETKDG** method combines random sampling with knowledge-based rules and efficient energy evaluations to generate a diverse set of low-energy conformers for small organic molecules. It strikes a balance between computational efficiency and conformational coverage, making it a popular choice for various molecular modeling and drug discovery applications.\n",
    "\n",
    "After that **MMFF** (Merck Molecular Force Field) and **UFF** (Universal Force Field) algorithms. They commonly use force fields for optimizing conformers of small organic molecules. Both force fields calculate the potential energy of a molecule based on its geometry and provide a set of atomic forces that guide the conformational search towards more stable conformations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can generate conformers and export them to a SDF files as follow:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "dataset = CSVLoader(\"../data/CHEMBL217_reduced.csv\", id_field=\"Original_Entry_ID\",\n",
    "                    smiles_field=\"SMILES\", labels_fields=[\"Activity_Flag\"]).create_dataset()\n",
    "generate_conformers_to_sdf_file(dataset, \"CHEMBL217_conformers.sdf\", n_conformations=1, threads=15,max_iterations=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you rather want to read directly from a SDF file, you can use the SDFLoader class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "dataset = SDFLoader(\"../data/CHEMBL217_conformers.sdf\", id_field=\"_ID\", labels_fields=[\"_Class\"]).create_dataset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### In DeepMol, we only use RDKit 3D descriptors\n",
    "\n",
    "- **AutoCorr3D**: AutoCorr3D is a type of 3D descriptor that captures spatial autocorrelation patterns in a molecule. It quantifies the distribution and arrangement of properties within a three-dimensional grid overlaid on the molecule's structure.\n",
    "- **RadialDistributionFunction**: The Radial Distribution Function (RDF), also known as the pair correlation function, is a 3D descriptor that characterizes the distribution of particles or atoms in a system based on their distances from a reference particle.\n",
    "- **PlaneOfBestFit**: the Plane of Best Fit is a geometric descriptor that represents the optimal plane that fits a set of points in three-dimensional space. It is also known as the least squares plane or the best-fitting plane.\n",
    "- **MORSE**: descriptors are based on an idea of obtaining information from the 3D atomic coordinates by the transform used in electron diffraction studies for preparing theoretical scattering curves. A generalized scattering function, called the molecular transform, can be used as an functional basis for deriving, from a known molecular structure, the specific analytic relationship of both X-ray and electron diffraction.\n",
    "- **WHIM** stands for Weighted Holistic Invariant Molecular descriptors. It is a set of molecular descriptors that captures various aspects of a molecule's structure and properties. WHIM descriptors are calculated based on the spatial distribution of atoms within a molecule. They consider interatomic distances, atomic properties, and connectivity patterns to generate a quantitative representation of the molecule.\n",
    "- **Radius of Gyration**: The radius of gyration is a measure of the spatial extent or compactness of a molecule. It quantifies the distribution of atoms around the center of mass of the molecule and provides information about its overall size and shape.\n",
    "- **Inertial Shape Factor**: The inertial shape factor is a descriptor that provides information about the molecular shape and symmetry based on its moments of inertia. It quantifies how the mass is distributed within a molecule and is used to characterize its rotational behavior.\n",
    "- **Eccentricity**: Eccentricity is a descriptor that quantifies the degree of elongation or distortion of a molecule from a perfectly spherical shape. It provides information about the symmetry and asymmetry of the molecule.\n",
    "- **Asphericity**: Asphericity is a descriptor that measures the degree of deviation of a molecule from a perfectly spherical shape. It provides information about the non-sphericity or distortion of a molecule's geometry.\n",
    "- **SpherocityIndex**: The spherocity index is a descriptor that quantifies the spherical nature of a molecule or object. It provides a measure of how closely a molecule resembles a perfect sphere.\n",
    "- **PrincipalMomentsOfInertia**: The principal moments of inertia are descriptors that characterize the rotational behavior of a molecule around its principal axes. They provide information about the distribution of mass or volume within the molecule and its rotational symmetry.\n",
    "- **NormalizedPrincipalMomentsRatios**: Normalized Principal Moments Ratios: Normalized principal moments ratios are descriptors that provide information about the relative magnitude of the principal moments of inertia of a molecule. They are calculated by normalizing the eigenvalues of the moment of inertia tensor."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "You can either generate the conformers or read them from a SDF file as shown above. Then, you can featurize the dataset with all the above features as follow:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-29T14:08:23.675730989Z",
     "start_time": "2023-05-29T14:07:54.202066376Z"
    }
   },
   "outputs": [],
   "source": [
    "All3DDescriptors(mandatory_generation_of_conformers=False).featurize(dataset, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-29T14:08:26.154631473Z",
     "start_time": "2023-05-29T14:08:26.151614026Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[7.7435791e-01, 1.3100000e-01, 3.1299999e-01, ..., 6.4344002e+01,\n",
       "        7.2148003e+01, 7.0723000e+01],\n",
       "       [1.7659803e-01, 1.2600000e-01, 3.0399999e-01, ..., 9.9838997e+01,\n",
       "        8.5703003e+01, 7.8072998e+01],\n",
       "       [4.8933503e-01, 1.0600000e-01, 2.4300000e-01, ..., 1.1920000e+02,\n",
       "        1.1242600e+02, 1.1243400e+02],\n",
       "       ...,\n",
       "       [9.3339241e-01, 5.0999999e-02, 1.1900000e-01, ..., 1.2269430e+03,\n",
       "        1.2413199e+03, 1.4608800e+03],\n",
       "       [7.7761173e-01, 4.8999999e-02, 1.2100000e-01, ..., 1.2056530e+03,\n",
       "        1.0074610e+03, 1.1707830e+03],\n",
       "       [4.8907563e-01, 5.0999999e-02, 1.3200000e-01, ..., 1.0148000e+03,\n",
       "        1.0399250e+03, 8.3022101e+02]], dtype=float32)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-29T14:09:57.699730695Z",
     "start_time": "2023-05-29T14:09:57.649131462Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Asphericity', 'AUTOCORR3D_0', 'AUTOCORR3D_1', 'AUTOCORR3D_2',\n",
       "       'AUTOCORR3D_3', 'AUTOCORR3D_4', 'AUTOCORR3D_5', 'AUTOCORR3D_6',\n",
       "       'AUTOCORR3D_7', 'AUTOCORR3D_8', 'AUTOCORR3D_9', 'AUTOCORR3D_10',\n",
       "       'AUTOCORR3D_11', 'AUTOCORR3D_12', 'AUTOCORR3D_13', 'AUTOCORR3D_14',\n",
       "       'AUTOCORR3D_15', 'AUTOCORR3D_16', 'AUTOCORR3D_17', 'AUTOCORR3D_18',\n",
       "       'AUTOCORR3D_19', 'AUTOCORR3D_20', 'AUTOCORR3D_21', 'AUTOCORR3D_22',\n",
       "       'AUTOCORR3D_23', 'AUTOCORR3D_24', 'AUTOCORR3D_25', 'AUTOCORR3D_26',\n",
       "       'AUTOCORR3D_27', 'AUTOCORR3D_28', 'AUTOCORR3D_29', 'AUTOCORR3D_30',\n",
       "       'AUTOCORR3D_31', 'AUTOCORR3D_32', 'AUTOCORR3D_33', 'AUTOCORR3D_34',\n",
       "       'AUTOCORR3D_35', 'AUTOCORR3D_36', 'AUTOCORR3D_37', 'AUTOCORR3D_38',\n",
       "       'AUTOCORR3D_39', 'AUTOCORR3D_40', 'AUTOCORR3D_41', 'AUTOCORR3D_42',\n",
       "       'AUTOCORR3D_43', 'AUTOCORR3D_44', 'AUTOCORR3D_45', 'AUTOCORR3D_46',\n",
       "       'AUTOCORR3D_47', 'AUTOCORR3D_48', 'AUTOCORR3D_49', 'AUTOCORR3D_50',\n",
       "       'AUTOCORR3D_51', 'AUTOCORR3D_52', 'AUTOCORR3D_53', 'AUTOCORR3D_54',\n",
       "       'AUTOCORR3D_55', 'AUTOCORR3D_56', 'AUTOCORR3D_57', 'AUTOCORR3D_58',\n",
       "       'AUTOCORR3D_59', 'AUTOCORR3D_60', 'AUTOCORR3D_61', 'AUTOCORR3D_62',\n",
       "       'AUTOCORR3D_63', 'AUTOCORR3D_64', 'AUTOCORR3D_65', 'AUTOCORR3D_66',\n",
       "       'AUTOCORR3D_67', 'AUTOCORR3D_68', 'AUTOCORR3D_69', 'AUTOCORR3D_70',\n",
       "       'AUTOCORR3D_71', 'AUTOCORR3D_72', 'AUTOCORR3D_73', 'AUTOCORR3D_74',\n",
       "       'AUTOCORR3D_75', 'AUTOCORR3D_76', 'AUTOCORR3D_77', 'AUTOCORR3D_78',\n",
       "       'AUTOCORR3D_79', 'Eccentricity', 'InertialShapeFactor', 'MORSE_0',\n",
       "       'MORSE_1', 'MORSE_2', 'MORSE_3', 'MORSE_4', 'MORSE_5', 'MORSE_6',\n",
       "       'MORSE_7', 'MORSE_8', 'MORSE_9', 'MORSE_10', 'MORSE_11',\n",
       "       'MORSE_12', 'MORSE_13', 'MORSE_14', 'MORSE_15', 'MORSE_16',\n",
       "       'MORSE_17', 'MORSE_18', 'MORSE_19', 'MORSE_20', 'MORSE_21',\n",
       "       'MORSE_22', 'MORSE_23', 'MORSE_24', 'MORSE_25', 'MORSE_26',\n",
       "       'MORSE_27', 'MORSE_28', 'MORSE_29', 'MORSE_30', 'MORSE_31',\n",
       "       'MORSE_32', 'MORSE_33', 'MORSE_34', 'MORSE_35', 'MORSE_36',\n",
       "       'MORSE_37', 'MORSE_38', 'MORSE_39', 'MORSE_40', 'MORSE_41',\n",
       "       'MORSE_42', 'MORSE_43', 'MORSE_44', 'MORSE_45', 'MORSE_46',\n",
       "       'MORSE_47', 'MORSE_48', 'MORSE_49', 'MORSE_50', 'MORSE_51',\n",
       "       'MORSE_52', 'MORSE_53', 'MORSE_54', 'MORSE_55', 'MORSE_56',\n",
       "       'MORSE_57', 'MORSE_58', 'MORSE_59', 'MORSE_60', 'MORSE_61',\n",
       "       'MORSE_62', 'MORSE_63', 'MORSE_64', 'MORSE_65', 'MORSE_66',\n",
       "       'MORSE_67', 'MORSE_68', 'MORSE_69', 'MORSE_70', 'MORSE_71',\n",
       "       'MORSE_72', 'MORSE_73', 'MORSE_74', 'MORSE_75', 'MORSE_76',\n",
       "       'MORSE_77', 'MORSE_78', 'MORSE_79', 'MORSE_80', 'MORSE_81',\n",
       "       'MORSE_82', 'MORSE_83', 'MORSE_84', 'MORSE_85', 'MORSE_86',\n",
       "       'MORSE_87', 'MORSE_88', 'MORSE_89', 'MORSE_90', 'MORSE_91',\n",
       "       'MORSE_92', 'MORSE_93', 'MORSE_94', 'MORSE_95', 'MORSE_96',\n",
       "       'MORSE_97', 'MORSE_98', 'MORSE_99', 'MORSE_100', 'MORSE_101',\n",
       "       'MORSE_102', 'MORSE_103', 'MORSE_104', 'MORSE_105', 'MORSE_106',\n",
       "       'MORSE_107', 'MORSE_108', 'MORSE_109', 'MORSE_110', 'MORSE_111',\n",
       "       'MORSE_112', 'MORSE_113', 'MORSE_114', 'MORSE_115', 'MORSE_116',\n",
       "       'MORSE_117', 'MORSE_118', 'MORSE_119', 'MORSE_120', 'MORSE_121',\n",
       "       'MORSE_122', 'MORSE_123', 'MORSE_124', 'MORSE_125', 'MORSE_126',\n",
       "       'MORSE_127', 'MORSE_128', 'MORSE_129', 'MORSE_130', 'MORSE_131',\n",
       "       'MORSE_132', 'MORSE_133', 'MORSE_134', 'MORSE_135', 'MORSE_136',\n",
       "       'MORSE_137', 'MORSE_138', 'MORSE_139', 'MORSE_140', 'MORSE_141',\n",
       "       'MORSE_142', 'MORSE_143', 'MORSE_144', 'MORSE_145', 'MORSE_146',\n",
       "       'MORSE_147', 'MORSE_148', 'MORSE_149', 'MORSE_150', 'MORSE_151',\n",
       "       'MORSE_152', 'MORSE_153', 'MORSE_154', 'MORSE_155', 'MORSE_156',\n",
       "       'MORSE_157', 'MORSE_158', 'MORSE_159', 'MORSE_160', 'MORSE_161',\n",
       "       'MORSE_162', 'MORSE_163', 'MORSE_164', 'MORSE_165', 'MORSE_166',\n",
       "       'MORSE_167', 'MORSE_168', 'MORSE_169', 'MORSE_170', 'MORSE_171',\n",
       "       'MORSE_172', 'MORSE_173', 'MORSE_174', 'MORSE_175', 'MORSE_176',\n",
       "       'MORSE_177', 'MORSE_178', 'MORSE_179', 'MORSE_180', 'MORSE_181',\n",
       "       'MORSE_182', 'MORSE_183', 'MORSE_184', 'MORSE_185', 'MORSE_186',\n",
       "       'MORSE_187', 'MORSE_188', 'MORSE_189', 'MORSE_190', 'MORSE_191',\n",
       "       'MORSE_192', 'MORSE_193', 'MORSE_194', 'MORSE_195', 'MORSE_196',\n",
       "       'MORSE_197', 'MORSE_198', 'MORSE_199', 'MORSE_200', 'MORSE_201',\n",
       "       'MORSE_202', 'MORSE_203', 'MORSE_204', 'MORSE_205', 'MORSE_206',\n",
       "       'MORSE_207', 'MORSE_208', 'MORSE_209', 'MORSE_210', 'MORSE_211',\n",
       "       'MORSE_212', 'MORSE_213', 'MORSE_214', 'MORSE_215', 'MORSE_216',\n",
       "       'MORSE_217', 'MORSE_218', 'MORSE_219', 'MORSE_220', 'MORSE_221',\n",
       "       'MORSE_222', 'MORSE_223', 'NPR1', 'NPR2', 'PBF', 'PMI1', 'PMI2',\n",
       "       'PMI3', 'RDF_0', 'RDF_1', 'RDF_2', 'RDF_3', 'RDF_4', 'RDF_5',\n",
       "       'RDF_6', 'RDF_7', 'RDF_8', 'RDF_9', 'RDF_10', 'RDF_11', 'RDF_12',\n",
       "       'RDF_13', 'RDF_14', 'RDF_15', 'RDF_16', 'RDF_17', 'RDF_18',\n",
       "       'RDF_19', 'RDF_20', 'RDF_21', 'RDF_22', 'RDF_23', 'RDF_24',\n",
       "       'RDF_25', 'RDF_26', 'RDF_27', 'RDF_28', 'RDF_29', 'RDF_30',\n",
       "       'RDF_31', 'RDF_32', 'RDF_33', 'RDF_34', 'RDF_35', 'RDF_36',\n",
       "       'RDF_37', 'RDF_38', 'RDF_39', 'RDF_40', 'RDF_41', 'RDF_42',\n",
       "       'RDF_43', 'RDF_44', 'RDF_45', 'RDF_46', 'RDF_47', 'RDF_48',\n",
       "       'RDF_49', 'RDF_50', 'RDF_51', 'RDF_52', 'RDF_53', 'RDF_54',\n",
       "       'RDF_55', 'RDF_56', 'RDF_57', 'RDF_58', 'RDF_59', 'RDF_60',\n",
       "       'RDF_61', 'RDF_62', 'RDF_63', 'RDF_64', 'RDF_65', 'RDF_66',\n",
       "       'RDF_67', 'RDF_68', 'RDF_69', 'RDF_70', 'RDF_71', 'RDF_72',\n",
       "       'RDF_73', 'RDF_74', 'RDF_75', 'RDF_76', 'RDF_77', 'RDF_78',\n",
       "       'RDF_79', 'RDF_80', 'RDF_81', 'RDF_82', 'RDF_83', 'RDF_84',\n",
       "       'RDF_85', 'RDF_86', 'RDF_87', 'RDF_88', 'RDF_89', 'RDF_90',\n",
       "       'RDF_91', 'RDF_92', 'RDF_93', 'RDF_94', 'RDF_95', 'RDF_96',\n",
       "       'RDF_97', 'RDF_98', 'RDF_99', 'RDF_100', 'RDF_101', 'RDF_102',\n",
       "       'RDF_103', 'RDF_104', 'RDF_105', 'RDF_106', 'RDF_107', 'RDF_108',\n",
       "       'RDF_109', 'RDF_110', 'RDF_111', 'RDF_112', 'RDF_113', 'RDF_114',\n",
       "       'RDF_115', 'RDF_116', 'RDF_117', 'RDF_118', 'RDF_119', 'RDF_120',\n",
       "       'RDF_121', 'RDF_122', 'RDF_123', 'RDF_124', 'RDF_125', 'RDF_126',\n",
       "       'RDF_127', 'RDF_128', 'RDF_129', 'RDF_130', 'RDF_131', 'RDF_132',\n",
       "       'RDF_133', 'RDF_134', 'RDF_135', 'RDF_136', 'RDF_137', 'RDF_138',\n",
       "       'RDF_139', 'RDF_140', 'RDF_141', 'RDF_142', 'RDF_143', 'RDF_144',\n",
       "       'RDF_145', 'RDF_146', 'RDF_147', 'RDF_148', 'RDF_149', 'RDF_150',\n",
       "       'RDF_151', 'RDF_152', 'RDF_153', 'RDF_154', 'RDF_155', 'RDF_156',\n",
       "       'RDF_157', 'RDF_158', 'RDF_159', 'RDF_160', 'RDF_161', 'RDF_162',\n",
       "       'RDF_163', 'RDF_164', 'RDF_165', 'RDF_166', 'RDF_167', 'RDF_168',\n",
       "       'RDF_169', 'RDF_170', 'RDF_171', 'RDF_172', 'RDF_173', 'RDF_174',\n",
       "       'RDF_175', 'RDF_176', 'RDF_177', 'RDF_178', 'RDF_179', 'RDF_180',\n",
       "       'RDF_181', 'RDF_182', 'RDF_183', 'RDF_184', 'RDF_185', 'RDF_186',\n",
       "       'RDF_187', 'RDF_188', 'RDF_189', 'RDF_190', 'RDF_191', 'RDF_192',\n",
       "       'RDF_193', 'RDF_194', 'RDF_195', 'RDF_196', 'RDF_197', 'RDF_198',\n",
       "       'RDF_199', 'RDF_200', 'RDF_201', 'RDF_202', 'RDF_203', 'RDF_204',\n",
       "       'RDF_205', 'RDF_206', 'RDF_207', 'RDF_208', 'RDF_209',\n",
       "       'RadiusOfGyration', 'SpherocityIndex', 'WHIM_0', 'WHIM_1',\n",
       "       'WHIM_2', 'WHIM_3', 'WHIM_4', 'WHIM_5', 'WHIM_6', 'WHIM_7',\n",
       "       'WHIM_8', 'WHIM_9', 'WHIM_10', 'WHIM_11', 'WHIM_12', 'WHIM_13',\n",
       "       'WHIM_14', 'WHIM_15', 'WHIM_16', 'WHIM_17', 'WHIM_18', 'WHIM_19',\n",
       "       'WHIM_20', 'WHIM_21', 'WHIM_22', 'WHIM_23', 'WHIM_24', 'WHIM_25',\n",
       "       'WHIM_26', 'WHIM_27', 'WHIM_28', 'WHIM_29', 'WHIM_30', 'WHIM_31',\n",
       "       'WHIM_32', 'WHIM_33', 'WHIM_34', 'WHIM_35', 'WHIM_36', 'WHIM_37',\n",
       "       'WHIM_38', 'WHIM_39', 'WHIM_40', 'WHIM_41', 'WHIM_42', 'WHIM_43',\n",
       "       'WHIM_44', 'WHIM_45', 'WHIM_46', 'WHIM_47', 'WHIM_48', 'WHIM_49',\n",
       "       'WHIM_50', 'WHIM_51', 'WHIM_52', 'WHIM_53', 'WHIM_54', 'WHIM_55',\n",
       "       'WHIM_56', 'WHIM_57', 'WHIM_58', 'WHIM_59', 'WHIM_60', 'WHIM_61',\n",
       "       'WHIM_62', 'WHIM_63', 'WHIM_64', 'WHIM_65', 'WHIM_66', 'WHIM_67',\n",
       "       'WHIM_68', 'WHIM_69', 'WHIM_70', 'WHIM_71', 'WHIM_72', 'WHIM_73',\n",
       "       'WHIM_74', 'WHIM_75', 'WHIM_76', 'WHIM_77', 'WHIM_78', 'WHIM_79',\n",
       "       'WHIM_80', 'WHIM_81', 'WHIM_82', 'WHIM_83', 'WHIM_84', 'WHIM_85',\n",
       "       'WHIM_86', 'WHIM_87', 'WHIM_88', 'WHIM_89', 'WHIM_90', 'WHIM_91',\n",
       "       'WHIM_92', 'WHIM_93', 'WHIM_94', 'WHIM_95', 'WHIM_96', 'WHIM_97',\n",
       "       'WHIM_98', 'WHIM_99', 'WHIM_100', 'WHIM_101', 'WHIM_102',\n",
       "       'WHIM_103', 'WHIM_104', 'WHIM_105', 'WHIM_106', 'WHIM_107',\n",
       "       'WHIM_108', 'WHIM_109', 'WHIM_110', 'WHIM_111', 'WHIM_112',\n",
       "       'WHIM_113'], dtype='<U19')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.feature_names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## In DeepMol, we also can use different featurizers for the same dataset, in case you want to use different featurizers at the same time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from deepmol.compound_featurization import MixedFeaturizer\n",
    "\n",
    "MixedFeaturizer(featurizers=[All3DDescriptors(mandatory_generation_of_conformers=False), TwoDimensionDescriptors()]).featurize(dataset, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-06T12:58:36.856784997Z",
     "start_time": "2023-06-06T12:58:36.850943314Z"
    },
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2023-06-06 13:58:36,849 — INFO — Mols_shape: (16623,)\n",
      "2023-06-06 13:58:36,850 — INFO — Features_shape: (16623, 847)\n",
      "2023-06-06 13:58:36,850 — INFO — Labels_shape: (16623,)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "((16623,), (16623, 847), (16623,))"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.get_shape()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-06T12:59:09.077778811Z",
     "start_time": "2023-06-06T12:59:09.074913267Z"
    },
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Asphericity'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.feature_names[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-06T12:59:21.713159187Z",
     "start_time": "2023-06-06T12:59:21.669561815Z"
    },
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'fr_urea'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.feature_names[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "As you see, the dataset has now 2D and 3D descriptors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DeepChem Featurization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Weave Featurization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Weave convolutions were introduced in [1]_. Unlike Duvenaud graph convolutions, weave convolutions require a quadratic matrix of interaction descriptors for each pair of atoms. These extra descriptors may provide for additional descriptive power but at the cost of a larger featurized dataset. Weave convolutions are implemented in DeepChem as the WeaveFeaturizer class.\n",
    "\n",
    "[1] Kearnes, Steven, et al. \"Molecular graph convolutions: moving beyond fingerprints.\" Journal of computer-aided molecular design 30.8 (2016): 595-608."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-29T14:10:38.138229894Z",
     "start_time": "2023-05-29T14:10:20.504259022Z"
    }
   },
   "outputs": [],
   "source": [
    "WeaveFeat(n_jobs=10).featurize(dataset, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-29T14:11:08.138498418Z",
     "start_time": "2023-05-29T14:11:08.082659191Z"
    },
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([<deepchem.feat.mol_graphs.WeaveMol object at 0x7f61e450f070>,\n",
       "       <deepchem.feat.mol_graphs.WeaveMol object at 0x7f61e4560d30>,\n",
       "       <deepchem.feat.mol_graphs.WeaveMol object at 0x7f61e450f760>, ...,\n",
       "       <deepchem.feat.mol_graphs.WeaveMol object at 0x7f62d7882550>,\n",
       "       <deepchem.feat.mol_graphs.WeaveMol object at 0x7f62d78824c0>,\n",
       "       <deepchem.feat.mol_graphs.WeaveMol object at 0x7f62d78826a0>],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-05-29T14:11:13.534687625Z",
     "start_time": "2023-05-29T14:11:13.526519821Z"
    },
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['weave_feat'], dtype='<U10')"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.feature_names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Coulomb Featurization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Coulomb matrices provide a representation of the electronic structure of a molecule. For a molecule with N atoms, the Coulomb matrix is a N X N matrix where each element gives the strength of the electrostatic interaction between two atoms. The method is described in more detail in [1]_.\n",
    "\n",
    "[1] Montavon, Grégoire, et al. “Learning invariant representations of molecules for atomization energy prediction.” Advances in neural information processing systems. 2012."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "CoulombFeat(n_jobs=10,max_atoms=10).featurize(dataset, inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Coulomb Eig Featurization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This featurizer computes the eigenvalues of the Coulomb matrices for provided molecules. Coulomb matrices are described in [1]_. This featurizer is useful for computing the eigenvalues of the Coulomb matrices for molecules in a dataset.\n",
    "\n",
    "[1] Montavon, Grégoire, et al. “Learning invariant representations of molecules for atomization energy prediction.” Advances in neural information processing systems. 2012."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "CoulombEigFeat(n_jobs=10,max_atoms=10).featurize(dataset, inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ConvMolFeat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Duvenaud graph convolutions [1]_ construct a vector of descriptors for each atom in a molecule. The featurizer computes that vector of local descriptors.\n",
    "\n",
    "    [1] Duvenaud, David K., et al. “Convolutional networks on graphs for learning molecular fingerprints.” Advances in neural information processing systems. 2015."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ConvMolFeat(n_jobs=10).featurize(dataset, inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### MolGraphConvFeat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This class is a featurizer of general graph convolution networks for molecules.\n",
    "\n",
    "The default node(atom) and edge(bond) representations are based on WeaveNet paper. If you want to use your own representations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MolGraphConvFeat(n_jobs=10).featurize(dataset, inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SmileImageFeat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SmilesToImage Featurizer takes a SMILES string, and turns it into an image. Details taken from [1]_.\n",
    "\n",
    "The default size of for the image is 80 x 80. Two image modes are currently supported - std & engd. std is the gray scale specification, with atomic numbers as pixel values for atom positions and a constant value of 2 for bond positions. engd is a 4-channel specification, which uses atom properties like hybridization, valency, charges in addition to atomic number. Bond type is also used for the bonds.\n",
    "\n",
    "The coordinates of all atoms are computed, and lines are drawn between atoms to indicate bonds. For the respective channels, the atom and bond positions are set to the property values as mentioned in the paper.\n",
    "\n",
    "[1] Goh, Garrett B., et al. “Using rule-based labels for weak supervised learning: a ChemNet for transferable chemical property prediction.” Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining. 2018."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SmileImageFeat(n_jobs=10).featurize(dataset, inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SmilesSeqFeat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SmilesToSeq Featurizer takes a SMILES string, and turns it into a sequence. Details taken from [1]_.\n",
    "\n",
    "SMILES strings smaller than a specified max length (max_len) are padded using the PAD token while those larger than the max length are not considered. Based on the paper, there is also the option to add extra padding (pad_len) on both sides of the string after length normalization. Using a character to index (char_to_idx) mapping, the SMILES characters are turned into indices and the resulting sequence of indices serves as the input for an embedding layer.\n",
    "\n",
    "[1] Goh, Garrett B., et al. “Using rule-based labels for weak supervised learning: a ChemNet for transferable chemical property prediction.” Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining. 2018."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SmilesSeqFeat().featurize(dataset, inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### MolGanFeat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Featurizer for MolGAN de-novo molecular generation [1]_. The default representation is in form of GraphMatrix object. It is wrapper for two matrices containing atom and bond type information. The class also provides reverse capabilities.\n",
    "\n",
    "[1] MolGAN: An implicit generative model for small molecular graphs. https://arxiv.org/abs/1805.11973"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MolGanFeat(n_jobs=10).featurize(dataset, inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## One hot encoding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "One hot encoding is a simple featurizer that takes a dataset of SMILES strings and converts them into a one-hot encoding of the characters in the SMILES strings. This featurizer is useful for converting SMILES strings into a format that can be used by models that require one-hot encodings of SMILES strings.\n",
    "\n",
    "Let's see how it works."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-06T15:43:55.950042355Z",
     "start_time": "2023-06-06T15:43:55.669342996Z"
    },
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from deepmol.compound_featurization import SmilesOneHotEncoder\n",
    "\n",
    "ohe = SmilesOneHotEncoder().fit(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-06T15:44:00.141621508Z",
     "start_time": "2023-06-06T15:43:58.076303726Z"
    },
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<deepmol.datasets.datasets.SmilesDataset at 0x7faa8bf2bf40>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ohe.transform(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-06T15:44:04.729720865Z",
     "start_time": "2023-06-06T15:44:04.727258251Z"
    },
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['one_hot_0', 'one_hot_1', 'one_hot_2', 'one_hot_3', 'one_hot_4',\n",
       "       'one_hot_5', 'one_hot_6', 'one_hot_7', 'one_hot_8', 'one_hot_9',\n",
       "       'one_hot_10', 'one_hot_11', 'one_hot_12', 'one_hot_13',\n",
       "       'one_hot_14', 'one_hot_15', 'one_hot_16', 'one_hot_17',\n",
       "       'one_hot_18', 'one_hot_19', 'one_hot_20', 'one_hot_21',\n",
       "       'one_hot_22', 'one_hot_23', 'one_hot_24', 'one_hot_25',\n",
       "       'one_hot_26', 'one_hot_27', 'one_hot_28', 'one_hot_29',\n",
       "       'one_hot_30', 'one_hot_31', 'one_hot_32', 'one_hot_33',\n",
       "       'one_hot_34', 'one_hot_35', 'one_hot_36', 'one_hot_37',\n",
       "       'one_hot_38', 'one_hot_39', 'one_hot_40', 'one_hot_41',\n",
       "       'one_hot_42', 'one_hot_43', 'one_hot_44', 'one_hot_45',\n",
       "       'one_hot_46', 'one_hot_47', 'one_hot_48', 'one_hot_49',\n",
       "       'one_hot_50', 'one_hot_51', 'one_hot_52', 'one_hot_53',\n",
       "       'one_hot_54', 'one_hot_55', 'one_hot_56', 'one_hot_57',\n",
       "       'one_hot_58', 'one_hot_59', 'one_hot_60', 'one_hot_61',\n",
       "       'one_hot_62', 'one_hot_63', 'one_hot_64', 'one_hot_65',\n",
       "       'one_hot_66', 'one_hot_67', 'one_hot_68', 'one_hot_69',\n",
       "       'one_hot_70', 'one_hot_71', 'one_hot_72', 'one_hot_73',\n",
       "       'one_hot_74', 'one_hot_75', 'one_hot_76', 'one_hot_77',\n",
       "       'one_hot_78', 'one_hot_79', 'one_hot_80', 'one_hot_81',\n",
       "       'one_hot_82', 'one_hot_83', 'one_hot_84', 'one_hot_85',\n",
       "       'one_hot_86', 'one_hot_87', 'one_hot_88', 'one_hot_89',\n",
       "       'one_hot_90', 'one_hot_91', 'one_hot_92', 'one_hot_93',\n",
       "       'one_hot_94', 'one_hot_95', 'one_hot_96', 'one_hot_97',\n",
       "       'one_hot_98', 'one_hot_99', 'one_hot_100', 'one_hot_101',\n",
       "       'one_hot_102', 'one_hot_103', 'one_hot_104', 'one_hot_105',\n",
       "       'one_hot_106', 'one_hot_107', 'one_hot_108', 'one_hot_109',\n",
       "       'one_hot_110', 'one_hot_111', 'one_hot_112', 'one_hot_113',\n",
       "       'one_hot_114', 'one_hot_115', 'one_hot_116', 'one_hot_117',\n",
       "       'one_hot_118', 'one_hot_119', 'one_hot_120', 'one_hot_121',\n",
       "       'one_hot_122', 'one_hot_123', 'one_hot_124', 'one_hot_125',\n",
       "       'one_hot_126', 'one_hot_127', 'one_hot_128', 'one_hot_129',\n",
       "       'one_hot_130', 'one_hot_131'], dtype='<U11')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.feature_names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "By default, the one hot encoder uses an atom-level tokenizer that splits SMILES strings into individual tokens associated with each atom and bond in the molecule.\n",
    "\n",
    "As you can see below, the vocabulary is composed of tokens associated with atoms in the molecule. The max_length is the maximum length of the SMILES tokens in the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-06T15:44:53.905180747Z",
     "start_time": "2023-06-06T15:44:53.857479622Z"
    },
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['[C@]',\n",
       " '[N@+]',\n",
       " '2',\n",
       " '8',\n",
       " '[11C]',\n",
       " 'Br',\n",
       " '#',\n",
       " '%10',\n",
       " ')',\n",
       " '=',\n",
       " 'C',\n",
       " '4',\n",
       " '[C@@H2]',\n",
       " '9',\n",
       " 'O',\n",
       " '6',\n",
       " '[2H]',\n",
       " 'I',\n",
       " '[CH2]',\n",
       " 'Cl',\n",
       " '3',\n",
       " '[C]',\n",
       " '1',\n",
       " '[N]',\n",
       " 'P',\n",
       " '[C@@]',\n",
       " '[C@@H]',\n",
       " '[N+]',\n",
       " '[18F]',\n",
       " '[NH+]',\n",
       " '7',\n",
       " '\\\\',\n",
       " '/',\n",
       " '(',\n",
       " '[11CH2]',\n",
       " 'N',\n",
       " '[C@H]',\n",
       " '5',\n",
       " '[NH3+]',\n",
       " '[11CH3]',\n",
       " 'S',\n",
       " '[S+]',\n",
       " 'F']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ohe.tokenizer.vocabulary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "As you see below, the max_length is the maximum length of the SMILES tokens in the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-06T15:45:11.162739679Z",
     "start_time": "2023-06-06T15:45:11.160248893Z"
    },
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "132"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ohe.max_length"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "You can also use a k-mer tokenizer that splits SMILES strings into k-mers. This is useful for models that use k-mer encodings of SMILES strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-06T15:46:45.852272932Z",
     "start_time": "2023-06-06T15:46:45.192100817Z"
    },
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from deepmol.tokenizers import KmerSmilesTokenizer\n",
    "\n",
    "ohe = SmilesOneHotEncoder(tokenizer=KmerSmilesTokenizer(size=2, stride=1)).fit(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-06T15:47:13.638203115Z",
     "start_time": "2023-06-06T15:46:58.602934129Z"
    },
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<deepmol.datasets.datasets.SmilesDataset at 0x7faa8bf2bf40>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ohe.transform(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-06T15:47:13.681570331Z",
     "start_time": "2023-06-06T15:47:13.639230502Z"
    },
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['one_hot_0', 'one_hot_1', 'one_hot_2', 'one_hot_3', 'one_hot_4',\n",
       "       'one_hot_5', 'one_hot_6', 'one_hot_7', 'one_hot_8', 'one_hot_9',\n",
       "       'one_hot_10', 'one_hot_11', 'one_hot_12', 'one_hot_13',\n",
       "       'one_hot_14', 'one_hot_15', 'one_hot_16', 'one_hot_17',\n",
       "       'one_hot_18', 'one_hot_19', 'one_hot_20', 'one_hot_21',\n",
       "       'one_hot_22', 'one_hot_23', 'one_hot_24', 'one_hot_25',\n",
       "       'one_hot_26', 'one_hot_27', 'one_hot_28', 'one_hot_29',\n",
       "       'one_hot_30', 'one_hot_31', 'one_hot_32', 'one_hot_33',\n",
       "       'one_hot_34', 'one_hot_35', 'one_hot_36', 'one_hot_37',\n",
       "       'one_hot_38', 'one_hot_39', 'one_hot_40', 'one_hot_41',\n",
       "       'one_hot_42', 'one_hot_43', 'one_hot_44', 'one_hot_45',\n",
       "       'one_hot_46', 'one_hot_47', 'one_hot_48', 'one_hot_49',\n",
       "       'one_hot_50', 'one_hot_51', 'one_hot_52', 'one_hot_53',\n",
       "       'one_hot_54', 'one_hot_55', 'one_hot_56', 'one_hot_57',\n",
       "       'one_hot_58', 'one_hot_59', 'one_hot_60', 'one_hot_61',\n",
       "       'one_hot_62', 'one_hot_63', 'one_hot_64', 'one_hot_65',\n",
       "       'one_hot_66', 'one_hot_67', 'one_hot_68', 'one_hot_69',\n",
       "       'one_hot_70', 'one_hot_71', 'one_hot_72', 'one_hot_73',\n",
       "       'one_hot_74', 'one_hot_75', 'one_hot_76', 'one_hot_77',\n",
       "       'one_hot_78', 'one_hot_79', 'one_hot_80', 'one_hot_81',\n",
       "       'one_hot_82', 'one_hot_83', 'one_hot_84', 'one_hot_85',\n",
       "       'one_hot_86', 'one_hot_87', 'one_hot_88', 'one_hot_89',\n",
       "       'one_hot_90', 'one_hot_91', 'one_hot_92', 'one_hot_93',\n",
       "       'one_hot_94', 'one_hot_95', 'one_hot_96', 'one_hot_97',\n",
       "       'one_hot_98', 'one_hot_99', 'one_hot_100', 'one_hot_101',\n",
       "       'one_hot_102', 'one_hot_103', 'one_hot_104', 'one_hot_105',\n",
       "       'one_hot_106', 'one_hot_107', 'one_hot_108', 'one_hot_109',\n",
       "       'one_hot_110', 'one_hot_111', 'one_hot_112', 'one_hot_113',\n",
       "       'one_hot_114', 'one_hot_115', 'one_hot_116', 'one_hot_117',\n",
       "       'one_hot_118', 'one_hot_119', 'one_hot_120', 'one_hot_121',\n",
       "       'one_hot_122', 'one_hot_123', 'one_hot_124', 'one_hot_125',\n",
       "       'one_hot_126', 'one_hot_127', 'one_hot_128', 'one_hot_129',\n",
       "       'one_hot_130'], dtype='<U11')"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.feature_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-06T15:48:38.403867460Z",
     "start_time": "2023-06-06T15:48:38.400935127Z"
    },
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "131"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ohe.max_length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-06T15:47:17.955893181Z",
     "start_time": "2023-06-06T15:47:17.953865058Z"
    },
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'#C',\n",
       " '#N',\n",
       " '#[C]',\n",
       " '%10)',\n",
       " '%10=',\n",
       " '%10C',\n",
       " '(#',\n",
       " '(/',\n",
       " '(=',\n",
       " '(Br',\n",
       " '(C',\n",
       " '(Cl',\n",
       " '(F',\n",
       " '(I',\n",
       " '(N',\n",
       " '(O',\n",
       " '(P',\n",
       " '(S',\n",
       " '([11C]',\n",
       " '([C@@H2]',\n",
       " '([C@@H]',\n",
       " '([C@@]',\n",
       " '([C@H]',\n",
       " '([C@]',\n",
       " '([N+]',\n",
       " '([NH+]',\n",
       " '([NH3+]',\n",
       " '(\\\\',\n",
       " ')#',\n",
       " ')(',\n",
       " ')/',\n",
       " ')=',\n",
       " ')Br',\n",
       " ')C',\n",
       " ')Cl',\n",
       " ')F',\n",
       " ')I',\n",
       " ')N',\n",
       " ')O',\n",
       " ')P',\n",
       " ')S',\n",
       " ')[11CH2]',\n",
       " ')[18F]',\n",
       " ')[2H]',\n",
       " ')[C@@H]',\n",
       " ')[C@@]',\n",
       " ')[C@H]',\n",
       " ')[C@]',\n",
       " ')\\\\',\n",
       " '/1',\n",
       " '/2',\n",
       " '/3',\n",
       " '/4',\n",
       " '/C',\n",
       " '/Cl',\n",
       " '/F',\n",
       " '/I',\n",
       " '/N',\n",
       " '/O',\n",
       " '/S',\n",
       " '/[C@]',\n",
       " '1(',\n",
       " '1)',\n",
       " '1/',\n",
       " '12',\n",
       " '13',\n",
       " '14',\n",
       " '15',\n",
       " '17',\n",
       " '18',\n",
       " '1=',\n",
       " '1Br',\n",
       " '1C',\n",
       " '1Cl',\n",
       " '1F',\n",
       " '1I',\n",
       " '1N',\n",
       " '1O',\n",
       " '1S',\n",
       " '1[C@@H]',\n",
       " '1[C@@]',\n",
       " '1[C@H]',\n",
       " '1[C@]',\n",
       " '1[S+]',\n",
       " '1\\\\',\n",
       " '2(',\n",
       " '2)',\n",
       " '2/',\n",
       " '21',\n",
       " '23',\n",
       " '24',\n",
       " '25',\n",
       " '2=',\n",
       " '2Br',\n",
       " '2C',\n",
       " '2Cl',\n",
       " '2F',\n",
       " '2N',\n",
       " '2O',\n",
       " '2S',\n",
       " '2[C@@H]',\n",
       " '2[C@@]',\n",
       " '2[C@H]',\n",
       " '2[C@]',\n",
       " '2[N+]',\n",
       " '2[S+]',\n",
       " '2\\\\',\n",
       " '3(',\n",
       " '3)',\n",
       " '3/',\n",
       " '31',\n",
       " '32',\n",
       " '34',\n",
       " '35',\n",
       " '3=',\n",
       " '3Br',\n",
       " '3C',\n",
       " '3Cl',\n",
       " '3F',\n",
       " '3N',\n",
       " '3O',\n",
       " '3S',\n",
       " '3[2H]',\n",
       " '3[C@@H]',\n",
       " '3[C@@]',\n",
       " '3[C@H]',\n",
       " '3[C@]',\n",
       " '3\\\\',\n",
       " '4(',\n",
       " '4)',\n",
       " '4/',\n",
       " '41',\n",
       " '42',\n",
       " '43',\n",
       " '45',\n",
       " '4=',\n",
       " '4Br',\n",
       " '4C',\n",
       " '4Cl',\n",
       " '4F',\n",
       " '4N',\n",
       " '4O',\n",
       " '4S',\n",
       " '4[C@@H]',\n",
       " '4[C@@]',\n",
       " '4[C@H]',\n",
       " '4\\\\',\n",
       " '5(',\n",
       " '5)',\n",
       " '51',\n",
       " '52',\n",
       " '53',\n",
       " '54',\n",
       " '56',\n",
       " '5=',\n",
       " '5Br',\n",
       " '5C',\n",
       " '5Cl',\n",
       " '5F',\n",
       " '5N',\n",
       " '5O',\n",
       " '5S',\n",
       " '5[C@@H]',\n",
       " '5[C@H]',\n",
       " '6(',\n",
       " '6)',\n",
       " '61',\n",
       " '62',\n",
       " '64',\n",
       " '67',\n",
       " '6=',\n",
       " '6C',\n",
       " '6N',\n",
       " '6O',\n",
       " '6S',\n",
       " '6[C@@]',\n",
       " '7)',\n",
       " '76',\n",
       " '7=',\n",
       " '7C',\n",
       " '7N',\n",
       " '7O',\n",
       " '7[C@@H]',\n",
       " '7[C@H]',\n",
       " '8)',\n",
       " '8=',\n",
       " '8C',\n",
       " '8O',\n",
       " '8[C@H]',\n",
       " '9%10',\n",
       " '9)',\n",
       " '9C',\n",
       " '=1',\n",
       " '=2',\n",
       " '=3',\n",
       " '=4',\n",
       " '=5',\n",
       " '=6',\n",
       " '=7',\n",
       " '=8',\n",
       " '=C',\n",
       " '=N',\n",
       " '=O',\n",
       " '=P',\n",
       " '=S',\n",
       " '=[N+]',\n",
       " 'Br)',\n",
       " 'Br/',\n",
       " 'BrC',\n",
       " 'Br[C@@H]',\n",
       " 'C#',\n",
       " 'C%10',\n",
       " 'C(',\n",
       " 'C)',\n",
       " 'C/',\n",
       " 'C1',\n",
       " 'C2',\n",
       " 'C3',\n",
       " 'C4',\n",
       " 'C5',\n",
       " 'C6',\n",
       " 'C7',\n",
       " 'C8',\n",
       " 'C9',\n",
       " 'C=',\n",
       " 'CC',\n",
       " 'CCl',\n",
       " 'CF',\n",
       " 'CN',\n",
       " 'CO',\n",
       " 'CP',\n",
       " 'CS',\n",
       " 'C[C@@H]',\n",
       " 'C[C@@]',\n",
       " 'C[C@H]',\n",
       " 'C[C@]',\n",
       " 'C[CH2]',\n",
       " 'C[C]',\n",
       " 'C[N+]',\n",
       " 'C[N@+]',\n",
       " 'C[NH+]',\n",
       " 'C[S+]',\n",
       " 'C\\\\',\n",
       " 'Cl)',\n",
       " 'Cl/',\n",
       " 'ClC',\n",
       " 'F)',\n",
       " 'FC',\n",
       " 'F[C@@H]',\n",
       " 'I)',\n",
       " 'IC',\n",
       " 'N#',\n",
       " 'N(',\n",
       " 'N)',\n",
       " 'N/',\n",
       " 'N1',\n",
       " 'N2',\n",
       " 'N3',\n",
       " 'N4',\n",
       " 'N5',\n",
       " 'N6',\n",
       " 'N7',\n",
       " 'N8',\n",
       " 'N9',\n",
       " 'N=',\n",
       " 'NC',\n",
       " 'NN',\n",
       " 'NO',\n",
       " 'NP',\n",
       " 'NS',\n",
       " 'N[C@@H]',\n",
       " 'N[C@@]',\n",
       " 'N[C@H]',\n",
       " 'N[N+]',\n",
       " 'N\\\\',\n",
       " 'O(',\n",
       " 'O)',\n",
       " 'O/',\n",
       " 'O1',\n",
       " 'O2',\n",
       " 'O3',\n",
       " 'O4',\n",
       " 'O5',\n",
       " 'O6',\n",
       " 'O=',\n",
       " 'OC',\n",
       " 'ON',\n",
       " 'OO',\n",
       " 'OS',\n",
       " 'O[11CH3]',\n",
       " 'O[C@@H]',\n",
       " 'O[C@@]',\n",
       " 'O[C@H]',\n",
       " 'O[C@]',\n",
       " 'O\\\\',\n",
       " 'P(',\n",
       " 'P1',\n",
       " 'S(',\n",
       " 'S)',\n",
       " 'S/',\n",
       " 'S1',\n",
       " 'S2',\n",
       " 'S3',\n",
       " 'S4',\n",
       " 'S5',\n",
       " 'S=',\n",
       " 'SC',\n",
       " 'SN',\n",
       " 'SS',\n",
       " 'S\\\\',\n",
       " '[11CH2]C',\n",
       " '[11CH3])',\n",
       " '[11C]#',\n",
       " '[18F])',\n",
       " '[18F]C',\n",
       " '[2H])',\n",
       " '[C@@H2]C',\n",
       " '[C@@H](',\n",
       " '[C@@H]1',\n",
       " '[C@@H]2',\n",
       " '[C@@H]3',\n",
       " '[C@@H]4',\n",
       " '[C@@H]5',\n",
       " '[C@@H]6',\n",
       " '[C@@H]7',\n",
       " '[C@@](',\n",
       " '[C@@]1',\n",
       " '[C@@]2',\n",
       " '[C@@]3',\n",
       " '[C@@]4',\n",
       " '[C@@]5',\n",
       " '[C@H](',\n",
       " '[C@H]1',\n",
       " '[C@H]2',\n",
       " '[C@H]3',\n",
       " '[C@H]4',\n",
       " '[C@H]5',\n",
       " '[C@H]6',\n",
       " '[C@H]7',\n",
       " '[C@](',\n",
       " '[C@]1',\n",
       " '[C@]2',\n",
       " '[C@]3',\n",
       " '[C@]4',\n",
       " '[C@]5',\n",
       " '[C@]6',\n",
       " '[CH2]C',\n",
       " '[C]#',\n",
       " '[C])',\n",
       " '[C]1',\n",
       " '[N+]#',\n",
       " '[N+](',\n",
       " '[N+]1',\n",
       " '[N+]2',\n",
       " '[N+]3',\n",
       " '[N+]=',\n",
       " '[N@+]2',\n",
       " '[NH+](',\n",
       " '[NH+]2',\n",
       " '[NH+]4',\n",
       " '[NH3+])',\n",
       " '[N]=',\n",
       " '[S+](',\n",
       " '\\\\1',\n",
       " '\\\\2',\n",
       " '\\\\3',\n",
       " '\\\\4',\n",
       " '\\\\C',\n",
       " '\\\\N',\n",
       " '\\\\O',\n",
       " '\\\\S'}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ohe.tokenizer.vocabulary"
   ]
  }
 ],
 "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.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}