Fixed lingo, shortestpath, topological-torsion and atom-pair fingerprints

Fixed bug in circular fingerprint (at default it was generating FCFP2 fingerprints instead of ECFP6)
Added atompairs (CDK), rdk-descriptor (RDKit) and spectrophore (openbabel) fingerprints
Renamed substructure to cdk-substructure fingerprint
Removed signature fingerprint
When generating a fingerprint without specifying a fingerprint size or depth, it will always go with the default parameters
The size and depth setting now are supported with many more fingerprints
Tried to fix heteroencoder fingerprint, but get an error when it loads the model

Author: Jnelen

Example/test_fingerprint.py

@@ -8,10 +8,9 @@
 import numpy as np
 from PyFingerprint.fingerprint import get_fingerprint, get_fingerprints
 
-cdktypes = ['standard', 'extended', 'graph', 'maccs', 'pubchem', 'estate', 'hybridization', 'lingo', 
-            'klekota-roth', 'shortestpath', 'signature', 'substructure']
-rdktypes = ['rdkit', 'morgan', 'rdk-maccs', 'topological-torsion', 'avalon', 'atom-pair']
-babeltypes = ['fp2', 'fp3', 'fp4']
+cdktypes = ['standard', 'extended', 'graph', 'maccs', 'pubchem', 'estate', 'hybridization', 'lingo', 'klekota-roth', 'shortestpath', 'cdk-substructure', 'circular', 'atompairs']
+rdktypes = ['rdkit', 'morgan', 'rdk-maccs', 'topological-torsion', 'avalon', 'atom-pair', 'rdk-descriptor']
+babeltypes = ['fp2', 'fp3', 'fp4', 'spectrophore']
 vectypes = ['mol2vec', 'heteroencoder']
 
 smi = 'CCCCN'

PyFingerprint/CDK/cdk-2.2.jar PyFingerprint/CDK/cdk-2.9.jarPyFingerprint/CDK/cdk-2.2.jar renamed to PyFingerprint/CDK/cdk-2.9.jar

@@ -3,20 +3,44 @@
 Created on Thu Nov 15 10:49:26 2018
 
 @author: hcji
+
+Updated on Thu Oct 12 20:04:22 2023
+
+@author: Jnelen
 """
 
-from openbabel import pybel
+from openbabel import openbabel, pybel
 
-def ob_fingerprint(smi, fp_type='FP2', nbit=1024):
+import numpy as np
+
+def convertToFP(bits, nbit):
+    fp = np.zeros(nbit)
+    for i in bits:
+        fp[i] = 1
+    return list(fp)
 
+def ob_fingerprint(smi, fp_type='FP2', depth=0):
 
     mol = pybel.readstring("smi", smi)
+    
     if fp_type == 'fp2':
-        fp = mol.calcfp('FP2')
+        bits = mol.calcfp('FP2').bits
+        nbit = 1024
+        fp = convertToFP(bits, nbit)
     elif fp_type == 'fp3':
-        fp = mol.calcfp('FP3')
+        bits = mol.calcfp('FP3').bits
+        nbit = 55
+        fp = convertToFP(bits, nbit)
     elif fp_type == 'fp4':
-        fp = mol.calcfp('FP4')
-    bits = fp.bits
-    bits = [x for x in bits if x < nbit]
-    return bits, nbit
+        bits = mol.calcfp('FP4').bits
+        nbit = 307
+        fp = convertToFP(bits, nbit)
+    elif fp_type == 'spectrophore':
+        mol.addh()
+        mol.make3D()       
+        spectrophoreCalculator = openbabel.OBSpectrophore()
+        spectrophoreCalculator.SetNormalization(depth)
+        fp = list(spectrophoreCalculator.GetSpectrophore(mol.OBMol))
+    else:
+        raise IOError('invalid fingerprint type')       
+    return fp

PyFingerprint/babel.py

@@ -3,6 +3,10 @@
 Created on Wed Nov 14 12:46:18 2018
 
 @author: hcji
+
+Updated on Thu Oct 12 20:04:22 2023
+
+@author: Jnelen
 """
 
 import os
@@ -11,7 +15,7 @@
 import PyFingerprint
 
 if not isJVMStarted():
-    cdk_path = os.path.join(PyFingerprint.__path__[0], 'CDK', 'cdk-2.2.jar')
+    cdk_path = os.path.join(PyFingerprint.__path__[0], 'CDK', 'cdk-2.9.jar')
     startJVM(getDefaultJVMPath(), "-ea", "-Djava.class.path=%s" % cdk_path)
     cdk = JPackage('org').openscience.cdk
 
