MolGraph

https://molgraph.readthedocs.io/en/latest/
Admin
MolGraph is a Python package for applying graph neural networks (GNNs) on molecular graphs, built...
Tokens:197,210
Snippets:752
Trust Score:9.6
Update:1 day ago
Show doc for...
Tokens:
Raw
### Install MolGraph for GPU

Source: https://molgraph.readthedocs.io/en/latest/get_started/installation.html

Use this command to install MolGraph with GPU support.

```bash
pip install molgraph[gpu]
```

--------------------------------

### Install MolGraph for CPU

Source: https://molgraph.readthedocs.io/en/latest/get_started/installation.html

Use this command to install MolGraph for CPU-only usage.

```bash
pip install molgraph
```

--------------------------------

### Get ESOL dataset with molgraph.chemistry.datasets.get

Source: https://molgraph.readthedocs.io/en/latest/api/chemistry.html

Shows how to obtain a dataset by name using the DatasetFactory.get method. The example retrieves the 'esol' dataset.

```python
>>> esol_dataset = molgraph.chemistry.datasets.get('esol') 
```

--------------------------------

### GradientActivationMapping example usage

Source: https://molgraph.readthedocs.io/en/latest/api/models.html

Shows how to encode molecular graphs, train a GNN model, and generate gradient activation maps using molgraph.models.GradientActivationMapping. The example uses the ESOL dataset and a sequential GCN model.

```python
>>> encoder = molgraph.chemistry.MolecularGraphEncoder(
...     atom_encoder=molgraph.chemistry.Featurizer([
...         molgraph.chemistry.features.Symbol(),
...         molgraph.chemistry.features.Hybridization()
...     ])
... )
>>> esol = molgraph.chemistry.datasets.get('esol')
>>> esol['train']['x'] = encoder(esol['train']['x'])
>>> esol['test']['x'] = encoder(esol['test']['x'])
...
>>> gnn_model = tf.keras.Sequential([
...     molgraph.layers.GCNConv(units=128, name='gcn_conv_1'),
...     molgraph.layers.GCNConv(units=128, name='gcn_conv_2'),
...     molgraph.layers.GCNConv(units=128, name='gcn_conv_3'),
...     molgraph.layers.Readout('mean'),
...     tf.keras.layers.Dense(units=512),
...     tf.keras.layers.Dense(units=1)
... ])
...
>>> gnn_model.compile(optimizer='adam', loss='mse')
>>> _ = gnn_model.fit(
...     esol['train']['x'], esol['train']['y'], epochs=10, verbose=0)
...
>>> gam_model = molgraph.models.GradientActivationMapping(
...     model=gnn_model,
...     discard_negative_values=False,
... )
>>> maps = gam_model(esol['test']['x'].separate())
```

--------------------------------

### GraphAutoEncoder usage example

Source: https://molgraph.readthedocs.io/en/latest/api/models.html

Shows how to create a GraphTensor, adapt embeddings, build an encoder-decoder model, compile, fit, evaluate, and save/load the encoder. The example uses a small graph tensor and trains for 50 epochs.

```python
>>> # Replace this graph_tensor with a large dataset of graphs
>>> # Also accepts featurized graph tensors (via `chemistry.Featurizer`)
>>> graph_tensor = molgraph.GraphTensor(
...     sizes=[5],
...     edge_src=[1, 4, 0, 2, 3, 1, 1, 0],
...     edge_dst=[0, 0, 1, 1, 1, 2, 3, 4],
...     node_feature=['Sym:C|Hyb:SP3', 'Sym:C|Hyb:SP2', 'Sym:O|Hyb:SP2',
...                   'Sym:O|Hyb:SP2', 'Sym:N|Hyb:SP3'],
...     edge_feature=['BonTyp:SINGLE|Rot:1', 'BonTyp:SINGLE|Rot:0',
...                   'BonTyp:SINGLE|Rot:1', 'BonTyp:DOUBLE|Rot:0',
...                   'BonTyp:SINGLE|Rot:0', 'BonTyp:DOUBLE|Rot:0',
...                   'BonTyp:SINGLE|Rot:0', 'BonTyp:SINGLE|Rot:0'],
... )
>>> node_embedding = molgraph.layers.NodeEmbeddingLookup(
...   32, mask_token='[MASK]')
>>> edge_embedding = molgraph.layers.EdgeEmbeddingLookup(
...   32, mask_token='[MASK]')
>>> node_embedding.adapt(graph_tensor)
>>> edge_embedding.adapt(graph_tensor)
>>> # Obtain GraphAutoEncoder model
>>> encoder = tf.keras.Sequential([
...     tf.keras.layers.Input(type_spec=graph_tensor.spec),
...     node_embedding,
...     edge_embedding,
...     molgraph.layers.GATv2Conv(128),
...     molgraph.layers.GATv2Conv(128),
...     molgraph.layers.GATv2Conv(128),
... ])
>>> decoder = molgraph.layers.DotProductIncident(normalize=True)
>>> gae = molgraph.models.GraphAutoEncoder(encoder, decoder)
>>> gae.compile('adam')
>>> _ = gae.fit(graph_tensor, batch_size=32, epochs=50, verbose=0)
>>> reconstruction_loss = gae.evaluate(graph_tensor, verbose=0)
>>> encoder.save( 
...     '/tmp/my_pretrained_encoder_model'
... )
>>> loaded_encoder = tf.saved_model.load( 
...     '/tmp/my_pretrained_encoder_model'
... )
```

