qsarmil 0.1.0__tar.gz

qsarmil-0.1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: qsarmil
+Version: 0.1.0
+Summary: Molecular multi-instance machine learning
+Author-email: Dmitry Zankov <dvzankov@gmail.com>
+License: MIT
+Description-Content-Type: text/x-rst
+Requires-Dist: mikit-learn
+Requires-Dist: rdkit
+Requires-Dist: molfeat
+Requires-Dist: py3Dmol
+Requires-Dist: tqdm
+Requires-Dist: huggingface_hub

qsarmil-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "qsarmil"
+version = "0.1.0"
+description = "Molecular multi-instance machine learning"
+readme = "README.rst"
+license = { text = "MIT" }
+authors = [
+  { name = "Dmitry Zankov", email = "dvzankov@gmail.com" }
+]
+
+dependencies = [
+        "mikit-learn",
+        "rdkit",
+        "molfeat",
+        "py3Dmol",
+        "tqdm",
+        "huggingface_hub"
+]
+
+[tool.setuptools.packages.find]
+where = ["."]

qsarmil-0.1.0/qsarmil/conformer/__init__.py

@@ -0,0 +1 @@
+from .rdkit import RDKitConformerGenerator

qsarmil-0.1.0/qsarmil/conformer/base.py

@@ -0,0 +1,112 @@
+import joblib
+from tqdm import tqdm
+from rdkit.Chem import AllChem, rdMolAlign
+from rdkit import RDLogger
+from joblib import Parallel, delayed
+from qsarmil.utils.logging import FailedMolecule, FailedConformer
+RDLogger.DisableLog('rdApp.*')
+
+
+class ConformerGenerator:
+    def __init__(self, num_conf=10, e_thresh=None, rmsd_thresh=None, num_cpu=1, verbose=True):
+        super().__init__()
+
+        self.num_conf = num_conf
+        self.e_thresh = e_thresh
+        self.rmsd_thresh = rmsd_thresh
+        self.num_cpu = num_cpu
+        self.verbose = verbose
+
+    def _prepare_molecule(self, mol):
+        return NotImplemented
+
+    def _embedd_conformers(self, mol):
+        mol = self._prepare_molecule(mol)
+        params = AllChem.ETKDGv3()
+        params.numThreads = 0
+        params.maxAttempts = 1000
+        params.pruneRmsThresh = 0.1
+        AllChem.EmbedMultipleConfs(mol, numConfs=self.num_conf, params=params)
+        return mol
+
+    def _optimize_conformers(self, mol):
+        for conf in mol.GetConformers():
+            AllChem.UFFOptimizeMolecule(mol, confId=conf.GetId())
+        return mol
+
+    def _generate_conformers(self, mol):
+        if isinstance(mol, (FailedMolecule, FailedConformer)):
+            return mol
+        try:
+            mol = self._embedd_conformers(mol)
+            if not mol.GetNumConformers():
+                return FailedConformer(mol)
+            mol = self._optimize_conformers(mol)
+        except Exception:
+            return FailedConformer(mol)
+
+        if self.e_thresh is not None:
+            mol = filter_by_energy(mol, self.e_thresh)
+
+        if self.rmsd_thresh is not None:
+            mol = filter_by_rmsd(mol, self.rmsd_thresh)
+
+        return mol
+
+    def run(self, list_of_mols):
+        with tqdm(total=len(list_of_mols), desc="Generating conformers", disable=not self.verbose) as progress_bar:
+            # Define a custom callback to update the tqdm bar
+            class TqdmCallback(joblib.parallel.BatchCompletionCallBack):
+                def __call__(self, *args, **kwargs):
+                    progress_bar.update(self.batch_size)
+                    return super().__call__(*args, **kwargs)
+
+            # Patch joblib to use our callback
+            old_callback = joblib.parallel.BatchCompletionCallBack
+            joblib.parallel.BatchCompletionCallBack = TqdmCallback
+
+            try:
+                results = Parallel(n_jobs=self.num_cpu)(
+                    delayed(self._generate_conformers)(mol) for mol in list_of_mols
+                )
+            finally:
+                joblib.parallel.BatchCompletionCallBack = old_callback  # Restore
+
+        return results
+
+
+def filter_by_energy(mol, e_thresh=1):
+    conf_energy_list = []
+    for conf in mol.GetConformers():
+        ff = AllChem.UFFGetMoleculeForceField(mol, confId=conf.GetId())
+        if ff is None:
+            continue
+        conf_energy_list.append((conf.GetId(), ff.CalcEnergy()))
+    conf_energy_list = sorted(conf_energy_list, key=lambda x: x[1])
+
+    min_energy = conf_energy_list[0][1]
+    for conf_id, conf_energy in conf_energy_list[1:]:
+        if conf_energy - min_energy >= e_thresh:
+            mol.RemoveConformer(conf_id)
+
+    return mol
+
+
+def filter_by_rmsd(mol, rmsd_thresh=2):
+    conf_ids = [conf.GetId() for conf in mol.GetConformers()]
+    to_remove = set()
+
+    for i, conf_id_i in enumerate(conf_ids):
+        if conf_id_i in to_remove:
+            continue
+        for conf_id_j in conf_ids[i + 1:]:
+            if conf_id_j in to_remove:
+                continue
+            rmsd = rdMolAlign.GetConformerRMS(mol, conf_id_i, conf_id_j, prealigned=False)
+            if rmsd < rmsd_thresh:
+                to_remove.add(conf_id_j)
+
+    for conf_id in to_remove:
+        mol.RemoveConformer(conf_id)
+
+    return mol