@@ -28,50 +32,88 @@ def cdk_parser_smiles(smi):
 
 def get_fingerprinter(name, size, depth): 
     ### This was getting made every time!
-    _fingerprinters = {"standard":lambda : cdk.fingerprint.Fingerprinter(size, depth)
-                       , "extended":lambda : cdk.fingerprint.ExtendedFingerprinter(size, depth)
-                       , "graph":lambda : cdk.fingerprint.GraphOnlyFingerprinter(size, depth)
-                       , "maccs":lambda : cdk.fingerprint.MACCSFingerprinter()
-                       , "pubchem":lambda : cdk.fingerprint.PubchemFingerprinter(cdk.silent.SilentChemObjectBuilder.getInstance())
-                       , "estate":lambda : cdk.fingerprint.EStateFingerprinter()
-                       , "hybridization":lambda : cdk.fingerprint.HybridizationFingerprinter(size, depth)
-                       , "lingo":lambda : cdk.fingerprint.LingoFingerprinter(depth)
-                       , "klekota-roth":lambda : cdk.fingerprint.KlekotaRothFingerprinter()
-                       , "shortestpath":lambda : cdk.fingerprint.ShortestPathFingerprinter(size)
-                       , "signature": lambda : cdk.fingerprint.SignatureFingerprinter(depth)
-                       , "circular": lambda : cdk.fingerprint.CircularFingerprinter()
-                       , "substructure": lambda : cdk.fingerprint.SubstructureFingerprinter()
-                            }
+    ## Checking if the depth is specified. If not, we use the default CDK values where appropriate 
+    if depth == None:
+	    _fingerprinters = {"standard":lambda : cdk.fingerprint.Fingerprinter(size, 7)
+	                       , "atompairs": lambda : cdk.fingerprint.AtomPairs2DFingerprinter()
+	                       , "extended":lambda : cdk.fingerprint.ExtendedFingerprinter(size, 7)
+	                       , "graph":lambda : cdk.fingerprint.GraphOnlyFingerprinter(size, 7)
+	                       , "maccs":lambda : cdk.fingerprint.MACCSFingerprinter()
+	                       , "pubchem":lambda : cdk.fingerprint.PubchemFingerprinter(cdk.silent.SilentChemObjectBuilder.getInstance())
+	                       , "estate":lambda : cdk.fingerprint.EStateFingerprinter()
+	                       , "hybridization":lambda : cdk.fingerprint.HybridizationFingerprinter(size, 7)
+	                       , "lingo":lambda : cdk.fingerprint.LingoFingerprinter()
+	                       , "klekota-roth":lambda : cdk.fingerprint.KlekotaRothFingerprinter()
+	                       , "shortestpath":lambda : cdk.fingerprint.ShortestPathFingerprinter(size)
+	                       , "signature": lambda : cdk.fingerprint.SignatureFingerprinter()
+	                       ## circular fingerprint defaults to ECFP6: https://github.com/cdk/cdk/blob/125505c5ea1f69b692183bb0aae65816e7cb44e7/descriptor/fingerprint/src/main/java/org/openscience/cdk/fingerprint/CircularFingerprinter.java
+	                       , "circular": lambda : cdk.fingerprint.CircularFingerprinter(4,size)
+	                       , "cdk-substructure": lambda : cdk.fingerprint.SubstructureFingerprinter()
+	                            }
+    ## Use the user-specified settings for the fingerprint generation
+    else:
+        _fingerprinters = {"standard":lambda : cdk.fingerprint.Fingerprinter(size, depth)
+	                       , "atompairs": lambda : cdk.fingerprint.AtomPairs2DFingerprinter()
+	                       , "extended":lambda : cdk.fingerprint.ExtendedFingerprinter(size, depth)
+	                       , "graph":lambda : cdk.fingerprint.GraphOnlyFingerprinter(size, depth)
+	                       , "maccs":lambda : cdk.fingerprint.MACCSFingerprinter()
+	                       , "pubchem":lambda : cdk.fingerprint.PubchemFingerprinter(cdk.silent.SilentChemObjectBuilder.getInstance())
+	                       , "estate":lambda : cdk.fingerprint.EStateFingerprinter()
+	                       , "hybridization":lambda : cdk.fingerprint.HybridizationFingerprinter(size, depth)
+	                       , "lingo":lambda : cdk.fingerprint.LingoFingerprinter(depth)
+	                       , "klekota-roth":lambda : cdk.fingerprint.KlekotaRothFingerprinter()
+	                       , "shortestpath":lambda : cdk.fingerprint.ShortestPathFingerprinter(size)
+	                       , "signature": lambda : cdk.fingerprint.SignatureFingerprinter(depth)
+	                       , "circular": lambda : cdk.fingerprint.CircularFingerprinter(depth, size)
+	                       , "cdk-substructure": lambda : cdk.fingerprint.SubstructureFingerprinter()
+	                            }
+	                            
     if name not in _fingerprinters: 
         raise IOError('invalid fingerprint type')
 
     return _fingerprinters[name]()
 