--------------------------------

### DMPNN usage example

Source: https://molgraph.readthedocs.io/en/latest/api/models.html

Shows how to create a GraphTensor, build a functional model with DMPNN, and make predictions. The example outputs a prediction shape of (2, 10).

```python
>>> # Obtain GraphTensor
>>> graph_tensor = molgraph.GraphTensor(
...     sizes=[2, 3],
...     node_feature=[[1., 0.], [1., 0.], [1., 0.], [1., 0.], [0., 1.]],
...     edge_feature=[[1., 0.], [0., 1.], [0., 1.], [0., 1.],
...                   [1., 0.], [0., 1.], [1., 0.], [0., 1.]],
...     edge_src=[1, 0, 3, 4, 2, 4, 3, 2],
...     edge_dst=[0, 1, 2, 2, 3, 3, 4, 4],
... )
>>> # Build Functional model
>>> inputs = tf.keras.layers.Input(type_spec=graph_tensor.spec)
>>> x = molgraph.models.DMPNN(units=32, name='dmpnn')(inputs)
>>> x = molgraph.layers.Readout(name='readout')(x)
>>> outputs = tf.keras.layers.Dense(10, activation='sigmoid')(x)
>>> dmpnn_classifier = tf.keras.Model(inputs, outputs)
>>> # Make predictions
>>> preds = dmpnn_classifier.predict(graph_tensor, verbose=0)
>>> preds.shape
(2, 10)
```

--------------------------------

### GINConv basic usage example

Source: https://molgraph.readthedocs.io/en/latest/api/layers.html

Shows how to create a GraphTensor and a sequential model with three GINConv layers and a Readout layer. The output shape is TensorShape([2, 16]).

```python
>>> graph_tensor = molgraph.GraphTensor(
...     sizes=[2, 3],
...     node_feature=[[1., 0.], [1., 0.], [1., 0.], [1., 0.], [0., 1.]],
...     edge_src=[1, 0, 3, 4, 2, 4, 3, 2],
...     edge_dst=[0, 1, 2, 2, 3, 3, 4, 4],
... )
>>> gnn_model = tf.keras.Sequential([
...     molgraph.layers.GINConv(units=16),
...     molgraph.layers.GINConv(units=16),
...     molgraph.layers.GINConv(units=16),
...     molgraph.layers.Readout(),
... ])
>>> gnn_model(graph_tensor).shape
TensorShape([2, 16])
```

--------------------------------

### GTConv basic usage example

Source: https://molgraph.readthedocs.io/en/latest/api/layers.html

Shows how to instantiate a GTConv layer within a tf.keras.Sequential model and apply it to a GraphTensor. The model outputs a TensorShape of [2, 16].

```python
>>> graph_tensor = molgraph.GraphTensor(
...     sizes=[2, 3],
...     node_feature=[[1., 0.], [1., 0.], [1., 0.], [1., 0.], [0., 1.]],
...     edge_src=[1, 0, 3, 4, 2, 4, 3, 2],
...     edge_dst=[0, 1, 2, 2, 3, 3, 4, 4],
... )
>>> gnn_model = tf.keras.Sequential([
...     molgraph.layers.GTConv(units=16),
...     molgraph.layers.GTConv(units=16),
...     molgraph.layers.GTConv(units=16),
...     molgraph.layers.Readout(),
... ])
>>> gnn_model(graph_tensor).shape
TensorShape([2, 16])
```

