diff --git a/kgcnn/data/base.py b/kgcnn/data/base.py index 41bdc2a1..634693b4 100644 --- a/kgcnn/data/base.py +++ b/kgcnn/data/base.py @@ -3,7 +3,7 @@ import pandas as pd import os from sklearn.model_selection import KFold -from kgcnn.io.loader import experimental_tf_disjoint_list_generator +from kgcnn.io.loader import tf_disjoint_list_generator # import typing as t from typing import Union, List, Callable, Dict, Optional # from collections.abc import MutableSequence @@ -332,7 +332,7 @@ def rename_property_on_graphs(self, old_property_name: str, new_property_name: s def tf_disjoint_data_generator(self, inputs, outputs, **kwargs): assert isinstance(inputs, list), "Dictionary input is not yet implemented" module_logger.info("Dataloader is experimental and not fully tested or stable.") - return experimental_tf_disjoint_list_generator(self, inputs=inputs, outputs=outputs, **kwargs) + return tf_disjoint_list_generator(self, inputs=inputs, outputs=outputs, **kwargs) class MemoryGraphDataset(MemoryGraphList): diff --git a/kgcnn/io/loader.py b/kgcnn/io/loader.py index ac645427..2d24fbb1 100644 --- a/kgcnn/io/loader.py +++ b/kgcnn/io/loader.py @@ -1,131 +1,66 @@ import keras as ks from typing import Union import numpy as np +from numpy.random import Generator, PCG64 import tensorflow as tf -def experimental_tf_disjoint_list_generator(graphs, - inputs, - outputs, - has_nodes=True, - has_edges=True, - has_graph_state=False, - batch_size=32, - shuffle=True): - def generator(): - dataset_size = len(graphs) - data_index = np.arange(dataset_size) - - if shuffle: - np.random.shuffle(data_index) - - for batch_index in range(0, dataset_size, batch_size): - idx = data_index[batch_index:batch_index + batch_size] - graphs_batch = [graphs[i] for i in idx] - - batch_id_node, batch_id_edge, node_id, edge_id, count_nodes, count_edges = [None for _ in range(6)] - out = [] - inputs_pos = 0 - for j in range(int(has_nodes)): - array_list = [x[inputs[inputs_pos]["name"]] for x in graphs_batch] - out.append(np.concatenate(array_list, axis=0)) - inputs_pos += 1 - if j == 0: - count_nodes = np.array([len(x) for x in array_list], dtype="int64") - batch_id_node = np.repeat(np.arange(len(array_list), dtype="int64"), repeats=count_nodes) - node_id = np.concatenate([np.arange(x, dtype="int64") for x in count_nodes], axis=0) - - for j in range(int(has_edges)): - array_list = [x[inputs[inputs_pos]["name"]] for x in graphs_batch] - out.append(np.concatenate(array_list, axis=0, dtype=inputs[inputs_pos]["dtype"])) - inputs_pos += 1 - - for j in range(int(has_graph_state)): - array_list = [x[inputs[inputs_pos]["name"]] for x in graphs_batch] - out.append(np.array(array_list, dtype=inputs[inputs_pos]["dtype"])) - inputs_pos += 1 - - # Indices - array_list = [x[inputs[inputs_pos]["name"]] for x in graphs_batch] - count_edges = np.array([len(x) for x in array_list], dtype="int64") - batch_id_edge = np.repeat(np.arange(len(array_list), dtype="int64"), repeats=count_edges) - edge_id = np.concatenate([np.arange(x, dtype="int64") for x in count_edges], axis=0) - edge_indices_flatten = np.concatenate(array_list, axis=0) - - node_splits = np.pad(np.cumsum(count_nodes), [[1, 0]]) - offset_edge_indices = np.expand_dims(np.repeat(node_splits[:-1], count_edges), axis=-1) - disjoint_indices = edge_indices_flatten + offset_edge_indices - disjoint_indices = np.transpose(disjoint_indices) - out.append(disjoint_indices) - - out = out + [batch_id_node, batch_id_edge, node_id, edge_id, count_nodes, count_edges] - - if isinstance(outputs, list): - out_y = [] - for k in range(len(outputs)): - array_list = [x[outputs[k]["name"]] for x in graphs_batch] - out_y.append(np.array(array_list, dtype=outputs[k]["dtype"])) - elif isinstance(outputs, dict): - out_y = np.array( - [x[outputs["name"]] for x in graphs_batch], dtype=outputs["dtype"]) - else: - raise ValueError() - - yield tuple(out), out_y - - input_spec = tuple([tf.TensorSpec(shape=tuple([None] + list(x["shape"])), dtype=x["dtype"]) for x in inputs]) - - if isinstance(outputs, list): - output_spec = tuple([tf.TensorSpec(shape=tuple([None] + list(x["shape"])), dtype=x["dtype"]) for x in outputs]) - elif isinstance(outputs, dict): - output_spec = tf.TensorSpec(shape=tuple([None] + list(outputs["shape"])), dtype=outputs["dtype"]) - else: - raise ValueError() - - data_loader = tf.data.Dataset.from_generator( - generator, - output_signature=( - input_spec, - output_spec - ) - ) - - return data_loader - - def tf_disjoint_list_generator( graphs, inputs: list, outputs: list, assignment_to_id: list = None, assignment_of_indices: list = None, - flag_batch_id: list = None, - flag_count: list = None, - flag_subgraph_id: list = None, + pos_batch_id: list = None, + pos_subgraph_id: list = None, + pos_count: list = None, batch_size=32, - shuffle=True + padded_disjoint=False, + epochs=None, + shuffle=True, + seed=42 ): + dataset_size = len(graphs) + data_index = np.arange(dataset_size) + num_inputs = len(inputs) + + if len(assignment_to_id) < num_inputs: + assignment_to_id = assignment_to_id + [None for _ in range(num_inputs-len(assignment_to_id))] + if len(assignment_of_indices) < num_inputs: + assignment_of_indices = assignment_of_indices + [None for _ in range(num_inputs-len(assignment_of_indices))] + + flag_batch_id = [None for _ in range(num_inputs)] + for i, x in enumerate(pos_batch_id): + flag_batch_id[x] = i + + flag_count = [None for _ in range(num_inputs)] + for i, x in enumerate(pos_count): + flag_count[x] = i + + flag_subgraph_id = [None for _ in range(num_inputs)] + for i, x in enumerate(pos_subgraph_id): + flag_subgraph_id[x] = i + + all_flags = [flag_batch_id, flag_count, flag_subgraph_id] + is_attributes = [True if all([x[i] is None for x in all_flags]) else False for i in range(num_inputs)] + + if padded_disjoint: + if epochs is None: + raise ValueError("Requires number of epochs if `padded_disjoint=True` .") + + rng = Generator(PCG64(seed=seed)) def generator(): - dataset_size = len(graphs) - data_index = np.arange(dataset_size) - num_inputs = len(inputs) - all_flags = [flag_batch_id, flag_count, flag_subgraph_id] - is_attributes = [True if all([x[i] is not None for x in all_flags]) else False for i in range(num_inputs)] - where_batch = [] - where_subgraph= [] - where_count = [] - num_attributes = sum(is_attributes) if shuffle: - np.random.shuffle(data_index) + rng.shuffle(data_index) for batch_index in range(0, dataset_size, batch_size): idx = data_index[batch_index:batch_index + batch_size] graphs_batch = [graphs[i] for i in idx] - out = [None for _ in range(num_attributes)] - out_counts = [None for _ in range(num_attributes)] + out = [None for _ in range(num_inputs)] + out_counts = [None for _ in range(num_inputs)] for i in range(num_inputs): if not is_attributes[i]: @@ -139,12 +74,12 @@ def generator(): counts = np.array([len(x) for x in array_list], dtype="int64") out_counts[i] = counts ids = assignment_to_id[i] - if out[where_count[ids]] is not None: - out[where_count[ids]] = counts - if out[where_batch[ids]] is not None: - out[where_batch[ids]] = np.repeat(np.arange(len(array_list), dtype="int64"), repeats=counts) - if out[where_subgraph[ids]] is not None: - out[where_subgraph[ids]] = np.concatenate([np.arange(x, dtype="int64") for x in counts], axis=0) + if out[pos_count[ids]] is None: + out[pos_count[ids]] = counts + if out[pos_batch_id[ids]] is None: + out[pos_batch_id[ids]] = np.repeat(np.arange(len(array_list), dtype="int64"), repeats=counts) + if out[pos_subgraph_id[ids]] is None: + out[pos_subgraph_id[ids]] = np.concatenate([np.arange(x, dtype="int64") for x in counts], axis=0) # Indices for i in range(num_inputs): diff --git a/kgcnn/layers/geom.py b/kgcnn/layers/geom.py index 6a054d22..ce1449a2 100644 --- a/kgcnn/layers/geom.py +++ b/kgcnn/layers/geom.py @@ -103,7 +103,7 @@ def call(self, inputs, **kwargs): """Forward pass. Args: - inputs (list): `[position, edge_image, lattice, num_edges]` + inputs (list): `[position, edge_image, lattice, batch_id_edge]` - position (Tensor): Positions of shape `(M, 3)` - edge_image (Tensor): Position in which image to shift of shape `(M, 3)` diff --git a/kgcnn/literature/CMPNN/_layers.py b/kgcnn/literature/CMPNN/_layers.py index c9acd2de..a324f43c 100644 --- a/kgcnn/literature/CMPNN/_layers.py +++ b/kgcnn/literature/CMPNN/_layers.py @@ -15,6 +15,7 @@ def __init__(self, units, static_output_shape=None, **kwargs): super(PoolingNodesGRU, self).__init__(**kwargs) self.units = units + self.static_output_shape = static_output_shape self.cast_layer = CastDisjointToBatchedAttributes( static_output_shape=static_output_shape, return_mask=True) self.gru = GRU( diff --git a/kgcnn/literature/GIN/_make.py b/kgcnn/literature/GIN/_make.py index 9db2d75c..19cc160c 100644 --- a/kgcnn/literature/GIN/_make.py +++ b/kgcnn/literature/GIN/_make.py @@ -151,7 +151,6 @@ def set_scale(*args, **kwargs): make_model.__doc__ = make_model.__doc__ % (template_cast_list_input.__doc__, template_cast_output.__doc__) - model_default_edge = { "name": "GINE", "inputs": [ @@ -244,7 +243,12 @@ def make_model_edge(inputs: list = None, 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) + model_inputs, + input_tensor_type=input_tensor_type, + cast_disjoint_kwargs=cast_disjoint_kwargs, + mask_assignment=[0, 1, 1], + index_assignment=[None, None, 0] + ) n, ed, disjoint_indices, batch_id_node, batch_id_edge, node_id, edge_id, count_nodes, count_edges = disjoint_inputs diff --git a/kgcnn/literature/Megnet/_model.py b/kgcnn/literature/Megnet/_model.py index 1b0c7938..ea252e12 100644 --- a/kgcnn/literature/Megnet/_model.py +++ b/kgcnn/literature/Megnet/_model.py @@ -133,7 +133,7 @@ def model_disjoint_crystal( # Edge distance as Gauss-Basis if make_distance: pos1, pos2 = NodePosition()([x, edi]) - pos2 = ShiftPeriodicLattice()([pos2, edge_image, lattice]) + pos2 = ShiftPeriodicLattice()([pos2, edge_image, lattice, batch_id_edge]) ep = NodeDistanceEuclidean()([pos1, pos2]) else: ep = x diff --git a/kgcnn/literature/NMPN/_make.py b/kgcnn/literature/NMPN/_make.py index cff58b53..9d45e248 100644 --- a/kgcnn/literature/NMPN/_make.py +++ b/kgcnn/literature/NMPN/_make.py @@ -1,6 +1,6 @@ import keras as ks from kgcnn.layers.scale import get as get_scaler -from ._model import model_disjoint +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 @@ -309,7 +309,7 @@ def make_crystal_model(inputs: list = None, n, x, d_indices, img, lattice, batch_id_node, batch_id_edge, node_id, edge_id, count_nodes, count_edges = dj - out = model_disjoint( + out = model_disjoint_crystal( [n, x, d_indices, 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_edge_embedding=("int" in inputs[1]['dtype']) if input_edge_embedding is not None else False, diff --git a/kgcnn/literature/NMPN/_model.py b/kgcnn/literature/NMPN/_model.py index 03b3c4c1..8344d4f7 100644 --- a/kgcnn/literature/NMPN/_model.py +++ b/kgcnn/literature/NMPN/_model.py @@ -117,7 +117,7 @@ def model_disjoint_crystal(inputs, if make_distance: x = ed pos1, pos2 = NodePosition()([x, disjoint_indices]) - pos2 = ShiftPeriodicLattice()([pos2, edge_image, lattice]) + pos2 = ShiftPeriodicLattice()([pos2, edge_image, lattice, batch_id_edge]) ed = NodeDistanceEuclidean()([pos1, pos2]) if expand_distance: diff --git a/kgcnn/models/casting.py b/kgcnn/models/casting.py index 11fdf0ef..1cce9356 100644 --- a/kgcnn/models/casting.py +++ b/kgcnn/models/casting.py @@ -38,6 +38,8 @@ def template_cast_output(model_outputs, # Output embedding choice if output_embedding == 'graph': + # Here we could also modify the behaviour for direct disjoint output to not remove padded ones, + # in case also the output is padded. out = CastDisjointToBatchedGraphState(**cast_disjoint_kwargs)(out) elif output_embedding == 'node': if output_tensor_type in ["padded", "masked"]: @@ -85,6 +87,7 @@ def template_cast_list_input(model_inputs, :obj:`[nodes, edges, angles, edge_indices, angle_indices, graph_state, image_translation, lattice,...]` . Note that in place of nodes or edges also more than one tensor can be provided, depending on the model, for example :obj:`[nodes_1, nodes_2, edges_1, edges_2, edge_indices, ...]` . + However, for future models we intend to used named inputs rather than a list that is sensible to ordering. Whether to use mask or length tensor for padded as well as further parameter of casting has to be set with (dict) :obj:`cast_disjoint_kwargs` . diff --git a/notebooks/tutorial_model_loading_options.ipynb b/notebooks/tutorial_model_loading_options.ipynb index 90f54ceb..69b5d884 100644 --- a/notebooks/tutorial_model_loading_options.ipynb +++ b/notebooks/tutorial_model_loading_options.ipynb @@ -100,7 +100,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO:kgcnn.models.utils:Updated model kwargs: '{'name': 'GINE', 'inputs': [{'shape': (None, 41), 'name': 'node_attributes', 'dtype': 'float32'}, {'shape': (None, 11), 'name': 'edge_attributes', 'dtype': 'float32'}, {'shape': (None, 2), 'name': 'edge_indices', 'dtype': 'int64'}, {'shape': (), 'name': 'total_nodes', 'dtype': 'int64'}, {'shape': (), 'name': 'total_edges', 'dtype': 'int64'}], 'input_tensor_type': 'padded', 'cast_disjoint_kwargs': {}, 'input_embedding': None, 'input_node_embedding': {'input_dim': 95, 'output_dim': 64}, 'input_edge_embedding': {'input_dim': 10, 'output_dim': 64}, 'gin_mlp': {'units': [64, 64], 'use_bias': True, 'activation': ['relu', 'linear'], 'use_normalization': True, 'normalization_technique': 'graph_batch'}, 'gin_args': {'epsilon_learnable': False}, 'depth': 3, 'dropout': 0.0, 'verbose': 10, 'last_mlp': {'use_bias': [True, True, True], 'units': [64, 64, 64], 'activation': ['relu', 'relu', 'linear']}, 'output_embedding': 'graph', 'output_to_tensor': True, 'output_tensor_type': 'padded', 'output_mlp': {'units': 1, 'activation': 'linear'}}'.\n" + "INFO:kgcnn.models.utils:Updated model kwargs: '{'name': 'GINE', 'inputs': [{'shape': (None, 41), 'name': 'node_attributes', 'dtype': 'float32'}, {'shape': (None, 11), 'name': 'edge_attributes', 'dtype': 'float32'}, {'shape': (None, 2), 'name': 'edge_indices', 'dtype': 'int64'}, {'shape': (), 'name': 'total_nodes', 'dtype': 'int64'}, {'shape': (), 'name': 'total_edges', 'dtype': 'int64'}], 'input_tensor_type': 'padded', 'cast_disjoint_kwargs': {}, 'input_embedding': None, 'input_node_embedding': {'input_dim': 95, 'output_dim': 64}, 'input_edge_embedding': {'input_dim': 10, 'output_dim': 64}, 'gin_mlp': {'units': [64, 64], 'use_bias': True, 'activation': ['relu', 'linear'], 'use_normalization': True, 'normalization_technique': 'graph_batch'}, 'gin_args': {'epsilon_learnable': False}, 'depth': 3, 'dropout': 0.0, 'verbose': 10, 'last_mlp': {'use_bias': [True, True, True], 'units': [64, 64, 64], 'activation': ['relu', 'relu', 'linear']}, 'output_embedding': 'graph', 'output_to_tensor': None, 'output_scaling': None, 'output_tensor_type': 'padded', 'output_mlp': {'units': 1, 'activation': 'linear'}}'.\n" ] } ], @@ -150,7 +150,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAioAAAHHCAYAAACRAnNyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABO1klEQVR4nO3dd3hUVf4G8PdOTe+dVBJIAiFINyCCgAIiimCBRTeyKqLows91XdFVKauw6rrqukZZXbCgiK4gIoh0ROkQIJQQSgqkEUJ6Mu2e3x9JRmIqKXMn4f08z+zD3Lkz882Vh7x7zvecKwkhBIiIiIjskErpAoiIiIgaw6BCREREdotBhYiIiOwWgwoRERHZLQYVIiIislsMKkRERGS3GFSIiIjIbjGoEBERkd1iUCEiIiK7xaBC1MU99NBDCA8Pb9V758+fD0mS2reg69jrr7+O7t27Q61W44YbblC6HKJOgUGFSGHZ2dmYP38+kpOTlS6FOtCPP/6IZ599FsOGDcOyZcvw6quvKl0SUacg8V4/RMo6cOAABg0ahGXLluGhhx5q9883mUyQZRl6vf6a32s2m2E2m+Hg4NDudV1vnnvuObz++uuorKyETqdTuhyiToMjKkSdTEVFxTWdr9VqWxVSAECj0XTZkGI2m2E0Gm32ffn5+XB0dGy3kCKEQGVlZbt8FpE9Y1AhUtD27dsxaNAgAMCMGTMgSRIkScLy5csBACNHjkRcXBwOHjyIm2++GU5OTnj++ecBAN9++y0mTJiAoKAg6PV6REZGYtGiRbBYLHW+47c9Kunp6ZAkCW+88QaWLl2KyMhI6PV6DBo0CPv376/z3oZ6VCRJwpNPPok1a9YgLi4Oer0evXv3xg8//NDgzzdw4EA4ODggMjISH3zwwTX1vezduxe33347PD094ezsjPj4eLz99tvW10eOHImRI0fWe19TP/Nbb71l/ZkPHz4MjUaDBQsW1PuM1NRUSJKEd99913qsqKgIc+fORUhICPR6PaKiovD3v/8dsiw3+XNIkoRly5ahvLy83n9js9mMRYsWWWsKDw/H888/D4PBUOczwsPDcccdd2Djxo0YOHAgHB0d8cEHH7TgKhJ1bhqlCyC6nsXGxmLhwoV46aWXMHPmTAwfPhwAMHToUOs5ly9fxvjx4zF16lQ88MAD8Pf3BwAsX74cLi4uePrpp+Hi4oKtW7fipZdeQklJCV5//fVmv/vzzz9HaWkpHnvsMUiShNdeew2TJ0/GuXPnoNVqm3zvrl278M033+CJJ56Aq6sr3nnnHUyZMgWZmZnw9vYGABw+fBjjxo1DYGAgFixYAIvFgoULF8LX17dF12bTpk244447EBgYiDlz5iAgIAAnT57EunXrMGfOnBZ9xm8tW7YMVVVVmDlzJvR6PQIDAzFixAisWrUKL7/8cp1zv/zyS6jVatx7770AqkeyRowYgYsXL+Kxxx5DaGgofvnlF8ybNw85OTl46623Gv3eTz/9FEuXLsW+ffvw4YcfAvj1v/EjjzyCjz/+GPfccw/+9Kc/Ye/evVi8eDFOnjyJ1atX1/mc1NRUTJs2DY899hgeffRRREdHt+o6EHUqgogUtX//fgFALFu2rN5rI0aMEADE+++/X++1ioqKescee+wx4eTkJKqqqqzHEhMTRVhYmPX5+fPnBQDh7e0tCgsLrce//fZbAUB899131mMvv/yy+O0/EwCETqcTZ86csR47cuSIACD+9a9/WY9NnDhRODk5iYsXL1qPpaWlCY1GU+8zf8tsNouIiAgRFhYmrly5Uuc1WZatfx4xYoQYMWJEvfc39jO7ubmJ/Pz8Oud+8MEHAoA4duxYneO9evUSo0aNsj5ftGiRcHZ2FqdPn65z3nPPPSfUarXIzMxs8mdKTEwUzs7OdY4lJycLAOKRRx6pc/yZZ54RAMTWrVutx8LCwgQA8cMPPzT5PURdDad+iOycXq/HjBkz6h13dHS0/rm0tBQFBQUYPnw4KioqcOrUqWY/9/7774enp6f1ee1ozrlz55p975gxYxAZGWl9Hh8fDzc3N+t7LRYLNm/ejEmTJiEoKMh6XlRUFMaPH9/s5x8+fBjnz5/H3Llz4eHhUee1tiyXnjJlSr0RncmTJ0Oj0eDLL7+0HktJScGJEydw//33W4999dVXGD58ODw9PVFQUGB9jBkzBhaLBTt37rzmetavXw8AePrpp+sc/9Of/gQA+P777+scj4iIwNixY6/5e4g6M079ENm5bt26NdiAefz4cfz1r3/F1q1bUVJSUue14uLiZj83NDS0zvPa0HLlypVrfm/t+2vfm5+fj8rKSkRFRdU7r6Fjv3X27FkAQFxcXLPnXouIiIh6x3x8fDB69GisWrUKixYtAlA97aPRaDB58mTreWlpaTh69GijU1f5+fnXXE9GRgZUKlW9axIQEAAPDw9kZGQ0Wz9RV8egQmTnrh45qVVUVIQRI0bAzc0NCxcuRGRkJBwcHHDo0CH85S9/aba5EwDUanWDx0ULdixoy3vbkyRJDX7nbxuKazV0LQFg6tSpmDFjBpKTk3HDDTdg1apVGD16NHx8fKznyLKMW2+9Fc8++2yDn9GzZ89W/ATVWjpK1Fj9RF0ZgwqRwlozlbF9+3ZcvnwZ33zzDW6++Wbr8fPnz7dnaa3m5+cHBwcHnDlzpt5rDR37rdpppZSUFIwZM6bR8zw9PRucqvrtSERzJk2ahMcee8w6/XP69GnMmzevXk1lZWVN1nOtwsLCIMsy0tLSEBsbaz2el5eHoqIihIWFtdt3EXVW7FEhUpizszOA6lGSlqod0bh6NMFoNOK9995r19paS61WY8yYMVizZg2ys7Otx8+cOYMNGzY0+/7+/fsjIiICb731Vr3rcvXPHBkZiVOnTuHSpUvWY0eOHMHPP/98TfV6eHhg7NixWLVqFVauXAmdTodJkybVOee+++7D7t27sXHjxnrvLyoqgtlsvqbvBIDbb78dAOqtGHrzzTcBABMmTLjmzyTqajiiQqSwyMhIeHh44P3334erqyucnZ0xZMiQJvsRhg4dCk9PTyQmJuKPf/wjJEnCp59+avOpl6bMnz8fP/74I4YNG4bHH38cFosF7777LuLi4pq9XYBKpUJSUhImTpyIG264ATNmzEBgYCBOnTqF48ePW8PCH/7wB7z55psYO3YsHn74YeTn5+P9999H79696/XtNOf+++/HAw88gPfeew9jx46t18T75z//GWvXrsUdd9yBhx56CAMGDEB5eTmOHTuGr7/+Gunp6XWmilqib9++SExMxNKlS63Tefv27cPHH3+MSZMm4ZZbbrmmzyPqijiiQqQwrVaLjz/+GGq1GrNmzcK0adOwY8eOJt/j7e2NdevWITAwEH/961/xxhtv4NZbb8Vrr71mo6qbN2DAAGzYsAGenp548cUX8dFHH2HhwoUYPXp0i3a7HTt2LLZt24aePXviH//4B55++mls2bIFEydOtJ4TGxuLTz75BMXFxXj66aexdu1afPrpp+jfv/8113vnnXfC0dERpaWldVb71HJycsKOHTvw5z//Gdu3b8ecOXOwZMkSpKWlYcGCBXB3d7/m7wSADz/8EAsWLMD+/fsxd+5cbN26FfPmzcPKlStb9XlEXQ3v9UNENjVp0iQcP34caWlpSpdCRJ0AR1SIqMP89l40aWlpWL9+fYPb3hMRNYQjKkTUYQIDA/HQQw+he/fuyMjIQFJSEgwGAw4fPowePXooXR4RdQJspiWiDjNu3Dh88cUXyM3NhV6vR0JCAl599VWGFCJqMY6oEBERkd1ijwoRERHZLQYVIiIisludukdFlmVkZ2fD1dW1TXdUJSIiItsRQqC0tBRBQUFQqZoeM+nUQSU7OxshISFKl0FEREStkJWVheDg4CbP6dRBxdXVFUD1D+rm5qZwNURERNQSJSUlCAkJsf4eb0qnDiq10z1ubm4MKkRERJ1MS9o22ExLREREdotBhYiIiOxWp576ISIi6gyEEDCbzbBYLEqXYlNarRZqtbpNn8GgQkRE1IGMRiNycnJQUVGhdCk2J0kSgoOD4eLi0urPYFAhIiLqILIs4/z581Cr1QgKCoJOp7tu9v0SQuDSpUu4cOECevTo0eqRFQYVIiKiDmI0GiHLMkJCQuDk5KR0OTbn6+uL9PR0mEymVgcVNtMSERF1sOZ2X+2q2mP06Pq8ckRERNQpMKgQERFdh8LDw7Fr1y6ly2gWgwoRERHZLQYVIiIislsMKkRERDYihECVydLhDyFEi2uqqqrC7NmzERAQgNDQUCxcuBCyLAMA9uzZg379+sHNzQ3dunXDP//5zyaPdwQuT25AlcmC4koT1CoJPi56pcshIqIuwmCWcfvbP3X496yfMxwO2pYtB160aBGOHz+OkydPorS0FGPGjEFoaCgeeughzJ07F8888wymT5+OK1euID09HQAaPd4ROKLSgF1pBZi6dA/+9v0JpUshIiLqUCtXrsTLL78MT09PhIaG4k9/+hO++OILANVb4J85cwaFhYXw9PREv379mjzeETii0gCNWoLRIqOo3KR0KURE1IXoNSqsnzPcJt/TUtnZ2QgNDbU+DwsLQ3Z2NgDgww8/xIsvvoioqCj06tULr7/+OhISEho93hEYVBqgU6sAAZjlls/xERERNUeSpBZPydhKUFAQMjMzERkZCQDIzMxEUFAQACA6OhqrVq2C2WzG+++/j2nTpiE9Pb3R4x2BUz8N0KirL4uFQYWIiLq4+++/H4sWLcKVK1eQlZWFN998E1OnTgUArFixApcvX4ZGo4Grq6t1G/zGjncEBpUGaNQSJAkwWWSlSyEiIupQL774IqKjoxETE4OEhARMnToViYmJAID169cjOjoarq6ueOedd/DJJ580ebwjcOqnAdqaezJw6oeIiLqqq6dqkpKSkJSUVO+cFStWNPjexo53BI6oNECrqb6JkkUW17QWnYiIiNoXg0oDNCoVJFSPqLBPhYiISDkMKg3QqqtHVMwWGcwpREREylE0qMyfPx+SJNV5xMTEKFkSgJpVP1L11I/MqR8iIiLFKN5M27t3b2zevNn6XKNRvCRo1RIkSDAzqBARUTuovXfO9aY9+jwVTwUajQYBAQFKl1FH7aofiyxg5hJlIiJqJZ1OB5VKhezsbPj6+kKn00GSJKXLsgkhBC5dugRJkqDValv9OYoHlbS0NAQFBcHBwQEJCQlYvHhxna18laBR//qXyGjhiAoREbWOSqVCREQEcnJyrNvSX08kSUJwcHCbNoRTNKgMGTIEy5cvR3R0NHJycrBgwQIMHz4cKSkpcHV1rXe+wWCAwWCwPi8pKemQurTq6lU/AGA0c0SFiIhaT6fTITQ0FGazGRaLRelybEqr1bZ511pFg8r48eOtf46Pj8eQIUMQFhaGVatW4eGHH653/uLFi7FgwYIOr0tb00wLMKgQEVHb1U5/tGUK5HplV8uTPTw80LNnT5w5c6bB1+fNm4fi4mLrIysrq0PqUKskqGrmEA3m6yv9EhER2RO7CiplZWU4e/YsAgMDG3xdr9fDzc2tzqOj1PapmNijQkREpBhFg8ozzzyDHTt2ID09Hb/88gvuvvtuqNVqTJs2TcmyAAC6mjsoc0SFiIhIOYr2qFy4cAHTpk3D5cuX4evri5tuugl79uyBr6+vkmUB+HVEhT0qREREylE0qKxcuVLJr29S7V4qRjOnfoiIiJRiVz0q9kRbM/VjvM6WkhEREdkTBpVG6DS1QYVTP0REREphUGlE7R2UTexRISIiUgyDSiM07FEhIiJSHINKI37dR4UjKkREREphUGmETs0eFSIiIqUxqDSidkTFzJ1piYiIFMOg0oja5clmmUGFiIhIKQwqjbAGFU79EBERKYZBpRG1y5MtHFEhIiJSDINKIzSc+iEiIlIcg0ojtKqaZloGFSIiIsUwqDSidkTFIrNHhYiISCkMKo34tZmWIypERERKYVBphPVeP5z6ISIiUgyDSiM0NT0qFi5PJiIiUgyDSiO46oeIiEh5DCqN0FmbaRlUiIiIlMKg0gjrvX4YVIiIiBTDoNIITv0QEREpj0GlETo1m2mJiIiUxqDSCI2KIypERERKY1BphFbDoEJERKQ0BpVG8F4/REREymNQaUTtiArv9UNERKQcBpVGaFQSJIn3+iEiIlISg0ojtFyeTEREpDgGlUbUbvhmkQVkhhUiIiJFMKg0QqtWQQJgtsiQBYMKERGREhhUGqG9ah8VC4MKERGRIhhUGqFRS4AkwSwLMKcQEREpg0GlERq1VD31IwveQZmIiEghDCqN0NWs+pFlwb1UiIiIFMKg0ojauycDgNHMERUiIiIlMKg0QqOqnvoBAKOZIypERERKYFBphFatQm1SMVgsyhZDRER0nWJQaYRaJUEtVScVjqgQEREpg0GlCbW70xoYVIiIiBTBoNKE2vv9mBhUiIiIFMGg0gSOqBARESmLQaUJtXupmCxcnkxERKQEBpUm1E79GMxc9UNERKQEBpUmWHtULJz6ISIiUgKDShO0ai5PJiIiUhKDShO07FEhIiJSFINKE2rv98MRFSIiImUwqDRBq6qe+mGPChERkTIYVJpgnfqROfVDRESkBAaVJtRu+GZhUCEiIlIEg0oTakdUzJz6ISIiUgSDShNqlyebOaJCRESkCAaVJtSOqHDqh4iISBkMKk2oXZ7MERUiIiJlMKg0oXZ5MntUiIiIlMGg0gQNp36IiIgUxaDShNpmWu6jQkREpAwGlSZYm2k59UNERKQIBpUmaLg8mYiISFEMKk3Qqrjqh4iISEkMKk3QariFPhERkZLsJqgsWbIEkiRh7ty5SpdipakZUeHdk4mIiJRhF0Fl//79+OCDDxAfH690KXVoeVNCIiIiRSkeVMrKyjB9+nT85z//gaenp9Ll1KFhjwoREZGiFA8qs2fPxoQJEzBmzJhmzzUYDCgpKanz6EhaDTd8IyIiUpJGyS9fuXIlDh06hP3797fo/MWLF2PBggUdXNWvuIU+ERGRshQbUcnKysKcOXOwYsUKODg4tOg98+bNQ3FxsfWRlZXVoTVqNSpA4tQPERGRUhQbUTl48CDy8/PRv39/6zGLxYKdO3fi3XffhcFggFqtrvMevV4PvV5vsxo1KgkSOPVDRESkFMWCyujRo3Hs2LE6x2bMmIGYmBj85S9/qRdSlFC7hT5HVIiIiJShWFBxdXVFXFxcnWPOzs7w9vaud1wp1qBikSHLAqqanhUiIiKyDcVX/dgzjfrXqR+L4KgKERGRrSm66ue3tm/frnQJdehqRlRMsoDMoEJERGRzHFFpgkYtAZIEiywgc4UyERGRzTGoNEGjUkFCTY8KR1SIiIhsjkGlCbX3+pEFb0xIRESkBAaVJtSu+gEAs4UjKkRERLbGoNKE2lU/AGAwc0SFiIjI1hhUmqBRVW+hDwAGs0XZYoiIiK5DDCpNUKskqKXqpGLkiAoREZHNMag0Q6upvkRGNtMSERHZHINKM7QqjqgQEREphUGlGZqalT9spiUiIrI9BpVm1O6lwn1UiIiIbI9BpRm62h4VjqgQERHZHINKM2o3fWNQISIisj0GlWZoVDV3UObUDxERkc0xqDSjtkeFy5OJiIhsj0GlGbVTPyYz7/VDRERkawwqzdBwRIWIiEgxDCrN0Nb0qJgZVIiIiGyOQaUZtSMqZplTP0RERLbGoNKM2h4VC4MKERGRzTGoNKN21Y/ZwqBCRERkawwqzagdUeHUDxERke0xqDTj16kfNtMSERHZGoNKM7RspiUiIlIMg0ozNJz6ISIiUgyDSjM0Ko6oEBERKYVBpRk6TU2PCjd8IyIisjkGlWbU3j2ZIypERES2x6DSjNqdaU3cR4WIiMjmGFSaUbvqh8uTiYiIbI9BpRnc8I2IiEg5DCrNqO1R4b1+iIiIbI9BpRm81w8REZFyGFSawQ3fiIiIlMOg0gw20xIRESmHQaUZWrUKkDiiQkREpAQGlWZo1SpIYFAhIiJSAoNKM2rv9cNVP0RERLbHoNIMnaZmRMUiQ2ZYISIisikGlWZcffdki2BQISIisiUGlWZcvTOtzKBCRERkUwwqzdCoJUCSYJEFuEKZiIjIthhUmmFd9WOROaJCRERkYwwqzdDW3OtHFoDJwiEVIiIiW2JQaYamZmdaADCZOaJCRERkSwwqzaid+gEAg8WiaC1ERETXGwaVZmhUEmqTitHMqR8iIiJbYlBphkolQS1VJxWDiSMqREREtsSg0gJaTfVlMrKZloiIyKYYVFpAW7M7rdHCZloiIiJbYlBpAeuICntUiIiIbIpBpQVqt9E3mtmjQkREZEsMKi2grdlLhSMqREREtsWg0gK6mhEVE3tUiIiIbIpBpQU01qDCERUiIiJbYlBpgdqpHwODChERkU0xqLSARsVVP0REREpgUGmB2lU/ZvaoEBER2RSDSgvUTv2YOfVDRERkUwwqLaCpDSoyR1SIiIhsSdGgkpSUhPj4eLi5ucHNzQ0JCQnYsGGDkiU1qLZHhUGFiIjIthQNKsHBwViyZAkOHjyIAwcOYNSoUbjrrrtw/PhxJcuqR1ezhb6FPSpEREQ2pVHyyydOnFjn+SuvvIKkpCTs2bMHvXv3Vqiq+jQ1NyU0yexRISIisiVFg8rVLBYLvvrqK5SXlyMhIaHBcwwGAwwGg/V5SUmJTWqrXfVj4dQPERGRTSneTHvs2DG4uLhAr9dj1qxZWL16NXr16tXguYsXL4a7u7v1ERISYpMatWymJSIiUoTiQSU6OhrJycnYu3cvHn/8cSQmJuLEiRMNnjtv3jwUFxdbH1lZWTapkSMqREREymjV1E9WVhYkSUJwcDAAYN++ffj888/Rq1cvzJw585o+S6fTISoqCgAwYMAA7N+/H2+//TY++OCDeufq9Xro9frWlNwmGuuGb+xRISIisqVWjaj87ne/w7Zt2wAAubm5uPXWW7Fv3z688MILWLhwYZsKkmW5Th+KPeDUDxERkTJaFVRSUlIwePBgAMCqVasQFxeHX375BStWrMDy5ctb/Dnz5s3Dzp07kZ6ejmPHjmHevHnYvn07pk+f3pqyOkztPiqc+iEiIrKtVk39mEwm6xTM5s2bceeddwIAYmJikJOT0+LPyc/Px+9//3vk5OTA3d0d8fHx2LhxI2699dbWlNVhakdUTNxHhYiIyKZaFVR69+6N999/HxMmTMCmTZuwaNEiAEB2dja8vb1b/DkfffRRa77e5qw3JeQ+KkRERDbVqqmfv//97/jggw8wcuRITJs2DX379gUArF271jol1JXU3uuHUz9ERES21aoRlZEjR6KgoAAlJSXw9PS0Hp85cyacnJzarTh78euICoMKERGRLbVqRKWyshIGg8EaUjIyMvDWW28hNTUVfn5+7VqgPajtUeG9foiIiGyrVUHlrrvuwieffAIAKCoqwpAhQ/CPf/wDkyZNQlJSUrsWaA9+vXsye1SIiIhsqVVB5dChQxg+fDgA4Ouvv4a/vz8yMjLwySef4J133mnXAu2BhvuoEBERKaJVQaWiogKurq4AgB9//BGTJ0+GSqXCjTfeiIyMjHYt0B7o1CpAYjMtERGRrbUqqERFRWHNmjXIysrCxo0bcdtttwGo3hfFzc2tXQu0Bxq1ChI4okJERGRrrQoqL730Ep555hmEh4dj8ODBSEhIAFA9utKvX792LdAeaFQ1Uz8WGUIwrBAREdlKq5Yn33PPPbjpppuQk5Nj3UMFAEaPHo2777673YqzFzrNryMqsgBqWlaIiIiog7UqqABAQEAAAgICcOHCBQBAcHBwl9zsDfh1HxWLLCALATWYVIiIiGyhVVM/sixj4cKFcHd3R1hYGMLCwuDh4YFFixZB7oJLeK1TP7JgQy0REZENtWpE5YUXXsBHH32EJUuWYNiwYQCAXbt2Yf78+aiqqsIrr7zSrkUqTatWAZJU06OidDVERETXj1YFlY8//hgffvih9a7JABAfH49u3brhiSee6HJBRaOWIKF66sfCpEJERGQzrZr6KSwsRExMTL3jMTExKCwsbHNR9qa2R0UWgMnS9aa2iIiI7FWrgkrfvn3x7rvv1jv+7rvvIj4+vs1F2RvtVct8jGaLgpUQERFdX1o19fPaa69hwoQJ2Lx5s3UPld27dyMrKwvr169v1wLtgUalsq7zMZo59UNERGQrrRpRGTFiBE6fPo27774bRUVFKCoqwuTJk3H8+HF8+umn7V2j4jQqCbVJxWDm1A8REZGttHoflaCgoHpNs0eOHMFHH32EpUuXtrkwe6JSSdCoJJgtAiZO/RAREdlMq0ZUrkeamoZaA5tpiYiIbIZBpYW0NZu+GS3sUSEiIrIVBpUW0mqqL5XJxBEVIiIiW7mmHpXJkyc3+XpRUVFbarFrupqpH6OFPSpERES2ck1Bxd3dvdnXf//737epIHtVu+kbV/0QERHZzjUFlWXLlnVUHXavdtM3E3tUiIiIbIY9Ki1UO6JSYTQrXAkREdH1g0GlhcK8nQAA3xy6CAP3UiEiIrIJBpUWmjUiEi4OGly4Uok3fzytdDlERETXBQaVFvJ20WP+xF4AgHVHc7A9NV/hioiIiLo+BpVrkBDpg3sHBgMAFq8/hUulVQpXRERE1LUxqFyjJ0ZGIdLXGWUGM5775hgsMlcBERERdRQGlWuk06jwt0l9oNOocCqnFMt+Pq90SURERF0Wg0orhHo74ekxPQEA/zt0EbLMTeCIiIg6AoNKK93a2x9atYSSShPSL1coXQ4REVGXxKDSSg5aNbr7ugAADmZcUbgaIiKirolBpQ16BboBAE7mlChcCRERUdfEoNIGMYGuAMCpHyIiog7CoNIGMQGugARkXC6HmXdVJiIiancMKm0Q7u0MR60aVSYZJ3NLlS6HiIioy2FQaQONWoVo/+rpn0OZhQpXQ0RE1PUwqLRRbE2fSlpemcKVEBERdT0MKm0UE1C98uc8G2qJiIjaHYNKG8UEukKSgAuFFag0mpUuh4iIqEthUGmjbh6OcHPQwiwLJF8oUrocIiKiLoVBpY0kSUKvoOrpn+TMImWLISIi6mIYVNpBbM0OteculStcCRERUdfCoNIOYgKqV/6cL2BQISIiak8MKu0gJsAVKgnILanClXKj0uUQERF1GQwq7cDbRQ9fVz2EAA5m8k7KRERE7YVBpZ3EdXMHABzlyh8iIqJ2w6DSTqJr+lTSC7jxGxERUXthUGkntTvUpl9mQy0REVF7YVBpJz39XaBSAZfLjLh4haMqRERE7YFBpZ24OmgR5uUMADiYwYZaIiKi9sCg0o5qd6g9nl2icCVERERdA4NKO4r2r2mo5Z2UiYiI2gWDSjuqXfmTcbkcsiwrXA0REVHnx6DSjqL8XKBVSyitMuMst9MnIiJqMwaVduSgVSPSzwUAcCijSNliiIiIugAGlXbWq+ZOyqdy2FBLRETUVooGlcWLF2PQoEFwdXWFn58fJk2ahNTUVCVLarNf+1TYUEtERNRWigaVHTt2YPbs2dizZw82bdoEk8mE2267DeXlnbe/IybAFZIEZBSWw2xmQy0REVFbaJT88h9++KHO8+XLl8PPzw8HDx7EzTffrFBVbRPu7QwHrRqVRgtO5ZYiLthd6ZKIiIg6LbvqUSkuLgYAeHl5KVxJ62nUKut+KoeyuEMtERFRWyg6onI1WZYxd+5cDBs2DHFxcQ2eYzAYYDAYrM9LSuyzYTU20BXJWUU4nVemdClERESdmt2MqMyePRspKSlYuXJlo+csXrwY7u7u1kdISIgNK2y52jspZ/BOykRERG1iF0HlySefxLp167Bt2zYEBwc3et68efNQXFxsfWRlZdmwypaLrmmozSqsQJXRrHQ5REREnZaiUz9CCDz11FNYvXo1tm/fjoiIiCbP1+v10Ov1Nqqu9bp5OMLVQYOSSjOOXizB4IjO23NDRESkJEVHVGbPno3PPvsMn3/+OVxdXZGbm4vc3FxUVlYqWVabqVSSdeO3ZDbUEhERtZqiQSUpKQnFxcUYOXIkAgMDrY8vv/xSybLaRW2fytl89qkQERG1luJTP11V7Q616WyoJSIiajW7aKbtimICXKGSgOyiSpRWmpQuh4iIqFNiUOkgvq56eLvoIQvgUGaR0uUQERF1SgwqHUSSJPQKrJ7+OXKBDbVEREStwaDSgWJqVv6cL+CdlImIiFqDQaUD1d7z53wBG2qJiIhag0GlA8UGuUGnUeFSqQF7zhYoXQ4REVGnw6DSgdwctJjQJxAA8NGudGWLISIi6oQYVDrY9BtDoZKAEzkl3KWWiIjoGjGodLBAd0eMjQsAACzdeV7haoiIiDoXBhUbePDGMADAkawinMotUbgaIiKizoNBxQbCvJ0xKsYXAPD+9rMKV0NERNR5MKjYyO8TwgEABzKu4PwlLlcmIiJqCQYVG+nh74phUd4QAkjacUbpcoiIiDoFBhUbqh1V2X32Mi5c4W61REREzWFQsaG4bu4YEOYJWQD/2spRFSIiouYwqNjYzJu7AwB2pRXgRE5xg+fIskDKxWJUmSy2LI2IiMjuMKjYWFw3d4yK8QMAvLHxNIQQ9c55b/sZzF5xCO9y1IWIiK5zDCoKeOKWSKhVElJzS7HlVH6d17al5uPrgxdglgX2pxcqVCEREZF9YFBRQKC7I343OAQA8N62MzBbZABAVmEFXv8hFSZL9SjLxaJKFFcaFauTiIhIaQwqCnkgIRzujlrklRiwYm8GqkwWvLz2OIorTejh7wIvZy2EAPan8/5ARER0/WJQUYiLXoPHahprP9uTidd+OIW0vFK4OWgwa0R39A/1BAAkZxYpWCUREZGyGFQUdEffIET4OKPCaMHG43kQAB4Z3h03dvdBbKAbACD9MnexJSKi6xeDioLUKglzxvSwPr+zbxAm9g0CAMTUBJXzBQwqRER0/dIoXcD1blC4Fx6+KQLZRZV4+KYI6DTV2THa3xUatYSiChPSC8oQ7uOicKVERES2x6BiB/5wU0S9Y446Nbr7OON0XhkOpF9hUCEiousSp37sWO8gdwDAiZwShSshIiJSBoOKHYtlnwoREV3nGFTsWGygKyQJyLhcAaNZVrocIiIim2NQsWNh3s5w1qlhMMs4nt3wDQyJiIi6MgYVO6ZWSdbpn4MZdXeoLaky4a3Np5GcVaRAZURERLbBoGLnegVVB5W0vLI6x5O2n8X/Dl7Awu+ON3gHZiIioq6AQcXONdRQm3KxGBuO5UAWQF6JASkXOS1ERERdE4OKnYsNdINKArKLK1FUYYRFFnh7SxpMFgFJqj7nu6PZyhZJRETUQRhU7JyPix5+bg4QAjiQfgVrj1xEam4pHHVq/G5wCADgQHoRp3+IiKhLYlDpBPp0q9747ae0Avx313lYZIFJN3TDgwnh0GlUyCup4qogIiLqkhhUOoGYAFcAwOaTebhSYUKolxPuHRgMVwctErp7AQC+O5KjZIlEREQdgkGlE6htqAUAIYD7B4XA380BAHBLjD8AYH/6FU7/EBFRl8Og0glEB1TfSRkAhkZ6Y1xcgPW1hEhvTv8QEVGXxaDSCTho1ZjQJxAhXo6YNjgUDlq19TUXvYbTP0RE1GVplC6AWubZcTEwWWRo1fWz5S0x/thxugAHfrN7LRERUWfHEZVOpKGQAvw6/ZNbXIWUi0W2LYqIiKgDMah0AZz+ISKiropBpYsYGe0HAJz+ISKiLoVBpYsYGuVjnf758KdzMJgtSpdERETUZgwqXYSLXoM74gMBAMt+Tse0pXuwLTWfe6sQEVGnxqDShfzfmJ7402094eGkRV6JAX9dnYJZnx1CWl6p0qURERG1CoNKF6JSSZjcPxj/e3wo7h8UAp1GhZSLxXj0kwPYefqS0uURERFdMwaVLshBq8YfR/fAlzNvRJ9gd5gsAs+vPoZvDl5QujQiIqJrwqDShfm5OeDfv+uP23r7QwjgH5tOI2n7GfatEBFRp8Gdabs4tUrCS3f0gr+bAz7dnYHP9mQip6gK9wwMRriPM9wctEqXSERE1ChJdOL/e11SUgJ3d3cUFxfDzc2t+Tdc5749fBFv/JgKuea/uEoFeDvrEenrjFt7+WNcXKCyBRIR0XXhWn5/c0TlOnJXv24I9HDARz+dR3ZxFQrLjbhUasClUgP2nCtElcmCSf2ClS6TiIjIikHlOjM4whuDI7wBAAVlVTh+sQSbTuZh26lL+MePp+Hv5oCESJ9676s0WmARAi56/pUhIiLbYTPtdczHxQEjov2w6K44jI7xgyyAF9akIC33131XzBYZX+7PxOSkn/G7/+xBUYVRwYqJiOh6w6BCkCQJf72jF/p0c4fBJGPuqmTkl1bh2IVizPz0IP697SxKKs24XGbEO1vPKF0uERFdRxhUCACg06jw+r3x6ObpiKIKE37/0T489cUhpOaWwlGrxuiY6psebj6RhwuFFQ1+xi9nC7D68AXIcqftzyYiIjvDoEJWrg5avDO1H9wcNCitMsNkEbiphw9euzce8+/shQFhnrDIAv/cfLree5OzivDimhS8sfE0Vh3MUqB6IiLqihhUqI4Adwe898AAjOjpi2fHRmPBnb3RN9gDKpUKs2+JAgDsOVeIEznF1vdcKjVg4XfHUWWSAQBLd55DTlGlIvUTEVHXwqBC9UT4OOPVyX1wV79ucNCqrcejA1wxJrZ6CuitTWkAAJNFxoLvjiOvxIBgT0d093WGwSTjpbXHuQMuERG1GYMKXZNHb+4OlQQczy7B7rMFeH/7WRy9UAxHrRozb+6OV+/uA61awonsEnxz6GK7fKcQAuuOZmP32cvt8nlERNR5KBpUdu7ciYkTJyIoKAiSJGHNmjVKlkMtEOzphLv7dwMALPzuBP536AIsssCMYeEYFeOHEC8nzLw5EgCQtP0s8kuqrO/NKqzAaz+cwtyVh3E6r7TBz2/IDym5eGNjKp79+gjO5Lf8fURE1PkpGlTKy8vRt29f/Pvf/1ayDLpGDw2NgF6rQklNw+3tfQIwZUAwJEkCANw/KAQxAa6oNFnw8trjOJ1Xivlrj+P3/92Hb5OzsT/9Ch75+AC+PpjV7PRQfmkV/r3tDEwWAVkAr64/xSklIqLriKJBZfz48fjb3/6Gu+++W8ky6Bp5OeuQmBAOAOgV6IZHh3ev08uiVkl48Y5eUKskHL1QjEc+PoBNJ/JgNMuID3ZHfLB79eqhTWl4fnUKygzmBr9HCIE3NqbiSoUJ3TwcoVFJSM0txfpjObb4MYmIyA50qv3QDQYDDAaD9XlJSYmC1VzfHrwxDN19nNHd1xl+bg71Xg/3ccajwyPw/o5zkIXAoHAvjI8LwIhoX+g1KqzYk4kPfjqHnacvITW3BK/c3QexgXVvTLUhJRd7zxdCo5Lw6PDuuFBUgQ9/Oo9/bzuLW2L84KTrVH99iYioFTrVv/SLFy/GggULlC6DAKhUEob39G3ynAduDEOguwP0GjWGdPeGTvPrAN4DCWG4IdQd875JQV6JAY98fAAT+wbisZsj4emsQ15JFd7bdgZmi8Dk/t0wKtYPJouM74/mIKe4Cv/acgZ/GR/T0T8mEREpTBJ2MuEvSRJWr16NSZMmNXpOQyMqISEhLbpNNNmn0ioTFq07gZ/PVK/ocdKp8djN3bEvvRA/n7mM7r7OeOPevvCvGbXZffYynvnqCFQSsGzGIET5uSpZPhERtUJJSQnc3d1b9Pu7Uy1P1uv1cHNzq/Ogzs3VQYvX7umLd6bdgFAvJ1QYLfjn5jT8cvYytGoJiQnh1pACAAmR3hgW5VPdWPs9G2uJiLq6ThVUqOsaEOaFzx4ZgidHRcFFr4EQwKQbuuGWmnsMXe3/bu0BrVpCal4p1iRnK1AtERHZiqI9KmVlZThz5te78Z4/fx7Jycnw8vJCaGiogpWREtQqCdMGh+KO+EAczixCv1APqFVSvfMC3R3x8E3VjbrvbElD32B3dPd1UaBiIiLqaIr2qGzfvh233HJLveOJiYlYvnx5s++/ljku6losssCclYdxOLMI/m4O+OyRwVwFRETUSVzL72+7aaZtDQaV69uVciMe/O9eXCk3YWikN167J9666RwREdmvLttMS3Q1T2cdlkyOh0oCfjl7GZ/vy1S6JCIiamcMKtSpxXVzx5OjogAA7+84h4PphagwmlFlssBskZtcFVRhNON8QTkOZV5pdHdcIiJSFif1qdO7b2AIkrOKsfP0JfxxZTLUKgnWCSAJcNCo4aRXw0WvgZNODYsM5JVUobTKBFkAshBwddDg0eHdcWffIGjUzO9ERPaCPSrUJZQbzJiz8jBO5lzb3ZUddWpo1SqUVJoAAGHeTpg7picGR3g1+33nC8rRK9ANqgZWJhERUePYTEvXJSEESqtMqDRZYJYBs0WG0SyjwmhBSZUJZVVmlBnMsMgCgR4OCPV0ho+rDnqNGl8eyMSnuzNQbrAAAG7s7oXnb4+Ft4u+3vfkFFfi2a+PIr2gHOPiAjBvfCzDChHRNWBQIWqFkkoj3t16FhuO50KWBdwdtfj7lHj0CXa3nnPuUhme/foocoqrrMfGxQXghdsZVoiIWoqrfohawc1Rh+cnxOLjGYMQ6O6A4koTnlhxEKsOZEEIgWMXijF3ZTJyiqsQ6O6A+wYGQ5KAH1Jysej7E5DlTpv5iYjsFkdUiBpQZbJg/trj+CmtAAAwKNwLp3JLUFplRndfZ/x5bDTigz3wQ0oO/vb9SQgB3NbbHy9O6NXkyMqutAJcqTBiULgXAtwdGj2PiKgr49QPUTsQQmDF3kx8sOMsagdL4oLc8Oy4aEReddfmjTUjKkIAI6N98cKE2Hq75Fpkgfd3nMVXB7JgsghIEhDu7YyESG8MjvBCkIcjPJ20cNSquWkdEXV5DCpE7Sg58woWbziF7j7OeGp0FII8nOqd8+PxXCxadwKyAALc9FhwVxziulX3tlQaLVj0/QnsSiuARRYI9XLChSsVuHqmSCUBkiRBr1HB01kHd0ctnHRqOOnUcNRq4OaoweR+wQj1rv/dRESdDYMKUQeQZdHktM6B9EIs+O4ECsuNkCTgwRvDMLFvEF5eexynckqgVklIHBqOaYNDUWEwY2tqPvaeK0RafhmKK00wmuUmv9/dUYsvH7sRrg7aeq9lXq7AS2tTEBvohmdui27wZo5ERPaCQYVIIWUGM175/gR2nq7ubdGqJZgs1RvKPTEyEhPigxoMEQazBcWVJuSXVOFSqRFFFUaUVplRYbTAYLZgW+olXCo1YHgPHyyZEl/nvVUmC55YcQipudV7yIyO9cP8ib25ComI7Na1/P7mzrRE7chFr8HiyfHYeDwXb2xMRYXRgkB3Bzx5SxRGxvg1+j69Rg0/VzX8XBtusB0d649Znx3ET2kF2HoqD6Ni/K2vvbf9LNLyy+CoU8NgsmDLyXw46zR4dlw0+12IqNNjUCHqAGN7B2BgmCfWHc3Gjd29ER3QthG/uG7umDY4FJ/vzcTrP6RiYLgX3By02J6aj7XJFyHLAo8O7w43Bw3+9v1JrD2SDWe9xnofJCKizor7qBB1EG8XPRKHRrQ5pNR6ZHgEQrwcUVJlxqLvTiC7qBJvbEyFySIwrncA7rohCOP7BOL/bu0BAPhiXyY+/OkcqkyWNn2vEAL5pVXcJ4aIFMEeFaJO5GROCR795ACEAII8HJBdVIXuvs547Z54BLo7Ws/7ZHc6PthxDgCgVknwctYh2NMRge4OSIj0xi3Rfi2aFsoqrMC/tqZh3/lCBHs6YfqQUIyO9YdOw/+PQ0Stx2Zaoi7s/R1n8enuDADVN1V8cUIsRkTX739Z/vN5fLonA1Wm+quJRkT7Yt74mAZXEAFAhdGMT3dn4KuDF1BprDsi4+Wsw9TBIZjYNwhujbyfiKgpDCpEXZjRLOPhj/fj3KVyzBoRiQduDG10dMRskZFTUoX0gnJkFVYgLa8Mm0/mQRaAj4sOiybFIT7Yw3p+bnEV9p6/jM/2ZCC3uAqyqN7k7s4buiH9cjnWH8tBUUX1naZVqupN62ICXBHl54Ke/q6ID/ZodGl0VmEFFq07gegAVzw1qkejozJCCAiBRlctybJAqcEMB60Keo36Gq4cEdkLBhWiLq7cYEZafil6Bbpf8zRMysVi/HVNCi6VGiBJwJT+wTBZZBzOLEJOcSXMcnVQ8HHR4b6BIbirXze46Kv77k0WGasPXcTXBy/gYlFlvc8eGOaJN+7rC626bk2/XULdp5sbXr+3b70RnZ2nL+FfW9NQUGaEk04NNwctXB000GvVKKsyoajChOJKEyyygE6jwoievhjTyx8DwzyhUXM6iqizYFAhoiZVGM145fuT2J56qc5xlQSEeTvjhhAP3DMgGOE+zo1+RlZhBQ5nFuFUbgkyCytwPLsERrOMW2J8seiuOOsojxACizecwoZjOXDWa2C0yDCYZAR7OuKdaf3g71Z9A8h/bUnD5pN5MFmu/Z8kDyctxsT6IT7YAz38XNHN07FDNr0zmmUcSC/Ez2cLEObtjHv6B3O/GqJWYFAhohb5ISUH3yZnI8DNAT39XTEowguhXk6tapbdc/Yy/vz1EcgCmDY4BE+Oql599G3yRby56TRkWWDumJ7oG+yOOV8mo6jCBDcHDR69uTtW7M1EXkkVgOql3RPjg2CWZRRVGFFSZUKZwQIXvQZezjr4uOrh46zD+YJyfH8sFwfSC1FaZbbWIUmAk06NHn6uuCHEA1MGBMPLWdfqa2S2yNiffgXbT+fj57QClFSZYalZATU4wgvz7+wNd0f26hBdCwYVIlLE2iMX8fcNqQCAp2/tgV5B7njqi8OoNFowuX83/HF0D2jVKuSXVmH2ikPILqqyvtffzQEPDQ3HuLiAawpKFllg26l8bD2Vj8zCCly4UlFnVEavUeHegSH43eBQuDv9GiiEECgoM8Iii0bvZH0ypwSvb0zFmfwyazhxd9QiNtANBzMKYbII+LjosGRKPGID+W8QUUsxqBCRYv6z8xyW/5IOSQJ8XfTILzWgX4gH/jYpDh5XjWyUGcx49qsjOHqxGGNi/fHQ0PAmp5paymCy4GROCY5cKMKPx/OQfrkCAOCgVeO+gcHQaVQ4nVeG03mlKCgzQJYFbgj1wNRBobixuzfUKglVJgv++/N5fH3wAgwmGU46NYZEeGFAmBdu6uENX1cHnM4txbP/O4pLpQaoVBKevCUSsYFuMJplGM0yTLJAmJdTu/xMHUEIgW+Ts6HTqDA+LoC7GJNNMagQkWKEEPjbupP44XguAMDXVY9X745DryD3Bs+9VGqAh5OuQ/ZmEUJgy6l8fPTTeWQWVtR7XZIACbDeyTrY0xET4gOx8XguMi9X3+F6cIQXfp8QihtCPOv9Mi8zmPHimhTsO19o/TwAEDX/I0nAxPggzBoRWWc0BwDOF5TjqwNZqDLJmDWye4O3TxBCYOupfJzILkGAuwNCvZwQ6u0EP1eHNvXgCCHw3vazWHUgC2aLwMS+gfjz2BjezJJshkGFiBRltsh46dvjOHaxGE+MjMT4PoGK1iOEwA8pufg2ufrWAmHeTgj3drIuzV6xNxPbUvPr7Bnj4aTF9CFhmNQvCE66xu82IoTAij2Z+ObwBQgBaNUqaNTVv/AzakZznPVqPDEyEhP7dsPpvFJ8vjcTP6Vdsk5ROenUmDc+BqNif72HU35JFf7x42nsOX8Z5qumslQSoNeqMSraF4+PjIJnK/pvPvzpHD7dk1Hnc0f09MGCu+Lqrdgi6ggMKkRkF6pMZjhoO8ctxSqNZqzcl4XNJ/MQ4eOM6TeGIjaw/ihQU4QQdUZdDqQX4vWNqbhwpXopt7eLDiWVJmtA6RfigcIKozXQ3NrLH3+6rSd+SivAe9vO4EqFCRqVhBsjvVFuMCO3uAr5pQZrv4yLXoO5Y3pg3DVM3Xy6JwMf/XQOJovA1EEh6O7njCUbUiHLAv1DPfD6vX3hoG18f5odpy/h7c2nEeXniqmDQ9AvxMNm00ZCCOw+exk/nSnA6Bg/DAz3ssn3UvtjUCEishMWWeCLfZlY/ks6Ko0WqCRgcIQ3xvb2x809faFRSUjafhZfHsiCEICDVgWzLGC2CET4OCMxIRyjYv2s0zKVRgsOZhTinS1nrHvZ9A/1wF/GxyDY06nJWlYdyMJ7287AZBGY0r8bHh8ZBUedGnvOFmDe6hQYzTKi/V3xj/v6NjhSs+FYDl7/MRWGq3Y77unvgt8NCcMt0b5t3sumuNKE9IJyBHs6wstZZw1Asiyw60wBPt2TgdN5pdaRoJt7+uCPo3vUuX0EdQ4MKkREduZKuQGrD2cjOsAVgyO86k2xJGdewctrj6OgzAitWsKdfYMw/cYw+Ls1vCLJbJHx313n8fm+TJgsAioJ6B/miSER3hgU7olIXxcIAGn5pTiaVYzkC0X45UwBTBaBiX2D8NSoKDjrfx3tSrlQjLmrklFptMBJr8bsmqmq2oD09cELeHdrGkwWgaGR3tCqVdh97jKM5urQ4uWsw43dvdA/1BP9wzwbrfu3sgorsPvsZfxytgBHLxbDVPN5ns46RPu7ItzHGYcyruBMfhnMsoBeo0JsoBuOXiiCLACtWsKDCeGYPiS0yZGgjmI0yziRUwJPJy3CvDu+cbrSaMGlUgNCvZsOpfaOQYWIqBOqMJqxan8WQr2cMCLar0XNrVmFFVjw3XGczCmtc9zLWQeLLFBm+HXfFwAY1zsAc8ZEwc2x/ojJuUtlmPfNMetUVQ9/FzxzWzQOZV7Bf3edh8kicGsvf8wZHQVPZz2ulBux/Jd0/Hg8FyW/2csm2NMJN0V54+aevugd5F7nZ8kprsTmE3nYciof6QXl1t2QgereoOJKE377m0mvVWFUtB8m9g1Cn27uOHupDIvXn0JqXvXP7eagwZDu3ugX6oEBYZ7o5uHYLlNSl0oNKDOYodOooFOroNeqUGGwYF96Ifadv4yDGVdQbqgeKXt5Yi/cEuPf/Ic2wCILlBvN0KlVjQauX84W4M0fTyOv1ICZw7vjwYSwtvxoimJQISK6zqTllWLzyTwcvVCMU7ml1pEOR50aPfxcEOXngthAV4zo6VdnJOW3LLLAZ3sy8OnuDFSaqpuL1SoJFrl6JOaJkd3rhRyjWcautEv45exlpOaVIr2gHFdlI3i76DAqxg8hnk7YfvoSjl0osoYTlQREB7iiTzcPDI7wRN8QD5jMMo5dLMHx7GJkFlbA3VGL2/sEolegW52dgIUQ2JCSi6TtZ1FYbrQelyQgwM0Bt8T44fY+gYhoZIl4UYURDlp1vWBgMFuwK60A3x/LwaGMK9VBTwIk/Prdsvg1XOk0KhjNMiQJePrWnpjcP7jO5529VIYPdpzF6bwyqCQJWrUEjVqCWqVCpdGMMoMZlUYLhADUagm3RPvh7n7d0DvIDZIkobTKhPe2n8WGYzl19gj60231vwsAzuSXYs+5QtzeJ7BNmx12JAYVIqLrmMFkwd7zhTBZZPTp5g5fV/01jy4Ulhnw2sZU/JRWAAC4b2AwHr25e5MroGpdKTdiZ9ol7DxdgCMXiurdgRuoDidDIrwwoqcvIv1c2rTayGyRsfvsZfx8pgCncktxtqAc8lVJqVeQG+6ID0RsoBtO5pQg5WIxjl0sRm5xFYQAgjwcEe7jjDBvJ5jMMjadzENRhalO07LJIsNkkSHXLDvv7uOMuG7u6NPNHYPCvZC04yx+SKlekj9jWDgevikCZQYzlv+cjtXJF+v09bRUT38XjIr1x3fJ2cgproQsgDGx/tBpJKw/Vv1dL94Ri3Fx1avqLLLA53szsPyXdFSZZLg7arHgrt4YZIdNxwwqRETULk5kF+NcQTnGxPq3qgfEaLZg66l8bDmZj8tlRsR1c8PwHj6ID/HosLtfl1aZsO1UPn48nocjNb0sQPXojQzUbHTTNE8nLYZG+mBktC/6hXpCkqqDgMEsw2yR4e6krVO/EAJJ289ixd5MAMBNPXxwOrcUl8oMEKK64Xls7wC4OWhhkqtDj9ki4KBTw91BCzdHLdwdNci4XIGvD17A/vTCOqMnvq56JCaE4/b4AOjUKvx9wyl8dzQHKgl4dXIfhHs7Y/GGk0i5WAKLLOCi16DMUD0dN21wCB4bEdlkGEwvKMdPaZeQXVxlHS0SQlTfQb2bG+7uV3/kpi0YVIiIiADkl1bhqwMXsD01H4XlRoR7OyPKzwVRvi7oH+4JjSThVF4pzuSXIaeoEgazjP6hnhgV69fihuCrfbk/E+9sOWN9HuDugKkDQzChb2CLRqNqXSk34vN9mdiVVoAe/i74/Y1hiPJ3tb4uywIvrz2OrafyoVFJcNCpUVZlhqNOjWmDQnDXDUFI2nHOOsrTw98FfxzdA846DbRqCVq1CpWm6imunWmXkF5Q3ugNQQdHeOKf9/e75mvRFAYVIiKi36gyWaBVqzp8B97NJ3Px0U/pGBjuiamDQtCtmWXjrWW2yPjL/45iz7nqnZFjAlwxY1gEhkV5W6f6Np/Iw5IfTlmn3+r86JJknSJTqyT0CnRDd19nqFUSVNVNOVBJQKSvC+7oG9SutTOoEBERXQcMZguStp+Fg0aN+wYFw8tZX++cvOJKLFx3EheLKq1TTrX9Nz38XTAgzBM3Rfkgys+lzXvhtBSDChEREdUjywIWUR1UZCGg16gVucfTtfz+7hx7WxMREVGbqWqmdRTYG6/VePcpIiIislsMKkRERGS3GFSIiIjIbjGoEBERkd1iUCEiIiK7xaBCREREdotBhYiIiOwWgwoRERHZLQYVIiIislsMKkRERGS3GFSIiIjIbjGoEBERkd1iUCEiIiK71anvniyEAFB9u2giIiLqHGp/b9f+Hm9Kpw4qpaWlAICQkBCFKyEiIqJrVVpaCnd39ybPkURL4oydkmUZ2dnZcHV1hSRJ7frZJSUlCAkJQVZWFtzc3Nr1s6kuXmvb4bW2HV5r2+G1tp32utZCCJSWliIoKAgqVdNdKJ16REWlUiE4OLhDv8PNzY1/8W2E19p2eK1th9fadnitbac9rnVzIym12ExLREREdotBhYiIiOwWg0oj9Ho9Xn75Zej1eqVL6fJ4rW2H19p2eK1th9fadpS41p26mZaIiIi6No6oEBERkd1iUCEiIiK7xaBCREREdotBhYiIiOwWg0oD/v3vfyM8PBwODg4YMmQI9u3bp3RJnd7ixYsxaNAguLq6ws/PD5MmTUJqamqdc6qqqjB79mx4e3vDxcUFU6ZMQV5enkIVdx1LliyBJEmYO3eu9Rivdfu5ePEiHnjgAXh7e8PR0RF9+vTBgQMHrK8LIfDSSy8hMDAQjo6OGDNmDNLS0hSsuHOyWCx48cUXERERAUdHR0RGRmLRokV17hXDa916O3fuxMSJExEUFARJkrBmzZo6r7fk2hYWFmL69Olwc3ODh4cHHn74YZSVlbW9OEF1rFy5Uuh0OvHf//5XHD9+XDz66KPCw8ND5OXlKV1apzZ27FixbNkykZKSIpKTk8Xtt98uQkNDRVlZmfWcWbNmiZCQELFlyxZx4MABceONN4qhQ4cqWHXnt2/fPhEeHi7i4+PFnDlzrMd5rdtHYWGhCAsLEw899JDYu3evOHfunNi4caM4c+aM9ZwlS5YId3d3sWbNGnHkyBFx5513ioiICFFZWalg5Z3PK6+8Iry9vcW6devE+fPnxVdffSVcXFzE22+/bT2H17r11q9fL1544QXxzTffCABi9erVdV5vybUdN26c6Nu3r9izZ4/46aefRFRUlJg2bVqba2NQ+Y3BgweL2bNnW59bLBYRFBQkFi9erGBVXU9+fr4AIHbs2CGEEKKoqEhotVrx1VdfWc85efKkACB2796tVJmdWmlpqejRo4fYtGmTGDFihDWo8Fq3n7/85S/ipptuavR1WZZFQECAeP31163HioqKhF6vF1988YUtSuwyJkyYIP7whz/UOTZ58mQxffp0IQSvdXv6bVBpybU9ceKEACD2799vPWfDhg1CkiRx8eLFNtXDqZ+rGI1GHDx4EGPGjLEeU6lUGDNmDHbv3q1gZV1PcXExAMDLywsAcPDgQZhMpjrXPiYmBqGhobz2rTR79mxMmDChzjUFeK3b09q1azFw4EDce++98PPzQ79+/fCf//zH+vr58+eRm5tb51q7u7tjyJAhvNbXaOjQodiyZQtOnz4NADhy5Ah27dqF8ePHA+C17kgtuba7d++Gh4cHBg4caD1nzJgxUKlU2Lt3b5u+v1PflLC9FRQUwGKxwN/fv85xf39/nDp1SqGquh5ZljF37lwMGzYMcXFxAIDc3FzodDp4eHjUOdff3x+5ubkKVNm5rVy5EocOHcL+/fvrvcZr3X7OnTuHpKQkPP3003j++eexf/9+/PGPf4ROp0NiYqL1ejb0bwqv9bV57rnnUFJSgpiYGKjValgsFrzyyiuYPn06APBad6CWXNvc3Fz4+fnVeV2j0cDLy6vN159BhWxu9uzZSElJwa5du5QupUvKysrCnDlzsGnTJjg4OChdTpcmyzIGDhyIV199FQDQr18/pKSk4P3330diYqLC1XUtq1atwooVK/D555+jd+/eSE5Oxty5cxEUFMRr3cVx6ucqPj4+UKvV9VY/5OXlISAgQKGqupYnn3wS69atw7Zt2xAcHGw9HhAQAKPRiKKiojrn89pfu4MHDyI/Px/9+/eHRqOBRqPBjh078M4770Cj0cDf35/Xup0EBgaiV69edY7FxsYiMzMTAKzXk/+mtN2f//xnPPfcc5g6dSr69OmDBx98EP/3f/+HxYsXA+C17kgtubYBAQHIz8+v87rZbEZhYWGbrz+DylV0Oh0GDBiALVu2WI/JsowtW7YgISFBwco6PyEEnnzySaxevRpbt25FREREndcHDBgArVZb59qnpqYiMzOT1/4ajR49GseOHUNycrL1MXDgQEyfPt36Z17r9jFs2LB6y+xPnz6NsLAwAEBERAQCAgLqXOuSkhLs3buX1/oaVVRUQKWq+ytLrVZDlmUAvNYdqSXXNiEhAUVFRTh48KD1nK1bt0KWZQwZMqRtBbSpFbcLWrlypdDr9WL58uXixIkTYubMmcLDw0Pk5uYqXVqn9vjjjwt3d3exfft2kZOTY31UVFRYz5k1a5YIDQ0VW7duFQcOHBAJCQkiISFBwaq7jqtX/QjBa91e9u3bJzQajXjllVdEWlqaWLFihXBychKfffaZ9ZwlS5YIDw8P8e2334qjR4+Ku+66i0tmWyExMVF069bNujz5m2++ET4+PuLZZ5+1nsNr3XqlpaXi8OHD4vDhwwKAePPNN8Xhw4dFRkaGEKJl13bcuHGiX79+Yu/evWLXrl2iR48eXJ7cUf71r3+J0NBQodPpxODBg8WePXuULqnTA9DgY9myZdZzKisrxRNPPCE8PT2Fk5OTuPvuu0VOTo5yRXchvw0qvNbt57vvvhNxcXFCr9eLmJgYsXTp0jqvy7IsXnzxReHv7y/0er0YPXq0SE1NVajazqukpETMmTNHhIaGCgcHB9G9e3fxwgsvCIPBYD2H17r1tm3b1uC/0YmJiUKIll3by5cvi2nTpgkXFxfh5uYmZsyYIUpLS9tcmyTEVdv6EREREdkR9qgQERGR3WJQISIiIrvFoEJERER2i0GFiIiI7BaDChEREdktBhUiIiKyWwwqREREZLcYVIio05MkCWvWrFG6DCLqAAwqRNQmDz30ECRJqvcYN26c0qURURegUboAIur8xo0bh2XLltU5ptfrFaqGiLoSjqgQUZvp9XoEBATUeXh6egKonpZJSkrC+PHj4ejoiO7du+Prr7+u8/5jx45h1KhRcHR0hLe3N2bOnImysrI65/z3v/9F7969odfrERgYiCeffLLO6wUFBbj77rvh5OSEHj16YO3atdbXrly5gunTp8PX1xeOjo7o0aNHvWBFRPaJQYWIOtyLL76IKVOm4MiRI5g+fTqmTp2KkydPAgDKy8sxduxYeHp6Yv/+/fjqq6+wefPmOkEkKSkJs2fPxsyZM3Hs2DGsXbsWUVFRdb5jwYIFuO+++3D06FHcfvvtmD59OgoLC63ff+LECWzYsAEnT55EUlISfHx8bHcBiKj12nxbQyK6riUmJgq1Wi2cnZ3rPF555RUhRPWds2fNmlXnPUOGDBGPP/64EEKIpUuXCk9PT1FWVmZ9/fvvvxcqlUrk5uYKIYQICgoSL7zwQqM1ABB//etfrc/LysoEALFhwwYhhBATJ04UM2bMaJ8fmIhsij0qRNRmt9xyC5KSkuoc8/Lysv45ISGhzmsJCQlITk4GAJw8eRJ9+/aFs7Oz9fVhw4ZBlmWkpqZCkiRkZ2dj9OjRTdYQHx9v/bOzszPc3NyQn58PAHj88ccxZcoUHDp0CLfddhsmTZqEoUOHtupnJSLbYlAhojZzdnauNxXTXhwdHVt0nlarrfNckiTIsgwAGD9+PDIyMrB+/Xps2rQJo0ePxuzZs/HGG2+0e71E1L7Yo0JEHW7Pnj31nsfGxgIAYmNjceTIEZSXl1tf//nnn6FSqRAdHQ1XV1eEh4djy5YtbarB19cXiYmJ+Oyzz/DWW29h6dKlbfo8IrINjqgQUZsZDAbk5ubWOabRaKwNq1999RUGDhyIm266CStWrMC+ffvw0UcfAQCmT5+Ol19+GYmJiZg/fz4uXbqEp556Cg8++CD8/f0BAPPnz8esWbPg5+eH8ePHo7S0FD///DOeeuqpFtX30ksvYcCAAejduzcMBgPWrVtnDUpEZN8YVIiozX744QcEBgbWORYdHY1Tp04BqF6Rs3LlSjzxxBMIDAzEF198gV69egEAnJycsHHjRsyZMweDBg2Ck5MTpkyZgjfffNP6WYmJiaiqqsI///lPPPPMM/Dx8cE999zT4vp0Oh3mzZuH9PR0ODo6Yvjw4Vi5cmU7/ORE1NEkIYRQuggi6rokScLq1asxadIkpUshok6IPSpERERktxhUiIiIyG6xR4WIOhRnl4moLTiiQkRERHaLQYWIiIjsFoMKERER2S0GFSIiIrJbDCpERERktxhUiIiIyG4xqBAREZHdYlAhIiIiu8WgQkRERHbr/wGl90za8RYEXgAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -162,7 +162,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "0.44405922293663025\n" + "0.4364333152770996\n" ] } ], @@ -205,7 +205,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO:kgcnn.models.utils:Updated model kwargs: '{'name': 'GINE', 'inputs': [{'shape': (None, 41), 'name': 'node_attributes', 'dtype': 'float32', 'ragged': True}, {'shape': (None, 11), 'name': 'edge_attributes', 'dtype': 'float32', 'ragged': True}, {'shape': (None, 2), 'name': 'edge_indices', 'dtype': 'int64', 'ragged': True}], 'input_tensor_type': 'ragged', 'cast_disjoint_kwargs': {}, 'input_embedding': None, 'input_node_embedding': {'input_dim': 95, 'output_dim': 64}, 'input_edge_embedding': {'input_dim': 10, 'output_dim': 64}, 'gin_mlp': {'units': [64, 64], 'use_bias': True, 'activation': ['relu', 'linear'], 'use_normalization': True, 'normalization_technique': 'graph_batch'}, 'gin_args': {'epsilon_learnable': False}, 'depth': 3, 'dropout': 0.0, 'verbose': 10, 'last_mlp': {'use_bias': [True, True, True], 'units': [64, 64, 64], 'activation': ['relu', 'relu', 'linear']}, 'output_embedding': 'graph', 'output_to_tensor': True, 'output_tensor_type': 'padded', 'output_mlp': {'units': 1, 'activation': 'linear'}}'.\n" + "INFO:kgcnn.models.utils:Updated model kwargs: '{'name': 'GINE', 'inputs': [{'shape': (None, 41), 'name': 'node_attributes', 'dtype': 'float32', 'ragged': True}, {'shape': (None, 11), 'name': 'edge_attributes', 'dtype': 'float32', 'ragged': True}, {'shape': (None, 2), 'name': 'edge_indices', 'dtype': 'int64', 'ragged': True}], 'input_tensor_type': 'ragged', 'cast_disjoint_kwargs': {}, 'input_embedding': None, 'input_node_embedding': {'input_dim': 95, 'output_dim': 64}, 'input_edge_embedding': {'input_dim': 10, 'output_dim': 64}, 'gin_mlp': {'units': [64, 64], 'use_bias': True, 'activation': ['relu', 'linear'], 'use_normalization': True, 'normalization_technique': 'graph_batch'}, 'gin_args': {'epsilon_learnable': False}, 'depth': 3, 'dropout': 0.0, 'verbose': 10, 'last_mlp': {'use_bias': [True, True, True], 'units': [64, 64, 64], 'activation': ['relu', 'relu', 'linear']}, 'output_embedding': 'graph', 'output_to_tensor': None, 'output_scaling': None, 'output_tensor_type': 'padded', 'output_mlp': {'units': 1, 'activation': 'linear'}}'.\n" ] } ], @@ -246,7 +246,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -258,7 +258,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "0.4353353977203369\n" + "0.4378684163093567\n" ] } ], @@ -307,7 +307,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO:kgcnn.models.utils:Updated model kwargs: '{'name': 'GINE', 'inputs': [{'shape': (41,), 'name': 'node_attributes', 'dtype': 'float32'}, {'shape': (11,), 'name': 'edge_attributes', 'dtype': 'float32'}, {'shape': (None,), 'name': 'edge_indices', 'dtype': 'int64'}, {'shape': (), 'name': 'batch_id_node', 'dtype': 'int64'}, {'shape': (), 'name': 'batch_id_edge', 'dtype': 'int64'}, {'shape': (), 'name': 'node_id', 'dtype': 'int64'}, {'shape': (), 'name': 'edge_id', 'dtype': 'int64'}, {'shape': (), 'name': 'count_nodes', 'dtype': 'int64'}, {'shape': (), 'name': 'count_edges', 'dtype': 'int64'}], 'input_tensor_type': 'disjoint', 'cast_disjoint_kwargs': {}, 'input_embedding': None, 'input_node_embedding': {'input_dim': 95, 'output_dim': 64}, 'input_edge_embedding': {'input_dim': 10, 'output_dim': 64}, 'gin_mlp': {'units': [64, 64], 'use_bias': True, 'activation': ['relu', 'linear'], 'use_normalization': True, 'normalization_technique': 'graph_batch'}, 'gin_args': {'epsilon_learnable': False}, 'depth': 3, 'dropout': 0.0, 'verbose': 10, 'last_mlp': {'use_bias': [True, True, True], 'units': [64, 64, 64], 'activation': ['relu', 'relu', 'linear']}, 'output_embedding': 'graph', 'output_to_tensor': True, 'output_tensor_type': 'padded', 'output_mlp': {'units': 1, 'activation': 'linear'}}'.\n" + "INFO:kgcnn.models.utils:Updated model kwargs: '{'name': 'GINE', 'inputs': [{'shape': (41,), 'name': 'node_attributes', 'dtype': 'float32'}, {'shape': (11,), 'name': 'edge_attributes', 'dtype': 'float32'}, {'shape': (None,), 'name': 'edge_indices', 'dtype': 'int64'}, {'shape': (), 'name': 'batch_id_node', 'dtype': 'int64'}, {'shape': (), 'name': 'batch_id_edge', 'dtype': 'int64'}, {'shape': (), 'name': 'node_id', 'dtype': 'int64'}, {'shape': (), 'name': 'edge_id', 'dtype': 'int64'}, {'shape': (), 'name': 'count_nodes', 'dtype': 'int64'}, {'shape': (), 'name': 'count_edges', 'dtype': 'int64'}], 'input_tensor_type': 'disjoint', 'cast_disjoint_kwargs': {}, 'input_embedding': None, 'input_node_embedding': {'input_dim': 95, 'output_dim': 64}, 'input_edge_embedding': {'input_dim': 10, 'output_dim': 64}, 'gin_mlp': {'units': [64, 64], 'use_bias': True, 'activation': ['relu', 'linear'], 'use_normalization': True, 'normalization_technique': 'graph_batch'}, 'gin_args': {'epsilon_learnable': False}, 'depth': 3, 'dropout': 0.0, 'verbose': 10, 'last_mlp': {'use_bias': [True, True, True], 'units': [64, 64, 64], 'activation': ['relu', 'relu', 'linear']}, 'output_embedding': 'graph', 'output_to_tensor': None, 'output_scaling': None, 'output_tensor_type': 'padded', 'output_mlp': {'units': 1, 'activation': 'linear'}}'.\n" ] } ], @@ -330,14 +330,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO:kgcnn.data.base:Dataloader is experimental and not fully tested nor stable.\n", + "INFO:kgcnn.data.base:Dataloader is experimental and not fully tested or stable.\n", "C:\\Users\\patri\\anaconda3\\envs\\gcnn_keras_test\\lib\\contextlib.py:153: UserWarning: Your input ran out of data; interrupting training. Make sure that your dataset or generator can generate at least `steps_per_epoch * epochs` batches. You may need to use the `.repeat()` function when building your dataset.\n", " self.gen.throw(typ, value, traceback)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -349,12 +349,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "0.41299083828926086\n" + "0.42463621497154236\n" ] } ], "source": [ - "dataloader = dataset.tf_disjoint_data_generator(inputs=inputs, outputs=outputs, batch_size=31, has_edges=True)\n", + "dataloader = dataset.tf_disjoint_data_generator(\n", + " inputs=inputs, \n", + " outputs=outputs, \n", + " batch_size=32, \n", + " assignment_to_id=[0, 1, 1],\n", + " assignment_of_indices=[None, None, 0],\n", + " pos_batch_id=[3,4],\n", + " pos_subgraph_id=[5,6],\n", + " pos_count=[7,8],\n", + ")\n", "hist = model.fit(dataloader, epochs=100, verbose=0)\n", "plot_train_test_loss([hist]);\n", "print(hist.history[\"loss\"][-1])" diff --git a/training/hyper/hyper_qm7.py b/training/hyper/hyper_qm7.py index 5c113c9b..60aae3c7 100644 --- a/training/hyper/hyper_qm7.py +++ b/training/hyper/hyper_qm7.py @@ -100,7 +100,6 @@ } }, "training": { - "cross_validation": None, "fit": { "batch_size": 32, "epochs": 800, "validation_freq": 10, "verbose": 2, "callbacks": [ @@ -169,7 +168,6 @@ } }, "training": { - "cross_validation": None, "fit": { "batch_size": 32, "epochs": 500, "validation_freq": 10, "verbose": 2, "callbacks": [ @@ -232,7 +230,6 @@ } }, "training": { - "cross_validation": None, "fit": { "batch_size": 32, "epochs": 872, "validation_freq": 10, "verbose": 2, "callbacks": [] }, @@ -304,7 +301,6 @@ } }, "training": { - "cross_validation": None, "fit": { "batch_size": 10, "epochs": 872, "validation_freq": 10, "verbose": 2, "callbacks": [] }, @@ -388,7 +384,6 @@ } }, "training": { - "cross_validation": None, "fit": { "batch_size": 128, "epochs": 900, "validation_freq": 10, "verbose": 2, "callbacks": [ @@ -473,7 +468,6 @@ } }, "training": { - "cross_validation": None, "fit": { "batch_size": 64, "epochs": 800, "validation_freq": 10, "verbose": 2, "callbacks": [ diff --git a/training/results/ESOLDataset/HDNNP2nd/HDNNP2nd_ESOLDataset_score.yaml b/training/results/ESOLDataset/HDNNP2nd/HDNNP2nd_ESOLDataset_score.yaml new file mode 100644 index 00000000..9aca0208 --- /dev/null +++ b/training/results/ESOLDataset/HDNNP2nd/HDNNP2nd_ESOLDataset_score.yaml @@ -0,0 +1,155 @@ +OS: posix_linux +backend: tensorflow +cuda_available: 'True' +data_unit: '' +date_time: '2023-12-16 14:20:51' +device_id: '[LogicalDevice(name=''/device:CPU:0'', device_type=''CPU''), LogicalDevice(name=''/device:GPU:0'', + device_type=''GPU'')]' +device_memory: '[]' +device_name: '[{}, {''compute_capability'': (7, 0), ''device_name'': ''Tesla V100-SXM2-32GB''}]' +epochs: +- 500 +- 500 +- 500 +- 500 +- 500 +execute_folds: null +kgcnn_version: 4.0.0 +learning_rate: +- 1.2475000403355807e-05 +- 1.2475000403355807e-05 +- 1.2475000403355807e-05 +- 1.2475000403355807e-05 +- 1.2475000403355807e-05 +loss: +- 0.15006421506404877 +- 0.2045334279537201 +- 0.182841494679451 +- 0.28615856170654297 +- 0.16819065809249878 +max_learning_rate: +- 0.0010000000474974513 +- 0.0010000000474974513 +- 0.0010000000474974513 +- 0.0010000000474974513 +- 0.0010000000474974513 +max_loss: +- 1050.958740234375 +- 1072.7860107421875 +- 1351.61328125 +- 742.5038452148438 +- 932.4214477539062 +max_scaled_mean_absolute_error: +- 2171.699951171875 +- 2397.251220703125 +- 2968.527099609375 +- 1670.48583984375 +- 2095.54443359375 +max_scaled_root_mean_squared_error: +- 4859.6962890625 +- 6274.77294921875 +- 9636.841796875 +- 4294.2744140625 +- 6170.39404296875 +max_val_loss: +- 2.967543840408325 +- 4.321155548095703 +- 2.379824161529541 +- 2.9825034141540527 +- 1.6983462572097778 +max_val_scaled_mean_absolute_error: +- 5.76836633682251 +- 8.934284210205078 +- 4.676303863525391 +- 6.372075080871582 +- 3.5247902870178223 +max_val_scaled_root_mean_squared_error: +- 12.232710838317871 +- 17.97592544555664 +- 9.654337882995605 +- 10.737979888916016 +- 5.654468059539795 +min_learning_rate: +- 1.2475000403355807e-05 +- 1.2475000403355807e-05 +- 1.2475000403355807e-05 +- 1.2475000403355807e-05 +- 1.2475000403355807e-05 +min_loss: +- 0.15006421506404877 +- 0.2045334279537201 +- 0.18247966468334198 +- 0.28615856170654297 +- 0.16791127622127533 +min_scaled_mean_absolute_error: +- 0.3100925087928772 +- 0.4585422873497009 +- 0.4036935567855835 +- 0.6466238498687744 +- 0.37718355655670166 +min_scaled_root_mean_squared_error: +- 0.5472607016563416 +- 0.6909869909286499 +- 0.6379508376121521 +- 0.9276455640792847 +- 0.6038655042648315 +min_val_loss: +- 0.359761118888855 +- 0.35519173741340637 +- 0.37606579065322876 +- 0.44839122891426086 +- 0.2795977294445038 +min_val_scaled_mean_absolute_error: +- 0.7317304015159607 +- 0.7574374079704285 +- 0.806479275226593 +- 0.9143146872520447 +- 0.5999270081520081 +min_val_scaled_root_mean_squared_error: +- 1.0076076984405518 +- 0.9617904424667358 +- 1.0709308385849 +- 1.2063385248184204 +- 0.8019803762435913 +model_class: make_model +model_name: HDNNP2nd +model_version: '2023-12-06' +multi_target_indices: null +number_histories: 5 +scaled_mean_absolute_error: +- 0.3100925087928772 +- 0.4585422873497009 +- 0.4036935567855835 +- 0.6466627717018127 +- 0.37718355655670166 +scaled_root_mean_squared_error: +- 0.547501266002655 +- 0.6915514469146729 +- 0.6396282315254211 +- 0.9276455640792847 +- 0.6038655042648315 +seed: 42 +time_list: +- '0:03:24.230775' +- '0:03:30.425506' +- '0:03:32.999628' +- '0:03:33.306796' +- '0:03:23.156946' +val_loss: +- 0.3843301236629486 +- 0.3677997291088104 +- 0.38562124967575073 +- 0.44839122891426086 +- 0.29149383306503296 +val_scaled_mean_absolute_error: +- 0.7867846488952637 +- 0.7965545654296875 +- 0.8203436732292175 +- 0.9143146872520447 +- 0.6104740500450134 +val_scaled_root_mean_squared_error: +- 1.034210205078125 +- 1.0530409812927246 +- 1.0990005731582642 +- 1.2352395057678223 +- 0.812187135219574 diff --git a/training/results/ESOLDataset/HDNNP2nd/HDNNP2nd_hyper.json b/training/results/ESOLDataset/HDNNP2nd/HDNNP2nd_hyper.json new file mode 100644 index 00000000..4a27f7be --- /dev/null +++ b/training/results/ESOLDataset/HDNNP2nd/HDNNP2nd_hyper.json @@ -0,0 +1 @@ +{"model": {"class_name": "make_model", "module_name": "kgcnn.literature.HDNNP2nd", "config": {"name": "HDNNP2nd", "inputs": [{"shape": [null], "name": "node_number", "dtype": "int64"}, {"shape": [null, 3], "name": "node_coordinates", "dtype": "float32"}, {"shape": [null, 2], "name": "range_indices", "dtype": "int64"}, {"shape": [null, 3], "name": "angle_indices_nodes", "dtype": "int64"}, {"shape": [], "name": "total_nodes", "dtype": "int64"}, {"shape": [], "name": "total_ranges", "dtype": "int64"}, {"shape": [], "name": "total_angles", "dtype": "int64"}], "input_tensor_type": "padded", "cast_disjoint_kwargs": {}, "w_acsf_ang_kwargs": {}, "w_acsf_rad_kwargs": {}, "mlp_kwargs": {"units": [128, 128, 128, 1], "num_relations": 96, "activation": ["swish", "swish", "swish", "linear"]}, "node_pooling_args": {"pooling_method": "sum"}, "verbose": 10, "output_embedding": "graph", "output_to_tensor": true, "use_output_mlp": false, "output_mlp": {"use_bias": [true, true], "units": [64, 1], "activation": ["swish", "linear"]}}}, "training": {"cross_validation": {"class_name": "KFold", "config": {"n_splits": 5, "random_state": 42, "shuffle": true}}, "scaler": {"class_name": "StandardLabelScaler", "config": {"with_std": true, "with_mean": true, "copy": true}}, "fit": {"batch_size": 64, "epochs": 500, "validation_freq": 10, "verbose": 2, "callbacks": [{"class_name": "kgcnn>LinearLearningRateScheduler", "config": {"learning_rate_start": 0.001, "learning_rate_stop": 1e-05, "epo_min": 100, "epo": 500, "verbose": 0}}]}, "compile": {"optimizer": {"class_name": "Adam", "config": {"learning_rate": 0.001}}, "loss": "mean_absolute_error"}}, "data": {}, "info": {"postfix": "", "postfix_file": "", "kgcnn_version": "4.0.0"}, "dataset": {"class_name": "ESOLDataset", "module_name": "kgcnn.data.datasets.ESOLDataset", "config": {}, "methods": [{"map_list": {"method": "set_range", "max_distance": 8, "max_neighbours": 10000}}, {"map_list": {"method": "set_angle"}}, {"map_list": {"method": "count_nodes_and_edges", "total_edges": "total_ranges", "count_edges": "range_indices"}}, {"map_list": {"method": "count_nodes_and_edges", "total_edges": "total_angles", "count_edges": "angle_indices"}}]}} \ No newline at end of file diff --git a/training/results/ESOLDataset/MXMNet/MXMNet_ESOLDataset_score.yaml b/training/results/ESOLDataset/MXMNet/MXMNet_ESOLDataset_score.yaml new file mode 100644 index 00000000..ae445b42 --- /dev/null +++ b/training/results/ESOLDataset/MXMNet/MXMNet_ESOLDataset_score.yaml @@ -0,0 +1,155 @@ +OS: posix_linux +backend: tensorflow +cuda_available: 'True' +data_unit: kcal/mol +date_time: '2023-12-16 15:10:00' +device_id: '[LogicalDevice(name=''/device:CPU:0'', device_type=''CPU''), LogicalDevice(name=''/device:GPU:0'', + device_type=''GPU'')]' +device_memory: '[]' +device_name: '[{}, {''compute_capability'': (7, 0), ''device_name'': ''Tesla V100-SXM2-32GB''}]' +epochs: +- 900 +- 900 +- 900 +- 900 +- 900 +execute_folds: null +kgcnn_version: 4.0.0 +learning_rate: +- 3.186606409144588e-05 +- 3.186606409144588e-05 +- 3.186606409144588e-05 +- 3.186606409144588e-05 +- 3.186606409144588e-05 +loss: +- 0.05602772906422615 +- 0.03677725791931152 +- 0.06303983926773071 +- 0.07047641277313232 +- 0.04589661583304405 +max_learning_rate: +- 0.0010000000474974513 +- 0.0010000000474974513 +- 0.0010000000474974513 +- 0.0010000000474974513 +- 0.0010000000474974513 +max_loss: +- 135098.234375 +- 1290025.25 +- 1062335.125 +- 2255.200927734375 +- 35993852.0 +max_scaled_mean_absolute_error: +- 279166.84375 +- 2928290.75 +- 1932644.0 +- 5220.38818359375 +- 86320776.0 +max_scaled_root_mean_squared_error: +- 547015.875 +- 6147397.5 +- 3640700.75 +- 13245.2216796875 +- 204592352.0 +max_val_loss: +- 0.47518110275268555 +- 1.0245468616485596 +- 1.0666401386260986 +- 0.6575448513031006 +- 0.8727327585220337 +max_val_scaled_mean_absolute_error: +- 0.9825155735015869 +- 2.0884854793548584 +- 2.2147927284240723 +- 1.379630208015442 +- 1.830553412437439 +max_val_scaled_root_mean_squared_error: +- 1.439700722694397 +- 4.682966232299805 +- 2.943596124649048 +- 1.6344813108444214 +- 2.244565725326538 +min_learning_rate: +- 3.186606409144588e-05 +- 3.186606409144588e-05 +- 3.186606409144588e-05 +- 3.186606409144588e-05 +- 3.186606409144588e-05 +min_loss: +- 0.053560771048069 +- 0.03636404871940613 +- 0.05852018669247627 +- 0.0642593652009964 +- 0.041281986981630325 +min_scaled_mean_absolute_error: +- 0.11067792028188705 +- 0.08455577492713928 +- 0.13409259915351868 +- 0.15212762355804443 +- 0.09525160491466522 +min_scaled_root_mean_squared_error: +- 0.2607514262199402 +- 0.21059618890285492 +- 0.2705477476119995 +- 0.31973862648010254 +- 0.23129011690616608 +min_val_loss: +- 0.285233736038208 +- 0.3163433372974396 +- 0.32148653268814087 +- 0.2641453146934509 +- 0.2512412667274475 +min_val_scaled_mean_absolute_error: +- 0.5918595790863037 +- 0.6662721633911133 +- 0.6673845648765564 +- 0.5478610396385193 +- 0.5306581854820251 +min_val_scaled_root_mean_squared_error: +- 0.782740592956543 +- 1.1565991640090942 +- 1.022428274154663 +- 0.7854965329170227 +- 0.714111328125 +model_class: make_model +model_name: MXMNet +model_version: '2023-12-09' +multi_target_indices: null +number_histories: 5 +scaled_mean_absolute_error: +- 0.11577564477920532 +- 0.08578737080097198 +- 0.13658908009529114 +- 0.16949298977851868 +- 0.10849414765834808 +scaled_root_mean_squared_error: +- 0.2676967978477478 +- 0.21508260071277618 +- 0.27416038513183594 +- 0.3255828320980072 +- 0.23512513935565948 +seed: 42 +time_list: +- '0:08:17.473709' +- '0:09:29.677180' +- '0:09:44.595441' +- '0:09:27.493328' +- '0:09:15.450368' +val_loss: +- 0.32490938901901245 +- 0.32593798637390137 +- 0.3547247052192688 +- 0.280733585357666 +- 0.2690351903438568 +val_scaled_mean_absolute_error: +- 0.6669237613677979 +- 0.6835973858833313 +- 0.7386835813522339 +- 0.5815834403038025 +- 0.572092592716217 +val_scaled_root_mean_squared_error: +- 0.9175363779067993 +- 1.352008581161499 +- 1.1380881071090698 +- 0.8667173385620117 +- 0.7872799038887024 diff --git a/training/results/ESOLDataset/MXMNet/MXMNet_hyper.json b/training/results/ESOLDataset/MXMNet/MXMNet_hyper.json new file mode 100644 index 00000000..4aac0824 --- /dev/null +++ b/training/results/ESOLDataset/MXMNet/MXMNet_hyper.json @@ -0,0 +1 @@ +{"model": {"class_name": "make_model", "module_name": "kgcnn.literature.MXMNet", "config": {"name": "MXMNet", "inputs": [{"shape": [null], "name": "node_number", "dtype": "int64"}, {"shape": [null, 3], "name": "node_coordinates", "dtype": "float32"}, {"shape": [null, 1], "name": "edge_weights", "dtype": "float32"}, {"shape": [null, 2], "name": "edge_indices", "dtype": "int64"}, {"shape": [null, 2], "name": "range_indices", "dtype": "int64"}, {"shape": [null, 2], "name": "angle_indices_1", "dtype": "int64"}, {"shape": [null, 2], "name": "angle_indices_2", "dtype": "int64"}, {"shape": [], "name": "total_nodes", "dtype": "int64"}, {"shape": [], "name": "total_edges", "dtype": "int64"}, {"shape": [], "name": "total_ranges", "dtype": "int64"}, {"shape": [], "name": "total_angles_1", "dtype": "int64"}, {"shape": [], "name": "total_angles_2", "dtype": "int64"}], "input_tensor_type": "padded", "input_embedding": null, "input_node_embedding": {"input_dim": 95, "output_dim": 32}, "input_edge_embedding": {"input_dim": 5, "output_dim": 32}, "bessel_basis_local": {"num_radial": 16, "cutoff": 5.0, "envelope_exponent": 5}, "bessel_basis_global": {"num_radial": 16, "cutoff": 5.0, "envelope_exponent": 5}, "spherical_basis_local": {"num_spherical": 7, "num_radial": 6, "cutoff": 5.0, "envelope_exponent": 5}, "mlp_rbf_kwargs": {"units": 32, "activation": "swish"}, "mlp_sbf_kwargs": {"units": 32, "activation": "swish"}, "global_mp_kwargs": {"units": 32, "pooling_method": "mean"}, "local_mp_kwargs": {"units": 32, "output_units": 1, "output_kernel_initializer": "glorot_uniform"}, "use_edge_attributes": false, "depth": 4, "verbose": 10, "node_pooling_args": {"pooling_method": "sum"}, "output_embedding": "graph", "output_to_tensor": true, "use_output_mlp": false, "output_mlp": {"use_bias": [true], "units": [1], "activation": ["linear"]}}}, "training": {"fit": {"batch_size": 128, "epochs": 900, "validation_freq": 10, "verbose": 2, "callbacks": [{"class_name": "kgcnn>LinearWarmupExponentialLRScheduler", "config": {"lr_start": 0.001, "gamma": 0.9961697, "epo_warmup": 1, "verbose": 1, "steps_per_epoch": 45}}]}, "compile": {"optimizer": {"class_name": "Adam", "config": {"learning_rate": 0.001, "global_clipnorm": 1000}}, "loss": "mean_absolute_error"}, "cross_validation": {"class_name": "KFold", "config": {"n_splits": 5, "random_state": 42, "shuffle": true}}, "scaler": {"class_name": "StandardLabelScaler", "config": {"with_std": true, "with_mean": true, "copy": true}}}, "data": {"data_unit": "kcal/mol"}, "info": {"postfix": "", "postfix_file": "", "kgcnn_version": "4.0.0"}, "dataset": {"class_name": "ESOLDataset", "module_name": "kgcnn.data.datasets.ESOLDataset", "config": {}, "methods": [{"map_list": {"method": "set_edge_weights_uniform"}}, {"map_list": {"method": "set_range", "max_distance": 5, "max_neighbours": 1000}}, {"map_list": {"method": "set_angle", "range_indices": "edge_indices", "edge_pairing": "jk", "angle_indices": "angle_indices_1", "angle_indices_nodes": "angle_indices_nodes_1", "angle_attributes": "angle_attributes_1"}}, {"map_list": {"method": "set_angle", "range_indices": "edge_indices", "edge_pairing": "ik", "allow_self_edges": true, "angle_indices": "angle_indices_2", "angle_indices_nodes": "angle_indices_nodes_2", "angle_attributes": "angle_attributes_2"}}, {"map_list": {"method": "count_nodes_and_edges"}}, {"map_list": {"method": "count_nodes_and_edges", "total_edges": "total_ranges", "count_edges": "range_indices"}}, {"map_list": {"method": "count_nodes_and_edges", "total_edges": "total_angles_1", "count_edges": "angle_indices_1"}}, {"map_list": {"method": "count_nodes_and_edges", "total_edges": "total_angles_2", "count_edges": "angle_indices_2"}}]}} \ No newline at end of file diff --git a/training/results/README.md b/training/results/README.md index 8c962ae4..dfc8add7 100644 --- a/training/results/README.md +++ b/training/results/README.md @@ -66,10 +66,12 @@ ESOL consists of 1128 compounds as smiles and their corresponding water solubili | GIN | 4.0.0 | 300 | 0.5369 ± 0.0334 | 0.7954 ± 0.0861 | | GNNFilm | 4.0.0 | 800 | 0.4854 ± 0.0368 | 0.6724 ± 0.0436 | | GraphSAGE | 4.0.0 | 500 | 0.4874 ± 0.0228 | 0.6982 ± 0.0608 | +| HDNNP2nd | 4.0.0 | 500 | 0.7857 ± 0.0986 | 1.0467 ± 0.1367 | | INorp | 4.0.0 | 500 | 0.5055 ± 0.0436 | 0.7297 ± 0.0786 | | MAT | 4.0.0 | 400 | 0.5064 ± 0.0299 | 0.7194 ± 0.0630 | | MEGAN | 4.0.0 | 400 | **0.4281 ± 0.0201** | **0.6062 ± 0.0252** | | Megnet | 4.0.0 | 800 | 0.5679 ± 0.0310 | 0.8196 ± 0.0480 | +| MXMNet | 4.0.0 | 900 | 0.6486 ± 0.0633 | 1.0123 ± 0.2059 | | NMPN | 4.0.0 | 800 | 0.5046 ± 0.0266 | 0.7193 ± 0.0607 | | PAiNN | 4.0.0 | 250 | 0.4857 ± 0.0598 | 0.6650 ± 0.0674 | | RGCN | 4.0.0 | 800 | 0.4703 ± 0.0251 | 0.6529 ± 0.0318 | @@ -180,10 +182,12 @@ Materials Project dataset from Matbench with 106113 crystal structures and their Materials Project dataset from Matbench with 636 crystal structures and their corresponding Exfoliation energy (meV/atom). We use a random 5-fold cross-validation. -| model | kgcnn | epochs | MAE [meV/atom] | RMSE [meV/atom] | -|:--------------------------|:--------|---------:|:-------------------------|:--------------------------| -| PAiNN.make_crystal_model | 4.0.0 | 800 | 49.3889 ± 11.5376 | 121.7087 ± 30.0472 | -| Schnet.make_crystal_model | 4.0.0 | 800 | **45.2412 ± 11.6395** | **115.6890 ± 39.0929** | +| model | kgcnn | epochs | MAE [meV/atom] | RMSE [meV/atom] | +|:-----------------------------|:--------|---------:|:-------------------------|:--------------------------| +| CGCNN.make_crystal_model | 4.0.0 | 1000 | 57.6974 ± 18.0803 | 140.6167 ± 44.8418 | +| DimeNetPP.make_crystal_model | 4.0.0 | 780 | 50.2880 ± 11.4199 | 126.0600 ± 38.3769 | +| PAiNN.make_crystal_model | 4.0.0 | 800 | 49.3889 ± 11.5376 | 121.7087 ± 30.0472 | +| Schnet.make_crystal_model | 4.0.0 | 800 | **45.2412 ± 11.6395** | **115.6890 ± 39.0929** | #### MatProjectLogGVRHDataset