-def cdk_fingerprint(smi, fp_type="standard", size=1024, depth=6):
-    if fp_type == 'maccs':
-        nbit = 166
-    elif fp_type == 'estate':
+def cdk_fingerprint(smi, fp_type="standard", size=1024, depth=None):
+
+    mol = cdk_parser_smiles(smi)
+    ## Sanitize input molecules, as is recommended for most fingerprints (especially shortestpath)
+    cdk.tools.manipulator.AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(mol)
+    cdk.tools.manipulator.AtomContainerManipulator.convertImplicitToExplicitHydrogens(mol)
+    
+    if fp_type == 'estate':
         nbit = 79
-    elif fp_type == 'cdk':
+    elif fp_type == 'maccs':
+        nbit = 166
+    elif fp_type == 'cdk-substructure':
         nbit = 307
+    elif fp_type == 'atompairs':
+        nbit = 780
     elif fp_type == 'pubchem':
         nbit = 881
     elif fp_type == 'klekota-roth':
-        nbit = 4860
-    elif fp_type in ['lingo', 'signature']:
+        nbit = 4860      
+    elif fp_type == 'signature':
         nbit = None
+        print("Signature_FP")
+        fingerprinter = cdk.fingerprint.SignatureFingerprinter()
+        mol = cdk_parser_smiles(smi)
+        print(fingerprinter.getSize())
+        print(fingerprinter.getBitFingerprint(mol).getSetbits())
+        print(fingerprinter.getBitFingerprint(mol).size())
+        print(fingerprinter.getRawFingerprint(mol))
+        
     else:
         nbit = size
 
-    mol = cdk_parser_smiles(smi)
+    
 
     # Pull from cache if it exists
     if (fp_type, size, depth) in fp_map: 
         fingerprinter = fp_map[(fp_type, size, depth)]
     else:
         fingerprinter = get_fingerprinter(fp_type, size, depth)
         fp_map[(fp_type, size, depth)] = fingerprinter
-
+    
     fp_obj = fingerprinter.getBitFingerprint(mol)
     bits = list(fp_obj.getSetbits())
     return bits, nbit

PyFingerprint/cdk.py

@@ -3,6 +3,10 @@
 Created on Wed Feb  2 08:01:30 2022
 
 @author: jihon