--------------------------------

### Setup and imports for DTNN QM7 benchmark

Source: https://molgraph.readthedocs.io/en/latest/examples/tutorials/06_benchmark-DTNN-QM7.html

Adds the project root to the Python path and imports necessary libraries including pandas, numpy, matplotlib, tensorflow, and molgraph modules for benchmarking.

```python
import sys
sys.path.append('../../../../')

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow import keras


from molgraph.chemistry.benchmark import configs
from molgraph.chemistry.benchmark import tf_records
from molgraph.chemistry import datasets
```

--------------------------------

### GraphSageConv usage example

Source: https://molgraph.readthedocs.io/en/latest/api/layers.html

Shows how to create a GraphTensor and a Keras Sequential model with three GraphSageConv layers and a Readout layer, then call the model to get output shape TensorShape([2, 16]).

```python
>>> graph_tensor = molgraph.GraphTensor(
...     sizes=[2, 3],
...     node_feature=[[1., 0.], [1., 0.], [1., 0.], [1., 0.], [0., 1.]],
...     edge_src=[1, 0, 3, 4, 2, 4, 3, 2],
...     edge_dst=[0, 1, 2, 2, 3, 3, 4, 4],
... )
>>> gnn_model = tf.keras.Sequential([
...     molgraph.layers.GraphSageConv(units=16),
...     molgraph.layers.GraphSageConv(units=16),
...     molgraph.layers.GraphSageConv(units=16),
...     molgraph.layers.Readout(),
... ])
>>> gnn_model(graph_tensor).shape
TensorShape([2, 16])
```

--------------------------------

### GINConv.from_config

Source: https://molgraph.readthedocs.io/en/latest/api/layers.html

Initializes and builds the layer based on a configuration dictionary.

```APIDOC
## GINConv.from_config

### Description
Initializes and builds the layer based on a configuration.

### Method
from_config (classmethod)

### Parameters
#### Parameters
- **config** (dict) - Required - A Python dictionary of parameters to initialize and build a layer instance. The config is usually obtained from `get_config()` of another layer instance (of the same class).

### Returns
A layer instance.
```

--------------------------------

### GCNIIConv.from_config

Source: https://molgraph.readthedocs.io/en/latest/api/layers.html

Initializes and builds the layer based on a configuration.

```APIDOC
## GCNIIConv.from_config

### Description
Initializes and builds the layer based on a configuration.

### Method
from_config (classmethod)

### Parameters
- **config** (dict) - Required - A Python dictionary of parameters to initialize and build a layer instance. The config is usually obtained from `get_config()` of another layer instance (of the same class).

### Returns
- **layer instance** - A layer instance.
```

--------------------------------

### GCNConv.from_config(config)

Source: https://molgraph.readthedocs.io/en/latest/api/layers.html

Initializes and builds the layer based on a configuration.

```APIDOC
## GCNConv.from_config(config)

### Description
Initializes and builds the layer based on a configuration.

### Method
from_config (classmethod)

### Parameters
- **config** (dict) - Required - A Python dictionary of parameters to initialize and build a layer instance. The config is usually obtained from `get_config()` of another layer instance (of the same class).

### Returns
- **layer instance** - A layer instance.
```

--------------------------------

### GatedGCNConv.from_config

Source: https://molgraph.readthedocs.io/en/latest/api/layers.html

Initializes and builds the layer based on a configuration.

```APIDOC
## from_config(config)

### Description
Initializes and builds the layer based on a configuration.

### Parameters
- **config** (dict) - Required - A Python dictionary of parameters to initialize and build a layer instance. The config is usually obtained from `get_config()` of another layer instance (of the same class).

### Returns
- **A layer instance** - A layer instance.
```

--------------------------------

### SetGatherReadout usage example

Source: https://molgraph.readthedocs.io/en/latest/api/layers.html

Shows how to use molgraph.layers.SetGatherReadout in a tf.keras.Sequential model. The layer doubles the output dimension (from 2 to 4) as noted in the comment. The example creates a GraphTensor with node features and edge indices.

