lazyqsar 0.4__py3-none-any.whl

lazyqsar/__init__.py

@@ -0,0 +1,7 @@
+from .binary.morgan import MorganBinaryClassifier
+from .binary.mordred import MordredBinaryClassifier
+from .binary.classic import ClassicBinaryClassifier
+from .binary.rdkit import RdkitBinaryClassifier
+from .binary.eosembedding import ErsiliaBinaryClassifier
+from .regression.morgan import MorganRegressor
+from .regression.eosembedding import ErsiliaRegressor

lazyqsar/binary/classic.py

@@ -0,0 +1,70 @@
+from flaml import AutoML
+from sklearn.ensemble import RandomForestClassifier
+
+import numpy as np
+import joblib
+
+import shap
+
+from ..descriptors.descriptors import ClassicDescriptor
+
+
+class ClassicBinaryClassifier(object):
+
+    def __init__(self, automl=True, time_budget_sec=20, estimator_list=None):
+        self.time_budget_sec=time_budget_sec
+        self.estimator_list=estimator_list
+        self.model = None
+        self.explainer = None
+        self._automl = automl
+        self.descriptor = ClassicDescriptor()
+        
+    def fit_automl(self, smiles, y):
+        model = AutoML(task="classification", time_budget=self.time_budget_sec)
+        X = self.descriptor.fit(smiles)
+        y = np.array(y)
+        model.fit(X, y, time_budget=self.time_budget_sec, estimator_list=self.estimator_list)
+        self._n_pos = int(np.sum(y))
+        self._n_neg = len(y) - self._n_pos
+        self._auroc = 1-model.best_loss
+        self.meta = {
+            "n_pos": self._n_pos,
+            "n_neg": self._n_neg,
+            "auroc": self._auroc
+        }
+        self.model = model.model.estimator
+        self.model.fit(X, y)
+
+    def fit_default(self, smiles, y):
+        model = RandomForestClassifier()
+        X = self.descriptor.fit(smiles)
+        y = np.array(y)
+        model.fit(X, y)
+        self.model = model
+
+    def fit(self, smiles, y):
+        if self._automl:
+            self.fit_automl(smiles, y)
+        else:
+            self.fit_default(smiles, y)
+
+    def predict(self, smiles):
+        X = self.descriptor.transform(smiles)
+        return self.model.predict(X)
+
+    def predict_proba(self, smiles):
+        X = self.descriptor.transform(smiles)
+        return self.model.predict_proba(X)
+
+    def explain(self, smiles):
+        X = self.descriptor.transform(smiles)
+        if self.explainer is None:
+            self.explainer = shap.Explainer(self.model)
+        shap_values = self.explainer(X, check_additivity=False)
+        return shap_values
+
+    def save(self, path):
+        joblib.dump(self, path)
+
+    def load(self, path):
+        return joblib.load(path)

lazyqsar/binary/eosembedding.py

