molcraft 0.1.0a25__tar.gz

molcraft-0.1.0a25/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Alexander Kensert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

molcraft-0.1.0a25/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: molcraft
+Version: 0.1.0a25
+Summary: Graph Neural Networks for Molecular Machine Learning
+Author-email: Alexander Kensert <alexander.kensert@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 Alexander Kensert
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/compomics/molcraft
+Keywords: python,machine-learning,deep-learning,graph-neural-networks,molecular-machine-learning,molecular-graphs,computational-chemistry,computational-biology
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tensorflow>=2.16
+Requires-Dist: rdkit>=2023.9.5
+Requires-Dist: pandas>=1.0.3
+Requires-Dist: ipython>=8.12.0
+Provides-Extra: gpu
+Requires-Dist: tensorflow[and-cuda]>=2.16; extra == "gpu"
+Dynamic: license-file
+
+<img src="https://github.com/akensert/molcraft/blob/main/docs/_static/molcraft-logo.png" alt="molcraft-logo" width="90%">
+
+**Deep Learning on Molecules**: A Minimalistic GNN package for Molecular ML.
+
+> [!NOTE]  
+> In progress.
+
+## Installation
+
+For CPU users:
+
+```bash
+pip install --pre molcraft
+```
+
+For GPU users:
+```bash
+pip install --pre molcraft[gpu]
+```
+
+## Examples 
+
+```python
+from molcraft import features
+from molcraft import descriptors
+from molcraft import featurizers 
+from molcraft import layers
+from molcraft import models 
+import keras
+
+featurizer = featurizers.MolGraphFeaturizer(
+    atom_features=[
+        features.AtomType(),
+        features.NumHydrogens(),
+        features.Degree(),
+    ],
+    bond_features=[
+        features.BondType(),
+        features.IsRotatable(),
+    ],
+    super_node=True,
+    self_loops=True,
+    include_hydrogens=False,
+)
+
+graph = featurizer([('N[C@@H](C)C(=O)O', 2.5), ('N[C@@H](CS)C(=O)O', 1.5)])
+print(graph)
+
+model = models.GraphModel.from_layers(
+    [
+        layers.Input(graph.spec),
+        layers.NodeEmbedding(dim=128),
+        layers.EdgeEmbedding(dim=128),
+        layers.GraphConv(units=128),
+        layers.GraphConv(units=128),
+        layers.GraphConv(units=128),
+        layers.GraphConv(units=128),
+        layers.Readout(),
+        keras.layers.Dense(units=1024, activation='elu'),
+        keras.layers.Dense(units=1024, activation='elu'),
+        keras.layers.Dense(1)
+    ]
+)
+
+pred = model(graph)
+print(pred)
+
+# featurizers.save_featurizer(featurizer, '/tmp/featurizer.json')
+# models.save_model(model, '/tmp/model.keras')
+
+# loaded_featurizer = featurizers.load_featurizer('/tmp/featurizer.json')
+# loaded_model = models.load_model('/tmp/model.keras')
+```
+

molcraft-0.1.0a25/README.md

@@ -0,0 +1,74 @@
+<img src="https://github.com/akensert/molcraft/blob/main/docs/_static/molcraft-logo.png" alt="molcraft-logo" width="90%">
+
+**Deep Learning on Molecules**: A Minimalistic GNN package for Molecular ML.
+
+> [!NOTE]  
+> In progress.
+
+## Installation
+
+For CPU users:
+
+```bash
+pip install --pre molcraft
+```
+
+For GPU users:
+```bash
+pip install --pre molcraft[gpu]
+```
+
+## Examples 
+
+```python
+from molcraft import features
+from molcraft import descriptors
+from molcraft import featurizers 
+from molcraft import layers
+from molcraft import models 
+import keras
+
+featurizer = featurizers.MolGraphFeaturizer(
+    atom_features=[
+        features.AtomType(),
+        features.NumHydrogens(),
+        features.Degree(),
+    ],
+    bond_features=[
+        features.BondType(),
+        features.IsRotatable(),
+    ],
+    super_node=True,
+    self_loops=True,
+    include_hydrogens=False,
+)
+
+graph = featurizer([('N[C@@H](C)C(=O)O', 2.5), ('N[C@@H](CS)C(=O)O', 1.5)])
+print(graph)
+
+model = models.GraphModel.from_layers(
+    [
+        layers.Input(graph.spec),
+        layers.NodeEmbedding(dim=128),
+        layers.EdgeEmbedding(dim=128),
+        layers.GraphConv(units=128),
+        layers.GraphConv(units=128),
+        layers.GraphConv(units=128),
+        layers.GraphConv(units=128),
+        layers.Readout(),
+        keras.layers.Dense(units=1024, activation='elu'),
+        keras.layers.Dense(units=1024, activation='elu'),
+        keras.layers.Dense(1)
+    ]
+)
+
+pred = model(graph)
+print(pred)
+
+# featurizers.save_featurizer(featurizer, '/tmp/featurizer.json')
+# models.save_model(model, '/tmp/model.keras')
+
+# loaded_featurizer = featurizers.load_featurizer('/tmp/featurizer.json')
+# loaded_model = models.load_model('/tmp/model.keras')
+```
+