qsarmil-0.1.0/qsarmil/conformer/rdkit.py

@@ -0,0 +1,17 @@
+from rdkit import Chem
+from rdkit.Chem import AllChem
+from qsarmil.conformer.base import ConformerGenerator
+
+
+class RDKitConformerGenerator(ConformerGenerator):
+    def __init__(self, num_conf=10, e_thresh=None, num_cpu=1, verbose=True):
+        super().__init__(num_conf=num_conf, e_thresh=e_thresh, num_cpu=num_cpu, verbose=verbose)
+
+    def _prepare_molecule(self, mol):
+        mol = Chem.AddHs(mol)
+        return mol
+
+    def _embedd_conformers(self, mol):
+        mol = self._prepare_molecule(mol)
+        AllChem.EmbedMultipleConfs(mol, numConfs=self.num_conf, maxAttempts=700, randomSeed=42)
+        return mol

qsarmil-0.1.0/qsarmil/data/fragment.py

@@ -0,0 +1,115 @@
+from rdkit import Chem
+from rdkit.Chem import Descriptors, rdMolDescriptors, BRICS
+import numpy as np
+from typing import List, Tuple
+from rdkit import Chem
+from rdkit.Chem import Draw
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Supported RDKit molecular property functions
+PROPERTY_FUNCTIONS = {
+    "LogP": Descriptors.MolLogP,
+    "MolWt": Descriptors.MolWt,
+    "TPSA": rdMolDescriptors.CalcTPSA,
+    "NumHDonors": Descriptors.NumHDonors,
+    "NumHAcceptors": Descriptors.NumHAcceptors,
+    "MolMR": Descriptors.MolMR,
+    "NumRotatableBonds": Descriptors.NumRotatableBonds,
+    "RingCount": Descriptors.RingCount,
+    "FractionCSP3": Descriptors.FractionCSP3,
+}
+
+def create_fragment_bags(
+    mols: List[Chem.Mol],
+    bag_size: int = 5,
+    property_name: str = "LogP",
+    random_state: int = 42
+) -> Tuple[List[List[Chem.Mol]], List[float], List[List[float]]]:
+    """
+    Create bags of BRICS fragments and compute bag-level label as the sum of a chosen molecular property.
+
+    Parameters:
+    - mols: list of RDKit Mol objects
+    - fragments_per_bag: number of fragments to sample per molecule
+    - property_name: RDKit property to calculate per fragment (e.g., "LogP", "MolWt")
+    - random_state: for reproducible fragment sampling
+
+    Returns:
+    - bags: list of bags (each a list of fragment Mol objects)
+    - labels: list of total property per bag
+    - fragment_props: list of property values per fragment per bag
+    """
+
+    if property_name not in PROPERTY_FUNCTIONS:
+        raise ValueError(f"Unsupported property: {property_name}")
+
+    get_property = PROPERTY_FUNCTIONS[property_name]
+    rng = np.random.RandomState(random_state)
+
+    bags = []
+    labels = []
+    fragment_props = []
+
+    for mol in mols:
+        if mol is None:
+            continue
+
+        # Generate BRICS fragments
+        frag_smiles_set = BRICS.BRICSDecompose(mol)
+        frags = [Chem.MolFromSmiles(smi) for smi in frag_smiles_set if smi]
+        frags = [f for f in frags if f is not None]
+
+        if len(frags) < bag_size:
+            continue  # skip molecules with too few fragments
+
+        # Randomly sample fragments
+        sampled_frags = rng.choice(frags, size=bag_size, replace=False).tolist()
+
+        # Compute property per fragment
+        props = [get_property(f) for f in sampled_frags]
+        total = float(np.sum(props))
+
+        bags.append(sampled_frags)
+        labels.append(total)
+        fragment_props.append(props)
+
+    return bags, labels, fragment_props
+
+
+def display_fragments_with_weights(fragments, props, pred_weights, sort=True, max_fragments=16, title=None):
+
+    props = np.array(props)
+    pred_weights = np.array(pred_weights)
+
+    if sort:
+        sorted_idx = np.argsort(props)[::-1]
+        fragments = [fragments[i] for i in sorted_idx]
+        props = props[sorted_idx]
+        pred_weights = pred_weights[sorted_idx]
+
+    fragments = fragments[:max_fragments]
+    props = props[:max_fragments]
+    pred_weights = pred_weights[:max_fragments]
+
+    cols = 4
+    rows = (len(fragments) + cols - 1) // cols
+
+    fig, axes = plt.subplots(rows, cols, figsize=(cols * 3, rows * 3))
+    axes = axes.flatten()
+
+    for ax in axes[len(fragments):]:
+        ax.axis('off')
+
+    for i, (frag, prop, weight) in enumerate(zip(fragments, props, pred_weights)):
+        ax = axes[i]
+        img = Draw.MolToImage(frag, size=(150, 150))
+        ax.imshow(img)
+        ax.set_title(f"True prop: {prop:.3f}\nWeight: {weight:.2f}", fontsize=10)
+        ax.axis('off')
+
+    if title:
+        fig.suptitle(title, fontsize=16)
+
+    plt.tight_layout(rect=[0, 0, 1, 0.95])  # leave space for suptitle
+    plt.show()