@@ -0,0 +1,87 @@
+from flaml import AutoML
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.decomposition import PCA
+
+import shap
+
+import numpy as np
+import joblib
+
+from ..descriptors.descriptors import ErsiliaEmbedding
+
+
+class ErsiliaBinaryClassifier(object):
+
+    def __init__(self, automl=True, reduced=False, time_budget_sec=20, estimator_list=None):
+        self.time_budget_sec=time_budget_sec
+        self.estimator_list=estimator_list
+        self.model = None
+        self.reducer=None
+        self.explainer = None
+        self._automl = automl
+        self._reduced = reduced
+        self.descriptor = ErsiliaEmbedding()
+
+    def fit_automl(self, smiles, y):
+        model = AutoML(task="classification", time_budget=self.time_budget_sec)
+        X = np.array(self.descriptor.transform(smiles))
+        y = np.array(y)
+        if self._reduced:
+            self.reducer = PCA(n_components=100)
+            self.reducer.fit(X)
+            X = self.reducer.transform(X)
+        model.fit(X, y, time_budget=self.time_budget_sec, estimator_list=self.estimator_list)
+        self._n_pos = int(np.sum(y))
+        self._n_neg = len(y) - self._n_pos
+        self._auroc = 1-model.best_loss
+        self.meta = {
+            "n_pos": self._n_pos,
+            "n_neg": self._n_neg,
+            "auroc": self._auroc
+        }
+        self.model = model.model.estimator
+        self.model.fit(X, y)
+
+    def fit_default(self, smiles, y):
+        model = RandomForestClassifier()
+        X = np.array(self.descriptor.transform(smiles))
+        y = np.array(y)
+        if self._reduced:
+            self.reducer = PCA(n_components=100)
+            self.reducer.fit(X)
+            X = self.reducer.transform(X)
+        model.fit(X, y)
+        self.model = model
+
+    def fit(self, smiles, y):
+        if self._automl:
+            self.fit_automl(smiles, y)
+        else:
+            self.fit_default(smiles, y)
+
+    def explain(self, smiles):
+        X = self.descriptor.transform(smiles)
+        if self._reduced:
+            X = self.reducer.transform(X)
+        if self.explainer is None:
+            self.explainer = shap.Explainer(self.model)
+        shap_values = self.explainer(X, check_additivity=False)
+        return shap_values
+
+    def predict(self, smiles):
+        X = np.array(self.descriptor.transform(smiles))
+        if self._reduced:
+            X = self.reducer.transform(X)
+        return self.model.predict(X)
+
+    def predict_proba(self, smiles):
+        X = np.array(self.descriptor.transform(smiles))
+        if self._reduced:
+            X = self.reducer.transform(X)
+        return self.model.predict_proba(X)
+
+    def save(self, path):
+        joblib.dump(self, path)
+
+    def load(self, path):
+        return joblib.load(path)

lazyqsar/binary/maccs.py

@@ -0,0 +1,70 @@
+from flaml import AutoML
+from sklearn.ensemble import RandomForestClassifier
+
+import numpy as np
+import joblib
+
+import shap
+
+from ..descriptors.descriptors import MaccsDescriptor
+
+
+class MaccsBinaryClassifier(object):
+
+    def __init__(self, automl=True, time_budget_sec=20, estimator_list=None):
+        self.time_budget_sec=time_budget_sec
+        self.estimator_list=estimator_list
+        self.model = None
+        self.explainer = None
+        self._automl = automl
+        self.descriptor = MaccsDescriptor()
+        
+    def fit_automl(self, smiles, y):
+        model = AutoML(task="classification", time_budget=self.time_budget_sec)
+        X = np.array(self.descriptor.fit(smiles))
+        y = np.array(y)
+        model.fit(X, y, time_budget=self.time_budget_sec, estimator_list=self.estimator_list)
+        self._n_pos = int(np.sum(y))
+        self._n_neg = len(y) - self._n_pos
+        self._auroc = 1-model.best_loss
+        self.meta = {
+            "n_pos": self._n_pos,
+            "n_neg": self._n_neg,
+            "auroc": self._auroc
+        }
+        self.model = model.model.estimator
+        self.model.fit(X, y)
+
+    def fit_default(self, smiles, y):
+        model = RandomForestClassifier()
+        X = np.array(self.descriptor.fit(smiles))
+        y = np.array(y)
+        model.fit(X, y)
+        self.model = model
+
+    def fit(self, smiles, y):
+        if self._automl:
+            self.fit_automl(smiles, y)
+        else:
+            self.fit_default(smiles, y)
+
+    def predict(self, smiles):
+        X = np.array(self.descriptor.transform(smiles))
+        return self.model.predict(X)
+
+    def predict_proba(self, smiles):
+        X = np.array(self.descriptor.transform(smiles))
+        return self.model.predict_proba(X)
+
+    def explain(self, smiles):
+        X = self.descriptor.transform(smiles)
+        if self.explainer is None:
+            self.explainer = shap.Explainer(self.model)
+        shap_values = self.explainer(X, check_additivity=False)
+        return shap_values
+
+    def save(self, path):
+        joblib.dump(self, path)
+
+    def load(self, path):
+        return joblib.load(path)