molcraft-0.1.0a25/molcraft/__init__.py

@@ -0,0 +1,17 @@
+__version__ = '0.1.0a25'
+
+import os
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
+
+from molcraft import chem
+from molcraft import features
+from molcraft import descriptors
+from molcraft import featurizers
+from molcraft import layers 
+from molcraft import models 
+from molcraft import ops 
+from molcraft import records 
+from molcraft import tensors
+from molcraft import callbacks
+from molcraft import datasets
+from molcraft import losses

molcraft-0.1.0a25/molcraft/callbacks.py

@@ -0,0 +1,100 @@
+import warnings
+import keras
+import numpy as np
+
+
+class TensorBoard(keras.callbacks.TensorBoard):
+
+    def _log_weights(self, epoch):
+        with self._train_writer.as_default():
+            for layer in self.model.layers:
+                for weight in layer.weights:
+                    # Use weight.path istead of weight.name to distinguish
+                    # weights of different layers.
+                    histogram_weight_name = weight.path + "/histogram"
+                    self.summary.histogram(
+                        histogram_weight_name, weight, step=epoch
+                    )
+                    if self.write_images:
+                        image_weight_name = weight.path + "/image"
+                        self._log_weight_as_image(
+                            weight, image_weight_name, epoch
+                        )
+            self._train_writer.flush()
+
+
+class LearningRateDecay(keras.callbacks.LearningRateScheduler):
+
+    def __init__(self, rate: float, delay: int = 0, **kwargs):
+
+        def lr_schedule(epoch: int, lr: float):
+            if epoch < delay:
+                return float(lr)
+            return float(lr * keras.ops.exp(-rate))
+        
+        super().__init__(schedule=lr_schedule, **kwargs)
+
+
+class Rollback(keras.callbacks.Callback):
+    """Rollback callback.
+
+    Currently, this callback simply restores the model and (optionally) the optimizer 
+    variables if current loss deviates too much from the best observed loss.
+
+    This callback might be useful in situations where the loss tend to spike and put 
+    the model in an undesired/problematic high-loss parameter space.
+
+    Args:
+        tolerance (float):
+            The threshold for when the restoration is triggered. The devaiation is 
+            calculated as follows: (current_loss - best_loss) / best_loss.
+    """
+
+    def __init__(
+        self,
+        tolerance: float = 0.5,
+        rollback_optimizer: bool = True,
+    ):
+        super().__init__()
+        self.tolerance = tolerance
+        self.rollback_optimizer = rollback_optimizer
+
+    def on_train_begin(self, logs=None):
+        self._rollback_weights = self._get_model_vars()
+        if self.rollback_optimizer:
+            self._rollback_optimizer_vars = self._get_optimizer_vars()
+        self._rollback_loss = float('inf')
+
+    def on_epoch_end(self, epoch: int, logs: dict = None):
+        current_loss = logs.get('val_loss', logs.get('loss'))
+        deviation = (current_loss - self._rollback_loss) / self._rollback_loss
+
+        if np.isnan(current_loss) or np.isinf(current_loss):
+            self._rollback()
+            # Rolling back model because of nan or inf loss
+            return
+
+        if deviation > self.tolerance:
+            self._rollback()
+            # Rolling back model because of large loss deviation.
+            return
+
+        if current_loss < self._rollback_loss:
+            self._save_state(current_loss)
+
+    def _save_state(self, current_loss: float) -> None:
+        self._rollback_loss = current_loss
+        self._rollback_weights = self._get_model_vars()
+        if self.rollback_optimizer:
+            self._rollback_optimizer_vars = self._get_optimizer_vars()
+
+    def _rollback(self) -> None:
+        self.model.set_weights(self._rollback_weights)
+        if self.rollback_optimizer:
+            self.model.optimizer.set_weights(self._rollback_optimizer_vars)
+
+    def _get_optimizer_vars(self):
+        return [v.numpy() for v in self.model.optimizer.variables]
+
+    def _get_model_vars(self):
+        return self.model.get_weights()