```python
>>> graph_tensor = molgraph.GraphTensor(
...     sizes=[2, 3],
...     node_feature=[[1., 0.], [1., 0.], [1., 0.], [1., 0.], [0., 1.]],
...     edge_src=[1, 0, 3, 4, 2, 4, 3, 2],
...     edge_dst=[0, 1, 2, 2, 3, 3, 4, 4],
... )
>>> model = tf.keras.Sequential([
...     # molgraph.layers.GCNConv(2),
...     molgraph.layers.SetGatherReadout()
... ])
>>> # Note: SetGatherReadout doubles output dim (from 2 to 4)
>>> model(graph_tensor).shape
TensorShape([2, 4])
```

--------------------------------

### AttentiveFPConv.from_config

Source: https://molgraph.readthedocs.io/en/latest/api/layers.html

Initializes and builds the layer based on a configuration.

```APIDOC
## from_config(config)

### Description
Initializes and builds the layer based on a configuration.

### Method
from_config (class method)

### Parameters
- **config** (dict) - Required - A Python dictionary of parameters to initialize and build a layer instance. The config is usually obtained from `get_config()` of another layer instance (of the same class).

### Returns
- **layer instance** - A layer instance.

```

--------------------------------

### SmoothGradSaliencyMapping usage example

Source: https://molgraph.readthedocs.io/en/latest/api/models.html

Shows how to encode molecular graphs, train a GNN model, and compute saliency maps with SmoothGradSaliencyMapping. The example uses the ESOL dataset and a sequential GNN model with GCNConv layers.

```python
>>> encoder = molgraph.chemistry.MolecularGraphEncoder(
...     atom_encoder=molgraph.chemistry.Featurizer([
...         molgraph.chemistry.features.Symbol(),
...         molgraph.chemistry.features.Hybridization()
...     ])
... )
>>> esol = molgraph.chemistry.datasets.get('esol')
>>> esol['train']['x'] = encoder(esol['train']['x'])
>>> esol['test']['x'] = encoder(esol['test']['x'])
...
>>> gnn_model = tf.keras.Sequential([
...     molgraph.layers.GCNConv(units=128, name='gcn_conv_1'),
...     molgraph.layers.GCNConv(units=128, name='gcn_conv_2'),
...     molgraph.layers.GCNConv(units=128, name='gcn_conv_3'),
...     molgraph.layers.Readout('mean'),
...     tf.keras.layers.Dense(units=512),
...     tf.keras.layers.Dense(units=1)
... ])
...
>>> gnn_model.compile(optimizer='adam', loss='mse')
>>> _ = gnn_model.fit(
...     esol['train']['x'], esol['train']['y'], epochs=10, verbose=0)
...
>>> saliency = molgraph.models.SmoothGradSaliencyMapping(model=gnn_model)
>>> saliency_maps = saliency(esol['test']['x'].separate())
```

--------------------------------

### GTConv.from_config

Source: https://molgraph.readthedocs.io/en/latest/api/layers.html

Initializes and builds the layer based on a configuration dictionary.

```APIDOC
## GTConv.from_config

### Description
Initializes and builds the layer based on a configuration.

### Method
from_config (classmethod)

### Parameters
- **config** (dict) - Required - A Python dictionary of parameters to initialize and build a layer instance. The config is usually obtained from `get_config()` of another layer instance (of the same class).

### Returns
- **layer instance** - A layer instance.
```

--------------------------------

### Create GradientActivationMapping instance

Source: https://molgraph.readthedocs.io/en/latest/examples/walk_through/04_activation_maps.html

Instantiates GradientActivationMapping with the sequential model and a list of layer names ('conv_1' to 'conv_4'). Disables output activation and negative value discarding. Then computes the activation maps by calling the instance on the separated input data.

```python
gam_model = GradientActivationMapping(
    sequential_model,
    ['conv_1', 'conv_2', 'conv_3', 'conv_4'],
    output_activation=None,
    discard_negative_values=False,
)

gam = gam_model(x_data.separate())
```

--------------------------------

### GATv2Conv.from_config

Source: https://molgraph.readthedocs.io/en/latest/api/layers.html

Initializes and builds the layer based on a configuration.

```APIDOC
## GATv2Conv.from_config

### Description
Initializes and builds the layer based on a configuration.

### Parameters
- **config** – (not fully documented in source) – Configuration dictionary.
```