lazyqsar/binary/mordred.py

@@ -0,0 +1,70 @@
+from flaml import AutoML
+from sklearn.ensemble import RandomForestClassifier
+
+import numpy as np
+import joblib
+
+import shap
+
+from ..descriptors.descriptors import MordredDescriptor
+
+
+class MordredBinaryClassifier(object):
+
+    def __init__(self, automl=True, time_budget_sec=20, estimator_list=None):
+        self.time_budget_sec=time_budget_sec
+        self.estimator_list=estimator_list
+        self.model = None
+        self.explainer = None
+        self._automl = automl
+        self.descriptor = MordredDescriptor()
+        
+    def fit_automl(self, smiles, y):
+        model = AutoML(task="classification", time_budget=self.time_budget_sec)
+        X = self.descriptor.fit(smiles)
+        y = np.array(y)
+        model.fit(X, y, time_budget=self.time_budget_sec, estimator_list=self.estimator_list)
+        self._n_pos = int(np.sum(y))
+        self._n_neg = len(y) - self._n_pos
+        self._auroc = 1-model.best_loss
+        self.meta = {
+            "n_pos": self._n_pos,
+            "n_neg": self._n_neg,
+            "auroc": self._auroc
+        }
+        self.model = model.model.estimator
+        self.model.fit(X, y)
+
+    def fit_default(self, smiles, y):
+        model = RandomForestClassifier()
+        X = self.descriptor.fit(smiles)
+        y = np.array(y)
+        model.fit(X, y)
+        self.model = model
+
+    def fit(self, smiles, y):
+        if self._automl:
+            self.fit_automl(smiles, y)
+        else:
+            self.fit_default(smiles, y)
+
+    def predict(self, smiles):
+        X = self.descriptor.transform(smiles)
+        return self.model.predict(X)
+
+    def predict_proba(self, smiles):
+        X = self.descriptor.transform(smiles)
+        return self.model.predict_proba(X)
+
+    def explain(self, smiles):
+        X = self.descriptor.transform(smiles)
+        if self.explainer is None:
+            self.explainer = shap.Explainer(self.model)
+        shap_values = self.explainer(X, check_additivity=False)
+        return shap_values
+
+    def save(self, path):
+        joblib.dump(self, path)
+
+    def load(self, path):
+        return joblib.load(path)

lazyqsar/binary/morgan.py

