From 7ba557dceff6e507ba1fd067c106fb60798a5f73 Mon Sep 17 00:00:00 2001 From: PatReis Date: Mon, 26 Feb 2024 16:23:57 +0100 Subject: [PATCH] Updated requirements and changelog.md. Added notebook and fix typo in name. --- .gitignore | 1 + changelog.md | 1 + notebooks/showcase_dipole.ipynb | 919 ++++++++++++++++++ ...pynb => showcase_energy_force_model.ipynb} | 0 setup.py | 2 +- 5 files changed, 922 insertions(+), 1 deletion(-) create mode 100644 notebooks/showcase_dipole.ipynb rename notebooks/{schowcase_energy_force_model.ipynb => showcase_energy_force_model.ipynb} (100%) diff --git a/.gitignore b/.gitignore index 785c7051..e31a8eaa 100644 --- a/.gitignore +++ b/.gitignore @@ -50,3 +50,4 @@ __pycache__ /notebooks/DMPNN_esol_loss.png /docs/source/GIN_ESOL_predict.png /docs/source/GIN_esol_loss.png +/notebooks/HDNNP2nd_freesolv_loss.png diff --git a/changelog.md b/changelog.md index 851691b5..63e60939 100644 --- a/changelog.md +++ b/changelog.md @@ -17,6 +17,7 @@ causing clashes with built-in functions. We catch defaults to be at least as bac * Implemented random equivariant initialize for PAiNN * Implemented charge and dipole output for HDNNP2nd * Implemented jax backend for force models. +* Fix ``GraphBatchNormalization`` . v4.0.0 diff --git a/notebooks/showcase_dipole.ipynb b/notebooks/showcase_dipole.ipynb new file mode 100644 index 00000000..11a5eba9 --- /dev/null +++ b/notebooks/showcase_dipole.ipynb @@ -0,0 +1,919 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "a3409eb0-2fd1-4f3a-ade2-fbb80fc524aa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch\n" + ] + } + ], + "source": [ + "import keras as ks\n", + "print(ks.backend.backend())" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2d2d2339-2dff-43a1-b1be-71d3a8432552", + "metadata": {}, + "outputs": [], + "source": [ + "%%capture\n", + "from kgcnn.data.datasets.FreeSolvDataset import FreeSolvDataset\n", + "data = FreeSolvDataset()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e76e67be-4870-4811-83d4-f5d95772d3bc", + "metadata": {}, + "outputs": [], + "source": [ + "from kgcnn.graph.preprocessor import SetRange\n", + "data.map_list(SetRange(max_distance=5.0, in_place=True));\n", + "data.map_list(method=\"set_angle\")\n", + "data.map_list(method=\"count_nodes_and_edges\");\n", + "data.map_list(method=\"count_nodes_and_edges\", total_edges=\"total_ranges\", count_edges=\"range_indices\");\n", + "data.map_list(method=\"count_nodes_and_edges\", total_edges=\"total_angles\", count_edges=\"angle_indices\");" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ae24ee82-66ad-4539-a811-9a7db6fa5e19", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['node_symbol', 'node_number', 'edge_indices', 'edge_number', 'graph_size', 'node_coordinates', 'graph_labels', 'node_attributes', 'edge_attributes', 'graph_attributes', 'range_indices', 'range_attributes', 'angle_indices', 'angle_indices_nodes', 'angle_attributes', 'total_nodes', 'total_edges', 'total_ranges', 'total_angles'])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data[0].keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2a163a80-0a13-4722-b801-61eca5f49513", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(642, 1) (642, 1) (642, 3)\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "labels = np.array(data.obtain_property(\"graph_labels\"))\n", + "if len(labels.shape) <= 1:\n", + " labels = np.expand_dims(labels, axis=-1)\n", + "total_charge = np.zeros_like(labels) # simply assume zero charge\n", + "total_dipole = np.repeat(total_charge, 3, axis=-1) # simply assume zero dipole\n", + "print(labels.shape, total_charge.shape, total_dipole.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "12f8571b-aefa-411f-8159-fc7f784f0792", + "metadata": {}, + "source": [ + "## Charge as labels\n", + "\n", + "Outputs of the model will be energy, plus dipole and charge. No additional input is needed." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "9047b8d8-adca-4ef0-ae6a-61c23dcfed71", + "metadata": {}, + "outputs": [], + "source": [ + "from kgcnn.literature.HDNNP2nd import make_model_weighted" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "5257acb7-453f-4b3c-a2c1-48a9d74e3c17", + "metadata": {}, + "outputs": [], + "source": [ + "model_config = {\n", + " \"name\": \"HDNNP2nd\",\n", + " \"inputs\": [\n", + " {\"shape\": (None,), \"name\": \"node_number\", \"dtype\": \"int64\"},\n", + " {\"shape\": (None, 3), \"name\": \"node_coordinates\", \"dtype\": \"float32\"},\n", + " {\"shape\": (None, 2), \"name\": \"range_indices\", \"dtype\": \"int64\"},\n", + " {\"shape\": (None, 3), \"name\": \"angle_indices_nodes\", \"dtype\": \"int64\"},\n", + " {\"shape\": (), \"name\": \"total_nodes\", \"dtype\": \"int64\"},\n", + " {\"shape\": (), \"name\": \"total_ranges\", \"dtype\": \"int64\"},\n", + " {\"shape\": (), \"name\": \"total_angles\", \"dtype\": \"int64\"}\n", + " ],\n", + " \"input_tensor_type\": \"padded\",\n", + " \"predict_dipole\": True,\n", + " \"cast_disjoint_kwargs\": {},\n", + " \"w_acsf_ang_kwargs\": {},\n", + " \"w_acsf_rad_kwargs\": {},\n", + " \"mlp_kwargs\": {\"units\": [128, 128, 128, 1],\n", + " \"num_relations\": 96,\n", + " \"activation\": [\"swish\", \"swish\", \"swish\", \"linear\"]},\n", + " \"node_pooling_args\": {\"pooling_method\": \"sum\"},\n", + " \"verbose\": 10,\n", + " \"output_embedding\": \"graph\", \"output_to_tensor\": True,\n", + " \"use_output_mlp\": False,\n", + " \"output_mlp\": {\"use_bias\": [True, True], \"units\": [64, 1],\n", + " \"activation\": [\"swish\", \"linear\"]}\n", + "}\n", + "model = make_model_weighted(\n", + " **model_config\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e32982cc-d980-490b-bbbc-60a97bab1481", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"HDNNP2nd\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"HDNNP2nd\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                  ┃ Output Shape              ┃         Param # ┃ Connected to               ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+       "│ node_coordinates (InputLayer) │ (None, None, 3)           │               0 │ -                          │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ total_nodes (InputLayer)      │ (None)                    │               0 │ -                          │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ node_number (InputLayer)      │ (None, None)              │               0 │ -                          │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ range_indices (InputLayer)    │ (None, None, 2)           │               0 │ -                          │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ total_ranges (InputLayer)     │ (None)                    │               0 │ -                          │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ angle_indices_nodes           │ (None, None, 3)           │               0 │ -                          │\n",
+       "│ (InputLayer)                  │                           │                 │                            │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ total_angles (InputLayer)     │ (None)                    │               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_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_indices_to_disj… │ [(None), (3, None),       │               0 │ node_number[0][0],         │\n",
+       "│ (CastBatchedIndicesToDisjoin… │ (None), (None), (None),   │                 │ angle_indices_nodes[0][0], │\n",
+       "│                               │ (None), (None), (None)]   │                 │ total_nodes[0][0],         │\n",
+       "│                               │                           │                 │ total_angles[0][0]         │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ w_acsf_rad (wACSFRad)         │ (None, 22)                │           5,192 │ cast_batched_indices_to_d… │\n",
+       "│                               │                           │                 │ cast_batched_attributes_t… │\n",
+       "│                               │                           │                 │ cast_batched_indices_to_d… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ w_acsf_ang (wACSFAng)         │ (None, 10)                │           4,720 │ cast_batched_indices_to_d… │\n",
+       "│                               │                           │                 │ cast_batched_attributes_t… │\n",
+       "│                               │                           │                 │ cast_batched_indices_to_d… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ concatenate (Concatenate)     │ (None, 32)                │               0 │ w_acsf_rad[0][0],          │\n",
+       "│                               │                           │                 │ w_acsf_ang[0][0]           │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ relational_mlp                │ (None, 1)                 │       3,551,617 │ concatenate[0][0],         │\n",
+       "│ (RelationalMLP)               │                           │                 │ cast_batched_indices_to_d… │\n",
+       "│                               │                           │                 │ cast_batched_attributes_t… │\n",
+       "│                               │                           │                 │ cast_batched_attributes_t… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ dense (Dense)                 │ (None, 1)                 │               2 │ relational_mlp[0][0]       │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ multiply_2 (Multiply)         │ (None, 3)                 │               0 │ dense[0][0],               │\n",
+       "│                               │                           │                 │ cast_batched_attributes_t… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ pooling_nodes (PoolingNodes)  │ (None, 1)                 │               0 │ cast_batched_attributes_t… │\n",
+       "│                               │                           │                 │ relational_mlp[0][0],      │\n",
+       "│                               │                           │                 │ cast_batched_attributes_t… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ pooling_nodes_2               │ (None, 3)                 │               0 │ cast_batched_attributes_t… │\n",
+       "│ (PoolingNodes)                │                           │                 │ multiply_2[0][0],          │\n",
+       "│                               │                           │                 │ cast_batched_attributes_t… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ pooling_nodes_1               │ (None, 1)                 │               0 │ cast_batched_attributes_t… │\n",
+       "│ (PoolingNodes)                │                           │                 │ dense[0][0],               │\n",
+       "│                               │                           │                 │ cast_batched_attributes_t… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ cast_disjoint_to_batched_gra… │ (None, 1)                 │               0 │ pooling_nodes[0][0]        │\n",
+       "│ (CastDisjointToBatchedGraphS… │                           │                 │                            │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ cast_disjoint_to_batched_gra… │ (None, 3)                 │               0 │ pooling_nodes_2[0][0]      │\n",
+       "│ (CastDisjointToBatchedGraphS… │                           │                 │                            │\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_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", + "│ total_nodes (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m) │ \u001b[38;5;34m0\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_ranges (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n", + "│ angle_indices_nodes │ (\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", + "│ (\u001b[38;5;33mInputLayer\u001b[0m) │ │ │ │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n", + "│ total_angles (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\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_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_indices_to_disj… │ [(\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_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), │ │ angle_indices_nodes[\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_angles[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n", + "│ w_acsf_rad (\u001b[38;5;33mwACSFRad\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m22\u001b[0m) │ \u001b[38;5;34m5,192\u001b[0m │ cast_batched_indices_to_d… │\n", + "│ │ │ │ cast_batched_attributes_t… │\n", + "│ │ │ │ cast_batched_indices_to_d… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n", + "│ w_acsf_ang (\u001b[38;5;33mwACSFAng\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m) │ \u001b[38;5;34m4,720\u001b[0m │ cast_batched_indices_to_d… │\n", + "│ │ │ │ cast_batched_attributes_t… │\n", + "│ │ │ │ cast_batched_indices_to_d… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n", + "│ concatenate (\u001b[38;5;33mConcatenate\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ w_acsf_rad[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ w_acsf_ang[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n", + "│ relational_mlp │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m3,551,617\u001b[0m │ concatenate[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mRelationalMLP\u001b[0m) │ │ │ cast_batched_indices_to_d… │\n", + "│ │ │ │ cast_batched_attributes_t… │\n", + "│ │ │ │ cast_batched_attributes_t… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n", + "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m2\u001b[0m │ relational_mlp[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n", + "│ multiply_2 (\u001b[38;5;33mMultiply\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ dense[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_attributes_t… │\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_attributes_t… │\n", + "│ │ │ │ relational_mlp[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_attributes_t… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n", + "│ pooling_nodes_2 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ cast_batched_attributes_t… │\n", + "│ (\u001b[38;5;33mPoolingNodes\u001b[0m) │ │ │ multiply_2[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_attributes_t… │\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_attributes_t… │\n", + "│ (\u001b[38;5;33mPoolingNodes\u001b[0m) │ │ │ dense[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_attributes_t… │\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", + "│ cast_disjoint_to_batched_gra… │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\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", + "│ 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: 3,561,531 (13.59 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m3,561,531\u001b[0m (13.59 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 3,551,619 (13.55 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m3,551,619\u001b[0m (13.55 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 9,912 (38.72 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m9,912\u001b[0m (38.72 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 25ms/step \n" + ] + } + ], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "from keras.optimizers import Adam\n", + "\n", + "data.clean(model_config[\"inputs\"])\n", + "train_index, test_index = train_test_split(np.arange(len(data)), test_size=0.2)\n", + "\n", + "dataset_train, dataset_test = data[train_index], data[test_index]\n", + "x_train, y_train = dataset_train.tensor(model_config[\"inputs\"]), [y_part[train_index] for y_part in [labels, total_dipole, total_charge]]\n", + "x_test, y_test = dataset_test.tensor(model_config[\"inputs\"]), [y_part[test_index] for y_part in [labels, total_dipole, total_charge]]\n", + "\n", + "# Compile model with optimizer and loss\n", + "model.compile(loss=[\"mean_absolute_error\"]*3, metrics=[[\"mean_absolute_error\"]]*3, optimizer=Adam(learning_rate=5e-04))\n", + "model.summary()\n", + "\n", + "# Build model with reasonable data.\n", + "model.predict(x_test, batch_size=2, steps=2)\n", + "model._compile_metrics.build(y_test, y_test)\n", + "model._compile_loss.build(y_test, y_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "1aede3ee-64c6-408d-8300-0b4363680ca5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Print Time for training: 0:01:23.656250\n" + ] + } + ], + "source": [ + "# Start and time training\n", + "import time\n", + "from datetime import timedelta\n", + "from kgcnn.training.scheduler import LinearLearningRateScheduler\n", + "start = time.process_time()\n", + "hist = model.fit(x_train, y_train,\n", + " validation_data=(x_test, y_test),\n", + " batch_size=32, \n", + " epochs=300, \n", + " validation_freq=10, \n", + " verbose=0, # Change to verbose = 2 to see progress\n", + " callbacks= [\n", + " LinearLearningRateScheduler(\n", + " learning_rate_start=0.001, learning_rate_stop=1e-05, epo_min=100, epo=300)\n", + " ])\n", + "stop = time.process_time()\n", + "print(\"Print Time for training: \", str(timedelta(seconds=stop - start)))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "bafb5381-02f3-4596-8c3b-d03a7601ba3e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from kgcnn.utils.plots import plot_train_test_loss, plot_predict_true\n", + "\n", + "plot_train_test_loss([hist], loss_name=None, val_loss_name=None,\n", + " model_name=\"HDNNP2nd\", data_unit=\"\", dataset_name=\"freesolv\",\n", + " filepath=\"\", file_name=f\"loss.png\");" + ] + }, + { + "cell_type": "markdown", + "id": "f495c36c-c9a2-4bd4-b149-3d9673cba966", + "metadata": {}, + "source": [ + "## Charge as input\n", + "\n", + "Total charge is needed at input. Output will be energy and dipole." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "96c49ffd-b24d-487e-ab69-c53173c27b81", + "metadata": {}, + "outputs": [], + "source": [ + "model_config = {\n", + " \"name\": \"HDNNP2nd\",\n", + " \"inputs\": [\n", + " {\"shape\": (None,), \"name\": \"node_number\", \"dtype\": \"int64\"},\n", + " {\"shape\": (None, 3), \"name\": \"node_coordinates\", \"dtype\": \"float32\"},\n", + " {\"shape\": (None, 2), \"name\": \"range_indices\", \"dtype\": \"int64\"},\n", + " {\"shape\": (None, 3), \"name\": \"angle_indices_nodes\", \"dtype\": \"int64\"},\n", + " {\"shape\": (1, ), \"name\": \"total_charge\", \"dtype\": \"int64\"},\n", + " {\"shape\": (), \"name\": \"total_nodes\", \"dtype\": \"int64\"},\n", + " {\"shape\": (), \"name\": \"total_ranges\", \"dtype\": \"int64\"},\n", + " {\"shape\": (), \"name\": \"total_angles\", \"dtype\": \"int64\"}\n", + " ],\n", + " \"input_tensor_type\": \"padded\",\n", + " \"predict_dipole\": True,\n", + " \"has_charge_input\": True,\n", + " \"cast_disjoint_kwargs\": {},\n", + " \"w_acsf_ang_kwargs\": {},\n", + " \"w_acsf_rad_kwargs\": {},\n", + " \"mlp_kwargs\": {\"units\": [128, 128, 128, 1],\n", + " \"num_relations\": 96,\n", + " \"activation\": [\"swish\", \"swish\", \"swish\", \"linear\"]},\n", + " \"node_pooling_args\": {\"pooling_method\": \"sum\"},\n", + " \"verbose\": 10,\n", + " \"output_embedding\": \"graph\", \"output_to_tensor\": True,\n", + " \"use_output_mlp\": False,\n", + " \"output_mlp\": {\"use_bias\": [True, True], \"units\": [64, 1],\n", + " \"activation\": [\"swish\", \"linear\"]}\n", + "}\n", + "model = make_model_weighted(\n", + " **model_config\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "3d0f1106-2a3c-4ece-b052-457b3f864949", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_keys(['node_symbol', 'node_number', 'edge_indices', 'edge_number', 'graph_size', 'node_coordinates', 'graph_labels', 'node_attributes', 'edge_attributes', 'graph_attributes', 'range_indices', 'range_attributes', 'angle_indices', 'angle_indices_nodes', 'angle_attributes', 'total_nodes', 'total_edges', 'total_ranges', 'total_angles', 'total_charge'])\n" + ] + } + ], + "source": [ + "# add charge to data\n", + "for i, x in enumerate(data):\n", + " x[\"total_charge\"] = total_charge[i]\n", + "print(data[0].keys())" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "cef9ae92-2c0c-43b5-ac79-32cf37ebbb72", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"HDNNP2nd\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"HDNNP2nd\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                  ┃ Output Shape              ┃         Param # ┃ Connected to               ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+       "│ node_coordinates (InputLayer) │ (None, None, 3)           │               0 │ -                          │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ total_nodes (InputLayer)      │ (None)                    │               0 │ -                          │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ node_number (InputLayer)      │ (None, None)              │               0 │ -                          │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ range_indices (InputLayer)    │ (None, None, 2)           │               0 │ -                          │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ total_ranges (InputLayer)     │ (None)                    │               0 │ -                          │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ angle_indices_nodes           │ (None, None, 3)           │               0 │ -                          │\n",
+       "│ (InputLayer)                  │                           │                 │                            │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ total_angles (InputLayer)     │ (None)                    │               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_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_indices_to_disj… │ [(None), (3, None),       │               0 │ node_number[0][0],         │\n",
+       "│ (CastBatchedIndicesToDisjoin… │ (None), (None), (None),   │                 │ angle_indices_nodes[0][0], │\n",
+       "│                               │ (None), (None), (None)]   │                 │ total_nodes[0][0],         │\n",
+       "│                               │                           │                 │ total_angles[0][0]         │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ w_acsf_rad_1 (wACSFRad)       │ (None, 22)                │           5,192 │ cast_batched_indices_to_d… │\n",
+       "│                               │                           │                 │ cast_batched_attributes_t… │\n",
+       "│                               │                           │                 │ cast_batched_indices_to_d… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ w_acsf_ang_1 (wACSFAng)       │ (None, 10)                │           4,720 │ cast_batched_indices_to_d… │\n",
+       "│                               │                           │                 │ cast_batched_attributes_t… │\n",
+       "│                               │                           │                 │ cast_batched_indices_to_d… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ concatenate_1 (Concatenate)   │ (None, 32)                │               0 │ w_acsf_rad_1[0][0],        │\n",
+       "│                               │                           │                 │ w_acsf_ang_1[0][0]         │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ relational_mlp_1              │ (None, 1)                 │       3,551,617 │ concatenate_1[0][0],       │\n",
+       "│ (RelationalMLP)               │                           │                 │ cast_batched_indices_to_d… │\n",
+       "│                               │                           │                 │ cast_batched_attributes_t… │\n",
+       "│                               │                           │                 │ cast_batched_attributes_t… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ dense_1 (Dense)               │ (None, 1)                 │               2 │ relational_mlp_1[0][0]     │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ total_charge (InputLayer)     │ (None, 1)                 │               0 │ -                          │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ pooling_nodes_4               │ (None, 1)                 │               0 │ cast_batched_attributes_t… │\n",
+       "│ (PoolingNodes)                │                           │                 │ dense_1[0][0],             │\n",
+       "│                               │                           │                 │ cast_batched_attributes_t… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ cast_batched_graph_state_to_… │ (None, 1)                 │               0 │ total_charge[0][0]         │\n",
+       "│ (CastBatchedGraphStateToDisj… │                           │                 │                            │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ correct_partial_charges       │ (None, 1)                 │               0 │ pooling_nodes_4[0][0],     │\n",
+       "│ (CorrectPartialCharges)       │                           │                 │ cast_batched_graph_state_… │\n",
+       "│                               │                           │                 │ cast_batched_attributes_t… │\n",
+       "│                               │                           │                 │ cast_batched_attributes_t… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ add (Add)                     │ (None, 1)                 │               0 │ dense_1[0][0],             │\n",
+       "│                               │                           │                 │ correct_partial_charges[0… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ multiply_5 (Multiply)         │ (None, 3)                 │               0 │ add[0][0],                 │\n",
+       "│                               │                           │                 │ cast_batched_attributes_t… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ pooling_nodes_3               │ (None, 1)                 │               0 │ cast_batched_attributes_t… │\n",
+       "│ (PoolingNodes)                │                           │                 │ relational_mlp_1[0][0],    │\n",
+       "│                               │                           │                 │ cast_batched_attributes_t… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ pooling_nodes_5               │ (None, 3)                 │               0 │ cast_batched_attributes_t… │\n",
+       "│ (PoolingNodes)                │                           │                 │ multiply_5[0][0],          │\n",
+       "│                               │                           │                 │ cast_batched_attributes_t… │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ cast_disjoint_to_batched_gra… │ (None, 1)                 │               0 │ pooling_nodes_3[0][0]      │\n",
+       "│ (CastDisjointToBatchedGraphS… │                           │                 │                            │\n",
+       "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
+       "│ cast_disjoint_to_batched_gra… │ (None, 3)                 │               0 │ pooling_nodes_5[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_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", + "│ total_nodes (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m) │ \u001b[38;5;34m0\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_ranges (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n", + "│ angle_indices_nodes │ (\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", + "│ (\u001b[38;5;33mInputLayer\u001b[0m) │ │ │ │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n", + "│ total_angles (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\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_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_indices_to_disj… │ [(\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_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), │ │ angle_indices_nodes[\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_angles[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n", + "│ w_acsf_rad_1 (\u001b[38;5;33mwACSFRad\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m22\u001b[0m) │ \u001b[38;5;34m5,192\u001b[0m │ cast_batched_indices_to_d… │\n", + "│ │ │ │ cast_batched_attributes_t… │\n", + "│ │ │ │ cast_batched_indices_to_d… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n", + "│ w_acsf_ang_1 (\u001b[38;5;33mwACSFAng\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m) │ \u001b[38;5;34m4,720\u001b[0m │ cast_batched_indices_to_d… │\n", + "│ │ │ │ cast_batched_attributes_t… │\n", + "│ │ │ │ cast_batched_indices_to_d… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n", + "│ concatenate_1 (\u001b[38;5;33mConcatenate\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ w_acsf_rad_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ w_acsf_ang_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n", + "│ relational_mlp_1 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m3,551,617\u001b[0m │ concatenate_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mRelationalMLP\u001b[0m) │ │ │ cast_batched_indices_to_d… │\n", + "│ │ │ │ cast_batched_attributes_t… │\n", + "│ │ │ │ cast_batched_attributes_t… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n", + "│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m2\u001b[0m │ relational_mlp_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n", + "│ total_charge (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n", + "│ pooling_nodes_4 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ cast_batched_attributes_t… │\n", + "│ (\u001b[38;5;33mPoolingNodes\u001b[0m) │ │ │ dense_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_attributes_t… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n", + "│ cast_batched_graph_state_to_… │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ total_charge[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "│ (\u001b[38;5;33mCastBatchedGraphStateToDisj…\u001b[0m │ │ │ │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n", + "│ correct_partial_charges │ (\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;33mCorrectPartialCharges\u001b[0m) │ │ │ cast_batched_graph_state_… │\n", + "│ │ │ │ cast_batched_attributes_t… │\n", + "│ │ │ │ cast_batched_attributes_t… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n", + "│ add (\u001b[38;5;33mAdd\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ dense_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ correct_partial_charges[\u001b[38;5;34m0\u001b[0m… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n", + "│ multiply_5 (\u001b[38;5;33mMultiply\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ add[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_attributes_t… │\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_attributes_t… │\n", + "│ (\u001b[38;5;33mPoolingNodes\u001b[0m) │ │ │ relational_mlp_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_attributes_t… │\n", + "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n", + "│ pooling_nodes_5 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ cast_batched_attributes_t… │\n", + "│ (\u001b[38;5;33mPoolingNodes\u001b[0m) │ │ │ multiply_5[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ cast_batched_attributes_t… │\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", + "│ cast_disjoint_to_batched_gra… │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ pooling_nodes_5[\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: 3,561,531 (13.59 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m3,561,531\u001b[0m (13.59 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 3,551,619 (13.55 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m3,551,619\u001b[0m (13.55 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 9,912 (38.72 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m9,912\u001b[0m (38.72 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 25ms/step\n" + ] + } + ], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "from keras.optimizers import Adam\n", + "\n", + "data.clean(model_config[\"inputs\"])\n", + "train_index, test_index = train_test_split(np.arange(len(data)), test_size=0.2)\n", + "\n", + "dataset_train, dataset_test = data[train_index], data[test_index]\n", + "x_train, y_train = dataset_train.tensor(model_config[\"inputs\"]), [y_part[train_index] for y_part in [labels, total_dipole]]\n", + "x_test, y_test = dataset_test.tensor(model_config[\"inputs\"]), [y_part[test_index] for y_part in [labels, total_dipole]]\n", + "\n", + "# Compile model with optimizer and loss\n", + "model.compile(loss=[\"mean_absolute_error\"]*2, metrics=[[\"mean_absolute_error\"]]*2, optimizer=Adam(learning_rate=5e-04))\n", + "model.summary()\n", + "\n", + "# Build model with reasonable data.\n", + "model.predict(x_test, batch_size=2, steps=2)\n", + "model._compile_metrics.build(y_test, y_test)\n", + "model._compile_loss.build(y_test, y_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "b3a3d0bd-61bb-4445-bead-d090f455a65c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Print Time for training: 0:01:20.671875\n" + ] + } + ], + "source": [ + "# Start and time training\n", + "import time\n", + "from datetime import timedelta\n", + "from kgcnn.training.scheduler import LinearLearningRateScheduler\n", + "start = time.process_time()\n", + "hist = model.fit(x_train, y_train,\n", + " validation_data=(x_test, y_test),\n", + " batch_size=32, \n", + " epochs=300, \n", + " validation_freq=10, \n", + " verbose=0, # Change to verbose = 2 to see progress\n", + " callbacks= [\n", + " LinearLearningRateScheduler(\n", + " learning_rate_start=0.001, learning_rate_stop=1e-05, epo_min=100, epo=300)\n", + " ])\n", + "stop = time.process_time()\n", + "print(\"Print Time for training: \", str(timedelta(seconds=stop - start)))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "193b7d4d-d71f-492d-a69d-e5f92cc334a0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from kgcnn.utils.plots import plot_train_test_loss, plot_predict_true\n", + "\n", + "plot_train_test_loss([hist], loss_name=None, val_loss_name=None,\n", + " model_name=\"HDNNP2nd\", data_unit=\"\", dataset_name=\"freesolv\",\n", + " filepath=\"\", file_name=f\"loss.png\");" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "37276deb-a88b-42c0-b880-3c8b9f6852aa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4/4\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 22ms/step\n" + ] + } + ], + "source": [ + "preds = model.predict(x_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "40cc6e4c-502a-4f8a-99bf-cf3406b98ff5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([-1.2860615], dtype=float32),\n", + " array([-3.7679669e-07, -7.7845078e-07, 1.2414034e-06], dtype=float32))" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "preds[0][0], preds[1][0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4015396d-bfe1-4836-90c6-0344a725e3a1", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/schowcase_energy_force_model.ipynb b/notebooks/showcase_energy_force_model.ipynb similarity index 100% rename from notebooks/schowcase_energy_force_model.ipynb rename to notebooks/showcase_energy_force_model.ipynb diff --git a/setup.py b/setup.py index 0ec20a70..9ed63779 100644 --- a/setup.py +++ b/setup.py @@ -15,7 +15,7 @@ url="https://github.com/aimat-lab/gcnn_keras", install_requires=[ # "dm-tree", - "keras>=3.0.5", + "keras>=3.0.2", # Backends # "tf-nightly-cpu==2.16.0.dev20240101", # "torch>=2.1.0",