molcraft 0.1.0a16__py3-none-any.whl → 0.1.0a18__py3-none-any.whl

molcraft/layers.py

@@ -380,11 +380,14 @@ class GraphConv(GraphLayer):
             self._update_final_dense = self.get_dense(self.units)
 
         if not self._normalize:
-            self._normalization = keras.layers.Identity()
+            self._message_norm = keras.layers.Identity()
+            self._update_norm = keras.layers.Identity()
         elif str(self._normalize).lower().startswith('layer'):
-            self._normalization = keras.layers.LayerNormalization()
+            self._message_norm = keras.layers.LayerNormalization()
+            self._update_norm = keras.layers.LayerNormalization()
         else:
-            self._normalization = keras.layers.BatchNormalization()
+            self._message_norm = keras.layers.BatchNormalization()
+            self._update_norm = keras.layers.BatchNormalization()
 
     def propagate(self, tensor: tensors.GraphTensor) -> tensors.GraphTensor:
         """Forward pass.
@@ -430,7 +433,7 @@ class GraphConv(GraphLayer):
         elif add_aggregate:
             update = update.update({'node': {'aggregate': None}})
 
-        if not self._skip_connect and not self._normalize:
+        if not self._skip_connect:
             return update
         
         feature = update.node['feature']
@@ -438,8 +441,6 @@ class GraphConv(GraphLayer):
         if self._skip_connect:
             feature += residual 
 
-        feature = self._normalization(feature)
-
         return update.update({'node': {'feature': feature}})
 
     def message(self, tensor: tensors.GraphTensor) -> tensors.GraphTensor:
@@ -480,6 +481,7 @@ class GraphConv(GraphLayer):
                 axis=-1
             )
         message = self._message_intermediate_dense(message)
+        message = self._message_norm(message)
         message = self._message_intermediate_activation(message)
         message = self._message_final_dense(message)
         return tensor.update({'edge': {'message': message}})
@@ -519,6 +521,7 @@ class GraphConv(GraphLayer):
         """
         aggregate = tensor.node['aggregate']
         node_feature = self._update_intermediate_dense(aggregate)