@@ -0,0 +1,87 @@
+from flaml import AutoML
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.decomposition import PCA
+
+import shap
+
+import numpy as np
+import joblib
+
+from ..descriptors.descriptors import MorganDescriptor
+
+
+class MorganBinaryClassifier(object):
+
+    def __init__(self, automl=True, reduced=False, time_budget_sec=20, estimator_list=None):
+        self.time_budget_sec=time_budget_sec
+        self.estimator_list=estimator_list
+        self.model = None
+        self.reducer = None
+        self.explainer = None
+        self._automl = automl
+        self._reduced =reduced
+        self.descriptor = MorganDescriptor()
+
+    def fit_automl(self, smiles, y):
+        model = AutoML(task="classification", time_budget=self.time_budget_sec)
+        X = np.array(self.descriptor.fit(smiles))
+        y = np.array(y)
+        if self._reduced:
+            self.reducer = PCA(n_components=100)
+            self.reducer.fit(X)
+            X = self.reducer.transform(X)
+        model.fit(X, y, time_budget=self.time_budget_sec, estimator_list=self.estimator_list)
+        self._n_pos = int(np.sum(y))
+        self._n_neg = len(y) - self._n_pos
+        self._auroc = 1-model.best_loss
+        self.meta = {
+            "n_pos": self._n_pos,
+            "n_neg": self._n_neg,
+            "auroc": self._auroc
+        }
+        self.model = model.model.estimator
+        self.model.fit(X, y)
+
+    def fit_default(self, smiles, y):
+        model = RandomForestClassifier()
+        X = np.array(self.descriptor.fit(smiles))
+        if self._reduced:
+            self.reducer = PCA(n_components=100)
+            self.reducer.fit(X)
+            X = self.reducer.transform(X)
+        y = np.array(y)
+        model.fit(X, y)
+        self.model = model
+
+    def fit(self, smiles, y):
+        if self._automl:
+            self.fit_automl(smiles, y)
+        else:
+            self.fit_default(smiles, y)
+
+    def explain(self, smiles):
+        X = self.descriptor.transform(smiles)
+        if self._reduced:
+            X = self.reducer.transform(X)
+        if self.explainer is None:
+            self.explainer = shap.Explainer(self.model)
+        shap_values = self.explainer(X, check_additivity=False)
+        return shap_values
+
+    def predict(self, smiles):
+        X = np.array(self.descriptor.transform(smiles))
+        if self._reduced:
+            X = self.reducer.transform(X)
+        return self.model.predict(X)
+
+    def predict_proba(self, smiles):
+        X = np.array(self.descriptor.transform(smiles))
+        if self._reduced:
+            X = self.reducer.transform(X)
+        return self.model.predict_proba(X)
+
+    def save(self, path):
+        joblib.dump(self, path)
+
+    def load(self, path):
+        return joblib.load(path)

lazyqsar/binary/rdkit.py

@@ -0,0 +1,70 @@
+from flaml import AutoML
+from sklearn.ensemble import RandomForestClassifier
+
+import numpy as np
+import joblib
+
+import shap
+
+from ..descriptors.descriptors import RdkitDescriptor
+
+
+class RdkitBinaryClassifier(object):
+
+    def __init__(self, automl=True, time_budget_sec=20, estimator_list=None):
+        self.time_budget_sec=time_budget_sec
+        self.estimator_list=estimator_list
+        self.model = None
+        self.explainer = None
+        self._automl = automl
+        self.descriptor = RdkitDescriptor()
+        
+    def fit_automl(self, smiles, y):
+        model = AutoML(task="classification", time_budget=self.time_budget_sec)
+        X = self.descriptor.fit(smiles)
+        y = np.array(y)
+        model.fit(X, y, time_budget=self.time_budget_sec, estimator_list=self.estimator_list)
+        self._n_pos = int(np.sum(y))
+        self._n_neg = len(y) - self._n_pos
+        self._auroc = 1-model.best_loss
+        self.meta = {
+            "n_pos": self._n_pos,
+            "n_neg": self._n_neg,
+            "auroc": self._auroc
+        }
+        self.model = model.model.estimator
+        self.model.fit(X, y)
+
+    def fit_default(self, smiles, y):
+        model = RandomForestClassifier()
+        X = self.descriptor.fit(smiles)
+        y = np.array(y)
+        model.fit(X, y)
+        self.model = model
+
+    def fit(self, smiles, y):
+        if self._automl:
+            self.fit_automl(smiles, y)
+        else:
+            self.fit_default(smiles, y)
+
+    def predict(self, smiles):
+        X = self.descriptor.transform(smiles)
+        return self.model.predict(X)
+
+    def predict_proba(self, smiles):
+        X = self.descriptor.transform(smiles)
+        return self.model.predict_proba(X)
+
+    def explain(self, smiles):
+        X = self.descriptor.transform(smiles)
+        if self.explainer is None:
+            self.explainer = shap.Explainer(self.model)
+        shap_values = self.explainer(X, check_additivity=False)
+        return shap_values
+
+    def save(self, path):
+        joblib.dump(self, path)
+
+    def load(self, path):
+        return joblib.load(path)