From eb7d5bdb16cb935f2bfa03e7c9774dfd1b5c6f3c Mon Sep 17 00:00:00 2001 From: PatReis Date: Mon, 4 Dec 2023 19:00:26 +0100 Subject: [PATCH] update notebooks docs. Add further models (not tested!!) --- AUTHORS | 4 +- changelog.md | 2 +- docs/source/forces.ipynb | 187 ++--- docs/source/layers.ipynb | 3 +- kgcnn/layers/polynom.py | 242 +++++++ kgcnn/literature/DGIN/__init__.py | 0 kgcnn/literature/DGIN/_layers.py | 121 ++++ kgcnn/literature/DGIN/_make.py | 214 ++++++ kgcnn/literature/DGIN/_model.py | 105 +++ kgcnn/literature/DMPNN/_make.py | 3 +- kgcnn/literature/DimeNetPP/__init__.py | 0 kgcnn/literature/DimeNetPP/_layers.py | 390 +++++++++++ kgcnn/literature/DimeNetPP/_make.py | 397 +++++++++++ kgcnn/literature/DimeNetPP/_model.py | 154 +++++ kgcnn/literature/EGNN/__init__.py | 0 kgcnn/literature/EGNN/_make.py | 214 ++++++ kgcnn/literature/EGNN/_model.py | 106 +++ kgcnn/literature/GCN/_make.py | 3 - kgcnn/literature/GCN/_model.py | 4 + kgcnn/literature/GNNFilm/__init__.py | 0 kgcnn/literature/GNNFilm/_make.py | 157 +++++ kgcnn/literature/GNNFilm/_model.py | 49 ++ kgcnn/literature/Megnet/__init__.py | 0 kgcnn/literature/Megnet/_layers.py | 134 ++++ kgcnn/literature/Megnet/_make.py | 366 ++++++++++ kgcnn/literature/Megnet/_model.py | 193 ++++++ kgcnn/literature/RGCN/__init__.py | 0 kgcnn/literature/RGCN/_make.py | 165 +++++ kgcnn/literature/RGCN/_model.py | 51 ++ kgcnn/literature/Schnet/_make.py | 10 +- kgcnn/molecule/dynamics/base.py | 3 +- notebooks/workflow_qm_regression.ipynb | 907 +++++++++++++++++++++++-- 32 files changed, 4052 insertions(+), 132 deletions(-) create mode 100644 kgcnn/layers/polynom.py create mode 100644 kgcnn/literature/DGIN/__init__.py create mode 100644 kgcnn/literature/DGIN/_layers.py create mode 100644 kgcnn/literature/DGIN/_make.py create mode 100644 kgcnn/literature/DGIN/_model.py create mode 100644 kgcnn/literature/DimeNetPP/__init__.py create mode 100644 kgcnn/literature/DimeNetPP/_layers.py create mode 100644 kgcnn/literature/DimeNetPP/_make.py create mode 100644 kgcnn/literature/DimeNetPP/_model.py create mode 100644 kgcnn/literature/EGNN/__init__.py create mode 100644 kgcnn/literature/EGNN/_make.py create mode 100644 kgcnn/literature/EGNN/_model.py create mode 100644 kgcnn/literature/GNNFilm/__init__.py create mode 100644 kgcnn/literature/GNNFilm/_make.py create mode 100644 kgcnn/literature/GNNFilm/_model.py create mode 100644 kgcnn/literature/Megnet/__init__.py create mode 100644 kgcnn/literature/Megnet/_layers.py create mode 100644 kgcnn/literature/Megnet/_make.py create mode 100644 kgcnn/literature/Megnet/_model.py create mode 100644 kgcnn/literature/RGCN/__init__.py create mode 100644 kgcnn/literature/RGCN/_make.py create mode 100644 kgcnn/literature/RGCN/_model.py diff --git a/AUTHORS b/AUTHORS index 25ff00ad..43b03f5f 100644 --- a/AUTHORS +++ b/AUTHORS @@ -1,3 +1,5 @@ List of contributors to kgcnn modules. -- GNNExplainer module by Robin Ruff +- GNNExplainer module by robinruff +- DGIN by thegodone + diff --git a/changelog.md b/changelog.md index ca10405b..52f3216a 100644 --- a/changelog.md +++ b/changelog.md @@ -27,7 +27,7 @@ Also be sure to check ``StandardLabelScaler`` if you want to scale regression ta * Input embedding in literature models is now controlled with separate ``input_node_embedding`` or ``input_edge_embedding`` arguments which can be set to `None` for no embedding. Also embedding input tokens must be of dtype int now. No auto-casting from float anymore. * New module ``kgcnn.ops`` with ``kgcnn.backend`` to generalize aggregation functions for graph operations. -* Reduced the models in literature. Will keep bringing all models of kgcnn<4.0.0 back in next versions. +* Reduced the models in literature. Will keep bringing all models of kgcnn<4.0.0 back in next versions and run benchmark training again. diff --git a/docs/source/forces.ipynb b/docs/source/forces.ipynb index d5345619..ece89355 100644 --- a/docs/source/forces.ipynb +++ b/docs/source/forces.ipynb @@ -48,8 +48,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO:kgcnn.model.utils:Updated model kwargs:\n", - "INFO:kgcnn.model.utils:{'name': 'SchnetEnergy', 'inputs': [{'shape': [None], 'name': 'z', 'dtype': 'float32', 'ragged': True}, {'shape': [None, 3], 'name': 'R', 'dtype': 'float32', 'ragged': True}, {'shape': [None, 2], 'name': 'range_indices', 'dtype': 'int64', 'ragged': True}], 'input_embedding': {'node': {'input_dim': 95, 'output_dim': 128}}, 'make_distance': True, 'expand_distance': True, 'interaction_args': {'units': 128, 'use_bias': True, 'activation': 'kgcnn>shifted_softplus', 'cfconv_pool': 'sum'}, 'node_pooling_args': {'pooling_method': 'sum'}, 'depth': 6, 'gauss_args': {'bins': 25, 'distance': 5, 'offset': 0.0, 'sigma': 0.4}, 'verbose': 10, 'last_mlp': {'use_bias': [True, True, True], 'units': [128, 64, 1], 'activation': ['kgcnn>shifted_softplus', 'kgcnn>shifted_softplus', 'linear']}, 'output_embedding': 'graph', 'output_to_tensor': True, 'use_output_mlp': False, 'output_mlp': {'use_bias': [True, True], 'units': [64, 1], 'activation': ['kgcnn>shifted_softplus', 'linear']}}\n" + "INFO:kgcnn.models.utils:Updated model kwargs: '{'name': 'SchnetEnergy', 'inputs': [{'shape': [None], 'name': 'z', 'dtype': 'int64'}, {'shape': [None, 3], 'name': 'R', 'dtype': 'float32'}, {'shape': [None, 2], 'name': 'range_indices', 'dtype': 'int64'}, {'shape': (), 'name': 'total_nodes', 'dtype': 'int64'}, {'shape': (), 'name': 'total_ranges', 'dtype': 'int64'}], 'input_tensor_type': 'padded', 'input_embedding': None, 'cast_disjoint_kwargs': {}, 'input_node_embedding': {'input_dim': 95, 'output_dim': 128}, 'make_distance': True, 'expand_distance': True, 'interaction_args': {'units': 128, 'use_bias': True, 'activation': 'kgcnn>shifted_softplus', 'cfconv_pool': 'sum'}, 'node_pooling_args': {'pooling_method': 'sum'}, 'depth': 6, 'gauss_args': {'bins': 25, 'distance': 5, 'offset': 0.0, 'sigma': 0.4}, 'verbose': 10, 'last_mlp': {'use_bias': [True, True, True], 'units': [128, 64, 1], 'activation': ['kgcnn>shifted_softplus', 'kgcnn>shifted_softplus', 'linear']}, 'output_embedding': 'graph', 'output_to_tensor': None, 'use_output_mlp': False, 'output_tensor_type': 'padded', 'output_scaling': None, 'output_mlp': {}}'.\n" ] } ], @@ -58,13 +57,14 @@ "config= {\n", " \"name\": \"SchnetEnergy\",\n", " \"inputs\": [\n", - " {\"shape\": [None], \"name\": \"z\", \"dtype\": \"float32\", \"ragged\": True},\n", - " {\"shape\": [None, 3], \"name\": \"R\", \"dtype\": \"float32\", \"ragged\": True},\n", - " {\"shape\": [None, 2], \"name\": \"range_indices\", \"dtype\": \"int64\", \"ragged\": True}\n", + " {\"shape\": [None], \"name\": \"z\", \"dtype\": \"int64\"},\n", + " {\"shape\": [None, 3], \"name\": \"R\", \"dtype\": \"float32\"},\n", + " {\"shape\": [None, 2], \"name\": \"range_indices\", \"dtype\": \"int64\"},\n", + " {\"shape\": (), \"name\": \"total_nodes\", \"dtype\": \"int64\"},\n", + " {\"shape\": (), \"name\": \"total_ranges\", \"dtype\": \"int64\"}\n", " ],\n", - " \"input_embedding\": {\n", - " \"node\": {\"input_dim\": 95, \"output_dim\": 128}\n", - " },\n", + " \"input_tensor_type\": \"padded\",\n", + " \"input_node_embedding\": {\"input_dim\": 95, \"output_dim\": 128},\n", " \"last_mlp\": {\"use_bias\": [True, True, True], \"units\": [128, 64, 1],\n", " \"activation\": ['kgcnn>shifted_softplus', 'kgcnn>shifted_softplus', 'linear']},\n", " \"interaction_args\": {\n", @@ -95,12 +95,24 @@ "metadata": {}, "outputs": [], "source": [ - "from kgcnn.model.force import EnergyForceModel\n", + "from kgcnn.models.force import EnergyForceModel\n", "\n", "model_energy_force = EnergyForceModel(\n", + " inputs=[\n", + " {\"shape\": [None], \"name\": \"z\", \"dtype\": \"int32\"},\n", + " {\"shape\": [None, 3], \"name\": \"node_coordinates\", \"dtype\": \"float32\"},\n", + " {\"shape\": [None, 2], \"name\": \"range_indices\", \"dtype\": \"int64\"},\n", + " {\"shape\": (), \"name\": \"total_nodes\", \"dtype\": \"int64\"},\n", + " {\"shape\": (), \"name\": \"total_ranges\", \"dtype\": \"int64\"}\n", + " ],\n", + " name=\"SchnetForce\",\n", " model_energy = model_energy,\n", " output_to_tensor = False,\n", - " output_squeeze_states = True\n", + " output_squeeze_states = True,\n", + " outputs={\n", + " \"energy\": {\"name\": \"energy\", \"shape\": (1,)},\n", + " \"force\": {\"name\": \"force\", \"shape\": (None, 3)}\n", + " }\n", ")" ] }, @@ -145,7 +157,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Dataset (2000): dict_keys(['R', 'E', 'F', 'z', 'name', 'type', 'md5', 'theory', 'train', 'range_indices', 'range_attributes'])\n" + "Dataset (2000): dict_keys(['R', 'E', 'F', 'z', 'name', 'type', 'md5', 'theory', 'train', 'range_indices', 'range_attributes', 'total_nodes', 'total_ranges'])\n" ] } ], @@ -153,6 +165,8 @@ "from kgcnn.data.datasets.MD17Dataset import MD17Dataset\n", "dataset = MD17Dataset(\"ethanol_ccsd_t\")\n", "dataset.map_list(method=\"set_range\", node_coordinates=\"R\", max_distance=4.0)\n", + "dataset.map_list(method= \"count_nodes_and_edges\", total_edges= \"total_ranges\", count_edges= \"range_indices\", \n", + " count_nodes= \"z\", total_nodes= \"total_nodes\")\n", "# Change units to eV/A from kcal/mol\n", "dataset.set(\"E\", [mol[\"E\"]*0.0433634 for mol in dataset])\n", "dataset.set(\"F\", [mol[\"F\"]*0.0433634 for mol in dataset])\n", @@ -197,11 +211,11 @@ "from kgcnn.data.transform.scaler.force import EnergyForceExtensiveLabelScaler\n", "\n", "# Scaling energy and forces.\n", - "scaler = EnergyForceExtensiveLabelScaler()\n", - "scaler_mapping = {\"atomic_number\": \"z\", \"y\": [\"E\", \"F\"]}\n", - "scaler.fit_dataset(dataset_train, **scaler_mapping)\n", - "scaler.transform_dataset(dataset_train, **scaler_mapping)\n", - "scaler.transform_dataset(dataset_test, **scaler_mapping);" + "scaler_mapping = {\"atomic_number\": \"z\", \"energy\": \"E\", \"force\": \"F\"}\n", + "scaler = EnergyForceExtensiveLabelScaler(standardize_scale=False, **scaler_mapping)\n", + "scaler.fit_dataset(dataset_train);\n", + "scaler.transform_dataset(dataset_train)\n", + "scaler.transform_dataset(dataset_test);" ] }, { @@ -221,8 +235,8 @@ "source": [ "# Conversion to tensor input\n", "labels_in_dataset = {\n", - " \"energy\": {\"name\": \"E\", \"ragged\": False},\n", - " \"force\": {\"name\": \"F\", \"shape\": (None, 3), \"ragged\": True}\n", + " \"energy\": {\"name\": \"E\", \"shape\": (1,)},\n", + " \"force\": {\"name\": \"F\", \"shape\": (None, 3)}\n", "}\n", "y_train, y_test = dataset_train.tensor(labels_in_dataset), dataset_test.tensor(labels_in_dataset)\n", "x_train, x_test = dataset_train.tensor(config[\"inputs\"]), dataset_test.tensor(config[\"inputs\"])" @@ -243,14 +257,14 @@ "metadata": {}, "outputs": [], "source": [ - "from kgcnn.metrics.loss import RaggedMeanAbsoluteError\n", - "from tensorflow.keras.optimizers import Adam\n", + "from kgcnn.losses.losses import ForceMeanAbsoluteError\n", + "from keras.optimizers import Adam\n", "\n", "model_energy_force.compile(\n", - " loss={\"energy\": \"mean_absolute_error\", \"force\": RaggedMeanAbsoluteError()},\n", + " loss={\"energy\": \"mean_absolute_error\", \"force\": ForceMeanAbsoluteError()},\n", " optimizer=Adam(learning_rate=1e-03),\n", " metrics=None,\n", - " loss_weights=[1, 49],\n", + " loss_weights={\"energy\": 0.02, \"force\": 0.98},\n", ")" ] }, @@ -284,8 +298,28 @@ " callbacks=[\n", " LinearWarmupExponentialLRScheduler(lr_start=1e-03, gamma=0.995, epo_warmup=1, steps_per_epoch=32, verbose=1)\n", " ]\n", - ");\n", - "plot_train_test_loss([hist])" + ");" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "5c65200d-ab11-45a6-8da1-fce3f71ca28b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_train_test_loss([hist]);" ] }, { @@ -298,13 +332,13 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "41da557f", "metadata": {}, "outputs": [], "source": [ "# model_energy_force.save(\"model_energy_force\")\n", - "# model_energy_force = tf.keras.models.load_model('model_energy_force')" + "# model_energy_force = keras.models.load_model('model_energy_force')" ] }, { @@ -317,18 +351,18 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "85b8c40d", "metadata": {}, "outputs": [], "source": [ - "scaler.inverse_transform_dataset(dataset, **scaler_mapping)\n", + "scaler.inverse_transform_dataset(dataset)\n", "true_y = dataset_test.get(\"E\"), dataset_test.get(\"F\")" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "851ec0a3", "metadata": {}, "outputs": [], @@ -351,20 +385,18 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "id": "123b82ca", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -410,20 +442,23 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 14, "id": "682e083f", "metadata": {}, "outputs": [], "source": [ "from kgcnn.molecule.dynamics.base import MolDynamicsModelPredictor\n", "from kgcnn.graph.postprocessor import ExtensiveEnergyForceScalerPostprocessor\n", - "from kgcnn.graph.preprocessor import SetRange\n", + "from kgcnn.graph.preprocessor import SetRange, CountNodesAndEdges\n", "\n", "dyn_model = MolDynamicsModelPredictor(\n", " model=model_energy_force, \n", " model_inputs=config[\"inputs\"], \n", " model_outputs={\"energy\":\"energy\", \"forces\": \"force\"},\n", - " graph_preprocessors=[SetRange(node_coordinates= \"R\", max_distance=4.0)],\n", + " graph_preprocessors=[\n", + " SetRange(node_coordinates=\"R\", max_distance=4.0),\n", + " CountNodesAndEdges(total_edges=\"total_ranges\", count_edges=\"range_indices\", count_nodes=\"z\", total_nodes=\"total_nodes\")\n", + " ],\n", " graph_postprocessors=[\n", " ExtensiveEnergyForceScalerPostprocessor(\n", " scaler, force=\"forces\", atomic_number=\"z\")]\n", @@ -432,7 +467,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 15, "id": "d118de18", "metadata": {}, "outputs": [], @@ -455,7 +490,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 16, "id": "a17953fb", "metadata": {}, "outputs": [ @@ -465,7 +500,7 @@ "Atoms(symbols='C2OH6', pbc=False)" ] }, - "execution_count": 23, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -480,7 +515,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 17, "id": "26914421", "metadata": {}, "outputs": [ @@ -498,7 +533,7 @@ " [ 1.84879848e+00, -2.86324036e-02, -5.25690230e-01]])} ...]>" ] }, - "execution_count": 24, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -510,7 +545,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 18, "id": "bdcb03b7", "metadata": {}, "outputs": [], @@ -533,7 +568,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 19, "id": "0fd134a9", "metadata": {}, "outputs": [ @@ -541,15 +576,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'energy': array(-4210.10608608), 'forces': array([[-0.40810014, 1.44508323, -0.08648853],\n", - " [ 2.57021069, -1.84409073, -0.43325531],\n", - " [ 1.60649781, -0.1155006 , -0.78838767],\n", - " [ 0.05678861, -0.22312301, -0.18917786],\n", - " [ 0.07157569, -0.02854657, 0.07422443],\n", - " [-0.47191066, 0.49506172, -0.81499557],\n", - " [-1.67661084, 1.06380911, 0.68716817],\n", - " [-0.22691964, -0.66149807, 0.58455748],\n", - " [-1.52153114, -0.13119507, 0.96635494]])}\n" + "{'energy': array(-4210.1056349), 'forces': array([[-0.41029084, 1.445263 , -0.09325541],\n", + " [ 2.5735703 , -1.8340608 , -0.41830564],\n", + " [ 1.602669 , -0.08252943, -0.7950784 ],\n", + " [ 0.07904099, -0.23876965, -0.19849436],\n", + " [ 0.05621693, -0.04351348, 0.08634967],\n", + " [-0.46894395, 0.5051009 , -0.827881 ],\n", + " [-1.6850219 , 1.0685279 , 0.7068002 ],\n", + " [-0.21787213, -0.68336594, 0.5771504 ],\n", + " [-1.5293683 , -0.13665256, 0.9627145 ]], dtype=float32)}\n" ] } ], @@ -571,7 +606,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 20, "id": "ade3f668", "metadata": {}, "outputs": [ @@ -579,27 +614,27 @@ "name": "stdout", "output_type": "stream", "text": [ - "Energy per atom: Epot = -467.790eV Ekin = 0.048eV (T=372K) Etot = -467.741eV\n", - "Energy per atom: Epot = -467.801eV Ekin = 0.060eV (T=463K) Etot = -467.741eV\n", - "Energy per atom: Epot = -467.812eV Ekin = 0.071eV (T=546K) Etot = -467.742eV\n", - "Energy per atom: Epot = -467.806eV Ekin = 0.063eV (T=491K) Etot = -467.742eV\n", - "Energy per atom: Epot = -467.797eV Ekin = 0.057eV (T=438K) Etot = -467.741eV\n", - "Energy per atom: Epot = -467.805eV Ekin = 0.062eV (T=481K) Etot = -467.742eV\n", - "Energy per atom: Epot = -467.794eV Ekin = 0.053eV (T=408K) Etot = -467.741eV\n", - "Energy per atom: Epot = -467.780eV Ekin = 0.040eV (T=311K) Etot = -467.740eV\n", - "Energy per atom: Epot = -467.791eV Ekin = 0.050eV (T=390K) Etot = -467.741eV\n", - "Energy per atom: Epot = -467.793eV Ekin = 0.051eV (T=394K) Etot = -467.742eV\n", - "Energy per atom: Epot = -467.777eV Ekin = 0.037eV (T=288K) Etot = -467.740eV\n", - "Energy per atom: Epot = -467.793eV Ekin = 0.051eV (T=398K) Etot = -467.742eV\n", - "Energy per atom: Epot = -467.806eV Ekin = 0.065eV (T=501K) Etot = -467.742eV\n", - "Energy per atom: Epot = -467.798eV Ekin = 0.057eV (T=438K) Etot = -467.741eV\n", - "Energy per atom: Epot = -467.797eV Ekin = 0.055eV (T=427K) Etot = -467.742eV\n", - "Energy per atom: Epot = -467.809eV Ekin = 0.067eV (T=520K) Etot = -467.742eV\n", - "Energy per atom: Epot = -467.787eV Ekin = 0.048eV (T=371K) Etot = -467.739eV\n", - "Energy per atom: Epot = -467.799eV Ekin = 0.058eV (T=450K) Etot = -467.741eV\n", - "Energy per atom: Epot = -467.797eV Ekin = 0.055eV (T=424K) Etot = -467.742eV\n", - "Energy per atom: Epot = -467.796eV Ekin = 0.054eV (T=417K) Etot = -467.742eV\n", - "Energy per atom: Epot = -467.793eV Ekin = 0.051eV (T=398K) Etot = -467.742eV\n" + "Energy per atom: Epot = -467.790eV Ekin = 0.047eV (T=364K) Etot = -467.742eV\n", + "Energy per atom: Epot = -467.799eV Ekin = 0.055eV (T=429K) Etot = -467.743eV\n", + "Energy per atom: Epot = -467.804eV Ekin = 0.061eV (T=470K) Etot = -467.743eV\n", + "Energy per atom: Epot = -467.809eV Ekin = 0.066eV (T=511K) Etot = -467.743eV\n", + "Energy per atom: Epot = -467.812eV Ekin = 0.068eV (T=527K) Etot = -467.744eV\n", + "Energy per atom: Epot = -467.797eV Ekin = 0.053eV (T=413K) Etot = -467.744eV\n", + "Energy per atom: Epot = -467.797eV Ekin = 0.054eV (T=416K) Etot = -467.743eV\n", + "Energy per atom: Epot = -467.809eV Ekin = 0.065eV (T=507K) Etot = -467.743eV\n", + "Energy per atom: Epot = -467.795eV Ekin = 0.052eV (T=402K) Etot = -467.743eV\n", + "Energy per atom: Epot = -467.786eV Ekin = 0.043eV (T=335K) Etot = -467.742eV\n", + "Energy per atom: Epot = -467.801eV Ekin = 0.058eV (T=450K) Etot = -467.743eV\n", + "Energy per atom: Epot = -467.787eV Ekin = 0.044eV (T=342K) Etot = -467.742eV\n", + "Energy per atom: Epot = -467.798eV Ekin = 0.056eV (T=432K) Etot = -467.742eV\n", + "Energy per atom: Epot = -467.807eV Ekin = 0.064eV (T=495K) Etot = -467.743eV\n", + "Energy per atom: Epot = -467.799eV Ekin = 0.056eV (T=436K) Etot = -467.743eV\n", + "Energy per atom: Epot = -467.801eV Ekin = 0.058eV (T=446K) Etot = -467.743eV\n", + "Energy per atom: Epot = -467.803eV Ekin = 0.061eV (T=471K) Etot = -467.742eV\n", + "Energy per atom: Epot = -467.778eV Ekin = 0.037eV (T=289K) Etot = -467.741eV\n", + "Energy per atom: Epot = -467.791eV Ekin = 0.050eV (T=387K) Etot = -467.741eV\n", + "Energy per atom: Epot = -467.804eV Ekin = 0.063eV (T=484K) Etot = -467.742eV\n", + "Energy per atom: Epot = -467.800eV Ekin = 0.058eV (T=450K) Etot = -467.742eV\n" ] } ], @@ -644,7 +679,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.10.5" } }, "nbformat": 4, diff --git a/docs/source/layers.ipynb b/docs/source/layers.ipynb index 11d952b1..1abade87 100644 --- a/docs/source/layers.ipynb +++ b/docs/source/layers.ipynb @@ -28,6 +28,7 @@ " * `mlp` Multi-layer perceptron for graphs.\n", " * `modules` Keras layers and modules to support ragged tensor input.\n", " * `norm` Normalization layers for graph tensors.\n", + " * `polynom` Layers for Polynomials.\n", " * `pooling` General layers for standard aggregation and pooling.\n", " * `relational` Relational message processing.\n", " * `scale` Scaling layer to (constantly) rescale e.g. graph output.\n", @@ -84,7 +85,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.10.5" } }, "nbformat": 4, diff --git a/kgcnn/layers/polynom.py b/kgcnn/layers/polynom.py new file mode 100644 index 00000000..53aa18ac --- /dev/null +++ b/kgcnn/layers/polynom.py @@ -0,0 +1,242 @@ +import numpy as np +import scipy as sp +import scipy.special +from keras import ops +from scipy.optimize import brentq + + +def spherical_bessel_jn(r, n): + r"""Compute spherical Bessel function :math:`j_n(r)` via scipy. + The spherical bessel functions and there properties can be looked up at + https://en.wikipedia.org/wiki/Bessel_function#Spherical_Bessel_functions . + + Args: + r (np.ndarray): Argument + n (np.ndarray, int): Order. + + Returns: + np.array: Values of the spherical Bessel function + """ + return np.sqrt(np.pi / (2 * r)) * sp.special.jv(n + 0.5, r) + + +def spherical_bessel_jn_zeros(n, k): + r"""Compute the first :math:`k` zeros of the spherical bessel functions :math:`j_n(r)` up to + order :math:`n` (excluded). + Taken from the original implementation of DimeNet at https://github.com/klicperajo/dimenet. + + Args: + n: Order. + k: Number of zero crossings. + + Returns: + np.ndarray: List of zero crossings of shape (n, k) + """ + zerosj = np.zeros((n, k), dtype="float32") + zerosj[0] = np.arange(1, k + 1) * np.pi + points = np.arange(1, k + n) * np.pi + racines = np.zeros(k + n - 1, dtype="float32") + for i in range(1, n): + for j in range(k + n - 1 - i): + foo = brentq(spherical_bessel_jn, points[j], points[j + 1], (i,)) + racines[j] = foo + points = racines + zerosj[i][:k] = racines[:k] + + return zerosj + + +def spherical_bessel_jn_normalization_prefactor(n, k): + r"""Compute the normalization or rescaling pre-factor for the spherical bessel functions :math:`j_n(r)` up to + order :math:`n` (excluded) and maximum frequency :math:`k` (excluded). + Taken from the original implementation of DimeNet at https://github.com/klicperajo/dimenet. + + Args: + n: Order. + k: frequency. + + Returns: + np.ndarray: Normalization of shape (n, k) + """ + zeros = spherical_bessel_jn_zeros(n, k) + normalizer = [] + for order in range(n): + normalizer_tmp = [] + for i in range(k): + normalizer_tmp += [0.5 * spherical_bessel_jn(zeros[order, i], order + 1) ** 2] + normalizer_tmp = 1 / np.array(normalizer_tmp) ** 0.5 + normalizer += [normalizer_tmp] + return np.array(normalizer) + + +def tf_spherical_bessel_jn_explicit(x, n=0): + r"""Compute spherical bessel functions :math:`j_n(x)` for constant positive integer :math:`n` explicitly. + TensorFlow has to cache the function for each :math:`n`. No gradient through :math:`n` or very large number + of :math:`n`'s is possible. + The spherical bessel functions and there properties can be looked up at + https://en.wikipedia.org/wiki/Bessel_function#Spherical_Bessel_functions. + For this implementation the explicit expression from https://dlmf.nist.gov/10.49 has been used. + The definition is: + + :math:`a_{k}(n+\tfrac{1}{2})=\begin{cases}\dfrac{(n+k)!}{2^{k}k!(n-k)!},&k=0,1,\dotsc,n\\ + 0,&k=n+1,n+2,\dotsc\end{cases}` + + :math:`\mathsf{j}_{n}\left(z\right)=\sin\left(z-\tfrac{1}{2}n\pi\right)\sum_{k=0}^{\left\lfloor n/2\right\rfloor} + (-1)^{k}\frac{a_{2k}(n+\tfrac{1}{2})}{z^{2k+1}}+\cos\left(z-\tfrac{1}{2}n\pi\right) + \sum_{k=0}^{\left\lfloor(n-1)/2\right\rfloor}(-1)^{k}\frac{a_{2k+1}(n+\tfrac{1}{2})}{z^{2k+2}}.` + + Args: + x (tf.Tensor): Values to compute :math:`j_n(x)` for. + n (int): Positive integer for the bessel order :math:`n`. + + Returns: + tf.Tensor: Spherical bessel function of order :math:`n` + """ + sin_x = ops.sin(x - n * np.pi / 2) + cos_x = ops.cos(x - n * np.pi / 2) + sum_sin = ops.zeros_like(x) + sum_cos = ops.zeros_like(x) + for k in range(int(np.floor(n / 2)) + 1): + if 2 * k < n + 1: + prefactor = float(sp.special.factorial(n + 2 * k) / np.power(2, 2 * k) / sp.special.factorial( + 2 * k) / sp.special.factorial(n - 2 * k) * np.power(-1, k)) + sum_sin += prefactor * ops.power(x, - (2 * k + 1)) + for k in range(int(np.floor((n - 1) / 2)) + 1): + if 2 * k + 1 < n + 1: + prefactor = float(sp.special.factorial(n + 2 * k + 1) / np.power(2, 2 * k + 1) / sp.special.factorial( + 2 * k + 1) / sp.special.factorial(n - 2 * k - 1) * np.power(-1, k)) + sum_cos += prefactor * ops.power(x, - (2 * k + 2)) + return sum_sin * sin_x + sum_cos * cos_x + + +def tf_spherical_bessel_jn(x, n=0): + r"""Compute spherical bessel functions :math:`j_n(x)` for constant positive integer :math:`n` via recursion. + TensorFlow has to cache the function for each :math:`n`. No gradient through :math:`n` or very large number + of :math:`n` is possible. + The spherical bessel functions and there properties can be looked up at + https://en.wikipedia.org/wiki/Bessel_function#Spherical_Bessel_functions. + The recursive rule is constructed from https://dlmf.nist.gov/10.51. The recursive definition is: + + :math:`j_{n+1}(z)=((2n+1)/z)j_{n}(z)-j_{n-1}(z)` + + :math:`j_{0}(x)=\frac{\sin x}{x}` + + :math:`j_{1}(x)=\frac{1}{x}\frac{\sin x}{x} - \frac{\cos x}{x}` + + :math:`j_{2}(x)=\left(\frac{3}{x^{2}} - 1\right)\frac{\sin x}{x} - \frac{3}{x}\frac{\cos x}{x}` + + Args: + x (tf.Tensor): Values to compute :math:`j_n(x)` for. + n (int): Positive integer for the bessel order :math:`n`. + + Returns: + tf.tensor: Spherical bessel function of order :math:`n` + """ + if n < 0: + raise ValueError("Order parameter must be >= 0 for this implementation of spherical bessel function.") + if n == 0: + return ops.sin(x) / x + elif n == 1: + return ops.sin(x) / ops.square(x) - ops.cos(x) / x + else: + j_n = ops.sin(x) / x + j_nn = ops.sin(x) / ops.square(x) - ops.cos(x) / x + for i in range(1, n): + temp = j_nn + j_nn = (2 * i + 1) / x * j_nn - j_n + j_n = temp + return j_nn + + +def tf_legendre_polynomial_pn(x, n=0): + r"""Compute the (non-associated) Legendre polynomial :math:`P_n(x)` for constant positive integer :math:`n` + via explicit formula. + TensorFlow has to cache the function for each :math:`n`. No gradient through :math:`n` or very large number + of :math:`n` is possible. + Closed form can be viewed at https://en.wikipedia.org/wiki/Legendre_polynomials. + + :math:`P_n(x)=\sum_{k=0}^{\lfloor n/2\rfloor} (-1)^k \frac{(2n - 2k)! \, }{(n-k)! \, (n-2k)! \, k! \, 2^n} x^{n-2k}` + + Args: + x (tf.Tensor): Values to compute :math:`P_n(x)` for. + n (int): Positive integer for :math:`n` in :math:`P_n(x)`. + + Returns: + tf.tensor: Legendre Polynomial of order :math:`n`. + """ + out_sum = ops.zeros_like(x) + prefactors = [ + float((-1) ** k * sp.special.factorial(2 * n - 2 * k) / sp.special.factorial(n - k) / sp.special.factorial( + n - 2 * k) / sp.special.factorial(k) / 2 ** n) for k in range(0, int(np.floor(n / 2)) + 1)] + powers = [float(n - 2 * k) for k in range(0, int(np.floor(n / 2)) + 1)] + for i in range(len(powers)): + out_sum = out_sum + prefactors[i] * ops.power(x, powers[i]) + return out_sum + + +def tf_spherical_harmonics_yl(theta, l=0): + r"""Compute the spherical harmonics :math:`Y_{ml}(\cos\theta)` for :math:`m=0` and constant non-integer :math:`l`. + TensorFlow has to cache the function for each :math:`l`. No gradient through :math:`l` or very large number + of :math:`n` is possible. Uses a simplified formula with :math:`m=0` from + https://en.wikipedia.org/wiki/Spherical_harmonics: + + :math:`Y_{l}^{m}(\theta ,\phi)=\sqrt{\frac{(2l+1)}{4\pi} \frac{(l -m)!}{(l +m)!}} \, P_{l}^{m}(\cos{\theta }) \, + e^{i m \phi}` + + where the associated Legendre polynomial simplifies to :math:`P_l(x)` for :math:`m=0`: + + :math:`P_n(x)=\sum_{k=0}^{\lfloor n/2\rfloor} (-1)^k \frac{(2n - 2k)! \, }{(n-k)! \, (n-2k)! \, k! \, 2^n} x^{n-2k}` + + Args: + theta (tf.Tensor): Values to compute :math:`Y_l(\cos\theta)` for. + l (int): Positive integer for :math:`l` in :math:`Y_l(\cos\theta)`. + + Returns: + tf.tensor: Spherical harmonics for :math:`m=0` and constant non-integer :math:`l`. + """ + x = ops.cos(theta) + out_sum = ops.zeros_like(x) + prefactors = [ + float((-1) ** k * sp.special.factorial(2 * l - 2 * k) / sp.special.factorial(l - k) / sp.special.factorial( + l - 2 * k) / sp.special.factorial(k) / 2 ** l) for k in range(0, int(np.floor(l / 2)) + 1)] + powers = [float(l - 2 * k) for k in range(0, int(np.floor(l / 2)) + 1)] + for i in range(len(powers)): + out_sum = out_sum + prefactors[i] * ops.power(x, powers[i]) + out_sum = out_sum * float(np.sqrt((2 * l + 1) / 4 / np.pi)) + return out_sum + + +def tf_associated_legendre_polynomial(x, l=0, m=0): + r"""Compute the associated Legendre polynomial :math:`P_{l}^{m}(x)` for :math:`m` and constant positive + integer :math:`l` via explicit formula. + Closed Form from taken from https://en.wikipedia.org/wiki/Associated_Legendre_polynomials. + + :math:`P_{l}^{m}(x)=(-1)^{m}\cdot 2^{l}\cdot (1-x^{2})^{m/2}\cdot \sum_{k=m}^{l}\frac{k!}{(k-m)!}\cdot x^{k-m} + \cdot \binom{l}{k}\binom{\frac{l+k-1}{2}}{l}`. + + Args: + x (tf.Tensor): Values to compute :math:`P_{l}^{m}(x)` for. + l (int): Positive integer for :math:`l` in :math:`P_{l}^{m}(x)`. + m (int): Positive/Negative integer for :math:`m` in :math:`P_{l}^{m}(x)`. + + Returns: + tf.tensor: Legendre Polynomial of order n. + """ + if np.abs(m) > l: + raise ValueError("Error: Legendre polynomial must have -l<= m <= l") + if l < 0: + raise ValueError("Error: Legendre polynomial must have l>=0") + if m < 0: + m = -m + neg_m = float(np.power(-1, m) * sp.special.factorial(l - m) / sp.special.factorial(l + m)) + else: + neg_m = 1 + + x_prefactor = ops.power(1 - ops.square(x), m / 2) * float(np.power(-1, m) * np.power(2, l)) + sum_out = ops.zeros_like(x) + for k in range(m, l + 1): + sum_out += ops.power(x, k - m) * float( + sp.special.factorial(k) / sp.special.factorial(k - m) * sp.special.binom(l, k) * + sp.special.binom((l + k - 1) / 2, l)) + + return sum_out * x_prefactor * neg_m \ No newline at end of file diff --git a/kgcnn/literature/DGIN/__init__.py b/kgcnn/literature/DGIN/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/kgcnn/literature/DGIN/_layers.py b/kgcnn/literature/DGIN/_layers.py new file mode 100644 index 00000000..16d4f745 --- /dev/null +++ b/kgcnn/literature/DGIN/_layers.py @@ -0,0 +1,121 @@ +from keras import ops +from kgcnn.layers.gather import GatherNodesOutgoing, GatherEdgesPairs +from kgcnn.layers.aggr import AggregateLocalEdges +from keras.layers import Subtract, Add, Layer + + +class DMPNNPPoolingEdgesDirected(Layer): # noqa + """Pooling of edges for around a target node as defined by + + `DMPNN `__ . This is slightly different as the normal node + aggregation from message passing like networks. Requires edge pair indices for this implementation. + """ + + def __init__(self, **kwargs): + """Initialize layer.""" + super(DMPNNPPoolingEdgesDirected, self).__init__(**kwargs) + self.pool_edge_1 = AggregateLocalEdges(pooling_method="scatter_sum") + self.gather_edges = GatherNodesOutgoing() + self.gather_pairs = GatherEdgesPairs() + self.subtract_layer = Subtract() + + def build(self, input_shape): + super(DMPNNPPoolingEdgesDirected, self).build(input_shape) + # Could call build on sub-layers but is not necessary. + + def call(self, inputs, **kwargs): + """Forward pass. + + Args: + inputs: [nodes, edges, edge_index, edge_reverse_pair] + + - nodes (Tensor): Node embeddings of shape ([N], F) + - edges (Tensor): Edge or message embeddings of shape ([M], F) + - edge_index (Tensor): Edge indices referring to nodes of shape (2, [M]) + - edge_reverse_pair (Tensor): Pair mappings for reverse edges (1, [M]) + + Returns: + Tensor: Edge embeddings of shape ([M], F) + """ + n, ed, edi, edp = inputs + pool_edge_receive = self.pool_edge_1([n, ed, edi], **kwargs) # Sum pooling of all edges + ed_new = self.gather_edges([pool_edge_receive, edi], **kwargs) + ed_not = self.gather_pairs([ed, edp], **kwargs) + out = self.subtract_layer([ed_new, ed_not], **kwargs) + return out + + +class GIN_D(Layer): + r"""Convolutional unit of `Graph Isomorphism Network from: How Powerful are Graph Neural Networks? + `__ . + + Modified to use :math:`h_{w_0}` + + Computes graph convolution at step :math:`k` for node embeddings :math:`h_\nu` as: + + .. math:: + + h_\nu^{(k)} = \phi^{(k)} ((1+\epsilon^{(k)}) h_\nu^{0} + \sum_{u\in N(\nu)}) h_u^{k-1}. + + with optional learnable :math:`\epsilon^{(k)}` + + .. note:: + + The non-linear mapping :math:`\phi^{(k)}`, usually an :obj:`MLP`, is not included in this layer. + """ + + def __init__(self, + pooling_method='sum', + epsilon_learnable=False, + **kwargs): + """Initialize layer. + + Args: + epsilon_learnable (bool): If epsilon is learnable or just constant zero. Default is False. + pooling_method (str): Pooling method for summing edges. Default is 'segment_sum'. + """ + super(GIN_D, self).__init__(**kwargs) + self.pooling_method = pooling_method + self.epsilon_learnable = epsilon_learnable + + # Layers + self.lay_gather = GatherNodesOutgoing() + self.lay_pool = AggregateLocalEdges(pooling_method=self.pooling_method) + self.lay_add = Add() + + # Epsilon with trainable as optional and default zeros initialized. + self.eps_k = self.add_weight(name="epsilon_k", trainable=self.epsilon_learnable, + initializer="zeros", dtype=self.dtype) + + def build(self, input_shape): + """Build layer.""" + super(GIN_D, self).build(input_shape) + + def call(self, inputs, **kwargs): + r"""Forward pass. + Args: + inputs: [nodes, edge_index, nodes_0] + + - nodes (Tensor): Node embeddings of shape `([N], F)` + - edge_index (Tensor): Edge indices referring to nodes of shape `(2, [M])` + - nodes_0 (Tensor): Node embeddings of shape `([N], F)` + + Returns: + Tensor: Node embeddings of shape `([N], F)` + """ + # Need to check if edge_index is full and not half (directed). + node, edge_index, node_0 = inputs + ed = self.lay_gather([node, edge_index], **kwargs) + # Summing for each node connection + nu = self.lay_pool([node, ed, edge_index], **kwargs) + # Modified to use node_0 instead of node see equation 7 in paper. + no = (ops.convert_to_tensor(1, dtype=self.eps_k.dtype) + self.eps_k) * node_0 + out = self.lay_add([no, nu], **kwargs) + return out + + def get_config(self): + """Update config.""" + config = super(GIN_D, self).get_config() + config.update({"pooling_method": self.pooling_method, + "epsilon_learnable": self.epsilon_learnable}) + return config diff --git a/kgcnn/literature/DGIN/_make.py b/kgcnn/literature/DGIN/_make.py new file mode 100644 index 00000000..c4415ee8 --- /dev/null +++ b/kgcnn/literature/DGIN/_make.py @@ -0,0 +1,214 @@ +import keras as ks +from kgcnn.layers.scale import get as get_scaler +from kgcnn.models.utils import update_model_kwargs +from kgcnn.models.casting import template_cast_output, template_cast_list_input +from keras.backend import backend as backend_to_use +from kgcnn.layers.modules import Input +from ._model import model_disjoint + +# Keep track of model version from commit date in literature. +# To be updated if model is changed in a significant way. +__model_version__ = "2023-10-23" + +# Supported backends +__kgcnn_model_backend_supported__ = ["tensorflow", "torch", "jax"] + +if backend_to_use() not in __kgcnn_model_backend_supported__: + raise NotImplementedError("Backend '%s' for model 'DGIN' is not supported." % backend_to_use()) + +# Implementation of DGIN in `keras` from paper: +# Analyzing Learned Molecular Representations for Property Prediction +# by Oliver Wieder, Mélaine Kuenemann, Marcus Wieder, Thomas Seidel, +# Christophe Meyer, Sharon D Bryant and Thierry Langer +# https://pubmed.ncbi.nlm.nih.gov/34684766/ + +model_default = { + "name": "DGIN", + "inputs": [ + {"shape": (None,), "name": "node_number", "dtype": "int64"}, + {"shape": (None,), "name": "edge_number", "dtype": "int64"}, + {"shape": (None, 2), "name": "edge_indices", "dtype": "int64"}, + {"shape": (None, 1), "name": "edge_indices_reverse", "dtype": "int64"}, + {"shape": (), "name": "total_nodes", "dtype": "int64"}, + {"shape": (), "name": "total_edges", "dtype": "int64"}, + {"shape": (), "name": "total_reverse", "dtype": "int64"} + ], + "input_tensor_type": "padded", + "cast_disjoint_kwargs": {}, + "input_embedding": None, # deprecated + "input_node_embedding": {"input_dim": 95, "output_dim": 64}, + "input_edge_embedding": {"input_dim": 5, "output_dim": 64}, + "input_graph_embedding": {"input_dim": 100, "output_dim": 64}, + "gin_mlp": {"units": [64, 64], "use_bias": True, "activation": ["relu", "linear"], + "use_normalization": True, "normalization_technique": "graph_batch"}, + "gin_args": {}, + "last_mlp": {"use_bias": [True, True], "units": [64, 64], + "activation": ["relu", "relu"]}, + "pooling_args": {"pooling_method": "sum"}, + "use_graph_state": False, + "edge_initialize": {"units": 128, "use_bias": True, "activation": "relu"}, + "edge_dense": {"units": 128, "use_bias": True, "activation": "linear"}, + "edge_activation": {"activation": "relu"}, + "verbose": 10, + "depthDMPNN": 4, + "depthGIN": 4, + "dropoutDMPNN": {"rate": 0.15}, + "dropoutGIN": {"rate": 0.15}, + "output_embedding": "graph", + "node_pooling_kwargs": {}, + "output_to_tensor": None, # deprecated + "output_tensor_type": "padded", + "output_mlp": {"use_bias": True, "units": 1, + "activation": "linear"}, + "output_scaling": None, +} + + +@update_model_kwargs(model_default, update_recursive=0, deprecated=["input_embedding", "output_to_tensor"]) +def make_model(name: str = None, + inputs: list = None, + input_tensor_type: str = None, + cast_disjoint_kwargs: dict = None, + input_embedding: dict = None, # noqa + input_node_embedding: dict = None, + input_edge_embedding: dict = None, + input_graph_embedding: dict = None, + pooling_args: dict = None, + edge_initialize: dict = None, + edge_dense: dict = None, + edge_activation: dict = None, + dropoutDMPNN: dict = None, # noqa + dropoutGIN: dict = None, # noqa + depthDMPNN: int = None, # noqa + depthGIN: int = None, # noqa + gin_args: dict = None, + gin_mlp: dict = None, + last_mlp: dict = None, + verbose: int = None, + node_pooling_kwargs: dict = None, + use_graph_state: bool = False, + output_embedding: str = None, + output_to_tensor: bool = None, # noqa + output_tensor_type: str = None, + output_mlp: dict = None, + output_scaling: dict = None + ): + r"""Make `DGIN `__ graph network via functional API. + Default parameters can be found in :obj:`kgcnn.literature.DGIN.model_default` . + + **Model inputs**: + Model uses the list template of inputs and standard output template. + The supported inputs are :obj:`[nodes, edges, edge_indices, reverse_indices, (graph_state), ...]` + with '...' indicating mask or id tensors following the template below. + Here, reverse indices are in place of angle indices and refer to edges. The graph state is optional and controlled + by `use_graph_state` parameter. + + %s + + **Model outputs**: + The standard output template: + + %s + + Args: + name (str): Name of the model. Should be "DGIN". + inputs (list): List of dictionaries unpacked in :obj:`Input`. Order must match model definition. + input_tensor_type (str): Input type of graph tensor. Default is "padded". + cast_disjoint_kwargs (dict): Dictionary of arguments for casting layers if used. + input_embedding (dict): Deprecated in favour of input_node_embedding etc. + input_node_embedding (dict): Dictionary of arguments for nodes unpacked in :obj:`Embedding` layers. + input_edge_embedding (dict): Dictionary of arguments for edge unpacked in :obj:`Embedding` layers. + input_graph_embedding (dict): Dictionary of arguments for edge unpacked in :obj:`Embedding` layers. + pooling_args (dict): Dictionary of layer arguments unpacked in :obj:`AggregateLocalEdges` layers. + edge_initialize (dict): Dictionary of layer arguments unpacked in :obj:`Dense` layer for first edge embedding. + edge_dense (dict): Dictionary of layer arguments unpacked in :obj:`Dense` layer for edge embedding. + edge_activation (dict): Edge Activation after skip connection. + depthDMPNN (int): Number of graph embedding units or depth of the DMPNN subnetwork. + depthGIN (int): Number of graph embedding units or depth of the GIN subnetwork. + dropoutDMPNN (dict): Dictionary of layer arguments unpacked in :obj:`Dropout`. + dropoutGIN (float): dropout rate. + gin_args (dict): Kwargs unpacked in :obj:`GIN_D` convolutional unit. + gin_mlp (dict): Kwargs unpacked in :obj:`MLP` for GIN layer. + last_mlp (dict): Kwargs unpacked in last :obj:`MLP` . + verbose (int): Level for print information. + use_graph_state (bool): Whether to use graph state information. Default is False. + node_pooling_kwargs (dict): Dictionary of layer arguments unpacked in :obj:`PoolingNodes` layer. + output_embedding (str): Main embedding task for graph network. Either "node", "edge" or "graph". + output_to_tensor (bool): WDeprecated in favour of `output_tensor_type` . + output_tensor_type (str): Output type of graph tensors such as nodes or edges. Default is "padded". + output_mlp (dict): Dictionary of layer arguments unpacked in the final classification :obj:`MLP` layer block. + Defines number of model outputs and activation. + output_scaling (dict): Kwargs for scaling layer, if scaling layer is to be used. + + Returns: + :obj:`keras.models.Model` + """ + # Make input + model_inputs = [Input(**x) for x in inputs] + + di = template_cast_list_input( + model_inputs, input_tensor_type=input_tensor_type, + cast_disjoint_kwargs=cast_disjoint_kwargs, + has_nodes=True, has_edges=True, + has_graph_state=use_graph_state, + has_angle_indices=True, # Treat reverse indices as edge indices + has_edge_indices=True + ) + + if use_graph_state: + n, ed, edi, e_pairs, gs, batch_id_node, batch_id_edge, _, node_id, edge_id, _, count_nodes, count_edges, _ = di + else: + n, ed, edi, e_pairs, batch_id_node, batch_id_edge, _, node_id, edge_id, _, count_nodes, count_edges, _ = di + gs = None + + # Wrapping disjoint model. + out = model_disjoint( + [n, ed, edi, batch_id_node, e_pairs, count_nodes, gs], + use_node_embedding=("int" in inputs[0]['dtype']) if input_node_embedding is not None else False, + use_edge_embedding=("int" in inputs[1]['dtype']) if input_edge_embedding is not None else False, + use_graph_embedding=False if not use_graph_state else ( + "int" in inputs[4]['dtype']) if input_graph_embedding is not None else False, + use_graph_state=use_graph_state, + input_node_embedding=input_node_embedding, + input_edge_embedding=input_edge_embedding, + input_graph_embedding=input_graph_embedding, + edge_initialize=edge_initialize, + edge_activation=edge_activation, + edge_dense=edge_dense, + depthDMPNN=depthDMPNN, + dropoutDMPNN=dropoutDMPNN, + pooling_args=pooling_args, + gin_mlp=gin_mlp, + depthGIN=depthGIN, + gin_args=gin_args, + output_embedding=output_embedding, + node_pooling_kwargs=node_pooling_kwargs, + last_mlp=last_mlp, + dropoutGIN=dropoutGIN, + output_mlp=output_mlp + ) + + if output_scaling is not None: + scaler = get_scaler(output_scaling["name"])(**output_scaling) + out = scaler(out) + + # Output embedding choice + out = template_cast_output( + [out, batch_id_node, batch_id_edge, node_id, edge_id, count_nodes, count_edges], + output_embedding=output_embedding, output_tensor_type=output_tensor_type, + input_tensor_type=input_tensor_type, cast_disjoint_kwargs=cast_disjoint_kwargs + ) + + model = ks.models.Model(inputs=model_inputs, outputs=out, name=name) + model.__kgcnn_model_version__ = __model_version__ + + if output_scaling is not None: + def set_scale(*args, **kwargs): + scaler.set_scale(*args, **kwargs) + + setattr(model, "set_scale", set_scale) + + return model + + +make_model.__doc__ = make_model.__doc__ % (template_cast_list_input.__doc__, template_cast_output.__doc__) diff --git a/kgcnn/literature/DGIN/_model.py b/kgcnn/literature/DGIN/_model.py new file mode 100644 index 00000000..505331d0 --- /dev/null +++ b/kgcnn/literature/DGIN/_model.py @@ -0,0 +1,105 @@ +from kgcnn.layers.modules import Embedding +from kgcnn.layers.mlp import MLP, GraphMLP +from kgcnn.layers.gather import GatherNodesOutgoing +from keras.layers import Concatenate, Dense, Activation, Add, Dropout +from kgcnn.layers.gather import GatherState +from kgcnn.layers.aggr import AggregateLocalEdges +from kgcnn.layers.pooling import PoolingNodes +from ._layers import DMPNNPPoolingEdgesDirected, GIN_D + + +def model_disjoint( + inputs, + use_node_embedding, + use_edge_embedding, + use_graph_embedding, + use_graph_state=None, + input_node_embedding=None, + input_edge_embedding=None, + input_graph_embedding=None, + edge_initialize=None, + edge_activation=None, + edge_dense=None, + depthDMPNN=None, + dropoutDMPNN=None, + pooling_args=None, + gin_mlp=None, + depthGIN=None, + gin_args=None, + output_embedding=None, + node_pooling_kwargs=None, + last_mlp=None, + dropoutGIN=None, + output_mlp=None +): + n, ed, edi, batch_id_node, ed_pairs, count_nodes, graph_state = inputs + + # Embedding, if no feature dimension + if use_node_embedding: + n = Embedding(**input_node_embedding)(n) + if use_edge_embedding: + ed = Embedding(**input_edge_embedding)(ed) + if use_graph_state: + if use_graph_embedding: + graph_state = Embedding(**input_graph_embedding)(graph_state) + + # Make first edge hidden h0 step 1 + h_n0 = GatherNodesOutgoing()([n, edi]) + h0 = Concatenate(axis=-1)([h_n0, ed]) + h0 = Dense(**edge_initialize)(h0) + h0 = Activation(**edge_activation)(h0) # relu equation 1 + + # One Dense layer for all message steps this is not the case in DGIN they are independents! + edge_dense_all = Dense(**edge_dense) # see equation 3 comments + + # Model Loop steps 2 & 3 + h = h0 + for i in range(depthDMPNN): + # equation 2 + m_vw = DMPNNPPoolingEdgesDirected()([n, h, edi, ed_pairs]) # ed_pairs for Directed Pooling! + # equation 3 + h = edge_dense_all(m_vw) # do one per layer ... + # h = Dense(**edge_dense)(m_vw) + h = Add()([h, h0]) + # remark : dropout before Activation in DGIN code + h = Activation(**edge_activation)(h) + if dropoutDMPNN is not None: + h = Dropout(**dropoutDMPNN)(h) + + # equation 4 & 5 + m_v = AggregateLocalEdges(**pooling_args)([n, h, edi]) + m_v = Concatenate(axis=-1)([n, m_v]) # + # equation 5b: hv = Dense(**node_dense)(mv) removed based on the paper + + # GIN_D part (this projection is normally not done in DGIN, but we need to get the correct "dim") + n_units = gin_mlp["units"][-1] if isinstance(gin_mlp["units"], list) else int(gin_mlp["units"]) + h_v = Dense(n_units, use_bias=True, activation='linear')(m_v) + h_v_0 = h_v + + list_embeddings = [h_v_0] # empty in the paper + for i in range(depthGIN): + # not sure of the mv, mv ... here but why not ;-) + h_v = GIN_D(**gin_args)( + [h_v, edi, h_v_0]) # equation 6 & 7a mv is new the new nodes values and we do pooling on ed via edi + h_v = GraphMLP(**gin_mlp)([h_v, batch_id_node, count_nodes]) # equation 7b + list_embeddings.append(h_v) + + # Output embedding choice look like it takes only the last h_v in the paper not all ??? + if output_embedding == 'graph': + out = [ + PoolingNodes(**node_pooling_kwargs)([count_nodes, x, batch_id_node]) for x in list_embeddings + ] # will return tensor equation 8 + out = [MLP(**last_mlp)(x) for x in out] # MLP apply per depthGIN + if dropoutGIN is not None: + out = [Dropout(**dropoutGIN)(x) for x in out] + out = Add()(out) + out = MLP(**output_mlp)(out) + elif output_embedding == 'node': + if use_graph_state: + graph_state_node = GatherState()([graph_state, batch_id_node]) + n = Concatenate()([n, graph_state_node]) + out = GraphMLP(**output_mlp)([n, batch_id_node, count_nodes]) + else: + raise ValueError("Unsupported graph embedding for mode `DGIN` .") + + return out diff --git a/kgcnn/literature/DMPNN/_make.py b/kgcnn/literature/DMPNN/_make.py index 6484d3db..ebf3e85d 100644 --- a/kgcnn/literature/DMPNN/_make.py +++ b/kgcnn/literature/DMPNN/_make.py @@ -148,7 +148,8 @@ def make_model(name: str = None, [n, ed, edi, batch_id_node, e_pairs, count_nodes, gs], use_node_embedding=("int" in inputs[0]['dtype']) if input_node_embedding is not None else False, use_edge_embedding=("int" in inputs[1]['dtype']) if input_edge_embedding is not None else False, - use_graph_embedding=("int" in inputs[4]['dtype']) if input_graph_embedding is not None else False, + use_graph_embedding=False if not use_graph_state else ( + "int" in inputs[4]['dtype']) if input_graph_embedding is not None else False, input_node_embedding=input_node_embedding, input_edge_embedding=input_edge_embedding, input_graph_embedding=input_graph_embedding, diff --git a/kgcnn/literature/DimeNetPP/__init__.py b/kgcnn/literature/DimeNetPP/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/kgcnn/literature/DimeNetPP/_layers.py b/kgcnn/literature/DimeNetPP/_layers.py new file mode 100644 index 00000000..27083e1b --- /dev/null +++ b/kgcnn/literature/DimeNetPP/_layers.py @@ -0,0 +1,390 @@ +import keras as ks +from keras import ops +from keras.layers import Dense, Multiply, Add, Layer +from kgcnn.layers.aggr import AggregateLocalEdges +from kgcnn.layers.gather import GatherNodesOutgoing +from kgcnn.layers.mlp import GraphMLP +from kgcnn.layers.update import ResidualLayer + + +class DimNetInteractionPPBlock(Layer): + """DimNetPP Interaction Block as defined by `DimNetPP `__ . + + Args: + emb_size: Embedding size used for the messages + int_emb_size (int): Embedding size used for interaction triplets + basis_emb_size: Embedding size used inside the basis transformation + num_before_skip: Number of residual layers in interaction block before skip connection + num_after_skip: Number of residual layers in interaction block before skip connection + use_bias (bool, optional): Use bias. Defaults to True. + pooling_method (str): Pooling method information for layer. Default is 'sum'. + activation (str): Activation function. Default is "kgcnn>swish". + kernel_regularizer: Kernel regularization. Default is None. + bias_regularizer: Bias regularization. Default is None. + activity_regularizer: Activity regularization. Default is None. + kernel_constraint: Kernel constrains. Default is None. + bias_constraint: Bias constrains. Default is None. + kernel_initializer: Initializer for kernels. Default is 'kgcnn>glorot_orthogonal'. + bias_initializer: Initializer for bias. Default is 'zeros'. + """ + + def __init__(self, emb_size, + int_emb_size, + basis_emb_size, + num_before_skip, + num_after_skip, + use_bias=True, + pooling_method="sum", + activation='kgcnn>swish', # default is 'kgcnn>swish' + kernel_regularizer=None, + bias_regularizer=None, + activity_regularizer=None, + kernel_constraint=None, + bias_constraint=None, + kernel_initializer="kgcnn>glorot_orthogonal", # default is 'kgcnn>glorot_orthogonal' + bias_initializer='zeros', + **kwargs): + super(DimNetInteractionPPBlock, self).__init__(**kwargs) + self.use_bias = use_bias + self.pooling_method = pooling_method + self.emb_size = emb_size + self.int_emb_size = int_emb_size + self.basis_emb_size = basis_emb_size + self.num_before_skip = num_before_skip + self.num_after_skip = num_after_skip + kernel_args = {"kernel_regularizer": kernel_regularizer, "activity_regularizer": activity_regularizer, + "bias_regularizer": bias_regularizer, "kernel_constraint": kernel_constraint, + "bias_constraint": bias_constraint, "kernel_initializer": kernel_initializer, + "bias_initializer": bias_initializer} + + # Transformations of Bessel and spherical basis representations + self.dense_rbf1 = Dense(basis_emb_size, use_bias=False, **kernel_args) + self.dense_rbf2 = Dense(emb_size, use_bias=False, **kernel_args) + self.dense_sbf1 = Dense(basis_emb_size, use_bias=False, **kernel_args) + self.dense_sbf2 = Dense(int_emb_size, use_bias=False, **kernel_args) + + # Dense transformations of input messages + self.dense_ji = Dense(emb_size, activation=activation, use_bias=True, **kernel_args) + self.dense_kj = Dense(emb_size, activation=activation, use_bias=True, **kernel_args) + + # Embedding projections for interaction triplets + self.down_projection = Dense(int_emb_size, activation=activation, use_bias=False, **kernel_args) + self.up_projection = Dense(emb_size, activation=activation, use_bias=False, **kernel_args) + + # Residual layers before skip connection + self.layers_before_skip = [] + for i in range(num_before_skip): + self.layers_before_skip.append( + ResidualLayer(emb_size, activation=activation, use_bias=True, **kernel_args)) + self.final_before_skip = Dense(emb_size, activation=activation, use_bias=True, **kernel_args) + + # Residual layers after skip connection + self.layers_after_skip = [] + for i in range(num_after_skip): + self.layers_after_skip.append( + ResidualLayer(emb_size, activation=activation, use_bias=True, **kernel_args)) + + self.lay_add1 = Add() + self.lay_add2 = Add() + self.lay_mult1 = Multiply() + self.lay_mult2 = Multiply() + + self.lay_gather = GatherNodesOutgoing() # Are edges here + self.lay_pool = AggregateLocalEdges(pooling_method=pooling_method) + + def call(self, inputs, **kwargs): + """Forward pass. + + Args: + inputs: [edges, rbf, sbf, angle_index] + + - edges (Tensor): Edge embeddings of shape ([M], F) + - rbf (Tensor): Radial basis features of shape ([M], F) + - sbf (Tensor): Spherical basis features of shape ([K], F) + - angle_index (tf.RaggedTensor): Angle indices referring to two edges of shape (2, [K]) + + Returns: + tf.RaggedTensor: Updated edge embeddings. + """ + x, rbf, sbf, id_expand = inputs + + # Initial transformation + x_ji = self.dense_ji(x, **kwargs) + x_kj = self.dense_kj(x, **kwargs) + + # Transform via Bessel basis + rbf = self.dense_rbf1(rbf, **kwargs) + rbf = self.dense_rbf2(rbf, **kwargs) + x_kj = self.lay_mult1([x_kj, rbf], **kwargs) + + # Down-project embeddings and generate interaction triplet embeddings + x_kj = self.down_projection(x_kj, **kwargs) + x_kj = self.lay_gather([x_kj, id_expand], **kwargs) + + # Transform via 2D spherical basis + sbf = self.dense_sbf1(sbf, **kwargs) + sbf = self.dense_sbf2(sbf, **kwargs) + x_kj = self.lay_mult1([x_kj, sbf], **kwargs) + + # Aggregate interactions and up-project embeddings + x_kj = self.lay_pool([rbf, x_kj, id_expand], **kwargs) + x_kj = self.up_projection(x_kj, **kwargs) + + # Transformations before skip connection + x2 = self.lay_add1([x_ji, x_kj], **kwargs) + for layer in self.layers_before_skip: + x2 = layer(x2, **kwargs) + x2 = self.final_before_skip(x2, **kwargs) + + # Skip connection + x = self.lay_add2([x, x2],**kwargs) + + # Transformations after skip connection + for layer in self.layers_after_skip: + x = layer(x, **kwargs) + + return x + + def get_config(self): + config = super(DimNetInteractionPPBlock, self).get_config() + config.update({"use_bias": self.use_bias, "pooling_method": self.pooling_method, "emb_size": self.emb_size, + "int_emb_size": self.int_emb_size, "basis_emb_size": self.basis_emb_size, + "num_before_skip": self.num_before_skip, "num_after_skip": self.num_after_skip}) + conf_dense = self.dense_ji.get_config() + for x in ["kernel_regularizer", "activity_regularizer", "bias_regularizer", "kernel_constraint", + "bias_constraint", "kernel_initializer", "bias_initializer", "activation"]: + config.update({x: conf_dense[x]}) + return config + + +class DimNetOutputBlock(Layer): + """DimNetPP Output Block as defined by `DimNetPP `__ . + + Args: + emb_size (list): List of node embedding dimension. + out_emb_size (list): List of edge embedding dimension. + num_dense (list): Number of dense layer for MLP. + num_targets (int): Number of output target dimension. Defaults to 12. + use_bias (bool, optional): Use bias. Defaults to True. + kernel_initializer: Initializer for kernels. Default is 'glorot_orthogonal' with fallback 'orthogonal'. + output_kernel_initializer: Initializer for last kernel. Default is 'zeros'. + bias_initializer: Initializer for bias. Default is 'zeros'. + activation (str): Activation function. Default is 'kgcnn>swish'. + kernel_regularizer: Kernel regularization. Default is None. + bias_regularizer: Bias regularization. Default is None. + activity_regularizer: Activity regularization. Default is None. + kernel_constraint: Kernel constrains. Default is None. + bias_constraint: Bias constrains. Default is None. + pooling_method (str): Pooling method information for layer. Default is 'mean'. + """ + + def __init__(self, emb_size, + out_emb_size, + num_dense, + num_targets=12, + use_bias=True, + output_kernel_initializer="zeros", kernel_initializer='kgcnn>glorot_orthogonal', + bias_initializer='zeros', + activation='kgcnn>swish', + kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, + kernel_constraint=None, bias_constraint=None, + pooling_method="sum", + **kwargs): + """Initialize layer.""" + super(DimNetOutputBlock, self).__init__(**kwargs) + self.pooling_method = pooling_method + self.emb_size = emb_size + self.out_emb_size = out_emb_size + self.num_dense = num_dense + self.num_targets = num_targets + self.use_bias = use_bias + kernel_args = {"kernel_regularizer": kernel_regularizer, "activity_regularizer": activity_regularizer, + "kernel_constraint": kernel_constraint, "bias_initializer": bias_initializer, + "bias_regularizer": bias_regularizer, "bias_constraint": bias_constraint, } + + self.dense_rbf = Dense(emb_size, use_bias=False, kernel_initializer=kernel_initializer, **kernel_args) + self.up_projection = Dense(out_emb_size, use_bias=False, kernel_initializer=kernel_initializer, **kernel_args) + self.dense_mlp = GraphMLP([out_emb_size] * num_dense, activation=activation, + kernel_initializer=kernel_initializer, use_bias=use_bias, **kernel_args) + self.dimnet_mult = Multiply() + self.pool = AggregateLocalEdges(pooling_method=self.pooling_method) + self.dense_final = Dense(num_targets, use_bias=False, kernel_initializer=output_kernel_initializer, + **kernel_args) + + def build(self, input_shape): + """Build layer.""" + super(DimNetOutputBlock, self).build(input_shape) + + def call(self, inputs, **kwargs): + """Forward pass. + + Args: + inputs: [nodes, edges, tensor_index, state] + + - nodes (Tensor): Node embeddings of shape ([N], F) + - edges (Tensor): Edge or message embeddings of shape ([M], F) + - rbf (Tensor): Edge distance basis of shape ([M], F) + - tensor_index (Tensor): Edge indices referring to nodes of shape (2, [M]) + + Returns: + Tensor: Updated node embeddings of shape ([N], F_T). + """ + # Calculate edge Update + n_atoms, x, rbf, idnb_i = inputs + g = self.dense_rbf(rbf, **kwargs) + x = self.dimnet_mult([g, x], **kwargs) + x = self.pool([n_atoms, x, idnb_i], **kwargs) + x = self.up_projection(x, **kwargs) + x = self.dense_mlp(x, **kwargs) + x = self.dense_final(x, **kwargs) + return x + + def get_config(self): + config = super(DimNetOutputBlock, self).get_config() + conf_mlp = self.dense_mlp.get_config() + for x in ["kernel_regularizer", "activity_regularizer", "bias_regularizer", "kernel_constraint", + "bias_constraint", "kernel_initializer", "bias_initializer", "activation"]: + config.update({x: conf_mlp[x][0]}) + conf_dense_output = self.dense_final.get_config() + config.update({"output_kernel_initializer": conf_dense_output["kernel_initializer"]}) + config.update({"pooling_method": self.pooling_method, "use_bias": self.use_bias}) + config.update({"emb_size": self.emb_size, "out_emb_size": self.out_emb_size, "num_dense": self.num_dense, + "num_targets": self.num_targets}) + return config + + +class EmbeddingDimeBlock(Layer): + """Custom Embedding Block of `DimNetPP `__ . + + Naming of inputs here should match keras Embedding layer. + + Args: + input_dim (int): Integer. Size of the vocabulary, i.e. maximum integer index + 1. + output_dim (int): Integer. Dimension of the dense embedding. + embeddings_initializer: Initializer for the embeddings matrix (see keras.initializers). + embeddings_regularizer: Regularizer function applied to the embeddings matrix (see keras.regularizers). + embeddings_constraint: Constraint function applied to the embeddings matrix (see keras.constraints). + + """ + def __init__(self, + input_dim, # Vocabulary + output_dim, # Embedding size + embeddings_initializer='uniform', + embeddings_regularizer=None, + embeddings_constraint=None, + **kwargs): + super(EmbeddingDimeBlock, self).__init__(**kwargs) + self._supports_ragged_inputs = True + self.output_dim = output_dim + self.input_dim = input_dim + self.embeddings_initializer = ks.initializers.get(embeddings_initializer) + self.embeddings_regularizer = ks.regularizers.get(embeddings_regularizer) + self.embeddings_constraint = ks.constraints.get(embeddings_constraint) + + # Original implementation used initializer: + # embeddings_initializer = {'class_name': 'RandomUniform', 'config': {'minval': -1.7320508075688772, + # 'maxval': 1.7320508075688772, 'seed': None}} + self.embeddings = self.add_weight(name="embeddings", shape=(self.input_dim + 1, self.output_dim), + dtype=self.dtype, initializer=self.embeddings_initializer, + regularizer=self.embeddings_regularizer, + constraint=self.embeddings_constraint, + trainable=True) + + def call(self, inputs, **kwargs): + """Embedding of inputs. Forward pass.""" + out = ops.take(self.embeddings, inputs, axis=0) + return out + + def get_config(self): + config = super(EmbeddingDimeBlock, self).get_config() + config.update({"input_dim": self.input_dim, "output_dim": self.output_dim, + "embeddings_initializer": ks.initializers.serialize(self.embeddings_initializer), + "embeddings_regularizer": ks.regularizers.serialize(self.embeddings_regularizer), + "embeddings_constraint": ks.constraints.serialize(self.embeddings_constraint) + }) + return config + + +class SphericalBasisLayer(Layer): + r"""Expand a distance into a Bessel Basis with :math:`l=m=0`, according to + `Klicpera et al. 2020 `__ . + + Args: + num_spherical (int): Number of spherical basis functions + num_radial (int): Number of radial basis functions + cutoff (float): Cutoff distance c + envelope_exponent (int): Degree of the envelope to smoothen at cutoff. Default is 5. + + """ + + def __init__(self, num_spherical, + num_radial, + cutoff, + envelope_exponent=5, + **kwargs): + super(SphericalBasisLayer, self).__init__(**kwargs) + + assert num_radial <= 64 + self.num_radial = int(num_radial) + self.num_spherical = num_spherical + self.cutoff = cutoff + self.inv_cutoff = ops.convert_to_tensor(1.0 / cutoff, dtype=self.dtype) + self.envelope_exponent = envelope_exponent + + # retrieve formulas + self.bessel_n_zeros = spherical_bessel_jn_zeros(num_spherical, num_radial) + self.bessel_norm = spherical_bessel_jn_normalization_prefactor(num_spherical, num_radial) + + self.layer_gather_out = GatherNodesOutgoing() + + def envelope(self, inputs): + p = self.envelope_exponent + 1 + a = -(p + 1) * (p + 2) / 2 + b = p * (p + 2) + c = -p * (p + 1) / 2 + env_val = 1 / inputs + a * inputs ** (p - 1) + b * inputs ** p + c * inputs ** (p + 1) + return ops.where(inputs < 1, env_val, ops.zeros_like(inputs)) + + def call(self, inputs, **kwargs): + """Forward pass. + + Args: + inputs: [distance, angles, angle_index] + + - distance (Tensor): Edge distance of shape ([M], 1) + - angles (Tensor): Angle list of shape ([K], 1) + - angle_index (Tensor): Angle indices referring to edges of shape (2, [K]) + + Returns: + Tensor: Expanded angle/distance basis. Shape is ([K], #Radial * #Spherical) + """ + edge, angles, angle_index = inputs + edge, edge_part = inputs[0].values, inputs[0].row_splits + angles, angle_part = inputs[1].values, inputs[1].row_splits + + d = edge + d_scaled = d[:, 0] * self.inv_cutoff + rbf = [] + for n in range(self.num_spherical): + for k in range(self.num_radial): + rbf += [self.bessel_norm[n, k] * tf_spherical_bessel_jn(d_scaled * self.bessel_n_zeros[n][k], n)] + rbf = ops.stack(rbf, axis=1) + + d_cutoff = self.envelope(d_scaled) + rbf_env = d_cutoff[:, None] * rbf + rbf_env = self.layer_gather_out([rbf_env, angle_index], **kwargs).values + # rbf_env = tf.gather(rbf_env, id_expand_kj[:, 1]) + + cbf = [tf_spherical_harmonics_yl(angles[:, 0], n) for n in range(self.num_spherical)] + cbf = ops.stack(cbf, axis=1) + cbf = ops.repeat(cbf, self.num_radial, axis=1) + out = rbf_env * cbf + + return out + + def get_config(self): + """Update config.""" + config = super(SphericalBasisLayer, self).get_config() + config.update({"num_radial": self.num_radial, "cutoff": self.cutoff, + "envelope_exponent": self.envelope_exponent, "num_spherical": self.num_spherical}) + return config \ No newline at end of file diff --git a/kgcnn/literature/DimeNetPP/_make.py b/kgcnn/literature/DimeNetPP/_make.py new file mode 100644 index 00000000..7245b17c --- /dev/null +++ b/kgcnn/literature/DimeNetPP/_make.py @@ -0,0 +1,397 @@ +import keras as ks +from kgcnn.layers.scale import get as get_scaler +from ._model import model_disjoint, model_disjoint_crystal +from kgcnn.layers.modules import Input +from kgcnn.models.casting import template_cast_output, template_cast_list_input +from kgcnn.models.utils import update_model_kwargs +from keras.backend import backend as backend_to_use + +# To be updated if model is changed in a significant way. +__model_version__ = "2023-12-04" + +# Supported backends +__kgcnn_model_backend_supported__ = ["tensorflow", "torch", "jax"] +if backend_to_use() not in __kgcnn_model_backend_supported__: + raise NotImplementedError("Backend '%s' for model 'DimeNetPP' is not supported." % backend_to_use()) + +# Implementation of DimeNet++ in `keras` from paper: +# Fast and Uncertainty-Aware Directional Message Passing for Non-Equilibrium Molecules +# Johannes Klicpera, Shankari Giri, Johannes T. Margraf, Stephan Günnemann +# https://arxiv.org/abs/2011.14115 +# Original code: https://github.com/gasteigerjo/dimenet + +model_default = { + "name": "DimeNetPP", + "inputs": [ + {"shape": [None], "name": "node_number", "dtype": "int64"}, + {"shape": [None, 3], "name": "node_coordinates", "dtype": "float32"}, + {"shape": [None, 2], "name": "edge_indices", "dtype": "int64"}, + {"shape": [None, 2], "name": "angle_indices", "dtype": "int64"}, + + ], + "input_tensor_type": "padded", + "input_embedding": None, # deprecated + "cast_disjoint_kwargs": {}, + "input_node_embedding": { + "input_dim": 95, "output_dim": 128, "embeddings_initializer": { + "class_name": "RandomUniform", + "config": {"minval": -1.7320508075688772, "maxval": 1.7320508075688772}} + }, + "emb_size": 128, "out_emb_size": 256, "int_emb_size": 64, "basis_emb_size": 8, + "num_blocks": 4, "num_spherical": 7, "num_radial": 6, + "cutoff": 5.0, "envelope_exponent": 5, + "num_before_skip": 1, "num_after_skip": 2, "num_dense_output": 3, + "num_targets": 64, "extensive": True, "output_init": "zeros", + "activation": "swish", "verbose": 10, + "output_embedding": "graph", + "use_output_mlp": True, + "output_tensor_type": "padded", + "output_scaling": None, + "output_mlp": {"use_bias": [True, False], + "units": [64, 12], "activation": ["swish", "linear"]} +} + + +@update_model_kwargs(model_default, update_recursive=0, deprecated=["input_embedding", "output_to_tensor"]) +def make_model(inputs: list = None, + input_tensor_type: str = None, + cast_disjoint_kwargs: dict = None, + input_embedding: dict = None, # noqa + input_node_embedding: dict = None, + emb_size: int = None, + out_emb_size: int = None, + int_emb_size: int = None, + basis_emb_size: int = None, + num_blocks: int = None, + num_spherical: int = None, + num_radial: int = None, + cutoff: float = None, + envelope_exponent: int = None, + num_before_skip: int = None, + num_after_skip: int = None, + num_dense_output: int = None, + num_targets: int = None, + activation: str = None, + extensive: bool = None, + output_init: str = None, + verbose: int = None, # noqa + name: str = None, + output_embedding: str = None, + output_tensor_type: str = None, + use_output_mlp: bool = None, + output_mlp: dict = None, + output_scaling: dict = None + ): + """Make `DimeNetPP `_ graph network via functional API. + Default parameters can be found in :obj:`kgcnn.literature.DimeNetPP.model_default`. + + Model inputs: + Model uses the list template of inputs and standard output template. + The supported inputs are :obj:`[nodes, coordinates, edge_indices, angle_indices...]` + with '...' indicating mask or ID tensors following the template below. + Note that you must supply angle indices as index pairs that refer to two edges. + + %s + + Model outputs: + The standard output template: + + %s + + + Args: + inputs (list): List of dictionaries unpacked in :obj:`tf.keras.layers.Input`. Order must match model definition. + input_tensor_type (str): Input type of graph tensor. Default is "padded". + cast_disjoint_kwargs (dict): Dictionary of arguments for casting layer. + input_embedding (dict): Deprecated in favour of input_node_embedding etc. + input_node_embedding (dict): Dictionary of embedding arguments for nodes unpacked in :obj:`Embedding` layers. + emb_size (int): Overall embedding size used for the messages. + out_emb_size (int): Embedding size for output of :obj:`DimNetOutputBlock`. + int_emb_size (int): Embedding size used for interaction triplets. + basis_emb_size (int): Embedding size used inside the basis transformation. + num_blocks (int): Number of graph embedding blocks or depth of the network. + num_spherical (int): Number of spherical components in :obj:`SphericalBasisLayer`. + num_radial (int): Number of radial components in basis layer. + cutoff (float): Distance cutoff for basis layer. + envelope_exponent (int): Exponent in envelope function for basis layer. + num_before_skip (int): Number of residual layers in interaction block before skip connection + num_after_skip (int): Number of residual layers in interaction block after skip connection + num_dense_output (int): Number of dense units in output :obj:`DimNetOutputBlock`. + num_targets (int): Number of targets or output embedding dimension of the model. + activation (str, dict): Activation to use. + extensive (bool): Graph output for extensive target to apply sum for pooling or mean otherwise. + output_init (str, dict): Output initializer for kernel. + verbose (int): Level of verbosity. + name (str): Name of the model. + output_embedding (str): Main embedding task for graph network. Either "node", "edge" or "graph". + use_output_mlp (bool): Whether to use the final output MLP. Possibility to skip final :obj:`MLP`. + output_mlp (dict): Dictionary of layer arguments unpacked in the final classification :obj:`MLP` layer block. + Defines number of model outputs and activation. Note that DimeNetPP originally defines the output dimension + via `num_targets`. But this can be set to `out_emb_size` and the `output_mlp` be used for more + specific control. + output_scaling (dict): Dictionary of layer arguments unpacked in scaling layers. Default is None. + output_tensor_type (str): Output type of graph tensors such as nodes or edges. Default is "padded". + + Returns: + :obj:`keras.models.Model` + """ + # Make input + model_inputs = [Input(**x) for x in inputs] + + dj = template_cast_list_input( + model_inputs, + input_tensor_type=input_tensor_type, + cast_disjoint_kwargs=cast_disjoint_kwargs, + has_edges=False, + has_nodes=2, + has_angles=True, + ) + + n, x, disjoint_indices, batch_id_node, batch_id_edge, node_id, edge_id, count_nodes, count_edges = dj + + out = model_disjoint( + [n, x, disjoint_indices, batch_id_node, count_nodes], + use_node_embedding=("int" in inputs[0]['dtype']) if input_node_embedding is not None else False, + input_node_embedding=input_node_embedding, + emb_size=emb_size, + out_emb_size=out_emb_size, + int_emb_size=int_emb_size, + basis_emb_size=basis_emb_size, + num_blocks=num_blocks, + num_spherical=num_spherical, + num_radial=num_radial, + cutoff=cutoff, + envelope_exponent=envelope_exponent, + num_before_skip=num_before_skip, + num_after_skip=num_after_skip, + num_dense_output=num_dense_output, + num_targets=num_targets, + activation=activation, + extensive=extensive, + output_init=output_init, + use_output_mlp=use_output_mlp, + output_embedding=output_embedding, + output_mlp=output_mlp + ) + + if output_scaling is not None: + scaler = get_scaler(output_scaling["name"])(**output_scaling) + if scaler.extensive: + # Node information must be numbers, or we need an additional input. + out = scaler([out, n, batch_id_node]) + else: + out = scaler(out) + + # Output embedding choice + out = template_cast_output( + [out, batch_id_node, batch_id_edge, node_id, edge_id, count_nodes, count_edges], + output_embedding=output_embedding, output_tensor_type=output_tensor_type, + input_tensor_type=input_tensor_type, cast_disjoint_kwargs=cast_disjoint_kwargs, + ) + + model = ks.models.Model(inputs=model_inputs, outputs=out, name=name) + + model.__kgcnn_model_version__ = __model_version__ + + if output_scaling is not None: + def set_scale(*args, **kwargs): + scaler.set_scale(*args, **kwargs) + + setattr(model, "set_scale", set_scale) + + return model + + +make_model.__doc__ = make_model.__doc__ % (template_cast_list_input.__doc__, template_cast_output.__doc__) + +model_crystal_default = { + "name": "DimeNetPP", + "inputs": [ + {"shape": [None], "name": "node_number", "dtype": "int64", "ragged": True}, + {"shape": [None, 3], "name": "node_coordinates", "dtype": "float32", "ragged": True}, + {"shape": [None, 2], "name": "edge_indices", "dtype": "int64", "ragged": True}, + {"shape": [None, 2], "name": "angle_indices", "dtype": "int64", "ragged": True}, + {'shape': (None, 3), 'name': "edge_image", 'dtype': 'int64', 'ragged': True}, + {'shape': (3, 3), 'name': "graph_lattice", 'dtype': 'float32', 'ragged': False} + ], + "input_tensor_type": "ragged", + "input_embedding": None, # deprecated + "cast_disjoint_kwargs": {}, + "input_node_embedding": { + "input_dim": 95, "output_dim": 128, "embeddings_initializer": { + "class_name": "RandomUniform", + "config": {"minval": -1.7320508075688772, "maxval": 1.7320508075688772}} + }, + "emb_size": 128, "out_emb_size": 256, "int_emb_size": 64, "basis_emb_size": 8, + "num_blocks": 4, "num_spherical": 7, "num_radial": 6, + "cutoff": 5.0, "envelope_exponent": 5, + "num_before_skip": 1, "num_after_skip": 2, "num_dense_output": 3, + "num_targets": 64, "extensive": True, "output_init": "zeros", + "activation": "swish", "verbose": 10, + "output_embedding": "graph", + "use_output_mlp": True, + "output_tensor_type": "padded", + "output_scaling": None, + "output_mlp": {"use_bias": [True, False], + "units": [64, 12], "activation": ["swish", "linear"]} +} + + +@update_model_kwargs(model_default, update_recursive=0, deprecated=["input_embedding", "output_to_tensor"]) +def make_crystal_model(inputs: list = None, + input_tensor_type: str = None, + cast_disjoint_kwargs: dict = None, + input_embedding: dict = None, # noqa + input_node_embedding: dict = None, + emb_size: int = None, + out_emb_size: int = None, + int_emb_size: int = None, + basis_emb_size: int = None, + num_blocks: int = None, + num_spherical: int = None, + num_radial: int = None, + cutoff: float = None, + envelope_exponent: int = None, + num_before_skip: int = None, + num_after_skip: int = None, + num_dense_output: int = None, + num_targets: int = None, + activation: str = None, + extensive: bool = None, + output_init: str = None, + verbose: int = None, # noqa + name: str = None, + output_embedding: str = None, + output_tensor_type: str = None, + use_output_mlp: bool = None, + output_mlp: dict = None, + output_scaling: dict = None + ): + """Make `DimeNetPP `__ graph network via functional API. + Default parameters can be found in :obj:`kgcnn.literature.DimeNetPP.model_crystal_default`. + + .. note:: + + DimeNetPP does require a large amount of memory for this implementation, which increase quickly with + the number of connections in a batch. Use ragged input or dataloader if possible. + + **Model inputs**: + Model uses the list template of inputs and standard output template. + The supported inputs are :obj:`[nodes, coordinates, edge_indices, angle_indices, image_translation, lattice, ...]` + with '...' indicating mask or ID tensors following the template below. + Note that you must supply angle indices as index pairs that refer to two edges. + + %s + + **Model outputs**: + The standard output template: + + %s + + + Args: + inputs (list): List of dictionaries unpacked in :obj:`tf.keras.layers.Input`. Order must match model definition. + input_tensor_type (str): Input type of graph tensor. Default is "padded". + cast_disjoint_kwargs (dict): Dictionary of arguments for casting layer. + input_embedding (dict): Deprecated in favour of input_node_embedding etc. + input_node_embedding (dict): Dictionary of embedding arguments for nodes unpacked in :obj:`Embedding` layers. + emb_size (int): Overall embedding size used for the messages. + out_emb_size (int): Embedding size for output of :obj:`DimNetOutputBlock`. + int_emb_size (int): Embedding size used for interaction triplets. + basis_emb_size (int): Embedding size used inside the basis transformation. + num_blocks (int): Number of graph embedding blocks or depth of the network. + num_spherical (int): Number of spherical components in :obj:`SphericalBasisLayer`. + num_radial (int): Number of radial components in basis layer. + cutoff (float): Distance cutoff for basis layer. + envelope_exponent (int): Exponent in envelope function for basis layer. + num_before_skip (int): Number of residual layers in interaction block before skip connection + num_after_skip (int): Number of residual layers in interaction block after skip connection + num_dense_output (int): Number of dense units in output :obj:`DimNetOutputBlock`. + num_targets (int): Number of targets or output embedding dimension of the model. + activation (str, dict): Activation to use. + extensive (bool): Graph output for extensive target to apply sum for pooling or mean otherwise. + output_init (str, dict): Output initializer for kernel. + verbose (int): Level of verbosity. + name (str): Name of the model. + output_embedding (str): Main embedding task for graph network. Either "node", "edge" or "graph". + use_output_mlp (bool): Whether to use the final output MLP. Possibility to skip final :obj:`MLP`. + output_mlp (dict): Dictionary of layer arguments unpacked in the final classification :obj:`MLP` layer block. + Defines number of model outputs and activation. Note that DimeNetPP originally defines the output dimension + via `num_targets`. But this can be set to `out_emb_size` and the `output_mlp` be used for more + specific control. + output_scaling (dict): Dictionary of layer arguments unpacked in scaling layers. Default is None. + output_tensor_type (str): Output type of graph tensors such as nodes or edges. Default is "padded". + + Returns: + :obj:`keras.models.Model` + """ + # Make input + model_inputs = [Input(**x) for x in inputs] + + disjoint_inputs = template_cast_list_input( + model_inputs, input_tensor_type=input_tensor_type, + cast_disjoint_kwargs=cast_disjoint_kwargs, + has_edges=False, + has_nodes=2, + has_angles=True, + has_crystal_input=2 + ) + + n, x, djx, img, lattice, batch_id_node, batch_id_edge, node_id, edge_id, count_nodes, count_edges = disjoint_inputs + + # Wrapp disjoint model + out = model_disjoint_crystal( + [n, x, djx, img, lattice, batch_id_node, batch_id_edge, count_nodes], + use_node_embedding=("int" in inputs[0]['dtype']) if input_node_embedding is not None else False, + input_node_embedding=input_node_embedding, + emb_size=emb_size, + out_emb_size=out_emb_size, + int_emb_size=int_emb_size, + basis_emb_size=basis_emb_size, + num_blocks=num_blocks, + num_spherical=num_spherical, + num_radial=num_radial, + cutoff=cutoff, + envelope_exponent=envelope_exponent, + num_before_skip=num_before_skip, + num_after_skip=num_after_skip, + num_dense_output=num_dense_output, + num_targets=num_targets, + activation=activation, + extensive=extensive, + output_init=output_init, + use_output_mlp=use_output_mlp, + output_embedding=output_embedding, + output_mlp=output_mlp + ) + + if output_scaling is not None: + scaler = get_scaler(output_scaling["name"])(**output_scaling) + if scaler.extensive: + # Node information must be numbers, or we need an additional input. + out = scaler([out, n, batch_id_node]) + else: + out = scaler(out) + + # Output embedding choice + out = template_cast_output( + [out, batch_id_node, batch_id_edge, node_id, edge_id, count_nodes, count_edges], + output_embedding=output_embedding, output_tensor_type=output_tensor_type, + input_tensor_type=input_tensor_type, cast_disjoint_kwargs=cast_disjoint_kwargs, + ) + + model = ks.models.Model(inputs=model_inputs, outputs=out, name=name) + + model.__kgcnn_model_version__ = __model_version__ + + if output_scaling is not None: + def set_scale(*args, **kwargs): + scaler.set_scale(*args, **kwargs) + + setattr(model, "set_scale", set_scale) + + return model + + +make_crystal_model.__doc__ = make_crystal_model.__doc__ % ( + template_cast_list_input.__doc__, template_cast_output.__doc__) diff --git a/kgcnn/literature/DimeNetPP/_model.py b/kgcnn/literature/DimeNetPP/_model.py new file mode 100644 index 00000000..d14c73ce --- /dev/null +++ b/kgcnn/literature/DimeNetPP/_model.py @@ -0,0 +1,154 @@ +from keras.layers import Add, Subtract, Concatenate, Dense +from kgcnn.layers.geom import NodePosition, NodeDistanceEuclidean, BesselBasisLayer, EdgeAngle, ShiftPeriodicLattice +from kgcnn.layers.gather import GatherNodes +from kgcnn.layers.pooling import PoolingNodes +from kgcnn.layers.mlp import MLP +from ._layers import DimNetInteractionPPBlock, EmbeddingDimeBlock, SphericalBasisLayer, DimNetOutputBlock + + +def model_disjoint( + inputs, + use_node_embedding, + input_node_embedding: dict = None, + emb_size: int = None, + out_emb_size: int = None, + int_emb_size: int = None, + basis_emb_size: int = None, + num_blocks: int = None, + num_spherical: int = None, + num_radial: int = None, + cutoff: float = None, + envelope_exponent: int = None, + num_before_skip: int = None, + num_after_skip: int = None, + num_dense_output: int = None, + num_targets: int = None, + activation: str = None, + extensive: bool = None, + output_init: str = None, + use_output_mlp: bool = None, + output_embedding: str = None, + output_mlp: dict = None +): + n, x, edi, adi, batch_id_node, count_nodes = inputs + + # Atom embedding + if use_node_embedding: + n = EmbeddingDimeBlock(**input_node_embedding)(n) + + # Calculate distances + pos1, pos2 = NodePosition()([x, edi]) + d = NodeDistanceEuclidean()([pos1, pos2]) + rbf = BesselBasisLayer(num_radial=num_radial, cutoff=cutoff, envelope_exponent=envelope_exponent)(d) + + # Calculate angles + v12 = Subtract()([pos1, pos2]) + a = EdgeAngle()([v12, adi]) + sbf = SphericalBasisLayer(num_spherical=num_spherical, num_radial=num_radial, cutoff=cutoff, + envelope_exponent=envelope_exponent)([d, a, adi]) + + # Embedding block + rbf_emb = Dense(emb_size, use_bias=True, activation=activation, + kernel_initializer="kgcnn>glorot_orthogonal")(rbf) + n_pairs = GatherNodes()([n, edi]) + x = Concatenate(axis=-1)([n_pairs, rbf_emb]) + x = Dense(emb_size, use_bias=True, activation=activation, kernel_initializer="kgcnn>glorot_orthogonal")(x) + ps = DimNetOutputBlock(emb_size, out_emb_size, num_dense_output, num_targets=num_targets, + output_kernel_initializer=output_init)([n, x, rbf, edi]) + + # Interaction blocks + add_xp = Add() + for i in range(num_blocks): + x = DimNetInteractionPPBlock(emb_size, int_emb_size, basis_emb_size, num_before_skip, num_after_skip)( + [x, rbf, sbf, adi]) + p_update = DimNetOutputBlock(emb_size, out_emb_size, num_dense_output, num_targets=num_targets, + output_kernel_initializer=output_init)([n, x, rbf, edi]) + ps = add_xp([ps, p_update]) + + if extensive: + out = PoolingNodes(pooling_method="sum")(ps) + else: + out = PoolingNodes(pooling_method="mean")(ps) + + if use_output_mlp: + out = MLP(**output_mlp)(out) + + if output_embedding != "graph": + raise ValueError("Unsupported output embedding for mode `DimeNetPP`. ") + + return out + + +def model_disjoint_crystal( + inputs, + use_node_embedding, + input_node_embedding: dict = None, + emb_size: int = None, + out_emb_size: int = None, + int_emb_size: int = None, + basis_emb_size: int = None, + num_blocks: int = None, + num_spherical: int = None, + num_radial: int = None, + cutoff: float = None, + envelope_exponent: int = None, + num_before_skip: int = None, + num_after_skip: int = None, + num_dense_output: int = None, + num_targets: int = None, + activation: str = None, + extensive: bool = None, + output_init: str = None, + use_output_mlp: bool = None, + output_embedding: str = None, + output_mlp: dict = None + ): + + n, x, edi, adi, edge_image, lattice, batch_id_node, batch_id_edge, count_nodes = inputs + + # Atom embedding + if use_node_embedding: + n = EmbeddingDimeBlock(**input_node_embedding)(n) + + # Calculate distances + pos1, pos2 = NodePosition()([x, edi]) + pos2 = ShiftPeriodicLattice()([pos2, edge_image, lattice, batch_id_edge]) + d = NodeDistanceEuclidean()([pos1, pos2]) + rbf = BesselBasisLayer(num_radial=num_radial, cutoff=cutoff, envelope_exponent=envelope_exponent)(d) + + # Calculate angles + v12 = Subtract()([pos1, pos2]) + a = EdgeAngle()([v12, adi]) + sbf = SphericalBasisLayer(num_spherical=num_spherical, num_radial=num_radial, cutoff=cutoff, + envelope_exponent=envelope_exponent)([d, a, adi]) + + # Embedding block + rbf_emb = Dense(emb_size, use_bias=True, activation=activation, + kernel_initializer="kgcnn>glorot_orthogonal")(rbf) + n_pairs = GatherNodes()([n, edi]) + x = Concatenate(axis=-1)([n_pairs, rbf_emb]) + x = Dense(emb_size, use_bias=True, activation=activation, kernel_initializer="kgcnn>glorot_orthogonal")(x) + ps = DimNetOutputBlock(emb_size, out_emb_size, num_dense_output, num_targets=num_targets, + output_kernel_initializer=output_init)([n, x, rbf, edi]) + + # Interaction blocks + add_xp = Add() + for i in range(num_blocks): + x = DimNetInteractionPPBlock(emb_size, int_emb_size, basis_emb_size, num_before_skip, num_after_skip)( + [x, rbf, sbf, adi]) + p_update = DimNetOutputBlock(emb_size, out_emb_size, num_dense_output, num_targets=num_targets, + output_kernel_initializer=output_init)([n, x, rbf, edi]) + ps = add_xp([ps, p_update]) + + if extensive: + out = PoolingNodes(pooling_method="sum")(ps) + else: + out = PoolingNodes(pooling_method="mean")(ps) + + if use_output_mlp: + out = MLP(**output_mlp)(out) + + if output_embedding != "graph": + raise ValueError("Unsupported output embedding for mode `DimeNetPP`. ") + + return out diff --git a/kgcnn/literature/EGNN/__init__.py b/kgcnn/literature/EGNN/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/kgcnn/literature/EGNN/_make.py b/kgcnn/literature/EGNN/_make.py new file mode 100644 index 00000000..295e85af --- /dev/null +++ b/kgcnn/literature/EGNN/_make.py @@ -0,0 +1,214 @@ +import keras as ks +from kgcnn.layers.scale import get as get_scaler +from ._model import model_disjoint +from kgcnn.layers.modules import Input +from kgcnn.models.casting import template_cast_output, template_cast_list_input +from kgcnn.models.utils import update_model_kwargs +from keras.backend import backend as backend_to_use + +# To be updated if model is changed in a significant way. +__model_version__ = "2023-12-04" + +# Supported backends +__kgcnn_model_backend_supported__ = ["tensorflow", "torch", "jax"] +if backend_to_use() not in __kgcnn_model_backend_supported__: + raise NotImplementedError("Backend '%s' for model 'EGNN' is not supported." % backend_to_use()) + +# Implementation of EGNN in `keras` from paper: +# E(n) Equivariant Graph Neural Networks +# by Victor Garcia Satorras, Emiel Hoogeboom, Max Welling (2021) +# https://arxiv.org/abs/2102.09844 + + +model_default = { + "name": "EGNN", + "inputs": [ + {"shape": (None,), "name": "node_number", "dtype": "int64", "ragged": True}, + {"shape": (None, 3), "name": "node_coordinates", "dtype": "float32", "ragged": True}, + {"shape": (None, 10), "name": "edge_attributes", "dtype": "float32", "ragged": True}, + {"shape": (None, 2), "name": "edge_indices", "dtype": "int64", "ragged": True}, + ], + "input_tensor_type": "padded", + "cast_disjoint_kwargs": {}, + "input_embedding": None, + "input_node_embedding": {"input_dim": 95, "output_dim": 64}, + "input_edge_embedding": {"input_dim": 95, "output_dim": 64}, + "depth": 4, + "node_mlp_initialize": None, + "euclidean_norm_kwargs": {"keepdims": True, "axis": 2}, + "use_edge_attributes": True, + "edge_mlp_kwargs": {"units": [64, 64], "activation": ["swish", "linear"]}, + "edge_attention_kwargs": None, # {"units: 1", "activation": "sigmoid"} + "use_normalized_difference": False, + "expand_distance_kwargs": None, + "coord_mlp_kwargs": {"units": [64, 1], "activation": ["swish", "linear"]}, # option: "tanh" at the end. + "pooling_coord_kwargs": {"pooling_method": "mean"}, + "pooling_edge_kwargs": {"pooling_method": "sum"}, + "node_normalize_kwargs": None, + "use_node_attributes": False, + "node_mlp_kwargs": {"units": [64, 64], "activation": ["swish", "linear"]}, + "use_skip": True, + "verbose": 10, + "node_decoder_kwargs": None, + "node_pooling_kwargs": {"pooling_method": "sum"}, + "output_embedding": "graph", + "output_to_tensor": None, # deprecated + "output_tensor_type": "padded", + "output_mlp": {"use_bias": [True, True], "units": [64, 1], + "activation": ["swish", "linear"]}, + "output_scaling": None, +} + + +@update_model_kwargs(model_default, update_recursive=0, deprecated=["input_embedding", "output_to_tensor"]) +def make_model(name: str = None, + inputs: list = None, + input_tensor_type: str = None, + cast_disjoint_kwargs: dict = None, + input_embedding: dict = None, # noqa + input_node_embedding: dict = None, + input_edge_embedding: dict = None, + depth: int = None, + euclidean_norm_kwargs: dict = None, + node_mlp_initialize: dict = None, + use_edge_attributes: bool = None, + edge_mlp_kwargs: dict = None, + edge_attention_kwargs: dict = None, + use_normalized_difference: bool = None, + expand_distance_kwargs: dict = None, + coord_mlp_kwargs: dict = None, + pooling_coord_kwargs: dict = None, + pooling_edge_kwargs: dict = None, + node_normalize_kwargs: dict = None, + use_node_attributes: bool = None, + node_mlp_kwargs: dict = None, + use_skip: bool = None, + verbose: int = None, # noqa + node_decoder_kwargs: dict = None, + node_pooling_kwargs: dict = None, + output_embedding: str = None, + output_to_tensor: bool = None, # noqa + output_mlp: dict = None, + output_tensor_type: str = None, + output_scaling: dict = None + ): + r"""Make `EGNN `__ graph network via functional API. + Default parameters can be found in :obj:`kgcnn.literature.EGNN.model_default`. + + **Model inputs**: + Model uses the list template of inputs and standard output template. + The supported inputs are :obj:`[nodes, node_coordinates, edge_attributes, edge_indices, ...]` + with '...' indicating mask or ID tensors following the template below. + + %s + + **Model outputs**: + The standard output template: + + %s + + Args: + name (str): Name of the model. Default is "EGNN". + inputs (list): List of dictionaries unpacked in :obj:`tf.keras.layers.Input`. Order must match model definition. + cast_disjoint_kwargs (dict): Dictionary of arguments for casting layers if used. + input_tensor_type (str): Input type of graph tensor. Default is "padded". + input_embedding (dict): Deprecated in favour of input_node_embedding etc. + input_node_embedding (dict): Dictionary of arguments for nodes unpacked in :obj:`Embedding` layers. + input_edge_embedding (dict): Dictionary of arguments for edge unpacked in :obj:`Embedding` layers. + depth (int): Number of graph embedding units or depth of the network. + euclidean_norm_kwargs (dict): Dictionary of layer arguments unpacked in :obj:`EuclideanNorm`. + node_mlp_initialize (dict): Dictionary of layer arguments unpacked in :obj:`GraphMLP` layer for start embedding. + use_edge_attributes (bool): Whether to use edge attributes including for example further edge information. + edge_mlp_kwargs (dict): Dictionary of layer arguments unpacked in :obj:`GraphMLP` layer. + edge_attention_kwargs (dict): Dictionary of layer arguments unpacked in :obj:`GraphMLP` layer. + use_normalized_difference (bool): Whether to use a normalized difference vector for nodes. + expand_distance_kwargs (dict): Dictionary of layer arguments unpacked in :obj:`PositionEncodingBasisLayer`. + coord_mlp_kwargs (dict): Dictionary of layer arguments unpacked in :obj:`GraphMLP` layer. + pooling_coord_kwargs (dict): + pooling_edge_kwargs (dict): + node_normalize_kwargs (dict): Dictionary of layer arguments unpacked in :obj:`GraphLayerNormalization` layer. + use_node_attributes (bool): Whether to add node attributes before node MLP. + node_mlp_kwargs (dict): + use_skip (bool): + verbose (int): Level of verbosity. + node_decoder_kwargs (dict): Dictionary of layer arguments unpacked in :obj:`MLP` layer after graph network. + node_pooling_kwargs (dict): Dictionary of layer arguments unpacked in :obj:`PoolingNodes` layers. + output_embedding (str): Main embedding task for graph network. Either "node", "edge" or "graph". + output_to_tensor (bool): Deprecated in favour of `output_tensor_type` . + output_tensor_type (str): Output type of graph tensors such as nodes or edges. Default is "padded". + output_mlp (dict): Dictionary of layer arguments unpacked in the final classification :obj:`MLP` layer block. + Defines number of model outputs and activation. + output_scaling (dict): Dictionary of layer arguments unpacked in scaling layers. + + Returns: + :obj:`keras.models.Model` + """ + # Make input + model_inputs = [Input(**x) for x in inputs] + + dj = template_cast_list_input( + model_inputs, + input_tensor_type=input_tensor_type, + cast_disjoint_kwargs=cast_disjoint_kwargs, + has_edges=True, + has_nodes=2 + ) + + n, x, ed, disjoint_indices, batch_id_node, batch_id_edge, node_id, edge_id, count_nodes, count_edges = dj + + out = model_disjoint( + [n, x, ed, disjoint_indices, batch_id_node, batch_id_edge, count_nodes, count_edges], + use_node_embedding=("int" in inputs[0]['dtype']) if input_node_embedding is not None else False, + use_edge_embedding=("int" in inputs[2]['dtype']) if input_edge_embedding is not None else False, + input_node_embedding=input_node_embedding, + input_edge_embedding=input_edge_embedding, + depth=depth, + euclidean_norm_kwargs=euclidean_norm_kwargs, + node_mlp_initialize=node_mlp_initialize, + use_edge_attributes=use_edge_attributes, + edge_mlp_kwargs=edge_mlp_kwargs, + edge_attention_kwargs=edge_attention_kwargs, + use_normalized_difference=use_normalized_difference, + expand_distance_kwargs=expand_distance_kwargs, + coord_mlp_kwargs=coord_mlp_kwargs, + pooling_coord_kwargs=pooling_coord_kwargs, + pooling_edge_kwargs=pooling_edge_kwargs, + node_normalize_kwargs=node_normalize_kwargs, + use_node_attributes=use_node_attributes, + node_mlp_kwargs=node_mlp_kwargs, + use_skip=use_skip, + node_decoder_kwargs=node_decoder_kwargs, + node_pooling_kwargs=node_pooling_kwargs, + output_embedding=output_embedding, + output_mlp=output_mlp + ) + + if output_scaling is not None: + scaler = get_scaler(output_scaling["name"])(**output_scaling) + if scaler.extensive: + # Node information must be numbers, or we need an additional input. + out = scaler([out, n, batch_id_node]) + else: + out = scaler(out) + + # Output embedding choice + out = template_cast_output( + [out, batch_id_node, batch_id_edge, node_id, edge_id, count_nodes, count_edges], + output_embedding=output_embedding, output_tensor_type=output_tensor_type, + input_tensor_type=input_tensor_type, cast_disjoint_kwargs=cast_disjoint_kwargs, + ) + + model = ks.models.Model(inputs=model_inputs, outputs=out, name=name) + + model.__kgcnn_model_version__ = __model_version__ + + if output_scaling is not None: + def set_scale(*args, **kwargs): + scaler.set_scale(*args, **kwargs) + + setattr(model, "set_scale", set_scale) + + return model + + +make_model.__doc__ = make_model.__doc__ % (template_cast_list_input.__doc__, template_cast_output.__doc__) diff --git a/kgcnn/literature/EGNN/_model.py b/kgcnn/literature/EGNN/_model.py new file mode 100644 index 00000000..02acbe70 --- /dev/null +++ b/kgcnn/literature/EGNN/_model.py @@ -0,0 +1,106 @@ +from keras.layers import Add, Concatenate, Multiply, Subtract +from kgcnn.layers.gather import GatherNodes +from kgcnn.layers.aggr import AggregateLocalEdges +from kgcnn.layers.modules import Embedding +from kgcnn.layers.mlp import GraphMLP, MLP +from kgcnn.layers.norm import GraphLayerNormalization +from kgcnn.layers.geom import NodePosition, EuclideanNorm, EdgeDirectionNormalized, PositionEncodingBasisLayer +from kgcnn.layers.pooling import PoolingNodes + + +def model_disjoint( + inputs, + use_node_embedding, + use_edge_embedding, + input_node_embedding: dict = None, + input_edge_embedding: dict = None, + depth: int = None, + euclidean_norm_kwargs: dict = None, + node_mlp_initialize: dict = None, + use_edge_attributes: bool = None, + edge_mlp_kwargs: dict = None, + edge_attention_kwargs: dict = None, + use_normalized_difference: bool = None, + expand_distance_kwargs: dict = None, + coord_mlp_kwargs: dict = None, + pooling_coord_kwargs: dict = None, + pooling_edge_kwargs: dict = None, + node_normalize_kwargs: dict = None, + use_node_attributes: bool = None, + node_mlp_kwargs: dict = None, + use_skip: bool = None, + node_decoder_kwargs: dict = None, + node_pooling_kwargs: dict = None, + output_embedding: str = None, + output_mlp: dict = None +): + h0, x, ed, edi, batch_id_node, batch_id_edge, count_nodes, count_edges = inputs + # Make input + + # Embedding, if no feature dimension + if use_node_embedding: + h0 = Embedding(**input_node_embedding)(h0) + if use_edge_embedding: + ed = Embedding(**input_edge_embedding)(ed) + + # Model + h = GraphMLP(**node_mlp_initialize)([h0, batch_id_node, count_nodes]) if node_mlp_initialize else h0 + for i in range(0, depth): + pos1, pos2 = NodePosition()([x, edi]) + diff_x = Subtract()([pos1, pos2]) + norm_x = EuclideanNorm(**euclidean_norm_kwargs)(diff_x) + # Original code has a normalize option for coord-differences. + if use_normalized_difference: + diff_x = EdgeDirectionNormalized()([pos1, pos2]) + if expand_distance_kwargs: + norm_x = PositionEncodingBasisLayer()(norm_x) + + # Edge model + h_i, h_j = GatherNodes([0, 1], concat_axis=None)([h, edi]) + if use_edge_attributes: + m_ij = Concatenate()([h_i, h_j, norm_x, ed]) + else: + m_ij = Concatenate()([h_i, h_j, norm_x]) + if edge_mlp_kwargs: + m_ij = GraphMLP(**edge_mlp_kwargs)([m_ij, batch_id_edge, count_edges]) + if edge_attention_kwargs: + m_att = GraphMLP(**edge_attention_kwargs)([m_ij, batch_id_edge, count_edges]) + m_ij = Multiply()([m_att, m_ij]) + + # Coord model + if coord_mlp_kwargs: + m_ij_weights = GraphMLP(**coord_mlp_kwargs)([m_ij, batch_id_edge, count_edges]) + x_trans = Multiply()([m_ij_weights, diff_x]) + agg = AggregateLocalEdges(**pooling_coord_kwargs)([h, x_trans, edi]) + x = Add()([x, agg]) + + # Node model + m_i = AggregateLocalEdges(**pooling_edge_kwargs)([h, m_ij, edi]) + if node_mlp_kwargs: + m_i = Concatenate()([h, m_i]) + if use_node_attributes: + m_i = Concatenate()([m_i, h0]) + m_i = GraphMLP(**node_mlp_kwargs)([m_i, batch_id_node, count_nodes]) + if node_normalize_kwargs: + h = GraphLayerNormalization(**node_normalize_kwargs)([h, batch_id_node, count_nodes]) + if use_skip: + h = Add()([h, m_i]) + else: + h = m_i + + # Output embedding choice + if node_decoder_kwargs: + n = GraphMLP(**node_mlp_kwargs)([h, batch_id_node, count_nodes]) + else: + n = h + + # Final step. + if output_embedding == 'graph': + out = PoolingNodes(**node_pooling_kwargs)([count_nodes, n, batch_id_node]) + out = MLP(**output_mlp)(out) + elif output_embedding == 'node': + out = GraphMLP(**output_mlp)([n, batch_id_node, count_nodes]) + else: + raise ValueError("Unsupported output embedding for mode `SchNet`") + + return out diff --git a/kgcnn/literature/GCN/_make.py b/kgcnn/literature/GCN/_make.py index ec2153a0..e23b4866 100644 --- a/kgcnn/literature/GCN/_make.py +++ b/kgcnn/literature/GCN/_make.py @@ -6,9 +6,6 @@ from kgcnn.models.casting import template_cast_output, template_cast_list_input from keras.backend import backend as backend_to_use -# from keras_core.layers import Activation -# from kgcnn.layers.aggr import AggregateWeightedLocalEdges -# from kgcnn.layers.gather import GatherNodesOutgoing # Keep track of model version from commit date in literature. __kgcnn_model_version__ = "2023-09-30" diff --git a/kgcnn/literature/GCN/_model.py b/kgcnn/literature/GCN/_model.py index 138084f2..e15aa74b 100644 --- a/kgcnn/literature/GCN/_model.py +++ b/kgcnn/literature/GCN/_model.py @@ -4,6 +4,10 @@ from kgcnn.layers.modules import Embedding from kgcnn.layers.pooling import PoolingNodes, PoolingWeightedNodes +# from keras_core.layers import Activation +# from kgcnn.layers.aggr import AggregateWeightedLocalEdges +# from kgcnn.layers.gather import GatherNodesOutgoing + def model_disjoint(inputs, use_node_embedding: bool = None, diff --git a/kgcnn/literature/GNNFilm/__init__.py b/kgcnn/literature/GNNFilm/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/kgcnn/literature/GNNFilm/_make.py b/kgcnn/literature/GNNFilm/_make.py new file mode 100644 index 00000000..25d20ef2 --- /dev/null +++ b/kgcnn/literature/GNNFilm/_make.py @@ -0,0 +1,157 @@ +import keras as ks +from kgcnn.layers.scale import get as get_scaler +from ._model import model_disjoint +from kgcnn.layers.modules import Input +from kgcnn.models.utils import update_model_kwargs +from kgcnn.models.casting import template_cast_output, template_cast_list_input +from keras.backend import backend as backend_to_use + + +# Keep track of model version from commit date in literature. +__kgcnn_model_version__ = "2023-12-04" + +# Supported backends +__kgcnn_model_backend_supported__ = ["tensorflow", "torch", "jax"] +if backend_to_use() not in __kgcnn_model_backend_supported__: + raise NotImplementedError("Backend '%s' for model 'GNNFilm' is not supported." % backend_to_use()) + +# Implementation of GNNFilm in `keras` from paper: +# GNN-FiLM: Graph Neural Networks with Feature-wise Linear Modulation +# Marc Brockschmidt +# https://arxiv.org/abs/1906.12192 + + +model_default = { + "name": "GNNFilm", + "inputs": [ + {"shape": (None,), "name": "node_attributes", "dtype": "int64"}, + {"shape": (None, ), "name": "edge_relations", "dtype": "int64"}, + {"shape": (None, 2), "name": "edge_indices", "dtype": "int64"}, + {"shape": (), "name": "total_nodes", "dtype": "int64"}, + {"shape": (), "name": "total_edges", "dtype": "int64"} + ], + "input_tensor_type": "padded", + "input_embedding": None, # deprecated + "cast_disjoint_kwargs": {}, + "input_node_embedding": {"input_dim": 95, "output_dim": 64}, + "dense_relation_kwargs": {"units": 64, "num_relations": 20}, + "dense_modulation_kwargs": {"units": 64, "num_relations": 20, "activation": "sigmoid"}, + "activation_kwargs": {"activation": "swish"}, + "depth": 3, + "verbose": 10, + "node_pooling_kwargs": {}, + "output_embedding": 'graph', + "output_scaling": None, + "output_tensor_type": "padded", + "output_to_tensor": None, # deprecated + "output_mlp": {"use_bias": True, "units": 1, + "activation": "softmax"} +} + + +@update_model_kwargs(model_default, update_recursive=0, deprecated=["input_embedding", "output_to_tensor"]) +def make_model(inputs: list = None, + input_tensor_type: str = None, + cast_disjoint_kwargs: dict = None, + input_embedding: dict = None, # noqa + input_node_embedding: dict = None, + depth: int = None, + dense_relation_kwargs: dict = None, + dense_modulation_kwargs: dict = None, + activation_kwargs: dict = None, + name: str = None, + verbose: int = None, # noqa + node_pooling_kwargs: dict = None, + output_embedding: str = None, + output_to_tensor: bool = None, # noqa + output_scaling: dict = None, + output_tensor_type: str = None, + output_mlp: dict = None + ): + r"""Make `GNNFilm `__ graph network via functional API. + Default parameters can be found in :obj:`kgcnn.literature.RGCN.model_default`. + + **Model inputs**: + Model uses the list template of inputs and standard output template. + The supported inputs are :obj:`[nodes, edge_relations, edge_indices, ...]` + with '...' indicating mask or ID tensors following the template below. + The edge relations do not have a feature dimension and specify the relation of each edge of type 'int'. + Edges are actually edge single weight values which are entries of the pre-scaled adjacency matrix. + + %s + + **Model outputs**: + The standard output template: + + %s + + Args: + inputs (list): List of dictionaries unpacked in :obj:`tf.keras.layers.Input`. Order must match model definition. + input_tensor_type (str): Input type of graph tensor. Default is "padded". + cast_disjoint_kwargs (dict): Dictionary of arguments for casting layers if used. + input_embedding (dict): Deprecated in favour of input_node_embedding etc. + input_node_embedding (dict): Dictionary of embedding arguments unpacked in :obj:`Embedding` layers. + depth (int): Number of graph embedding units or depth of the network. + dense_relation_kwargs (dict): Dictionary of layer arguments unpacked in :obj:`RelationalDense` layer. + dense_modulation_kwargs (dict): Dictionary of layer arguments unpacked in :obj:`RelationalDense` layer. + activation_kwargs (dict): Dictionary of layer arguments unpacked in :obj:`Activation` layer. + name (str): Name of the model. + verbose (int): Level of print output. + node_pooling_kwargs (dict): Dictionary of layer arguments unpacked in :obj:`PoolingNodes` layer. + output_embedding (str): Main embedding task for graph network. Either "node", "edge" or "graph". + output_to_tensor (bool): Whether to cast model output to :obj:`tf.Tensor`. + output_mlp (dict): Dictionary of layer arguments unpacked in the final classification :obj:`MLP` layer block. + Defines number of model outputs and activation. + output_tensor_type (str): Output type of graph tensors such as nodes or edges. Default is "padded". + output_scaling (dict): Dictionary of layer arguments unpacked in scaling layers. Default is None. + + Returns: + :obj:`keras.models.Model` + """ + # Make input + model_inputs = [Input(**x) for x in inputs] + + dj_inputs = template_cast_list_input( + model_inputs, + input_tensor_type=input_tensor_type, + cast_disjoint_kwargs=cast_disjoint_kwargs + ) + + n, er, disjoint_indices, batch_id_node, batch_id_edge, node_id, edge_id, count_nodes, count_edges = dj_inputs + + out = model_disjoint( + [n, er, disjoint_indices, batch_id_node, count_nodes], + use_node_embedding=("int" in inputs[0]['dtype']) if input_node_embedding is not None else False, + input_node_embedding=input_node_embedding, + depth=depth, + dense_modulation_kwargs=dense_modulation_kwargs, + dense_relation_kwargs=dense_relation_kwargs, + activation_kwargs=activation_kwargs, + output_embedding=output_embedding, + output_mlp=output_mlp, + node_pooling_kwargs=node_pooling_kwargs + ) + + if output_scaling is not None: + scaler = get_scaler(output_scaling["name"])(**output_scaling) + out = scaler(out) + + # Output embedding choice + out = template_cast_output( + [out, batch_id_node, batch_id_edge, node_id, edge_id, count_nodes, count_edges], + output_embedding=output_embedding, output_tensor_type=output_tensor_type, + input_tensor_type=input_tensor_type, cast_disjoint_kwargs=cast_disjoint_kwargs + ) + + model = ks.models.Model(inputs=model_inputs, outputs=out, name=name) + model.__kgcnn_model_version__ = __kgcnn_model_version__ + + if output_scaling is not None: + def set_scale(*args, **kwargs): + scaler.set_scale(*args, **kwargs) + + setattr(model, "set_scale", set_scale) + return model + + +make_model.__doc__ = make_model.__doc__ % (template_cast_list_input.__doc__, template_cast_output.__doc__) diff --git a/kgcnn/literature/GNNFilm/_model.py b/kgcnn/literature/GNNFilm/_model.py new file mode 100644 index 00000000..ff830eaa --- /dev/null +++ b/kgcnn/literature/GNNFilm/_model.py @@ -0,0 +1,49 @@ +from keras.layers import Dense, Add, Multiply, Activation +from kgcnn.layers.modules import Embedding +from kgcnn.layers.gather import GatherNodes +from kgcnn.layers.relational import RelationalDense +from kgcnn.layers.aggr import AggregateLocalEdges +from kgcnn.layers.pooling import PoolingNodes +from kgcnn.layers.mlp import MLP, GraphMLP + + +def model_disjoint( + inputs, + use_node_embedding, + input_node_embedding=None, + depth=None, + dense_modulation_kwargs=None, + dense_relation_kwargs=None, + activation_kwargs=None, + output_embedding=None, + output_mlp=None, + node_pooling_kwargs=None +): + n, edge_relations, edi, batch_id_node, count_nodes = inputs + + # Embedding, if no feature dimension + if use_node_embedding: + n = Embedding(**input_node_embedding)(n) + + # Model + for i in range(0, depth): + n_i, n_j = GatherNodes(selection_index=[0, 1], concat_axis=None)([n, edi]) + # Note: This maybe could be done more efficiently. + gamma = RelationalDense(**dense_modulation_kwargs)([n_i, edge_relations]) + beta = RelationalDense(**dense_modulation_kwargs)([n_i, edge_relations]) + h_j = RelationalDense(**dense_relation_kwargs)([n_j, edge_relations]) + m = Multiply()([h_j, gamma]) + m = Add()([m, beta]) + h = AggregateLocalEdges(pooling_method="sum")([n, m, edi]) + n = Activation(**activation_kwargs)(h) + + # Output embedding choice + if output_embedding == "graph": + out = PoolingNodes(**node_pooling_kwargs)([count_nodes, n, batch_id_node]) # will return tensor + out = MLP(**output_mlp)(out) + elif output_embedding == "node": # Node labeling + out = GraphMLP(**output_mlp)([n, batch_id_node, count_nodes]) + else: + raise ValueError("Unsupported output embedding for mode `GNNFilm`") + + return out diff --git a/kgcnn/literature/Megnet/__init__.py b/kgcnn/literature/Megnet/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/kgcnn/literature/Megnet/_layers.py b/kgcnn/literature/Megnet/_layers.py new file mode 100644 index 00000000..c3e71102 --- /dev/null +++ b/kgcnn/literature/Megnet/_layers.py @@ -0,0 +1,134 @@ +from keras.layers import Layer, Dense, Concatenate +from kgcnn.layers.gather import GatherNodes, GatherState +from kgcnn.layers.aggr import AggregateLocalEdges +from kgcnn.layers.pooling import PoolingNodes + + +PoolingGlobalEdges = PoolingNodes + + +class MEGnetBlock(Layer): + r"""Convolutional unit of `MegNet `_ called MegNet Block.""" + + def __init__(self, + node_embed=None, + edge_embed=None, + env_embed=None, + pooling_method="mean", + use_bias=True, + activation='kgcnn>softplus2', + kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, + kernel_constraint=None, bias_constraint=None, + kernel_initializer='glorot_uniform', bias_initializer='zeros', + **kwargs): + """Initialize layer. + + Args: + node_embed (list, optional): List of node embedding dimension. Defaults to [16,16,16]. + edge_embed (list, optional): List of edge embedding dimension. Defaults to [16,16,16]. + env_embed (list, optional): List of environment embedding dimension. Defaults to [16,16,16]. + pooling_method (str): Pooling method information for layer. Default is 'mean'. + use_bias (bool, optional): Use bias. Defaults to True. + activation (str): Activation function. Default is 'kgcnn>softplus2'. + kernel_regularizer: Kernel regularization. Default is None. + bias_regularizer: Bias regularization. Default is None. + activity_regularizer: Activity regularization. Default is None. + kernel_constraint: Kernel constrains. Default is None. + bias_constraint: Bias constrains. Default is None. + kernel_initializer: Initializer for kernels. Default is 'glorot_uniform'. + bias_initializer: Initializer for bias. Default is 'zeros'. + """ + super(MEGnetBlock, self).__init__(**kwargs) + self.pooling_method = pooling_method + if node_embed is None: + node_embed = [16, 16, 16] + if env_embed is None: + env_embed = [16, 16, 16] + if edge_embed is None: + edge_embed = [16, 16, 16] + self.node_embed = node_embed + self.edge_embed = edge_embed + self.env_embed = env_embed + self.use_bias = use_bias + kernel_args = {"kernel_regularizer": kernel_regularizer, "activity_regularizer": activity_regularizer, + "bias_regularizer": bias_regularizer, "kernel_constraint": kernel_constraint, + "bias_constraint": bias_constraint, "kernel_initializer": kernel_initializer, + "bias_initializer": bias_initializer, "use_bias": use_bias} + + # Node + self.lay_phi_n = Dense(units=self.node_embed[0], activation=activation, **kernel_args) + self.lay_phi_n_1 = Dense(units=self.node_embed[1], activation=activation, **kernel_args) + self.lay_phi_n_2 = Dense(units=self.node_embed[2], activation='linear', **kernel_args) + self.lay_esum = AggregateLocalEdges(pooling_method=self.pooling_method) + self.lay_gather_un = GatherState() + self.lay_conc_nu = Concatenate(axis=-1) + # Edge + self.lay_phi_e = Dense(units=self.edge_embed[0], activation=activation, **kernel_args) + self.lay_phi_e_1 = Dense(units=self.edge_embed[1], activation=activation, **kernel_args) + self.lay_phi_e_2 = Dense(units=self.edge_embed[2], activation='linear', **kernel_args) + self.lay_gather_n = GatherNodes() + self.lay_gather_ue = GatherState() + self.lay_conc_enu = Concatenate(axis=-1) + # Environment + self.lay_usum_e = PoolingGlobalEdges(pooling_method=self.pooling_method) + self.lay_usum_n = PoolingNodes(pooling_method=self.pooling_method) + self.lay_conc_u = Concatenate(axis=-1) + self.lay_phi_u = Dense(units=self.env_embed[0], activation=activation, **kernel_args) + self.lay_phi_u_1 = Dense(units=self.env_embed[1], activation=activation, **kernel_args) + self.lay_phi_u_2 = Dense(units=self.env_embed[2], activation='linear', **kernel_args) + + def build(self, input_shape): + """Build layer.""" + super(MEGnetBlock, self).build(input_shape) + + def call(self, inputs, **kwargs): + """Forward pass. + + Args: + inputs: [nodes, edges, tensor_index, state, batch_id_node, batch_id_edge, count_nodes, count_edges] + + - nodes (Tensor): Node embeddings of shape ([N], F) + - edges (Tensor): Edge or message embeddings of shape ([M], F) + - tensor_index (Tensor): Edge indices referring to nodes of shape (2, [M]) + - state (Tensor): State information for the graph, a single tensor of shape (batch, F) + - graph_id_node (Tensor): ID tensor of batch assignment in disjoint graph of shape `([N], )` . + - graph_id_edge (Tensor): ID tensor of batch assignment in disjoint graph of shape `([M], )` . + - nodes_count (Tensor): Tensor of number of nodes for each graph of shape `(batch, )` . + - edges_count (Tensor): Tensor of number of edges for each graph of shape `(batch, )` . + + Returns: + Tensor: Updated node embeddings of shape ([N], F) + """ + # Calculate edge Update + node_input, edge_input, edge_index_input, env_input, batch_id_node, batch_id_edge, count_nodes, count_edges = inputs + e_n = self.lay_gather_n([node_input, edge_index_input], **kwargs) + e_u = self.lay_gather_ue([env_input, batch_id_edge], **kwargs) + ec = self.lay_conc_enu([e_n, edge_input, e_u], **kwargs) + ep = self.lay_phi_e(ec, **kwargs) # Learning of Update Functions + ep = self.lay_phi_e_1(ep, **kwargs) # Learning of Update Functions + ep = self.lay_phi_e_2(ep, **kwargs) # Learning of Update Functions + # Calculate Node update + vb = self.lay_esum([node_input, ep, edge_index_input], **kwargs) # Summing for each node connections + v_u = self.lay_gather_un([env_input, batch_id_node], **kwargs) + vc = self.lay_conc_nu([vb, node_input, v_u], **kwargs) # LazyConcatenate node features with new edge updates + vp = self.lay_phi_n(vc, **kwargs) # Learning of Update Functions + vp = self.lay_phi_n_1(vp, **kwargs) # Learning of Update Functions + vp = self.lay_phi_n_2(vp, **kwargs) # Learning of Update Functions + # Calculate environment update + es = self.lay_usum_e([count_edges, ep, batch_id_edge], **kwargs) + vs = self.lay_usum_n([count_nodes, vp, batch_id_node], **kwargs) + ub = self.lay_conc_u([es, vs, env_input], **kwargs) + up = self.lay_phi_u(ub, **kwargs) + up = self.lay_phi_u_1(up, **kwargs) + up = self.lay_phi_u_2(up, **kwargs) # Learning of Update Functions + return vp, ep, up + + def get_config(self): + config = super(MEGnetBlock, self).get_config() + config.update({"pooling_method": self.pooling_method, "node_embed": self.node_embed, "use_bias": self.use_bias, + "edge_embed": self.edge_embed, "env_embed": self.env_embed}) + config_dense = self.lay_phi_n.get_config() + for x in ["kernel_regularizer", "activity_regularizer", "bias_regularizer", "kernel_constraint", + "bias_constraint", "kernel_initializer", "bias_initializer", "activation"]: + config.update({x: config_dense[x]}) + return config diff --git a/kgcnn/literature/Megnet/_make.py b/kgcnn/literature/Megnet/_make.py new file mode 100644 index 00000000..fac956eb --- /dev/null +++ b/kgcnn/literature/Megnet/_make.py @@ -0,0 +1,366 @@ +import keras as ks +from kgcnn.layers.scale import get as get_scaler +from ._model import model_disjoint, model_disjoint_crystal +from kgcnn.layers.modules import Input +from kgcnn.models.casting import template_cast_output, template_cast_list_input +from kgcnn.models.utils import update_model_kwargs +from keras.backend import backend as backend_to_use + +# To be updated if model is changed in a significant way. +__model_version__ = "2023-12-05" + +# Supported backends +__kgcnn_model_backend_supported__ = ["tensorflow", "torch", "jax"] +if backend_to_use() not in __kgcnn_model_backend_supported__: + raise NotImplementedError("Backend '%s' for model 'Megnet' is not supported." % backend_to_use()) + +# Implementation of Megnet in `tf.keras` from paper: +# Graph Networks as a Universal Machine Learning Framework for Molecules and Crystals +# by Chi Chen, Weike Ye, Yunxing Zuo, Chen Zheng, and Shyue Ping Ong* +# https://github.com/materialsvirtuallab/megnet +# https://pubs.acs.org/doi/10.1021/acs.chemmater.9b01294 + + +model_default = { + "name": "Megnet", + "inputs": [ + {"shape": (None,), "name": "node_number", "dtype": "int64"}, + {"shape": (None, 3), "name": "node_coordinates", "dtype": "float32"}, + {"shape": (None, 2), "name": "edge_indices", "dtype": "int64"}, + {"shape": (), "name": "graph_number", "dtype": "int64"}, + {"shape": (), "name": "total_nodes", "dtype": "int64"}, + {"shape": (), "name": "total_edges", "dtype": "int64"} + ], + "input_tensor_type": "padded", + "input_embedding": None, # deprecated + "cast_disjoint_kwargs": {}, + "input_node_embedding": {"input_dim": 95, "output_dim": 64}, + "input_graph_embedding": {"input_dim": 100, "output_dim": 64}, + "make_distance": True, "expand_distance": True, + "gauss_args": {"bins": 20, "distance": 4, "offset": 0.0, "sigma": 0.4}, + "meg_block_args": {"node_embed": [64, 32, 32], "edge_embed": [64, 32, 32], + "env_embed": [64, 32, 32], "activation": "kgcnn>softplus2"}, + "set2set_args": {"channels": 16, "T": 3, "pooling_method": "sum", "init_qstar": "0"}, + "node_ff_args": {"units": [64, 32], "activation": "kgcnn>softplus2"}, + "edge_ff_args": {"units": [64, 32], "activation": "kgcnn>softplus2"}, + "state_ff_args": {"units": [64, 32], "activation": "kgcnn>softplus2"}, + "nblocks": 3, "has_ff": True, "dropout": None, "use_set2set": True, + "verbose": 10, + "output_embedding": "graph", + "output_mlp": {"use_bias": [True, True, True], "units": [32, 16, 1], + "activation": ["kgcnn>softplus2", "kgcnn>softplus2", "linear"]}, + "output_scaling": None +} + + +@update_model_kwargs(model_default, update_recursive=0, deprecated=["input_embedding", "output_to_tensor"]) +def make_model(inputs: list = None, + input_tensor_type: str = None, + cast_disjoint_kwargs: dict = None, + input_embedding: dict = None, # noqa + input_node_embedding: dict = None, + input_graph_embedding: dict = None, + expand_distance: bool = None, + make_distance: bool = None, + gauss_args: dict = None, + meg_block_args: dict = None, + set2set_args: dict = None, + node_ff_args: dict = None, + edge_ff_args: dict = None, + state_ff_args: dict = None, + use_set2set: bool = None, + nblocks: int = None, + has_ff: bool = None, + dropout: float = None, + name: str = None, + verbose: int = None, # noqa + output_embedding: str = None, + output_mlp: dict = None, + output_tensor_type: str = None, + output_scaling: dict = None + ): + r"""Make `MegNet `__ graph network via functional API. + Default parameters can be found in :obj:`kgcnn.literature.Megnet.model_default`. + + **Model inputs**: + Model uses the list template of inputs and standard output template. + The supported inputs are :obj:`[nodes, coordinates, edge_indices, graph_state, ...]` with `make_distance` and + with '...' indicating mask or ID tensors following the template below. + Note that you could also supply edge features with `make_distance` to False, which would make the input + :obj:`[nodes, edges, edge_indices, graph_state...]` . + + %s + + **Model outputs**: + The standard output template: + + %s + + Args: + inputs (list): List of dictionaries unpacked in :obj:`Input`. Order must match model definition. + input_tensor_type (str): Input type of graph tensor. Default is "padded". + cast_disjoint_kwargs (dict): Dictionary of arguments for casting layer. + input_embedding (dict): Deprecated in favour of input_node_embedding etc. + input_node_embedding (dict): Dictionary of embedding arguments for nodes unpacked in :obj:`Embedding` layers. + input_graph_embedding (dict): Dictionary of embedding arguments for graph unpacked in :obj:`Embedding` layers. + make_distance (bool): Whether input is distance or coordinates at in place of edges. + expand_distance (bool): If the edge input are actual edges or node coordinates instead that are expanded to + form edges with a gauss distance basis given edge indices. Expansion uses `gauss_args`. + gauss_args (dict): Dictionary of layer arguments unpacked in :obj:`GaussBasisLayer` layer. + meg_block_args (dict): Dictionary of layer arguments unpacked in :obj:`MEGnetBlock` layer. + set2set_args (dict): Dictionary of layer arguments unpacked in `:obj:PoolingSet2SetEncoder` layer. + node_ff_args (dict): Dictionary of layer arguments unpacked in :obj:`MLP` feed-forward layer. + edge_ff_args (dict): Dictionary of layer arguments unpacked in :obj:`MLP` feed-forward layer. + state_ff_args (dict): Dictionary of layer arguments unpacked in :obj:`MLP` feed-forward layer. + use_set2set (bool): Whether to use :obj:`PoolingSet2SetEncoder` layer. + nblocks (int): Number of graph embedding blocks or depth of the network. + has_ff (bool): Use feed-forward MLP in each block. + dropout (int): Dropout to use. Default is None. + name (str): Name of the model. + verbose (int): Verbosity level of print. + output_embedding (str): Main embedding task for graph network. Either "node", "edge" or "graph". + output_mlp (dict): Dictionary of layer arguments unpacked in the final classification :obj:`MLP` layer block. + Defines number of model outputs and activation. + output_scaling (dict): Dictionary of layer arguments unpacked in scaling layers. Default is None. + output_tensor_type (str): Output type of graph tensors such as nodes or edges. Default is "padded". + + Returns: + :obj:`keras.models.Model` + """ + # Make input + model_inputs = [Input(**x) for x in inputs] + + dj = template_cast_list_input( + model_inputs, + input_tensor_type=input_tensor_type, + cast_disjoint_kwargs=cast_disjoint_kwargs, + has_edges=(not make_distance), + has_nodes=1 + int(make_distance), + has_graph_state=True + ) + + n, x, disjoint_indices, gs, batch_id_node, batch_id_edge, node_id, edge_id, count_nodes, count_edges = dj + + out = model_disjoint( + [n, x, disjoint_indices, gs, batch_id_node, batch_id_edge, count_nodes, count_edges], + use_node_embedding=("int" in inputs[0]['dtype']) if input_node_embedding is not None else False, + use_graph_embedding=("int" in inputs[3]['dtype']) if input_graph_embedding is not None else False, + input_node_embedding=input_node_embedding, + input_graph_embedding=input_graph_embedding, + expand_distance=expand_distance, + make_distance=make_distance, + gauss_args=gauss_args, + meg_block_args=meg_block_args, + set2set_args=set2set_args, + node_ff_args=node_ff_args, + edge_ff_args=edge_ff_args, + state_ff_args=state_ff_args, + use_set2set=use_set2set, + nblocks=nblocks, + has_ff=has_ff, + dropout=dropout, + output_embedding=output_embedding, + output_mlp=output_mlp + ) + + if output_scaling is not None: + scaler = get_scaler(output_scaling["name"])(**output_scaling) + if scaler.extensive: + # Node information must be numbers, or we need an additional input. + out = scaler([out, n, batch_id_node]) + else: + out = scaler(out) + + # Output embedding choice + out = template_cast_output( + [out, batch_id_node, batch_id_edge, node_id, edge_id, count_nodes, count_edges], + output_embedding=output_embedding, output_tensor_type=output_tensor_type, + input_tensor_type=input_tensor_type, cast_disjoint_kwargs=cast_disjoint_kwargs, + ) + + model = ks.models.Model(inputs=model_inputs, outputs=out, name=name) + + model.__kgcnn_model_version__ = __model_version__ + + if output_scaling is not None: + def set_scale(*args, **kwargs): + scaler.set_scale(*args, **kwargs) + + setattr(model, "set_scale", set_scale) + + return model + + +make_model.__doc__ = make_model.__doc__ % (template_cast_list_input.__doc__, template_cast_output.__doc__) + +model_crystal_default = { + 'name': "Megnet", + 'inputs': [ + {'shape': (None,), 'name': "node_attributes", 'dtype': 'float32', 'ragged': True}, + {'shape': (None, 3), 'name': "node_coordinates", 'dtype': 'float32', 'ragged': True}, + {'shape': (None, 2), 'name': "edge_indices", 'dtype': 'int64', 'ragged': True}, + {'shape': [1], 'name': "charge", 'dtype': 'float32', 'ragged': False}, + {'shape': (None, 3), 'name': "edge_image", 'dtype': 'int64', 'ragged': True}, + {'shape': (3, 3), 'name': "graph_lattice", 'dtype': 'float32', 'ragged': False} + ], + "input_tensor_type": "ragged", + "input_embedding": None, # deprecated + "cast_disjoint_kwargs": {}, + "input_node_embedding": {"input_dim": 95, "output_dim": 64}, + "input_graph_embedding": {"input_dim": 100, "output_dim": 64}, + "make_distance": True, "expand_distance": True, + 'gauss_args': {"bins": 20, "distance": 4, "offset": 0.0, "sigma": 0.4}, + 'meg_block_args': {'node_embed': [64, 32, 32], 'edge_embed': [64, 32, 32], + 'env_embed': [64, 32, 32], 'activation': 'kgcnn>softplus2'}, + 'set2set_args': {'channels': 16, 'T': 3, "pooling_method": "sum", "init_qstar": "0"}, + 'node_ff_args': {"units": [64, 32], "activation": "kgcnn>softplus2"}, + 'edge_ff_args': {"units": [64, 32], "activation": "kgcnn>softplus2"}, + 'state_ff_args': {"units": [64, 32], "activation": "kgcnn>softplus2"}, + 'nblocks': 3, 'has_ff': True, 'dropout': None, 'use_set2set': True, + 'verbose': 10, + 'output_embedding': 'graph', + 'output_mlp': {"use_bias": [True, True, True], "units": [32, 16, 1], + "activation": ['kgcnn>softplus2', 'kgcnn>softplus2', 'linear']}, + "output_scaling": None +} + + +@update_model_kwargs(model_default, update_recursive=0, deprecated=["input_embedding", "output_to_tensor"]) +def make_crystal_model(inputs: list = None, + input_tensor_type: str = None, + cast_disjoint_kwargs: dict = None, + input_embedding: dict = None, # noqa + input_node_embedding: dict = None, + input_graph_embedding: dict = None, + expand_distance: bool = None, + make_distance: bool = None, + gauss_args: dict = None, + meg_block_args: dict = None, + set2set_args: dict = None, + node_ff_args: dict = None, + edge_ff_args: dict = None, + state_ff_args: dict = None, + use_set2set: bool = None, + nblocks: int = None, + has_ff: bool = None, + dropout: float = None, + name: str = None, + verbose: int = None, # noqa + output_embedding: str = None, + output_mlp: dict = None, + output_tensor_type: str = None, + output_scaling: dict = None + ): + r"""Make `MegNet `__ graph network via functional API. + Default parameters can be found in :obj:`kgcnn.literature.Megnet.model_crystal_default`. + + **Model inputs**: + Model uses the list template of inputs and standard output template. + The supported inputs are :obj:`[nodes, coordinates, edge_indices, graph_state, image_translation, lattice, ...]` + with '...' indicating mask or ID tensors following the template below. + + %s + + **Model outputs**: + The standard output template: + + %s + + Args: + inputs (list): List of dictionaries unpacked in :obj:`Input`. Order must match model definition. + input_tensor_type (str): Input type of graph tensor. Default is "padded". + cast_disjoint_kwargs (dict): Dictionary of arguments for casting layer. + input_embedding (dict): Deprecated in favour of input_node_embedding etc. + input_node_embedding (dict): Dictionary of embedding arguments for nodes unpacked in :obj:`Embedding` layers. + input_graph_embedding (dict): Dictionary of embedding arguments for graph unpacked in :obj:`Embedding` layers. + make_distance (bool): Whether input is distance or coordinates at in place of edges. + expand_distance (bool): If the edge input are actual edges or node coordinates instead that are expanded to + form edges with a gauss distance basis given edge indices. Expansion uses `gauss_args`. + gauss_args (dict): Dictionary of layer arguments unpacked in :obj:`GaussBasisLayer` layer. + meg_block_args (dict): Dictionary of layer arguments unpacked in :obj:`MEGnetBlock` layer. + set2set_args (dict): Dictionary of layer arguments unpacked in `:obj:PoolingSet2SetEncoder` layer. + node_ff_args (dict): Dictionary of layer arguments unpacked in :obj:`MLP` feed-forward layer. + edge_ff_args (dict): Dictionary of layer arguments unpacked in :obj:`MLP` feed-forward layer. + state_ff_args (dict): Dictionary of layer arguments unpacked in :obj:`MLP` feed-forward layer. + use_set2set (bool): Whether to use :obj:`PoolingSet2SetEncoder` layer. + nblocks (int): Number of graph embedding blocks or depth of the network. + has_ff (bool): Use feed-forward MLP in each block. + dropout (int): Dropout to use. Default is None. + name (str): Name of the model. + verbose (int): Verbosity level of print. + output_embedding (str): Main embedding task for graph network. Either "node", "edge" or "graph". + output_mlp (dict): Dictionary of layer arguments unpacked in the final classification :obj:`MLP` layer block. + Defines number of model outputs and activation. + output_scaling (dict): Dictionary of layer arguments unpacked in scaling layers. Default is None. + output_tensor_type (str): Output type of graph tensors such as nodes or edges. Default is "padded". + + Returns: + :obj:`keras.models.Model` + """ + # Make input + model_inputs = [Input(**x) for x in inputs] + + dj = template_cast_list_input( + model_inputs, input_tensor_type=input_tensor_type, + cast_disjoint_kwargs=cast_disjoint_kwargs, + has_edges=(not make_distance), + has_nodes=1 + int(make_distance), + has_graph_state=True, + has_crystal_input=2 + ) + + n, x, djx, gs, img, lattice, batch_id_node, batch_id_edge, node_id, edge_id, count_nodes, count_edges = dj + + # Wrapp disjoint model + out = model_disjoint_crystal( + [n, x, djx, gs, img, lattice, batch_id_node, batch_id_edge, count_nodes, count_edges], + use_node_embedding=("int" in inputs[0]['dtype']) if input_node_embedding is not None else False, + use_graph_embedding=("int" in inputs[3]['dtype']) if input_graph_embedding is not None else False, + input_node_embedding=input_node_embedding, + input_graph_embedding=input_graph_embedding, + expand_distance=expand_distance, + make_distance=make_distance, + gauss_args=gauss_args, + meg_block_args=meg_block_args, + set2set_args=set2set_args, + node_ff_args=node_ff_args, + edge_ff_args=edge_ff_args, + state_ff_args=state_ff_args, + use_set2set=use_set2set, + nblocks=nblocks, + has_ff=has_ff, + dropout=dropout, + output_embedding=output_embedding, + output_mlp=output_mlp + ) + + if output_scaling is not None: + scaler = get_scaler(output_scaling["name"])(**output_scaling) + if scaler.extensive: + # Node information must be numbers, or we need an additional input. + out = scaler([out, n, batch_id_node]) + else: + out = scaler(out) + + # Output embedding choice + out = template_cast_output( + [out, batch_id_node, batch_id_edge, node_id, edge_id, count_nodes, count_edges], + output_embedding=output_embedding, output_tensor_type=output_tensor_type, + input_tensor_type=input_tensor_type, cast_disjoint_kwargs=cast_disjoint_kwargs, + ) + + model = ks.models.Model(inputs=model_inputs, outputs=out, name=name) + + model.__kgcnn_model_version__ = __model_version__ + + if output_scaling is not None: + def set_scale(*args, **kwargs): + scaler.set_scale(*args, **kwargs) + + setattr(model, "set_scale", set_scale) + + return model + + +make_crystal_model.__doc__ = make_crystal_model.__doc__ % ( + template_cast_list_input.__doc__, template_cast_output.__doc__) diff --git a/kgcnn/literature/Megnet/_model.py b/kgcnn/literature/Megnet/_model.py new file mode 100644 index 00000000..1b0c7938 --- /dev/null +++ b/kgcnn/literature/Megnet/_model.py @@ -0,0 +1,193 @@ +from kgcnn.layers.modules import Embedding +from kgcnn.layers.geom import NodePosition, NodeDistanceEuclidean, GaussBasisLayer, ShiftPeriodicLattice +from kgcnn.layers.mlp import MLP, GraphMLP +from keras.layers import Dense, Dropout, Concatenate, Flatten, Add +from kgcnn.layers.pooling import PoolingNodes +from kgcnn.layers.set2set import PoolingSet2SetEncoder +from ._layers import MEGnetBlock + + +PoolingGlobalEdges = PoolingNodes + + +def model_disjoint( + inputs, + use_node_embedding, + use_graph_embedding, + input_node_embedding: dict = None, + input_graph_embedding: dict = None, + expand_distance: bool = None, + make_distance: bool = None, + gauss_args: dict = None, + meg_block_args: dict = None, + set2set_args: dict = None, + node_ff_args: dict = None, + edge_ff_args: dict = None, + state_ff_args: dict = None, + use_set2set: bool = None, + nblocks: int = None, + has_ff: bool = None, + dropout: float = None, + output_embedding: str = None, + output_mlp: dict = None, +): + # Make input + vp, x, edi, up, batch_id_node, batch_id_edge, count_nodes, count_edges = inputs + + # Embedding, if no feature dimension + if use_node_embedding: + vp = Embedding(**input_node_embedding)(vp) + if use_graph_embedding: + up = Embedding(**input_graph_embedding)(up) + + # Edge distance as Gauss-Basis + if make_distance: + pos1, pos2 = NodePosition()([x, edi]) + ep = NodeDistanceEuclidean()([pos1, pos2]) + else: + ep = x + + if expand_distance: + ep = GaussBasisLayer(**gauss_args)(ep) + + # Model + vp = GraphMLP(**node_ff_args)([vp, batch_id_node, count_nodes]) + ep = GraphMLP(**edge_ff_args)([ep, batch_id_edge, count_edges]) + up = MLP(**state_ff_args)(up) + vp2 = vp + ep2 = ep + up2 = up + for i in range(0, nblocks): + if has_ff and i > 0: + vp2 = GraphMLP(**node_ff_args)([vp, batch_id_node, count_nodes]) + ep2 = GraphMLP(**edge_ff_args)([ep, batch_id_edge, count_edges]) + up2 = MLP(**state_ff_args)(up) + + # MEGnetBlock + vp2, ep2, up2 = MEGnetBlock(**meg_block_args)( + [vp2, ep2, edi, up2, batch_id_node, batch_id_edge, count_nodes, count_edges]) + + # skip connection + if dropout is not None: + vp2 = Dropout(dropout, name='dropout_atom_%d' % i)(vp2) + ep2 = Dropout(dropout, name='dropout_bond_%d' % i)(ep2) + up2 = Dropout(dropout, name='dropout_state_%d' % i)(up2) + + vp = Add()([vp2, vp]) + ep = Add()([ep2, ep]) + up = Add()([up2, up]) + + if use_set2set: + vp = Dense(set2set_args["channels"], activation='linear')(vp) # to match units + ep = Dense(set2set_args["channels"], activation='linear')(ep) # to match units + vp = PoolingSet2SetEncoder(**set2set_args)([count_nodes, vp, batch_id_node]) + ep = PoolingSet2SetEncoder(**set2set_args)([count_edges, ep, batch_id_edge]) + else: + vp = PoolingNodes()([count_nodes, vp, batch_id_node]) + ep = PoolingGlobalEdges()([count_edges, ep, batch_id_edge]) + + ep = Flatten()(ep) + vp = Flatten()(vp) + final_vec = Concatenate(axis=-1)([vp, ep, up]) + + if dropout is not None: + final_vec = Dropout(dropout, name='dropout_final')(final_vec) + + # Only graph embedding for Megnet + if output_embedding != "graph": + raise ValueError("Unsupported output embedding for mode `Megnet`.") + + main_output = MLP(**output_mlp)(final_vec) + return main_output + + +def model_disjoint_crystal( + inputs, + use_node_embedding, + use_graph_embedding, + input_node_embedding: dict = None, + input_graph_embedding: dict = None, + expand_distance: bool = None, + make_distance: bool = None, + gauss_args: dict = None, + meg_block_args: dict = None, + set2set_args: dict = None, + node_ff_args: dict = None, + edge_ff_args: dict = None, + state_ff_args: dict = None, + use_set2set: bool = None, + nblocks: int = None, + has_ff: bool = None, + dropout: float = None, + output_embedding: str = None, + output_mlp: dict = None, +): + vp, x, edi, up, edge_image, lattice, batch_id_node, batch_id_edge, count_nodes, count_edges = inputs + + # Embedding, if no feature dimension + if use_node_embedding: + vp = Embedding(**input_node_embedding)(vp) + if use_graph_embedding: + up = Embedding(**input_graph_embedding)(up) + + # Edge distance as Gauss-Basis + if make_distance: + pos1, pos2 = NodePosition()([x, edi]) + pos2 = ShiftPeriodicLattice()([pos2, edge_image, lattice]) + ep = NodeDistanceEuclidean()([pos1, pos2]) + else: + ep = x + + if expand_distance: + ep = GaussBasisLayer(**gauss_args)(ep) + + # Model + vp = GraphMLP(**node_ff_args)([vp, batch_id_edge, count_edges]) + ep = GraphMLP(**edge_ff_args)([ep, batch_id_edge, count_edges]) + up = MLP(**state_ff_args)(up) + vp2 = vp + ep2 = ep + up2 = up + for i in range(0, nblocks): + if has_ff and i > 0: + vp2 = GraphMLP(**node_ff_args)([vp, batch_id_node, count_nodes]) + ep2 = GraphMLP(**edge_ff_args)([ep, batch_id_edge, count_edges]) + up2 = MLP(**state_ff_args)(up) + + # MEGnetBlock + vp2, ep2, up2 = MEGnetBlock(**meg_block_args)( + [vp2, ep2, edi, up2, batch_id_node, batch_id_edge, count_nodes, count_edges]) + + # skip connection + if dropout is not None: + vp2 = Dropout(dropout, name='dropout_atom_%d' % i)(vp2) + ep2 = Dropout(dropout, name='dropout_bond_%d' % i)(ep2) + up2 = Dropout(dropout, name='dropout_state_%d' % i)(up2) + + vp = Add()([vp2, vp]) + ep = Add()([ep2, ep]) + up = Add()([up2, up]) + + if use_set2set: + vp = Dense(set2set_args["channels"], activation='linear')(vp) # to match units + ep = Dense(set2set_args["channels"], activation='linear')(ep) # to match units + vp = PoolingSet2SetEncoder(**set2set_args)([count_nodes, vp, batch_id_node]) + ep = PoolingSet2SetEncoder(**set2set_args)([count_edges, ep, batch_id_edge]) + else: + vp = PoolingNodes()([count_nodes, vp, batch_id_node]) + ep = PoolingGlobalEdges()([count_edges, ep, batch_id_edge]) + + ep = Flatten()(ep) + vp = Flatten()(vp) + final_vec = Concatenate(axis=-1)([vp, ep, up]) + + if dropout is not None: + final_vec = Dropout(dropout, name='dropout_final')(final_vec) + + # Only graph embedding for Megnet + if output_embedding != "graph": + raise ValueError("Unsupported output embedding for mode `Megnet`.") + + main_output = MLP(**output_mlp)(final_vec) + + return main_output diff --git a/kgcnn/literature/RGCN/__init__.py b/kgcnn/literature/RGCN/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/kgcnn/literature/RGCN/_make.py b/kgcnn/literature/RGCN/_make.py new file mode 100644 index 00000000..220185f3 --- /dev/null +++ b/kgcnn/literature/RGCN/_make.py @@ -0,0 +1,165 @@ +import keras as ks +from kgcnn.layers.scale import get as get_scaler +from ._model import model_disjoint +from kgcnn.layers.modules import Input +from kgcnn.models.utils import update_model_kwargs +from kgcnn.models.casting import template_cast_output, template_cast_list_input +from keras.backend import backend as backend_to_use + + +# Keep track of model version from commit date in literature. +__kgcnn_model_version__ = "2023-12-04" + +# Supported backends +__kgcnn_model_backend_supported__ = ["tensorflow", "torch", "jax"] +if backend_to_use() not in __kgcnn_model_backend_supported__: + raise NotImplementedError("Backend '%s' for model 'RGCN' is not supported." % backend_to_use()) + +# Implementation of GCN in `keras` from paper: +# Modeling Relational Data with Graph Convolutional Networks +# Michael Schlichtkrull, Thomas N. Kipf, Peter Bloem, Rianne van den Berg, Ivan Titov and Max Welling +# https://arxiv.org/abs/1703.06103 + + +model_default = { + "name": "RGCN", + "inputs": [ + {"shape": (None,), "name": "node_number", "dtype": "int64"}, + {"shape": (None, 1), "name": "edge_weights", "dtype": "float32"}, + {"shape": (None, ), "name": "edge_relations", "dtype": "int64"}, + {"shape": (None, 2), "name": "edge_indices", "dtype": "int64"}, + {"shape": (), "name": "total_nodes", "dtype": "int64"}, + {"shape": (), "name": "total_edges", "dtype": "int64"} + ], + "input_tensor_type": "padded", + "input_embedding": None, # deprecated + "cast_disjoint_kwargs": {}, + "input_node_embedding": {"input_dim": 95, "output_dim": 64}, + "input_edge_embedding": {"input_dim": 25, "output_dim": 1}, + "dense_relation_kwargs": {"units": 64, "num_relations": 20}, + "dense_kwargs": {"units": 64}, + "activation_kwargs": {"activation": "swish"}, + "depth": 3, + "verbose": 10, + "output_embedding": 'graph', + "node_pooling_kwargs": {}, + "output_to_tensor": None, # deprecated + "output_tensor_type": "padded", + "output_mlp": {"use_bias": True, "units": 1, + "activation": "softmax"}, + "output_scaling": None, +} + + +@update_model_kwargs(model_default, update_recursive=0, deprecated=["input_embedding", "output_to_tensor"]) +def make_model(inputs: list = None, + input_tensor_type: str = None, + cast_disjoint_kwargs: dict = None, + input_embedding: dict = None, # noqa + input_node_embedding: dict = None, + input_edge_embedding: dict = None, + depth: int = None, + dense_relation_kwargs: dict = None, + dense_kwargs: dict = None, + activation_kwargs: dict = None, + name: str = None, + verbose: int = None, + output_embedding: str = None, + output_tensor_type: dict = None, + output_scaling: dict = None, + output_to_tensor: bool = None, # noqa + node_pooling_kwargs: dict = None, + output_mlp: dict = None + ): + r"""Make `RGCN `__ graph network via functional API. + Default parameters can be found in :obj:`kgcnn.literature.RGCN.model_default`. + + **Model inputs**: + Model uses the list template of inputs and standard output template. + The supported inputs are :obj:`[nodes, edges, edge_relations, edge_indices, ...]` + with '...' indicating mask or ID tensors following the template below. + The edge relations do not have a feature dimension and specify the relation of each edge of type 'int'. + Edges are actually edge single weight values which are entries of the pre-scaled adjacency matrix. + + %s + + **Model outputs**: + The standard output template: + + %s + + Args: + inputs (list): List of dictionaries unpacked in :obj:`Input`. Order must match model definition. + input_tensor_type (str): Input type of graph tensor. Default is "padded". + cast_disjoint_kwargs (dict): Dictionary of arguments for casting layers if used. + input_embedding (dict): Deprecated in favour of input_node_embedding etc. + input_node_embedding (dict): Dictionary of embedding arguments unpacked in :obj:`Embedding` layers. + input_edge_embedding (dict): Dictionary of embedding arguments unpacked in :obj:`Embedding` layers. + depth (int): Number of graph embedding units or depth of the network. + dense_relation_kwargs (dict): Dictionary of layer arguments unpacked in :obj:`RelationalDense` layer. + dense_kwargs (dict): Dictionary of layer arguments unpacked in :obj:`Dense` layer. + activation_kwargs (dict): Dictionary of layer arguments unpacked in :obj:`Activation` layer. + name (str): Name of the model. + verbose (int): Level of print output. + output_embedding (str): Main embedding task for graph network. Either "node", "edge" or "graph". + output_scaling (dict): Dictionary of layer arguments unpacked in scaling layers. Default is None. + output_tensor_type (str): Output type of graph tensors such as nodes or edges. Default is "padded". + output_mlp (dict): Dictionary of layer arguments unpacked in the final classification :obj:`MLP` layer block. + Defines number of model outputs and activation. + node_pooling_kwargs (dict): Dictionary of layer arguments unpacked in :obj:`PoolingNodes` layer. + + Returns: + :obj:`keras.models.Model` + """ + # Make input + model_inputs = [Input(**x) for x in inputs] + + dj_inputs = template_cast_list_input( + model_inputs, + input_tensor_type=input_tensor_type, + cast_disjoint_kwargs=cast_disjoint_kwargs, + has_nodes=True, + has_edges=2, + has_edge_indices=True + ) + + n, ed, er, disjoint_indices, batch_id_node, batch_id_edge, node_id, edge_id, count_nodes, count_edges = dj_inputs + + out = model_disjoint( + [n, ed, er, disjoint_indices, batch_id_node, count_nodes], + use_node_embedding=("int" in inputs[0]['dtype']) if input_node_embedding is not None else False, + use_edge_embedding=("int" in inputs[1]['dtype']) if input_edge_embedding is not None else False, + input_node_embedding=input_node_embedding, + input_edge_embedding=input_edge_embedding, + depth=depth, + dense_kwargs=dense_kwargs, + dense_relation_kwargs=dense_relation_kwargs, + activation_kwargs=activation_kwargs, + node_pooling_kwargs=node_pooling_kwargs, + output_mlp=output_mlp, + output_embedding=output_embedding + ) + + if output_scaling is not None: + scaler = get_scaler(output_scaling["name"])(**output_scaling) + out = scaler(out) + + # Output embedding choice + out = template_cast_output( + [out, batch_id_node, batch_id_edge, node_id, edge_id, count_nodes, count_edges], + output_embedding=output_embedding, output_tensor_type=output_tensor_type, + input_tensor_type=input_tensor_type, cast_disjoint_kwargs=cast_disjoint_kwargs + ) + + model = ks.models.Model(inputs=model_inputs, outputs=out, name=name) + model.__kgcnn_model_version__ = __kgcnn_model_version__ + + if output_scaling is not None: + def set_scale(*args, **kwargs): + scaler.set_scale(*args, **kwargs) + + setattr(model, "set_scale", set_scale) + return model + + +make_model.__doc__ = make_model.__doc__ % (template_cast_list_input.__doc__, template_cast_output.__doc__) diff --git a/kgcnn/literature/RGCN/_model.py b/kgcnn/literature/RGCN/_model.py new file mode 100644 index 00000000..f4b2ee4d --- /dev/null +++ b/kgcnn/literature/RGCN/_model.py @@ -0,0 +1,51 @@ +from keras.layers import Dense, Add, Multiply, Activation +from kgcnn.layers.modules import Embedding +from kgcnn.layers.gather import GatherNodesOutgoing +from kgcnn.layers.relational import RelationalDense +from kgcnn.layers.aggr import AggregateLocalEdges +from kgcnn.layers.pooling import PoolingNodes +from kgcnn.layers.mlp import MLP, GraphMLP + + +def model_disjoint( + inputs, + use_node_embedding, + use_edge_embedding, + input_node_embedding=None, + input_edge_embedding=None, + depth=None, + dense_kwargs=None, + dense_relation_kwargs=None, + activation_kwargs=None, + node_pooling_kwargs=None, + output_mlp=None, + output_embedding=None +): + n, edge_weights, edge_relations, edi, batch_id_node, count_nodes = inputs + + # Embedding, if no feature dimension + if use_node_embedding: + n = Embedding(**input_node_embedding)(n) + if use_edge_embedding: + edge_weights = Embedding(**input_edge_embedding)(edge_weights) + + # Model + for i in range(0, depth): + n_j = GatherNodesOutgoing()([n, edi]) + h0 = Dense(**dense_kwargs)(n) + h_j = RelationalDense(**dense_relation_kwargs)([n_j, edge_relations]) + m = Multiply()([h_j, edge_weights]) + h = AggregateLocalEdges(pooling_method="sum")([n, m, edi]) + n = Add()([h, h0]) + n = Activation(**activation_kwargs)(n) + + # Output embedding choice + if output_embedding == "graph": + out = PoolingNodes(**node_pooling_kwargs)([count_nodes, n, batch_id_node]) # will return tensor + out = MLP(**output_mlp)(out) + elif output_embedding == "node": # Node labeling + out = GraphMLP(**output_mlp)([n, batch_id_node, count_nodes]) + else: + raise ValueError("Unsupported output embedding for mode `RGCN`") + + return out diff --git a/kgcnn/literature/Schnet/_make.py b/kgcnn/literature/Schnet/_make.py index 4951bada..69eeda3f 100644 --- a/kgcnn/literature/Schnet/_make.py +++ b/kgcnn/literature/Schnet/_make.py @@ -80,7 +80,7 @@ def make_model(inputs: list = None, r"""Make `SchNet `__ graph network via functional API. Default parameters can be found in :obj:`kgcnn.literature.Schnet.model_default` . - Model inputs: + **Model inputs**: Model uses the list template of inputs and standard output template. The supported inputs are :obj:`[nodes, coordinates, edge_indices, ...]` with `make_distance` and with '...' indicating mask or ID tensors following the template below. @@ -89,7 +89,7 @@ def make_model(inputs: list = None, %s - Model outputs: + **Model outputs**: The standard output template: %s @@ -99,8 +99,7 @@ def make_model(inputs: list = None, input_tensor_type (str): Input type of graph tensor. Default is "padded". cast_disjoint_kwargs (dict): Dictionary of arguments for casting layer. input_embedding (dict): Deprecated in favour of input_node_embedding etc. - input_node_embedding (dict): Dictionary of embedding arguments for nodes etc. - unpacked in :obj:`Embedding` layers. + input_node_embedding (dict): Dictionary of embedding arguments for nodes unpacked in :obj:`Embedding` layers. make_distance (bool): Whether input is distance or coordinates at in place of edges. expand_distance (bool): If the edge input are actual edges or node coordinates instead that are expanded to form edges with a gauss distance basis given edge indices. Expansion uses `gauss_args`. @@ -245,8 +244,7 @@ def make_crystal_model(inputs: list = None, input_tensor_type (str): Input type of graph tensor. Default is "padded". cast_disjoint_kwargs (dict): Dictionary of arguments for casting layer. input_embedding (dict): Deprecated in favour of input_node_embedding etc. - input_node_embedding (dict): Dictionary of embedding arguments for nodes etc. - unpacked in :obj:`Embedding` layers. + input_node_embedding (dict): Dictionary of embedding arguments for nodes unpacked in :obj:`Embedding` layers. make_distance (bool): Whether input is distance or coordinates at in place of edges. expand_distance (bool): If the edge input are actual edges or node coordinates instead that are expanded to form edges with a gauss distance basis given edge indices. Expansion uses `gauss_args`. diff --git a/kgcnn/molecule/dynamics/base.py b/kgcnn/molecule/dynamics/base.py index e09fa41d..45b96689 100644 --- a/kgcnn/molecule/dynamics/base.py +++ b/kgcnn/molecule/dynamics/base.py @@ -1,5 +1,6 @@ import time import keras as ks +from keras import ops import numpy as np from typing import Union, List, Callable, Dict from kgcnn.data.base import MemoryGraphList @@ -146,7 +147,7 @@ def __call__(self, graph_list: MemoryGraphList) -> MemoryGraphList: output_list = [] for i in range(num_samples): temp_dict = { - key: np.array(value[i]) for key, value in tensor_dict.items() + key: ops.convert_to_numpy(value[i]) for key, value in tensor_dict.items() } temp_dict = GraphDict(temp_dict) for mp in self.graph_postprocessors: diff --git a/notebooks/workflow_qm_regression.ipynb b/notebooks/workflow_qm_regression.ipynb index e7c87a5b..7f0b2860 100644 --- a/notebooks/workflow_qm_regression.ipynb +++ b/notebooks/workflow_qm_regression.ipynb @@ -291,7 +291,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "7a24751c", "metadata": {}, "outputs": [ @@ -299,7 +299,607 @@ "name": "stdout", "output_type": "stream", "text": [ - "Running training on fold: 0\n" + "Running training on fold: 0\n" + ] + }, + { + "data": { + "text/html": [ + "
Model: \"Schnet\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"Schnet\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                  ┃ Output Shape              ┃     Param # ┃ Connected to                   ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+       "│ node_number (InputLayer)      │ (None, None)              │           0 │ -                              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ range_indices (InputLayer)    │ (None, None, 2)           │           0 │ -                              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ total_nodes (InputLayer)      │ (None)                    │           0 │ -                              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ total_ranges (InputLayer)     │ (None)                    │           0 │ -                              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ node_coordinates (InputLayer) │ (None, None, 3)           │           0 │ -                              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ cast_batched_indices_to_disj… │ [(None), (2, None),       │           0 │ node_number[0][0],             │\n",
+       "│ (CastBatchedIndicesToDisjoin… │ (None), (None), (None),   │             │ range_indices[0][0],           │\n",
+       "│                               │ (None), (None), (None)]   │             │ total_nodes[0][0],             │\n",
+       "│                               │                           │             │ total_ranges[0][0]             │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ cast_batched_attributes_to_d… │ [(None, 3), (None),       │           0 │ node_coordinates[0][0],        │\n",
+       "│ (CastBatchedAttributesToDisj… │ (None), (None)]           │             │ total_nodes[0][0]              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ cast_batched_attributes_to_d… │ [(None), (None), (None),  │           0 │ node_number[0][0],             │\n",
+       "│ (CastBatchedAttributesToDisj… │ (None)]                   │             │ total_nodes[0][0]              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ node_position (NodePosition)  │ [(None, 3), (None, 3)]    │           0 │ cast_batched_attributes_to_di… │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ embedding (Embedding)         │ (None, 64)                │       6,080 │ cast_batched_attributes_to_di… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ node_distance_euclidean       │ (None, 1)                 │           0 │ node_position[0][0],           │\n",
+       "│ (NodeDistanceEuclidean)       │                           │             │ node_position[0][1]            │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ dense (Dense)                 │ (None, 128)               │       8,320 │ embedding[0][0]                │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ gauss_basis_layer             │ (None, 20)                │           0 │ node_distance_euclidean[0][0]  │\n",
+       "│ (GaussBasisLayer)             │                           │             │                                │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ sch_net_interaction           │ (None, 128)               │      68,608 │ dense[0][0],                   │\n",
+       "│ (SchNetInteraction)           │                           │             │ gauss_basis_layer[0][0],       │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ sch_net_interaction_1         │ (None, 128)               │      68,608 │ sch_net_interaction[0][0],     │\n",
+       "│ (SchNetInteraction)           │                           │             │ gauss_basis_layer[0][0],       │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ sch_net_interaction_2         │ (None, 128)               │      68,608 │ sch_net_interaction_1[0][0],   │\n",
+       "│ (SchNetInteraction)           │                           │             │ gauss_basis_layer[0][0],       │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ sch_net_interaction_3         │ (None, 128)               │      68,608 │ sch_net_interaction_2[0][0],   │\n",
+       "│ (SchNetInteraction)           │                           │             │ gauss_basis_layer[0][0],       │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ mlp (MLP)                     │ (None, 1)                 │      24,833 │ sch_net_interaction_3[0][0],   │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ pooling_nodes (PoolingNodes)  │ (None, 1)                 │           0 │ cast_batched_indices_to_disjo… │\n",
+       "│                               │                           │             │ mlp[0][0],                     │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ cast_disjoint_to_batched_gra… │ (None, 1)                 │           0 │ pooling_nodes[0][0]            │\n",
+       "│ (CastDisjointToBatchedGraphS… │                           │             │                                │\n",
+       "└───────────────────────────────┴───────────────────────────┴─────────────┴────────────────────────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mConnected to \u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", + "│ node_number (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ range_indices (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ total_nodes (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ total_ranges (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ node_coordinates (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ cast_batched_indices_to_disj… │ [(\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;34m2\u001b[0m, \u001b[38;5;45mNone\u001b[0m), │ \u001b[38;5;34m0\u001b[0m │ node_number[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mCastBatchedIndicesToDisjoin…\u001b[0m │ (\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m), │ │ range_indices[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ (\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m)] │ │ total_nodes[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ total_ranges[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ cast_batched_attributes_to_d… │ [(\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m), (\u001b[38;5;45mNone\u001b[0m), │ \u001b[38;5;34m0\u001b[0m │ node_coordinates[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mCastBatchedAttributesToDisj…\u001b[0m │ (\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m)] │ │ total_nodes[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ cast_batched_attributes_to_d… │ [(\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m), │ \u001b[38;5;34m0\u001b[0m │ node_number[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mCastBatchedAttributesToDisj…\u001b[0m │ (\u001b[38;5;45mNone\u001b[0m)] │ │ total_nodes[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ node_position (\u001b[38;5;33mNodePosition\u001b[0m) │ [(\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m), (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m)] │ \u001b[38;5;34m0\u001b[0m │ cast_batched_attributes_to_di… │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ embedding (\u001b[38;5;33mEmbedding\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m6,080\u001b[0m │ cast_batched_attributes_to_di… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ node_distance_euclidean │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ node_position[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mNodeDistanceEuclidean\u001b[0m) │ │ │ node_position[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m1\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m8,320\u001b[0m │ embedding[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ gauss_basis_layer │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m20\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ node_distance_euclidean[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "│ (\u001b[38;5;33mGaussBasisLayer\u001b[0m) │ │ │ │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ sch_net_interaction │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m68,608\u001b[0m │ dense[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mSchNetInteraction\u001b[0m) │ │ │ gauss_basis_layer[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ sch_net_interaction_1 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m68,608\u001b[0m │ sch_net_interaction[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mSchNetInteraction\u001b[0m) │ │ │ gauss_basis_layer[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ sch_net_interaction_2 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m68,608\u001b[0m │ sch_net_interaction_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mSchNetInteraction\u001b[0m) │ │ │ gauss_basis_layer[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ sch_net_interaction_3 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m68,608\u001b[0m │ sch_net_interaction_2[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mSchNetInteraction\u001b[0m) │ │ │ gauss_basis_layer[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ mlp (\u001b[38;5;33mMLP\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m24,833\u001b[0m │ sch_net_interaction_3[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ pooling_nodes (\u001b[38;5;33mPoolingNodes\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ cast_batched_indices_to_disjo… │\n", + "│ │ │ │ mlp[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ cast_disjoint_to_batched_gra… │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ pooling_nodes[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "│ (\u001b[38;5;33mCastDisjointToBatchedGraphS…\u001b[0m │ │ │ │\n", + "└───────────────────────────────┴───────────────────────────┴─────────────┴────────────────────────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 313,665 (1.20 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m313,665\u001b[0m (1.20 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 313,665 (1.20 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m313,665\u001b[0m (1.20 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Compiled with jit: False\n", + "Print Time for training: 1:46:01.859375\n", + "Running training on fold: 1\n" + ] + }, + { + "data": { + "text/html": [ + "
Model: \"Schnet\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"Schnet\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                  ┃ Output Shape              ┃     Param # ┃ Connected to                   ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+       "│ node_number (InputLayer)      │ (None, None)              │           0 │ -                              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ range_indices (InputLayer)    │ (None, None, 2)           │           0 │ -                              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ total_nodes (InputLayer)      │ (None)                    │           0 │ -                              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ total_ranges (InputLayer)     │ (None)                    │           0 │ -                              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ node_coordinates (InputLayer) │ (None, None, 3)           │           0 │ -                              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ cast_batched_indices_to_disj… │ [(None), (2, None),       │           0 │ node_number[0][0],             │\n",
+       "│ (CastBatchedIndicesToDisjoin… │ (None), (None), (None),   │             │ range_indices[0][0],           │\n",
+       "│                               │ (None), (None), (None)]   │             │ total_nodes[0][0],             │\n",
+       "│                               │                           │             │ total_ranges[0][0]             │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ cast_batched_attributes_to_d… │ [(None, 3), (None),       │           0 │ node_coordinates[0][0],        │\n",
+       "│ (CastBatchedAttributesToDisj… │ (None), (None)]           │             │ total_nodes[0][0]              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ cast_batched_attributes_to_d… │ [(None), (None), (None),  │           0 │ node_number[0][0],             │\n",
+       "│ (CastBatchedAttributesToDisj… │ (None)]                   │             │ total_nodes[0][0]              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ node_position_1               │ [(None, 3), (None, 3)]    │           0 │ cast_batched_attributes_to_di… │\n",
+       "│ (NodePosition)                │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ embedding_1 (Embedding)       │ (None, 64)                │       6,080 │ cast_batched_attributes_to_di… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ node_distance_euclidean_1     │ (None, 1)                 │           0 │ node_position_1[0][0],         │\n",
+       "│ (NodeDistanceEuclidean)       │                           │             │ node_position_1[0][1]          │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ dense_21 (Dense)              │ (None, 128)               │       8,320 │ embedding_1[0][0]              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ gauss_basis_layer_1           │ (None, 20)                │           0 │ node_distance_euclidean_1[0][… │\n",
+       "│ (GaussBasisLayer)             │                           │             │                                │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ sch_net_interaction_4         │ (None, 128)               │      68,608 │ dense_21[0][0],                │\n",
+       "│ (SchNetInteraction)           │                           │             │ gauss_basis_layer_1[0][0],     │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ sch_net_interaction_5         │ (None, 128)               │      68,608 │ sch_net_interaction_4[0][0],   │\n",
+       "│ (SchNetInteraction)           │                           │             │ gauss_basis_layer_1[0][0],     │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ sch_net_interaction_6         │ (None, 128)               │      68,608 │ sch_net_interaction_5[0][0],   │\n",
+       "│ (SchNetInteraction)           │                           │             │ gauss_basis_layer_1[0][0],     │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ sch_net_interaction_7         │ (None, 128)               │      68,608 │ sch_net_interaction_6[0][0],   │\n",
+       "│ (SchNetInteraction)           │                           │             │ gauss_basis_layer_1[0][0],     │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ mlp_1 (MLP)                   │ (None, 1)                 │      24,833 │ sch_net_interaction_7[0][0],   │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ pooling_nodes_1               │ (None, 1)                 │           0 │ cast_batched_indices_to_disjo… │\n",
+       "│ (PoolingNodes)                │                           │             │ mlp_1[0][0],                   │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ cast_disjoint_to_batched_gra… │ (None, 1)                 │           0 │ pooling_nodes_1[0][0]          │\n",
+       "│ (CastDisjointToBatchedGraphS… │                           │             │                                │\n",
+       "└───────────────────────────────┴───────────────────────────┴─────────────┴────────────────────────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mConnected to \u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", + "│ node_number (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ range_indices (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ total_nodes (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ total_ranges (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ node_coordinates (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ cast_batched_indices_to_disj… │ [(\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;34m2\u001b[0m, \u001b[38;5;45mNone\u001b[0m), │ \u001b[38;5;34m0\u001b[0m │ node_number[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mCastBatchedIndicesToDisjoin…\u001b[0m │ (\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m), │ │ range_indices[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ (\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m)] │ │ total_nodes[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ total_ranges[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ cast_batched_attributes_to_d… │ [(\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m), (\u001b[38;5;45mNone\u001b[0m), │ \u001b[38;5;34m0\u001b[0m │ node_coordinates[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mCastBatchedAttributesToDisj…\u001b[0m │ (\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m)] │ │ total_nodes[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ cast_batched_attributes_to_d… │ [(\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m), │ \u001b[38;5;34m0\u001b[0m │ node_number[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mCastBatchedAttributesToDisj…\u001b[0m │ (\u001b[38;5;45mNone\u001b[0m)] │ │ total_nodes[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ node_position_1 │ [(\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m), (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m)] │ \u001b[38;5;34m0\u001b[0m │ cast_batched_attributes_to_di… │\n", + "│ (\u001b[38;5;33mNodePosition\u001b[0m) │ │ │ cast_batched_indices_to_disjo… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ embedding_1 (\u001b[38;5;33mEmbedding\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m6,080\u001b[0m │ cast_batched_attributes_to_di… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ node_distance_euclidean_1 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ node_position_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mNodeDistanceEuclidean\u001b[0m) │ │ │ node_position_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m1\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ dense_21 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m8,320\u001b[0m │ embedding_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ gauss_basis_layer_1 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m20\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ node_distance_euclidean_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m…\u001b[0m │\n", + "│ (\u001b[38;5;33mGaussBasisLayer\u001b[0m) │ │ │ │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ sch_net_interaction_4 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m68,608\u001b[0m │ dense_21[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mSchNetInteraction\u001b[0m) │ │ │ gauss_basis_layer_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ sch_net_interaction_5 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m68,608\u001b[0m │ sch_net_interaction_4[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mSchNetInteraction\u001b[0m) │ │ │ gauss_basis_layer_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ sch_net_interaction_6 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m68,608\u001b[0m │ sch_net_interaction_5[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mSchNetInteraction\u001b[0m) │ │ │ gauss_basis_layer_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ sch_net_interaction_7 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m68,608\u001b[0m │ sch_net_interaction_6[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mSchNetInteraction\u001b[0m) │ │ │ gauss_basis_layer_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ mlp_1 (\u001b[38;5;33mMLP\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m24,833\u001b[0m │ sch_net_interaction_7[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ pooling_nodes_1 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ cast_batched_indices_to_disjo… │\n", + "│ (\u001b[38;5;33mPoolingNodes\u001b[0m) │ │ │ mlp_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ cast_disjoint_to_batched_gra… │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ pooling_nodes_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "│ (\u001b[38;5;33mCastDisjointToBatchedGraphS…\u001b[0m │ │ │ │\n", + "└───────────────────────────────┴───────────────────────────┴─────────────┴────────────────────────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 313,665 (1.20 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m313,665\u001b[0m (1.20 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 313,665 (1.20 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m313,665\u001b[0m (1.20 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Compiled with jit: False\n", + "Print Time for training: 1:44:55.859375\n", + "Running training on fold: 2\n" + ] + }, + { + "data": { + "text/html": [ + "
Model: \"Schnet\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"Schnet\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                  ┃ Output Shape              ┃     Param # ┃ Connected to                   ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+       "│ node_number (InputLayer)      │ (None, None)              │           0 │ -                              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ range_indices (InputLayer)    │ (None, None, 2)           │           0 │ -                              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ total_nodes (InputLayer)      │ (None)                    │           0 │ -                              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ total_ranges (InputLayer)     │ (None)                    │           0 │ -                              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ node_coordinates (InputLayer) │ (None, None, 3)           │           0 │ -                              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ cast_batched_indices_to_disj… │ [(None), (2, None),       │           0 │ node_number[0][0],             │\n",
+       "│ (CastBatchedIndicesToDisjoin… │ (None), (None), (None),   │             │ range_indices[0][0],           │\n",
+       "│                               │ (None), (None), (None)]   │             │ total_nodes[0][0],             │\n",
+       "│                               │                           │             │ total_ranges[0][0]             │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ cast_batched_attributes_to_d… │ [(None, 3), (None),       │           0 │ node_coordinates[0][0],        │\n",
+       "│ (CastBatchedAttributesToDisj… │ (None), (None)]           │             │ total_nodes[0][0]              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ cast_batched_attributes_to_d… │ [(None), (None), (None),  │           0 │ node_number[0][0],             │\n",
+       "│ (CastBatchedAttributesToDisj… │ (None)]                   │             │ total_nodes[0][0]              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ node_position_2               │ [(None, 3), (None, 3)]    │           0 │ cast_batched_attributes_to_di… │\n",
+       "│ (NodePosition)                │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ embedding_2 (Embedding)       │ (None, 64)                │       6,080 │ cast_batched_attributes_to_di… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ node_distance_euclidean_2     │ (None, 1)                 │           0 │ node_position_2[0][0],         │\n",
+       "│ (NodeDistanceEuclidean)       │                           │             │ node_position_2[0][1]          │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ dense_42 (Dense)              │ (None, 128)               │       8,320 │ embedding_2[0][0]              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ gauss_basis_layer_2           │ (None, 20)                │           0 │ node_distance_euclidean_2[0][… │\n",
+       "│ (GaussBasisLayer)             │                           │             │                                │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ sch_net_interaction_8         │ (None, 128)               │      68,608 │ dense_42[0][0],                │\n",
+       "│ (SchNetInteraction)           │                           │             │ gauss_basis_layer_2[0][0],     │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ sch_net_interaction_9         │ (None, 128)               │      68,608 │ sch_net_interaction_8[0][0],   │\n",
+       "│ (SchNetInteraction)           │                           │             │ gauss_basis_layer_2[0][0],     │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ sch_net_interaction_10        │ (None, 128)               │      68,608 │ sch_net_interaction_9[0][0],   │\n",
+       "│ (SchNetInteraction)           │                           │             │ gauss_basis_layer_2[0][0],     │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ sch_net_interaction_11        │ (None, 128)               │      68,608 │ sch_net_interaction_10[0][0],  │\n",
+       "│ (SchNetInteraction)           │                           │             │ gauss_basis_layer_2[0][0],     │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ mlp_2 (MLP)                   │ (None, 1)                 │      24,833 │ sch_net_interaction_11[0][0],  │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ pooling_nodes_2               │ (None, 1)                 │           0 │ cast_batched_indices_to_disjo… │\n",
+       "│ (PoolingNodes)                │                           │             │ mlp_2[0][0],                   │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ cast_disjoint_to_batched_gra… │ (None, 1)                 │           0 │ pooling_nodes_2[0][0]          │\n",
+       "│ (CastDisjointToBatchedGraphS… │                           │             │                                │\n",
+       "└───────────────────────────────┴───────────────────────────┴─────────────┴────────────────────────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mConnected to \u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", + "│ node_number (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ range_indices (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ total_nodes (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ total_ranges (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ node_coordinates (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ cast_batched_indices_to_disj… │ [(\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;34m2\u001b[0m, \u001b[38;5;45mNone\u001b[0m), │ \u001b[38;5;34m0\u001b[0m │ node_number[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mCastBatchedIndicesToDisjoin…\u001b[0m │ (\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m), │ │ range_indices[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ (\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m)] │ │ total_nodes[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ total_ranges[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ cast_batched_attributes_to_d… │ [(\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m), (\u001b[38;5;45mNone\u001b[0m), │ \u001b[38;5;34m0\u001b[0m │ node_coordinates[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mCastBatchedAttributesToDisj…\u001b[0m │ (\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m)] │ │ total_nodes[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ cast_batched_attributes_to_d… │ [(\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m), │ \u001b[38;5;34m0\u001b[0m │ node_number[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mCastBatchedAttributesToDisj…\u001b[0m │ (\u001b[38;5;45mNone\u001b[0m)] │ │ total_nodes[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ node_position_2 │ [(\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m), (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m)] │ \u001b[38;5;34m0\u001b[0m │ cast_batched_attributes_to_di… │\n", + "│ (\u001b[38;5;33mNodePosition\u001b[0m) │ │ │ cast_batched_indices_to_disjo… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ embedding_2 (\u001b[38;5;33mEmbedding\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m6,080\u001b[0m │ cast_batched_attributes_to_di… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ node_distance_euclidean_2 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ node_position_2[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mNodeDistanceEuclidean\u001b[0m) │ │ │ node_position_2[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m1\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ dense_42 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m8,320\u001b[0m │ embedding_2[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ gauss_basis_layer_2 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m20\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ node_distance_euclidean_2[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m…\u001b[0m │\n", + "│ (\u001b[38;5;33mGaussBasisLayer\u001b[0m) │ │ │ │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ sch_net_interaction_8 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m68,608\u001b[0m │ dense_42[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mSchNetInteraction\u001b[0m) │ │ │ gauss_basis_layer_2[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ sch_net_interaction_9 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m68,608\u001b[0m │ sch_net_interaction_8[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mSchNetInteraction\u001b[0m) │ │ │ gauss_basis_layer_2[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ sch_net_interaction_10 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m68,608\u001b[0m │ sch_net_interaction_9[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mSchNetInteraction\u001b[0m) │ │ │ gauss_basis_layer_2[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ sch_net_interaction_11 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m68,608\u001b[0m │ sch_net_interaction_10[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mSchNetInteraction\u001b[0m) │ │ │ gauss_basis_layer_2[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ mlp_2 (\u001b[38;5;33mMLP\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m24,833\u001b[0m │ sch_net_interaction_11[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ pooling_nodes_2 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ cast_batched_indices_to_disjo… │\n", + "│ (\u001b[38;5;33mPoolingNodes\u001b[0m) │ │ │ mlp_2[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ cast_disjoint_to_batched_gra… │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ pooling_nodes_2[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "│ (\u001b[38;5;33mCastDisjointToBatchedGraphS…\u001b[0m │ │ │ │\n", + "└───────────────────────────────┴───────────────────────────┴─────────────┴────────────────────────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 313,665 (1.20 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m313,665\u001b[0m (1.20 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 313,665 (1.20 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m313,665\u001b[0m (1.20 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Compiled with jit: False\n", + "Print Time for training: 1:45:27.593750\n", + "Running training on fold: 3\n" ] }, { @@ -342,44 +942,44 @@ "│ cast_batched_attributes_to_d… │ [(None), (None), (None), │ 0 │ node_number[0][0], │\n", "│ (CastBatchedAttributesToDisj… │ (None)] │ │ total_nodes[0][0] │\n", "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", - "│ node_position (NodePosition) │ [(None, 3), (None, 3)] │ 0 │ cast_batched_attributes_to_di… │\n", - "│ │ │ │ cast_batched_indices_to_disjo… │\n", + "│ node_position_3 │ [(None, 3), (None, 3)] │ 0 │ cast_batched_attributes_to_di… │\n", + "│ (NodePosition) │ │ │ cast_batched_indices_to_disjo… │\n", "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", - "│ embedding (Embedding) │ (None, 64) │ 6,080 │ cast_batched_attributes_to_di… │\n", + "│ embedding_3 (Embedding) │ (None, 64) │ 6,080 │ cast_batched_attributes_to_di… │\n", "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", - "│ node_distance_euclidean │ (None, 1) │ 0 │ node_position[0][0], │\n", - "│ (NodeDistanceEuclidean) │ │ │ node_position[0][1] │\n", + "│ node_distance_euclidean_3 │ (None, 1) │ 0 │ node_position_3[0][0], │\n", + "│ (NodeDistanceEuclidean) │ │ │ node_position_3[0][1] │\n", "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", - "│ dense (Dense) │ (None, 128) │ 8,320 │ embedding[0][0] │\n", + "│ dense_63 (Dense) │ (None, 128) │ 8,320 │ embedding_3[0][0] │\n", "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", - "│ gauss_basis_layer │ (None, 20) │ 0 │ node_distance_euclidean[0][0] │\n", + "│ gauss_basis_layer_3 │ (None, 20) │ 0 │ node_distance_euclidean_3[0][… │\n", "│ (GaussBasisLayer) │ │ │ │\n", "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", - "│ sch_net_interaction │ (None, 128) │ 68,608 │ dense[0][0], │\n", - "│ (SchNetInteraction) │ │ │ gauss_basis_layer[0][0], │\n", + "│ sch_net_interaction_12 │ (None, 128) │ 68,608 │ dense_63[0][0], │\n", + "│ (SchNetInteraction) │ │ │ gauss_basis_layer_3[0][0], │\n", "│ │ │ │ cast_batched_indices_to_disjo… │\n", "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", - "│ sch_net_interaction_1 │ (None, 128) │ 68,608 │ sch_net_interaction[0][0], │\n", - "│ (SchNetInteraction) │ │ │ gauss_basis_layer[0][0], │\n", + "│ sch_net_interaction_13 │ (None, 128) │ 68,608 │ sch_net_interaction_12[0][0], │\n", + "│ (SchNetInteraction) │ │ │ gauss_basis_layer_3[0][0], │\n", "│ │ │ │ cast_batched_indices_to_disjo… │\n", "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", - "│ sch_net_interaction_2 │ (None, 128) │ 68,608 │ sch_net_interaction_1[0][0], │\n", - "│ (SchNetInteraction) │ │ │ gauss_basis_layer[0][0], │\n", + "│ sch_net_interaction_14 │ (None, 128) │ 68,608 │ sch_net_interaction_13[0][0], │\n", + "│ (SchNetInteraction) │ │ │ gauss_basis_layer_3[0][0], │\n", "│ │ │ │ cast_batched_indices_to_disjo… │\n", "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", - "│ sch_net_interaction_3 │ (None, 128) │ 68,608 │ sch_net_interaction_2[0][0], │\n", - "│ (SchNetInteraction) │ │ │ gauss_basis_layer[0][0], │\n", + "│ sch_net_interaction_15 │ (None, 128) │ 68,608 │ sch_net_interaction_14[0][0], │\n", + "│ (SchNetInteraction) │ │ │ gauss_basis_layer_3[0][0], │\n", "│ │ │ │ cast_batched_indices_to_disjo… │\n", "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", - "│ mlp (MLP) │ (None, 1) │ 24,833 │ sch_net_interaction_3[0][0], │\n", + "│ mlp_3 (MLP) │ (None, 1) │ 24,833 │ sch_net_interaction_15[0][0], │\n", "│ │ │ │ cast_batched_indices_to_disjo… │\n", "│ │ │ │ cast_batched_indices_to_disjo… │\n", "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", - "│ pooling_nodes (PoolingNodes) │ (None, 1) │ 0 │ cast_batched_indices_to_disjo… │\n", - "│ │ │ │ mlp[0][0], │\n", + "│ pooling_nodes_3 │ (None, 1) │ 0 │ cast_batched_indices_to_disjo… │\n", + "│ (PoolingNodes) │ │ │ mlp_3[0][0], │\n", "│ │ │ │ cast_batched_indices_to_disjo… │\n", "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", - "│ cast_disjoint_to_batched_gra… │ (None, 1) │ 0 │ pooling_nodes[0][0] │\n", + "│ cast_disjoint_to_batched_gra… │ (None, 1) │ 0 │ pooling_nodes_3[0][0] │\n", "│ (CastDisjointToBatchedGraphS… │ │ │ │\n", "└───────────────────────────────┴───────────────────────────┴─────────────┴────────────────────────────────┘\n", "\n" @@ -409,44 +1009,244 @@ "│ cast_batched_attributes_to_d… │ [(\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m), │ \u001b[38;5;34m0\u001b[0m │ node_number[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", "│ (\u001b[38;5;33mCastBatchedAttributesToDisj…\u001b[0m │ (\u001b[38;5;45mNone\u001b[0m)] │ │ total_nodes[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", - "│ node_position (\u001b[38;5;33mNodePosition\u001b[0m) │ [(\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m), (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m)] │ \u001b[38;5;34m0\u001b[0m │ cast_batched_attributes_to_di… │\n", + "│ node_position_3 │ [(\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m), (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m)] │ \u001b[38;5;34m0\u001b[0m │ cast_batched_attributes_to_di… │\n", + "│ (\u001b[38;5;33mNodePosition\u001b[0m) │ │ │ cast_batched_indices_to_disjo… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ embedding_3 (\u001b[38;5;33mEmbedding\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m6,080\u001b[0m │ cast_batched_attributes_to_di… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ node_distance_euclidean_3 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ node_position_3[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mNodeDistanceEuclidean\u001b[0m) │ │ │ node_position_3[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m1\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ dense_63 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m8,320\u001b[0m │ embedding_3[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ gauss_basis_layer_3 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m20\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ node_distance_euclidean_3[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m…\u001b[0m │\n", + "│ (\u001b[38;5;33mGaussBasisLayer\u001b[0m) │ │ │ │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ sch_net_interaction_12 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m68,608\u001b[0m │ dense_63[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mSchNetInteraction\u001b[0m) │ │ │ gauss_basis_layer_3[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", "│ │ │ │ cast_batched_indices_to_disjo… │\n", "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", - "│ embedding (\u001b[38;5;33mEmbedding\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m6,080\u001b[0m │ cast_batched_attributes_to_di… │\n", + "│ sch_net_interaction_13 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m68,608\u001b[0m │ sch_net_interaction_12[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mSchNetInteraction\u001b[0m) │ │ │ gauss_basis_layer_3[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", - "│ node_distance_euclidean │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ node_position[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", - "│ (\u001b[38;5;33mNodeDistanceEuclidean\u001b[0m) │ │ │ node_position[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m1\u001b[0m] │\n", + "│ sch_net_interaction_14 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m68,608\u001b[0m │ sch_net_interaction_13[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mSchNetInteraction\u001b[0m) │ │ │ gauss_basis_layer_3[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", - "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m8,320\u001b[0m │ embedding[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "│ sch_net_interaction_15 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m68,608\u001b[0m │ sch_net_interaction_14[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mSchNetInteraction\u001b[0m) │ │ │ gauss_basis_layer_3[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", - "│ gauss_basis_layer │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m20\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ node_distance_euclidean[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "│ mlp_3 (\u001b[38;5;33mMLP\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m24,833\u001b[0m │ sch_net_interaction_15[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ pooling_nodes_3 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ cast_batched_indices_to_disjo… │\n", + "│ (\u001b[38;5;33mPoolingNodes\u001b[0m) │ │ │ mlp_3[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_indices_to_disjo… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ cast_disjoint_to_batched_gra… │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ pooling_nodes_3[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "│ (\u001b[38;5;33mCastDisjointToBatchedGraphS…\u001b[0m │ │ │ │\n", + "└───────────────────────────────┴───────────────────────────┴─────────────┴────────────────────────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 313,665 (1.20 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m313,665\u001b[0m (1.20 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 313,665 (1.20 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m313,665\u001b[0m (1.20 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Compiled with jit: False\n", + "Print Time for training: 1:45:28.109375\n", + "Running training on fold: 4\n" + ] + }, + { + "data": { + "text/html": [ + "
Model: \"Schnet\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"Schnet\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                  ┃ Output Shape              ┃     Param # ┃ Connected to                   ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+       "│ node_number (InputLayer)      │ (None, None)              │           0 │ -                              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ range_indices (InputLayer)    │ (None, None, 2)           │           0 │ -                              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ total_nodes (InputLayer)      │ (None)                    │           0 │ -                              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ total_ranges (InputLayer)     │ (None)                    │           0 │ -                              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ node_coordinates (InputLayer) │ (None, None, 3)           │           0 │ -                              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ cast_batched_indices_to_disj… │ [(None), (2, None),       │           0 │ node_number[0][0],             │\n",
+       "│ (CastBatchedIndicesToDisjoin… │ (None), (None), (None),   │             │ range_indices[0][0],           │\n",
+       "│                               │ (None), (None), (None)]   │             │ total_nodes[0][0],             │\n",
+       "│                               │                           │             │ total_ranges[0][0]             │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ cast_batched_attributes_to_d… │ [(None, 3), (None),       │           0 │ node_coordinates[0][0],        │\n",
+       "│ (CastBatchedAttributesToDisj… │ (None), (None)]           │             │ total_nodes[0][0]              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ cast_batched_attributes_to_d… │ [(None), (None), (None),  │           0 │ node_number[0][0],             │\n",
+       "│ (CastBatchedAttributesToDisj… │ (None)]                   │             │ total_nodes[0][0]              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ node_position_4               │ [(None, 3), (None, 3)]    │           0 │ cast_batched_attributes_to_di… │\n",
+       "│ (NodePosition)                │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ embedding_4 (Embedding)       │ (None, 64)                │       6,080 │ cast_batched_attributes_to_di… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ node_distance_euclidean_4     │ (None, 1)                 │           0 │ node_position_4[0][0],         │\n",
+       "│ (NodeDistanceEuclidean)       │                           │             │ node_position_4[0][1]          │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ dense_84 (Dense)              │ (None, 128)               │       8,320 │ embedding_4[0][0]              │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ gauss_basis_layer_4           │ (None, 20)                │           0 │ node_distance_euclidean_4[0][… │\n",
+       "│ (GaussBasisLayer)             │                           │             │                                │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ sch_net_interaction_16        │ (None, 128)               │      68,608 │ dense_84[0][0],                │\n",
+       "│ (SchNetInteraction)           │                           │             │ gauss_basis_layer_4[0][0],     │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ sch_net_interaction_17        │ (None, 128)               │      68,608 │ sch_net_interaction_16[0][0],  │\n",
+       "│ (SchNetInteraction)           │                           │             │ gauss_basis_layer_4[0][0],     │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ sch_net_interaction_18        │ (None, 128)               │      68,608 │ sch_net_interaction_17[0][0],  │\n",
+       "│ (SchNetInteraction)           │                           │             │ gauss_basis_layer_4[0][0],     │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ sch_net_interaction_19        │ (None, 128)               │      68,608 │ sch_net_interaction_18[0][0],  │\n",
+       "│ (SchNetInteraction)           │                           │             │ gauss_basis_layer_4[0][0],     │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ mlp_4 (MLP)                   │ (None, 1)                 │      24,833 │ sch_net_interaction_19[0][0],  │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ pooling_nodes_4               │ (None, 1)                 │           0 │ cast_batched_indices_to_disjo… │\n",
+       "│ (PoolingNodes)                │                           │             │ mlp_4[0][0],                   │\n",
+       "│                               │                           │             │ cast_batched_indices_to_disjo… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n",
+       "│ cast_disjoint_to_batched_gra… │ (None, 1)                 │           0 │ pooling_nodes_4[0][0]          │\n",
+       "│ (CastDisjointToBatchedGraphS… │                           │             │                                │\n",
+       "└───────────────────────────────┴───────────────────────────┴─────────────┴────────────────────────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mConnected to \u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n", + "│ node_number (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ range_indices (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ total_nodes (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ total_ranges (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ node_coordinates (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ cast_batched_indices_to_disj… │ [(\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;34m2\u001b[0m, \u001b[38;5;45mNone\u001b[0m), │ \u001b[38;5;34m0\u001b[0m │ node_number[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mCastBatchedIndicesToDisjoin…\u001b[0m │ (\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m), │ │ range_indices[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ (\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m)] │ │ total_nodes[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ total_ranges[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ cast_batched_attributes_to_d… │ [(\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m), (\u001b[38;5;45mNone\u001b[0m), │ \u001b[38;5;34m0\u001b[0m │ node_coordinates[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mCastBatchedAttributesToDisj…\u001b[0m │ (\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m)] │ │ total_nodes[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ cast_batched_attributes_to_d… │ [(\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m), (\u001b[38;5;45mNone\u001b[0m), │ \u001b[38;5;34m0\u001b[0m │ node_number[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mCastBatchedAttributesToDisj…\u001b[0m │ (\u001b[38;5;45mNone\u001b[0m)] │ │ total_nodes[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ node_position_4 │ [(\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m), (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m)] │ \u001b[38;5;34m0\u001b[0m │ cast_batched_attributes_to_di… │\n", + "│ (\u001b[38;5;33mNodePosition\u001b[0m) │ │ │ cast_batched_indices_to_disjo… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ embedding_4 (\u001b[38;5;33mEmbedding\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m6,080\u001b[0m │ cast_batched_attributes_to_di… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ node_distance_euclidean_4 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ node_position_4[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mNodeDistanceEuclidean\u001b[0m) │ │ │ node_position_4[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m1\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ dense_84 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m8,320\u001b[0m │ embedding_4[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", + "│ gauss_basis_layer_4 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m20\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ node_distance_euclidean_4[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m…\u001b[0m │\n", "│ (\u001b[38;5;33mGaussBasisLayer\u001b[0m) │ │ │ │\n", "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", - "│ sch_net_interaction │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m68,608\u001b[0m │ dense[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", - "│ (\u001b[38;5;33mSchNetInteraction\u001b[0m) │ │ │ gauss_basis_layer[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ sch_net_interaction_16 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m68,608\u001b[0m │ dense_84[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mSchNetInteraction\u001b[0m) │ │ │ gauss_basis_layer_4[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", "│ │ │ │ cast_batched_indices_to_disjo… │\n", "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", - "│ sch_net_interaction_1 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m68,608\u001b[0m │ sch_net_interaction[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", - "│ (\u001b[38;5;33mSchNetInteraction\u001b[0m) │ │ │ gauss_basis_layer[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ sch_net_interaction_17 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m68,608\u001b[0m │ sch_net_interaction_16[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mSchNetInteraction\u001b[0m) │ │ │ gauss_basis_layer_4[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", "│ │ │ │ cast_batched_indices_to_disjo… │\n", "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", - "│ sch_net_interaction_2 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m68,608\u001b[0m │ sch_net_interaction_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", - "│ (\u001b[38;5;33mSchNetInteraction\u001b[0m) │ │ │ gauss_basis_layer[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ sch_net_interaction_18 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m68,608\u001b[0m │ sch_net_interaction_17[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mSchNetInteraction\u001b[0m) │ │ │ gauss_basis_layer_4[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", "│ │ │ │ cast_batched_indices_to_disjo… │\n", "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", - "│ sch_net_interaction_3 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m68,608\u001b[0m │ sch_net_interaction_2[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", - "│ (\u001b[38;5;33mSchNetInteraction\u001b[0m) │ │ │ gauss_basis_layer[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ sch_net_interaction_19 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m68,608\u001b[0m │ sch_net_interaction_18[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mSchNetInteraction\u001b[0m) │ │ │ gauss_basis_layer_4[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", "│ │ │ │ cast_batched_indices_to_disjo… │\n", "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", - "│ mlp (\u001b[38;5;33mMLP\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m24,833\u001b[0m │ sch_net_interaction_3[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ mlp_4 (\u001b[38;5;33mMLP\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m24,833\u001b[0m │ sch_net_interaction_19[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", "│ │ │ │ cast_batched_indices_to_disjo… │\n", "│ │ │ │ cast_batched_indices_to_disjo… │\n", "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", - "│ pooling_nodes (\u001b[38;5;33mPoolingNodes\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ cast_batched_indices_to_disjo… │\n", - "│ │ │ │ mlp[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ pooling_nodes_4 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ cast_batched_indices_to_disjo… │\n", + "│ (\u001b[38;5;33mPoolingNodes\u001b[0m) │ │ │ mlp_4[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", "│ │ │ │ cast_batched_indices_to_disjo… │\n", "├───────────────────────────────┼───────────────────────────┼─────────────┼────────────────────────────────┤\n", - "│ cast_disjoint_to_batched_gra… │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ pooling_nodes[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "│ cast_disjoint_to_batched_gra… │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ pooling_nodes_4[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", "│ (\u001b[38;5;33mCastDisjointToBatchedGraphS…\u001b[0m │ │ │ │\n", "└───────────────────────────────┴───────────────────────────┴─────────────┴────────────────────────────────┘\n" ] @@ -497,7 +1297,8 @@ "name": "stdout", "output_type": "stream", "text": [ - " Compiled with jit: False\n" + " Compiled with jit: False\n", + "Print Time for training: 1:45:01.765625\n" ] } ], @@ -575,10 +1376,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "c1d034b3", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "from kgcnn.utils.plots import plot_train_test_loss, plot_predict_true\n", "\n",