RDKit_2D Descriptors in Python – Part 4

This is part-4 from the five-part series tutorial of the blog post, Computing Molecular Descriptors – Intro, in the context of drug discovery. The goal of this post to explain the python code on computing 2D RDKit descriptors and exporting them as CSV files.

First, install the required library packages using miniconda.

import pandas as pd
from rdkit import Chem
from rdkit.Chem import Descriptors
from rdkit.ML.Descriptors import MoleculeDescriptors

The code for RDKit_2D class that I have developed can be found below and here in the GitHub link as well.

Also, please check out the previous posts: Computing Molecular Descriptors – Part 1, and MACCS Fingerprints in Python – Part 2 to see more explanation on the formatting of the code and python class.

import pandas as pd
from rdkit import Chem
from rdkit.Chem import Descriptors
from rdkit.ML.Descriptors import MoleculeDescriptors

class RDKit_2D:
    def __init__(self, smiles):
        self.mols = [Chem.MolFromSmiles(i) for i in smiles]
        self.smiles = smiles
        
    def compute_2Drdkit(self, name):
        rdkit_2d_desc = []
        calc = MoleculeDescriptors.MolecularDescriptorCalculator([x[0] for x in Descriptors._descList])
        header = calc.GetDescriptorNames()
        for i in range(len(self.mols)):
            ds = calc.CalcDescriptors(self.mols[i])
            rdkit_2d_desc.append(ds)
        df = pd.DataFrame(rdkit_2d_desc,columns=header)
        df.insert(loc=0, column='smiles', value=self.smiles)
        df.to_csv(name[:-4]+'_RDKit_2D.csv', index=False)

The above code snipped is a class stored as “RDKit_2D.py” which you can load from other python scripts and call its modules.

In RDKit_2D class, I implemented “compute_2Drdkit()” as the only and major function to handle the calculation of RDKit descriptors, prepare them and export them as a CSV file.

Below is the full list of the RDKit descriptors that we will compute. You can check it by running the following line of code.

from rdkit import Chem    # make sure to import it if you haven't done so
from rdkit.Chem import Descriptors    # make sure to import it if you haven't done so
descriptors_list = [x[0] for x in Descriptors._descList]
print(descriptors_list)

It will print out the following list containing the currently available descriptors.

As you can see, there are altogether 115 RDKit descriptors as of now. We will compute all of them for each given compound.

We can directly use the aforementioned list as the header for the output molecular descriptors. Or we can also use the following line of code to achieve the same thing.

header = calc.GetDescriptorNames()

MoleculeDescriptors.MolecularDescriptorCalculator() is an abstract base class for descriptor calculators that you will need to call for whatever molecular descriptor feature that you want. Since we want to compute all the descriptors, we will call this for the entire list of available descriptors. So, below is the single line of code to prepare that.

calc = MoleculeDescriptors.MolecularDescriptorCalculator([x[0] for x in Descriptors._descList])

If you want to know the type of calc, you can check it by calling type(calc). The output is here:

<class 'rdkit.ML.Descriptors.MoleculeDescriptors.MolecularDescriptorCalculator'>

Once we have set up the calc variable, we can then compute the descriptors for a mol of interest by executing the code below:

mol = Chem.MolFromSmiles('CC1=CC(=C(C=C1NC(=O)C2=C(C(=CC(=C2)I)I)O)Cl)C(C#N)C3=CC=C(C=C3)Cl')
ds = calc.CalcDescriptors(mol)
print(ds)

Below is the output of the variable ds, which contains all the computed molecular properties in the order of the descriptor list that I have mentioned before: [x[0] for x in Descriptors._descList].

Essentially, when you get to this point, you can put them together in a function to iterate for all the mols and organize them into a pandas dataframe. It requires that you know some basic python codes on how to use for loops, constructing a pandas frame, exporting a CSV file, etc.

As a result of putting these pieces together, you will get something like the following class module from RDKit_2D (note that they are indented that way because I copied pasted it directly from the python class):

    def compute_2Drdkit(self, name):
        rdkit_2d_desc = []
        calc = MoleculeDescriptors.MolecularDescriptorCalculator([x[0] for x in Descriptors._descList])
        header = calc.GetDescriptorNames()
        for i in range(len(self.mols)):
            ds = calc.CalcDescriptors(self.mols[i])
            rdkit_2d_desc.append(ds)
        df = pd.DataFrame(rdkit_2d_desc,columns=header)
        df.insert(loc=0, column='smiles', value=self.smiles)
        df.to_csv(name[:-4]+'_RDKit_2D.csv', index=False)

I know that some of us are more interested in actually importing and using this class so below is an example code to import the “RDKit_2D” class and use it to compute RDKit 2D descriptors. It follows pretty much the same code format as MACCS and ECFP from the previous tutorials.

import pandas as pd
from molvs import standardize_smiles
from RDKit_2D import *

def main():
    filename = 'data/macrolides_smiles.csv'  # path to your csv file
    df = pd.read_csv(filename)               # read the csv file as pandas data frame
    smiles = [standardize_smiles(i) for i in df['smiles'].values]  

    ## Compute RDKit_2D Fingerprints and export a csv file.
    RDKit_descriptor = RDKit_2D(smiles)        # create your RDKit_2D object and provide smiles
    RDKit_descriptor.compute_2Drdkit(filename) # compute RDKit_2D and provide the name of your desired output file. you can use the same name as the input file because the RDKit_2D class will ensure to add "_RDKit_2D.csv" as part of the output file.

if __name__ == '__main__':
    main()

That’s all for this post for now. Please stay tuned for the next post which is the last of this five-part series: Mordred_MRC_Descriptors in Python – Part 5.

MRC descriptors are new descriptors that were developed as part of the MacrolactoneDB project to better characterize macrolides and macrocycles. You will get a closer look at how to develop new descriptors like MRC in the next post. Cheers!