+        node_feature = self._update_norm(node_feature)
         node_feature = self._update_intermediate_activation(node_feature)
         node_feature = self._update_final_dense(node_feature)
         return tensor.update(
@@ -1312,13 +1315,19 @@ class NodeEmbedding(GraphLayer):
 
     def __init__(
         self, 
-        dim: int = None, 
+        dim: int | None = None, 
+        intermediate_dim: int | None = None,
+        intermediate_activation: str | keras.layers.Activation | None = 'relu',
         normalize: bool = False,
         embed_context: bool = False,
         **kwargs
     ) -> None:
         super().__init__(**kwargs)
         self.dim = dim
+        self._intermediate_dim = intermediate_dim
+        self._intermediate_activation = keras.activations.get(
+            intermediate_activation
+        )
         self._normalize = normalize
         self._embed_context = embed_context
 
@@ -1326,30 +1335,38 @@ class NodeEmbedding(GraphLayer):
         feature_dim = spec.node['feature'].shape[-1]
         if not self.dim:
             self.dim = feature_dim
-        self._node_dense = self.get_dense(self.dim)
-
+        if not self._intermediate_dim:
+            self._intermediate_dim = self.dim * 2 
+        self._node_dense = self.get_dense(
+            self._intermediate_dim, activation=self._intermediate_activation
+        )
         self._has_super = 'super' in spec.node
         has_context_feature = 'feature' in spec.context
         if not has_context_feature:
             self._embed_context = False 
         if self._has_super and not self._embed_context:
-            self._super_feature = self.get_weight(shape=[self.dim], name='super_node_feature')
+            self._super_feature = self.get_weight(
+                shape=[self._intermediate_dim], name='super_node_feature'
+            )
         if self._embed_context:
-            self._context_dense = self.get_dense(self.dim)
-        
+            self._context_dense = self.get_dense(
+                self._intermediate_dim, activation=self._intermediate_activation
+            )
         if not self._normalize:
             self._norm = keras.layers.Identity()
         elif str(self._normalize).lower().startswith('layer'):
             self._norm = keras.layers.LayerNormalization()
         else:
             self._norm = keras.layers.BatchNormalization()
+        self._dense = self.get_dense(self.dim)
 
     def propagate(self, tensor: tensors.GraphTensor) -> tensors.GraphTensor:
         feature = self._node_dense(tensor.node['feature'])
 
         if self._has_super and not self._embed_context:
             super_mask = keras.ops.expand_dims(tensor.node['super'], 1)
-            feature = keras.ops.where(super_mask, self._super_feature, feature)
+            super_feature = self._intermediate_activation(self._super_feature)
+            feature = keras.ops.where(super_mask, super_feature, feature)
 
         if self._embed_context:
             context_feature = self._context_dense(tensor.context['feature'])
@@ -1357,6 +1374,7 @@ class NodeEmbedding(GraphLayer):
             tensor = tensor.update({'context': {'feature': None}})
 
         feature = self._norm(feature)
+        feature = self._dense(feature)
 
         return tensor.update({'node': {'feature': feature}})
 
@@ -1364,6 +1382,10 @@ class NodeEmbedding(GraphLayer):
         config = super().get_config()
         config.update({
             'dim': self.dim,
+            'intermediate_dim': self._intermediate_dim,
+            'intermediate_activation': keras.activations.serialize(
+                self._intermediate_activation
+            ),
             'normalize': self._normalize,
             'embed_context': self._embed_context,
         })
@@ -1381,50 +1403,67 @@ class EdgeEmbedding(GraphLayer):
     def __init__(
         self, 
         dim: int = None, 
+        intermediate_dim: int | None = None,
+        intermediate_activation: str | keras.layers.Activation | None = 'relu',
         normalize: bool = False,
         **kwargs
     ) -> None:
         super().__init__(**kwargs)
         self.dim = dim
+        self._intermediate_dim = intermediate_dim
+        self._intermediate_activation = keras.activations.get(
+            intermediate_activation
+        )
         self._normalize = normalize
 
     def build(self, spec: tensors.GraphTensor.Spec) -> None:
         feature_dim = spec.edge['feature'].shape[-1]
         if not self.dim:
             self.dim = feature_dim
-        self._edge_dense = self.get_dense(self.dim) 
-
-        self._self_loop_feature = self.get_weight(shape=[self.dim], name='self_loop_edge_feature')
-
+        if not self._intermediate_dim:
+            self._intermediate_dim = self.dim * 2 
+        self._edge_dense = self.get_dense(
+            self._intermediate_dim, activation=self._intermediate_activation
+        ) 
+        self._self_loop_feature = self.get_weight(
+            shape=[self._intermediate_dim], name='self_loop_edge_feature'
+        )
         self._has_super = 'super' in spec.edge
         if self._has_super:
-            self._super_feature = self.get_weight(shape=[self.dim], name='super_edge_feature')
-        
+            self._super_feature = self.get_weight(
+                shape=[self._intermediate_dim], name='super_edge_feature'
+            )
         if not self._normalize:
             self._norm = keras.layers.Identity()
         elif str(self._normalize).lower().startswith('layer'):
             self._norm = keras.layers.LayerNormalization()
         else:
             self._norm = keras.layers.BatchNormalization()
+        self._dense = self.get_dense(self.dim)
 
     def propagate(self, tensor: tensors.GraphTensor) -> tensors.GraphTensor:
         feature = self._edge_dense(tensor.edge['feature'])
 
         if self._has_super:
             super_mask = keras.ops.expand_dims(tensor.edge['super'], 1)
-            feature = keras.ops.where(super_mask, self._super_feature, feature)
+            super_feature = self._intermediate_activation(self._super_feature)
+            feature = keras.ops.where(super_mask, super_feature, feature)
 
         self_loop_mask = keras.ops.expand_dims(tensor.edge['source'] == tensor.edge['target'], 1)
-        feature = keras.ops.where(self_loop_mask, self._self_loop_feature, feature)
-
+        self_loop_feature = self._intermediate_activation(self._self_loop_feature)
+        feature = keras.ops.where(self_loop_mask, self_loop_feature, feature)
         feature = self._norm(feature)
-
+        feature = self._dense(feature)
         return tensor.update({'edge': {'feature': feature}})
 
     def get_config(self) -> dict:
         config = super().get_config()
         config.update({
             'dim': self.dim,
+            'intermediate_dim': self._intermediate_dim,
+            'intermediate_activation': keras.activations.serialize(
+                self._intermediate_activation
+            ),
             'normalize': self._normalize,
         })
         return config
@@ -1441,42 +1480,60 @@ class AddContext(GraphLayer):
     def __init__(
         self, 
         field: str = 'feature',
-        drop: bool = True,
+        intermediate_dim: int | None = None,
+        intermediate_activation: str | keras.layers.Activation | None = 'relu',
+        drop: bool = False,
         normalize: bool = False,
         **kwargs
     ) -> None:
         super().__init__(**kwargs)
-        self.field = field
-        self.drop = drop
+        self._field = field
+        self._drop = drop
+        self._intermediate_dim = intermediate_dim
+        self._intermediate_activation = keras.activations.get(
+            intermediate_activation
+        )
         self._normalize = normalize
         
     def build(self, spec: tensors.GraphTensor.Spec) -> None:
         feature_dim = spec.node['feature'].shape[-1]
-        self._context_dense = self.get_dense(feature_dim)
+        if self._intermediate_dim is None:
+            self._intermediate_dim = feature_dim * 2
+        self._intermediate_dense = self.get_dense(
+            self._intermediate_dim, activation=self._intermediate_activation
+        )
+        self._final_dense = self.get_dense(feature_dim)
         if not self._normalize:
-            self._norm = keras.layers.Identity()
+            self._intermediate_norm = keras.layers.Identity()
         elif str(self._normalize).lower().startswith('layer'):
-            self._norm = keras.layers.LayerNormalization()
+            self._intermediate_norm = keras.layers.LayerNormalization()
         else:
-            self._norm = keras.layers.BatchNormalization()
+            self._intermediate_norm = keras.layers.BatchNormalization()
 
     def propagate(self, tensor: tensors.GraphTensor) -> tensors.GraphTensor:
-        context = tensor.context[self.field]
-        context = self._context_dense(context)
-        context = self._norm(context)
+        context = tensor.context[self._field]
+        context = self._intermediate_dense(context)
+        context = self._intermediate_norm(context)
+        context = self._final_dense(context)
         node_feature = ops.scatter_add(
             tensor.node['feature'], tensor.node['super'], context
         )
         data = {'node': {'feature': node_feature}}
-        if self.drop:
-            data['context'] = {self.field: None}
+        if self._drop:
+            data['context'] = {self._field: None}
         return tensor.update(data)
 
     def get_config(self) -> dict:
         config = super().get_config()
-        config['field'] = self.field 
-        config['drop'] = self.drop
-        config['normalize'] = self._normalize
+        config.update({
+            'field': self._field,
+            'intermediate_dim': self._intermediate_dim,
+            'intermediate_activation': keras.activations.serialize(
+                self._intermediate_activation
+            ),
+            'drop': self._drop,
+            'normalize': self._normalize,
+        })
         return config
 
 
@@ -1738,5 +1795,3 @@ def _spec_from_inputs(inputs):
         return spec
     return tensors.GraphTensor.Spec(**nested_specs)
 
-
-GraphTransformer = GTConv

molcraft/models.py

@@ -154,6 +154,7 @@ class GraphModel(layers.GraphLayer, keras.models.Model):
         return graph
     
     def get_config(self):
+        """Obtain model config."""
         config = super().get_config()
         if hasattr(self, '_model_layers') and self._model_layers is not None:
             config['model_layers'] = [
@@ -164,6 +165,7 @@ class GraphModel(layers.GraphLayer, keras.models.Model):
     
     @classmethod
     def from_config(cls, config: dict):
+        """Obtain model from model config."""
         if 'model_layers' in config:
             config['model_layers'] = [
                 keras.saving.deserialize_keras_object(l) 

molcraft/records.py

@@ -14,7 +14,7 @@ from molcraft import featurizers
 
 def write(
     inputs: list[str | tuple], 
-    featurizer: featurizers.Featurizer,
+    featurizer: featurizers.GraphFeaturizer,
     path: str, 
     overwrite: bool = True, 
     num_files: typing.Optional[int] = None, 
@@ -23,10 +23,13 @@ def write(
     device: str = '/cpu:0'
 ) -> None:
     
-    if os.path.isdir(path) and not overwrite:
-        return 
-    
-    os.makedirs(path, exist_ok=True)
+    if os.path.isdir(path):
+        if not overwrite:
+            return
+        else:
+            _remove_files(path)
+    else:
+        os.makedirs(path)
 
     with tf.device(device):
 
@@ -133,7 +136,7 @@ def load_spec(path: str) -> tensors.GraphTensor.Spec:
 def _write_tfrecord(
     inputs, 
     path: str,
-    featurizer: featurizers.Featurizer, 
+    featurizer: featurizers.GraphFeaturizer, 
 ) -> None:
     
     def _write_example(tensor):
@@ -149,11 +152,7 @@ def _write_tfrecord(
                 x = tuple(x)
             tensor = featurizer(x)
             if tensor is not None:
-                if isinstance(tensor, tensors.GraphTensor):
-                    _write_example(tensor)
-                else:
-                    for t in tensor:
-                        _write_example(t)
+                _write_example(tensor)
 
 def _serialize_example(
     feature: dict[str, tf.train.Feature]
@@ -168,8 +167,18 @@ def _parse_example(
 ) -> tf.Tensor:
     out = tf.io.parse_single_example(
         x, features={'feature': tf.io.RaggedFeature(tf.string)})['feature']
-    out = [tf.ensure_shape(tf.io.parse_tensor(x[0], s.dtype), s.shape) for (x, s) in zip(
-        tf.split(out, len(tf.nest.flatten(spec, expand_composites=True))), 
-        tf.nest.flatten(spec, expand_composites=True))]
+    out = [
+        tf.ensure_shape(tf.io.parse_tensor(x[0], s.dtype), s.shape) 
+        for (x, s) in zip(
+            tf.split(out, len(tf.nest.flatten(spec, expand_composites=True))), 
+            tf.nest.flatten(spec, expand_composites=True)
+        )
+    ]
     out = tf.nest.pack_sequence_as(spec, tf.nest.flatten(out), expand_composites=True)
-    return out
+    return out
+
+def _remove_files(path):
+    for filename in os.listdir(path):
+        if filename.endswith('tfrecord') or filename == 'spec.pb':
+            filepath = os.path.join(path, filename)
+            os.remove(filepath)

{molcraft-0.1.0a16.dist-info → molcraft-0.1.0a18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: molcraft
-Version: 0.1.0a16
+Version: 0.1.0a18
 Summary: Graph Neural Networks for Molecular Machine Learning
 Author-email: Alexander Kensert <alexander.kensert@gmail.com>
 License: MIT License
@@ -43,9 +43,9 @@ 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">
+<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. 
+**Deep Learning on Molecules**: A Minimalistic GNN package for Molecular ML.
 
 > [!NOTE]  
 > In progress.
@@ -83,11 +83,12 @@ featurizer = featurizers.MolGraphFeaturizer(
         features.BondType(),
         features.IsRotatable(),
     ],
-    super_atom=True,
+    super_node=True,
     self_loops=True,
+    include_hydrogens=False,
 )
 
-graph = featurizer([('N[C@@H](C)C(=O)O', 2.0), ('N[C@@H](CS)C(=O)O', 1.0)])
+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(
@@ -95,13 +96,13 @@ model = models.GraphModel.from_layers(
         layers.Input(graph.spec),
         layers.NodeEmbedding(dim=128),
         layers.EdgeEmbedding(dim=128),
-        layers.GraphTransformer(units=128),
-        layers.GraphTransformer(units=128),
-        layers.GraphTransformer(units=128),
-        layers.GraphTransformer(units=128),
-        layers.Readout(mode='mean'),
-        keras.layers.Dense(units=1024, activation='relu'),
-        keras.layers.Dense(units=1024, activation='relu'),
+        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)
     ]
 )

molcraft-0.1.0a18.dist-info/RECORD

@@ -0,0 +1,21 @@
+molcraft/__init__.py,sha256=nK5aO2tHHpVmGxS0I5gz7gDmmf3yyyggcGCAKBAjdyU,477
+molcraft/callbacks.py,sha256=x5HnkZhqcFRrW6xdApt_jZ4X08A-0fxcnFKfdmRKa0c,3571
+molcraft/chem.py,sha256=e56qBDuqh8rq_4-UMyp6LCQNxxSx8hZ7gzuz-87DHgw,21652
+molcraft/datasets.py,sha256=Nd2lw5USUZE52vvAiNr-q-n03Y3--NlZlK0NzqHgp-E,4145
+molcraft/descriptors.py,sha256=Cl3KnBPsTST7XLgRLktkX5LwY9MV0P_lUlrt8iPV5no,3508
+molcraft/features.py,sha256=s0WeV8eZcDEypPgC1m37f4s9QkvWIlVgn-L43Cdsa14,13525
+molcraft/featurizers.py,sha256=bD3RFY9eg89-O-Nxgy6gote1zS4cyjOgzdSiSJZJdJE,17664
+molcraft/layers.py,sha256=FanfJGsB4FxHe_uzNw-0RRJMLtgkf_eH5WMIEm3JwfM,64616
+molcraft/losses.py,sha256=qnS2yC5g-O3n_zVea9MR6TNiFraW2yqRgePOisoUP4A,1065
+molcraft/models.py,sha256=2Pc1htT9fCukGd8ZxrvE0rzEHsPBm0pluHw4FZXaUE4,21963
+molcraft/ops.py,sha256=bQbdFDt9waxVCzF5-dkTB6vlpj9eoSt8I4Qg7ZGXbsU,6178
+molcraft/records.py,sha256=0j4EWP55sfnkoQIH5trdaAIevPfVbAtPLrygTRmLyFw,5686
+molcraft/tensors.py,sha256=EOUKx496KUZsjA1zA2ABc7tU_TW3Jv7AXDsug_QsLbA,22407
+molcraft/applications/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+molcraft/applications/chromatography.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+molcraft/applications/proteomics.py,sha256=qy6KTUrpu0MGOgAsbh0mw4ibtZbYQZa1GLlGA6g1ivg,8991
+molcraft-0.1.0a18.dist-info/licenses/LICENSE,sha256=sbVeqlrtZ0V63uYhZGL5dCxUm8rBAOqe2avyA1zIQNk,1074
+molcraft-0.1.0a18.dist-info/METADATA,sha256=glSAlKMG_kYkWKy4slJ7srY9-CVnc4VPcw-J_lh4osM,3930
+molcraft-0.1.0a18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+molcraft-0.1.0a18.dist-info/top_level.txt,sha256=dENV6MfOceshM6MQCgJlcN1ojZkiCL9B4F7XyUge3QM,9
+molcraft-0.1.0a18.dist-info/RECORD,,

molcraft/conformers.py

@@ -1,151 +0,0 @@
-import keras
-
-from molcraft import chem
-
-
-@keras.saving.register_keras_serializable(package="molcraft")
-class ConformerProcessor:
-
-    def get_config(self) -> dict:
-        return {}
-
-    @classmethod
-    def from_config(cls, config: dict):
-        return cls(**config)
-
-    def __call__(self, mol: chem.Mol) -> chem.Mol:
-        raise NotImplementedError
-
-
-@keras.saving.register_keras_serializable(package="molcraft")
-class ConformerEmbedder(ConformerProcessor):
-
-    def __init__(
-        self, 
-        method: str = 'ETKDGv3',
-        num_conformers: int = 5, 
-        **kwargs,
-    ) -> None:
-        self.method = method 
-        self.num_conformers = num_conformers 
-        self.kwargs = kwargs 
-
-    def get_config(self) -> dict:
-        config = {
-            'method': self.method, 
-            'num_conformers': self.num_conformers, 
-        }
-        config.update({
-            k: v for (k, v) in self.kwargs.items()
-        })
-        return config
-    
-    def __call__(self, mol: chem.Mol) -> chem.Mol:
-        return chem.embed_conformers(
-            mol, 
-            method=self.method,
-            num_conformers=self.num_conformers,
-            **self.kwargs,
-        )
-
-
-@keras.saving.register_keras_serializable(package="molcraft")
-class ConformerOptimizer(ConformerProcessor):
-
-    def __init__(
-        self, 
-        method: str = 'UFF',
-        max_iter: int = 200, 
-        ignore_interfragment_interactions: bool = True,
-        vdw_threshold: float = 10.0,
-        **kwargs,
-    ) -> None:
-        self.method = method 
-        self.max_iter = max_iter 
-        self.ignore_interfragment_interactions = ignore_interfragment_interactions
-        self.vdw_threshold = vdw_threshold 
-        self.kwargs = kwargs
-
-    def get_config(self) -> dict:
-        config = {
-            'method': self.method,
-            'max_iter': self.max_iter,
-            'ignore_interfragment_interactions': self.ignore_interfragment_interactions,
-            'vdw_threshold': self.vdw_threshold,
-        }
-        config.update({
-            k: v for (k, v) in self.kwargs.items()
-        })
-        return config
-    
-    def __call__(self, mol: chem.Mol) -> chem.Mol:
-        return chem.optimize_conformers(
-            mol,
-            method=self.method,
-            max_iter=self.max_iter,
-            ignore_interfragment_interactions=self.ignore_interfragment_interactions,
-            vdw_threshold=self.vdw_threshold,
-            **self.kwargs,
-        )
-
-
-@keras.saving.register_keras_serializable(package="molcraft")
-class ConformerPruner(ConformerProcessor):
-    def __init__(
-        self,
-        keep: int = 1,
-        threshold: float = 0.0,
-        energy_force_field: str = 'UFF',
-        **kwargs,
-    ) -> None:
-        self.keep = keep
-        self.threshold = threshold
-        self.energy_force_field = energy_force_field
-        self.kwargs = kwargs
-
-    def get_config(self) -> dict:
-        config = {
-            'keep': self.keep,
-            'threshold': self.threshold,
-            'energy_force_field': self.energy_force_field,
-        }
-        config.update({
-            k: v for (k, v) in self.kwargs.items()
-        })
-        return config
-    
-    def __call__(self, mol: chem.Mol) -> chem.Mol:
-        return chem.prune_conformers(
-            mol,
-            keep=self.keep,
-            threshold=self.threshold,
-            energy_force_field=self.energy_force_field,
-            **self.kwargs,
-        )
-
-
-@keras.saving.register_keras_serializable(package='molcraft')
-class ConformerGenerator(ConformerProcessor):
-
-    def __init__(self, steps: list[ConformerProcessor]) -> None:
-        self.steps = steps
-
-    def get_config(self) -> dict:
-        return {
-            "steps": [
-                keras.saving.serialize_keras_object(step) for step in self.steps
-            ]
-        }
-
-    @classmethod
-    def from_config(cls, config: dict) -> 'ConformerGenerator':
-        steps = [
-            keras.saving.deserialize_keras_object(obj) 
-            for obj in config["steps"]
-        ]
-        return cls(steps)
-
-    def __call__(self, mol: chem.Mol) -> chem.Mol:
-        for step in self.steps:
-            mol = step(mol)
-        return mol

molcraft-0.1.0a16.dist-info/RECORD

@@ -1,21 +0,0 @@
-molcraft/__init__.py,sha256=uo2ze7WMv3VhP0JcJedXDS9UkeEFydlXgSw4l7Xi8E0,464
-molcraft/callbacks.py,sha256=x5HnkZhqcFRrW6xdApt_jZ4X08A-0fxcnFKfdmRKa0c,3571
-molcraft/chem.py,sha256=--4AdZV0TCj_cf5i-TRidNJGSFyab1ksUEMjmDi7zaM,21837
-molcraft/conformers.py,sha256=K6ZtiSUNDN_fwqGP9JrPcwALLFFvlMlF_XejEJH3Sr4,4205
-molcraft/datasets.py,sha256=QKHi9SUBKvJvdkRFmRQNowhrnu35pQqtujuLatOK8bE,4151
-molcraft/descriptors.py,sha256=jJpT0XWu3Tx_bxnwk1rENySRkaM8cMDMaDIjG8KKvtg,3097
-molcraft/features.py,sha256=GwOecLCNUIuGfbIVzsAJH4LikkzWMKj5IT7zSgGTttU,13846
-molcraft/featurizers.py,sha256=8Jmd2yguYmVRyh5wkn6sRzzEENkJ0TqHSlR8qgC4zNY,27131
-molcraft/layers.py,sha256=200Y4QLOXDyHw1bnjoSQ6hZ-zD0vpforv-KQGESAZi8,61733
-molcraft/losses.py,sha256=qnS2yC5g-O3n_zVea9MR6TNiFraW2yqRgePOisoUP4A,1065
-molcraft/models.py,sha256=hKYSV8z65ohRKfPyjjzxZeVjipm064BWeUBGZE0tpyU,21882
-molcraft/ops.py,sha256=bQbdFDt9waxVCzF5-dkTB6vlpj9eoSt8I4Qg7ZGXbsU,6178
-molcraft/records.py,sha256=MbvYkcCunbAmpy_MWXmQ9WBGi2WvwxFUlwQSPKPvSSk,5534
-molcraft/tensors.py,sha256=EOUKx496KUZsjA1zA2ABc7tU_TW3Jv7AXDsug_QsLbA,22407
-molcraft/applications/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-molcraft/applications/proteomics.py,sha256=usZkoYtmTi1BtoP8SigyBNPjxR-nLH1yEsuAdpjvF2M,9009
-molcraft-0.1.0a16.dist-info/licenses/LICENSE,sha256=sbVeqlrtZ0V63uYhZGL5dCxUm8rBAOqe2avyA1zIQNk,1074
-molcraft-0.1.0a16.dist-info/METADATA,sha256=JL32RxGZY92s39EnhonY4mZbvgGvXjcybtV9nXukn4s,3930
-molcraft-0.1.0a16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-molcraft-0.1.0a16.dist-info/top_level.txt,sha256=dENV6MfOceshM6MQCgJlcN1ojZkiCL9B4F7XyUge3QM,9
-molcraft-0.1.0a16.dist-info/RECORD,,