+
+Updated on Thu Oct 12 20:04:22 2023
+
+@author: Jnelen
 """
 
 
@@ -18,22 +22,21 @@
     hc_enable = False
 
 
-cdktypes = ['standard', 'extended', 'graph', 'maccs', 'pubchem', 'estate', 'hybridization', 'lingo', 
-            'klekota-roth', 'shortestpath', 'signature', 'substructure', 'circular']
-rdktypes = ['rdkit', 'morgan', 'rdk-maccs', 'topological-torsion', 'avalon', 'atom-pair']
-babeltypes = ['fp2', 'fp3', 'fp4']
+cdktypes = ['standard', 'extended', 'graph', 'maccs', 'pubchem', 'estate', 'hybridization', 'lingo', 'klekota-roth', 'shortestpath', 'cdk-substructure', 'circular', 'atompairs']
+rdktypes = ['rdkit', 'morgan', 'rdk-maccs', 'topological-torsion', 'avalon', 'atom-pair', 'rdk-descriptor']
+babeltypes = ['fp2', 'fp3', 'fp4', 'spectrophore']
 vectypes = ['mol2vec', 'heteroencoder']
 
-
 class fingerprint:
 
-    def __init__(self, bits: list, values: list, n: int):
-        self.bits = bits
-        self.values = values
-        self.n = n
+    def __init__(self, fp: list):
+        self.fp = np.array(fp)
+        self.bits = np.nonzero(self.fp)[0]
+        self.values = self.fp[self.bits]
+        self.n = len(self.fp)
 
     def __str__(self):
-        return (self.bits, self.n)
+        return str(list(self.fp))[1:-1]
 
     def check(self):
         for i in self.bits:
@@ -46,55 +49,50 @@ def check(self):
                 raise TypeError    
 
     def to_numpy(self):
-        if self.n is None:
-            return None
-        elif self.n > 10024:
-            return None
-        v = np.zeros(self.n)
-        for i, k in enumerate(self.bits):
-            v[k] = self.values[i]
-        return v
+        return self.fp
+
+    def getActiveBits(self):
+        return self.bits
+        
+    def numActiveBits(self):
+        return len(self.getActiveBits()) 
+        
+    def getActiveValues(self):
+        return dict(zip(self.getActiveBits(), self.values)) 
+           
+    def to_str(self):          
+        return str(list(self.fp))[1:-1]
 
 
 def get_fingerprint(smi: str, fp_type: str, nbit=None, depth=None):
-    if nbit is None:
-        nbit = 1024
-    if depth is None:
-        depth = 6
     if fp_type in cdktypes:
-        bits, n = cdk_fingerprint(smi, fp_type, size = nbit, depth = depth)
-        values = [1] * len(bits)
+        if nbit is None:
+            nbit = 1024
+        bits, n = cdk_fingerprint(smi, fp_type, size=nbit, depth=depth)
+        fp = np.zeros(n)
+        for i, k in enumerate(bits):
+            fp[k] = 1
     elif fp_type in rdktypes:
-        bits, n = rdk_fingerprint(smi, fp_type, size = nbit)
-        values = [1] * len(bits)
+        fp = list(rdk_fingerprint(smi, fp_type, size=nbit))
+
     elif fp_type in babeltypes:
-        if nbit is None:
-            nbit = 307
-        bits, n = ob_fingerprint(smi, fp_type)
-        values = [1] * len(bits)
+        fp = ob_fingerprint(smi, fp_type)
     elif fp_type == 'mol2vec':
-        values = list(mol2vec_fingerprint(smi))
-        n = len(values)
-        bits = list(np.arange(n))
+        fp = list(mol2vec_fingerprint(smi))
     elif fp_type == 'heteroencoder':
         if not hc_enable:
             raise IOError('heteroencoder is not enabled')
-        values = list(hc_fingerprint(smi))
-        n = len(values)
-        bits = list(np.arange(n))
+        fp = list(hc_fingerprint(smi))
     else:
         raise IOError('invalid fingerprint type')
-    return fingerprint(bits, values, n)
+    return fingerprint(fp)
 
 
 def get_fingerprints(smlist: list, fp_type: str, nbit=None, depth=None):
     if fp_type not in vectypes:
         output = [get_fingerprint(smi, fp_type, nbit, depth) for smi in smlist]
     elif fp_type == 'mol2vec':
-        vecs = mol2vec_fingerprints(smlist)
-        n = vecs.shape[1]
-        bits = list(np.arange(n))
-        output = [fingerprint(bits, vecs[i,:], n) for i in range(vecs.shape[0])]
+        output = [get_fingerprint(smi, fp_type, nbit, depth) for smi in smlist]
     elif fp_type == 'heteroencoder':
         if not hc_enable:
             raise IOError('heteroencoder is not enabled')

PyFingerprint/fingerprint.py

@@ -2012,15 +2012,15 @@ def transform(self, mols, misses=False):
 '''
 
 def hc_fingerprint(smi: str):
-    model_name = os.path.join(PyFingerprint.__path__[0], 'Heteroencoder', 'heteroencoder_model.pkl')
+    model_name = os.path.join(PyFingerprint.__path__[0], 'Heteroencoder', 'heteroencoder_model')
     model = DDC(model_name = model_name)
     molb = Chem.rdchem.Mol.ToBinary(Chem.MolFromSmiles(smi))
     vec = model.transform(model.vectorize([molb]))
     return vec[0,0,:]
 
 
 def hc_fingerprints(smlist: list):
-    model_name = os.path.join(PyFingerprint.__path__[0], 'Heteroencoder', 'heteroencoder_model.pkl')
+    model_name = os.path.join(PyFingerprint.__path__[0], 'Heteroencoder', 'heteroencoder_model')
     model = DDC(model_name = model_name)
     molb = [Chem.rdchem.Mol.ToBinary(Chem.MolFromSmiles(smi)) for smi in smlist]
     vecs = model.transform(model.vectorize(molb))