diff --git a/README.md b/README.md index d51ca559..9f732e23 100644 --- a/README.md +++ b/README.md @@ -299,7 +299,7 @@ You can find a [table](training/results/README.md) of common benchmark datasets Some known issues to be aware of, if using and making new models or layers with `kgcnn`. * Jagged or nested Tensors loading into models for PyTorch backend is not working. -* Dataloader for Jax is not yet implemented. +* Dataloader for Jax is implemented but does not provide all functionalities like output padding or dictionary inputs. * ForceModel does not support all tensor types and does not have Scaler layer yet. * BatchNormalization layer dos not support padding yet. diff --git a/docs/source/literature.ipynb b/docs/source/literature.ipynb index bee3cd18..ad2e22cc 100644 --- a/docs/source/literature.ipynb +++ b/docs/source/literature.ipynb @@ -21,18 +21,33 @@ "id": "f9c829a4", "metadata": {}, "source": [ - "* **[GCN](https://github.com/aimat-lab/gcnn_keras/blob/master/kgcnn/literature/GCN)**: [Semi-Supervised Classification with Graph Convolutional Networks](https://arxiv.org/abs/1609.02907) by Kipf et al. (2016)\n", - "* **[Schnet](https://github.com/aimat-lab/gcnn_keras/blob/master/kgcnn/literature/Schnet)**: [SchNet – A deep learning architecture for molecules and materials ](https://aip.scitation.org/doi/10.1063/1.5019779) by Schütt et al. (2017)\n", - "* **[GAT](https://github.com/aimat-lab/gcnn_keras/blob/master/kgcnn/literature/GAT)**: [Graph Attention Networks](https://arxiv.org/abs/1710.10903) by Veličković et al. (2018)\n", - "* **[GraphSAGE](https://github.com/aimat-lab/gcnn_keras/blob/master/kgcnn/literature/GraphSAGE)**: [Inductive Representation Learning on Large Graphs](http://arxiv.org/abs/1706.02216) by Hamilton et al. (2017)\n", - "* **[GNNExplainer](https://github.com/aimat-lab/gcnn_keras/blob/master/kgcnn/literature/GNNExplain)**: [GNNExplainer: Generating Explanations for Graph Neural Networks](https://arxiv.org/abs/1903.03894) by Ying et al. (2019)\n", - "* **[AttentiveFP](https://github.com/aimat-lab/gcnn_keras/blob/master/kgcnn/literature/AttentiveFP)**: [Pushing the Boundaries of Molecular Representation for Drug Discovery with the Graph Attention Mechanism](https://pubs.acs.org/doi/10.1021/acs.jmedchem.9b00959) by Xiong et al. (2019)\n", - "* **[GATv2](https://github.com/aimat-lab/gcnn_keras/blob/master/kgcnn/literature/GATv2)**: [How Attentive are Graph Attention Networks?](https://arxiv.org/abs/2105.14491) by Brody et al. (2021)\n", - "* **[GIN](https://github.com/aimat-lab/gcnn_keras/blob/master/kgcnn/literature/GIN)**: [How Powerful are Graph Neural Networks?](https://arxiv.org/abs/1810.00826) by Xu et al. (2019)\n", - "* **[PAiNN](https://github.com/aimat-lab/gcnn_keras/blob/master/kgcnn/literature/PAiNN)**: [Equivariant message passing for the prediction of tensorial properties and molecular spectra](https://arxiv.org/pdf/2102.03150.pdf) by Schütt et al. (2020)\n", - "* **[DMPNN](https://github.com/aimat-lab/gcnn_keras/blob/master/kgcnn/literature/DMPNN)**: [Analyzing Learned Molecular Representations for Property Prediction](https://pubs.acs.org/doi/abs/10.1021/acs.jcim.9b00237) by Yang et al. (2019)\n", + "* **[AttentiveFP](kgcnn/literature/AttentiveFP)**: [Pushing the Boundaries of Molecular Representation for Drug Discovery with the Graph Attention Mechanism](https://pubs.acs.org/doi/10.1021/acs.jmedchem.9b00959) by Xiong et al. (2019)\n", + "* **[CGCNN](kgcnn/literature/CGCNN)**: [Crystal Graph Convolutional Neural Networks for an Accurate and Interpretable Prediction of Material Properties](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.120.145301) by Xie et al. (2018)\n", + "* **[CMPNN](kgcnn/literature/CMPNN)**: [Communicative Representation Learning on Attributed Molecular Graphs](https://www.ijcai.org/proceedings/2020/0392.pdf) by Song et al. (2020)\n", + "* **[DGIN](kgcnn/literature/DGIN)**: [Improved Lipophilicity and Aqueous Solubility Prediction with Composite Graph Neural Networks ](https://pubmed.ncbi.nlm.nih.gov/34684766/) by Wieder et al. (2021)\n", + "* **[DimeNetPP](kgcnn/literature/DimeNetPP)**: [Fast and Uncertainty-Aware Directional Message Passing for Non-Equilibrium Molecules](https://arxiv.org/abs/2011.14115) by Klicpera et al. (2020)\n", + "* **[DMPNN](kgcnn/literature/DMPNN)**: [Analyzing Learned Molecular Representations for Property Prediction](https://pubs.acs.org/doi/abs/10.1021/acs.jcim.9b00237) by Yang et al. (2019)\n", + "* **[EGNN](kgcnn/literature/EGNN)**: [E(n) Equivariant Graph Neural Networks](https://arxiv.org/abs/2102.09844) by Satorras et al. (2021)\n", + "* **[GAT](kgcnn/literature/GAT)**: [Graph Attention Networks](https://arxiv.org/abs/1710.10903) by Veličković et al. (2018)\n", + "* **[GATv2](kgcnn/literature/GATv2)**: [How Attentive are Graph Attention Networks?](https://arxiv.org/abs/2105.14491) by Brody et al. (2021)\n", + "* **[GCN](kgcnn/literature/GCN)**: [Semi-Supervised Classification with Graph Convolutional Networks](https://arxiv.org/abs/1609.02907) by Kipf et al. (2016)\n", + "* **[GIN](kgcnn/literature/GIN)**: [How Powerful are Graph Neural Networks?](https://arxiv.org/abs/1810.00826) by Xu et al. (2019)\n", + "* **[GNNExplainer](kgcnn/literature/GNNExplain)**: [GNNExplainer: Generating Explanations for Graph Neural Networks](https://arxiv.org/abs/1903.03894) by Ying et al. (2019)\n", + "* **[GNNFilm](kgcnn/literature/GNNFilm)**: [GNN-FiLM: Graph Neural Networks with Feature-wise Linear Modulation](https://arxiv.org/abs/1906.12192) by Marc Brockschmidt (2020)\n", + "* **[GraphSAGE](kgcnn/literature/GraphSAGE)**: [Inductive Representation Learning on Large Graphs](http://arxiv.org/abs/1706.02216) by Hamilton et al. (2017)\n", + "* **[HamNet](kgcnn/literature/HamNet)**: [HamNet: Conformation-Guided Molecular Representation with Hamiltonian Neural Networks](https://arxiv.org/abs/2105.03688) by Li et al. (2021)\n", + "* **[HDNNP2nd](kgcnn/literature/HDNNP2nd)**: [Atom-centered symmetry functions for constructing high-dimensional neural network potentials](https://aip.scitation.org/doi/abs/10.1063/1.3553717) by Jörg Behler (2011)\n", + "* **[INorp](kgcnn/literature/INorp)**: [Interaction Networks for Learning about Objects,Relations and Physics](https://arxiv.org/abs/1612.00222) by Battaglia et al. (2016)\n", + "* **[MAT](kgcnn/literature/MAT)**: [Molecule Attention Transformer](https://arxiv.org/abs/2002.08264) by Maziarka et al. (2020)\n", + "* **[MEGAN](kgcnn/literature/MEGAN)**: [MEGAN: Multi-explanation Graph Attention Network](https://link.springer.com/chapter/10.1007/978-3-031-44067-0_18) by Teufel et al. (2023)\n", + "* **[Megnet](kgcnn/literature/Megnet)**: [Graph Networks as a Universal Machine Learning Framework for Molecules and Crystals](https://doi.org/10.1021/acs.chemmater.9b01294) by Chen et al. (2019)\n", + "* **[MoGAT](kgcnn/literature/MoGAT)**: [Multi-order graph attention network for water solubility prediction and interpretation](https://www.nature.com/articles/s41598-022-25701-5) by Lee et al. (2023)\n", + "* **[MXMNet](kgcnn/literature/MXMNet)**: [Molecular Mechanics-Driven Graph Neural Network with Multiplex Graph for Molecular Structures](https://arxiv.org/abs/2011.07457) by Zhang et al. (2020)\n", "* **[NMPN](kgcnn/literature/NMPN)**: [Neural Message Passing for Quantum Chemistry](http://arxiv.org/abs/1704.01212) by Gilmer et al. (2017)\n", - "* **[CGCNN](kgcnn/literature/CGCNN)**: [Crystal Graph Convolutional Neural Networks for an Accurate and Interpretable Prediction of Material Properties](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.120.145301) by Xie et al. (2018)" + "* **[PAiNN](kgcnn/literature/PAiNN)**: [Equivariant message passing for the prediction of tensorial properties and molecular spectra](https://arxiv.org/pdf/2102.03150.pdf) by Schütt et al. (2020)\n", + "* **[RGCN](kgcnn/literature/RGCN)**: [Modeling Relational Data with Graph Convolutional Networks](https://arxiv.org/abs/1703.06103) by Schlichtkrull et al. (2017)\n", + "* **[rGIN](kgcnn/literature/rGIN)** [Random Features Strengthen Graph Neural Networks](https://arxiv.org/abs/2002.03155) by Sato et al. (2020)\n", + "* **[Schnet](kgcnn/literature/Schnet)**: [SchNet – A deep learning architecture for molecules and materials ](https://aip.scitation.org/doi/10.1063/1.5019779) by Schütt et al. (2017)\n" ] }, { @@ -336,14 +351,26 @@ "\n", "| model | kgcnn | epochs | MAE [log mol/L] | RMSE [log mol/L] |\n", "|:------------|:--------|---------:|:-----------------------|:-----------------------|\n", - "| AttentiveFP | 4.0.0 | 200 | **0.4351 ± 0.0110** | **0.6080 ± 0.0207** |\n", + "| AttentiveFP | 4.0.0 | 200 | 0.4351 ± 0.0110 | 0.6080 ± 0.0207 |\n", + "| DGIN | 4.0.0 | 300 | 0.4434 ± 0.0252 | 0.6225 ± 0.0420 |\n", "| DMPNN | 4.0.0 | 300 | 0.4401 ± 0.0165 | 0.6203 ± 0.0292 |\n", + "| EGNN | 4.0.0 | 800 | 0.4507 ± 0.0152 | 0.6563 ± 0.0370 |\n", "| GAT | 4.0.0 | 500 | 0.4818 ± 0.0240 | 0.6919 ± 0.0694 |\n", "| GATv2 | 4.0.0 | 500 | 0.4598 ± 0.0234 | 0.6650 ± 0.0409 |\n", "| GCN | 4.0.0 | 800 | 0.4613 ± 0.0205 | 0.6534 ± 0.0513 |\n", "| GIN | 4.0.0 | 300 | 0.5369 ± 0.0334 | 0.7954 ± 0.0861 |\n", + "| GNNFilm | 4.0.0 | 800 | 0.4854 ± 0.0368 | 0.6724 ± 0.0436 |\n", "| GraphSAGE | 4.0.0 | 500 | 0.4874 ± 0.0228 | 0.6982 ± 0.0608 |\n", + "| HDNNP2nd | 4.0.0 | 500 | 0.7857 ± 0.0986 | 1.0467 ± 0.1367 |\n", + "| INorp | 4.0.0 | 500 | 0.5055 ± 0.0436 | 0.7297 ± 0.0786 |\n", + "| MAT | 4.0.0 | 400 | 0.5064 ± 0.0299 | 0.7194 ± 0.0630 |\n", + "| MEGAN | 4.0.0 | 400 | **0.4281 ± 0.0201** | **0.6062 ± 0.0252** |\n", + "| Megnet | 4.0.0 | 800 | 0.5679 ± 0.0310 | 0.8196 ± 0.0480 |\n", + "| MXMNet | 4.0.0 | 900 | 0.6486 ± 0.0633 | 1.0123 ± 0.2059 |\n", "| NMPN | 4.0.0 | 800 | 0.5046 ± 0.0266 | 0.7193 ± 0.0607 |\n", + "| PAiNN | 4.0.0 | 250 | 0.4857 ± 0.0598 | 0.6650 ± 0.0674 |\n", + "| RGCN | 4.0.0 | 800 | 0.4703 ± 0.0251 | 0.6529 ± 0.0318 |\n", + "| rGIN | 4.0.0 | 300 | 0.5196 ± 0.0351 | 0.7142 ± 0.0263 |\n", "| Schnet | 4.0.0 | 800 | 0.4777 ± 0.0294 | 0.6977 ± 0.0538 |\n", "\n", "#### FreeSolvDataset\n", @@ -352,12 +379,27 @@ "\n", "| model | kgcnn | epochs | MAE [log mol/L] | RMSE [log mol/L] |\n", "|:----------|:--------|---------:|:-----------------------|:-----------------------|\n", - "| DMPNN | 4.0.0 | 300 | **0.5487 ± 0.0754** | **0.9206 ± 0.1889** |\n", + "| CMPNN | 4.0.0 | 600 | 0.5202 ± 0.0504 | 0.9339 ± 0.1286 |\n", + "| DGIN | 4.0.0 | 300 | 0.5489 ± 0.0374 | 0.9448 ± 0.0787 |\n", + "| DimeNetPP | 4.0.0 | 872 | 0.6167 ± 0.0719 | 1.0302 ± 0.1717 |\n", + "| DMPNN | 4.0.0 | 300 | 0.5487 ± 0.0754 | **0.9206 ± 0.1889** |\n", + "| EGNN | 4.0.0 | 800 | 0.5386 ± 0.0548 | 1.0363 ± 0.1237 |\n", "| GAT | 4.0.0 | 500 | 0.6051 ± 0.0861 | 1.0326 ± 0.1819 |\n", "| GATv2 | 4.0.0 | 500 | 0.6151 ± 0.0247 | 1.0535 ± 0.0817 |\n", "| GCN | 4.0.0 | 800 | 0.6400 ± 0.0834 | 1.0876 ± 0.1393 |\n", "| GIN | 4.0.0 | 300 | 0.8100 ± 0.1016 | 1.2695 ± 0.1192 |\n", + "| GNNFilm | 4.0.0 | 800 | 0.6562 ± 0.0552 | 1.1597 ± 0.1245 |\n", "| GraphSAGE | 4.0.0 | 500 | 0.5894 ± 0.0675 | 1.0009 ± 0.1491 |\n", + "| HamNet | 4.0.0 | 400 | 0.6619 ± 0.0428 | 1.1410 ± 0.1120 |\n", + "| HDNNP2nd | 4.0.0 | 500 | 1.0201 ± 0.1559 | 1.6351 ± 0.3419 |\n", + "| INorp | 4.0.0 | 500 | 0.6612 ± 0.0188 | 1.1155 ± 0.1061 |\n", + "| MAT | 4.0.0 | 400 | 0.8115 ± 0.0649 | 1.3099 ± 0.1235 |\n", + "| MEGAN | 4.0.0 | 400 | 0.6303 ± 0.0550 | 1.0429 ± 0.1031 |\n", + "| Megnet | 4.0.0 | 800 | 0.8878 ± 0.0528 | 1.4134 ± 0.1200 |\n", + "| MoGAT | 4.0.0 | 200 | 0.7097 ± 0.0374 | 1.0911 ± 0.1334 |\n", + "| MXMNet | 4.0.0 | 900 | 1.1386 ± 0.1979 | 3.0487 ± 2.1757 |\n", + "| RGCN | 4.0.0 | 800 | **0.5128 ± 0.0810** | 0.9228 ± 0.1887 |\n", + "| rGIN | 4.0.0 | 300 | 0.8503 ± 0.0613 | 1.3285 ± 0.0976 |\n", "| Schnet | 4.0.0 | 800 | 0.6070 ± 0.0285 | 1.0603 ± 0.0549 |\n", "\n", "#### ISO17Dataset\n", @@ -435,10 +477,12 @@ "\n", "Materials Project dataset from Matbench with 636 crystal structures and their corresponding Exfoliation energy (meV/atom). We use a random 5-fold cross-validation. \n", "\n", - "| model | kgcnn | epochs | MAE [meV/atom] | RMSE [meV/atom] |\n", - "|:--------------------------|:--------|---------:|:-------------------------|:--------------------------|\n", - "| PAiNN.make_crystal_model | 4.0.0 | 800 | 49.3889 ± 11.5376 | 121.7087 ± 30.0472 |\n", - "| Schnet.make_crystal_model | 4.0.0 | 800 | **45.2412 ± 11.6395** | **115.6890 ± 39.0929** |\n", + "| model | kgcnn | epochs | MAE [meV/atom] | RMSE [meV/atom] |\n", + "|:-----------------------------|:--------|---------:|:-------------------------|:--------------------------|\n", + "| CGCNN.make_crystal_model | 4.0.0 | 1000 | 57.6974 ± 18.0803 | 140.6167 ± 44.8418 |\n", + "| DimeNetPP.make_crystal_model | 4.0.0 | 780 | 50.2880 ± 11.4199 | 126.0600 ± 38.3769 |\n", + "| PAiNN.make_crystal_model | 4.0.0 | 800 | 49.3889 ± 11.5376 | 121.7087 ± 30.0472 |\n", + "| Schnet.make_crystal_model | 4.0.0 | 800 | **45.2412 ± 11.6395** | **115.6890 ± 39.0929** |\n", "\n", "#### MatProjectLogGVRHDataset\n", "\n", @@ -593,7 +637,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.10.5" } }, "nbformat": 4, diff --git a/kgcnn/data/base.py b/kgcnn/data/base.py index 634693b4..c5a4a865 100644 --- a/kgcnn/data/base.py +++ b/kgcnn/data/base.py @@ -331,7 +331,7 @@ def rename_property_on_graphs(self, old_property_name: str, new_property_name: s def tf_disjoint_data_generator(self, inputs, outputs, **kwargs): assert isinstance(inputs, list), "Dictionary input is not yet implemented" - module_logger.info("Dataloader is experimental and not fully tested or stable.") + module_logger.info("Dataloader is experimental and does not have all features for in and output.") return tf_disjoint_list_generator(self, inputs=inputs, outputs=outputs, **kwargs) diff --git a/kgcnn/io/loader.py b/kgcnn/io/loader.py index 2d24fbb1..75c8c3a6 100644 --- a/kgcnn/io/loader.py +++ b/kgcnn/io/loader.py @@ -1,10 +1,23 @@ import keras as ks +import logging from typing import Union import numpy as np from numpy.random import Generator, PCG64 import tensorflow as tf +# Module logger +logging.basicConfig() +module_logger = logging.getLogger(__name__) +module_logger.setLevel(logging.INFO) + + +def pad_at_axis(x, pad_width, axis=0, **kwargs): + pads = [(0, 0) for _ in range(len(x.shape))] + pads[axis] = pad_width + return np.pad(x, pad_width=pads, **kwargs) + + def tf_disjoint_list_generator( graphs, inputs: list, @@ -15,8 +28,8 @@ def tf_disjoint_list_generator( pos_subgraph_id: list = None, pos_count: list = None, batch_size=32, - padded_disjoint=False, epochs=None, + padded_disjoint=False, shuffle=True, seed=42 ): @@ -44,10 +57,45 @@ def tf_disjoint_list_generator( all_flags = [flag_batch_id, flag_count, flag_subgraph_id] is_attributes = [True if all([x[i] is None for x in all_flags]) else False for i in range(num_inputs)] + max_size = [[] if assignment_to_id[i] is not None else None for i in range(num_inputs)] + total_max = [[] if assignment_to_id[i] is not None else None for i in range(num_inputs)] + + # We can check the maximum batch size at the beginning or just have a maximum batch size for each epoch. if padded_disjoint: if epochs is None: raise ValueError("Requires number of epochs if `padded_disjoint=True` .") + for i in range(num_inputs): + if assignment_to_id[i] is None: + continue + len_list = [len(x[inputs[i]["name"]]) for x in graphs] + total_max[i] = max(len_list) + + rng = Generator(PCG64(seed=seed)) + + for epoch in range(epochs): + max_size_epoch = [[] if assignment_to_id[i] is not None else None for i in range(num_inputs)] + if shuffle: + rng.shuffle(data_index) + for batch_index in range(0, dataset_size, batch_size): + idx = data_index[batch_index:batch_index + batch_size] + graphs_batch = [graphs[i] for i in idx] + for i in range(num_inputs): + if assignment_to_id[i] is None: + continue + len_list = [len(x[inputs[i]["name"]]) for x in graphs_batch] + max_length = sum(len_list) + max_size_epoch[i].append(max_length) + for i, x in enumerate(max_size_epoch): + if x is not None: + max_size[i].append(max(x)) + max_size = [max(x) if x is not None else None for x in max_size] + + module_logger.info("Max of graph: %s." % total_max) + module_logger.info("Padded max of disjoint: %s." % [ + x/batch_size if x is not None else None for x in max_size]) + + data_index = np.arange(dataset_size) rng = Generator(PCG64(seed=seed)) def generator(): @@ -68,18 +116,34 @@ def generator(): array_list = [x[inputs[i]["name"]] for x in graphs_batch] if assignment_to_id[i] is None: - out[i] = np.array(array_list, dtype=inputs[i]["dtype"]) + values = np.array(array_list, dtype=inputs[i]["dtype"]) + if padded_disjoint: + out = pad_at_axis(values, (1, 0), axis=0) + out[i] = values else: - out[i] = np.concatenate(array_list, axis=0) + values = np.concatenate(array_list, axis=0) counts = np.array([len(x) for x in array_list], dtype="int64") - out_counts[i] = counts ids = assignment_to_id[i] + + if not padded_disjoint: + out[i] = values + out_counts[i] = counts + else: + len_values = len(values) + num_pad_required = max_size[i] - len_values + 1 + values = pad_at_axis(values, (num_pad_required, 0), axis=0) + out[i] = values + counts = np.concatenate([np.array([num_pad_required], dtype=counts.dtype), counts], axis=0) + out_counts[i] = counts + if out[pos_count[ids]] is None: out[pos_count[ids]] = counts if out[pos_batch_id[ids]] is None: - out[pos_batch_id[ids]] = np.repeat(np.arange(len(array_list), dtype="int64"), repeats=counts) + out[pos_batch_id[ids]] = np.repeat( + np.arange(len(counts), dtype="int64"), repeats=counts) if out[pos_subgraph_id[ids]] is None: - out[pos_subgraph_id[ids]] = np.concatenate([np.arange(x, dtype="int64") for x in counts], axis=0) + out[pos_subgraph_id[ids]] = np.concatenate( + [np.arange(x, dtype="int64") for x in counts], axis=0) # Indices for i in range(num_inputs): diff --git a/notebooks/tutorial_jax_jit.ipynb b/notebooks/tutorial_jax_jit.ipynb new file mode 100644 index 00000000..c6e37ef4 --- /dev/null +++ b/notebooks/tutorial_jax_jit.ipynb @@ -0,0 +1,425 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d9e621b0-f26e-461d-abc9-2da351a73a26", + "metadata": {}, + "source": [ + "# Using JAX as Backend\n", + "\n", + "Showcase how to use jitable jax models." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "27d6f797-5e9d-4dd3-b74d-ba09f666baea", + "metadata": {}, + "outputs": [], + "source": [ + "import keras as ks" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "88f50597-0b72-47a6-9f05-0be224e91790", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from kgcnn.literature.GIN import make_model_edge as make_model\n", + "from kgcnn.utils.plots import plot_train_test_loss\n", + "from sklearn.model_selection import train_test_split" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c4ed1e84-e4e7-42f0-a42e-34fd413806a1", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:kgcnn.data.download:Checking and possibly downloading dataset with name FreeSolv\n", + "INFO:kgcnn.data.download:Dataset directory located at C:\\Users\\patri\\.kgcnn\\datasets\n", + "INFO:kgcnn.data.download:Dataset directory found. Done.\n", + "INFO:kgcnn.data.download:Dataset found. Done.\n", + "INFO:kgcnn.data.FreeSolv:Found SDF C:\\Users\\patri\\.kgcnn\\datasets\\FreeSolv\\SAMPL.sdf of pre-computed structures.\n", + "INFO:kgcnn.data.FreeSolv:Read molecules from mol-file.\n", + "INFO:kgcnn.data.FreeSolv: ... process molecules 0 from 642\n", + "INFO:kgcnn.molecule.encoder:OneHotEncoder Symbol found ['C', 'N', 'O', 'S', 'Cl', 'Br', 'P', 'F', 'I']\n", + "INFO:kgcnn.molecule.encoder:OneHotEncoder Hybridization found [rdkit.Chem.rdchem.HybridizationType.SP3, rdkit.Chem.rdchem.HybridizationType.SP2, rdkit.Chem.rdchem.HybridizationType.SP]\n", + "INFO:kgcnn.molecule.encoder:OneHotEncoder TotalDegree found [4, 3, 1, 2]\n", + "INFO:kgcnn.molecule.encoder:OneHotEncoder TotalNumHs found [3, 0, 1, 2, 4]\n", + "INFO:kgcnn.molecule.encoder:OneHotEncoder CIPCode found [None, 'S', 'R']\n", + "INFO:kgcnn.molecule.encoder:OneHotEncoder ChiralityPossible found [None, '1']\n", + "INFO:kgcnn.molecule.encoder:OneHotEncoder BondType found [rdkit.Chem.rdchem.BondType.SINGLE, rdkit.Chem.rdchem.BondType.DOUBLE, rdkit.Chem.rdchem.BondType.AROMATIC, rdkit.Chem.rdchem.BondType.TRIPLE]\n", + "INFO:kgcnn.molecule.encoder:OneHotEncoder Stereo found [rdkit.Chem.rdchem.BondStereo.STEREONONE, rdkit.Chem.rdchem.BondStereo.STEREOZ, rdkit.Chem.rdchem.BondStereo.STEREOE]\n" + ] + } + ], + "source": [ + "from kgcnn.data.datasets.FreeSolvDataset import FreeSolvDataset\n", + "dataset = FreeSolvDataset()" + ] + }, + { + "cell_type": "markdown", + "id": "000b1498-ddec-48bf-9e43-cc0b09b8eead", + "metadata": {}, + "source": [ + "## Padded input" + ] + }, + { + "cell_type": "markdown", + "id": "09e0cccd-3fcc-4a19-a612-d39d1de12ee5", + "metadata": {}, + "source": [ + "With keeping the padded input in the disjoint representation and adding a dummy graph for the padded values which can be achieved with the `padded_disjoint` argument for the cast to disjoint layers in `\"cast_disjoint_kwargs\": {\"padded_disjoint\": True}` , the model can be jited.\n", + "However, this will yield a significant number of padded values for node or edge attributes.\n", + "For better performance it is better to padd the entire batch/disjoint node or edge tensors which requires a dataloader.\n", + "\n", + "Note that for the moment special layers like `BatchNormalization` must also passed the argument `padded_disjoint` but which is not yet fully supported." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "6bbdd779-8297-4be9-a0d8-2674e5637c43", + "metadata": {}, + "outputs": [], + "source": [ + "model_config = {\n", + " \"name\": \"GINE\",\n", + " \"inputs\": [\n", + " {\"shape\": (None, 41), \"name\": \"node_attributes\", \"dtype\": \"float32\"},\n", + " {\"shape\": (None, 11), \"name\": \"edge_attributes\", \"dtype\": \"float32\"},\n", + " {\"shape\": (None, 2), \"name\": \"edge_indices\", \"dtype\": \"int64\"},\n", + " {\"shape\": (), \"name\": \"total_nodes\", \"dtype\": \"int64\"}, # Or mask\n", + " {\"shape\": (), \"name\": \"total_edges\", \"dtype\": \"int64\"}, # Or mask\n", + " ],\n", + " \"input_tensor_type\": \"padded\",\n", + " \"cast_disjoint_kwargs\": {\"padded_disjoint\": True},\n", + " \"input_embedding\": None, # deprecated\n", + " \"input_node_embedding\": {\"input_dim\": 95, \"output_dim\": 64},\n", + " \"input_edge_embedding\": {\"input_dim\": 10, \"output_dim\": 64},\n", + " \"gin_mlp\": {\"units\": [64, 64], \"use_bias\": True, \"activation\": [\"relu\", \"linear\"],\n", + " # At the moment we do not have a batch normalization for padded_disjoint\n", + " \"use_normalization\": False, \n", + " \"normalization_technique\": \"graph_batch\"},\n", + " \"gin_args\": {\"epsilon_learnable\": False},\n", + " \"depth\": 3, \"dropout\": 0.0, \"verbose\": 10,\n", + " \"last_mlp\": {\"use_bias\": [True, True, True], \"units\": [64, 64, 64],\n", + " \"activation\": [\"relu\", \"relu\", \"linear\"]},\n", + " \"output_embedding\": 'graph',\n", + " \"output_to_tensor\": None,\n", + " \"output_scaling\": None,\n", + " \"output_tensor_type\": \"padded\",\n", + " \"output_mlp\": {\"use_bias\": True, \"units\": 1,\n", + " \"activation\": \"linear\"}\n", + "}\n", + "inputs = model_config[\"inputs\"]\n", + "outputs = {\"shape\": (1, ), \"name\": \"graph_labels\", \"dtype\": \"float32\"}" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "30451b1f-d516-4ce5-bee6-6ae9d7441b3e", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:kgcnn.data.FreeSolv:Property 'edge_attributes' is an empty list for graph '61'.\n", + "INFO:kgcnn.data.FreeSolv:Property 'edge_attributes' is an empty list for graph '195'.\n", + "INFO:kgcnn.data.FreeSolv:Property 'edge_attributes' is an empty list for graph '286'.\n", + "INFO:kgcnn.data.FreeSolv:Property 'edge_indices' is an empty list for graph '61'.\n", + "INFO:kgcnn.data.FreeSolv:Property 'edge_indices' is an empty list for graph '195'.\n", + "INFO:kgcnn.data.FreeSolv:Property 'edge_indices' is an empty list for graph '286'.\n", + "WARNING:kgcnn.data.FreeSolv:Found invalid graphs for properties. Removing graphs '[286 195 61]'.\n" + ] + } + ], + "source": [ + "dataset.map_list(method=\"count_nodes_and_edges\")\n", + "dataset.clean(inputs)\n", + "for i in range(len(dataset)):\n", + " if len(dataset[i][\"graph_labels\"].shape) < 1:\n", + " dataset[i][\"graph_labels\"] = np.expand_dims(dataset[i][\"graph_labels\"], axis=-1)\n", + "train_indices, test_indices = train_test_split(np.arange(len(dataset)), test_size=0.2)\n", + "\n", + "x_train = dataset[train_indices].tensor(inputs)\n", + "y_train = dataset[train_indices].tensor(outputs)\n", + "x_test = dataset[test_indices].tensor(inputs)\n", + "y_test = dataset[test_indices].tensor(outputs)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8cf506a5-55bb-4985-b3c8-516d73332406", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:kgcnn.models.utils:Updated model kwargs: '{'name': 'GINE', 'inputs': [{'shape': (None, 41), 'name': 'node_attributes', 'dtype': 'float32'}, {'shape': (None, 11), 'name': 'edge_attributes', 'dtype': 'float32'}, {'shape': (None, 2), 'name': 'edge_indices', 'dtype': 'int64'}, {'shape': (), 'name': 'total_nodes', 'dtype': 'int64'}, {'shape': (), 'name': 'total_edges', 'dtype': 'int64'}], 'input_tensor_type': 'padded', 'cast_disjoint_kwargs': {'padded_disjoint': True}, 'input_embedding': None, 'input_node_embedding': {'input_dim': 95, 'output_dim': 64}, 'input_edge_embedding': {'input_dim': 10, 'output_dim': 64}, 'gin_mlp': {'units': [64, 64], 'use_bias': True, 'activation': ['relu', 'linear'], 'use_normalization': False, 'normalization_technique': 'graph_batch'}, 'gin_args': {'epsilon_learnable': False}, 'depth': 3, 'dropout': 0.0, 'verbose': 10, 'last_mlp': {'use_bias': [True, True, True], 'units': [64, 64, 64], 'activation': ['relu', 'relu', 'linear']}, 'output_embedding': 'graph', 'output_to_tensor': None, 'output_scaling': None, 'output_tensor_type': 'padded', 'output_mlp': {'use_bias': True, 'units': 1, 'activation': 'linear'}}'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Compiled with jit: True\n" + ] + } + ], + "source": [ + "model = make_model(**model_config)\n", + "model.compile(loss=\"mean_absolute_error\", optimizer=ks.optimizers.Adam(learning_rate=1e-03))\n", + "print(\" Compiled with jit: %s\" % model._jit_compile)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a28b8310-910f-47e3-9e9e-898400ba07be", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\patri\\anaconda3\\envs\\gcnn_keras_test\\lib\\site-packages\\keras\\src\\backend\\jax\\core.py:64: UserWarning: Explicitly requested dtype int64 requested in array is not available, and will be truncated to dtype int32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return jnp.array(x, dtype=dtype)\n", + "C:\\Users\\patri\\anaconda3\\envs\\gcnn_keras_test\\lib\\site-packages\\keras\\src\\backend\\jax\\numpy.py:129: UserWarning: Explicitly requested dtype int64 requested in arange is not available, and will be truncated to dtype int32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return jnp.arange(start, stop, step=step, dtype=dtype)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.2884478271007538\n" + ] + } + ], + "source": [ + "hist = model.fit(\n", + " x_train, y_train, \n", + " validation_data=(x_test, y_test),\n", + " epochs=100, \n", + " verbose=0\n", + ")\n", + "plot_train_test_loss([hist], dataset_name=\"FreeSolv\", model_name=\"GIN.make_model_edge\");\n", + "print(hist.history[\"loss\"][-1])" + ] + }, + { + "cell_type": "markdown", + "id": "b47652e0-30b0-49e4-9eaf-f5291ef65595", + "metadata": {}, + "source": [ + "## Dataloader" + ] + }, + { + "cell_type": "markdown", + "id": "25961b4d-51eb-4f55-be06-f94175ccbbbe", + "metadata": {}, + "source": [ + "The best way for training is to use a dataloader to generate a padded disjoint representation.\n", + "One could recompile the model for each batch and run a fixed batch size. However, this is not tested and implemented.\n", + "For now you can give the number of epochs and it will generate the maximum batch disjoint representation for the entire training process." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "0d7dae3d-d1c3-432e-8948-3afa2b608fdf", + "metadata": {}, + "outputs": [], + "source": [ + "model_config = {\n", + " \"name\": \"GINE\",\n", + " \"inputs\": [\n", + " {\"shape\": (41, ), \"name\": \"node_attributes\", \"dtype\": \"float32\"},\n", + " {\"shape\": (11, ), \"name\": \"edge_attributes\", \"dtype\": \"float32\"},\n", + " {\"shape\": (None, ), \"name\": \"edge_indices\", \"dtype\": \"int64\"}, # shape is (2, None)\n", + " {\"shape\": (), \"name\": \"batch_id_node\", \"dtype\": \"int64\"},\n", + " {\"shape\": (), \"name\": \"batch_id_edge\", \"dtype\": \"int64\"},\n", + " {\"shape\": (), \"name\": \"node_id\", \"dtype\": \"int64\"},\n", + " {\"shape\": (), \"name\": \"edge_id\", \"dtype\": \"int64\"},\n", + " {\"shape\": (), \"name\": \"count_nodes\", \"dtype\": \"int64\"},\n", + " {\"shape\": (), \"name\": \"count_edges\", \"dtype\": \"int64\"},\n", + " ],\n", + " \"input_tensor_type\": \"disjoint\",\n", + " \"cast_disjoint_kwargs\": {\"padded_disjoint\": True},\n", + " \"input_embedding\": None, # deprecated\n", + " \"input_node_embedding\": {\"input_dim\": 95, \"output_dim\": 64},\n", + " \"input_edge_embedding\": {\"input_dim\": 10, \"output_dim\": 64},\n", + " \"gin_mlp\": {\"units\": [64, 64], \"use_bias\": True, \"activation\": [\"relu\", \"linear\"],\n", + " # At the moment we do not have a batch normalization for padded_disjoint\n", + " \"use_normalization\": False, \n", + " \"normalization_technique\": \"graph_batch\"},\n", + " \"gin_args\": {\"epsilon_learnable\": False},\n", + " \"depth\": 3, \"dropout\": 0.0, \"verbose\": 10,\n", + " \"last_mlp\": {\"use_bias\": [True, True, True], \"units\": [64, 64, 64],\n", + " \"activation\": [\"relu\", \"relu\", \"linear\"]},\n", + " \"output_embedding\": 'graph',\n", + " \"output_to_tensor\": None,\n", + " \"output_scaling\": None,\n", + " \"output_tensor_type\": \"padded\",\n", + " \"output_mlp\": {\"use_bias\": True, \"units\": 1,\n", + " \"activation\": \"linear\"}\n", + "}\n", + "inputs = model_config[\"inputs\"]\n", + "outputs = {\"shape\": (1, ), \"name\": \"graph_labels\", \"dtype\": \"float32\"}" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f98401c3-281d-4e7b-a079-b2ff3795b5ad", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:kgcnn.models.utils:Updated model kwargs: '{'name': 'GINE', 'inputs': [{'shape': (41,), 'name': 'node_attributes', 'dtype': 'float32'}, {'shape': (11,), 'name': 'edge_attributes', 'dtype': 'float32'}, {'shape': (None,), 'name': 'edge_indices', 'dtype': 'int64'}, {'shape': (), 'name': 'batch_id_node', 'dtype': 'int64'}, {'shape': (), 'name': 'batch_id_edge', 'dtype': 'int64'}, {'shape': (), 'name': 'node_id', 'dtype': 'int64'}, {'shape': (), 'name': 'edge_id', 'dtype': 'int64'}, {'shape': (), 'name': 'count_nodes', 'dtype': 'int64'}, {'shape': (), 'name': 'count_edges', 'dtype': 'int64'}], 'input_tensor_type': 'disjoint', 'cast_disjoint_kwargs': {'padded_disjoint': True}, 'input_embedding': None, 'input_node_embedding': {'input_dim': 95, 'output_dim': 64}, 'input_edge_embedding': {'input_dim': 10, 'output_dim': 64}, 'gin_mlp': {'units': [64, 64], 'use_bias': True, 'activation': ['relu', 'linear'], 'use_normalization': False, 'normalization_technique': 'graph_batch'}, 'gin_args': {'epsilon_learnable': False}, 'depth': 3, 'dropout': 0.0, 'verbose': 10, 'last_mlp': {'use_bias': [True, True, True], 'units': [64, 64, 64], 'activation': ['relu', 'relu', 'linear']}, 'output_embedding': 'graph', 'output_to_tensor': None, 'output_scaling': None, 'output_tensor_type': 'padded', 'output_mlp': {'use_bias': True, 'units': 1, 'activation': 'linear'}}'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Compiled with jit: True\n" + ] + } + ], + "source": [ + "model = make_model(**model_config)\n", + "model.compile(loss=\"mean_absolute_error\", optimizer=ks.optimizers.Adam(learning_rate=1e-03))\n", + "print(\" Compiled with jit: %s\" % model._jit_compile)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "2c233f60-65e7-4896-8269-840f51cf3110", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:kgcnn.data.base:Dataloader is experimental and does not have all features for in and output.\n", + "INFO:kgcnn.io.loader:Max of graph: [24, 50, 50, None, None, None, None, None, None].\n", + "INFO:kgcnn.io.loader:Padded max of disjoint: [11.09375, 22.25, 22.25, None, None, None, None, None, None].\n", + "INFO:kgcnn.data.base:Dataloader is experimental and does not have all features for in and output.\n", + "INFO:kgcnn.io.loader:Max of graph: [23, 46, 46, None, None, None, None, None, None].\n", + "INFO:kgcnn.io.loader:Padded max of disjoint: [10.96875, 21.75, 21.75, None, None, None, None, None, None].\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.3443690240383148\n" + ] + } + ], + "source": [ + "dataloader_train = dataset[train_indices].tf_disjoint_data_generator(\n", + " inputs=inputs, \n", + " outputs=outputs, \n", + " batch_size=32, \n", + " assignment_to_id=[0, 1, 1],\n", + " assignment_of_indices=[None, None, 0],\n", + " pos_batch_id=[3,4],\n", + " pos_subgraph_id=[5,6],\n", + " pos_count=[7,8],\n", + " epochs=100,\n", + " padded_disjoint=True\n", + ")\n", + "dataloader_test = dataset[test_indices].tf_disjoint_data_generator(\n", + " inputs=inputs, \n", + " outputs=outputs, \n", + " batch_size=32, \n", + " assignment_to_id=[0, 1, 1],\n", + " assignment_of_indices=[None, None, 0],\n", + " pos_batch_id=[3,4],\n", + " pos_subgraph_id=[5,6],\n", + " pos_count=[7,8],\n", + " epochs=100,\n", + " padded_disjoint=True\n", + ")\n", + "hist = model.fit(\n", + " dataloader_train, \n", + " validation_data=dataloader_test, \n", + " epochs=100,\n", + " verbose=0\n", + ")\n", + "plot_train_test_loss([hist], dataset_name=\"FreeSolv\", model_name=\"GIN.make_model_edge\");\n", + "print(hist.history[\"loss\"][-1])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "02333c75-0703-4543-8da8-c6bb0f0184be", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/tutorial_model_loading_options.ipynb b/notebooks/tutorial_model_loading_options.ipynb index 69b5d884..358e4be8 100644 --- a/notebooks/tutorial_model_loading_options.ipynb +++ b/notebooks/tutorial_model_loading_options.ipynb @@ -150,7 +150,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -162,7 +162,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "0.4364333152770996\n" + "0.45586878061294556\n" ] } ], @@ -246,7 +246,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -258,7 +258,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "0.4378684163093567\n" + "0.4058905243873596\n" ] } ], @@ -330,14 +330,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO:kgcnn.data.base:Dataloader is experimental and not fully tested or stable.\n", + "INFO:kgcnn.data.base:Dataloader is experimental and does not have all features for in and output.\n", "C:\\Users\\patri\\anaconda3\\envs\\gcnn_keras_test\\lib\\contextlib.py:153: UserWarning: Your input ran out of data; interrupting training. Make sure that your dataset or generator can generate at least `steps_per_epoch * epochs` batches. You may need to use the `.repeat()` function when building your dataset.\n", " self.gen.throw(typ, value, traceback)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -349,7 +349,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "0.42463621497154236\n" + "0.3954358696937561\n" ] } ],