--------------------------------

### MPNN model usage example

Source: https://molgraph.readthedocs.io/en/latest/api/models.html

Shows how to create a GraphTensor, build a functional model with MPNN, and make predictions. The example uses molgraph.GraphTensor, tf.keras.layers.Input, molgraph.models.MPNN, molgraph.layers.SetGatherReadout, and tf.keras.layers.Dense. The output shape is (2, 10).

```python
>>> # Obtain GraphTensor
>>> graph_tensor = molgraph.GraphTensor(
...     sizes=[2, 3],
...     node_feature=[[1., 0.], [1., 0.], [1., 0.], [1., 0.], [0., 1.]],
...     edge_feature=[[1., 0.], [0., 1.], [0., 1.], [0., 1.],
...                   [1., 0.], [0., 1.], [1., 0.], [0., 1.]],
...     edge_src=[1, 0, 3, 4, 2, 4, 3, 2],
...     edge_dst=[0, 1, 2, 2, 3, 3, 4, 4],
... )
>>> # Build Functional model
>>> inputs = tf.keras.layers.Input(type_spec=graph_tensor.spec)
>>> x = molgraph.models.MPNN(units=32, steps=4, name='mpnn')(inputs)
>>> x = molgraph.layers.SetGatherReadout(name='readout')(x)
>>> outputs = tf.keras.layers.Dense(10, activation='sigmoid')(x)
>>> mpnn_classifier = tf.keras.Model(inputs, outputs)
>>> # Make predictions
>>> preds = mpnn_classifier.predict(graph_tensor, verbose=0)
>>> preds.shape
(2, 10)
```

--------------------------------

### MPNNConv.from_config

Source: https://molgraph.readthedocs.io/en/latest/api/layers.html

Initializes and builds the layer based on a configuration.

```APIDOC
## MPNNConv.from_config

### Description
Initializes and builds the layer based on a configuration.

### Method
from_config (classmethod)

### Parameters
- **config** (dict) - Required - A Python dictionary of parameters to initialize and build a layer instance. The config is usually obtained from `get_config()` of another layer instance (of the same class).

### Returns
A layer instance.
```

--------------------------------

### GraphTensor propagate example

Source: https://molgraph.readthedocs.io/en/latest/api/tensors.html

Creates a GraphTensor with node features and edge indices, then calls propagate() to perform message passing. The example uses sizes [2,3] and edge lists to define a graph with 5 nodes.

```python
>>> graph_tensor = molgraph.GraphTensor(
...     sizes=[2, 3],
...     node_feature=[
...         [1.0, 0.0],
...         [1.0, 0.0],
...         [1.0, 0.0],
...         [1.0, 0.0],
...         [0.0, 1.0]
...     ],
...     edge_src=[1, 0, 3, 4, 2, 4, 3, 2],
...     edge_dst=[0, 1, 2, 2, 3, 3, 4, 4],
... )
>>> graph_tensor = graph_tensor.propagate()
```

--------------------------------

### GraphVariationalAutoEncoder example usage

Source: https://molgraph.readthedocs.io/en/latest/api/models.html

Shows how to create a GraphTensor, apply node and edge embeddings, build an encoder with GATv2Conv layers, define a decoder, and train/evaluate the GraphVariationalAutoEncoder. The example also demonstrates saving and loading the encoder model.

