RDKFingerprint() Method in RDKit

Cheminformatics Tutorials - Herong's Tutorial Examples

∟Daylight Fingerprint Generator in RDKit

∟RDKFingerprint() Method in RDKit

This section provides a tutorial example on understanding the fingerprint generation algorithm used in the rdkit.Chem.rdmolops.RDKFingerprint() function.

RDKFingerprint(mol) method is located in the rdkit.Chem.rdmolops module of the RDKit library. The same method is also packaged as rdkit.Chem.AllChem.RDKFingerprint() for easier access. It returns a fingerprint as a bit string generated from the Daylight fingerprint method.

Here is the definition of the method:

rdkit.Chem.rdmolops.RDKFingerprint((Mol)mol[, 
  (int)minPath=1[, 
  (int)maxPath=7[, 
  (int)fpSize=2048[, 
  (int)nBitsPerHash=2[, 
  (bool)useHs=True[, 
  (float)tgtDensity=0.0[, 
  (int)minSize=128[, 
  (bool)branchedPaths=True[, 
  (bool)useBondOrder=True[, 
  (AtomPairsParameters)atomInvariants=0[, 
  (AtomPairsParameters)fromAtoms=0[, 
  (AtomPairsParameters)atomBits=None[, 
  (AtomPairsParameters)bitInfo=None]]]]]]]]]]]]]) 
-> ExplicitBitVect

Descriptions of all arguments:

mol: the molecule to use.
minPath: (optional) minimum number of bonds to include in the subgraphs.
maxPath: (optional) maximum number of bonds to include in the subgraphs.
fpSize: (optional) number of bits in the fingerprint.
nBitsPerHash: (optional) number of bits to set per path.
useHs: (optional) include paths involving Hs in the fingerprint if the molecule has explicit Hydrogens.
tgtDensity: (optional) fold the fingerprint until this minimum density has been reached.
minSize: (optional) the minimum size the fingerprint will be folded to when trying to reach tgtDensity.
branchedPaths: (optional) if set, both branched and unbranched paths will be used in the fingerprint.
useBondOrder: (optional) if set, both bond orders will be used in the path hashes.
atomInvariants: (optional) a sequence of atom invariants to use in the path hashes.
fromAtoms: (optional) a sequence of atom indices. If provided, only paths/subgraphs starting from these atoms will be used.
atomBits: (optional) an empty list. If provided, the result will contain a list containing the bits each atom sets.
bitInfo: (optional) an empty dict. If provided, the result will contain a dict with bits as keys and corresponding bond paths as values.

Based on my understanding, RDKFingerprint() implements the Daylight fingerprint method with several modifications. Here is the RDKit's modified version:

Find all unique subgraphs between minPath=1 and maxPath=7 in bond length. So subgraph "C" is too short. Subgraph "CCCCCCCCC" is too long. Subgraph "CO" and subgraph "OC" are identical.
Calculate the hash value of each unique subgraph.
Use the hash value as the seed to generate nBitsPerHash=2 random numbers between 0 and 2**(fpSize=2048).
Set the corresponding bits in the fingerprint to '1' for those two random numbers for each unique subgraph.
Finally, fold the fingerprint to increase its density to meet the tgtDensity value, but stop folding when the fingerprint length reaches minSize. Fingerprint density is defined as the ratio of number of '1' bits over number of all bits.

Now let's verify the algorithm with some simple tests.

1. Molecule with a 1 subgraph: "CC" expressed in SMILES.

from rdkit import Chem
atomBits = []
bitInfo = {}
mol = Chem.MolFromSmiles('CC')
fp = Chem.RDKFingerprint(mol, 
  fpSize=64, nBitsPerHash=1, atomBits=atomBits, bitInfo=bitInfo)
print(fp.ToBitString())
print(fp.GetNumOnBits())
print(atomBits)
print(bitInfo)

# output:
0000000000000000000000000000100000000000000000000000000000000000
1
[[28], [28]]
{28: [[0]]}

Notes on this test:

"fpSize=64" is used to reduce the fingerprint size to make it easier to study.
"nBitsPerHash=1" is used to simplify the fingerprint to 1 bit per subgraph.
Only 1 subgraph, "CC", is used in the fingerprint, which turns on 1 bit at index of 28.
Output "atomBits=[[28], [28]]" indicates that first atom "C" and second atom "C" are involved in the same subgraph which sets the bit 28.
Output "bitInfo={28: [[0]]}" indicates that bit 28 is set by the subgraph with bond 0 only.

2. Molecule with a 2 unique subgraphs: "CCC" expressed in SMILES.

atomBits = []
bitInfo = {}
mol = Chem.MolFromSmiles('CCC')
fp = Chem.RDKFingerprint(mol, 
  fpSize=64, nBitsPerHash=1, atomBits=atomBits, bitInfo=bitInfo)
print(fp.ToBitString())
print(fp.GetNumOnBits())
print(atomBits)
print(bitInfo)

# output:
0000000000000000000001000000100000000000000000000000000000000000
2
[[28, 21], [28, 21], [28, 21]]
{21: [[0, 1]], 28: [[0], [1]]}

Notes on this test:

Only 2 unique subgraphs, "CC" and "CCC", are used in the fingerprint, resulting 2 bits being turned on at indexes of 21 and 28.
Output "atomBits=[[28, 21], [28, 21], [28, 21]]" indicates that all 3 atoms are involved in subgraphs which set bit 21 and bit 28. Because there are actually 3 non-unique subgraphs in this molecule: "CC", "CCC" and "CC".
Output "bitInfo={21: [[0, 1]], 28: [[0], [1]]}" indicates that bit 21 is set by the subgraph with 2 bonds: bond 0 and bond 1. Bit 28 is set by 2 identical subgraphs: one with bond 0 and one with bond 1.

3. Molecule with a 3 unique subgraphs: "CCO" expressed in SMILES.

atomBits = []
bitInfo = {}
mol = Chem.MolFromSmiles('CCO')
fp = Chem.RDKFingerprint(mol, 
  fpSize=64, nBitsPerHash=1, atomBits=atomBits, bitInfo=bitInfo)
print(fp.ToBitString())
print(fp.GetNumOnBits())
print(atomBits)
print(bitInfo)

# output:
1000000000000000000000000000100000000000000000000000000000010000
3
[[28, 0], [28, 59, 0], [59, 0]]
{0: [[0, 1]], 28: [[0]], 59: [[1]]}

Notes on this test:

3 unique subgraphs, "CC", "CCO" and "CO", are used in the fingerprint, resulting 3 bits being turned on at indexes of 0, 28, and 59.
Output "atomBits=[[28, 0], [28, 59, 0], [59, 0]]" indicates that the first atom, C, is involved in 2 subgraphs which set bit 28 and bit 0. The second atom, C, is involved in 3 subgraphs which set bit 28, bit 59 and bit 0. The third atom, O, is involved in 2 subgraphs which set bit 59, and bit 0. Because there are actually 3 unique subgraphs in this molecule: "CC", "CCO" and "CO".
Output "bitInfo={0: [[0, 1]], 28: [[0]], 59: [[1]]}" indicates that bit 0 is set by the subgraph with 2 bonds: bond 0 and bond 1. Bit 28 is set by the subgraph with bond 0. Bit 59 is set by the subgraph with bond 1.