qsarmil-0.1.0/qsarmil/descriptor/__init__.py

@@ -0,0 +1 @@
+from .rdkit import RDKitGEOM, RDKitAUTOCORR, RDKitRDF, RDKitMORSE, RDKitWHIM, RDKitGETAWAY

qsarmil-0.1.0/qsarmil/descriptor/rdkit.py

@@ -0,0 +1,76 @@
+import numpy as np
+from rdkit.Chem import Descriptors3D
+
+def validate_desc_vector(x):
+
+    # nan values
+    if np.isnan(x).sum() > 0:
+        imp = np.mean(x[~np.isnan(x)])
+        x = np.where(np.isnan(x), imp, x)  # TODO temporary solution, should be revised
+    # extreme dsc values
+    if (abs(x) >= 10 ** 25).sum() > 0:
+        imp = np.mean(x[abs(x) <= 10 ** 25])
+        x = np.where(abs(x) <= 10 ** 25, x, imp)
+    return x
+
+class RDKitDescriptor3D:
+    def __init__(self, desc_name=None):
+        super().__init__()
+
+        if desc_name:
+            self.transformer = getattr(Descriptors3D.rdMolDescriptors, desc_name)
+
+    def __call__(self, mol, conformer_id=None):
+        x = np.array(self.transformer(mol, confId=conformer_id))
+        x = validate_desc_vector(x)
+        return x
+
+class RDKitGEOM(RDKitDescriptor3D):
+    def __init__(self):
+        super().__init__()
+
+        self.columns = ['CalcAsphericity',
+                        'CalcEccentricity',
+                        'CalcInertialShapeFactor',
+                        'CalcNPR1',
+                        'CalcNPR2',
+                        'CalcPMI1',
+                        'CalcPMI2',
+                        'CalcPMI3',
+                        'CalcRadiusOfGyration',
+                        'CalcSpherocityIndex',
+                        'CalcPBF']
+
+    def __call__(self, mol, conformer_id=None):
+        x = []
+        for desc_name in self.columns:
+            transformer = getattr(Descriptors3D.rdMolDescriptors, desc_name)
+            x.append(transformer(mol, confId=conformer_id))
+        x = np.array(x)
+        x = validate_desc_vector(x)
+        return x
+
+
+class RDKitAUTOCORR(RDKitDescriptor3D):
+    def __init__(self):
+        super().__init__('CalcAUTOCORR3D')
+
+
+class RDKitRDF(RDKitDescriptor3D):
+    def __init__(self):
+        super().__init__('CalcRDF')
+
+
+class RDKitMORSE(RDKitDescriptor3D):
+    def __init__(self):
+        super().__init__('CalcMORSE')
+
+
+class RDKitWHIM(RDKitDescriptor3D):
+    def __init__(self):
+        super().__init__('CalcWHIM')
+
+
+class RDKitGETAWAY(RDKitDescriptor3D):
+    def __init__(self):
+        super().__init__('CalcGETAWAY')