```python
>>> # Replace this graph_tensor with a large dataset of graphs
>>> # Also accepts featurized graph tensors (via `chemistry.Featurizer`)
>>> graph_tensor = molgraph.GraphTensor(
...     sizes=[5],
...     edge_src=[1, 4, 0, 2, 3, 1, 1, 0],
...     edge_dst=[0, 0, 1, 1, 1, 2, 3, 4],
...     node_feature=['Sym:C|Hyb:SP3', 'Sym:C|Hyb:SP2', 'Sym:O|Hyb:SP2',
...                   'Sym:O|Hyb:SP2', 'Sym:N|Hyb:SP3'],
...     edge_feature=['BonTyp:SINGLE|Rot:1', 'BonTyp:SINGLE|Rot:0',
...                   'BonTyp:SINGLE|Rot:1', 'BonTyp:DOUBLE|Rot:0',
...                   'BonTyp:SINGLE|Rot:0', 'BonTyp:DOUBLE|Rot:0',
...                   'BonTyp:SINGLE|Rot:0', 'BonTyp:SINGLE|Rot:0'],
... )
>>> graph_tensor = graph_tensor.separate()
>>> node_embedding = molgraph.layers.NodeEmbeddingLookup(
...   32, mask_token='[MASK]')
>>> edge_embedding = molgraph.layers.EdgeEmbeddingLookup(
...   32, mask_token='[MASK]')
>>> node_embedding.adapt(graph_tensor)
>>> edge_embedding.adapt(graph_tensor)
>>> # Obtain the encoder of GVAE
>>> encoder_inputs = tf.keras.layers.Input(type_spec=graph_tensor.spec)
>>> encoder_x = node_embedding(encoder_inputs)
>>> encoder_x = edge_embedding(encoder_x)
>>> encoder_x = molgraph.layers.GATv2Conv(128, name='shared_conv')(encoder_x)
>>> encoder_x_mean = molgraph.layers.GATv2Conv(128, name='loc_conv')(encoder_x)
>>> encoder_x_log_var = molgraph.layers.GATv2Conv(128, name='log_var_conv')(encoder_x)
>>> encoder = tf.keras.Model(encoder_inputs, [encoder_x_mean, encoder_x_log_var])
>>> # Obtain the decoder of GVAE
>>> decoder = molgraph.layers.DotProductIncident(normalize=True)
>>> # Obtain, train and evaluate GVAE model
>>> gvae = molgraph.models.GraphVariationalAutoEncoder(encoder, decoder)
>>> gvae.compile('adam')
>>> _ = gvae.fit(graph_tensor, batch_size=32, epochs=50, verbose=0)
>>> total_loss, rec_loss, kl_loss = gvae.evaluate(graph_tensor, verbose=0)
>>> encoder.save( 
...     '/tmp/my_pretrained_encoder_model'
... )
>>> loaded_encoder = tf.saved_model.load( 
...     '/tmp/my_pretrained_encoder_model'
... )
```

--------------------------------

### GMMConv.from_config

Source: https://molgraph.readthedocs.io/en/latest/api/layers.html

Initializes and builds the layer based on a configuration dictionary.

```APIDOC
## GMMConv.from_config

### Description
Initializes and builds the layer based on a configuration.

### Parameters
- **config** (dict) - A Python dictionary of parameters to initialize and build a layer instance. Usually obtained from `get_config()` of another layer instance.

### Returns
- **Layer instance** - A layer instance.
```

--------------------------------

### SegmentPoolingReadout usage example

Source: https://molgraph.readthedocs.io/en/latest/api/layers.html

Shows how to use molgraph.layers.Readout (alias for SegmentPoolingReadout) in a tf.keras.Sequential model to pool node features of a GraphTensor. The example creates a GraphTensor with sizes [2, 3] and node features, then applies the readout layer with mode 'mean', producing a tensor of shape (2, 2).

```python
>>> graph_tensor = molgraph.GraphTensor(
...     sizes=[2, 3],
...     node_feature=[[1., 0.], [1., 0.], [1., 0.], [1., 0.], [0., 1.]],
...     edge_src=[1, 0, 3, 4, 2, 4, 3, 2],
...     edge_dst=[0, 1, 2, 2, 3, 3, 4, 4],
... )
>>> model = tf.keras.Sequential([
...     # molgraph.layers.GCNConv(4),
...     molgraph.layers.Readout('mean') # alias for SegmentPoolingReadout
... ])
>>> model(graph_tensor)
<tf.Tensor: shape=(2, 2), dtype=float32, numpy=
array([[1.        , 0.        ],
       [0.6666667 , 0.33333334]], dtype=float32)>
```

--------------------------------

### GraphMasking pretraining example

Source: https://molgraph.readthedocs.io/en/latest/api/models.html

Example usage of GraphMasking for pretraining a graph transformer encoder on a tokenized molecular graph. It creates a GraphTensor, embeds node and edge features with masking tokens, builds a sequential encoder with GTConv layers, and trains the GraphMasking model. The encoder is then saved and loaded.

```python
>>> # Replace this graph_tensor with a large dataset of graphs
>>> graph_tensor = molgraph.GraphTensor(
...     sizes=[5],
...     edge_src=[1, 4, 0, 2, 3, 1, 1, 0],
...     edge_dst=[0, 0, 1, 1, 1, 2, 3, 4],
...     node_feature=['Sym:C|Hyb:SP3', 'Sym:C|Hyb:SP2', 'Sym:O|Hyb:SP2',
...                   'Sym:O|Hyb:SP2', 'Sym:N|Hyb:SP3'],
...     edge_feature=['BonTyp:SINGLE|Rot:1', 'BonTyp:SINGLE|Rot:0',
...                   'BonTyp:SINGLE|Rot:1', 'BonTyp:DOUBLE|Rot:0',
...                   'BonTyp:SINGLE|Rot:0', 'BonTyp:DOUBLE|Rot:0',
...                   'BonTyp:SINGLE|Rot:0', 'BonTyp:SINGLE|Rot:0'],
... )
>>> node_embedding = molgraph.layers.NodeEmbeddingLookup(
...    32, mask_token='[MASK]')
>>> edge_embedding = molgraph.layers.EdgeEmbeddingLookup(
...    32, mask_token='[MASK]')
>>> node_embedding.adapt(graph_tensor)
>>> edge_embedding.adapt(graph_tensor)
>>> graph_transformer_encoder = tf.keras.Sequential([
...     node_embedding,
...     edge_embedding,
...     molgraph.layers.GTConv(units=32),
...     molgraph.layers.GTConv(units=32),
...     molgraph.layers.GTConv(units=32),
... ])
>>> pretraining_model = molgraph.models.GraphMasking(
...     graph_transformer_encoder,
...     node_feature_masking_rate=0.15,
...     edge_feature_masking_rate=0.15
... )
>>> pretraining_model.compile(
...     optimizer=tf.keras.optimizers.Adam(1e-4),
...     metrics=[
...         tf.keras.metrics.SparseCategoricalAccuracy(name='sparse_acc'),
...     ]
... )
>>> _ = pretraining_model.fit(graph_tensor, epochs=1, verbose=0)
>>> metric_values = pretraining_model.evaluate(graph_tensor, verbose=0)
>>> graph_transformer_encoder.save( 
...     '/tmp/my_pretrained_encoder_model'
... )
>>> loaded_encoder = tf.saved_model.load( 
...     '/tmp/my_pretrained_encoder_model'
... )
```

--------------------------------

### Import libraries and set up environment

Source: https://molgraph.readthedocs.io/en/latest/examples/tutorials/07_benchmark-MPNN-Tox21.html

Imports required Python packages including TensorFlow, Keras, pandas, numpy, matplotlib, and molgraph modules. Also appends the parent directory to sys.path for module resolution.

```python
import sys
sys.path.append('../../../../')

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow import keras


from molgraph.chemistry.benchmark import configs
from molgraph.chemistry.benchmark import tf_records
from molgraph.chemistry import datasets
from molgraph.losses import MaskedBinaryCrossentropy
```

--------------------------------

### NodeReadout usage example

Source: https://molgraph.readthedocs.io/en/latest/api/layers.html

Shows how to use NodeReadout in a Keras Sequential model to aggregate edge states produced by EdgeConv layers. The example creates a GraphTensor with node and edge features, builds a model with two EdgeConv layers followed by NodeReadout, and prints the resulting node feature shape.

```python
>>> graph_tensor = molgraph.GraphTensor(
...     sizes=[2, 3],
...     node_feature=[[1., 0.], [1., 0.], [1., 0.], [1., 0.], [0., 1.]],
...     edge_feature=[[1., 0.], [0., 1.], [0., 1.], [0., 1.],
...                   [1., 0.], [0., 1.], [1., 0.], [0., 1.]],
...     edge_src=[1, 0, 3, 4, 2, 4, 3, 2],
...     edge_dst=[0, 1, 2, 2, 3, 3, 4, 4],
... )
>>> gnn_model = tf.keras.Sequential([
...     molgraph.layers.EdgeConv(16),                           # will produce 'edge_state' component
...     molgraph.layers.EdgeConv(16),                           # will produce 'edge_state' component
...     molgraph.layers.NodeReadout(target='edge_state'),       # target='edge_state' is default
... ])
>>> gnn_model(graph_tensor).node_feature.shape
TensorShape([5, 16])
```
Tokens:
Raw