qsarmil-0.1.0/qsarmil/descriptor/wrapper.py

@@ -0,0 +1,34 @@
+import numpy as np
+from qsarmil.utils.logging import FailedDescriptor
+
+
+class DescriptorWrapper:
+    def __init__(self, transformer):
+        super().__init__()
+        self.transformer = transformer
+
+    def _ce2bag(self, mol):
+        bag = []
+        for conf in mol.GetConformers():
+            x = self.transformer(mol, conformer_id=conf.GetId())
+            bag.append(x)
+
+        return np.array(bag)
+
+    def transform(self, list_of_mols):
+        list_of_bags = []
+        for mol_id, mol in enumerate(list_of_mols):
+
+            try:
+                x = self._ce2bag(mol)
+            except Exception as e:
+                print(e)
+                x = FailedDescriptor(mol)
+            list_of_bags.append(x)
+
+        return list_of_bags
+
+
+
+
+

qsarmil-0.1.0/qsarmil/utils/logging.py

@@ -0,0 +1,33 @@
+from rdkit import Chem
+
+from rdkit import RDLogger
+RDLogger.DisableLog('rdApp.*')
+
+
+class FailedMolecule:
+    def __init__(self, smiles):
+        super().__init__()
+        self.smiles = smiles
+
+    def __str__(self):
+        return f'{self.smiles} -> SMILES parsing failed'
+
+
+class FailedConformer:
+    def __init__(self, mol):
+        super().__init__()
+        self.mol = mol
+
+    def __str__(self):
+        smi = Chem.MolToSmiles(self.mol)
+        return f'{smi} -> conformer generation failed'
+
+
+class FailedDescriptor:
+    def __init__(self, mol):
+        super().__init__()
+        self.mol = mol
+
+    def __str__(self):
+        smi = Chem.MolToSmiles(self.mol)
+        return f'{smi} -> descriptor calculation failed'

qsarmil-0.1.0/qsarmil.egg-info/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: qsarmil
+Version: 0.1.0
+Summary: Molecular multi-instance machine learning
+Author-email: Dmitry Zankov <dvzankov@gmail.com>
+License: MIT
+Description-Content-Type: text/x-rst
+Requires-Dist: mikit-learn
+Requires-Dist: rdkit
+Requires-Dist: molfeat
+Requires-Dist: py3Dmol
+Requires-Dist: tqdm
+Requires-Dist: huggingface_hub

qsarmil-0.1.0/qsarmil.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+pyproject.toml
+qsarmil/__init__.py
+qsarmil.egg-info/PKG-INFO
+qsarmil.egg-info/SOURCES.txt
+qsarmil.egg-info/dependency_links.txt
+qsarmil.egg-info/requires.txt
+qsarmil.egg-info/top_level.txt
+qsarmil/conformer/__init__.py
+qsarmil/conformer/base.py
+qsarmil/conformer/rdkit.py
+qsarmil/data/__init__.py
+qsarmil/data/fragment.py
+qsarmil/descriptor/__init__.py
+qsarmil/descriptor/rdkit.py
+qsarmil/descriptor/wrapper.py
+qsarmil/fragment/__init__.py
+qsarmil/fragment/base.py
+qsarmil/fragment/rdkit.py
+qsarmil/utils/__init__.py
+qsarmil/utils/logging.py

qsarmil-0.1.0/qsarmil.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

qsarmil-0.1.0/qsarmil.egg-info/requires.txt

@@ -0,0 +1,6 @@
+mikit-learn
+rdkit
+molfeat
+py3Dmol
+tqdm
+huggingface_hub

qsarmil-0.1.0/qsarmil.egg-info/top_level.txt

@@ -0,0 +1,5 @@
+data
+dist
+michal_data
+new_data
+qsarmil

qsarmil-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+