From 9599f42d3b3908aaf05095475f5af8abf738612e Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Fri, 7 Jul 2023 15:45:53 -0700 Subject: [PATCH 01/63] initial single trainer commit --- configs/goc_single_debug.yml | 137 ++++ ocpmodels/common/utils.py | 33 + ocpmodels/datasets/lmdb_dataset.py | 5 + ocpmodels/models/gemnet_oc/gemnet_oc.py | 16 +- ocpmodels/modules/evaluator.py | 99 ++- ocpmodels/modules/loss.py | 10 +- ocpmodels/trainers/base_trainer.py | 77 +-- ocpmodels/trainers/ocp_trainer.py | 801 ++++++++++++++++++++++++ 8 files changed, 1109 insertions(+), 69 deletions(-) create mode 100644 configs/goc_single_debug.yml create mode 100644 ocpmodels/trainers/ocp_trainer.py diff --git a/configs/goc_single_debug.yml b/configs/goc_single_debug.yml new file mode 100644 index 000000000..d0ddacced --- /dev/null +++ b/configs/goc_single_debug.yml @@ -0,0 +1,137 @@ +trainer: ocp + +dataset: + train: + src: /checkpoint/saro00/mpf_datasets/s2efs/0/train.lmdb + #src: /datasets01/open_catalyst/oc20/082422/struct_to_energy_forces/val/id_30k + val: + #src: /datasets01/open_catalyst/oc20/082422/struct_to_energy_forces/val/id_30k + src: /checkpoint/saro00/mpf_datasets/s2efs/0/val.lmdb + test: + #src: /datasets01/open_catalyst/oc20/082422/struct_to_energy_forces/val/id_30k + src: /checkpoint/saro00/mpf_datasets/s2efs/0/val.lmdb + +logger: tensorboard + +task: + dataset: lmdb + + train_on_free_atoms: True + eval_on_free_atoms: True + + metrics: + - energy_mae + - energy_mse + - energy_within_threshold + - forces_mae + - forces_cos + - stress_mae + + primary_metric: forces_mae + + targets: + energy: + irreps: 0 + loss: mae + level: system + coefficient: 1 + normalizer: + mean: -5.9749126 + stdev: 1.866159 + forces: + irreps: 1 + loss: mae + level: atom + coefficient: 100 + normalizer: + stdev: 1.866159 + stress: + isotropic_stress: + irreps: 0 + loss: mae + level: system + coefficient: 1 + normalizer: + mean: 43.27065 + stdev: 674.1657344451734 + anisotropic_stress: + irreps: 2 + loss: mae + level: system + coefficient: 1 + normalizer: + stdev: 143.72764771869745 + +model: + name: gemnet_oc + num_spherical: 7 + num_radial: 128 + num_blocks: 4 + emb_size_atom: 256 + emb_size_edge: 512 + emb_size_trip_in: 64 + emb_size_trip_out: 64 + emb_size_quad_in: 32 + emb_size_quad_out: 32 + emb_size_aint_in: 64 + emb_size_aint_out: 64 + emb_size_rbf: 16 + emb_size_cbf: 16 + emb_size_sbf: 32 + num_before_skip: 2 + num_after_skip: 2 + num_concat: 1 + num_atom: 3 + num_output_afteratom: 3 + cutoff: 12.0 + cutoff_qint: 12.0 + cutoff_aeaint: 12.0 + cutoff_aint: 12.0 + max_neighbors: 30 + max_neighbors_qint: 8 + max_neighbors_aeaint: 20 + max_neighbors_aint: 1000 + rbf: + name: gaussian + envelope: + name: polynomial + exponent: 5 + cbf: + name: spherical_harmonics + sbf: + name: legendre_outer + extensive: True + output_init: HeOrthogonal + activation: silu + scale_file: configs/s2ef/all/gemnet/scaling_factors/gemnet-oc.pt + + regress_forces: True + direct_forces: True + forces_coupled: False + + quad_interaction: True + atom_edge_interaction: True + edge_atom_interaction: True + atom_interaction: True + + num_atom_emb_layers: 2 + num_global_out_layers: 2 + qint_tags: [1, 2] + +optim: + batch_size: 1 + eval_batch_size: 1 + load_balancing: atoms + eval_every: 5000 + num_workers: 2 + lr_initial: 5.e-4 + optimizer: AdamW + optimizer_params: {"amsgrad": True} + scheduler: ReduceLROnPlateau + mode: min + factor: 0.8 + patience: 3 + max_epochs: 80 + ema_decay: 0.999 + clip_grad_norm: 10 + weight_decay: 0 diff --git a/ocpmodels/common/utils.py b/ocpmodels/common/utils.py index 976e2bc35..66b05f06a 100644 --- a/ocpmodels/common/utils.py +++ b/ocpmodels/common/utils.py @@ -1121,3 +1121,36 @@ def scatter_det(*args, **kwargs): torch.use_deterministic_algorithms(mode=False) return out + + +change_mat = torch.tensor( + [ + [3 ** (-0.5), 0, 0, 0, 3 ** (-0.5), 0, 0, 0, 3 ** (-0.5)], + [0, 0, 0, 0, 0, 2 ** (-0.5), 0, -(2 ** (-0.5)), 0], + [0, 0, -(2 ** (-0.5)), 0, 0, 0, 2 ** (-0.5), 0, 0], + [0, 2 ** (-0.5), 0, -(2 ** (-0.5)), 0, 0, 0, 0, 0], + [0, 0, 0.5**0.5, 0, 0, 0, 0.5**0.5, 0, 0], + [0, 2 ** (-0.5), 0, 2 ** (-0.5), 0, 0, 0, 0, 0], + [ + -(6 ** (-0.5)), + 0, + 0, + 0, + 2 * 6 ** (-0.5), + 0, + 0, + 0, + -(6 ** (-0.5)), + ], + [0, 0, 0, 0, 0, 2 ** (-0.5), 0, 2 ** (-0.5), 0], + [-(2 ** (-0.5)), 0, 0, 0, 0, 0, 0, 0, 2 ** (-0.5)], + ] +).detach() + + +def irreps_sum(l): + total = 0 + for i in range(l + 1): + total += 2 * i + 1 + + return total diff --git a/ocpmodels/datasets/lmdb_dataset.py b/ocpmodels/datasets/lmdb_dataset.py index fb6ce268c..72501eb63 100644 --- a/ocpmodels/datasets/lmdb_dataset.py +++ b/ocpmodels/datasets/lmdb_dataset.py @@ -151,6 +151,11 @@ def __getitem__(self, idx: int): if self.transform is not None: data_object = self.transform(data_object) + if "stress" in data_object: + data_object.stress = data_object.stress.reshape(1, -1) + data_object.energy = data_object.y + data_object.forces = data_object.force + return data_object def connect_db(self, lmdb_path: Optional[Path] = None): diff --git a/ocpmodels/models/gemnet_oc/gemnet_oc.py b/ocpmodels/models/gemnet_oc/gemnet_oc.py index 48efd98dd..aa81c694f 100644 --- a/ocpmodels/models/gemnet_oc/gemnet_oc.py +++ b/ocpmodels/models/gemnet_oc/gemnet_oc.py @@ -1355,10 +1355,22 @@ def forward(self, data): E_t = E_t.squeeze(1) # (num_molecules) F_t = F_t.squeeze(1) # (num_atoms, 3) - return E_t, F_t + + outputs = { + "energy": E_t, + "forces": F_t, + "isotropic_stress": torch.rand( + (E_t.numel(), 1), device=E_t.device + ), + "anisotropic_stress": torch.rand( + (E_t.numel(), 5), device=E_t.device + ), + } else: E_t = E_t.squeeze(1) # (num_molecules) - return E_t + outputs = {"y": E_t} + + return outputs @property def num_params(self) -> int: diff --git a/ocpmodels/modules/evaluator.py b/ocpmodels/modules/evaluator.py index ae38d40c1..6eb97c4ab 100644 --- a/ocpmodels/modules/evaluator.py +++ b/ocpmodels/modules/evaluator.py @@ -9,6 +9,7 @@ import torch from typing import Dict, Union +from ocpmodels.common.utils import change_mat """ An evaluation module for use with the OCP dataset and suite of tasks. It should @@ -50,10 +51,26 @@ class Evaluator: "is2re": ["energy_mae", "energy_mse", "energy_within_threshold"], } - task_attributes = { - "s2ef": ["energy", "forces", "natoms"], - "is2rs": ["positions", "cell", "pbc", "natoms"], - "is2re": ["energy"], + metric_attributes = { + "forcesx_mae": ["forces"], + "forcesy_mae": ["forces"], + "forcesz_mae": ["forces"], + "forces_mae": ["forces"], + "forces_cos": ["forces"], + "forces_magnitude": ["forces"], + "energy_mae": ["energy"], + "energy_force_within_threshold": ["energy", "forces", "natoms"], + "energy_mse": ["energy"], + "energy_within_threshold": ["energy"], + "average_distance_within_threshold": [ + "positions", + "cell", + "pbc", + "natoms", + ], + "positions_mae": ["positions"], + "positions_mse": ["positions"], + "stress_mae": ["isotropic_stress", "anisotropic_stress"], } task_primary_metric = { @@ -62,20 +79,21 @@ class Evaluator: "is2re": "energy_mae", } - def __init__(self, task: str) -> None: - assert task in ["s2ef", "is2rs", "is2re"] + def __init__(self, task: str = None, eval_metrics: str = None) -> None: self.task = task - self.metric_fn = self.task_metrics[task] + self.metric_fns = self.task_metrics.get(task, eval_metrics) def eval(self, prediction, target, prev_metrics={}): - for attr in self.task_attributes[self.task]: - assert attr in prediction - assert attr in target - assert prediction[attr].shape == target[attr].shape + + for metric in self.metric_fns: + for attr in self.metric_attributes.get(metric, {}): + assert attr in prediction + assert attr in target + assert prediction[attr].shape == target[attr].shape metrics = prev_metrics - for fn in self.task_metrics[self.task]: + for fn in self.metric_fns: res = eval(fn)(prediction, target) metrics = self.update(fn, res, metrics) @@ -110,43 +128,43 @@ def update(self, key, stat, metrics): def energy_mae(prediction, target): - return absolute_error(prediction["energy"], target["energy"]) + return mae(prediction["energy"], target["energy"]) def energy_mse(prediction, target): - return squared_error(prediction["energy"], target["energy"]) + return mse(prediction["energy"], target["energy"]) def forcesx_mae(prediction, target): - return absolute_error(prediction["forces"][:, 0], target["forces"][:, 0]) + return mae(prediction["forces"][:, 0], target["forces"][:, 0]) def forcesx_mse(prediction, target): - return squared_error(prediction["forces"][:, 0], target["forces"][:, 0]) + return mse(prediction["forces"][:, 0], target["forces"][:, 0]) def forcesy_mae(prediction, target): - return absolute_error(prediction["forces"][:, 1], target["forces"][:, 1]) + return mae(prediction["forces"][:, 1], target["forces"][:, 1]) def forcesy_mse(prediction, target): - return squared_error(prediction["forces"][:, 1], target["forces"][:, 1]) + return mse(prediction["forces"][:, 1], target["forces"][:, 1]) def forcesz_mae(prediction, target): - return absolute_error(prediction["forces"][:, 2], target["forces"][:, 2]) + return mae(prediction["forces"][:, 2], target["forces"][:, 2]) def forcesz_mse(prediction, target): - return squared_error(prediction["forces"][:, 2], target["forces"][:, 2]) + return mse(prediction["forces"][:, 2], target["forces"][:, 2]) def forces_mae(prediction, target): - return absolute_error(prediction["forces"], target["forces"]) + return mae(prediction["forces"], target["forces"]) def forces_mse(prediction, target): - return squared_error(prediction["forces"], target["forces"]) + return mse(prediction["forces"], target["forces"]) def forces_cos(prediction, target): @@ -158,11 +176,11 @@ def forces_magnitude(prediction, target): def positions_mae(prediction, target): - return absolute_error(prediction["positions"], target["positions"]) + return mae(prediction["positions"], target["positions"]) def positions_mse(prediction, target): - return squared_error(prediction["positions"], target["positions"]) + return mse(prediction["positions"], target["positions"]) def energy_force_within_threshold( @@ -252,6 +270,31 @@ def average_distance_within_threshold( return {"metric": success / total, "total": success, "numel": total} +def stress_mae(prediction, target): + device = prediction["isotropic_stress"].device + cg_decomp_mat = change_mat.to(device) + + zero_vectors = torch.zeros( + (prediction["isotropic_stress"].shape[0], 3), + device=device, + ) + prediction_irreps = torch.concat( + [ + prediction["isotropic_stress"].reshape(-1, 1), + zero_vectors, + prediction["anisotropic_stress"].reshape(-1, 5), + ], + dim=1, + ) + prediction_stress = torch.einsum( + "ba, cb->ca", cg_decomp_mat, prediction_irreps + ).reshape(-1) + + target_stress = target["stress"] + + return mae(prediction_stress, target_stress) + + def min_diff(pred_pos, dft_pos, cell, pbc): pos_diff = pred_pos - dft_pos fractional = np.linalg.solve(cell.T, pos_diff.T).T @@ -276,8 +319,8 @@ def cosine_similarity(prediction: torch.Tensor, target: torch.Tensor): } -def absolute_error( - prediction: torch.Tensor, target: torch.Tensor +def mae( + prediction: dict, target: dict ) -> Dict[str, Union[float, int]]: error = torch.abs(target - prediction) return { @@ -287,8 +330,8 @@ def absolute_error( } -def squared_error( - prediction: torch.Tensor, target: torch.Tensor +def mse( + prediction: dict, target: dict ) -> Dict[str, Union[float, int]]: error = (target - prediction) ** 2 return { diff --git a/ocpmodels/modules/loss.py b/ocpmodels/modules/loss.py index 7ab36c500..b7b8a50c4 100644 --- a/ocpmodels/modules/loss.py +++ b/ocpmodels/modules/loss.py @@ -46,9 +46,10 @@ def forward( class DDPLoss(nn.Module): - def __init__(self, loss_fn, reduction: str = "mean") -> None: + def __init__(self, loss_fn, loss_name: str = "mae", reduction: str = "mean") -> None: super().__init__() self.loss_fn = loss_fn + self.loss_name = loss_name self.loss_fn.reduction = "sum" self.reduction = reduction assert reduction in ["mean", "sum"] @@ -66,10 +67,11 @@ def forward( logging.warning("Found nans while computing loss") input = torch.nan_to_num(input, nan=0.0) - if natoms is None: - loss = self.loss_fn(input, target) - else: # atom-wise loss + if self.loss_name.startswith("atomwise"): loss = self.loss_fn(input, target, natoms) + else: + loss = self.loss_fn(input, target) + if self.reduction == "mean": num_samples = ( batch_size if batch_size is not None else input.shape[0] diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index ffdfa2167..bd56b6b8b 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -126,7 +126,7 @@ def __init__( logger_name = logger if isinstance(logger, str) else logger["name"] self.config = { "task": task, - "trainer": "forces" if name == "s2ef" else "energy", + "trainer": "ocp", "model": assert_is_instance(model.pop("name"), str), "model_attributes": model, "optim": optimizer, @@ -180,11 +180,6 @@ def __init__( else: self.config["dataset"] = dataset - self.normalizer = normalizer - # This supports the legacy way of providing norm parameters in dataset - if self.config.get("dataset", None) is not None and normalizer is None: - self.normalizer = self.config["dataset"] - if not is_debug and distutils.is_master() and not is_hpo: os.makedirs(self.config["cmd"]["checkpoint_dir"], exist_ok=True) os.makedirs(self.config["cmd"]["results_dir"], exist_ok=True) @@ -206,7 +201,9 @@ def __init__( print(yaml.dump(self.config, default_flow_style=False)) self.load() - self.evaluator = Evaluator(task=name) + self.evaluator = Evaluator( + task=name, eval_metrics=self.config["task"].get("metrics", None) + ) def load(self) -> None: self.load_seed_from_config() @@ -283,6 +280,7 @@ def get_dataloader(self, dataset, sampler) -> DataLoader: return loader def load_datasets(self) -> None: + logging.info(f"Loading dataset: {self.config['task']['dataset']}") self.parallel_collater = ParallelCollater( 0 if self.cpu else 1, self.config["model_attributes"].get("otf_graph", False), @@ -292,6 +290,7 @@ def load_datasets(self) -> None: self.val_loader = None self.test_loader = None + # load train, val, test datasets if self.config.get("dataset", None): self.train_dataset = registry.get_dataset_class( self.config["task"]["dataset"] @@ -338,23 +337,22 @@ def load_datasets(self) -> None: self.test_sampler, ) - # Normalizer for the dataset. - # Compute mean, std of training set labels. - self.normalizers = {} - if self.normalizer.get("normalize_labels", False): - if "target_mean" in self.normalizer: - self.normalizers["target"] = Normalizer( - mean=self.normalizer["target_mean"], - std=self.normalizer["target_std"], - device=self.device, - ) - else: - self.normalizers["target"] = Normalizer( - tensor=self.train_loader.dataset.data.y[ - self.train_loader.dataset.__indices__ - ], - device=self.device, - ) + # load relaxation dataset + if "relax_dataset" in self.config["task"]: + self.relax_dataset = registry.get_dataset_class("lmdb")( + self.config["task"]["relax_dataset"] + ) + self.relax_sampler = self.get_sampler( + self.relax_dataset, + self.config["optim"].get( + "eval_batch_size", self.config["optim"]["batch_size"] + ), + shuffle=False, + ) + self.relax_loader = self.get_dataloader( + self.relax_dataset, + self.relax_sampler, + ) @abstractmethod def load_task(self): @@ -467,24 +465,26 @@ def load_checkpoint(self, checkpoint_path: str) -> None: self.scaler.load_state_dict(checkpoint["amp"]) def load_loss(self) -> None: - self.loss_fn: Dict[str, str] = { - "energy": self.config["optim"].get("loss_energy", "mae"), - "force": self.config["optim"].get("loss_force", "mae"), - } - for loss, loss_name in self.loss_fn.items(): + self.loss_fn = {} + for target_name in self.train_targets: + self.loss_fn[target_name] = self.train_targets[target_name].get( + "loss", "mae" + ) + + for target, loss_name in self.loss_fn.items(): if loss_name in ["l1", "mae"]: - self.loss_fn[loss] = nn.L1Loss() + self.loss_fn[target] = nn.L1Loss() elif loss_name == "mse": - self.loss_fn[loss] = nn.MSELoss() + self.loss_fn[target] = nn.MSELoss() elif loss_name == "l2mae": - self.loss_fn[loss] = L2MAELoss() + self.loss_fn[target] = L2MAELoss() elif loss_name == "atomwisel2": - self.loss_fn[loss] = AtomwiseL2Loss() + self.loss_fn[target] = AtomwiseL2Loss() else: raise NotImplementedError( f"Unknown loss function name: {loss_name}" ) - self.loss_fn[loss] = DDPLoss(self.loss_fn[loss]) + self.loss_fn[target] = DDPLoss(self.loss_fn[target], loss_name) def load_optimizer(self) -> None: optimizer = self.config["optim"].get("optimizer", "AdamW") @@ -651,7 +651,14 @@ def validate(self, split: str = "val", disable_tqdm: bool = False): self.ema.store() self.ema.copy_to() - evaluator, metrics = Evaluator(task=self.name), {} + evaluator, metrics = ( + Evaluator( + task=self.name, + eval_metrics=self.config["task"].get("metrics", None), + ), + {}, + ) + rank = distutils.get_rank() loader = self.val_loader if split == "val" else self.test_loader diff --git a/ocpmodels/trainers/ocp_trainer.py b/ocpmodels/trainers/ocp_trainer.py new file mode 100644 index 000000000..490a841e8 --- /dev/null +++ b/ocpmodels/trainers/ocp_trainer.py @@ -0,0 +1,801 @@ +""" +Copyright (c) Facebook, Inc. and its affiliates. + +This source code is licensed under the MIT license found in the +LICENSE file in the root directory of this source tree. +""" + +import logging +import os +import pathlib +from collections import defaultdict +from pathlib import Path + +import numpy as np +import torch +import torch_geometric +from tqdm import tqdm + +from ocpmodels.common import distutils +from ocpmodels.common.registry import registry +from ocpmodels.common.relaxation.ml_relaxation import ml_relax +from ocpmodels.common.utils import change_mat, check_traj_files, irreps_sum +from ocpmodels.modules.evaluator import Evaluator +from ocpmodels.modules.normalizer import Normalizer +from ocpmodels.modules.scaling.util import ensure_fitted +from ocpmodels.trainers.base_trainer import BaseTrainer + + +@registry.register_trainer("ocp") +class OCPTrainer(BaseTrainer): + """ + Trainer class for the Structure to Energy & Force (S2EF) and Initial State to + Relaxed State (IS2RS) tasks. + + .. note:: + + Examples of configurations for task, model, dataset and optimizer + can be found in `configs/ocp_s2ef `_ + and `configs/ocp_is2rs `_. + + Args: + task (dict): Task configuration. + model (dict): Model configuration. + dataset (dict): Dataset configuration. The dataset needs to be a SinglePointLMDB dataset. + optimizer (dict): Optimizer configuration. + identifier (str): Experiment identifier that is appended to log directory. + run_dir (str, optional): Path to the run directory where logs are to be saved. + (default: :obj:`None`) + is_debug (bool, optional): Run in debug mode. + (default: :obj:`False`) + is_hpo (bool, optional): Run hyperparameter optimization with Ray Tune. + (default: :obj:`False`) + print_every (int, optional): Frequency of printing logs. + (default: :obj:`100`) + seed (int, optional): Random number seed. + (default: :obj:`None`) + logger (str, optional): Type of logger to be used. + (default: :obj:`tensorboard`) + local_rank (int, optional): Local rank of the process, only applicable for distributed training. + (default: :obj:`0`) + amp (bool, optional): Run using automatic mixed precision. + (default: :obj:`False`) + slurm (dict): Slurm configuration. Currently just for keeping track. + (default: :obj:`{}`) + """ + + def __init__( + self, + task, + model, + dataset, + optimizer, + identifier, + normalizer=None, + timestamp_id=None, + run_dir=None, + is_debug=False, + is_hpo=False, + print_every=100, + seed=None, + logger="tensorboard", + local_rank=0, + amp=False, + cpu=False, + slurm={}, + noddp=False, + ): + super().__init__( + task=task, + model=model, + dataset=dataset, + optimizer=optimizer, + identifier=identifier, + normalizer=normalizer, + timestamp_id=timestamp_id, + run_dir=run_dir, + is_debug=is_debug, + is_hpo=is_hpo, + print_every=print_every, + seed=seed, + logger=logger, + local_rank=local_rank, + amp=amp, + cpu=cpu, + slurm=slurm, + noddp=noddp, + ) + + def load_task(self): + self.targets = self.config["task"]["targets"] + self.num_targets = 1 + + self.train_targets = {} + for target in self.targets: + if "irreps" in self.targets[target]: + self.train_targets[target] = self.targets[target] + else: + for subtarget in self.targets[target]: + self.train_targets[subtarget] = self.targets[target][ + subtarget + ] + self.train_targets[subtarget]["parent"] = target + + # Normalizer for the dataset. + self.normalizers = {} + for target in self.train_targets: + self.normalizers[target] = Normalizer( + mean=self.train_targets.get("mean", 0), + std=self.train_targets.get("std", 1), + device=self.device, + ) + + self.eval_metrics = self.config["task"]["metrics"] + + # assert len(self.targets.keys() - self.eval_metrics.keys()) == 0 + + # Takes in a new data source and generates predictions on it. + @torch.no_grad() + def predict( + self, + data_loader, + per_image=True, + results_file=None, + disable_tqdm=False, + ): + ensure_fitted(self._unwrapped_model, warn=True) + + if distutils.is_master() and not disable_tqdm: + logging.info("Predicting on test.") + assert isinstance( + data_loader, + ( + torch.utils.data.dataloader.DataLoader, + torch_geometric.data.Batch, + ), + ) + rank = distutils.get_rank() + + if isinstance(data_loader, torch_geometric.data.Batch): + data_loader = [[data_loader]] + + self.model.eval() + if self.ema: + self.ema.store() + self.ema.copy_to() + + if self.normalizers is not None and "target" in self.normalizers: + self.normalizers["target"].to(self.device) + self.normalizers["grad_target"].to(self.device) + + predictions = {"id": [], "energy": [], "forces": [], "chunk_idx": []} + + for i, batch_list in tqdm( + enumerate(data_loader), + total=len(data_loader), + position=rank, + desc="device {}".format(rank), + disable=disable_tqdm, + ): + with torch.cuda.amp.autocast(enabled=self.scaler is not None): + out = self._forward(batch_list) + + if self.normalizers is not None and "target" in self.normalizers: + out["energy"] = self.normalizers["target"].denorm( + out["energy"] + ) + out["forces"] = self.normalizers["grad_target"].denorm( + out["forces"] + ) + if per_image: + systemids = [ + str(i) + "_" + str(j) + for i, j in zip( + batch_list[0].sid.tolist(), batch_list[0].fid.tolist() + ) + ] + predictions["id"].extend(systemids) + batch_natoms = torch.cat( + [batch.natoms for batch in batch_list] + ) + batch_fixed = torch.cat([batch.fixed for batch in batch_list]) + # total energy target requires predictions to be saved in float32 + # default is float16 + if ( + self.config["task"].get("prediction_dtype", "float16") + == "float32" + or self.config["task"]["dataset"] == "oc22_lmdb" + ): + predictions["energy"].extend( + out["energy"].cpu().detach().to(torch.float32).numpy() + ) + forces = out["forces"].cpu().detach().to(torch.float32) + else: + predictions["energy"].extend( + out["energy"].cpu().detach().to(torch.float16).numpy() + ) + forces = out["forces"].cpu().detach().to(torch.float16) + per_image_forces = torch.split(forces, batch_natoms.tolist()) + per_image_forces = [ + force.numpy() for force in per_image_forces + ] + # evalAI only requires forces on free atoms + if results_file is not None: + _per_image_fixed = torch.split( + batch_fixed, batch_natoms.tolist() + ) + _per_image_free_forces = [ + force[(fixed == 0).tolist()] + for force, fixed in zip( + per_image_forces, _per_image_fixed + ) + ] + _chunk_idx = np.array( + [ + free_force.shape[0] + for free_force in _per_image_free_forces + ] + ) + per_image_forces = _per_image_free_forces + predictions["chunk_idx"].extend(_chunk_idx) + predictions["forces"].extend(per_image_forces) + else: + predictions["energy"] = out["energy"].detach() + predictions["forces"] = out["forces"].detach() + if self.ema: + self.ema.restore() + return predictions + + predictions["forces"] = np.array(predictions["forces"]) + predictions["chunk_idx"] = np.array(predictions["chunk_idx"]) + predictions["energy"] = np.array(predictions["energy"]) + predictions["id"] = np.array(predictions["id"]) + self.save_results( + predictions, results_file, keys=["energy", "forces", "chunk_idx"] + ) + + if self.ema: + self.ema.restore() + + return predictions + + def update_best( + self, + primary_metric, + val_metrics, + disable_eval_tqdm=True, + ): + if ( + "mae" in primary_metric + and val_metrics[primary_metric]["metric"] < self.best_val_metric + ) or ( + "mae" not in primary_metric + and val_metrics[primary_metric]["metric"] > self.best_val_metric + ): + self.best_val_metric = val_metrics[primary_metric]["metric"] + self.save( + metrics=val_metrics, + checkpoint_file="best_checkpoint.pt", + training_state=False, + ) + if self.test_loader is not None: + self.predict( + self.test_loader, + results_file="predictions", + disable_tqdm=disable_eval_tqdm, + ) + + def train(self, disable_eval_tqdm=False): + ensure_fitted(self._unwrapped_model, warn=True) + + eval_every = self.config["optim"].get( + "eval_every", len(self.train_loader) + ) + checkpoint_every = self.config["optim"].get( + "checkpoint_every", eval_every + ) + primary_metric = self.config["task"]["primary_metric"] + # TODO: support for old naming conventions - is2re, s2ef, etc. + # primary_metric = self.config["task"].get( + # "primary_metric", self.evaluator.task_primary_metric[self.name] + # ) + if ( + not hasattr(self, "primary_metric") + or self.primary_metric != primary_metric + ): + self.best_val_metric = 1e9 if "mae" in primary_metric else -1.0 + else: + primary_metric = self.primary_metric + self.metrics = {} + + # Calculate start_epoch from step instead of loading the epoch number + # to prevent inconsistencies due to different batch size in checkpoint. + start_epoch = self.step // len(self.train_loader) + + for epoch_int in range( + start_epoch, self.config["optim"]["max_epochs"] + ): + self.train_sampler.set_epoch(epoch_int) + skip_steps = self.step % len(self.train_loader) + train_loader_iter = iter(self.train_loader) + + for i in range(skip_steps, len(self.train_loader)): + self.epoch = epoch_int + (i + 1) / len(self.train_loader) + self.step = epoch_int * len(self.train_loader) + i + 1 + self.model.train() + + # Get a batch. + batch = next(train_loader_iter) + + # Forward, loss, backward. + with torch.cuda.amp.autocast(enabled=self.scaler is not None): + out = self._forward(batch) + loss = self._compute_loss(out, batch) + loss = self.scaler.scale(loss) if self.scaler else loss + self._backward(loss) + scale = self.scaler.get_scale() if self.scaler else 1.0 + + # Compute metrics. + self.metrics = self._compute_metrics( + out, + batch, + self.evaluator, + self.metrics, + ) + self.metrics = self.evaluator.update( + "loss", loss.item() / scale, self.metrics + ) + + # Log metrics. + log_dict = {k: self.metrics[k]["metric"] for k in self.metrics} + log_dict.update( + { + "lr": self.scheduler.get_lr(), + "epoch": self.epoch, + "step": self.step, + } + ) + if ( + self.step % self.config["cmd"]["print_every"] == 0 + and distutils.is_master() + and not self.is_hpo + ): + log_str = [ + "{}: {:.2e}".format(k, v) for k, v in log_dict.items() + ] + logging.info(", ".join(log_str)) + self.metrics = {} + + if self.logger is not None: + self.logger.log( + log_dict, + step=self.step, + split="train", + ) + + if ( + checkpoint_every != -1 + and self.step % checkpoint_every == 0 + ): + self.save( + checkpoint_file="checkpoint.pt", training_state=True + ) + + # Evaluate on val set every `eval_every` iterations. + if self.step % eval_every == 0: + if self.val_loader is not None: + val_metrics = self.validate( + split="val", + disable_tqdm=disable_eval_tqdm, + ) + self.update_best( + primary_metric, + val_metrics, + disable_eval_tqdm=disable_eval_tqdm, + ) + if self.is_hpo: + self.hpo_update( + self.epoch, + self.step, + self.metrics, + val_metrics, + ) + + if self.config["task"].get("eval_relaxations", False): + if "relax_dataset" not in self.config["task"]: + logging.warning( + "Cannot evaluate relaxations, relax_dataset not specified" + ) + else: + self.run_relaxations() + + if self.scheduler.scheduler_type == "ReduceLROnPlateau": + if self.step % eval_every == 0: + self.scheduler.step( + metrics=val_metrics[primary_metric]["metric"], + ) + else: + self.scheduler.step() + + torch.cuda.empty_cache() + + if checkpoint_every == -1: + self.save(checkpoint_file="checkpoint.pt", training_state=True) + + self.train_dataset.close_db() + if self.config.get("val_dataset", False): + self.val_dataset.close_db() + if self.config.get("test_dataset", False): + self.test_dataset.close_db() + + def _forward(self, batch_list): + # forward pass. + return self.model(batch_list) + + def _compute_loss(self, out, batch_list): + natoms = torch.cat( + [batch.natoms.to(self.device) for batch in batch_list], dim=0 + ) + natoms = torch.repeat_interleave(natoms, natoms) + batch_size = natoms.numel() + + loss = [] + if self.config["task"].get("train_on_free_atoms", True): + fixed = torch.cat( + [batch.fixed.to(self.device) for batch in batch_list] + ) + mask = fixed == 0 + + for target_name in self.train_targets: + if "parent" not in self.train_targets[target_name]: + target = torch.cat( + [ + batch[target_name].to(self.device) + for batch in batch_list + ], + dim=0, + ) + # property is a decomposition of a higher order tensor + else: + irreps = self.train_targets[target_name]["irreps"] + if irreps > 2: + raise NotImplementedError + + target = [ + torch.einsum( + "ab, cb->ca", + change_mat.to(self.device), + batch[self.train_targets[target_name]["parent"]], + ) + for batch in batch_list + ] + + target = torch.cat( + [ + batch[ + :, + max(0, irreps_sum(irreps - 1)) : irreps_sum( + irreps + ), + ] + for batch in target + ], + dim=0, + ) + + pred = out[target_name] + + if ( + self.config["task"].get("train_on_free_atoms", True) + and self.train_targets[target_name].get("level", "system") + == "atom" + ): + target = target[mask] + pred = pred[mask] + natoms = natoms[mask] + + if self.normalizers.get(target_name, False): + target = self.normalizers[target_name].norm(target) + + mult = self.train_targets[target_name].get("coefficient", 1) + + loss.append( + mult + * self.loss_fn[target_name]( + pred, + target, + natoms=natoms, + batch_size=batch_size, + ) + ) + + # Sanity check to make sure the compute graph is correct. + for lc in loss: + assert hasattr(lc, "grad_fn") + + loss = sum(loss) + return loss + + def _compute_metrics(self, out, batch_list, evaluator, metrics={}): + natoms = torch.cat( + [batch.natoms.to(self.device) for batch in batch_list], dim=0 + ) + + if self.config["task"].get("eval_on_free_atoms", True): + fixed = torch.cat( + [batch.fixed.to(self.device) for batch in batch_list] + ) + mask = fixed == 0 + + s_idx = 0 + natoms_free = [] + for _natoms in natoms: + natoms_free.append( + torch.sum(mask[s_idx : s_idx + _natoms]).item() + ) + s_idx += _natoms + natoms = torch.LongTensor(natoms_free).to(self.device) + + targets = {} + for target_name in self.train_targets: + if "parent" not in self.train_targets[target_name]: + target = torch.cat( + [ + batch[target_name].to(self.device) + for batch in batch_list + ], + dim=0, + ) + else: + irreps = self.train_targets[target_name]["irreps"] + parent_target_name = self.train_targets[target_name]["parent"] + + if parent_target_name not in targets: + parent_target = torch.cat( + [ + batch[parent_target_name].to(self.device) + for batch in batch_list + ], + dim=0, + ) + targets[parent_target_name] = parent_target + + target = [ + torch.einsum( + "ab, cb->ca", + change_mat.to(self.device), + batch[parent_target_name], + ) + for batch in batch_list + ] + + target = torch.cat( + [ + batch[ + :, + max(0, irreps_sum(irreps - 1)) : irreps_sum( + irreps + ), + ] + for batch in target + ], + dim=0, + ) + + if ( + self.config["task"].get("eval_on_free_atoms", True) + and self.train_targets[target_name].get("level", "system") + == "atom" + ): + target = target[mask] + out[target_name] = out[target_name][mask] + + targets[target_name] = target + if self.normalizers.get(target_name, False): + out[target_name] = self.normalizers[target_name].denorm( + out[target_name] + ) + + targets["natoms"] = natoms + out["natoms"] = natoms + + metrics = evaluator.eval(out, targets, prev_metrics=metrics) + return metrics + + def run_relaxations(self, split="val"): + ensure_fitted(self._unwrapped_model) + + # When set to true, uses deterministic CUDA scatter ops, if available. + # https://pytorch.org/docs/stable/generated/torch.use_deterministic_algorithms.html#torch.use_deterministic_algorithms + # Only implemented for GemNet-OC currently. + registry.register( + "set_deterministic_scatter", + self.config["task"].get("set_deterministic_scatter", False), + ) + + logging.info("Running ML-relaxations") + self.model.eval() + if self.ema: + self.ema.store() + self.ema.copy_to() + + evaluator_is2rs, metrics_is2rs = Evaluator(task="is2rs"), {} + evaluator_is2re, metrics_is2re = Evaluator(task="is2re"), {} + + # Need both `pos_relaxed` and `y_relaxed` to compute val IS2R* metrics. + # Else just generate predictions. + if ( + hasattr(self.relax_dataset[0], "pos_relaxed") + and self.relax_dataset[0].pos_relaxed is not None + ) and ( + hasattr(self.relax_dataset[0], "y_relaxed") + and self.relax_dataset[0].y_relaxed is not None + ): + split = "val" + else: + split = "test" + + ids = [] + relaxed_positions = [] + chunk_idx = [] + for i, batch in tqdm( + enumerate(self.relax_loader), total=len(self.relax_loader) + ): + if i >= self.config["task"].get("num_relaxation_batches", 1e9): + break + + # If all traj files already exist, then skip this batch + if check_traj_files( + batch, self.config["task"]["relax_opt"].get("traj_dir", None) + ): + logging.info(f"Skipping batch: {batch[0].sid.tolist()}") + continue + + relaxed_batch = ml_relax( + batch=batch, + model=self, + steps=self.config["task"].get("relaxation_steps", 200), + fmax=self.config["task"].get("relaxation_fmax", 0.0), + relax_opt=self.config["task"]["relax_opt"], + save_full_traj=self.config["task"].get("save_full_traj", True), + device=self.device, + transform=None, + ) + + if self.config["task"].get("write_pos", False): + systemids = [str(i) for i in relaxed_batch.sid.tolist()] + natoms = relaxed_batch.natoms.tolist() + positions = torch.split(relaxed_batch.pos, natoms) + batch_relaxed_positions = [pos.tolist() for pos in positions] + + relaxed_positions += batch_relaxed_positions + chunk_idx += natoms + ids += systemids + + if split == "val": + mask = relaxed_batch.fixed == 0 + s_idx = 0 + natoms_free = [] + for natoms in relaxed_batch.natoms: + natoms_free.append( + torch.sum(mask[s_idx : s_idx + natoms]).item() + ) + s_idx += natoms + + target = { + "energy": relaxed_batch.y_relaxed, + "positions": relaxed_batch.pos_relaxed[mask], + "cell": relaxed_batch.cell, + "pbc": torch.tensor([True, True, True]), + "natoms": torch.LongTensor(natoms_free), + } + + prediction = { + "energy": relaxed_batch.y, + "positions": relaxed_batch.pos[mask], + "cell": relaxed_batch.cell, + "pbc": torch.tensor([True, True, True]), + "natoms": torch.LongTensor(natoms_free), + } + + metrics_is2rs = evaluator_is2rs.eval( + prediction, + target, + metrics_is2rs, + ) + metrics_is2re = evaluator_is2re.eval( + {"energy": prediction["energy"]}, + {"energy": target["energy"]}, + metrics_is2re, + ) + + if self.config["task"].get("write_pos", False): + rank = distutils.get_rank() + pos_filename = os.path.join( + self.config["cmd"]["results_dir"], f"relaxed_pos_{rank}.npz" + ) + np.savez_compressed( + pos_filename, + ids=ids, + pos=np.array(relaxed_positions, dtype=object), + chunk_idx=chunk_idx, + ) + + distutils.synchronize() + if distutils.is_master(): + gather_results = defaultdict(list) + full_path = os.path.join( + self.config["cmd"]["results_dir"], + "relaxed_positions.npz", + ) + + for i in range(distutils.get_world_size()): + rank_path = os.path.join( + self.config["cmd"]["results_dir"], + f"relaxed_pos_{i}.npz", + ) + rank_results = np.load(rank_path, allow_pickle=True) + gather_results["ids"].extend(rank_results["ids"]) + gather_results["pos"].extend(rank_results["pos"]) + gather_results["chunk_idx"].extend( + rank_results["chunk_idx"] + ) + os.remove(rank_path) + + # Because of how distributed sampler works, some system ids + # might be repeated to make no. of samples even across GPUs. + _, idx = np.unique(gather_results["ids"], return_index=True) + gather_results["ids"] = np.array(gather_results["ids"])[idx] + gather_results["pos"] = np.concatenate( + np.array(gather_results["pos"])[idx] + ) + gather_results["chunk_idx"] = np.cumsum( + np.array(gather_results["chunk_idx"])[idx] + )[ + :-1 + ] # np.split does not need last idx, assumes n-1:end + + logging.info(f"Writing results to {full_path}") + np.savez_compressed(full_path, **gather_results) + + if split == "val": + for task in ["is2rs", "is2re"]: + metrics = eval(f"metrics_{task}") + aggregated_metrics = {} + for k in metrics: + aggregated_metrics[k] = { + "total": distutils.all_reduce( + metrics[k]["total"], + average=False, + device=self.device, + ), + "numel": distutils.all_reduce( + metrics[k]["numel"], + average=False, + device=self.device, + ), + } + aggregated_metrics[k]["metric"] = ( + aggregated_metrics[k]["total"] + / aggregated_metrics[k]["numel"] + ) + metrics = aggregated_metrics + + # Make plots. + log_dict = { + f"{task}_{k}": metrics[k]["metric"] for k in metrics + } + if self.logger is not None: + self.logger.log( + log_dict, + step=self.step, + split=split, + ) + + if distutils.is_master(): + logging.info(metrics) + + if self.ema: + self.ema.restore() + + registry.unregister("set_deterministic_scatter") From 68afdeb5e950ccad2e42569c9b5fe4072047767b Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Mon, 10 Jul 2023 17:45:04 -0700 Subject: [PATCH 02/63] more general evaluator --- ocpmodels/modules/evaluator.py | 142 ++++++++++++++++----------------- 1 file changed, 67 insertions(+), 75 deletions(-) diff --git a/ocpmodels/modules/evaluator.py b/ocpmodels/modules/evaluator.py index 6eb97c4ab..4c66df8a7 100644 --- a/ocpmodels/modules/evaluator.py +++ b/ocpmodels/modules/evaluator.py @@ -33,44 +33,36 @@ class Evaluator: task_metrics = { - "s2ef": [ - "forcesx_mae", - "forcesy_mae", - "forcesz_mae", - "forces_mae", - "forces_cos", - "forces_magnitude", - "energy_mae", - "energy_force_within_threshold", - ], - "is2rs": [ - "average_distance_within_threshold", - "positions_mae", - "positions_mse", - ], - "is2re": ["energy_mae", "energy_mse", "energy_within_threshold"], - } - - metric_attributes = { - "forcesx_mae": ["forces"], - "forcesy_mae": ["forces"], - "forcesz_mae": ["forces"], - "forces_mae": ["forces"], - "forces_cos": ["forces"], - "forces_magnitude": ["forces"], - "energy_mae": ["energy"], - "energy_force_within_threshold": ["energy", "forces", "natoms"], - "energy_mse": ["energy"], - "energy_within_threshold": ["energy"], - "average_distance_within_threshold": [ - "positions", - "cell", - "pbc", - "natoms", - ], - "positions_mae": ["positions"], - "positions_mse": ["positions"], - "stress_mae": ["isotropic_stress", "anisotropic_stress"], + "s2ef": { + "energy": {"metrics": ["energy_mae"]}, + "forces": { + "metrics": [ + "forcesx_mae", + "forcesy_mae", + "forcesz_mae", + "forces_mae", + "forces_cos", + "forces_magnitude", + "energy_force_within_threshold", + ] + }, + }, + "is2rs": { + "positions": { + "metrics": [ + "average_distance_within_threshold", + "positions_mae", + "positions_mse", + ] + } + }, + "is2re": { + "metrics": [ + "energy_mae", + "energy_mse", + "energy_within_threshold", + ] + }, } task_primary_metric = { @@ -81,21 +73,27 @@ class Evaluator: def __init__(self, task: str = None, eval_metrics: str = None) -> None: self.task = task - self.metric_fns = self.task_metrics.get(task, eval_metrics) + self.target_metrics = self.task_metrics.get(task, eval_metrics) def eval(self, prediction, target, prev_metrics={}): - for metric in self.metric_fns: - for attr in self.metric_attributes.get(metric, {}): - assert attr in prediction - assert attr in target - assert prediction[attr].shape == target[attr].shape + # TODO: arbitrary type check + # for metric in self.metric_fns: + # assert attr in prediction + # assert attr in target + # assert prediction[attr].shape == target[attr].shape metrics = prev_metrics - for fn in self.metric_fns: - res = eval(fn)(prediction, target) - metrics = self.update(fn, res, metrics) + for target_property in self.target_metrics: + for fn in self.target_metrics[target_property]["metrics"]: + metric_name = ( + f"{target_property}_{fn}" + if target_property not in fn + else fn + ) + res = eval(fn)(prediction, target, target_property) + metrics = self.update(metric_name, res, metrics) return metrics @@ -127,38 +125,31 @@ def update(self, key, stat, metrics): return metrics -def energy_mae(prediction, target): - return mae(prediction["energy"], target["energy"]) - - -def energy_mse(prediction, target): - return mse(prediction["energy"], target["energy"]) - - -def forcesx_mae(prediction, target): +def forcesx_mae(prediction, target, key=None): return mae(prediction["forces"][:, 0], target["forces"][:, 0]) -def forcesx_mse(prediction, target): +def forcesx_mse(prediction, target, key=None): return mse(prediction["forces"][:, 0], target["forces"][:, 0]) -def forcesy_mae(prediction, target): +def forcesy_mae(prediction, target, key=None): return mae(prediction["forces"][:, 1], target["forces"][:, 1]) -def forcesy_mse(prediction, target): +def forcesy_mse(prediction, target, key=None): return mse(prediction["forces"][:, 1], target["forces"][:, 1]) -def forcesz_mae(prediction, target): +def forcesz_mae(prediction, target, key=None): return mae(prediction["forces"][:, 2], target["forces"][:, 2]) -def forcesz_mse(prediction, target): +def forcesz_mse(prediction, target, key=None): return mse(prediction["forces"][:, 2], target["forces"][:, 2]) +<<<<<<< HEAD def forces_mae(prediction, target): return mae(prediction["forces"], target["forces"]) @@ -184,7 +175,7 @@ def positions_mse(prediction, target): def energy_force_within_threshold( - prediction, target + prediction, target, key=None ) -> Dict[str, Union[float, int]]: # Note that this natoms should be the count of free atoms we evaluate over. assert target["natoms"].sum() == prediction["forces"].size(0) @@ -219,7 +210,7 @@ def energy_force_within_threshold( def energy_within_threshold( - prediction, target + prediction, target, key=None ) -> Dict[str, Union[float, int]]: # compute absolute error on energy per system. # then count the no. of systems where max energy error is < 0.02. @@ -237,7 +228,7 @@ def energy_within_threshold( def average_distance_within_threshold( - prediction, target + prediction, target, key=None ) -> Dict[str, Union[float, int]]: pred_pos = torch.split( prediction["positions"], prediction["natoms"].tolist() @@ -270,7 +261,7 @@ def average_distance_within_threshold( return {"metric": success / total, "total": success, "numel": total} -def stress_mae(prediction, target): +def stress_mae(prediction, target, key=None): device = prediction["isotropic_stress"].device cg_decomp_mat = change_mat.to(device) @@ -310,8 +301,8 @@ def min_diff(pred_pos, dft_pos, cell, pbc): return np.matmul(fractional, cell) -def cosine_similarity(prediction: torch.Tensor, target: torch.Tensor): - error = torch.cosine_similarity(prediction, target) +def cosine_similarity(prediction: dict, target: dict, key=slice(None)): + error = torch.cosine_similarity(prediction[key], target[key]) return { "metric": torch.mean(error).item(), "total": torch.sum(error).item(), @@ -320,33 +311,34 @@ def cosine_similarity(prediction: torch.Tensor, target: torch.Tensor): def mae( - prediction: dict, target: dict + prediction: dict, target: dict, key=slice(None) ) -> Dict[str, Union[float, int]]: - error = torch.abs(target - prediction) + error = torch.abs(target[key] - prediction[key]) return { "metric": torch.mean(error).item(), "total": torch.sum(error).item(), - "numel": prediction.numel(), + "numel": error.numel(), } def mse( - prediction: dict, target: dict + prediction: dict, target: dict, key=slice(None) ) -> Dict[str, Union[float, int]]: - error = (target - prediction) ** 2 + error = (target[key] - prediction[key]) ** 2 return { "metric": torch.mean(error).item(), "total": torch.sum(error).item(), - "numel": prediction.numel(), + "numel": error.numel(), } def magnitude_error( - prediction: torch.Tensor, target: torch.Tensor, p: int = 2 + prediction: dict, target: dict, key=slice(None), p: int = 2 ) -> Dict[str, Union[float, int]]: assert prediction.shape[1] > 1 error = torch.abs( - torch.norm(prediction, p=p, dim=-1) - torch.norm(target, p=p, dim=-1) + torch.norm(prediction[key], p=p, dim=-1) + - torch.norm(target[key], p=p, dim=-1) ) return { "metric": torch.mean(error).item(), From 3c62f4ac6771cfe4cb09dd74d35372b2870d5190 Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Mon, 10 Jul 2023 17:45:53 -0700 Subject: [PATCH 03/63] backwards tasks --- ocpmodels/common/utils.py | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/ocpmodels/common/utils.py b/ocpmodels/common/utils.py index 66b05f06a..50b0cda80 100644 --- a/ocpmodels/common/utils.py +++ b/ocpmodels/common/utils.py @@ -994,9 +994,16 @@ class _TrainingContext: gp_utils.setup_gp(config) try: setup_imports(config) - trainer_cls = registry.get_trainer_class( - config.get("trainer", "energy") - ) + trainer_name = config.get("trainer", "ocp") + # backwards compatibility for older configs + if trainer_name == "forces": + task_name = "s2ef" + elif trainer_name == "energy": + task_name = "is2re" + else: + task_name = "ocp" + + trainer_cls = registry.get_trainer_class(trainer_name) assert trainer_cls is not None, "Trainer not found" trainer = trainer_cls( task=config["task"], @@ -1015,6 +1022,7 @@ class _TrainingContext: cpu=config.get("cpu", False), slurm=config.get("slurm", {}), noddp=config.get("noddp", False), + name=task_name, ) task_cls = registry.get_task_class(config["mode"]) From 569375c3c35023d2f7cdf318173cf7b21b98a305 Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Mon, 10 Jul 2023 17:46:53 -0700 Subject: [PATCH 04/63] debug config --- configs/goc_single_debug.yml | 24 +++++++++++++++--------- 1 file changed, 15 insertions(+), 9 deletions(-) diff --git a/configs/goc_single_debug.yml b/configs/goc_single_debug.yml index d0ddacced..caca567e1 100644 --- a/configs/goc_single_debug.yml +++ b/configs/goc_single_debug.yml @@ -19,13 +19,19 @@ task: train_on_free_atoms: True eval_on_free_atoms: True - metrics: - - energy_mae - - energy_mse - - energy_within_threshold - - forces_mae - - forces_cos - - stress_mae + evaluation_metrics: + energy: + metrics: + - mae + - mse + - energy_within_threshold + forces: + metrics: + - mae + - cosine_similarity + stress: + metrics: + - stress_mae primary_metric: forces_mae @@ -119,8 +125,8 @@ model: qint_tags: [1, 2] optim: - batch_size: 1 - eval_batch_size: 1 + batch_size: 4 + eval_batch_size: 4 load_balancing: atoms eval_every: 5000 num_workers: 2 From 2e284cc0afff512ee8a560471d76a5459d3c6cca Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Tue, 11 Jul 2023 18:01:36 -0700 Subject: [PATCH 05/63] predict support, evaluator cleanup --- configs/goc_single_debug.yml | 30 +- ocpmodels/common/utils.py | 54 +-- ocpmodels/modules/evaluator.py | 4 +- ocpmodels/trainers/base_trainer.py | 607 +++++++++++++++++++++++++++-- ocpmodels/trainers/ocp_trainer.py | 500 +----------------------- 5 files changed, 621 insertions(+), 574 deletions(-) diff --git a/configs/goc_single_debug.yml b/configs/goc_single_debug.yml index caca567e1..cf12a638c 100644 --- a/configs/goc_single_debug.yml +++ b/configs/goc_single_debug.yml @@ -52,21 +52,21 @@ task: normalizer: stdev: 1.866159 stress: - isotropic_stress: - irreps: 0 - loss: mae - level: system - coefficient: 1 - normalizer: - mean: 43.27065 - stdev: 674.1657344451734 - anisotropic_stress: - irreps: 2 - loss: mae - level: system - coefficient: 1 - normalizer: - stdev: 143.72764771869745 + level: system + decomp: + isotropic_stress: + irreps: 0 + loss: mae + coefficient: 1 + normalizer: + mean: 43.27065 + stdev: 674.1657344451734 + anisotropic_stress: + irreps: 2 + loss: mae + coefficient: 1 + normalizer: + stdev: 143.72764771869745 model: name: gemnet_oc diff --git a/ocpmodels/common/utils.py b/ocpmodels/common/utils.py index 50b0cda80..d11262ee8 100644 --- a/ocpmodels/common/utils.py +++ b/ocpmodels/common/utils.py @@ -1131,29 +1131,37 @@ def scatter_det(*args, **kwargs): return out -change_mat = torch.tensor( - [ - [3 ** (-0.5), 0, 0, 0, 3 ** (-0.5), 0, 0, 0, 3 ** (-0.5)], - [0, 0, 0, 0, 0, 2 ** (-0.5), 0, -(2 ** (-0.5)), 0], - [0, 0, -(2 ** (-0.5)), 0, 0, 0, 2 ** (-0.5), 0, 0], - [0, 2 ** (-0.5), 0, -(2 ** (-0.5)), 0, 0, 0, 0, 0], - [0, 0, 0.5**0.5, 0, 0, 0, 0.5**0.5, 0, 0], - [0, 2 ** (-0.5), 0, 2 ** (-0.5), 0, 0, 0, 0, 0], - [ - -(6 ** (-0.5)), - 0, - 0, - 0, - 2 * 6 ** (-0.5), - 0, - 0, - 0, - -(6 ** (-0.5)), - ], - [0, 0, 0, 0, 0, 2 ** (-0.5), 0, 2 ** (-0.5), 0], - [-(2 ** (-0.5)), 0, 0, 0, 0, 0, 0, 0, 2 ** (-0.5)], - ] -).detach() +def cg_decomp_mat(l, device): + if l not in [2]: + raise NotImplementedError + + if l == 2: + change_mat = torch.tensor( + [ + [3 ** (-0.5), 0, 0, 0, 3 ** (-0.5), 0, 0, 0, 3 ** (-0.5)], + [0, 0, 0, 0, 0, 2 ** (-0.5), 0, -(2 ** (-0.5)), 0], + [0, 0, -(2 ** (-0.5)), 0, 0, 0, 2 ** (-0.5), 0, 0], + [0, 2 ** (-0.5), 0, -(2 ** (-0.5)), 0, 0, 0, 0, 0], + [0, 0, 0.5**0.5, 0, 0, 0, 0.5**0.5, 0, 0], + [0, 2 ** (-0.5), 0, 2 ** (-0.5), 0, 0, 0, 0, 0], + [ + -(6 ** (-0.5)), + 0, + 0, + 0, + 2 * 6 ** (-0.5), + 0, + 0, + 0, + -(6 ** (-0.5)), + ], + [0, 0, 0, 0, 0, 2 ** (-0.5), 0, 2 ** (-0.5), 0], + [-(2 ** (-0.5)), 0, 0, 0, 0, 0, 0, 0, 2 ** (-0.5)], + ], + device=device, + ).detach() + + return change_mat def irreps_sum(l): diff --git a/ocpmodels/modules/evaluator.py b/ocpmodels/modules/evaluator.py index 4c66df8a7..bdfeb0866 100644 --- a/ocpmodels/modules/evaluator.py +++ b/ocpmodels/modules/evaluator.py @@ -9,7 +9,7 @@ import torch from typing import Dict, Union -from ocpmodels.common.utils import change_mat +from ocpmodels.common.utils import cg_decomp_mat """ An evaluation module for use with the OCP dataset and suite of tasks. It should @@ -263,7 +263,7 @@ def average_distance_within_threshold( def stress_mae(prediction, target, key=None): device = prediction["isotropic_stress"].device - cg_decomp_mat = change_mat.to(device) + cg_decomp_mat = cg_decomp_mat(2, device) zero_vectors = torch.zeros( (prediction["isotropic_stress"].shape[0], 3), diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index bd56b6b8b..e98dd1d4b 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -18,6 +18,7 @@ import torch import torch.nn as nn import torch.optim as optim +import torch_geometric import yaml from torch.nn.parallel.distributed import DistributedDataParallel from torch.utils.data import DataLoader @@ -32,7 +33,13 @@ ) from ocpmodels.common.registry import registry from ocpmodels.common.typing import assert_is_instance -from ocpmodels.common.utils import load_state_dict, save_checkpoint +from ocpmodels.common.utils import ( + cg_decomp_mat, + check_traj_files, + irreps_sum, + load_state_dict, + save_checkpoint, +) from ocpmodels.modules.evaluator import Evaluator from ocpmodels.modules.exponential_moving_average import ( ExponentialMovingAverage, @@ -46,13 +53,6 @@ @registry.register_trainer("base") class BaseTrainer(ABC): - @property - def _unwrapped_model(self): - module = self.model - while isinstance(module, (OCPDataParallel, DistributedDataParallel)): - module = module.module - return module - def __init__( self, task, @@ -71,7 +71,7 @@ def __init__( local_rank: int = 0, amp: bool = False, cpu: bool = False, - name: str = "base_trainer", + name: str = "ocp", slurm={}, noddp: bool = False, ) -> None: @@ -201,8 +201,10 @@ def __init__( print(yaml.dump(self.config, default_flow_style=False)) self.load() + # TODO: asserts for targets+evaluation config definitions self.evaluator = Evaluator( - task=name, eval_metrics=self.config["task"].get("metrics", None) + task=name, + eval_metrics=self.config["task"].get("evaluation_metrics", None), ) def load(self) -> None: @@ -354,9 +356,37 @@ def load_datasets(self) -> None: self.relax_sampler, ) - @abstractmethod def load_task(self): - """Initialize task-specific information. Derived classes should implement this function.""" + self.targets = self.config["task"]["targets"] + self.num_targets = 1 + + self.train_targets = {} + for target in self.targets: + if "decomp" in self.targets[target]: + for subtarget in self.targets[target]["decomp"]: + self.train_targets[subtarget] = self.targets[target][ + "decomp" + ][subtarget] + self.train_targets[subtarget]["parent"] = target + self.train_targets[subtarget]["level"] = self.targets[ + target + ].get("level", "system") + else: + self.train_targets[target] = self.targets[target] + + # Normalizer for the dataset. + # Default - no normalization + self.normalizers = {} + for target in self.train_targets: + self.normalizers[target] = Normalizer( + mean=self.train_targets.get("mean", 0), + std=self.train_targets.get("std", 1), + device=self.device, + ) + + self.eval_metrics = self.config["task"].get("evaluation_metrics", {}) + + assert len(self.eval_metrics.keys() - self.targets.keys()) == 0 def load_model(self) -> None: # Build model @@ -400,6 +430,13 @@ def load_model(self) -> None: self.model, device_ids=[self.device] ) + @property + def _unwrapped_model(self): + module = self.model + while isinstance(module, (OCPDataParallel, DistributedDataParallel)): + module = module.module + return module + def load_checkpoint(self, checkpoint_path: str) -> None: if not os.path.isfile(checkpoint_path): raise FileNotFoundError( @@ -633,9 +670,347 @@ def hpo_update( test_metrics=test_metrics, ) - @abstractmethod - def train(self): - """Derived classes should implement this function.""" + def update_best( + self, + primary_metric, + val_metrics, + disable_eval_tqdm=True, + ): + if ( + "mae" in primary_metric + and val_metrics[primary_metric]["metric"] < self.best_val_metric + ) or ( + "mae" not in primary_metric + and val_metrics[primary_metric]["metric"] > self.best_val_metric + ): + self.best_val_metric = val_metrics[primary_metric]["metric"] + self.save( + metrics=val_metrics, + checkpoint_file="best_checkpoint.pt", + training_state=False, + ) + if self.test_loader is not None: + self.predict( + self.test_loader, + results_file="predictions", + disable_tqdm=disable_eval_tqdm, + ) + + def train(self, disable_eval_tqdm=False): + ensure_fitted(self._unwrapped_model, warn=True) + + eval_every = self.config["optim"].get( + "eval_every", len(self.train_loader) + ) + checkpoint_every = self.config["optim"].get( + "checkpoint_every", eval_every + ) + primary_metric = self.config["task"]["primary_metric"] + # TODO: support for old naming conventions - is2re, s2ef, etc. + # primary_metric = self.config["task"].get( + # "primary_metric", self.evaluator.task_primary_metric[self.name] + # ) + if ( + not hasattr(self, "primary_metric") + or self.primary_metric != primary_metric + ): + self.best_val_metric = 1e9 if "mae" in primary_metric else -1.0 + else: + primary_metric = self.primary_metric + self.metrics = {} + + # Calculate start_epoch from step instead of loading the epoch number + # to prevent inconsistencies due to different batch size in checkpoint. + start_epoch = self.step // len(self.train_loader) + + for epoch_int in range( + start_epoch, self.config["optim"]["max_epochs"] + ): + self.train_sampler.set_epoch(epoch_int) + skip_steps = self.step % len(self.train_loader) + train_loader_iter = iter(self.train_loader) + + for i in range(skip_steps, len(self.train_loader)): + self.epoch = epoch_int + (i + 1) / len(self.train_loader) + self.step = epoch_int * len(self.train_loader) + i + 1 + self.model.train() + + # Get a batch. + batch = next(train_loader_iter) + + # Forward, loss, backward. + with torch.cuda.amp.autocast(enabled=self.scaler is not None): + out = self._forward(batch) + loss = self._compute_loss(out, batch) + loss = self.scaler.scale(loss) if self.scaler else loss + self._backward(loss) + scale = self.scaler.get_scale() if self.scaler else 1.0 + + # Compute metrics. + self.metrics = self._compute_metrics( + out, + batch, + self.evaluator, + self.metrics, + ) + self.metrics = self.evaluator.update( + "loss", loss.item() / scale, self.metrics + ) + + # Log metrics. + log_dict = {k: self.metrics[k]["metric"] for k in self.metrics} + log_dict.update( + { + "lr": self.scheduler.get_lr(), + "epoch": self.epoch, + "step": self.step, + } + ) + if ( + self.step % self.config["cmd"]["print_every"] == 0 + and distutils.is_master() + and not self.is_hpo + ): + log_str = [ + "{}: {:.2e}".format(k, v) for k, v in log_dict.items() + ] + logging.info(", ".join(log_str)) + self.metrics = {} + + if self.logger is not None: + self.logger.log( + log_dict, + step=self.step, + split="train", + ) + + if ( + checkpoint_every != -1 + and self.step % checkpoint_every == 0 + ): + self.save( + checkpoint_file="checkpoint.pt", training_state=True + ) + + # Evaluate on val set every `eval_every` iterations. + if self.step % eval_every == 0: + if self.val_loader is not None: + val_metrics = self.validate( + split="val", + disable_tqdm=disable_eval_tqdm, + ) + self.update_best( + primary_metric, + val_metrics, + disable_eval_tqdm=disable_eval_tqdm, + ) + if self.is_hpo: + self.hpo_update( + self.epoch, + self.step, + self.metrics, + val_metrics, + ) + + if self.config["task"].get("eval_relaxations", False): + if "relax_dataset" not in self.config["task"]: + logging.warning( + "Cannot evaluate relaxations, relax_dataset not specified" + ) + else: + self.run_relaxations() + + if self.scheduler.scheduler_type == "ReduceLROnPlateau": + if self.step % eval_every == 0: + self.scheduler.step( + metrics=val_metrics[primary_metric]["metric"], + ) + else: + self.scheduler.step() + + torch.cuda.empty_cache() + + if checkpoint_every == -1: + self.save(checkpoint_file="checkpoint.pt", training_state=True) + + self.train_dataset.close_db() + if self.config.get("val_dataset", False): + self.val_dataset.close_db() + if self.config.get("test_dataset", False): + self.test_dataset.close_db() + + def _forward(self, batch_list): + return self.model(batch_list) + + def _compute_loss(self, out, batch_list): + natoms = torch.cat( + [batch.natoms.to(self.device) for batch in batch_list], dim=0 + ) + natoms = torch.repeat_interleave(natoms, natoms) + batch_size = natoms.numel() + + loss = [] + if self.config["task"].get("train_on_free_atoms", True): + fixed = torch.cat( + [batch.fixed.to(self.device) for batch in batch_list] + ) + mask = fixed == 0 + + for target_name in self.train_targets: + if "parent" not in self.train_targets[target_name]: + target = torch.cat( + [ + batch[target_name].to(self.device) + for batch in batch_list + ], + dim=0, + ) + # property is a decomposition of a higher order tensor + else: + irreps = self.train_targets[target_name]["irreps"] + if irreps > 2: + raise NotImplementedError + + target = [ + torch.einsum( + "ab, cb->ca", + cg_decomp_mat(2).to(self.device), + batch[self.train_targets[target_name]["parent"]], + ) + for batch in batch_list + ] + + target = torch.cat( + [ + batch[ + :, + max(0, irreps_sum(irreps - 1)) : irreps_sum( + irreps + ), + ] + for batch in target + ], + dim=0, + ) + + pred = out[target_name] + + if ( + self.config["task"].get("train_on_free_atoms", True) + and self.train_targets[target_name].get("level", "system") + == "atom" + ): + target = target[mask] + pred = pred[mask] + natoms = natoms[mask] + + if self.normalizers.get(target_name, False): + target = self.normalizers[target_name].norm(target) + + mult = self.train_targets[target_name].get("coefficient", 1) + + loss.append( + mult + * self.loss_fn[target_name]( + pred, + target, + natoms=natoms, + batch_size=batch_size, + ) + ) + + # Sanity check to make sure the compute graph is correct. + for lc in loss: + assert hasattr(lc, "grad_fn") + + loss = sum(loss) + return loss + + def _compute_metrics(self, out, batch_list, evaluator, metrics={}): + natoms = torch.cat( + [batch.natoms.to(self.device) for batch in batch_list], dim=0 + ) + + if self.config["task"].get("eval_on_free_atoms", True): + fixed = torch.cat( + [batch.fixed.to(self.device) for batch in batch_list] + ) + mask = fixed == 0 + + s_idx = 0 + natoms_free = [] + for _natoms in natoms: + natoms_free.append( + torch.sum(mask[s_idx : s_idx + _natoms]).item() + ) + s_idx += _natoms + natoms = torch.LongTensor(natoms_free).to(self.device) + + targets = {} + for target_name in self.train_targets: + if "parent" not in self.train_targets[target_name]: + target = torch.cat( + [ + batch[target_name].to(self.device) + for batch in batch_list + ], + dim=0, + ) + else: + irreps = self.train_targets[target_name]["irreps"] + parent_target_name = self.train_targets[target_name]["parent"] + + if parent_target_name not in targets: + parent_target = torch.cat( + [ + batch[parent_target_name].to(self.device) + for batch in batch_list + ], + dim=0, + ) + targets[parent_target_name] = parent_target + + target = [ + torch.einsum( + "ab, cb->ca", + cg_decomp_mat(2).to(self.device), + batch[parent_target_name], + ) + for batch in batch_list + ] + + target = torch.cat( + [ + batch[ + :, + max(0, irreps_sum(irreps - 1)) : irreps_sum( + irreps + ), + ] + for batch in target + ], + dim=0, + ) + + if ( + self.config["task"].get("eval_on_free_atoms", True) + and self.train_targets[target_name].get("level", "system") + == "atom" + ): + target = target[mask] + out[target_name] = out[target_name][mask] + + targets[target_name] = target + if self.normalizers.get(target_name, False): + out[target_name] = self.normalizers[target_name].denorm( + out[target_name] + ) + + targets["natoms"] = natoms + out["natoms"] = natoms + + metrics = evaluator.eval(out, targets, prev_metrics=metrics) + return metrics @torch.no_grad() def validate(self, split: str = "val", disable_tqdm: bool = False): @@ -651,12 +1026,10 @@ def validate(self, split: str = "val", disable_tqdm: bool = False): self.ema.store() self.ema.copy_to() - evaluator, metrics = ( - Evaluator( - task=self.name, - eval_metrics=self.config["task"].get("metrics", None), - ), - {}, + metrics = {} + evaluator = Evaluator( + task=self.name, + eval_metrics=self.config["task"].get("evaluation_metrics", None), ) rank = distutils.get_rank() @@ -713,14 +1086,6 @@ def validate(self, split: str = "val", disable_tqdm: bool = False): return metrics - @abstractmethod - def _forward(self, batch_list): - """Derived classes should implement this function.""" - - @abstractmethod - def _compute_loss(self, out, batch_list): - """Derived classes should implement this function.""" - def _backward(self, loss) -> None: self.optimizer.zero_grad() loss.backward() @@ -756,11 +1121,180 @@ def _backward(self, loss) -> None: if self.ema: self.ema.update() + # Takes in a new data source and generates predictions on it. + @torch.no_grad() + def predict( + self, + data_loader, + per_image=True, + results_file=None, + disable_tqdm=False, + ): + ensure_fitted(self._unwrapped_model, warn=True) + + if distutils.is_master() and not disable_tqdm: + logging.info("Predicting on test.") + assert isinstance( + data_loader, + ( + torch.utils.data.dataloader.DataLoader, + torch_geometric.data.Batch, + ), + ) + rank = distutils.get_rank() + + if isinstance(data_loader, torch_geometric.data.Batch): + data_loader = [[data_loader]] + + self.model.eval() + if self.ema: + self.ema.store() + self.ema.copy_to() + + predictions = defaultdict(list) + + for i, batch_list in tqdm( + enumerate(data_loader), + total=len(data_loader), + position=rank, + desc="device {}".format(rank), + disable=disable_tqdm, + ): + batch_size = batch_list[0].natoms.numel() + + ### Get unique system identifiers + sids = batch_list[0].sid.tolist() + ## Support naming structure for OC20 S2EF + if "fid" in batch_list[0]: + fids = batch_list[0].fid.tolist() + systemids = [f"{sid}_{fid}" for sid, fid in zip(sids, fids)] + else: + systemids = [f"{sid}" for sid in sids] + + predictions["ids"].extend(systemids) + + with torch.cuda.amp.autocast(enabled=self.scaler is not None): + out = self._forward(batch_list) + + for target_key in self.targets: + ### Target property is a direct output of the model + if target_key in self.train_targets: + pred = out[target_key] + ### Denormalize predictions if needed + if self.normalizers.get(target_key, False): + pred = self.normalizers[target_key].denorm(pred) + ## Target property is a derived output of the model + else: + _max_rank = 0 + for subtarget_key in self.targets[target_key]["decomp"]: + _max_rank = max( + _max_rank, + self.train_targets[subtarget_key]["irreps"], + ) + + pred_irreps = torch.zeros( + (batch_size, irreps_sum(_max_rank)), device=self.device + ) + + for subtarget_key in self.targets[target_key]["decomp"]: + irreps = self.train_targets[subtarget_key]["irreps"] + _pred = out[subtarget_key] + + ### Denormalize predictions if needed + if self.normalizers.get(subtarget_key, False): + _pred = self.normalizers[subtarget_key].denorm( + _pred + ) + + ## Fill in the corresponding irreps prediction + pred_irreps[ + :, + max(0, irreps_sum(irreps - 1)) : irreps_sum( + irreps + ), + ] = _pred + + pred = torch.einsum( + "ba, cb->ca", + cg_decomp_mat(_max_rank, self.device), + pred_irreps, + ) + + ### Save outputs in desired precision, default float16 + if ( + self.targets[target_key].get("prediction_dtype", "float16") + == "float32" + or self.config["task"].get("prediction_dtype", "float16") + == "float32" + or self.config["task"]["dataset"] == "oc22_lmdb" + ): + dtype = torch.float32 + else: + dtype = torch.float16 + + pred = pred.cpu().detach().to(dtype) + + ### Split predictions into per-image predictions + if self.targets[target_key].get("level", "system") == "atom": + batch_natoms = torch.cat( + [batch.natoms for batch in batch_list] + ) + batch_fixed = torch.cat( + [batch.fixed for batch in batch_list] + ) + per_image_pred = torch.split(pred, batch_natoms.tolist()) + + ### Save out only free atom, EvalAI does not need fixed atoms + _per_image_fixed = torch.split( + batch_fixed, batch_natoms.tolist() + ) + _per_image_free_preds = [ + _pred[(fixed == 0).tolist()].numpy() + for _pred, fixed in zip( + per_image_pred, _per_image_fixed + ) + ] + _chunk_idx = np.array( + [ + free_pred.shape[0] + for free_pred in _per_image_free_preds + ] + ) + per_image_pred = _per_image_free_preds + ### Assumes system level properties are of the same dimension + else: + per_image_pred = pred.numpy() + _chunk_idx = None + + predictions[f"{target_key}"].extend(per_image_pred) + ### Backwards compatibility, retain 'chunk_idx' for forces. + if _chunk_idx is not None: + if target_key == "forces": + predictions["chunk_idx"].extend(_chunk_idx) + else: + predictions[f"{target_key}_chunk_idx"].extend( + _chunk_idx + ) + + for key in predictions: + predictions[key] = np.array(predictions[key]) + + self.save_results(predictions, results_file) + # TODO relaxation support + + if self.ema: + self.ema.restore() + + return predictions + def save_results( self, predictions, results_file: Optional[str], keys ) -> None: + if results_file is None: return + if keys is None: + keys = predictions.keys() results_file_path = os.path.join( self.config["cmd"]["results_dir"], @@ -768,7 +1302,6 @@ def save_results( ) np.savez_compressed( results_file_path, - ids=predictions["id"], **{key: predictions[key] for key in keys}, ) @@ -794,18 +1327,18 @@ def save_results( # Because of how distributed sampler works, some system ids # might be repeated to make no. of samples even across GPUs. _, idx = np.unique(gather_results["ids"], return_index=True) - gather_results["ids"] = np.array(gather_results["ids"])[idx] for k in keys: - if k == "forces": - gather_results[k] = np.concatenate( - np.array(gather_results[k])[idx] - ) - elif k == "chunk_idx": + if "chunk_idx" in k: gather_results[k] = np.cumsum( np.array(gather_results[k])[idx] )[:-1] else: - gather_results[k] = np.array(gather_results[k])[idx] + if f"{k}_chunk_idx" in keys or k == "forces": + gather_results[k] = np.concatenate( + np.array(gather_results[k])[idx] + ) + else: + gather_results[k] = np.array(gather_results[k])[idx] logging.info(f"Writing results to {full_path}") np.savez_compressed(full_path, **gather_results) diff --git a/ocpmodels/trainers/ocp_trainer.py b/ocpmodels/trainers/ocp_trainer.py index 490a841e8..3a73e878f 100644 --- a/ocpmodels/trainers/ocp_trainer.py +++ b/ocpmodels/trainers/ocp_trainer.py @@ -19,7 +19,7 @@ from ocpmodels.common import distutils from ocpmodels.common.registry import registry from ocpmodels.common.relaxation.ml_relaxation import ml_relax -from ocpmodels.common.utils import change_mat, check_traj_files, irreps_sum +from ocpmodels.common.utils import cg_decomp_mat, check_traj_files, irreps_sum from ocpmodels.modules.evaluator import Evaluator from ocpmodels.modules.normalizer import Normalizer from ocpmodels.modules.scaling.util import ensure_fitted @@ -84,6 +84,7 @@ def __init__( cpu=False, slurm={}, noddp=False, + name="ocp", ): super().__init__( task=task, @@ -104,504 +105,9 @@ def __init__( cpu=cpu, slurm=slurm, noddp=noddp, + name=name, ) - def load_task(self): - self.targets = self.config["task"]["targets"] - self.num_targets = 1 - - self.train_targets = {} - for target in self.targets: - if "irreps" in self.targets[target]: - self.train_targets[target] = self.targets[target] - else: - for subtarget in self.targets[target]: - self.train_targets[subtarget] = self.targets[target][ - subtarget - ] - self.train_targets[subtarget]["parent"] = target - - # Normalizer for the dataset. - self.normalizers = {} - for target in self.train_targets: - self.normalizers[target] = Normalizer( - mean=self.train_targets.get("mean", 0), - std=self.train_targets.get("std", 1), - device=self.device, - ) - - self.eval_metrics = self.config["task"]["metrics"] - - # assert len(self.targets.keys() - self.eval_metrics.keys()) == 0 - - # Takes in a new data source and generates predictions on it. - @torch.no_grad() - def predict( - self, - data_loader, - per_image=True, - results_file=None, - disable_tqdm=False, - ): - ensure_fitted(self._unwrapped_model, warn=True) - - if distutils.is_master() and not disable_tqdm: - logging.info("Predicting on test.") - assert isinstance( - data_loader, - ( - torch.utils.data.dataloader.DataLoader, - torch_geometric.data.Batch, - ), - ) - rank = distutils.get_rank() - - if isinstance(data_loader, torch_geometric.data.Batch): - data_loader = [[data_loader]] - - self.model.eval() - if self.ema: - self.ema.store() - self.ema.copy_to() - - if self.normalizers is not None and "target" in self.normalizers: - self.normalizers["target"].to(self.device) - self.normalizers["grad_target"].to(self.device) - - predictions = {"id": [], "energy": [], "forces": [], "chunk_idx": []} - - for i, batch_list in tqdm( - enumerate(data_loader), - total=len(data_loader), - position=rank, - desc="device {}".format(rank), - disable=disable_tqdm, - ): - with torch.cuda.amp.autocast(enabled=self.scaler is not None): - out = self._forward(batch_list) - - if self.normalizers is not None and "target" in self.normalizers: - out["energy"] = self.normalizers["target"].denorm( - out["energy"] - ) - out["forces"] = self.normalizers["grad_target"].denorm( - out["forces"] - ) - if per_image: - systemids = [ - str(i) + "_" + str(j) - for i, j in zip( - batch_list[0].sid.tolist(), batch_list[0].fid.tolist() - ) - ] - predictions["id"].extend(systemids) - batch_natoms = torch.cat( - [batch.natoms for batch in batch_list] - ) - batch_fixed = torch.cat([batch.fixed for batch in batch_list]) - # total energy target requires predictions to be saved in float32 - # default is float16 - if ( - self.config["task"].get("prediction_dtype", "float16") - == "float32" - or self.config["task"]["dataset"] == "oc22_lmdb" - ): - predictions["energy"].extend( - out["energy"].cpu().detach().to(torch.float32).numpy() - ) - forces = out["forces"].cpu().detach().to(torch.float32) - else: - predictions["energy"].extend( - out["energy"].cpu().detach().to(torch.float16).numpy() - ) - forces = out["forces"].cpu().detach().to(torch.float16) - per_image_forces = torch.split(forces, batch_natoms.tolist()) - per_image_forces = [ - force.numpy() for force in per_image_forces - ] - # evalAI only requires forces on free atoms - if results_file is not None: - _per_image_fixed = torch.split( - batch_fixed, batch_natoms.tolist() - ) - _per_image_free_forces = [ - force[(fixed == 0).tolist()] - for force, fixed in zip( - per_image_forces, _per_image_fixed - ) - ] - _chunk_idx = np.array( - [ - free_force.shape[0] - for free_force in _per_image_free_forces - ] - ) - per_image_forces = _per_image_free_forces - predictions["chunk_idx"].extend(_chunk_idx) - predictions["forces"].extend(per_image_forces) - else: - predictions["energy"] = out["energy"].detach() - predictions["forces"] = out["forces"].detach() - if self.ema: - self.ema.restore() - return predictions - - predictions["forces"] = np.array(predictions["forces"]) - predictions["chunk_idx"] = np.array(predictions["chunk_idx"]) - predictions["energy"] = np.array(predictions["energy"]) - predictions["id"] = np.array(predictions["id"]) - self.save_results( - predictions, results_file, keys=["energy", "forces", "chunk_idx"] - ) - - if self.ema: - self.ema.restore() - - return predictions - - def update_best( - self, - primary_metric, - val_metrics, - disable_eval_tqdm=True, - ): - if ( - "mae" in primary_metric - and val_metrics[primary_metric]["metric"] < self.best_val_metric - ) or ( - "mae" not in primary_metric - and val_metrics[primary_metric]["metric"] > self.best_val_metric - ): - self.best_val_metric = val_metrics[primary_metric]["metric"] - self.save( - metrics=val_metrics, - checkpoint_file="best_checkpoint.pt", - training_state=False, - ) - if self.test_loader is not None: - self.predict( - self.test_loader, - results_file="predictions", - disable_tqdm=disable_eval_tqdm, - ) - - def train(self, disable_eval_tqdm=False): - ensure_fitted(self._unwrapped_model, warn=True) - - eval_every = self.config["optim"].get( - "eval_every", len(self.train_loader) - ) - checkpoint_every = self.config["optim"].get( - "checkpoint_every", eval_every - ) - primary_metric = self.config["task"]["primary_metric"] - # TODO: support for old naming conventions - is2re, s2ef, etc. - # primary_metric = self.config["task"].get( - # "primary_metric", self.evaluator.task_primary_metric[self.name] - # ) - if ( - not hasattr(self, "primary_metric") - or self.primary_metric != primary_metric - ): - self.best_val_metric = 1e9 if "mae" in primary_metric else -1.0 - else: - primary_metric = self.primary_metric - self.metrics = {} - - # Calculate start_epoch from step instead of loading the epoch number - # to prevent inconsistencies due to different batch size in checkpoint. - start_epoch = self.step // len(self.train_loader) - - for epoch_int in range( - start_epoch, self.config["optim"]["max_epochs"] - ): - self.train_sampler.set_epoch(epoch_int) - skip_steps = self.step % len(self.train_loader) - train_loader_iter = iter(self.train_loader) - - for i in range(skip_steps, len(self.train_loader)): - self.epoch = epoch_int + (i + 1) / len(self.train_loader) - self.step = epoch_int * len(self.train_loader) + i + 1 - self.model.train() - - # Get a batch. - batch = next(train_loader_iter) - - # Forward, loss, backward. - with torch.cuda.amp.autocast(enabled=self.scaler is not None): - out = self._forward(batch) - loss = self._compute_loss(out, batch) - loss = self.scaler.scale(loss) if self.scaler else loss - self._backward(loss) - scale = self.scaler.get_scale() if self.scaler else 1.0 - - # Compute metrics. - self.metrics = self._compute_metrics( - out, - batch, - self.evaluator, - self.metrics, - ) - self.metrics = self.evaluator.update( - "loss", loss.item() / scale, self.metrics - ) - - # Log metrics. - log_dict = {k: self.metrics[k]["metric"] for k in self.metrics} - log_dict.update( - { - "lr": self.scheduler.get_lr(), - "epoch": self.epoch, - "step": self.step, - } - ) - if ( - self.step % self.config["cmd"]["print_every"] == 0 - and distutils.is_master() - and not self.is_hpo - ): - log_str = [ - "{}: {:.2e}".format(k, v) for k, v in log_dict.items() - ] - logging.info(", ".join(log_str)) - self.metrics = {} - - if self.logger is not None: - self.logger.log( - log_dict, - step=self.step, - split="train", - ) - - if ( - checkpoint_every != -1 - and self.step % checkpoint_every == 0 - ): - self.save( - checkpoint_file="checkpoint.pt", training_state=True - ) - - # Evaluate on val set every `eval_every` iterations. - if self.step % eval_every == 0: - if self.val_loader is not None: - val_metrics = self.validate( - split="val", - disable_tqdm=disable_eval_tqdm, - ) - self.update_best( - primary_metric, - val_metrics, - disable_eval_tqdm=disable_eval_tqdm, - ) - if self.is_hpo: - self.hpo_update( - self.epoch, - self.step, - self.metrics, - val_metrics, - ) - - if self.config["task"].get("eval_relaxations", False): - if "relax_dataset" not in self.config["task"]: - logging.warning( - "Cannot evaluate relaxations, relax_dataset not specified" - ) - else: - self.run_relaxations() - - if self.scheduler.scheduler_type == "ReduceLROnPlateau": - if self.step % eval_every == 0: - self.scheduler.step( - metrics=val_metrics[primary_metric]["metric"], - ) - else: - self.scheduler.step() - - torch.cuda.empty_cache() - - if checkpoint_every == -1: - self.save(checkpoint_file="checkpoint.pt", training_state=True) - - self.train_dataset.close_db() - if self.config.get("val_dataset", False): - self.val_dataset.close_db() - if self.config.get("test_dataset", False): - self.test_dataset.close_db() - - def _forward(self, batch_list): - # forward pass. - return self.model(batch_list) - - def _compute_loss(self, out, batch_list): - natoms = torch.cat( - [batch.natoms.to(self.device) for batch in batch_list], dim=0 - ) - natoms = torch.repeat_interleave(natoms, natoms) - batch_size = natoms.numel() - - loss = [] - if self.config["task"].get("train_on_free_atoms", True): - fixed = torch.cat( - [batch.fixed.to(self.device) for batch in batch_list] - ) - mask = fixed == 0 - - for target_name in self.train_targets: - if "parent" not in self.train_targets[target_name]: - target = torch.cat( - [ - batch[target_name].to(self.device) - for batch in batch_list - ], - dim=0, - ) - # property is a decomposition of a higher order tensor - else: - irreps = self.train_targets[target_name]["irreps"] - if irreps > 2: - raise NotImplementedError - - target = [ - torch.einsum( - "ab, cb->ca", - change_mat.to(self.device), - batch[self.train_targets[target_name]["parent"]], - ) - for batch in batch_list - ] - - target = torch.cat( - [ - batch[ - :, - max(0, irreps_sum(irreps - 1)) : irreps_sum( - irreps - ), - ] - for batch in target - ], - dim=0, - ) - - pred = out[target_name] - - if ( - self.config["task"].get("train_on_free_atoms", True) - and self.train_targets[target_name].get("level", "system") - == "atom" - ): - target = target[mask] - pred = pred[mask] - natoms = natoms[mask] - - if self.normalizers.get(target_name, False): - target = self.normalizers[target_name].norm(target) - - mult = self.train_targets[target_name].get("coefficient", 1) - - loss.append( - mult - * self.loss_fn[target_name]( - pred, - target, - natoms=natoms, - batch_size=batch_size, - ) - ) - - # Sanity check to make sure the compute graph is correct. - for lc in loss: - assert hasattr(lc, "grad_fn") - - loss = sum(loss) - return loss - - def _compute_metrics(self, out, batch_list, evaluator, metrics={}): - natoms = torch.cat( - [batch.natoms.to(self.device) for batch in batch_list], dim=0 - ) - - if self.config["task"].get("eval_on_free_atoms", True): - fixed = torch.cat( - [batch.fixed.to(self.device) for batch in batch_list] - ) - mask = fixed == 0 - - s_idx = 0 - natoms_free = [] - for _natoms in natoms: - natoms_free.append( - torch.sum(mask[s_idx : s_idx + _natoms]).item() - ) - s_idx += _natoms - natoms = torch.LongTensor(natoms_free).to(self.device) - - targets = {} - for target_name in self.train_targets: - if "parent" not in self.train_targets[target_name]: - target = torch.cat( - [ - batch[target_name].to(self.device) - for batch in batch_list - ], - dim=0, - ) - else: - irreps = self.train_targets[target_name]["irreps"] - parent_target_name = self.train_targets[target_name]["parent"] - - if parent_target_name not in targets: - parent_target = torch.cat( - [ - batch[parent_target_name].to(self.device) - for batch in batch_list - ], - dim=0, - ) - targets[parent_target_name] = parent_target - - target = [ - torch.einsum( - "ab, cb->ca", - change_mat.to(self.device), - batch[parent_target_name], - ) - for batch in batch_list - ] - - target = torch.cat( - [ - batch[ - :, - max(0, irreps_sum(irreps - 1)) : irreps_sum( - irreps - ), - ] - for batch in target - ], - dim=0, - ) - - if ( - self.config["task"].get("eval_on_free_atoms", True) - and self.train_targets[target_name].get("level", "system") - == "atom" - ): - target = target[mask] - out[target_name] = out[target_name][mask] - - targets[target_name] = target - if self.normalizers.get(target_name, False): - out[target_name] = self.normalizers[target_name].denorm( - out[target_name] - ) - - targets["natoms"] = natoms - out["natoms"] = natoms - - metrics = evaluator.eval(out, targets, prev_metrics=metrics) - return metrics - def run_relaxations(self, split="val"): ensure_fitted(self._unwrapped_model) From ba97e97d2421e8abe29c058aa0dc9671b3e5d133 Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Wed, 12 Jul 2023 16:04:34 -0700 Subject: [PATCH 06/63] cleanup, remove hpo --- ocpmodels/trainers/base_trainer.py | 97 ++++-------------------------- 1 file changed, 13 insertions(+), 84 deletions(-) diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index e98dd1d4b..47aab32ca 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -36,6 +36,7 @@ from ocpmodels.common.utils import ( cg_decomp_mat, check_traj_files, + get_commit_hash, irreps_sum, load_state_dict, save_checkpoint, @@ -64,7 +65,6 @@ def __init__( timestamp_id: Optional[str] = None, run_dir=None, is_debug: bool = False, - is_hpo: bool = False, print_every: int = 100, seed=None, logger: str = "tensorboard", @@ -95,38 +95,22 @@ def __init__( ) # create directories from master rank only distutils.broadcast(timestamp, 0) - timestamp = datetime.datetime.fromtimestamp( - timestamp.float().item() + _timestamp_id = datetime.datetime.fromtimestamp( + timestamp.int() ).strftime("%Y-%m-%d-%H-%M-%S") if identifier: - self.timestamp_id = f"{timestamp}-{identifier}" + timestamp_id = f"{_timestamp_id}-{identifier}" else: - self.timestamp_id = timestamp - else: - self.timestamp_id = timestamp_id + timestamp_id = _timestamp_id - try: - commit_hash = ( - subprocess.check_output( - [ - "git", - "-C", - assert_is_instance(ocpmodels.__path__[0], str), - "describe", - "--always", - ] - ) - .strip() - .decode("ascii") - ) - # catch instances where code is not being run from a git repo - except Exception: - commit_hash = None + self.timestamp_id = timestamp_id + + commit_hash = get_commit_hash() logger_name = logger if isinstance(logger, str) else logger["name"] self.config = { "task": task, - "trainer": "ocp", + "trainer": name, "model": assert_is_instance(model.pop("name"), str), "model_attributes": model, "optim": optimizer, @@ -155,6 +139,7 @@ def __init__( # AMP Scaler self.scaler = torch.cuda.amp.GradScaler() if amp else None + # Fill in SLURM information in config, if applicable if "SLURM_JOB_ID" in os.environ and "folder" in self.config["slurm"]: if "SLURM_ARRAY_JOB_ID" in os.environ: self.config["slurm"]["job_id"] = "%s_%s" % ( @@ -166,6 +151,7 @@ def __init__( self.config["slurm"]["folder"] = self.config["slurm"][ "folder" ].replace("%j", self.config["slurm"]["job_id"]) + if isinstance(dataset, list): if len(dataset) > 0: self.config["dataset"] = dataset[0] @@ -180,22 +166,12 @@ def __init__( else: self.config["dataset"] = dataset - if not is_debug and distutils.is_master() and not is_hpo: + if not is_debug and distutils.is_master(): os.makedirs(self.config["cmd"]["checkpoint_dir"], exist_ok=True) os.makedirs(self.config["cmd"]["results_dir"], exist_ok=True) os.makedirs(self.config["cmd"]["logs_dir"], exist_ok=True) self.is_debug = is_debug - self.is_hpo = is_hpo - - if self.is_hpo: - # conditional import is necessary for checkpointing - - # sets the hpo checkpoint frequency - # default is no checkpointing - self.hpo_checkpoint_every = self.config["optim"].get( - "checkpoint_every", -1 - ) if distutils.is_master(): print(yaml.dump(self.config, default_flow_style=False)) @@ -232,7 +208,7 @@ def load_seed_from_config(self) -> None: def load_logger(self) -> None: self.logger = None - if not self.is_debug and distutils.is_master() and not self.is_hpo: + if not self.is_debug and distutils.is_master(): assert ( self.config["logger"] is not None ), "Specify logger in config" @@ -633,43 +609,6 @@ def save( return ckpt_path return None - def save_hpo(self, epoch, step: int, metrics, checkpoint_every: int): - # default is no checkpointing - # checkpointing frequency can be adjusted by setting checkpoint_every in steps - # to checkpoint every time results are communicated to Ray Tune set checkpoint_every=1 - if checkpoint_every != -1 and step % checkpoint_every == 0: - with tune.checkpoint_dir( # noqa: F821 - step=step - ) as checkpoint_dir: - path = os.path.join(checkpoint_dir, "checkpoint") - torch.save(self.save_state(epoch, step, metrics), path) - - def hpo_update( - self, epoch, step, train_metrics, val_metrics, test_metrics=None - ): - progress = { - "steps": step, - "epochs": epoch, - "act_lr": self.optimizer.param_groups[0]["lr"], - } - # checkpointing must occur before reporter - # default is no checkpointing - self.save_hpo( - epoch, - step, - val_metrics, - self.hpo_checkpoint_every, - ) - # report metrics to tune - tune_reporter( # noqa: F821 - iters=progress, - train_metrics={ - k: train_metrics[k]["metric"] for k in self.metrics - }, - val_metrics={k: val_metrics[k]["metric"] for k in val_metrics}, - test_metrics=test_metrics, - ) - def update_best( self, primary_metric, @@ -769,7 +708,6 @@ def train(self, disable_eval_tqdm=False): if ( self.step % self.config["cmd"]["print_every"] == 0 and distutils.is_master() - and not self.is_hpo ): log_str = [ "{}: {:.2e}".format(k, v) for k, v in log_dict.items() @@ -804,13 +742,6 @@ def train(self, disable_eval_tqdm=False): val_metrics, disable_eval_tqdm=disable_eval_tqdm, ) - if self.is_hpo: - self.hpo_update( - self.epoch, - self.step, - self.metrics, - val_metrics, - ) if self.config["task"].get("eval_relaxations", False): if "relax_dataset" not in self.config["task"]: @@ -1018,8 +949,6 @@ def validate(self, split: str = "val", disable_tqdm: bool = False): if distutils.is_master(): logging.info(f"Evaluating on {split}.") - if self.is_hpo: - disable_tqdm = True self.model.eval() if self.ema: From 8af0f9046a78f6c33a9c408ee1936481c26144fc Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Wed, 12 Jul 2023 17:20:30 -0700 Subject: [PATCH 07/63] loss bugfix, cleanup hpo --- ocpmodels/common/utils.py | 19 +++++++++++++++++++ ocpmodels/modules/loss.py | 4 +++- ocpmodels/trainers/base_trainer.py | 7 ++++--- ocpmodels/trainers/ocp_trainer.py | 4 ---- 4 files changed, 26 insertions(+), 8 deletions(-) diff --git a/ocpmodels/common/utils.py b/ocpmodels/common/utils.py index d11262ee8..5569f62ba 100644 --- a/ocpmodels/common/utils.py +++ b/ocpmodels/common/utils.py @@ -13,6 +13,7 @@ import json import logging import os +import subprocess import sys import time from argparse import Namespace @@ -35,6 +36,8 @@ from torch_geometric.utils import remove_self_loops from torch_scatter import scatter, segment_coo, segment_csr +import ocpmodels + if TYPE_CHECKING: from torch.nn.modules.module import _IncompatibleKeys @@ -1170,3 +1173,19 @@ def irreps_sum(l): total += 2 * i + 1 return total + + +def get_commit_hash(): + try: + commit_hash = ( + subprocess.check_output( + ["git", "-C", ocpmodels.__path__[0], "describe", "--always"] + ) + .strip() + .decode("ascii") + ) + # catch instances where code is not being run from a git repo + except Exception: + commit_hash = None + + return commit_hash diff --git a/ocpmodels/modules/loss.py b/ocpmodels/modules/loss.py index b7b8a50c4..fae9f6f24 100644 --- a/ocpmodels/modules/loss.py +++ b/ocpmodels/modules/loss.py @@ -74,7 +74,9 @@ def forward( if self.reduction == "mean": num_samples = ( - batch_size if batch_size is not None else input.shape[0] + batch_size + if self.loss_name.startswith("atomwise") + else input.shape[0] ) num_samples = distutils.all_reduce( num_samples, device=input.device diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index 47aab32ca..3aad66e89 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -354,9 +354,10 @@ def load_task(self): # Default - no normalization self.normalizers = {} for target in self.train_targets: + normalizer = self.train_targets[target].get("normalizer", {}) self.normalizers[target] = Normalizer( - mean=self.train_targets.get("mean", 0), - std=self.train_targets.get("std", 1), + mean=normalizer.get("mean", 0), + std=normalizer.get("stdev", 1), device=self.device, ) @@ -777,8 +778,8 @@ def _compute_loss(self, out, batch_list): natoms = torch.cat( [batch.natoms.to(self.device) for batch in batch_list], dim=0 ) - natoms = torch.repeat_interleave(natoms, natoms) batch_size = natoms.numel() + natoms = torch.repeat_interleave(natoms, natoms) loss = [] if self.config["task"].get("train_on_free_atoms", True): diff --git a/ocpmodels/trainers/ocp_trainer.py b/ocpmodels/trainers/ocp_trainer.py index 3a73e878f..998b0a786 100644 --- a/ocpmodels/trainers/ocp_trainer.py +++ b/ocpmodels/trainers/ocp_trainer.py @@ -48,8 +48,6 @@ class OCPTrainer(BaseTrainer): (default: :obj:`None`) is_debug (bool, optional): Run in debug mode. (default: :obj:`False`) - is_hpo (bool, optional): Run hyperparameter optimization with Ray Tune. - (default: :obj:`False`) print_every (int, optional): Frequency of printing logs. (default: :obj:`100`) seed (int, optional): Random number seed. @@ -75,7 +73,6 @@ def __init__( timestamp_id=None, run_dir=None, is_debug=False, - is_hpo=False, print_every=100, seed=None, logger="tensorboard", @@ -96,7 +93,6 @@ def __init__( timestamp_id=timestamp_id, run_dir=run_dir, is_debug=is_debug, - is_hpo=is_hpo, print_every=print_every, seed=seed, logger=logger, From d4526759723b5ac07889857a10e9fc9f8dc0aeda Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Thu, 13 Jul 2023 12:58:31 -0700 Subject: [PATCH 08/63] backwards compatability for old configs --- ocpmodels/common/utils.py | 43 ++++++++++++++++++++++ ocpmodels/modules/evaluator.py | 59 ++++++++---------------------- ocpmodels/trainers/base_trainer.py | 32 ++++++++-------- ocpmodels/trainers/ocp_trainer.py | 4 +- 4 files changed, 78 insertions(+), 60 deletions(-) diff --git a/ocpmodels/common/utils.py b/ocpmodels/common/utils.py index 5569f62ba..d6bddb86b 100644 --- a/ocpmodels/common/utils.py +++ b/ocpmodels/common/utils.py @@ -1189,3 +1189,46 @@ def get_commit_hash(): commit_hash = None return commit_hash + + +def load_old_targets(name, config): + normalizer = config.get("dataset", {}) + + if name == "is2re": + targets = { + "energy": { + "irreps": 0, + "loss": config["optim"].get("loss_energy", "mae"), + "level": "system", + "coefficient": config["optim"].get("energy_coefficient", 1), + "normalizer": { + "mean": normalizer.get("target_mean", 0), + "stdev": normalizer.get("target_std", 1), + }, + } + } + elif name == "s2ef": + targets = { + "energy": { + "irreps": 0, + "loss": config["optim"].get("loss_energy", "mae"), + "level": "system", + "coefficient": config["optim"].get("energy_coefficient", 1), + "normalizer": { + "mean": normalizer.get("target_mean", 0), + "stdev": normalizer.get("target_std", 1), + }, + }, + "forces": { + "irreps": 1, + "loss": config["optim"].get("loss_force", "mae"), + "level": "atom", + "coefficient": config["optim"].get("force_coefficient", 1), + "normalizer": { + "mean": normalizer.get("grad_target_mean", 0), + "stdev": normalizer.get("grad_target_std", 1), + }, + }, + } + + return targets diff --git a/ocpmodels/modules/evaluator.py b/ocpmodels/modules/evaluator.py index bdfeb0866..c78127d6c 100644 --- a/ocpmodels/modules/evaluator.py +++ b/ocpmodels/modules/evaluator.py @@ -34,16 +34,16 @@ class Evaluator: task_metrics = { "s2ef": { - "energy": {"metrics": ["energy_mae"]}, + "energy": {"metrics": ["mae"]}, "forces": { "metrics": [ "forcesx_mae", "forcesy_mae", "forcesz_mae", - "forces_mae", - "forces_cos", - "forces_magnitude", - "energy_force_within_threshold", + "mae", + "cosine_similarity", + "magnitude_error", + "energy_forces_within_threshold", ] }, }, @@ -51,15 +51,15 @@ class Evaluator: "positions": { "metrics": [ "average_distance_within_threshold", - "positions_mae", - "positions_mse", + "mae", + "mse", ] } }, "is2re": { "metrics": [ - "energy_mae", - "energy_mse", + "mae", + "mse", "energy_within_threshold", ] }, @@ -77,15 +77,13 @@ def __init__(self, task: str = None, eval_metrics: str = None) -> None: def eval(self, prediction, target, prev_metrics={}): - # TODO: arbitrary type check - # for metric in self.metric_fns: - # assert attr in prediction - # assert attr in target - # assert prediction[attr].shape == target[attr].shape - metrics = prev_metrics for target_property in self.target_metrics: + assert ( + prediction[target_property].shape + == target[target_property].shape + ) for fn in self.target_metrics[target_property]["metrics"]: metric_name = ( f"{target_property}_{fn}" @@ -149,33 +147,8 @@ def forcesz_mse(prediction, target, key=None): return mse(prediction["forces"][:, 2], target["forces"][:, 2]) -<<<<<<< HEAD -def forces_mae(prediction, target): - return mae(prediction["forces"], target["forces"]) - - -def forces_mse(prediction, target): - return mse(prediction["forces"], target["forces"]) - - -def forces_cos(prediction, target): - return cosine_similarity(prediction["forces"], target["forces"]) - - -def forces_magnitude(prediction, target): - return magnitude_error(prediction["forces"], target["forces"], p=2) - - -def positions_mae(prediction, target): - return mae(prediction["positions"], target["positions"]) - - -def positions_mse(prediction, target): - return mse(prediction["positions"], target["positions"]) - - -def energy_force_within_threshold( - prediction, target, key=None +def energy_forces_within_threshold( + prediction: dict, target: dict, key=None ) -> Dict[str, Union[float, int]]: # Note that this natoms should be the count of free atoms we evaluate over. assert target["natoms"].sum() == prediction["forces"].size(0) @@ -335,7 +308,7 @@ def mse( def magnitude_error( prediction: dict, target: dict, key=slice(None), p: int = 2 ) -> Dict[str, Union[float, int]]: - assert prediction.shape[1] > 1 + assert prediction[key].shape[1] > 1 error = torch.abs( torch.norm(prediction[key], p=p, dim=-1) - torch.norm(target[key], p=p, dim=-1) diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index 3aad66e89..cb7ba19bc 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -38,6 +38,7 @@ check_traj_files, get_commit_hash, irreps_sum, + load_old_targets, load_state_dict, save_checkpoint, ) @@ -61,7 +62,6 @@ def __init__( dataset, optimizer, identifier, - normalizer=None, timestamp_id: Optional[str] = None, run_dir=None, is_debug: bool = False, @@ -180,7 +180,9 @@ def __init__( # TODO: asserts for targets+evaluation config definitions self.evaluator = Evaluator( task=name, - eval_metrics=self.config["task"].get("evaluation_metrics", None), + eval_metrics=self.config["task"].get( + "evaluation_metrics", Evaluator.task_metrics[name] + ), ) def load(self) -> None: @@ -333,8 +335,9 @@ def load_datasets(self) -> None: ) def load_task(self): - self.targets = self.config["task"]["targets"] - self.num_targets = 1 + self.targets = self.config["task"].get( + "targets", load_old_targets(self.name, self.config) + ) self.train_targets = {} for target in self.targets: @@ -384,7 +387,7 @@ def load_model(self) -> None: and loader.dataset[0].x is not None else None, bond_feat_dim, - self.num_targets, + 1, **self.config["model_attributes"], ).to(self.device) @@ -577,10 +580,9 @@ def save( if self.scaler else None, "best_val_metric": self.best_val_metric, - "primary_metric": self.config["task"].get( - "primary_metric", - self.evaluator.task_primary_metric[self.name], - ), + "primary_metric": self.config["task"][ + "primary_metric" + ], }, checkpoint_dir=self.config["cmd"]["checkpoint_dir"], checkpoint_file=checkpoint_file, @@ -645,11 +647,9 @@ def train(self, disable_eval_tqdm=False): checkpoint_every = self.config["optim"].get( "checkpoint_every", eval_every ) - primary_metric = self.config["task"]["primary_metric"] - # TODO: support for old naming conventions - is2re, s2ef, etc. - # primary_metric = self.config["task"].get( - # "primary_metric", self.evaluator.task_primary_metric[self.name] - # ) + primary_metric = self.config["task"].get( + "primary_metric", self.evaluator.task_primary_metric[self.name] + ) if ( not hasattr(self, "primary_metric") or self.primary_metric != primary_metric @@ -959,7 +959,9 @@ def validate(self, split: str = "val", disable_tqdm: bool = False): metrics = {} evaluator = Evaluator( task=self.name, - eval_metrics=self.config["task"].get("evaluation_metrics", None), + eval_metrics=self.config["task"].get( + "evaluation_metrics", Evaluator.task_metrics[self.name] + ), ) rank = distutils.get_rank() diff --git a/ocpmodels/trainers/ocp_trainer.py b/ocpmodels/trainers/ocp_trainer.py index 998b0a786..b90cdb7b5 100644 --- a/ocpmodels/trainers/ocp_trainer.py +++ b/ocpmodels/trainers/ocp_trainer.py @@ -27,6 +27,8 @@ @registry.register_trainer("ocp") +@registry.register_trainer("energy") +@registry.register_trainer("forces") class OCPTrainer(BaseTrainer): """ Trainer class for the Structure to Energy & Force (S2EF) and Initial State to @@ -69,7 +71,6 @@ def __init__( dataset, optimizer, identifier, - normalizer=None, timestamp_id=None, run_dir=None, is_debug=False, @@ -89,7 +90,6 @@ def __init__( dataset=dataset, optimizer=optimizer, identifier=identifier, - normalizer=normalizer, timestamp_id=timestamp_id, run_dir=run_dir, is_debug=is_debug, From adba02cfbc54784e3821d58ec13e26806d5ca6bc Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Fri, 14 Jul 2023 16:20:29 -0700 Subject: [PATCH 09/63] backwards breaking fix --- ocpmodels/common/utils.py | 2 ++ ocpmodels/modules/evaluator.py | 2 ++ 2 files changed, 4 insertions(+) diff --git a/ocpmodels/common/utils.py b/ocpmodels/common/utils.py index d6bddb86b..7d1703484 100644 --- a/ocpmodels/common/utils.py +++ b/ocpmodels/common/utils.py @@ -1230,5 +1230,7 @@ def load_old_targets(name, config): }, }, } + else: + targets = {} return targets diff --git a/ocpmodels/modules/evaluator.py b/ocpmodels/modules/evaluator.py index c78127d6c..1f013fe73 100644 --- a/ocpmodels/modules/evaluator.py +++ b/ocpmodels/modules/evaluator.py @@ -63,12 +63,14 @@ class Evaluator: "energy_within_threshold", ] }, + "ocp": {}, } task_primary_metric = { "s2ef": "energy_force_within_threshold", "is2rs": "average_distance_within_threshold", "is2re": "energy_mae", + "ocp": None, } def __init__(self, task: str = None, eval_metrics: str = None) -> None: From 8bac18404461aa247e2040cb0e73431373af3d78 Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Fri, 14 Jul 2023 16:50:30 -0700 Subject: [PATCH 10/63] eval fix --- ocpmodels/modules/evaluator.py | 1 - 1 file changed, 1 deletion(-) diff --git a/ocpmodels/modules/evaluator.py b/ocpmodels/modules/evaluator.py index 1f013fe73..0d98a9465 100644 --- a/ocpmodels/modules/evaluator.py +++ b/ocpmodels/modules/evaluator.py @@ -63,7 +63,6 @@ class Evaluator: "energy_within_threshold", ] }, - "ocp": {}, } task_primary_metric = { From 4961bb1f48ed6ae9be8e3e0916dfa1a80321e563 Mon Sep 17 00:00:00 2001 From: Janice Lan Date: Mon, 17 Jul 2023 14:28:13 -0700 Subject: [PATCH 11/63] remove old imports --- ocpmodels/tasks/task.py | 1 - ocpmodels/trainers/__init__.py | 6 ++---- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/ocpmodels/tasks/task.py b/ocpmodels/tasks/task.py index 522251ffb..b3c9cdafd 100644 --- a/ocpmodels/tasks/task.py +++ b/ocpmodels/tasks/task.py @@ -9,7 +9,6 @@ import os from ocpmodels.common.registry import registry -from ocpmodels.trainers.forces_trainer import ForcesTrainer class BaseTask: diff --git a/ocpmodels/trainers/__init__.py b/ocpmodels/trainers/__init__.py index a93fc680b..20b44d540 100644 --- a/ocpmodels/trainers/__init__.py +++ b/ocpmodels/trainers/__init__.py @@ -5,10 +5,8 @@ __all__ = [ "BaseTrainer", - "ForcesTrainer", - "EnergyTrainer", + "OCPTrainer", ] from .base_trainer import BaseTrainer -from .energy_trainer import EnergyTrainer -from .forces_trainer import ForcesTrainer +from .ocp_trainer import OCPTrainer From 99eb4826e82466f9963f0200d3f4f4d4940b88c6 Mon Sep 17 00:00:00 2001 From: Janice Lan Date: Mon, 17 Jul 2023 17:14:54 -0700 Subject: [PATCH 12/63] default for get task metrics --- ocpmodels/trainers/base_trainer.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index cb7ba19bc..71b4fd893 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -181,7 +181,7 @@ def __init__( self.evaluator = Evaluator( task=name, eval_metrics=self.config["task"].get( - "evaluation_metrics", Evaluator.task_metrics[name] + "evaluation_metrics", Evaluator.task_metrics.get(name, {}) ), ) @@ -960,7 +960,7 @@ def validate(self, split: str = "val", disable_tqdm: bool = False): evaluator = Evaluator( task=self.name, eval_metrics=self.config["task"].get( - "evaluation_metrics", Evaluator.task_metrics[self.name] + "evaluation_metrics", Evaluator.task_metrics.get(self.name, {}) ), ) From a26954475d3abcfb7a0f2b96b2f48b2c86d43f9b Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Tue, 18 Jul 2023 11:49:52 -0700 Subject: [PATCH 13/63] rebase cleanup --- ocpmodels/common/utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ocpmodels/common/utils.py b/ocpmodels/common/utils.py index 7d1703484..9ca1b041f 100644 --- a/ocpmodels/common/utils.py +++ b/ocpmodels/common/utils.py @@ -1134,7 +1134,7 @@ def scatter_det(*args, **kwargs): return out -def cg_decomp_mat(l, device): +def cg_decomp_mat(l, device="cpu"): if l not in [2]: raise NotImplementedError From 448c567d7eb1d5023a24cc74edd2bb21e5c18283 Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Wed, 19 Jul 2023 11:55:03 -0700 Subject: [PATCH 14/63] config refactor support --- configs/goc_oc20_debug.yml | 131 +++ ..._single_debug.yml => goc_stress_debug.yml} | 121 +-- ocpmodels/common/utils.py | 35 +- ocpmodels/datasets/lmdb_dataset.py | 35 +- ocpmodels/modules/evaluator.py | 23 +- ocpmodels/modules/transforms.py | 42 + ocpmodels/trainers/base_trainer.py | 266 +++--- ocpmodels/trainers/energy_trainer.py | 340 ------- ocpmodels/trainers/forces_trainer.py | 827 ------------------ ocpmodels/trainers/ocp_trainer.py | 6 + 10 files changed, 420 insertions(+), 1406 deletions(-) create mode 100644 configs/goc_oc20_debug.yml rename configs/{goc_single_debug.yml => goc_stress_debug.yml} (61%) create mode 100644 ocpmodels/modules/transforms.py delete mode 100644 ocpmodels/trainers/energy_trainer.py delete mode 100644 ocpmodels/trainers/forces_trainer.py diff --git a/configs/goc_oc20_debug.yml b/configs/goc_oc20_debug.yml new file mode 100644 index 000000000..137bd2f50 --- /dev/null +++ b/configs/goc_oc20_debug.yml @@ -0,0 +1,131 @@ +trainer: ocp + +dataset: + train: + format: lmdb + src: /datasets01/open_catalyst/oc20/082422/struct_to_energy_forces/train/2M + key_mapping: + y: energy + force: forces + transforms: + normalizer: + energy: + mean: -0.7554450631141663 + stdev: 2.887317180633545 + forces: + mean: 0 + stdev: 2.887317180633545 + val: + src: /datasets01/open_catalyst/oc20/082422/struct_to_energy_forces/val/id_30k + test: + src: /datasets01/open_catalyst/oc20/082422/struct_to_energy_forces/val/id_30k + +logger: tensorboard + +loss_functions: + - energy: + fn: mae + coefficient: 1 + - forces: + fn: l2mae + coefficient: 100 + +evaluation_metrics: + metrics: + energy: + - mae + - mse + - energy_within_threshold + forces: + - mae + - cosine_similarity + misc: + - energy_forces_within_threshold + primary_metric: forces_mae + +outputs: + energy: + shape: 1 + level: system + forces: + shape: 3 + level: atom + +task: + train_on_free_atoms: True + eval_on_free_atoms: True + +model: + name: gemnet_oc + num_spherical: 7 + num_radial: 128 + num_blocks: 4 + emb_size_atom: 256 + emb_size_edge: 512 + emb_size_trip_in: 64 + emb_size_trip_out: 64 + emb_size_quad_in: 32 + emb_size_quad_out: 32 + emb_size_aint_in: 64 + emb_size_aint_out: 64 + emb_size_rbf: 16 + emb_size_cbf: 16 + emb_size_sbf: 32 + num_before_skip: 2 + num_after_skip: 2 + num_concat: 1 + num_atom: 3 + num_output_afteratom: 3 + cutoff: 12.0 + cutoff_qint: 12.0 + cutoff_aeaint: 12.0 + cutoff_aint: 12.0 + max_neighbors: 30 + max_neighbors_qint: 8 + max_neighbors_aeaint: 20 + max_neighbors_aint: 1000 + rbf: + name: gaussian + envelope: + name: polynomial + exponent: 5 + cbf: + name: spherical_harmonics + sbf: + name: legendre_outer + extensive: True + output_init: HeOrthogonal + activation: silu + scale_file: configs/s2ef/all/gemnet/scaling_factors/gemnet-oc.pt + + regress_forces: True + direct_forces: True + forces_coupled: False + + quad_interaction: True + atom_edge_interaction: True + edge_atom_interaction: True + atom_interaction: True + + num_atom_emb_layers: 2 + num_global_out_layers: 2 + qint_tags: [1, 2] + otf_graph: True + +optim: + batch_size: 4 + eval_batch_size: 4 + load_balancing: atoms + eval_every: 5000 + num_workers: 2 + lr_initial: 5.e-4 + optimizer: AdamW + optimizer_params: {"amsgrad": True} + scheduler: ReduceLROnPlateau + mode: min + factor: 0.8 + patience: 3 + max_epochs: 80 + ema_decay: 0.999 + clip_grad_norm: 10 + weight_decay: 0 diff --git a/configs/goc_single_debug.yml b/configs/goc_stress_debug.yml similarity index 61% rename from configs/goc_single_debug.yml rename to configs/goc_stress_debug.yml index cf12a638c..0534d5103 100644 --- a/configs/goc_single_debug.yml +++ b/configs/goc_stress_debug.yml @@ -2,71 +2,89 @@ trainer: ocp dataset: train: + format: lmdb src: /checkpoint/saro00/mpf_datasets/s2efs/0/train.lmdb - #src: /datasets01/open_catalyst/oc20/082422/struct_to_energy_forces/val/id_30k + key_mapping: + y: energy + force: forces + stress: stress + transforms: + decompose_tensor: + tensor: stress + rank: 2 + decomposition: + isotropic_stress: + irrep_dim: 0 + anisotropic_stress: + irrep_dim: 2 + normalizer: + energy: + mean: -5.9749126 + stdev: 1.866159 + forces: + mean: 0 + stdev: 1.866159 + isotropic_stress: + mean: 43.27065 + stdev: 674.1657344451734 + anisotropic_stress: + stdev: 143.72764771869745 val: - #src: /datasets01/open_catalyst/oc20/082422/struct_to_energy_forces/val/id_30k src: /checkpoint/saro00/mpf_datasets/s2efs/0/val.lmdb test: - #src: /datasets01/open_catalyst/oc20/082422/struct_to_energy_forces/val/id_30k src: /checkpoint/saro00/mpf_datasets/s2efs/0/val.lmdb logger: tensorboard -task: - dataset: lmdb - - train_on_free_atoms: True - eval_on_free_atoms: True +loss_functions: + - energy: + fn: mae + coefficient: 1 + - forces: + fn: l2mae + coefficient: 100 + - isotropic_stress: + fn: mae + - anisotropic_stress: + fn: mae - evaluation_metrics: +evaluation_metrics: + metrics: energy: - metrics: - - mae - - mse - - energy_within_threshold + - mae + - mse + - energy_within_threshold forces: - metrics: - - mae - - cosine_similarity + - mae + - cosine_similarity + isotropic_stress: + - mae + anisotropic_stress: + - mae stress: - metrics: - - stress_mae - + - stress_mae_from_decomposition + misc: + - energy_forces_within_threshold primary_metric: forces_mae - targets: - energy: - irreps: 0 - loss: mae - level: system - coefficient: 1 - normalizer: - mean: -5.9749126 - stdev: 1.866159 - forces: - irreps: 1 - loss: mae - level: atom - coefficient: 100 - normalizer: - stdev: 1.866159 - stress: - level: system - decomp: - isotropic_stress: - irreps: 0 - loss: mae - coefficient: 1 - normalizer: - mean: 43.27065 - stdev: 674.1657344451734 - anisotropic_stress: - irreps: 2 - loss: mae - coefficient: 1 - normalizer: - stdev: 143.72764771869745 +outputs: + energy: + shape: 1 + level: system + forces: + shape: 3 + level: atom + stress: + level: system + decomposition: + isotropic_stress: + irrep_dim: 0 + anisotropic_stress: + irrep_dim: 2 + +task: + train_on_free_atoms: True + eval_on_free_atoms: True model: name: gemnet_oc @@ -123,6 +141,7 @@ model: num_atom_emb_layers: 2 num_global_out_layers: 2 qint_tags: [1, 2] + otf_graph: True optim: batch_size: 4 diff --git a/ocpmodels/common/utils.py b/ocpmodels/common/utils.py index 9ca1b041f..82df7cfda 100644 --- a/ocpmodels/common/utils.py +++ b/ocpmodels/common/utils.py @@ -1011,8 +1011,11 @@ class _TrainingContext: trainer = trainer_cls( task=config["task"], model=config["model"], + outputs=config.get("outputs", None), dataset=config["dataset"], optimizer=config["optim"], + loss_fns=config.get("loss_functions", None), + eval_metrics=config.get("evaluation_metrics", None), identifier=config["identifier"], timestamp_id=config.get("timestamp_id", None), run_dir=config.get("run_dir", "./"), @@ -1134,6 +1137,22 @@ def scatter_det(*args, **kwargs): return out +def get_commit_hash(): + try: + commit_hash = ( + subprocess.check_output( + ["git", "-C", ocpmodels.__path__[0], "describe", "--always"] + ) + .strip() + .decode("ascii") + ) + # catch instances where code is not being run from a git repo + except Exception: + commit_hash = None + + return commit_hash + + def cg_decomp_mat(l, device="cpu"): if l not in [2]: raise NotImplementedError @@ -1175,22 +1194,6 @@ def irreps_sum(l): return total -def get_commit_hash(): - try: - commit_hash = ( - subprocess.check_output( - ["git", "-C", ocpmodels.__path__[0], "describe", "--always"] - ) - .strip() - .decode("ascii") - ) - # catch instances where code is not being run from a git repo - except Exception: - commit_hash = None - - return commit_hash - - def load_old_targets(name, config): normalizer = config.get("dataset", {}) diff --git a/ocpmodels/datasets/lmdb_dataset.py b/ocpmodels/datasets/lmdb_dataset.py index 72501eb63..03e7e88d7 100644 --- a/ocpmodels/datasets/lmdb_dataset.py +++ b/ocpmodels/datasets/lmdb_dataset.py @@ -25,6 +25,8 @@ from ocpmodels.common.typing import assert_is_instance from ocpmodels.common.utils import pyg2_data_transform from ocpmodels.datasets.target_metadata_guesser import guess_property_metadata +from ocpmodels.modules.normalizer import Normalizer +from ocpmodels.modules.transforms import DataTransforms T_co = TypeVar("T_co", covariant=True) @@ -116,7 +118,23 @@ def __init__(self, config, transform=None) -> None: self.available_indices = self.shards[self.config.get("shard", 0)] self.num_samples = len(self.available_indices) - self.transform = transform + self.key_mapping = self.config.get("key_mapping", None) + self.transforms = self.config.get("transforms", {}) + self._normalizers = self.transforms.get("normalizer", None) + + self.load() + + def load(self): + self.normalizers = {} + if self._normalizers: + for target in self._normalizers: + self.normalizers[target] = Normalizer( + mean=self._normalizers[target].get("mean", 0), + std=self._normalizers[target].get("stdev", 1), + ) + self.transforms.pop("normalizer") + + self.transform = DataTransforms(self.transforms) def __len__(self) -> int: return self.num_samples @@ -148,13 +166,16 @@ def __getitem__(self, idx: int): ) data_object = pyg2_data_transform(pickle.loads(datapoint_pickled)) - if self.transform is not None: - data_object = self.transform(data_object) + if self.key_mapping is not None: + for _property in self.key_mapping: + # catch for test data not containing labels + if _property in data_object: + new_property = self.key_mapping[_property] + if new_property not in data_object: + data_object[new_property] = data_object[_property] + del data_object[_property] - if "stress" in data_object: - data_object.stress = data_object.stress.reshape(1, -1) - data_object.energy = data_object.y - data_object.forces = data_object.force + self.transform(data_object) return data_object diff --git a/ocpmodels/modules/evaluator.py b/ocpmodels/modules/evaluator.py index 0d98a9465..1539bc5dc 100644 --- a/ocpmodels/modules/evaluator.py +++ b/ocpmodels/modules/evaluator.py @@ -5,9 +5,10 @@ LICENSE file in the root directory of this source tree. """ +from typing import Dict, Union + import numpy as np import torch -from typing import Dict, Union from ocpmodels.common.utils import cg_decomp_mat @@ -66,7 +67,7 @@ class Evaluator: } task_primary_metric = { - "s2ef": "energy_force_within_threshold", + "s2ef": "energy_forces_within_threshold", "is2rs": "average_distance_within_threshold", "is2re": "energy_mae", "ocp": None, @@ -81,14 +82,10 @@ def eval(self, prediction, target, prev_metrics={}): metrics = prev_metrics for target_property in self.target_metrics: - assert ( - prediction[target_property].shape - == target[target_property].shape - ) - for fn in self.target_metrics[target_property]["metrics"]: + for fn in self.target_metrics[target_property]: metric_name = ( f"{target_property}_{fn}" - if target_property not in fn + if target_property not in fn and target_property != "misc" else fn ) res = eval(fn)(prediction, target, target_property) @@ -149,7 +146,7 @@ def forcesz_mse(prediction, target, key=None): def energy_forces_within_threshold( - prediction: dict, target: dict, key=None + prediction: dict, target: dict, key=None ) -> Dict[str, Union[float, int]]: # Note that this natoms should be the count of free atoms we evaluate over. assert target["natoms"].sum() == prediction["forces"].size(0) @@ -235,9 +232,9 @@ def average_distance_within_threshold( return {"metric": success / total, "total": success, "numel": total} -def stress_mae(prediction, target, key=None): +def stress_mae_from_decomposition(prediction, target, key=None): device = prediction["isotropic_stress"].device - cg_decomp_mat = cg_decomp_mat(2, device) + cg_matrix = cg_decomp_mat(2, device) zero_vectors = torch.zeros( (prediction["isotropic_stress"].shape[0], 3), @@ -252,10 +249,10 @@ def stress_mae(prediction, target, key=None): dim=1, ) prediction_stress = torch.einsum( - "ba, cb->ca", cg_decomp_mat, prediction_irreps + "ba, cb->ca", cg_matrix, prediction_irreps ).reshape(-1) - target_stress = target["stress"] + target_stress = target["stress"].reshape(-1) return mae(prediction_stress, target_stress) diff --git a/ocpmodels/modules/transforms.py b/ocpmodels/modules/transforms.py new file mode 100644 index 000000000..95eb18f5b --- /dev/null +++ b/ocpmodels/modules/transforms.py @@ -0,0 +1,42 @@ +import torch + +from ocpmodels.common.utils import cg_decomp_mat, irreps_sum + + +class DataTransforms: + def __init__(self, config): + self.config = config + + def __call__(self, data_object): + if self.config is None: + return data_object + + for transform_fn in self.config: + data_object = eval(transform_fn)( + data_object, self.config[transform_fn] + ) + + return data_object + + +def decompose_tensor(data_object, config): + tensor_key = config["tensor"] + rank = config["rank"] + + if rank != 2: + raise NotImplementedError + + tensor_decomposition = torch.einsum( + "ab, cb->ca", + cg_decomp_mat(rank), + data_object[tensor_key].reshape(1, irreps_sum(rank)), + ) + + for decomposition_key in config["decomposition"]: + irrep_dim = config["decomposition"][decomposition_key]["irrep_dim"] + data_object[decomposition_key] = tensor_decomposition[ + :, + max(0, irreps_sum(irrep_dim - 1)) : irreps_sum(irrep_dim), + ] + + return data_object diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index 71b4fd893..6a9e287ac 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -12,7 +12,7 @@ import subprocess from abc import ABC, abstractmethod from collections import defaultdict -from typing import cast, Dict, Optional +from typing import Dict, Optional, cast import numpy as np import torch @@ -59,8 +59,11 @@ def __init__( self, task, model, + outputs, dataset, optimizer, + loss_fns, + eval_metrics, identifier, timestamp_id: Optional[str] = None, run_dir=None, @@ -113,7 +116,10 @@ def __init__( "trainer": name, "model": assert_is_instance(model.pop("name"), str), "model_attributes": model, + "outputs": outputs, "optim": optimizer, + "loss_fns": loss_fns, + "eval_metrics": eval_metrics, "logger": logger, "amp": amp, "gpus": distutils.get_world_size() if not self.cpu else 0, @@ -175,15 +181,8 @@ def __init__( if distutils.is_master(): print(yaml.dump(self.config, default_flow_style=False)) - self.load() - # TODO: asserts for targets+evaluation config definitions - self.evaluator = Evaluator( - task=name, - eval_metrics=self.config["task"].get( - "evaluation_metrics", Evaluator.task_metrics.get(name, {}) - ), - ) + self.load() def load(self) -> None: self.load_seed_from_config() @@ -260,7 +259,9 @@ def get_dataloader(self, dataset, sampler) -> DataLoader: return loader def load_datasets(self) -> None: - logging.info(f"Loading dataset: {self.config['task']['dataset']}") + logging.info( + f"Loading dataset: {self.config['dataset'].get('format', 'lmdb')}" + ) self.parallel_collater = ParallelCollater( 0 if self.cpu else 1, self.config["model_attributes"].get("otf_graph", False), @@ -273,7 +274,7 @@ def load_datasets(self) -> None: # load train, val, test datasets if self.config.get("dataset", None): self.train_dataset = registry.get_dataset_class( - self.config["task"]["dataset"] + self.config["dataset"].get("format", "lmdb") )(self.config["dataset"]) self.train_sampler = self.get_sampler( self.train_dataset, @@ -285,10 +286,15 @@ def load_datasets(self) -> None: self.train_sampler, ) + self.train_dataset[0] if self.config.get("val_dataset", None): + if self.config["val_dataset"].get("use_train_settings", True): + val_config = self.config["dataset"].copy() + val_config.update(self.config["val_dataset"]) + self.val_dataset = registry.get_dataset_class( - self.config["task"]["dataset"] - )(self.config["val_dataset"]) + self.config["val_dataset"].get("format", "lmdb") + )(val_config) self.val_sampler = self.get_sampler( self.val_dataset, self.config["optim"].get( @@ -302,9 +308,13 @@ def load_datasets(self) -> None: ) if self.config.get("test_dataset", None): + if self.config["test_dataset"].get("use_train_settings", True): + test_config = self.config["dataset"].copy() + test_config.update(self.config["test_dataset"]) + self.test_dataset = registry.get_dataset_class( - self.config["task"]["dataset"] - )(self.config["test_dataset"]) + self.config["test_dataset"].get("format", "lmdb") + )(test_config) self.test_sampler = self.get_sampler( self.test_dataset, self.config["optim"].get( @@ -335,38 +345,32 @@ def load_datasets(self) -> None: ) def load_task(self): - self.targets = self.config["task"].get( - "targets", load_old_targets(self.name, self.config) - ) - - self.train_targets = {} - for target in self.targets: - if "decomp" in self.targets[target]: - for subtarget in self.targets[target]["decomp"]: - self.train_targets[subtarget] = self.targets[target][ - "decomp" - ][subtarget] - self.train_targets[subtarget]["parent"] = target - self.train_targets[subtarget]["level"] = self.targets[ - target - ].get("level", "system") - else: - self.train_targets[target] = self.targets[target] - # Normalizer for the dataset. - # Default - no normalization - self.normalizers = {} - for target in self.train_targets: - normalizer = self.train_targets[target].get("normalizer", {}) - self.normalizers[target] = Normalizer( - mean=normalizer.get("mean", 0), - std=normalizer.get("stdev", 1), - device=self.device, - ) - - self.eval_metrics = self.config["task"].get("evaluation_metrics", {}) + self.normalizers = self.train_dataset.normalizers - assert len(self.eval_metrics.keys() - self.targets.keys()) == 0 + self.output_targets = {} + for target_name in self.config["outputs"]: + if "decomposition" not in self.config["outputs"][target_name]: + self.output_targets[target_name] = self.config["outputs"][ + target_name + ] + else: + for subtarget in self.config["outputs"][target_name][ + "decomposition" + ]: + self.output_targets[subtarget] = ( + self.config["outputs"][target_name]["decomposition"] + )[subtarget] + self.output_targets[subtarget]["parent"] = target_name + + ##TODO: Assert that all targets, loss fn, metrics defined and consistent + self.evaluation_metrics = self.config.get("eval_metrics", {}) + self.evaluator = Evaluator( + task=self.name, + eval_metrics=self.evaluation_metrics.get( + "metrics", Evaluator.task_metrics.get(self.name, {}) + ), + ) def load_model(self) -> None: # Build model @@ -482,26 +486,29 @@ def load_checkpoint(self, checkpoint_path: str) -> None: self.scaler.load_state_dict(checkpoint["amp"]) def load_loss(self) -> None: - self.loss_fn = {} - for target_name in self.train_targets: - self.loss_fn[target_name] = self.train_targets[target_name].get( - "loss", "mae" - ) + self.loss_fns = [] + for idx, loss in enumerate(self.config["loss_fns"]): + for target in loss: + loss_name = loss[target].get("fn", "mae") + coefficient = loss[target].get("coefficient", 1) + + if loss_name in ["l1", "mae"]: + loss_fn = nn.L1Loss() + elif loss_name == "mse": + loss_fn = nn.MSELoss() + elif loss_name == "l2mae": + loss_fn = L2MAELoss() + elif loss_name == "atomwisel2": + loss_fn = AtomwiseL2Loss() + else: + raise NotImplementedError( + f"Unknown loss function name: {loss_name}" + ) + loss_fn = DDPLoss(loss_fn, loss_name) - for target, loss_name in self.loss_fn.items(): - if loss_name in ["l1", "mae"]: - self.loss_fn[target] = nn.L1Loss() - elif loss_name == "mse": - self.loss_fn[target] = nn.MSELoss() - elif loss_name == "l2mae": - self.loss_fn[target] = L2MAELoss() - elif loss_name == "atomwisel2": - self.loss_fn[target] = AtomwiseL2Loss() - else: - raise NotImplementedError( - f"Unknown loss function name: {loss_name}" + self.loss_fns.append( + (target, {"fn": loss_fn, "coefficient": coefficient}) ) - self.loss_fn[target] = DDPLoss(self.loss_fn[target], loss_name) def load_optimizer(self) -> None: optimizer = self.config["optim"].get("optimizer", "AdamW") @@ -580,7 +587,7 @@ def save( if self.scaler else None, "best_val_metric": self.best_val_metric, - "primary_metric": self.config["task"][ + "primary_metric": self.config["metrics"][ "primary_metric" ], }, @@ -647,7 +654,7 @@ def train(self, disable_eval_tqdm=False): checkpoint_every = self.config["optim"].get( "checkpoint_every", eval_every ) - primary_metric = self.config["task"].get( + primary_metric = self.evaluation_metrics.get( "primary_metric", self.evaluator.task_primary_metric[self.name] ) if ( @@ -788,49 +795,18 @@ def _compute_loss(self, out, batch_list): ) mask = fixed == 0 - for target_name in self.train_targets: - if "parent" not in self.train_targets[target_name]: - target = torch.cat( - [ - batch[target_name].to(self.device) - for batch in batch_list - ], - dim=0, - ) - # property is a decomposition of a higher order tensor - else: - irreps = self.train_targets[target_name]["irreps"] - if irreps > 2: - raise NotImplementedError - - target = [ - torch.einsum( - "ab, cb->ca", - cg_decomp_mat(2).to(self.device), - batch[self.train_targets[target_name]["parent"]], - ) - for batch in batch_list - ] - - target = torch.cat( - [ - batch[ - :, - max(0, irreps_sum(irreps - 1)) : irreps_sum( - irreps - ), - ] - for batch in target - ], - dim=0, - ) + for loss_fn in self.loss_fns: + target_name, loss_info = loss_fn + target = torch.cat( + [batch[target_name].to(self.device) for batch in batch_list], + dim=0, + ) pred = out[target_name] if ( self.config["task"].get("train_on_free_atoms", True) - and self.train_targets[target_name].get("level", "system") - == "atom" + and self.config["outputs"].get("level", "system") == "atom" ): target = target[mask] pred = pred[mask] @@ -839,11 +815,11 @@ def _compute_loss(self, out, batch_list): if self.normalizers.get(target_name, False): target = self.normalizers[target_name].norm(target) - mult = self.train_targets[target_name].get("coefficient", 1) + mult = loss_info["coefficient"] loss.append( mult - * self.loss_fn[target_name]( + * loss_info["fn"]( pred, target, natoms=natoms, @@ -879,18 +855,14 @@ def _compute_metrics(self, out, batch_list, evaluator, metrics={}): natoms = torch.LongTensor(natoms_free).to(self.device) targets = {} - for target_name in self.train_targets: - if "parent" not in self.train_targets[target_name]: - target = torch.cat( - [ - batch[target_name].to(self.device) - for batch in batch_list - ], - dim=0, - ) - else: - irreps = self.train_targets[target_name]["irreps"] - parent_target_name = self.train_targets[target_name]["parent"] + for target_name in self.output_targets: + target = torch.cat( + [batch[target_name].to(self.device) for batch in batch_list], + dim=0, + ) + # Add parent target to targets + if "parent" in self.output_targets[target_name]: + parent_target_name = self.output_targets[target_name]["parent"] if parent_target_name not in targets: parent_target = torch.cat( @@ -902,31 +874,9 @@ def _compute_metrics(self, out, batch_list, evaluator, metrics={}): ) targets[parent_target_name] = parent_target - target = [ - torch.einsum( - "ab, cb->ca", - cg_decomp_mat(2).to(self.device), - batch[parent_target_name], - ) - for batch in batch_list - ] - - target = torch.cat( - [ - batch[ - :, - max(0, irreps_sum(irreps - 1)) : irreps_sum( - irreps - ), - ] - for batch in target - ], - dim=0, - ) - if ( self.config["task"].get("eval_on_free_atoms", True) - and self.train_targets[target_name].get("level", "system") + and self.output_targets[target_name].get("level", "system") == "atom" ): target = target[mask] @@ -959,8 +909,8 @@ def validate(self, split: str = "val", disable_tqdm: bool = False): metrics = {} evaluator = Evaluator( task=self.name, - eval_metrics=self.config["task"].get( - "evaluation_metrics", Evaluator.task_metrics.get(self.name, {}) + eval_metrics=self.evaluation_metrics.get( + "metrics", Evaluator.task_metrics.get(self.name, {}) ), ) @@ -1108,9 +1058,9 @@ def predict( with torch.cuda.amp.autocast(enabled=self.scaler is not None): out = self._forward(batch_list) - for target_key in self.targets: + for target_key in self.config["outputs"]: ### Target property is a direct output of the model - if target_key in self.train_targets: + if target_key in out: pred = out[target_key] ### Denormalize predictions if needed if self.normalizers.get(target_key, False): @@ -1118,18 +1068,24 @@ def predict( ## Target property is a derived output of the model else: _max_rank = 0 - for subtarget_key in self.targets[target_key]["decomp"]: + for subtarget_key in self.config["outputs"][target_key][ + "decomposition" + ]: _max_rank = max( _max_rank, - self.train_targets[subtarget_key]["irreps"], + self.output_targets[subtarget_key]["irrep_dim"], ) pred_irreps = torch.zeros( (batch_size, irreps_sum(_max_rank)), device=self.device ) - for subtarget_key in self.targets[target_key]["decomp"]: - irreps = self.train_targets[subtarget_key]["irreps"] + for subtarget_key in self.config["outputs"][target_key][ + "decomposition" + ]: + irreps = self.output_targets[subtarget_key][ + "irrep_dim" + ] _pred = out[subtarget_key] ### Denormalize predictions if needed @@ -1154,11 +1110,14 @@ def predict( ### Save outputs in desired precision, default float16 if ( - self.targets[target_key].get("prediction_dtype", "float16") + self.config["outputs"][target_key].get( + "prediction_dtype", "float16" + ) == "float32" or self.config["task"].get("prediction_dtype", "float16") == "float32" - or self.config["task"]["dataset"] == "oc22_lmdb" + or self.config["task"].get("dataset", "lmdb") + == "oc22_lmdb" ): dtype = torch.float32 else: @@ -1167,7 +1126,10 @@ def predict( pred = pred.cpu().detach().to(dtype) ### Split predictions into per-image predictions - if self.targets[target_key].get("level", "system") == "atom": + if ( + self.config["outputs"][target_key].get("level", "system") + == "atom" + ): batch_natoms = torch.cat( [batch.natoms for batch in batch_list] ) @@ -1220,7 +1182,7 @@ def predict( return predictions def save_results( - self, predictions, results_file: Optional[str], keys + self, predictions, results_file: Optional[str], keys=None ) -> None: if results_file is None: diff --git a/ocpmodels/trainers/energy_trainer.py b/ocpmodels/trainers/energy_trainer.py deleted file mode 100644 index 764fd7f51..000000000 --- a/ocpmodels/trainers/energy_trainer.py +++ /dev/null @@ -1,340 +0,0 @@ -""" -Copyright (c) Facebook, Inc. and its affiliates. - -This source code is licensed under the MIT license found in the -LICENSE file in the root directory of this source tree. -""" - -import logging -from typing import Optional - -import torch -import torch_geometric -from tqdm import tqdm - -from ocpmodels.common import distutils -from ocpmodels.common.registry import registry -from ocpmodels.modules.scaling.util import ensure_fitted -from ocpmodels.trainers.base_trainer import BaseTrainer - - -@registry.register_trainer("energy") -class EnergyTrainer(BaseTrainer): - """ - Trainer class for the Initial Structure to Relaxed Energy (IS2RE) task. - - .. note:: - - Examples of configurations for task, model, dataset and optimizer - can be found in `configs/ocp_is2re `_. - - - Args: - task (dict): Task configuration. - model (dict): Model configuration. - dataset (dict): Dataset configuration. The dataset needs to be a SinglePointLMDB dataset. - optimizer (dict): Optimizer configuration. - identifier (str): Experiment identifier that is appended to log directory. - run_dir (str, optional): Path to the run directory where logs are to be saved. - (default: :obj:`None`) - is_debug (bool, optional): Run in debug mode. - (default: :obj:`False`) - is_hpo (bool, optional): Run hyperparameter optimization with Ray Tune. - (default: :obj:`False`) - print_every (int, optional): Frequency of printing logs. - (default: :obj:`100`) - seed (int, optional): Random number seed. - (default: :obj:`None`) - logger (str, optional): Type of logger to be used. - (default: :obj:`tensorboard`) - local_rank (int, optional): Local rank of the process, only applicable for distributed training. - (default: :obj:`0`) - amp (bool, optional): Run using automatic mixed precision. - (default: :obj:`False`) - slurm (dict): Slurm configuration. Currently just for keeping track. - (default: :obj:`{}`) - """ - - def __init__( - self, - task, - model, - dataset, - optimizer, - identifier, - normalizer=None, - timestamp_id: Optional[str] = None, - run_dir=None, - is_debug: bool = False, - is_hpo: bool = False, - print_every: int = 100, - seed=None, - logger: str = "tensorboard", - local_rank: int = 0, - amp: bool = False, - cpu: bool = False, - slurm={}, - noddp: bool = False, - ) -> None: - super().__init__( - task=task, - model=model, - dataset=dataset, - optimizer=optimizer, - identifier=identifier, - normalizer=normalizer, - timestamp_id=timestamp_id, - run_dir=run_dir, - is_debug=is_debug, - is_hpo=is_hpo, - print_every=print_every, - seed=seed, - logger=logger, - local_rank=local_rank, - amp=amp, - cpu=cpu, - name="is2re", - slurm=slurm, - noddp=noddp, - ) - - def load_task(self) -> None: - logging.info(f"Loading dataset: {self.config['task']['dataset']}") - self.num_targets = 1 - - @torch.no_grad() - def predict( - self, - loader, - per_image: bool = True, - results_file=None, - disable_tqdm: bool = False, - ): - ensure_fitted(self._unwrapped_model) - - if distutils.is_master() and not disable_tqdm: - logging.info("Predicting on test.") - assert isinstance( - loader, - ( - torch.utils.data.dataloader.DataLoader, - torch_geometric.data.Batch, - ), - ) - rank = distutils.get_rank() - - if isinstance(loader, torch_geometric.data.Batch): - loader = [[loader]] - - self.model.eval() - if self.ema: - self.ema.store() - self.ema.copy_to() - - if self.normalizers is not None and "target" in self.normalizers: - self.normalizers["target"].to(self.device) - predictions = {"id": [], "energy": []} - - for _, batch in tqdm( - enumerate(loader), - total=len(loader), - position=rank, - desc="device {}".format(rank), - disable=disable_tqdm, - ): - with torch.cuda.amp.autocast(enabled=self.scaler is not None): - out = self._forward(batch) - - if self.normalizers is not None and "target" in self.normalizers: - out["energy"] = self.normalizers["target"].denorm( - out["energy"] - ) - - if per_image: - predictions["id"].extend( - [str(i) for i in batch[0].sid.tolist()] - ) - predictions["energy"].extend( - out["energy"].cpu().detach().numpy() - ) - else: - predictions["energy"] = out["energy"].detach() - return predictions - - self.save_results(predictions, results_file, keys=["energy"]) - - if self.ema: - self.ema.restore() - - return predictions - - def train(self, disable_eval_tqdm: bool = False) -> None: - ensure_fitted(self._unwrapped_model, warn=True) - - eval_every = self.config["optim"].get( - "eval_every", len(self.train_loader) - ) - primary_metric = self.config["task"].get( - "primary_metric", self.evaluator.task_primary_metric[self.name] - ) - self.best_val_metric = 1e9 - - # Calculate start_epoch from step instead of loading the epoch number - # to prevent inconsistencies due to different batch size in checkpoint. - start_epoch = self.step // len(self.train_loader) - - for epoch_int in range( - start_epoch, self.config["optim"]["max_epochs"] - ): - self.train_sampler.set_epoch(epoch_int) - skip_steps = self.step % len(self.train_loader) - train_loader_iter = iter(self.train_loader) - - for i in range(skip_steps, len(self.train_loader)): - self.epoch = epoch_int + (i + 1) / len(self.train_loader) - self.step = epoch_int * len(self.train_loader) + i + 1 - self.model.train() - - # Get a batch. - batch = next(train_loader_iter) - - # Forward, loss, backward. - with torch.cuda.amp.autocast(enabled=self.scaler is not None): - out = self._forward(batch) - loss = self._compute_loss(out, batch) - loss = self.scaler.scale(loss) if self.scaler else loss - self._backward(loss) - scale = self.scaler.get_scale() if self.scaler else 1.0 - - # Compute metrics. - self.metrics = self._compute_metrics( - out, - batch, - self.evaluator, - metrics={}, - ) - self.metrics = self.evaluator.update( - "loss", loss.item() / scale, self.metrics - ) - - # Log metrics. - log_dict = {k: self.metrics[k]["metric"] for k in self.metrics} - log_dict.update( - { - "lr": self.scheduler.get_lr(), - "epoch": self.epoch, - "step": self.step, - } - ) - if ( - self.step % self.config["cmd"]["print_every"] == 0 - and distutils.is_master() - and not self.is_hpo - ): - log_str = [ - "{}: {:.2e}".format(k, v) for k, v in log_dict.items() - ] - print(", ".join(log_str)) - self.metrics = {} - - if self.logger is not None: - self.logger.log( - log_dict, - step=self.step, - split="train", - ) - - # Evaluate on val set after every `eval_every` iterations. - if self.step % eval_every == 0: - self.save( - checkpoint_file="checkpoint.pt", training_state=True - ) - - if self.val_loader is not None: - val_metrics = self.validate( - split="val", - disable_tqdm=disable_eval_tqdm, - ) - if ( - val_metrics[ - self.evaluator.task_primary_metric[self.name] - ]["metric"] - < self.best_val_metric - ): - self.best_val_metric = val_metrics[ - self.evaluator.task_primary_metric[self.name] - ]["metric"] - self.save( - metrics=val_metrics, - checkpoint_file="best_checkpoint.pt", - training_state=False, - ) - if self.test_loader is not None: - self.predict( - self.test_loader, - results_file="predictions", - disable_tqdm=False, - ) - - if self.is_hpo: - self.hpo_update( - self.epoch, - self.step, - self.metrics, - val_metrics, - ) - - if self.scheduler.scheduler_type == "ReduceLROnPlateau": - if self.step % eval_every == 0: - self.scheduler.step( - metrics=val_metrics[primary_metric]["metric"], - ) - else: - self.scheduler.step() - - torch.cuda.empty_cache() - - self.train_dataset.close_db() - if self.config.get("val_dataset", False): - self.val_dataset.close_db() - if self.config.get("test_dataset", False): - self.test_dataset.close_db() - - def _forward(self, batch_list): - output = self.model(batch_list) - - if output.shape[-1] == 1: - output = output.view(-1) - - return { - "energy": output, - } - - def _compute_loss(self, out, batch_list): - energy_target = torch.cat( - [batch.y_relaxed.to(self.device) for batch in batch_list], dim=0 - ) - - if self.normalizer.get("normalize_labels", False): - target_normed = self.normalizers["target"].norm(energy_target) - else: - target_normed = energy_target - - loss = self.loss_fn["energy"](out["energy"], target_normed) - return loss - - def _compute_metrics(self, out, batch_list, evaluator, metrics={}): - energy_target = torch.cat( - [batch.y_relaxed.to(self.device) for batch in batch_list], dim=0 - ) - - if self.normalizer.get("normalize_labels", False): - out["energy"] = self.normalizers["target"].denorm(out["energy"]) - - metrics = evaluator.eval( - out, - {"energy": energy_target}, - prev_metrics=metrics, - ) - - return metrics diff --git a/ocpmodels/trainers/forces_trainer.py b/ocpmodels/trainers/forces_trainer.py deleted file mode 100644 index dc2ad5371..000000000 --- a/ocpmodels/trainers/forces_trainer.py +++ /dev/null @@ -1,827 +0,0 @@ -""" -Copyright (c) Facebook, Inc. and its affiliates. - -This source code is licensed under the MIT license found in the -LICENSE file in the root directory of this source tree. -""" - -import logging -import os -import pathlib -from collections import defaultdict -from pathlib import Path -from typing import Optional - -import numpy as np -import torch -import torch_geometric -from tqdm import tqdm - -from ocpmodels.common import distutils -from ocpmodels.common.registry import registry -from ocpmodels.common.relaxation.ml_relaxation import ml_relax -from ocpmodels.common.utils import check_traj_files -from ocpmodels.modules.evaluator import Evaluator -from ocpmodels.modules.normalizer import Normalizer -from ocpmodels.modules.scaling.util import ensure_fitted -from ocpmodels.trainers.base_trainer import BaseTrainer - - -@registry.register_trainer("forces") -class ForcesTrainer(BaseTrainer): - """ - Trainer class for the Structure to Energy & Force (S2EF) and Initial State to - Relaxed State (IS2RS) tasks. - - .. note:: - - Examples of configurations for task, model, dataset and optimizer - can be found in `configs/ocp_s2ef `_ - and `configs/ocp_is2rs `_. - - Args: - task (dict): Task configuration. - model (dict): Model configuration. - dataset (dict): Dataset configuration. The dataset needs to be a SinglePointLMDB dataset. - optimizer (dict): Optimizer configuration. - identifier (str): Experiment identifier that is appended to log directory. - run_dir (str, optional): Path to the run directory where logs are to be saved. - (default: :obj:`None`) - is_debug (bool, optional): Run in debug mode. - (default: :obj:`False`) - is_hpo (bool, optional): Run hyperparameter optimization with Ray Tune. - (default: :obj:`False`) - print_every (int, optional): Frequency of printing logs. - (default: :obj:`100`) - seed (int, optional): Random number seed. - (default: :obj:`None`) - logger (str, optional): Type of logger to be used. - (default: :obj:`tensorboard`) - local_rank (int, optional): Local rank of the process, only applicable for distributed training. - (default: :obj:`0`) - amp (bool, optional): Run using automatic mixed precision. - (default: :obj:`False`) - slurm (dict): Slurm configuration. Currently just for keeping track. - (default: :obj:`{}`) - """ - - def __init__( - self, - task, - model, - dataset, - optimizer, - identifier, - normalizer=None, - timestamp_id: Optional[str] = None, - run_dir: Optional[str] = None, - is_debug: bool = False, - is_hpo: bool = False, - print_every: int = 100, - seed: Optional[int] = None, - logger: str = "tensorboard", - local_rank: int = 0, - amp: bool = False, - cpu: bool = False, - slurm={}, - noddp: bool = False, - ) -> None: - super().__init__( - task=task, - model=model, - dataset=dataset, - optimizer=optimizer, - identifier=identifier, - normalizer=normalizer, - timestamp_id=timestamp_id, - run_dir=run_dir, - is_debug=is_debug, - is_hpo=is_hpo, - print_every=print_every, - seed=seed, - logger=logger, - local_rank=local_rank, - amp=amp, - cpu=cpu, - name="s2ef", - slurm=slurm, - noddp=noddp, - ) - - def load_task(self) -> None: - logging.info(f"Loading dataset: {self.config['task']['dataset']}") - - if "relax_dataset" in self.config["task"]: - self.relax_dataset = registry.get_dataset_class("lmdb")( - self.config["task"]["relax_dataset"] - ) - self.relax_sampler = self.get_sampler( - self.relax_dataset, - self.config["optim"].get( - "eval_batch_size", self.config["optim"]["batch_size"] - ), - shuffle=False, - ) - self.relax_loader = self.get_dataloader( - self.relax_dataset, - self.relax_sampler, - ) - - self.num_targets = 1 - - # If we're computing gradients wrt input, set mean of normalizer to 0 -- - # since it is lost when compute dy / dx -- and std to forward target std - if self.config["model_attributes"].get("regress_forces", True): - if self.normalizer.get("normalize_labels", False): - if "grad_target_mean" in self.normalizer: - self.normalizers["grad_target"] = Normalizer( - mean=self.normalizer["grad_target_mean"], - std=self.normalizer["grad_target_std"], - device=self.device, - ) - else: - self.normalizers["grad_target"] = Normalizer( - tensor=self.train_loader.dataset.data.y[ - self.train_loader.dataset.__indices__ - ], - device=self.device, - ) - self.normalizers["grad_target"].mean.fill_(0) - - # Takes in a new data source and generates predictions on it. - @torch.no_grad() - def predict( - self, - data_loader, - per_image: bool = True, - results_file=None, - disable_tqdm: bool = False, - ): - ensure_fitted(self._unwrapped_model, warn=True) - - if distutils.is_master() and not disable_tqdm: - logging.info("Predicting on test.") - assert isinstance( - data_loader, - ( - torch.utils.data.dataloader.DataLoader, - torch_geometric.data.Batch, - ), - ) - rank = distutils.get_rank() - - if isinstance(data_loader, torch_geometric.data.Batch): - data_loader = [[data_loader]] - - self.model.eval() - if self.ema: - self.ema.store() - self.ema.copy_to() - - if self.normalizers is not None and "target" in self.normalizers: - self.normalizers["target"].to(self.device) - self.normalizers["grad_target"].to(self.device) - - predictions = {"id": [], "energy": [], "forces": [], "chunk_idx": []} - - for i, batch_list in tqdm( - enumerate(data_loader), - total=len(data_loader), - position=rank, - desc="device {}".format(rank), - disable=disable_tqdm, - ): - with torch.cuda.amp.autocast(enabled=self.scaler is not None): - out = self._forward(batch_list) - - if self.normalizers is not None and "target" in self.normalizers: - out["energy"] = self.normalizers["target"].denorm( - out["energy"] - ) - out["forces"] = self.normalizers["grad_target"].denorm( - out["forces"] - ) - if per_image: - systemids = [ - str(i) + "_" + str(j) - for i, j in zip( - batch_list[0].sid.tolist(), batch_list[0].fid.tolist() - ) - ] - predictions["id"].extend(systemids) - batch_natoms = torch.cat( - [batch.natoms for batch in batch_list] - ) - batch_fixed = torch.cat([batch.fixed for batch in batch_list]) - # total energy target requires predictions to be saved in float32 - # default is float16 - if ( - self.config["task"].get("prediction_dtype", "float16") - == "float32" - or self.config["task"]["dataset"] == "oc22_lmdb" - ): - predictions["energy"].extend( - out["energy"].cpu().detach().to(torch.float32).numpy() - ) - forces = out["forces"].cpu().detach().to(torch.float32) - else: - predictions["energy"].extend( - out["energy"].cpu().detach().to(torch.float16).numpy() - ) - forces = out["forces"].cpu().detach().to(torch.float16) - per_image_forces = torch.split(forces, batch_natoms.tolist()) - per_image_forces = [ - force.numpy() for force in per_image_forces - ] - # evalAI only requires forces on free atoms - if results_file is not None: - _per_image_fixed = torch.split( - batch_fixed, batch_natoms.tolist() - ) - _per_image_free_forces = [ - force[(fixed == 0).tolist()] - for force, fixed in zip( - per_image_forces, _per_image_fixed - ) - ] - _chunk_idx = np.array( - [ - free_force.shape[0] - for free_force in _per_image_free_forces - ] - ) - per_image_forces = _per_image_free_forces - predictions["chunk_idx"].extend(_chunk_idx) - predictions["forces"].extend(per_image_forces) - else: - predictions["energy"] = out["energy"].detach() - predictions["forces"] = out["forces"].detach() - if self.ema: - self.ema.restore() - return predictions - - predictions["forces"] = np.array(predictions["forces"]) - predictions["chunk_idx"] = np.array(predictions["chunk_idx"]) - predictions["energy"] = np.array(predictions["energy"]) - predictions["id"] = np.array(predictions["id"]) - self.save_results( - predictions, results_file, keys=["energy", "forces", "chunk_idx"] - ) - - if self.ema: - self.ema.restore() - - return predictions - - def update_best( - self, - primary_metric, - val_metrics, - disable_eval_tqdm: bool = True, - ) -> None: - if ( - "mae" in primary_metric - and val_metrics[primary_metric]["metric"] < self.best_val_metric - ) or ( - "mae" not in primary_metric - and val_metrics[primary_metric]["metric"] > self.best_val_metric - ): - self.best_val_metric = val_metrics[primary_metric]["metric"] - self.save( - metrics=val_metrics, - checkpoint_file="best_checkpoint.pt", - training_state=False, - ) - if self.test_loader is not None: - self.predict( - self.test_loader, - results_file="predictions", - disable_tqdm=disable_eval_tqdm, - ) - - def train(self, disable_eval_tqdm: bool = False) -> None: - ensure_fitted(self._unwrapped_model, warn=True) - - eval_every = self.config["optim"].get( - "eval_every", len(self.train_loader) - ) - checkpoint_every = self.config["optim"].get( - "checkpoint_every", eval_every - ) - primary_metric = self.config["task"].get( - "primary_metric", self.evaluator.task_primary_metric[self.name] - ) - if ( - not hasattr(self, "primary_metric") - or self.primary_metric != primary_metric - ): - self.best_val_metric = 1e9 if "mae" in primary_metric else -1.0 - else: - primary_metric = self.primary_metric - self.metrics = {} - - # Calculate start_epoch from step instead of loading the epoch number - # to prevent inconsistencies due to different batch size in checkpoint. - start_epoch = self.step // len(self.train_loader) - - for epoch_int in range( - start_epoch, self.config["optim"]["max_epochs"] - ): - self.train_sampler.set_epoch(epoch_int) - skip_steps = self.step % len(self.train_loader) - train_loader_iter = iter(self.train_loader) - - for i in range(skip_steps, len(self.train_loader)): - self.epoch = epoch_int + (i + 1) / len(self.train_loader) - self.step = epoch_int * len(self.train_loader) + i + 1 - self.model.train() - - # Get a batch. - batch = next(train_loader_iter) - - # Forward, loss, backward. - with torch.cuda.amp.autocast(enabled=self.scaler is not None): - out = self._forward(batch) - loss = self._compute_loss(out, batch) - loss = self.scaler.scale(loss) if self.scaler else loss - self._backward(loss) - scale = self.scaler.get_scale() if self.scaler else 1.0 - - # Compute metrics. - self.metrics = self._compute_metrics( - out, - batch, - self.evaluator, - self.metrics, - ) - self.metrics = self.evaluator.update( - "loss", loss.item() / scale, self.metrics - ) - - # Log metrics. - log_dict = {k: self.metrics[k]["metric"] for k in self.metrics} - log_dict.update( - { - "lr": self.scheduler.get_lr(), - "epoch": self.epoch, - "step": self.step, - } - ) - if ( - self.step % self.config["cmd"]["print_every"] == 0 - and distutils.is_master() - and not self.is_hpo - ): - log_str = [ - "{}: {:.2e}".format(k, v) for k, v in log_dict.items() - ] - logging.info(", ".join(log_str)) - self.metrics = {} - - if self.logger is not None: - self.logger.log( - log_dict, - step=self.step, - split="train", - ) - - if ( - checkpoint_every != -1 - and self.step % checkpoint_every == 0 - ): - self.save( - checkpoint_file="checkpoint.pt", training_state=True - ) - - # Evaluate on val set every `eval_every` iterations. - if self.step % eval_every == 0: - if self.val_loader is not None: - val_metrics = self.validate( - split="val", - disable_tqdm=disable_eval_tqdm, - ) - self.update_best( - primary_metric, - val_metrics, - disable_eval_tqdm=disable_eval_tqdm, - ) - if self.is_hpo: - self.hpo_update( - self.epoch, - self.step, - self.metrics, - val_metrics, - ) - - if self.config["task"].get("eval_relaxations", False): - if "relax_dataset" not in self.config["task"]: - logging.warning( - "Cannot evaluate relaxations, relax_dataset not specified" - ) - else: - self.run_relaxations() - - if self.scheduler.scheduler_type == "ReduceLROnPlateau": - if self.step % eval_every == 0: - self.scheduler.step( - metrics=val_metrics[primary_metric]["metric"], - ) - else: - self.scheduler.step() - - torch.cuda.empty_cache() - - if checkpoint_every == -1: - self.save(checkpoint_file="checkpoint.pt", training_state=True) - - self.train_dataset.close_db() - if self.config.get("val_dataset", False): - self.val_dataset.close_db() - if self.config.get("test_dataset", False): - self.test_dataset.close_db() - - def _forward(self, batch_list): - # forward pass. - if self.config["model_attributes"].get("regress_forces", True): - out_energy, out_forces = self.model(batch_list) - else: - out_energy = self.model(batch_list) - - if out_energy.shape[-1] == 1: - out_energy = out_energy.view(-1) - - out = { - "energy": out_energy, - } - - if self.config["model_attributes"].get("regress_forces", True): - out["forces"] = out_forces - - return out - - def _compute_loss(self, out, batch_list) -> int: - loss = [] - - # Energy loss. - energy_target = torch.cat( - [batch.y.to(self.device) for batch in batch_list], dim=0 - ) - if self.normalizer.get("normalize_labels", False): - energy_target = self.normalizers["target"].norm(energy_target) - energy_mult = self.config["optim"].get("energy_coefficient", 1) - loss.append( - energy_mult * self.loss_fn["energy"](out["energy"], energy_target) - ) - - # Force loss. - if self.config["model_attributes"].get("regress_forces", True): - force_target = torch.cat( - [batch.force.to(self.device) for batch in batch_list], dim=0 - ) - if self.normalizer.get("normalize_labels", False): - force_target = self.normalizers["grad_target"].norm( - force_target - ) - - tag_specific_weights = self.config["task"].get( - "tag_specific_weights", [] - ) - if tag_specific_weights != []: - # handle tag specific weights as introduced in forcenet - assert len(tag_specific_weights) == 3 - - batch_tags = torch.cat( - [ - batch.tags.float().to(self.device) - for batch in batch_list - ], - dim=0, - ) - weight = torch.zeros_like(batch_tags) - weight[batch_tags == 0] = tag_specific_weights[0] - weight[batch_tags == 1] = tag_specific_weights[1] - weight[batch_tags == 2] = tag_specific_weights[2] - - if self.config["optim"].get("loss_force", "l2mae") == "l2mae": - # zero out nans, if any - found_nans_or_infs = not torch.all( - out["forces"].isfinite() - ) - if found_nans_or_infs is True: - logging.warning("Found nans while computing loss") - out["forces"] = torch.nan_to_num( - out["forces"], nan=0.0 - ) - - dists = torch.norm( - out["forces"] - force_target, p=2, dim=-1 - ) - weighted_dists_sum = (dists * weight).sum() - - num_samples = out["forces"].shape[0] - num_samples = distutils.all_reduce( - num_samples, device=self.device - ) - weighted_dists_sum = ( - weighted_dists_sum - * distutils.get_world_size() - / num_samples - ) - - force_mult = self.config["optim"].get( - "force_coefficient", 30 - ) - loss.append(force_mult * weighted_dists_sum) - else: - raise NotImplementedError - else: - # Force coefficient = 30 has been working well for us. - force_mult = self.config["optim"].get("force_coefficient", 30) - if self.config["task"].get("train_on_free_atoms", False): - fixed = torch.cat( - [batch.fixed.to(self.device) for batch in batch_list] - ) - mask = fixed == 0 - if ( - self.config["optim"] - .get("loss_force", "mae") - .startswith("atomwise") - ): - force_mult = self.config["optim"].get( - "force_coefficient", 1 - ) - natoms = torch.cat( - [ - batch.natoms.to(self.device) - for batch in batch_list - ] - ) - natoms = torch.repeat_interleave(natoms, natoms) - force_loss = force_mult * self.loss_fn["force"]( - out["forces"][mask], - force_target[mask], - natoms=natoms[mask], - batch_size=batch_list[0].natoms.shape[0], - ) - loss.append(force_loss) - else: - loss.append( - force_mult - * self.loss_fn["force"]( - out["forces"][mask], force_target[mask] - ) - ) - else: - loss.append( - force_mult - * self.loss_fn["force"](out["forces"], force_target) - ) - - # Sanity check to make sure the compute graph is correct. - for lc in loss: - assert hasattr(lc, "grad_fn") - - loss = sum(loss) - return loss - - def _compute_metrics(self, out, batch_list, evaluator, metrics={}): - natoms = torch.cat( - [batch.natoms.to(self.device) for batch in batch_list], dim=0 - ) - - target = { - "energy": torch.cat( - [batch.y.to(self.device) for batch in batch_list], dim=0 - ), - "forces": torch.cat( - [batch.force.to(self.device) for batch in batch_list], dim=0 - ), - "natoms": natoms, - } - - out["natoms"] = natoms - - if self.config["task"].get("eval_on_free_atoms", True): - fixed = torch.cat( - [batch.fixed.to(self.device) for batch in batch_list] - ) - mask = fixed == 0 - out["forces"] = out["forces"][mask] - target["forces"] = target["forces"][mask] - - s_idx = 0 - natoms_free = [] - for natoms in target["natoms"]: - natoms_free.append( - torch.sum(mask[s_idx : s_idx + natoms]).item() - ) - s_idx += natoms - target["natoms"] = torch.LongTensor(natoms_free).to(self.device) - out["natoms"] = torch.LongTensor(natoms_free).to(self.device) - - if self.normalizer.get("normalize_labels", False): - out["energy"] = self.normalizers["target"].denorm(out["energy"]) - out["forces"] = self.normalizers["grad_target"].denorm( - out["forces"] - ) - - metrics = evaluator.eval(out, target, prev_metrics=metrics) - return metrics - - def run_relaxations(self, split: str = "val") -> None: - ensure_fitted(self._unwrapped_model) - - # When set to true, uses deterministic CUDA scatter ops, if available. - # https://pytorch.org/docs/stable/generated/torch.use_deterministic_algorithms.html#torch.use_deterministic_algorithms - # Only implemented for GemNet-OC currently. - registry.register( - "set_deterministic_scatter", - self.config["task"].get("set_deterministic_scatter", False), - ) - - logging.info("Running ML-relaxations") - self.model.eval() - if self.ema: - self.ema.store() - self.ema.copy_to() - - evaluator_is2rs, metrics_is2rs = Evaluator(task="is2rs"), {} - evaluator_is2re, metrics_is2re = Evaluator(task="is2re"), {} - - # Need both `pos_relaxed` and `y_relaxed` to compute val IS2R* metrics. - # Else just generate predictions. - if ( - hasattr(self.relax_dataset[0], "pos_relaxed") - and self.relax_dataset[0].pos_relaxed is not None - ) and ( - hasattr(self.relax_dataset[0], "y_relaxed") - and self.relax_dataset[0].y_relaxed is not None - ): - split = "val" - else: - split = "test" - - ids = [] - relaxed_positions = [] - chunk_idx = [] - for i, batch in tqdm( - enumerate(self.relax_loader), total=len(self.relax_loader) - ): - if i >= self.config["task"].get("num_relaxation_batches", 1e9): - break - - # If all traj files already exist, then skip this batch - if check_traj_files( - batch, self.config["task"]["relax_opt"].get("traj_dir", None) - ): - logging.info(f"Skipping batch: {batch[0].sid.tolist()}") - continue - - relaxed_batch = ml_relax( - batch=batch, - model=self, - steps=self.config["task"].get("relaxation_steps", 200), - fmax=self.config["task"].get("relaxation_fmax", 0.0), - relax_opt=self.config["task"]["relax_opt"], - save_full_traj=self.config["task"].get("save_full_traj", True), - device=self.device, - transform=None, - ) - - if self.config["task"].get("write_pos", False): - systemids = [str(i) for i in relaxed_batch.sid.tolist()] - natoms = relaxed_batch.natoms.tolist() - positions = torch.split(relaxed_batch.pos, natoms) - batch_relaxed_positions = [pos.tolist() for pos in positions] - - relaxed_positions += batch_relaxed_positions - chunk_idx += natoms - ids += systemids - - if split == "val": - mask = relaxed_batch.fixed == 0 - s_idx = 0 - natoms_free = [] - for natoms in relaxed_batch.natoms: - natoms_free.append( - torch.sum(mask[s_idx : s_idx + natoms]).item() - ) - s_idx += natoms - - target = { - "energy": relaxed_batch.y_relaxed, - "positions": relaxed_batch.pos_relaxed[mask], - "cell": relaxed_batch.cell, - "pbc": torch.tensor([True, True, True]), - "natoms": torch.LongTensor(natoms_free), - } - - prediction = { - "energy": relaxed_batch.y, - "positions": relaxed_batch.pos[mask], - "cell": relaxed_batch.cell, - "pbc": torch.tensor([True, True, True]), - "natoms": torch.LongTensor(natoms_free), - } - - metrics_is2rs = evaluator_is2rs.eval( - prediction, - target, - metrics_is2rs, - ) - metrics_is2re = evaluator_is2re.eval( - {"energy": prediction["energy"]}, - {"energy": target["energy"]}, - metrics_is2re, - ) - - if self.config["task"].get("write_pos", False): - rank = distutils.get_rank() - pos_filename = os.path.join( - self.config["cmd"]["results_dir"], f"relaxed_pos_{rank}.npz" - ) - np.savez_compressed( - pos_filename, - ids=ids, - pos=np.array(relaxed_positions, dtype=object), - chunk_idx=chunk_idx, - ) - - distutils.synchronize() - if distutils.is_master(): - gather_results = defaultdict(list) - full_path = os.path.join( - self.config["cmd"]["results_dir"], - "relaxed_positions.npz", - ) - - for i in range(distutils.get_world_size()): - rank_path = os.path.join( - self.config["cmd"]["results_dir"], - f"relaxed_pos_{i}.npz", - ) - rank_results = np.load(rank_path, allow_pickle=True) - gather_results["ids"].extend(rank_results["ids"]) - gather_results["pos"].extend(rank_results["pos"]) - gather_results["chunk_idx"].extend( - rank_results["chunk_idx"] - ) - os.remove(rank_path) - - # Because of how distributed sampler works, some system ids - # might be repeated to make no. of samples even across GPUs. - _, idx = np.unique(gather_results["ids"], return_index=True) - gather_results["ids"] = np.array(gather_results["ids"])[idx] - gather_results["pos"] = np.concatenate( - np.array(gather_results["pos"])[idx] - ) - gather_results["chunk_idx"] = np.cumsum( - np.array(gather_results["chunk_idx"])[idx] - )[ - :-1 - ] # np.split does not need last idx, assumes n-1:end - - logging.info(f"Writing results to {full_path}") - np.savez_compressed(full_path, **gather_results) - - if split == "val": - for task in ["is2rs", "is2re"]: - metrics = eval(f"metrics_{task}") - aggregated_metrics = {} - for k in metrics: - aggregated_metrics[k] = { - "total": distutils.all_reduce( - metrics[k]["total"], - average=False, - device=self.device, - ), - "numel": distutils.all_reduce( - metrics[k]["numel"], - average=False, - device=self.device, - ), - } - aggregated_metrics[k]["metric"] = ( - aggregated_metrics[k]["total"] - / aggregated_metrics[k]["numel"] - ) - metrics = aggregated_metrics - - # Make plots. - log_dict = { - f"{task}_{k}": metrics[k]["metric"] for k in metrics - } - if self.logger is not None: - self.logger.log( - log_dict, - step=self.step, - split=split, - ) - - if distutils.is_master(): - logging.info(metrics) - - if self.ema: - self.ema.restore() - - registry.unregister("set_deterministic_scatter") diff --git a/ocpmodels/trainers/ocp_trainer.py b/ocpmodels/trainers/ocp_trainer.py index b90cdb7b5..768ef9c1b 100644 --- a/ocpmodels/trainers/ocp_trainer.py +++ b/ocpmodels/trainers/ocp_trainer.py @@ -68,8 +68,11 @@ def __init__( self, task, model, + outputs, dataset, optimizer, + loss_fns, + eval_metrics, identifier, timestamp_id=None, run_dir=None, @@ -87,8 +90,11 @@ def __init__( super().__init__( task=task, model=model, + outputs=outputs, dataset=dataset, optimizer=optimizer, + loss_fns=loss_fns, + eval_metrics=eval_metrics, identifier=identifier, timestamp_id=timestamp_id, run_dir=run_dir, From 15fdc56be4598c413828bebfdf81c9ba22c3dc02 Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Wed, 19 Jul 2023 12:02:32 -0700 Subject: [PATCH 15/63] black --- ocpmodels/modules/loss.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/ocpmodels/modules/loss.py b/ocpmodels/modules/loss.py index fae9f6f24..2efcea832 100644 --- a/ocpmodels/modules/loss.py +++ b/ocpmodels/modules/loss.py @@ -46,7 +46,9 @@ def forward( class DDPLoss(nn.Module): - def __init__(self, loss_fn, loss_name: str = "mae", reduction: str = "mean") -> None: + def __init__( + self, loss_fn, loss_name: str = "mae", reduction: str = "mean" + ) -> None: super().__init__() self.loss_fn = loss_fn self.loss_name = loss_name From c47111fba3867adba5a1c2449b62b90bf3a283ae Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Wed, 19 Jul 2023 17:07:19 -0700 Subject: [PATCH 16/63] reorganize free_atoms --- configs/goc_oc20_debug.yml | 6 +- configs/goc_stress_debug.yml | 7 +- ocpmodels/common/utils.py | 2 +- .../equiformer_v2/trainers/forces_trainer.py | 4 +- ocpmodels/trainers/base_trainer.py | 74 ++++++++++++------- 5 files changed, 57 insertions(+), 36 deletions(-) diff --git a/configs/goc_oc20_debug.yml b/configs/goc_oc20_debug.yml index 137bd2f50..3065a22a0 100644 --- a/configs/goc_oc20_debug.yml +++ b/configs/goc_oc20_debug.yml @@ -50,10 +50,8 @@ outputs: forces: shape: 3 level: atom - -task: - train_on_free_atoms: True - eval_on_free_atoms: True + train_on_free_atoms: True + eval_on_free_atoms: True model: name: gemnet_oc diff --git a/configs/goc_stress_debug.yml b/configs/goc_stress_debug.yml index 0534d5103..b8d38dfc8 100644 --- a/configs/goc_stress_debug.yml +++ b/configs/goc_stress_debug.yml @@ -74,6 +74,9 @@ outputs: forces: shape: 3 level: atom + train_on_free_atoms: True + eval_on_free_atoms: True + stress: level: system decomposition: @@ -82,10 +85,6 @@ outputs: anisotropic_stress: irrep_dim: 2 -task: - train_on_free_atoms: True - eval_on_free_atoms: True - model: name: gemnet_oc num_spherical: 7 diff --git a/ocpmodels/common/utils.py b/ocpmodels/common/utils.py index 82df7cfda..957f311a0 100644 --- a/ocpmodels/common/utils.py +++ b/ocpmodels/common/utils.py @@ -1009,7 +1009,7 @@ class _TrainingContext: trainer_cls = registry.get_trainer_class(trainer_name) assert trainer_cls is not None, "Trainer not found" trainer = trainer_cls( - task=config["task"], + task=config.get("task", {}), model=config["model"], outputs=config.get("outputs", None), dataset=config["dataset"], diff --git a/ocpmodels/models/equiformer_v2/trainers/forces_trainer.py b/ocpmodels/models/equiformer_v2/trainers/forces_trainer.py index c346d8cc7..691c7e065 100755 --- a/ocpmodels/models/equiformer_v2/trainers/forces_trainer.py +++ b/ocpmodels/models/equiformer_v2/trainers/forces_trainer.py @@ -16,7 +16,7 @@ from ocpmodels.modules.exponential_moving_average import ( ExponentialMovingAverage, ) -from ocpmodels.trainers import ForcesTrainer +from ocpmodels.trainers import OCPTrainer from .lr_scheduler import LRScheduler @@ -49,7 +49,7 @@ def add_weight_decay(model, weight_decay, skip_list=()): @registry.register_trainer("equiformerv2_forces") -class EquiformerV2ForcesTrainer(ForcesTrainer): +class EquiformerV2ForcesTrainer(OCPTrainer): # This trainer does a few things differently from the parent forces trainer: # - Different way of setting up model parameters with no weight decay. # - Support for cosine LR scheduler. diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index 6a9e287ac..f69c3c6cd 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -362,6 +362,31 @@ def load_task(self): self.config["outputs"][target_name]["decomposition"] )[subtarget] self.output_targets[subtarget]["parent"] = target_name + # inherent properties if not available + if "level" not in self.output_targets[subtarget]: + self.output_targets[subtarget][ + "level" + ] = self.output_targets[target_name].get( + "level", "system" + ) + if ( + "train_on_free_atoms" + not in self.output_targets[subtarget] + ): + self.output_targets[subtarget][ + "train_on_free_atoms" + ] = self.output_targets[target_name].get( + "train_on_free_atoms", True + ) + if ( + "eval_on_free_atoms" + not in self.output_targets[subtarget] + ): + self.output_targets[subtarget][ + "eval_on_free_atoms" + ] = self.output_targets[target_name].get( + "eval_on_free_atoms", True + ) ##TODO: Assert that all targets, loss fn, metrics defined and consistent self.evaluation_metrics = self.config.get("eval_metrics", {}) @@ -788,12 +813,12 @@ def _compute_loss(self, out, batch_list): batch_size = natoms.numel() natoms = torch.repeat_interleave(natoms, natoms) + fixed = torch.cat( + [batch.fixed.to(self.device) for batch in batch_list] + ) + mask = fixed == 0 + loss = [] - if self.config["task"].get("train_on_free_atoms", True): - fixed = torch.cat( - [batch.fixed.to(self.device) for batch in batch_list] - ) - mask = fixed == 0 for loss_fn in self.loss_fns: target_name, loss_info = loss_fn @@ -804,9 +829,10 @@ def _compute_loss(self, out, batch_list): ) pred = out[target_name] - if ( - self.config["task"].get("train_on_free_atoms", True) - and self.config["outputs"].get("level", "system") == "atom" + if self.output_targets[target_name].get( + "level", "system" + ) == "atom" and self.output_targets[target_name].get( + "train_on_free_atoms", True ): target = target[mask] pred = pred[mask] @@ -839,20 +865,18 @@ def _compute_metrics(self, out, batch_list, evaluator, metrics={}): [batch.natoms.to(self.device) for batch in batch_list], dim=0 ) - if self.config["task"].get("eval_on_free_atoms", True): - fixed = torch.cat( - [batch.fixed.to(self.device) for batch in batch_list] - ) - mask = fixed == 0 + ### Retrieve free atoms + fixed = torch.cat( + [batch.fixed.to(self.device) for batch in batch_list] + ) + mask = fixed == 0 - s_idx = 0 - natoms_free = [] - for _natoms in natoms: - natoms_free.append( - torch.sum(mask[s_idx : s_idx + _natoms]).item() - ) - s_idx += _natoms - natoms = torch.LongTensor(natoms_free).to(self.device) + s_idx = 0 + natoms_free = [] + for _natoms in natoms: + natoms_free.append(torch.sum(mask[s_idx : s_idx + _natoms]).item()) + s_idx += _natoms + natoms = torch.LongTensor(natoms_free).to(self.device) targets = {} for target_name in self.output_targets: @@ -874,10 +898,10 @@ def _compute_metrics(self, out, batch_list, evaluator, metrics={}): ) targets[parent_target_name] = parent_target - if ( - self.config["task"].get("eval_on_free_atoms", True) - and self.output_targets[target_name].get("level", "system") - == "atom" + if self.output_targets[target_name].get( + "level", "system" + ) == "atom" and self.output_targets[target_name].get( + "eval_on_free_atoms", True ): target = target[mask] out[target_name] = out[target_name][mask] From eacd66b15cdb53b707cd68e599f1c0c7bed08bc1 Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Thu, 20 Jul 2023 09:07:07 -0700 Subject: [PATCH 17/63] output config fix --- ocpmodels/trainers/base_trainer.py | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index f69c3c6cd..bd20f7f5c 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -364,18 +364,16 @@ def load_task(self): self.output_targets[subtarget]["parent"] = target_name # inherent properties if not available if "level" not in self.output_targets[subtarget]: - self.output_targets[subtarget][ - "level" - ] = self.output_targets[target_name].get( - "level", "system" - ) + self.output_targets[subtarget]["level"] = self.config[ + "outputs" + ][target_name].get("level", "system") if ( "train_on_free_atoms" not in self.output_targets[subtarget] ): self.output_targets[subtarget][ "train_on_free_atoms" - ] = self.output_targets[target_name].get( + ] = self.config["outputs"][target_name].get( "train_on_free_atoms", True ) if ( @@ -384,7 +382,7 @@ def load_task(self): ): self.output_targets[subtarget][ "eval_on_free_atoms" - ] = self.output_targets[target_name].get( + ] = self.config["outputs"][target_name].get( "eval_on_free_atoms", True ) From 024bc86f3eb72a04cd185f3678b45747919efb1f Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Thu, 20 Jul 2023 10:26:20 -0700 Subject: [PATCH 18/63] config naming --- ocpmodels/trainers/base_trainer.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index bd20f7f5c..4de265c1f 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -610,7 +610,7 @@ def save( if self.scaler else None, "best_val_metric": self.best_val_metric, - "primary_metric": self.config["metrics"][ + "primary_metric": self.config["eval_metrics"][ "primary_metric" ], }, From 5f47f8af3e3178587d1d51bf4428d6928804270b Mon Sep 17 00:00:00 2001 From: Janice Lan Date: Fri, 21 Jul 2023 16:04:31 -0700 Subject: [PATCH 19/63] support loss mean over all dimensions --- ocpmodels/modules/loss.py | 14 ++++++++++++-- ocpmodels/trainers/base_trainer.py | 3 ++- 2 files changed, 14 insertions(+), 3 deletions(-) diff --git a/ocpmodels/modules/loss.py b/ocpmodels/modules/loss.py index 2efcea832..114840cca 100644 --- a/ocpmodels/modules/loss.py +++ b/ocpmodels/modules/loss.py @@ -52,9 +52,15 @@ def __init__( super().__init__() self.loss_fn = loss_fn self.loss_name = loss_name - self.loss_fn.reduction = "sum" self.reduction = reduction - assert reduction in ["mean", "sum"] + assert reduction in ["mean", "mean_all", "sum"] + + # for forces, we want to sum over xyz errors and average over batches/atoms (mean) + # for other metrics, we want to average over all axes (mean_all) or leave as a sum (sum) + if reduction == "mean_all": + self.loss_fn.reduction = "mean" + else: + self.loss_fn.reduction = "sum" def forward( self, @@ -63,6 +69,9 @@ def forward( natoms: Optional[torch.Tensor] = None, batch_size: Optional[int] = None, ): + # ensure torch doesn't do any unwanted broadcasting + assert input.shape == target.shape + # zero out nans, if any found_nans_or_infs = not torch.all(input.isfinite()) if found_nans_or_infs is True: @@ -87,4 +96,5 @@ def forward( # across DDP replicas return loss * distutils.get_world_size() / num_samples else: + # if reduction is sum or mean over all axes, no other operations are needed return loss diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index 4de265c1f..67aa6adc4 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -514,6 +514,7 @@ def load_loss(self) -> None: for target in loss: loss_name = loss[target].get("fn", "mae") coefficient = loss[target].get("coefficient", 1) + loss_reduction = loss[target].get("reduction", "mean") if loss_name in ["l1", "mae"]: loss_fn = nn.L1Loss() @@ -527,7 +528,7 @@ def load_loss(self) -> None: raise NotImplementedError( f"Unknown loss function name: {loss_name}" ) - loss_fn = DDPLoss(loss_fn, loss_name) + loss_fn = DDPLoss(loss_fn, loss_name, loss_reduction) self.loss_fns.append( (target, {"fn": loss_fn, "coefficient": coefficient}) From 0a7d8155ba0822c8810ba32c9e659e89ce9c1d4c Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Fri, 21 Jul 2023 16:21:05 -0700 Subject: [PATCH 20/63] config backwards support --- ocpmodels/common/utils.py | 117 ++++++++++++++++++++--------- ocpmodels/datasets/lmdb_dataset.py | 19 +---- ocpmodels/modules/evaluator.py | 32 ++++---- ocpmodels/modules/transforms.py | 5 +- ocpmodels/trainers/base_trainer.py | 16 +++- 5 files changed, 119 insertions(+), 70 deletions(-) diff --git a/ocpmodels/common/utils.py b/ocpmodels/common/utils.py index 957f311a0..7c96d9f6f 100644 --- a/ocpmodels/common/utils.py +++ b/ocpmodels/common/utils.py @@ -1011,11 +1011,11 @@ class _TrainingContext: trainer = trainer_cls( task=config.get("task", {}), model=config["model"], - outputs=config.get("outputs", None), + outputs=config.get("outputs", {}), dataset=config["dataset"], optimizer=config["optim"], - loss_fns=config.get("loss_functions", None), - eval_metrics=config.get("evaluation_metrics", None), + loss_fns=config.get("loss_functions", {}), + eval_metrics=config.get("evaluation_metrics", {}), identifier=config["identifier"], timestamp_id=config.get("timestamp_id", None), run_dir=config.get("run_dir", "./"), @@ -1194,46 +1194,93 @@ def irreps_sum(l): return total -def load_old_targets(name, config): - normalizer = config.get("dataset", {}) - +def load_old_config(name, config): if name == "is2re": - targets = { - "energy": { - "irreps": 0, - "loss": config["optim"].get("loss_energy", "mae"), - "level": "system", - "coefficient": config["optim"].get("energy_coefficient", 1), - "normalizer": { - "mean": normalizer.get("target_mean", 0), - "stdev": normalizer.get("target_std", 1), + ### Define loss functions + _loss_fns = [ + { + "energy": { + "fn": config["optim"].get("loss_energy", "mae"), + "coefficient": config["optim"].get( + "energy_coefficient", 1 + ), }, } + ] + ### Define evaluation metrics + _eval_metrics = { + "metrics": {"energy": ["mae", "mse", "energy_within_threshold"]}, } - elif name == "s2ef": - targets = { - "energy": { - "irreps": 0, - "loss": config["optim"].get("loss_energy", "mae"), - "level": "system", - "coefficient": config["optim"].get("energy_coefficient", 1), - "normalizer": { - "mean": normalizer.get("target_mean", 0), - "stdev": normalizer.get("target_std", 1), + if "primary_metric" in config["task"]: + _eval_metrics["primary_metric"] = config["task"]["primary_metric"] + ### Define outputs + _outputs = {"energy": {"shape": 1, "level": "system"}} + if name == "s2ef": + ### Define loss functions + _loss_fns = [ + { + "energy": { + "fn": config["optim"].get("loss_energy", "mae"), + "coefficient": config["optim"].get( + "energy_coefficient", 1 + ), + }, + "forces": { + "fn": config["optim"].get("loss_forces", "l2mae"), + "coefficient": config["optim"].get( + "force_coefficient", 30 + ), }, + } + ] + ### Define evaluation metrics + _eval_metrics = { + "metrics": { + "misc": ["energy_forces_within_threshold"], + "energy": ["mae"], + "forces": [ + "forcesx_mae", + "forcesy_mae", + "forcesz_mae", + "mae", + "cosine_similarity", + "magnitude_error", + ], }, + } + if "primary_metric" in config["task"]: + _eval_metrics["primary_metric"] = config["task"]["primary_metric"] + ### Define outputs + _outputs = { + "energy": {"shape": 1, "level": "system"}, "forces": { - "irreps": 1, - "loss": config["optim"].get("loss_force", "mae"), + "shape": 3, "level": "atom", - "coefficient": config["optim"].get("force_coefficient", 1), - "normalizer": { - "mean": normalizer.get("grad_target_mean", 0), - "stdev": normalizer.get("grad_target_std", 1), - }, + "train_on_free_atoms": ( + config["task"].get("train_on_free_atoms", False) + ), + "eval_on_free_atoms": ( + config["task"].get("eval_on_free_atoms", True) + ), }, } - else: - targets = {} - return targets + if config["dataset"].get("normalize_labels", False): + normalizer = { + "energy": { + "mean": config["dataset"]["target_mean"], + "stdev": config["dataset"]["target_std"], + }, + "forces": { + "mean": config["dataset"]["grad_target_mean"], + "stdev": config["dataset"]["grad_target_std"], + }, + } + config["dataset"]["normalizer"] = normalizer + + config["dataset"]["key_mapping"] = {"y": "energy", "force": "forces"} + ### Update config + config.update({"loss_fns": _loss_fns}) + config.update({"eval_metrics": _eval_metrics}) + config.update({"outputs": _outputs}) + return config diff --git a/ocpmodels/datasets/lmdb_dataset.py b/ocpmodels/datasets/lmdb_dataset.py index 03e7e88d7..2db5b1583 100644 --- a/ocpmodels/datasets/lmdb_dataset.py +++ b/ocpmodels/datasets/lmdb_dataset.py @@ -119,22 +119,7 @@ def __init__(self, config, transform=None) -> None: self.num_samples = len(self.available_indices) self.key_mapping = self.config.get("key_mapping", None) - self.transforms = self.config.get("transforms", {}) - self._normalizers = self.transforms.get("normalizer", None) - - self.load() - - def load(self): - self.normalizers = {} - if self._normalizers: - for target in self._normalizers: - self.normalizers[target] = Normalizer( - mean=self._normalizers[target].get("mean", 0), - std=self._normalizers[target].get("stdev", 1), - ) - self.transforms.pop("normalizer") - - self.transform = DataTransforms(self.transforms) + self.transforms = DataTransforms(self.config.get("transforms", {})) def __len__(self) -> int: return self.num_samples @@ -175,7 +160,7 @@ def __getitem__(self, idx: int): data_object[new_property] = data_object[_property] del data_object[_property] - self.transform(data_object) + self.transforms(data_object) return data_object diff --git a/ocpmodels/modules/evaluator.py b/ocpmodels/modules/evaluator.py index 1539bc5dc..253f366d0 100644 --- a/ocpmodels/modules/evaluator.py +++ b/ocpmodels/modules/evaluator.py @@ -35,9 +35,9 @@ class Evaluator: task_metrics = { "s2ef": { - "energy": {"metrics": ["mae"]}, - "forces": { - "metrics": [ + "metrics": { + "energy": ["mae"], + "forces": [ "forcesx_mae", "forcesy_mae", "forcesz_mae", @@ -45,12 +45,12 @@ class Evaluator: "cosine_similarity", "magnitude_error", "energy_forces_within_threshold", - ] - }, + ], + } }, "is2rs": { - "positions": { - "metrics": [ + "metrics": { + "positions": [ "average_distance_within_threshold", "mae", "mse", @@ -58,11 +58,13 @@ class Evaluator: } }, "is2re": { - "metrics": [ - "mae", - "mse", - "energy_within_threshold", - ] + "metrics": { + "energy": [ + "mae", + "mse", + "energy_within_threshold", + ] + }, }, } @@ -73,9 +75,11 @@ class Evaluator: "ocp": None, } - def __init__(self, task: str = None, eval_metrics: str = None) -> None: + def __init__(self, task: str = None, eval_metrics: dict = {}) -> None: self.task = task - self.target_metrics = self.task_metrics.get(task, eval_metrics) + self.target_metrics = ( + eval_metrics if eval_metrics else self.task_metrics.get(task, {}) + ) def eval(self, prediction, target, prev_metrics={}): diff --git a/ocpmodels/modules/transforms.py b/ocpmodels/modules/transforms.py index 95eb18f5b..0f37c1556 100644 --- a/ocpmodels/modules/transforms.py +++ b/ocpmodels/modules/transforms.py @@ -8,10 +8,13 @@ def __init__(self, config): self.config = config def __call__(self, data_object): - if self.config is None: + if not self.config: return data_object for transform_fn in self.config: + # TODO move normalizer into dataset + if transform_fn == "normalizer": + continue data_object = eval(transform_fn)( data_object, self.config[transform_fn] ) diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index 67aa6adc4..b1a0ac689 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -38,7 +38,7 @@ check_traj_files, get_commit_hash, irreps_sum, - load_old_targets, + load_old_config, load_state_dict, save_checkpoint, ) @@ -182,6 +182,10 @@ def __init__( if distutils.is_master(): print(yaml.dump(self.config, default_flow_style=False)) + ### backwards compatability with OCP v<2.0 + if self.name in ["is2re", "s2ef"]: + self.config = load_old_config(self.name, self.config) + self.load() def load(self) -> None: @@ -286,7 +290,6 @@ def load_datasets(self) -> None: self.train_sampler, ) - self.train_dataset[0] if self.config.get("val_dataset", None): if self.config["val_dataset"].get("use_train_settings", True): val_config = self.config["dataset"].copy() @@ -346,7 +349,14 @@ def load_datasets(self) -> None: def load_task(self): # Normalizer for the dataset. - self.normalizers = self.train_dataset.normalizers + self.normalizers = {} + if "normalizer" in self.config["dataset"]: + normalizer = self.config["dataset"]["normalizer"] + for target in normalizer: + self.normalizers[target] = Normalizer( + mean=normalizer[target].get("mean", 0), + std=normalizer[target].get("stdev", 1), + ) self.output_targets = {} for target_name in self.config["outputs"]: From 73fba567e7a66cff8d8da504e7b920565cfd65c1 Mon Sep 17 00:00:00 2001 From: Janice Lan Date: Tue, 25 Jul 2023 11:27:21 -0700 Subject: [PATCH 21/63] equiformer can now run --- ocpmodels/models/equiformer_v2/equiformer_v2_oc20.py | 7 +++++-- ocpmodels/models/equiformer_v2/trainers/forces_trainer.py | 8 ++++---- 2 files changed, 9 insertions(+), 6 deletions(-) diff --git a/ocpmodels/models/equiformer_v2/equiformer_v2_oc20.py b/ocpmodels/models/equiformer_v2/equiformer_v2_oc20.py index df1e17350..8d2e451ea 100644 --- a/ocpmodels/models/equiformer_v2/equiformer_v2_oc20.py +++ b/ocpmodels/models/equiformer_v2/equiformer_v2_oc20.py @@ -494,9 +494,12 @@ def forward(self, data): forces = forces.view(-1, 3) if not self.regress_forces: - return energy + return {"energy": energy} else: - return energy, forces + return { + "energy": energy, + "forces": forces, + } # Initialize the edge rotation matrics def _init_edge_rot_mat(self, data, edge_index, edge_distance_vec): diff --git a/ocpmodels/models/equiformer_v2/trainers/forces_trainer.py b/ocpmodels/models/equiformer_v2/trainers/forces_trainer.py index 691c7e065..790c35ac5 100755 --- a/ocpmodels/models/equiformer_v2/trainers/forces_trainer.py +++ b/ocpmodels/models/equiformer_v2/trainers/forces_trainer.py @@ -56,7 +56,7 @@ class EquiformerV2ForcesTrainer(OCPTrainer): # - When using the LR scheduler, it first converts the epochs into number of # steps and then passes it to the scheduler. That way in the config # everything can be specified in terms of epochs. - def load_model(self): + def load_model(self) -> None: # Build model if distutils.is_master(): logging.info(f"Loading model: {self.config['model']}") @@ -75,7 +75,7 @@ def load_model(self): and loader.dataset[0].x is not None else None, bond_feat_dim, - self.num_targets, + 1, **self.config["model_attributes"], ).to(self.device) @@ -103,7 +103,7 @@ def load_model(self): self.model, device_ids=[self.device] ) - def load_optimizer(self): + def load_optimizer(self) -> None: optimizer = self.config["optim"].get("optimizer", "AdamW") optimizer = getattr(optim, optimizer) optimizer_params = self.config["optim"]["optimizer_params"] @@ -121,7 +121,7 @@ def load_optimizer(self): **optimizer_params, ) - def load_extras(self): + def load_extras(self) -> None: def multiply(obj, num): if isinstance(obj, list): for i in range(len(obj)): From efd956d4659ce1a69b7a1349a0e8c5a4f2e8d84c Mon Sep 17 00:00:00 2001 From: Janice Lan Date: Tue, 25 Jul 2023 18:06:18 -0700 Subject: [PATCH 22/63] add example equiformer config --- .../2M/equiformer_v2/equiformer_refactor.yml | 131 ++++++++++++++++++ 1 file changed, 131 insertions(+) create mode 100755 configs/s2ef/2M/equiformer_v2/equiformer_refactor.yml diff --git a/configs/s2ef/2M/equiformer_v2/equiformer_refactor.yml b/configs/s2ef/2M/equiformer_v2/equiformer_refactor.yml new file mode 100755 index 000000000..5ad262728 --- /dev/null +++ b/configs/s2ef/2M/equiformer_v2/equiformer_refactor.yml @@ -0,0 +1,131 @@ +trainer: equiformerv2_forces + +dataset: + train: + format: lmdb + src: /datasets01/open_catalyst/oc20/082422/struct_to_energy_forces/train/2M + key_mapping: + y: energy + force: forces + transforms: + normalizer: + energy: + mean: -0.7554450631141663 + stdev: 2.887317180633545 + forces: + mean: 0 + stdev: 2.887317180633545 + val: + src: /datasets01/open_catalyst/oc20/082422/struct_to_energy_forces/val/id_30k + # test: + # src: /datasets01/open_catalyst/oc20/082422/struct_to_energy_forces/val/id_30k + +logger: + name: wandb + project: is2dt_v4 + +loss_functions: + - energy: + fn: mae + coefficient: 1 + - forces: + fn: l2mae + coefficient: 100 + +evaluation_metrics: + metrics: + energy: + - mae + - mse + - energy_within_threshold + forces: + - mae + - cosine_similarity + misc: + - energy_forces_within_threshold + primary_metric: forces_mae + +outputs: + energy: + shape: 1 + level: system + forces: + shape: 3 + level: atom + train_on_free_atoms: True + eval_on_free_atoms: True + +slurm: + constraint: "volta32gb" + +model: + name: equiformer_v2 + + use_pbc: True + regress_forces: True + otf_graph: True + max_neighbors: 20 + max_radius: 12.0 + max_num_elements: 90 + + num_layers: 12 + sphere_channels: 128 + attn_hidden_channels: 64 # [64, 96] This determines the hidden size of message passing. Do not necessarily use 96. + num_heads: 8 + attn_alpha_channels: 64 # Not used when `use_s2_act_attn` is True. + attn_value_channels: 16 + ffn_hidden_channels: 128 + norm_type: 'layer_norm_sh' # ['rms_norm_sh', 'layer_norm', 'layer_norm_sh'] + + lmax_list: [6] + mmax_list: [2] + grid_resolution: 18 # [18, 16, 14, None] For `None`, simply comment this line. + + num_sphere_samples: 128 + + edge_channels: 128 + use_atom_edge_embedding: True + share_atom_edge_embedding: False # If `True`, `use_atom_edge_embedding` must be `True` and the atom edge embedding will be shared across all blocks. + distance_function: 'gaussian' + num_distance_basis: 512 # not used + + attn_activation: 'silu' + use_s2_act_attn: False # [False, True] Switch between attention after S2 activation or the original EquiformerV1 attention. + use_attn_renorm: True # Attention re-normalization. Used for ablation study. + ffn_activation: 'silu' # ['silu', 'swiglu'] + use_gate_act: False # [True, False] Switch between gate activation and S2 activation + use_grid_mlp: True # [False, True] If `True`, use projecting to grids and performing MLPs for FFNs. + use_sep_s2_act: True # Separable S2 activation. Used for ablation study. + + alpha_drop: 0.1 # [0.0, 0.1] + drop_path_rate: 0.05 # [0.0, 0.05] + proj_drop: 0.0 + + weight_init: 'uniform' # ['uniform', 'normal'] + +optim: + batch_size: 4 # 6 + eval_batch_size: 4 # 6 + load_balancing: atoms + num_workers: 8 + lr_initial: 0.0004 # [0.0002, 0.0004], eSCN uses 0.0008 for batch size 96 + + optimizer: AdamW + optimizer_params: + weight_decay: 0.001 + scheduler: LambdaLR + scheduler_params: + lambda_type: cosine + warmup_factor: 0.2 + warmup_epochs: 0.1 + lr_min_factor: 0.01 # + + max_epochs: 30 + force_coefficient: 100 + energy_coefficient: 2 + clip_grad_norm: 100 + ema_decay: 0.999 + loss_energy: mae + loss_force: l2mae + + eval_every: 5000 From 4477f90cf1026170e0d7d49963ecf4561af6c19f Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Thu, 27 Jul 2023 14:26:34 -0700 Subject: [PATCH 23/63] handle arbitrary torch loss fns --- ocpmodels/common/utils.py | 16 ++++++++++++++++ ocpmodels/trainers/base_trainer.py | 20 ++++++++------------ 2 files changed, 24 insertions(+), 12 deletions(-) diff --git a/ocpmodels/common/utils.py b/ocpmodels/common/utils.py index 7c96d9f6f..fc0a99c4d 100644 --- a/ocpmodels/common/utils.py +++ b/ocpmodels/common/utils.py @@ -37,6 +37,7 @@ from torch_scatter import scatter, segment_coo, segment_csr import ocpmodels +from ocpmodels.modules.loss import AtomwiseL2Loss, L2MAELoss if TYPE_CHECKING: from torch.nn.modules.module import _IncompatibleKeys @@ -1284,3 +1285,18 @@ def load_old_config(name, config): config.update({"eval_metrics": _eval_metrics}) config.update({"outputs": _outputs}) return config + + +def get_loss_module(loss_name): + if loss_name in ["l1", "mae"]: + loss_fn = nn.L1Loss() + elif loss_name == "mse": + loss_fn = nn.MSELoss() + elif loss_name == "l2mae": + loss_fn = L2MAELoss() + elif loss_name == "atomwisel2": + loss_fn = AtomwiseL2Loss() + else: + raise NotImplementedError(f"Unknown loss function name: {loss_name}") + + return loss_fn diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index b1a0ac689..bb71d160b 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -37,6 +37,7 @@ cg_decomp_mat, check_traj_files, get_commit_hash, + get_loss_module, irreps_sum, load_old_config, load_state_dict, @@ -46,7 +47,7 @@ from ocpmodels.modules.exponential_moving_average import ( ExponentialMovingAverage, ) -from ocpmodels.modules.loss import AtomwiseL2Loss, DDPLoss, L2MAELoss +from ocpmodels.modules.loss import DDPLoss from ocpmodels.modules.normalizer import Normalizer from ocpmodels.modules.scaling.compat import load_scales_compat from ocpmodels.modules.scaling.util import ensure_fitted @@ -526,18 +527,13 @@ def load_loss(self) -> None: coefficient = loss[target].get("coefficient", 1) loss_reduction = loss[target].get("reduction", "mean") - if loss_name in ["l1", "mae"]: - loss_fn = nn.L1Loss() - elif loss_name == "mse": - loss_fn = nn.MSELoss() - elif loss_name == "l2mae": - loss_fn = L2MAELoss() - elif loss_name == "atomwisel2": - loss_fn = AtomwiseL2Loss() + ### if torch module name provided, use that directly + if hasattr(nn, loss_name): + loss_fn = getattr(nn, loss_name)() + ### otherwise, retrieve the correct module based off old naming else: - raise NotImplementedError( - f"Unknown loss function name: {loss_name}" - ) + loss_fn = get_loss_module(loss_name) + loss_fn = DDPLoss(loss_fn, loss_name, loss_reduction) self.loss_fns.append( From 0bd89359b08e859b35f2c15a75b3bbf2b0cdd51d Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Tue, 1 Aug 2023 09:58:53 -0700 Subject: [PATCH 24/63] correct primary metric def --- ocpmodels/trainers/base_trainer.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index bb71d160b..298124305 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -617,9 +617,10 @@ def save( if self.scaler else None, "best_val_metric": self.best_val_metric, - "primary_metric": self.config["eval_metrics"][ - "primary_metric" - ], + "primary_metric": self.evaluation_metrics.get( + "primary_metric", + self.evaluator.task_primary_metric[self.name], + ), }, checkpoint_dir=self.config["cmd"]["checkpoint_dir"], checkpoint_file=checkpoint_file, From ac13093e84b020c638ea8ac639a07ffffc365e93 Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Tue, 1 Aug 2023 13:27:57 -0700 Subject: [PATCH 25/63] update s2ef portion of OCP tutorial --- tutorials/OCP_Tutorial.ipynb | 8602 +++++++++++++++------------------- 1 file changed, 3687 insertions(+), 4915 deletions(-) diff --git a/tutorials/OCP_Tutorial.ipynb b/tutorials/OCP_Tutorial.ipynb index 9930cfa89..fcb84a8a9 100644 --- a/tutorials/OCP_Tutorial.ipynb +++ b/tutorials/OCP_Tutorial.ipynb @@ -1,4927 +1,3699 @@ { - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "view-in-github" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "dzeHYa5GCxN7" + }, + "outputs": [], + "source": [ + "# MIT License\n", + "#\n", + "#@title Copyright (c) 2021 CCAI Community Authors { display-mode: \"form\" }\n", + "#\n", + "# Permission is hereby granted, free of charge, to any person obtaining a\n", + "# copy of this software and associated documentation files (the \"Software\"),\n", + "# to deal in the Software without restriction, including without limitation\n", + "# the rights to use, copy, modify, merge, publish, distribute, sublicense,\n", + "# and/or sell copies of the Software, and to permit persons to whom the\n", + "# Software is furnished to do so, subject to the following conditions:\n", + "#\n", + "# The above copyright notice and this permission notice shall be included in\n", + "# all copies or substantial portions of the Software.\n", + "#\n", + "# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n", + "# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n", + "# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\n", + "# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n", + "# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n", + "# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n", + "# DEALINGS IN THE SOFTWARE." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "13i7KQ9t-CV8" + }, + "source": [ + "# Open Catalyst Project Tutorial Notebook\n", + "Author(s):\n", + "* [Muhammed Shuaibi](https://mshuaibii.github.io/), CMU, mshuaibi@andrew.cmu.edu\n", + "* [Abhishek Das](https://abhishekdas.com/), FAIR, abhshkdz@fb.com \n", + "* [Adeesh Kolluru](https://adeeshkolluru.github.io/), CMU, akolluru@andrew.cmu.edu\n", + "* [Brandon Wood](https://wood-b.github.io/), NERSC, bwood@lbl.gov \n", + "* [Janice Lan](https://www.linkedin.com/in/janice-lan), FAIR, janlan@fb.com\n", + "* [Anuroop Sriram](https://www.linkedin.com/in/anuroopsriram), FAIR, anuroops@fb.com\n", + "* [Zachary Ulissi](https://ulissigroup.cheme.cmu.edu/), CMU, zulissi@andrew.cmu.edu\n", + "* [Larry Zitnick](http://larryzitnick.org/), FAIR, zitnick@fb.com\n", + "\n", + "FAIR - Facebook AI Research\n", + "\n", + "CMU - Carnegie Mellon University\n", + "\n", + "NERSC - National Energy Research Scientific Computing Center\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "E_qIKf8erkfC" + }, + "source": [ + "## Table of Contents\n", + "\n", + "* [Background](#background)\n", + "* [Objective](#objective)\n", + "* [Climate Impact](#climate-impact)\n", + "* [Target Audience](#target-audience)\n", + "* [Background & Prerequisites](#background-and-prereqs)\n", + "* [Software Requirements](#software-requirements)\n", + "* [Dataset Overview & Visualization](#data-description)\n", + " * [Download](#download)\n", + " * [Visualization](#visual)\n", + " * [Data contents](#contents)\n", + "* [Tasks](#tasks)\n", + " * [S2EF](#s2ef)\n", + " * [IS2RE](#is2re)\n", + " * [IS2RS](#is2rs)\n", + "* [OCP Calculator](#calc)\n", + "* [Model development](#model-dev)\n", + "* [Running on command line](#cmd)\n", + "* [Limitations](#limit)\n", + "* [Next steps](#steps)\n", + "* [References](#references)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "JkjKcVJ47hSN" + }, + "source": [ + "## Background \n", + "The discovery of efficient and economic catalysts (materials) are needed to enable the widespread use of renewable energy technologies. A common approach in discovering high performance catalysts is using molecular simulations. Specifically, each simulation models the interaction of a catalyst surface with molecules that are commonly seen in electrochemical reactions. By predicting these interactions accurately, the catalyst's impact on the overall rate of a chemical reaction may be estimated.\n", + "\n", + "An important quantity in screening catalysts is their adsorption energy for the molecules, referred to as `adsorbates', involved in the reaction of interest. The adsorption energy may be found by simulating the interaction of the adsorbate molecule on the surface of the catalyst to find their resting or relaxed energy, i.e., how tightly the adsorbate binds to the catalyst's surface (visualized below). The rate of the chemical reaction, a value of high practical importance, is then commonly approximated using simple functions of the adsorption energy. The goal of this tutorial specifically and the project overall is to encourage research and benchmark progress towards training ML models to approximate this relaxation.\n", + "\n", + "Specifically, during the course of a relaxation, given an initial set of atoms and their positions, the task is to iteratively estimate atomic forces and update atomic positions until a relaxed state is reached. The energy corresponding to the relaxed state is the structure's 'relaxed energy'.\n", + "\n", + "As part of the [Open Catalyst Project](https://github.com/Open-Catalyst-Project/ocp) (OCP), we identify three key tasks ML models need to perform well on in\n", + "order to effectively approximate DFT --\n", + "\n", + " 1) Given an **I**nitial **S**tructure, predict the **R**elaxed **E**nergy of the relaxed strucutre (**IS2RE**),\n", + "\n", + " 2) Given an **I**nitial **S**tructure, predict the **R**elaxed **S**tructure (**IS2RS**),\n", + "\n", + " 3) Given any **S**tructure, predict the structure **E**nergy and per-atom **F**orces (**S2EF**)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FPeCifZbtiKJ" + }, + "source": [ + "![Capture2.PNG](data:image/png;base64,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)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PvjO99jp7xnh" + }, + "source": [ + "## Objective \n", + "This notebook serves as a tutorial for interacting with the Open Catalyst Project.\n", + "\n", + "By the end of this tutorial, users will have gained:\n", + "* Intuition to the dataset and it's properties\n", + "* Knowledge of the various OCP tasks: IS2RE, IS2RS, S2EF\n", + "* Steps to train, validate, and predict a model on the various tasks\n", + "* A walkthrough on creating your own model\n", + "* (Optional) Creating your own dataset for other molecular/catalyst applications \n", + "* (Optional) Using pretrained models directly with an [ASE](https://wiki.fysik.dtu.dk/ase/#:~:text=The%20Atomic%20Simulation%20Environment%20(ASE,under%20the%20GNU%20LGPL%20license.)-style calculator." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "99jkSa_KmrDH" + }, + "source": [ + "\n", + "# Climate Impact\n", + "\n", + "Scalable and cost-effective solutions to renewable energy storage are essential to addressing the world’s rising energy needs while reducing climate change. As illustrated in the figure below, as we increase our reliance on renewable energy sources such as wind and solar, which produce intermittent power, storage is needed to transfer power from times of peak generation to peak demand. This may require the storage of power for hours, days, or months. One solution that offers the potential of scaling to nation-sized grids is the conversion of renewable energy to other fuels, such as hydrogen. To be widely adopted, this process requires cost-effective solutions to running chemical reactions.\n", + "\n", + "An open challenge is finding low-cost catalysts to drive these reactions at high rates. Through the use of quantum mechanical simulations (Density Functional Theory, DFT), new catalyst structures can be tested and evaluated. Unfortunately, the high computational cost of these simulations limits the number of structures that may be tested. The use of AI or machine learning may provide a method to efficiently approximate these calculations; reducing the time required from 24} hours to a second. This capability would transform the search for new catalysts from the present day practice of evaluating O(1,000) of handpicked candidates to the brute force search over millions or even billions of candidates.\n", + "\n", + "As part of OCP, we publicly released the world's largest quantum mechanical simulation dataset -- [OC20](https://github.com/Open-Catalyst-Project/ocp/blob/master/DATASET.md) -- in the Fall of 2020 along with a suite of baselines and evaluation metrics. The creation of the dataset required over 70 million hours of compute. This dataset enables the exploration of techniques that will generalize across different catalyst materials and adsorbates. If successful, models trained on the dataset could enable the computational testing of millions of catalyst materials for a wide variety of chemical reactions. However, techniques that achieve the accuracies required** for practical impact are still beyond reach and remain an open area for research, thus encouraging research in this important area to help in meeting the world's energy needs in the decades ahead.\n", + "\n", + "** The computational catalysis community often aims for an adsorption energy MAE of 0.1-0.2 eV for practical relevance." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jcpOlBcTsYVa" + }, + "source": [ + "![Capture.PNG](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABGoAAAHOCAYAAADAAu9ZAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAP+lSURBVHhe7L13dFzJeeb9/bW752xeb87R6yDJlhUsy1awsmRJVpwZDjMRCSLnnHPuBDRyI+ecMwHmHIacwEnMJAigAVBa5/XzvU/dvkADJEcjaWTTq3rP+Z3KdevWvQ2gHrxV/f9BmzZt2rRp06ZNmzZt2rRp06ZN23NhWqjRpk2bNm3atGnTpk2bNm3atGl7TkwLNdq0adOmTZs2bdq0adOmTZs2bc+JaaFGmzZt2rRp06ZNmzZt2rRp06btOTEt1GjTpk2bNm3atGnTpk2bNm3atD0npoUabdq0adOmTZs2bdq0adOmTZu258S0UKNNmzZt2rRp06ZNmzZt2rRp0/acmBZqtGnTpk2bNm3atGnTpk2bNm3anhPTQo02bdq0adOmTZs2bdq0adOmTdtzYlqo0aZNmzZt2rRp06ZNmzZt2rRpe05MCzXatGnTpk2bNm3atGnTpk2bNm3PiWmhRps2bdq0adOmTZs2bdq0adOm7TkxLdRo06ZNmzZt2rRp06ZN2y/Q/vqv/1qj0fw/xi/StFCjTZs2bdq0adOmTZs2bb8A+6u/+iv8xV/8Bf7sz/4Mf/qnf6rRaP4fgZ9pfrb5Gf9FiDZaqNGmTZs2bdq0adOmTZu2D9j+7//9v/g//+f/YGVlBffu3cOdO3cUt2/f1mg0f4fh55if6UePHuHHP/4x/vIv/9Lzqf/gTAs12rRp06ZNmzZt2rRp0/YBGv/D/ud//udqIXf9+nWcPHUKC4vHcFSYX1jchGmTp+bvqGPmPau9We6d/8y8p2D2u7Nvs713vhn3ru8d976mmb9Z5il/ar6n/lPny1PPu753Oduodiz34J0242a9p9Xdme+d5122M9xW15P2ZrPsKeVm3rY6whN13ivfK75Z5gm9Mct3ttnEq5433u2900/UfUb+zvrb6pihF5tl5GltPHinzbgKveLe+d7pnXlmvndoxhVe6ZOnTuPK1Vdw/8FD/Mmf/OkH7lWjhRpt2rRp06ZNmzZt2rRp+wCN3jTcHnHz5k3ML55Ac+8IHO3DKG8bU5S1jqJEKG0d26SM+W3MEyRknPUI81jfaGPA+ir0onwHZttt9TzXMeJbbNUxx2KM1Rzvdsw6Et9kRx7reeWbYzbrMO3dvxm3eLB6Qu8877hKS7vNtMTZxsTmxc70Ju3b2aznlWf3wHwz/gRS5pBwJxXvm/HN+pUS36RD0h3jKt8p4XthtHmyXpUHp5Sb8SfoNKhmKGmGT6PmfVAt7Z+WX9M5gdonGH8qrK/iXR486TqvUCFl2/DOk3i9hCZGesLDOBoUEx7MtFF3K38Cru4JNHrR1GPQNjCLkbmzOHf9Fu6t/Fg+81qo0aZNmzZt2rRp06ZNm7bn1ijU/Mmf/AneeustjE3PI7ZhDr9XcQMfrXgXv+V4Bx8Sfs36Nn7d9i5+3f4ufkP4LSn7sJ15b0n6LRX/KJG6TP9P25v4X1L2a6wjfFjafMR+Ex+2Sdz2Dn7L/g4+KvHfln4Z/pbwEcn/iKonfUv8N1lX4h+Sur8pfMQhdaR/XusjwoekDss+7JA2jptqvB+rvInflpD5H/JcS/UpdT7MuhXv4LelD/bzIYkz5D2yP5azH/bHe/6wp8wol3bSL69BflvqsJ9PVtzEpxS3FL9beRufqLyFj0veJyX8lPMOPiV5n5SyT0rfn5R2Rv2bMsc38WnJ+wMp+6zUIZ/xhORzTgmFzzjfxWeq3sXnqm/hc1U3BSNk3mcl/EL1bfyh5H1eYPhFSX9J+ILEyZek3ZcVNyV+E1+R+Nel3OAW/ohIX98Qvinl35L0NwWG3665vcm3hD+uvYNve8G0oo7cxnfr7+B7DXfwfQl/IHk/rL/rhZF+oeGecBcvSj2Du3hJ2LUT1z287E3jXexuvIM9TXexp/ke9jUZ7G+6jwPN97HfA+PkkOT7ND3wgul7BtLel7Tch1/LA/i1esG04N/6cBsBUhbQel+4h8C2+whsFyQ8vBk+QJDEjwhB7fckvIcQiYdIWaiEYVK+jY7thHc8RHinhEKExKM6lxBNuh4gRvEQsd0PJbyPWCGu+4GHh4iTsvjuJST2PEJq70Nk9C0psgYeCRIOLiF78BFyh5dRs7CuhRpt2rRp06ZNmzZt2rRpe57NPJ/mzTffxMjUPKLq5/FJx9v4sOMOPiT8hv02fsN2Gx+y3xXueULJt93Cr1pv4n/bb+HXhQ9JnQ8Lvyb5/0v43xL/ddaz3sZv2u5sR/LM+h+W/j8s9baVs51c5zc88d903DXqCh8RfkvSHxJ+g7Ce1OF4P6LypX7FXdWOY/2w456CdX5D1TH6/HWHjEtgO2Jex4T9f6TyHj4ifX1Y+C2J/1YF+zLqM/1RSX9McV+Fv1N5H78tIfmoxD9W+QCfkPDjUv4J4eOS/wnp65MSfsp5H7/LUMb2aanze1KukDjTJr/nvItPC7/v4Q+c9yQkkq66h89U38cfSGjy2ar7+KzkfYZxCf+wZjtflLwve/hK9QPhPr5GpEzhlf5G7YMnqWP40KDuIf5I0t/08O36B/jjhgf4joTku/UP8T2B4Wa6YUl4iO9LvR+4HuKHjUv4oYtI3MMLkn5B8hm+2PgILzUtCQ8Vu5qX8HLzI+z2sMekyWBv8zL2tixjn4T7vTggdUwOSrnJIdK6YtDizTJ8JE/RtgrfthVhWXgEv/ZlhT/pMOIkoP0RAoXDkkeCJO+IEEw6VjYJIZ2rHpY3Ce1aUYQLkV1uRHWvIrJb4t3LiOpZQbQQL+kEIbFnFYm9q0gSkvu2SOlbQaqEaf1upA+sIWNQGJL44Kqicn4df6WFGm3atGnTpk2bNm3atGl7fs1bqBmdmkdcw1F8pvJdfKLyLj5WcRcfddzGxxV3lMigcNxV6Y/ab+O3JSS/Y7+Dj0v6d5gvdX5H+JjjHj5mk9B+T/I9aRVK3QoTI22UST27WU/wxClw/K6Evyttf1fqM66EES8+rsbE68pYZOy8PkUSQyC5r+rwfj4pmPU+UXlP8XHhYx7M/tj/J533BaP8E57w49L3J6VflpntVVr4XYovXlB0+f3KB4o/UNxXfEbin3U+wGcElW+GAvMIyz8rfXxervuHVVt8oeq+wkx/vuY+PldN7qnwC5L+Qs0DFX6p9gG+XCfU3jeQ+Fcl72tSbvJ1SZtCC/mjHelvkfqH2/h2A1na5DsND/Bd1xbfE74vUIjZYkuYeUHCFxsfbAovu5qERokLL5tI3stSd1OIaTHY27qs2NeyjP1e7JM6hPEDrSs4SIGlZdWDR3CRduSQBx8lvmzhp1j1sBX3b3cjoGMVhztWlAAT6OFw5wqCBCXKeDjS8QhHOpcRTOFFysI8hHetKrzjim5JCxGKVUT2rCJawuhuN2J73IjrWVHE964igaKMlKf2upHWv4b0gXWkU4gZpChDcWZFMEQak/QBijRbQk2FFmq0adOmTZs2bdq0adOm7fm2nUJNgmsBX3LexO9XUmi46/HouCPcxqcrDX6/4i7+oIKeIPfwKSVU3MWnJO/T9jtSZuR9im0l7/cc5J7EdyB12P+nWYdt5XqfVl4l0i+Rcva1CdMeWGb0QY8TaSeYIogxJvbHupInZQzZP8PPyjU+46mnytiefUrIvj7lvIffZf8SZ/kfVBn9s55xfU++YLZh+Gmpx7zPePhs1QN8zvkAf+jFFzx8Ucq+JHxB+Lw31VKv5iG+YCJper58tebZfLlW+qq9jy96+Er9A3zVw9fqHwoS1hl8XaBHzDYhRsqVF8w2Hnow4t91LW2n0eB7wveblvCDxgf4YdMD/IAwLrwgvNj0cBNDlDE9YpawW9jjxV7pZy/DZnrFGOxrMYQXRavE2x7hQNuy4mDrFhRdNuNt9IBZgW87BRYDv01M75cVyV9BQMcWgUqEWUVQhxuHpa43zDvS6UZw14qwbEAxRsKQTVYUod1b0DMmomt1k0jSvYqobnrLGB4z9JQxvGVWEd27ihghrs+N+F43EoWkvlWBoRvJ/WvCKlIH3EgdXEPagDDoVqQOMJ8ijbdQQ3HGrTxqMocNzxrn0Q0t1GjTpk2bNm3atGnTpk3b82zeQg3PqElyHcVXq97B56ru4rPVdyQUnMaZKQZM38FnpfwzComrvLv4fOUdfF5CpjeRvM958nfCflS88i7+UPiCxP+w8p5RVsVtPILECcfzeW/YznnPuK7H6+QL9DJRafYlaeGLHlSadaSMddiO97AFtwqZSFp5qBgw/XkJzWt8qeo+vlRtbCNSfZr5UkdBAUX4ipegYuLtzUK+upPa7dDjheIKtxgp6j3U3Vd8Q+IGRvybHr7VQB6q7UhqSxLxEmC+6+F7Ar1fvk+vl0aD73uh8pqW8MNtPFS80LyEF4UtEeYhXmIo6ZeJlFGQMUQXLy8Yii6tS9s4IBwkbY+2cah92cMj+JCOZQNP2lexvIlfx4rCX4kvqwjsNJF057KHFQRJ+REhWOJqC1IXcSNU2NyWxLjKW1WEda0grNvA9IRR3jA9q4IbkTuIovgiMDTEGDdietc8MO5GLOkja4jvdyNpYBUpg24kS0hRRgk0UpbSv45UIVnqpAwQyRMo2qR5oPdMxuAqMsnQKrKG3MgadiN7ZIvqBS3UaNOmTZs2bdq0adOmTdtzbTuFmtSmo/hm7TvggbRfrrkj3MWXq+8aAkQVw7v4Iqm5J+E9fMGTZr7JF6vu4IvOLcx2KlSwLw/Sx5cl7ysS/6qHLwvse6t/yTOR626GXlAUIWa9r1YbZ614h2adr6g299U9fGkTbhUSJK7uTeB2ITOPcSW0SD9frzEEFBPzXJevS51v1N3zIPHae/gjxf1Nvin5xIh7e7cYwsumEOOBHi8m324QXB4a7huYaQ8UYSi+cPuRCinECMa2IxPD68X0fDHY8n55wQvlDdO8hF3NjzxIvGUJL5PWR9gt7JH4Xgn3mtuTPOxrXcY+esB4tiKZGF4vjxSH2pYM0cWT9hZdtoQXho/g37m8BdNCgGJ5k8CuFRwmFGM8HOlaFSTsXpZQ6Da8X5TwImXh3Ttxe9ieT0EmsmdFYYgvBtG97idQIkwfvWNWN8N4espQkFG4kSAkKnFmDcmDa0gdWkP6sBuZI26kD60ibZDeMYbnTMbgumKb8ML4DnIkXzHqRu4O8sbWUHvssRZqtGnTpk2bNm3atGnTpu15tp1CTUbTUXy//l38Ue1dfKP2Dr4uIQWIzcNma+7h6xJ687Xqe/ga66h6FEm2Y7ZVaSk3+zHqb/XzDRPJNw+vNcvVIbbeeMo3PUp25POslU0vFAUPvhU8dbeXbcfsazPt6XNLVHmIbxHPmS1Mq7z6+/hWwz0loPyxix4sEm7ytC1GXlBkYRsX2xrtmf5u43a+13jfoEnipHmL75tbjyQkL3h4qZFbjzxnwXhtPzKh18s2WsgjvCwwNMQX42wYJci0GexrX8Z+4YBwsH1lc1uSQtLMO9ixAp92Hsa7hfJ42Sa4eAsvW6JLgJRvesJ0PVIc7lpWBHWtKCi6eBPcs6oI6aZHDLcgrSJU0gaSVqwifIf3izdRvWvbMPOj+1aFFcT0ryoowCgRRuIG7k3oHRMveQkSGmIMty4Zh/2mcJsSRRhBecAMu5E1Ynq/rCJ3bE1hiDEM15Aj5I6uo3jCjZLJNZRIyHihUDC+hoIxCcm4J1RxyfeiUGg4roUabdq0adOmTZs2bdq0aXuubadQk9l8FC/Wv4vv1t/Fd+r4Ncx38S3T20N5gtyTvPv449oHCsa/STbLPXi38S7zShveJQ9U/9+myCEhD6/9tvAdD8Y1BNOj5H2itvp48N76Y7Ckwu+SevLAE27H/MYik62zW7bYOruFcenHRSHFEFFM4cQ8u+UJmL+D71NwMZH0D5sf7oB5W7zQQh4qXhR27YCiCz1eTPa2LmGfElmENsPjZZ/aisQzYJYVSoDpMEKWm/kUZAweKQ5KnUMdK/B9Gp1bUJjhYbwmSnzpoviyjMPdpvDyJJvii0nPFqbgEkZ6vXErwpUYY8BtSRFSZhLV51ZEP8Hadvq34jFSrsSZgRXEDa4qEgbcisQd0ENGCTODbrWNKXXIjbThNeUpkz28ihwhb5TiiiGeFE2sCxRT3Min0MK4kC9lTJswr2TSjbKpNZROephyK0omV1E8saLEm2KpR0qkXtnUupQbUOBpPKmFGm3atGnTpk2bNm3atGl7rs1bqBmfnkdW8wJ2uW7i+w33FN8TvqM8QhgafFfS362/j+95YJp1jHIzvsUfS53vEKbNuFdanZfiMvoh35O4cW7KA7m+pD15W98s5Ik3muknMbf9bLaXuOpT2qjzVyRufBORgdoSxO1BO1FbhQzMM1xMVH6TB4kbHiz3FS82P8BLwi4PLzXf92DmSbxF8j286GFX68MtKLZI+LKEL5t5bVLfi5eFPZK/V9jX9hD7JTRYwv62JRwwaTfCgxRYngLPgFFnwXRISDofwafTOA/G10TSxM+ka0XhLwR4022yLGX0hPFsRxJML5hgKSMhPSuKMIkrJM5zXxiG9RJDgAnfxgoi+lY9uBWREidRQnQ/PV9WDXHFgxJiJD+m343YAQ8SVx4wEo8bWBPWtxE/sIH4QUHF15AwuIJEIWloBcnDq0gZdiN1eA2pI2tKiMlQYsw6skfXkSV5GSPGNiZuQ8qfoCDjEVCEsol1WKbWUa7EFLeEbpRNulE6IVCMmWQ+WTVEGIEiTbnkWySfba3T0odQPm30oUQbj5BT7imzzGwomC6V/KaT+owabdq0adOmTZs2bdq0aXuubadQk9OygD1NtzfPLjHPMvlB430PhufHVvo+ftjE8N62vO2wviGIbMbNtJnn8Sgh5tadnwvpc+v8FYMXJf9JjANwX2p5D1juzbbyJexq5bkt9F55oNhDWrfYy9ArT6UJRZb2hwoKLrsFii072cuwfUmQeIe079xif8dDHJR8Hynnwbo+Ej/kSft0SJ7gp3jkOefFCJ/EsxVJsaQI6HqkoNeLsfXI8IIJlLTyhDHpWUGQF0dI77LEpW3PksQfIVjSIQrDG0YJMhKn8BIhYaSURQncWkQiTfpXFVFkwBOquHuTaCFGykjcoBvxRPLo7cJQIXmbZUNrioTBNSRKSJKIpJMG1w2G1pE8vIEUL9KG3UgfXkX6iBsZo9yetI78sQ0UjD9G4YQw+RhFU8Kk5E2sI095wRgiCwUUCi30aqEnjGVyHTaKLTNrsE67YZPQLjimVw2mVlEx44Z91i113EqModhilTZsp/CIMcwvYyh5pkBjndmAbfbxpkhD8YbXbzyhv55bmzZt2rRp06ZNmzZt2p5r2ynU5LUu4kDLHexWwgO9OTweIU33BQlNDxHGBcNbxCg3PEW2MOoYXiQq3miE6pwUCiSbfUjau52nvkrL9ZVHyU+JOX5v6HnyJEvY27akQhNuDyIqLWXmmSybeNUhW1uJHmJ/24MnOEDan4bU7zCh6PIABym8eHGoc2kbPl0eGPfg12UIMDzTxRBiKLRQZFnehOKKwhRbhMPdK0/FEGIeIahnWYkum+e+7KTXrQjdQVjfKsL6V4RlhPYtqzC8bwURkkdM8UUJMAOriFYiy4raVhQrccWg2+BpaW49GqLgskXC0KoicditSBpeQ7KQ4gmTVJ5RZpS7N8uJ6RGTQU8YMxxdQ+bYOjJHBQmzJJ016kb22BpyeO4LPWSm1lE8KaFQMsntRYLkc6tR+Qw9WkyPF2ObUgk9ZwR6xdgl3z7jhmNmDc65dVTPr6N2fg11AsMawSl5jtk11Y8hxng8ajxx5XUjcXrLPAvj2qZQoz1qtGnTpk2bNm3atGnTpu25tp1CTUHbInzb7mA/vThaDUxPkG2eIox7p5+F1DE8TTxiibApgnjShkCyvQ2h5wm9Sd4v3l4o3PbzfuG2oJ3p7fBMFjM041sc7OBWIW4TWhIePhXfzifxEQ51beEj+Coovhj4dz8SlhUBEg/0QCGFmAIMPVv4rUZBKv5IhUpo8eQHK8HFYLvQsl1wMdJSp28FoRRchPA+Y3vRNvrdiOxfezoDHu8XxYqHVUQPmrgRPeRGjBDrIW6I4otBvBJdKL7QA0bSPA/Gk1ZQbBlZQ5IXySNupJDRNaQKaUL66LoHY3tSioJ13KoO81meoYSYNeQp8YWeMIy7PaEBty4VTK4boVCoRJlVlE9tYQouzrkNVM8/RtXRDTjm1pRHjEXKLDOrsM2soGJ2VeoYQky90LCwDtfCBhoWN1AnYS2RthRuKgX7plDjEWa84Dk0xV6hEo68MIUak+ZT+owabdq0adOmTZs2bdq0aXuuzVuomZieR2H7IgLb7+BQh7Gl5mDbQyjvD49nyEEvjxDGzfT+J3i4hZdwsiV4GPGtPK/6bM/rdbBvub6M5UCH1CGsa4ZeHNzBIamzBc9dMeMeTxXBEFbolWKkt/INEcX0WPH18l4x4PktjyTfgB4tfvRc6X70E1jysJXn30OWFKpM0oFeHO7xCC69xnaiYMkzthAZBEs+vV3MbzZSZ7r0mGe7GOe8hEu9sD6PV0vfKqL61wz6ngIFmIHVTaIGPduKGHoztIZoIWaQeLxdPBjl0mZ4i1hJxzIU4obdiB/ZImHU4+kicZNk5fFieL4o75dNoUWg8DK2nTQhXcjwQOEli94w9IQZJ5L2kCmoOpJPWJ47uY4iihvTGyicWkP+pEeQmVhX35hUJGkKJeUzblhn12Cn0DK3jrr5DUFCiddKWD2/huo5N6pmhblVVM0LR9dQtbCOGoFijOvYY7gWDRqOriuxhl40FG4q2LfytOHWJgo0vKZcW9Kl0+soUeILtzIZ25nMw4LNsIR15B5M2NbCfqbdKmw9rYUabdq0adOmTZs2bdq0aXuubZtQMzOP4o4FBHfehn/nA/h3bOHXcR9+7YKKe/Kkjje+nffhK/V8pcy34+E2/LZhnJuys8y3nX1LqDxO2J83Rt1NjxTGd7DVv9BpnLOyxUPjnkiXQUD3w038yVPySWD30jM5bNJjbhV6Br3kkcAzWzz0PUKwh515IX3LCm4dMrYPcSuRsZ0ofMDYTkQiuIWoj4fp0sPFrc5vUYfpelDeLIPLEj5SRA+ueLYQGaJK3OAa4oaMM1sMJG94FfFkZFWJKMmjq0iWeJLkkQSPuKJEFuYLLE9Wdd1IGltDIhldk3pbME2SBAourJs65kb6uBsZY6vIGDfIlDSFFkNsMcSV7In1bWyVGencibVt5An0fimcWhc2UEQBRihQIowbuZNST8ryWU5xg2e5CBRjSgWGFDZsM9x69BiVykNmDXWL/IrrNTSSxfVNoaV+3q22K9UuCJJXuyBI3XoPbFfH9qwzv46qOel3xtj6ZJ91q+1N9L7h9QxhxaBMiTQGpYIhxHjOopG0cUaNcWCwOo9G2pfPSpkHh/TtlLFx7Ay7z+mtT9q0adOmTZs2bdq0adP2XNtOoaakYxFh3bcR1P0Ah7s8eOKBnfcV3nkqX+IkoOu+h4fCEgI6PUg8kOmfhKeuas/+NmHa44XS5cHLK4WYW4JMth12q6CgIuPteSgYYZBJrxGaeRRMgvoeSb6EpoCioKAiUFihoCLxEC9MUeWp8LwWL5TQQsFlB+EDK5tECJEmg/RuoejiEV48RAsxSnzhQbr0VvGILMMrEheGyLLB8LLKp7hikihQaEmiwEJPFo94kjbuRvqEG5mTa8gmjFNMGVuRslVVrupQVFHiyiqypA5hG7Y16+wkQ2D9nIlV5E+5UTTtRsn0Kkpn3B4oSJiihGdrj0eg2NziI9cw88soUHiECescwzUPRtrKsjmpI5TSM0WuwX55HXqcWOfW4OA2o6Pr6kyY6nlj65HakrS4gaZjjxWu4xvCOpqOr6FZaDq2jkayKHnHWG9D8jdUHsUZijY1C25UHzVQnjVyDbWdSY1LxkhxhtdXrMPGsXpEGgXFGOK5p3LB9OhxzBkij81M0yNHqJTrECcFI4pJMh7CMfVf0B412rRp06ZNmzZt2rRp0/Zc206hpqxzEVE9dxDa+xChPQYhHoK7HyhCewxCPASzTOofkbgB40tPEKSg58lOPGXdrMe0IaYEEYooFEkkn54pQb1STu+UnR4rAr9ZKJihiq9AnbWyCb1Ulgykv22hELrJI4T1CwMUXrant8QUD/30aNliU1R5LwalnhJbVhE1tJ1owXu7kIJ5XvmxIyuIHTah8LKMxBGyojxfKIRkUSgZk/jYClLoDUMknSJlqUL6OD1XKJisqnjaOMUXQ4DJmFhFzuQqcqdWkTflVhRIvEDy8idXkDe+jJyJFamz4qkj+ZImrEPy2N6rDzNupgum3SiaWUXZrBv2eQoKa6hecKNmcU1RvUA2ULVATxbDK8Qx4/E6IRLnFiGKKhQjeBZMNbcWLRoYosgWlfOrypvEpMoTVvLaEtLzpeH4Olwn1lF/TOIeKMAYIgzPkPF4xbAuyyjUKNbRfGIDLUIzhRqBgk6d1FH34bkfXrNC7pP3axUs8xsKxinS8GybKklXyD1RePGGIoxJxdyqsYXq2GM0SN9KCFKsoZZijIyH96LuQ8U3VLxe6mihRps2bdq0adOmTZs2bdr+DthOoaa8axExfbcR0fdwBw8Q3mvAuEm4hzCpEyZloYqHT2FpG0ok8YJ5YZ7QwGin+qVgYub3UUDZ2hrkvUWI57CYHixhFFiEcG/6lwTGlxAh8YgBua8BhtuJHHik2EwPStqD8mQZWka0EGMybMa3zmFRML0NQ2Chpwu3FSlGd+JWcGsRtxipM1t4TosZlzoJAkMlzNDLZWIVWZOryJlaQ8H0BopnH6stP/kTbuRMupE9RVaRN+1G4Qy3+ayjeGZNebJQhFGCjMQp0BB6uRQIPKuliB4tM24Dtpf6+dNE4gL7YH6x5JVIn4wXSZwUz6yifM6tvEbKyaxbpZU4s+BWwkLjicdK6Gg+sYamE25F43G38lyhyGCKDi6KJSZKQFmTNutoPkmhxIR9sO4qGo65PaIL2xjiSaP0ZbAmZetyfYZyTXrISLuWk2synlW4TqzIdVdVnTqKPxSSZMzVElIIqpP+6jg+Kadoo4QQGU+9lBEKKVULFKAoBpmikBsVAr1eeP/2oxuokHoUWHiN5hM/lrH/WMb0GFWSpohE1Nk2kle9aIhR7L/x+GMZ82MlIrnUPVI4Mu6L961YNFD36RkTx9534UdaqNGmTZs2bdq0adOmTZu259m8hZrJmXlYuxYR338b0QMP3ycPECVEkn5PaMY9RPQ/9LC0SdgmD5WAYuZ7xw22t1MMPEL4T4B1IpXoYmKc0UJUfHAJ0UNPErONR4gZ9mYZsSPLiBtdUSSMLu+AeYaQog7IFdSWok24xWjFYGzF4+WyE/c2zENyCeP0iEmbcCNj0hBnDI8XQ3QxtvNwaw8PkvVsG5pZQ8msG2Vzbljn3bDJ4t/i2R7EbTRlArcAmZhtSmfXpc1jY7vQnORL++LZVeUJUyT9FUu6bH7dEGAkXj5niDKGMOOG/agbzkU36o670UBPFcWaijcJrSfX0HF6A11nfiQ8RufpdXScWkO70CZQNGnexI1Wadsu8faT64oOyes6tY4uadcpodGeZWtS140Wii/H1wUKQT9S4oYSfZRIs6Y8XigU8byZVmnHsbSf2UCb9MNrKsGH9aWe8tKhd4ygvHaknUIJIIaAo/DUYZxCjYp72jK9mSewbcOJx3Kfcs1Tj2U+NtDIOZJrUgSqUdflOJm3oaCgQ+FFwbgShwyhZidKPCJsJ/duiEsb6L/0Yy3UaNOmTZs2bdq0adOmTdvzbDuFGlv3IpIG7yJ+aOl9Ead4iNgdxJDBBwLDJYOBJUQLURROJP0EHlGFIsqTGOKKEQpD702M1Nli2WBoWcZm8ghxwzL2kUeI9YTx29gpwghjK0gk46tIEpLHV4RlRQqZWBFWFake0t6LSTfSn0HG5JrgNs6HkVCd/8K0xzOmYMatBJOyOYotPNdlFaWzq8prxSIo7xWF4clCrxZ1XouELDdDi7SxzK5I+SpsFHKOSj3BvrCuzm3hdhuL5BtCzArK51dgW1hB5aIb1cfWlKBQe8wtIT1k1pQg03hqHa1nNtB5dgNdZ9fRfW4N3efX0HNhHT3nhXMb6JGy3nOP0XveC6aljG3az6wr0aSFIo1AAUYJMqcYrqHjpMRPyjWEDoYUak57hB4l7LjRImNRW5JOPEajhC6KL9Ku8ZTEpY3r5GM0USSRdNtpCYUWidO7Rnn1eMQO3le13G+NwLhJ3SK/Sts8OJhIvsLwuqlX4tBj6UPqHTMEGAoxChkbx9As0KPH5fGEqZM465lsCjPH6V3EbUxMm0LMVrnhfWQIOgp1fXoS0dPG8LYhQ5f01idt2rRp06ZNmzZt2rRpe65tp1Dj6DmGtOF7SBldRvLIo59IkpA4srSNhOGHiN8GRZ1HijiBIslOb5Wnebd44133/aAOzh0yznDxJmFkRcZIlpE4KmPfZBlJY9uhEEPxxRRdtnArDMFlxWByBelTy8jYZAWZQpaHbMWqxN0KYzvSmiLLCzMvZ3oNuULeNIWZFeR7KJR0Gb1ilKjiRsWiG47FVViPrsIiaXqyVCx4IfmVEjoEbrlRYowH1rVLuePospQvo1L6IVWLK6g+topaesQQiddxK9AJNxpOutF02o2WM2toEzqIpEnnWQoyG+i9sIH+ixvou7CO3nNu9J53S3wNfRcFCfslv591FI8VAxeNsE/a97Cfc+uqP/bfeVrSZ6SvM1ImYbfpReMRbUyPGoWUdyqR6LG0fay8VSjWNJ2kMLKmRKQmqddIwYai0knDk0WJOMqLhnDrlVvyjTzl5SJ16I1DjyCeZUO4bYu4lAhEUcRAbbeSkGWmgNIg5QYUsyjGsC9utWIb47rK40fS3my29/RhXtu4vuGdxO1f9MwhFH6M9Dpa5d7b5H7bBeVtJHM1fuWxfOa1UKNNmzZt2rRp06ZNmzZtz63tFGoqe48he/QeMseXkTH2SJE+vpNlg7FlpHlIJZKXKuUpY0tIHt0iafSRwANvHyFBCTtGSOJHPF4tRAkskhZUWojx5MeynvRFYoV4ImVx0jeJ9RAn14mn94s6YNcUYVYUHEMyBRi17cjjBUMmZNxKkNlOuhJfVpHhRabCrciSuGJ6FdlCzswqcmdWJFxR4abAInGF1OHZLpvMrCnyZtyKfKK8ZdZQOGtQxO1GQsmcQdncCqzzq3AsrKJKFvf1J9dQKwt+5yLzViRcQc3xVdSdcKNOyljeIIt21qk6bmxHqlpcM7xhjku+5NWdWJF6q3CdciuahZbTa8qjpePMhiHGnF1Twknn2XV0nVtTdEu696xb0Sdp0n+eIgzFGFOQkZACjQfG+y9K/kVDzCEDih8ZYo3Qd2EDPec35BrrxvUEeuDQE6dX4vS66T73WMopyHCMxljbZMwtpzyYcbl/bmNqYijpJgpNQqPQcmpdedBQxGmUciXeEIo5CkPYoRcORR6XzKnqSwkshshiYAg2TQK9d5qYd9woo0eLIaxIXPppUM+Dgpf0x36Zz/KTLDf7M2jaFF48cRlrq9wnoQDTRkHqjMwPxSuJd8scUdCimGV6LPXJHCk4b/K8Zl7RQo02bdq0adOmTZs2bdq0PdfmLdRMzcyjqu8YCsbvIW9i2WByGTlPwG/9WUW2hCZZHjKlPHPiETLGt0iTdKqQMr6EZIFCTpqQOvoQKaMPkCxhkoLCjqRHHiBl5L5wT5Gs4pInZar+yENVL2nsARLHHiqSxu4jeeyulN/39LssdQzRKJXffjRO7xcZy6TJMtIVK9uEGCXGTBtkz8i9zVCAcSuUmKIEFlNkkXDWjYJtosoKiueIIayUPoF7GyXzBsUMJc1tTDxPpnx+TUHvmbKjblgW3LAurCrvGWPbERf7hqDQSE+XY6tquw7FiXZZlLeeWUPTack7ZYgSCooXsqDntqSW04LUbZXy9tMr6DzrRvc5D7Kgp1eL8myRfrqkjKgtTELvOYolW/SdXzMwxZmL6xi4uLaN/ktuyTfq9ErdXgl7uB2K8fPSzwVuf6K4QBHGEGgoDrULDDvOGIKMiktZ29kNNEu6We6pSeC9EZdHbGqkKOOB98v6HYLaUuWBZ9KY59K0Sj0l7gjNnnbmvJn9mCKPAdMy/9w+5dlC1UzvHYkrcYVii4QmFFpM8ecJ5PrNfB4eAUZ5wKjzewyxqkvu2aSX889Q6JMyCmMDMpeDFzcwRC5sMSzp4YuPPWxgUJ7N3HUt1GjTpk2bNm3atGnTpk3bc23bhJrZedT0L6J48i6KppYUhdNLKPBm6pGwvEm+4hFyvciRdjmTS8iefGgw9RBZQqYZSh7JmHiA9PEHyBi/L+E9pEk6ZeIhUsYfIn3sLtJHbyN95BbSh28idegm0obeRdrgO8gYegeZZOSmcAuZo3eQLfHskXdV3OjT8PzJmHiE7Ill5DCUMamxqTHKWKeXkbeTGQN6wBTNbVE8u4ISoVRhiC5lJvMUVtywzK8orEeFBeMsly1WFfZF4lYwbdTbyqMQU0GOuT2soVLCquOrHk8ZfivRqiz8V9FCzxeBIkb3WQom9GAxthx1nV1F2+lH6DhnbEnqOCP1GJrIgr9T6FKiiXvT40VtUZL2SkxR58mYAo3bEFU8ZRRmKBr0UDg4v7W9qf/SOgaIR6DZFGouGnW4FYpteF2TznPraD9riCkUUFpPrwluibuVUEOUuCRQ0GiWOi3SpoliFMUagVuxTJhupRAjc8J+O8//SO6Xooz0JXDLFr1v2nmAsAflkSNtzOtTsDHGwb48eOcpDO8Wb1Q/9HYhEm/fxLymiZFH+Pw2z/PxQMGK28CUiCXQy4gYXkoegUaJM+sYEUYvb2BMGL2ygZHLkndpTWD4WMoNoWZI2h199UdaqNGmTZs2bdq0adOmTZu259l2CjV1A4uwTN9B2exDlAsMS+Z2MLu0jSKpUziznYKZB08lf9ogd+ohciYfIGfiHrLH7yJ79C5yht5F/uANFPS/hrzea8jpvIistjPIbFxEbuUosq29yLV0I8/ShYLKQZTUT6LUNYuypqMobT6OwpbTyO+6jDxpnz/8NnLHbiJ74i7yhMLxOyiauIPiyXsombqPEhlDiYyTlM49eoIyofzoI1gEhtaFZdiPrsDhRcWCR1TxwG1HzsXlTSqPeTguaYWUe6g6saqg+LKNE8vCCmpPrqDu5Coa6B0ii/mWMx7hQqB3iymQUDBRHhUCF+ejskgfvuTG4MUVWdCvyGKedSiQrKJPYJueCwa9FGY8IopC8hQqj6yrctZTsI0ScijseIk7Ki7t5PoDcv3BSwZKpGGeB8Ojht4zG+i5uIFu6b9T+us4vy48RjvFFIo2RPKIUbZuiDhetEqdVsknbcJW3Y1NKAB1Sp9dEu+SMkMUMjHKtsM86eOsAeNqe5V3uSdfpaXPTtWnW9GlWFNQ3OIzUuKZYGwNY+iBeTIuo3zDQAkxMk/CgPJKehosM5F5lpAMKeTZC0PSflCe85A8JxVXaYN57VGjTZs2bdq0adOmTZs2bc+37RRqGgYX4Ji9DdvRB7DNk4ewHiVLm1jml1DuRdkcxY4tSuaWPDxA6ex9lM3cU2Hx7AMUCYUz9M55hKLJeygefQf5Pa8gz3UKuY5RFJW1oay4FkXZpchOzERmXCrSoxKQEhKJtOBw5ISEIT8sHIWR0SiNS4QtOQ32lAyUxiahMDoZhcm5KM61ocTRg5LGoyjpOIfSzgsoaT+Hsp6LsA1dR+Xk23DO3IZDxmeX8duOLsM6v6xEGatgIwuPYF9chkOoOPYIFFqqJF5tcmwFNce2iyy1x1eEZdRJWE+xRag5KVB8OUkBZlnyBInXn6IIw61Jq2gSmk+7FS1nV9B6bhVtstAm7WfdSgwwvFkMsWPw0hqGBQozY5dXMS6MXZH41Q2MX1kXmBauujEqadYdumgs3Nl24LL0QxhXGPlDgir3YIg1hiCjRBaPIMMy1hukKLMJ09KHjGH46mMMXxEuP8bQ5Q0F6/B69Ljpu7iBnksmj9HNNIWbC+vqm6EYdkqadBCmz1No8SDprots91jCDUX3BQP2o2Dcm4vSt9Cr2JAxcBzebEj+YwNuw5I2m6iyrbTybpF6al44V3LfCsYpUFGo4n3L/Y3IHCgYVxjeLcrDxSs0YFtPP9K3CZ+Bd/gk0o7ijswL+6DnDEUZhttZw9FXtVCjTZs2bdq0adOmTZs2bc+1eQs107PzcA0touroHTgXH3pYgnNheZNKoeLoIy+W4JhfUoKHCcUO5Y0y/0C4B+vsA+WdUzJ7DyXTd1E6dhNl/a+hsGEeGYWNSIzLR2JIPFKCY5AeFoWs8EhkHAlSpAUFIeXwYSQFBiLOxxfR+/Yj4eAhJEk8U8qLIiNREi1tgg4LQcgJDUNOWARSD4cjLTgOGREpyIpKR2Z0GvKTclGSY0GFxQVnVQ+qWmZR138eNRNvomr2DiqP3kfFwkNUHnuESnq9CNUnCAWWR+rQXfPgXQO3wjgg1nNI7CkD12l6wrjVNyQ1nfFwmoLMivKOaT3rRvu5VXSfX4Xp2UK2L/opBNBTxRBHBi67MSgMCSNSxxBn3MIqxq+5hTVMkFckLkxI3sS1dSXgjF2R0MPoK2sYvSqhh3Hpw2T08ipGpd+RKxR5pJ4wvAOKP2TsirHVZkjGooQaKRuS/KdBoca4HwoO68KGpB8LP5K8H6H30sY2KOAYMC55lzfQd/mxol8YkDxTFFHCiIlHIGFo5jFtCkaGaLSBYWFkE4+YsgNuJ1Jbiq4+3sbE1R8JDNdlrjnfDGUeXzHKOTdq+xFDbkUShmV+NsfA8XjYNkbBFGk281U7zrsZZ8j7lLjUNQU7M6RHlULaGtufTIz8xdf11idt2rRp06ZNmzZt2rRpe65tp1DTNLyIuoW7qD2+5OHRNmqOPUL1sSVUmWwKOuSBonLxPhwL92A7ek8JNWUzd1E28Q7K+y+htOUoCm1dyM6wIDkyGXH+wUjw9UfcIT8kBRxGzMFDiDlwEPE+Pkg/chj54aFI9fdF5N69UscH8Yd8kSSk+vki83AAcsPDkOAjeb6+yA4ORm5ICDICA5Em6azAw0iXPlOFdInnSXlheDhKo2NgTUiENSkZ1uwiVNpdqGsaRmP/MTSOXULDzFuom7+NhsXbcJ14ANfJZcPzRQktq0po2cZZCi9r2zm3hnah87xbbbkxcBvCjNo6ZIgWFF0ofox4RBOGI0xzkX9VFt4UVV5xe8I1JcBMClMSn7kmvLqG6evCq24J3ZInMK1CN2ZfXcfsdYGhYk3SzF/D3FNgmWovmOGk5E8o3BiX8olrG8KPMPHKYyVOjL5CL5p1Qe7HI+YwNONKZFBCw5bwYMSlHYUexToGzXqbecJVA+WlI9dSoUob1xt5ReZNGPPAuHdaIeMdkzFynIyPq/E/xpQwvcmP5F69YHqTH28yJelJGYfBugeZI4FizZiMyxDEKGh5nqPCO74DuR+F3O+wmhfmM82Q7QT1XjwJrzUu9Z+A+duQexZO3PixFmq0adOmTZs2bdq0adOm7Xm2nUJNy8giXMfvouHkElynHikYV5x4iHpy8iHqTjzYpJYcv48aD1XHKdrch3PmXdiHr6G4aRbZpU3ISC1CenQi0kPCkBZwGMm+FF0OIeHQQSQHBiDO1wfR+w8i7pAvEvz8kBEchPyIMKnng/A9e5DoH4AUaZfiG4BUfz9kHglEVkgwYvbvR9yB/aq/NH9/RZ60LQ4PQdZhf6QHkgBkB0l/ISEoDA1BSUQ4ymKiUBodjvLYcDiS4+DMzISzoBRVtjrU1HajvmMS7ROX0HX8FjrPLKPz3Aq6zq+i+4LbA+OGV4xC5a15Qp4Bw/NeVjFwSVDbVlYxJHGeIcOQ3jCT1yi8rGLyuoTXKcQIV41FP+MT11YxdX2LmesrmH/VjaPCInlN4l4sqLw1HHt9HcffWJeF+QZOCqfeFN6S+JvMW8OJNwxYh3UXX1vHgrRbkPjR1zYwL2kyJ0xL/pT0yzFOvLIiY+K4TC8SgV47FCkkf0zGPCZpU1gihmBiiiWmmOIpk7psT88U437XZU4k7YHxyetPQuFofFNAkvHJOBWMPw3eg2IdM3KPs8Lc6xtyfxteIpYXco2Za48VswyvP8a0oMYj4zSQ66m0kWd41xj3YD4/PkvzeRp5GxJuYaYZjl/dgiKYUYftzL694wZT0vfTmJa609c2DKQfg8c4/aYWarRp06ZNmzZt2rRp06btubadQk3b6CJaTtxFy+kltJzxcPqhovnUAzQJjacfwMVQcR8NJ++jXtrULt5CzdzbcI6/BmvnKWSXtiA9qRCpkUlIDeF2plCkBAYgyc8HKb4+SA/wR1qApP19kRTghwQ/X8T5+CDZ3x+pAb5IkXyKMBF79iJi7z7EHjykvGqidu+V/ANI8PWVen6IP7APCQcPIEnKUiUv58gRFIUFoywqDHnBh5XnTRa9b4ICkB8cpEScojCKNSGwxHHrVCgKJV4cGYbSqEjJi4UzNRl1WRloLLejvakXw5NnMHD8TQyeuYOhC0sYvLSCocurGLoibIbGtiS1VUUYkfjY5RVZeK8qDE8YtyyYjZDeK4bAsqqYl7ghFFAoeYz51zdw9HU3Fm6QNSxKePwNN07dWMdpxRpOvSFI3IT5Z97cwLm3HivOvrUhrHtg3TUcJ9LumLDIa3iEGYoy8xKfk2sbAobBjMSnr8vCX5i6JmOXMU5J/iZS7h1Osz7DTQyRQ4Wv/UhguK76nZHrz0qo7lfd82McfeNHct8SCpv5CtYT2Ob1NWkr8yX3MPcM5hlKve3Ifb4h9yksCEcl7wlek7acCxmvQsbOcFbGMCP3M3Pdg8Q5P2purnnmR+bGnCuVJ1DMMeOGeOKZDwlZth2ZQ9bxlE/LdTb7ewqz0mb2lSeZk/x5aWsyR6Tfs29poUabNm3atGnTpk2bNm3anmvzFmpmZufRMXYMXafvoevcoy3OLik6zzxUtJ19YHDmAVpP3oPr2C3Uzt2Ac/gCSuvGkJnpQGJUMuKOhCHej9uaKMAIhw4pz5eEQweQeGg/0gJ9kBHkj+QAXyT4HkK8ry9ifQ4h0f8QUgMp0hxA6K7dSqSJ2n8Qkfv2I+zl3QjfvQsRu18WdiNq314k+vogxc9PiTSp0k9B6BFYY8JQER8JS0yESmfINbIDA5AfEiTpIJREHEF5VAgcCVGwxEYgQ66XFugv4WEUhoXCFhsJe0w4qpLj0Jibid5KG/qaWtHbPYrB6fMYPX0T45cfYvKVZUxeW8HUdTemX6XHi7H9aPb6miyOV2WBv+IRY9xYeG0Vix6Ove7GyTfcOH1jVRbPbpx5c1UwRBh6v5ymB8yb6zj91hrOvE3WFRRczr+zgQvvPsZ55rFcsVVOzr29IUjcA/s5RaHnxhoW3qAAZIgS8wpZ1L8HR5VgRIHEkyftvZm7sYFZL45K3oLUX3iN4WMsmrzxGMfe+BGO3dji+CY/9op7IfXJMdXWZEParguG2KTwCFCb6TfWJf14G8d2pI+zHxmn6u8JpL6M2RuKWou8px0cfZXwq6/JzrRwXebMw9HrLHus6szzHbm2qt6TuVcp0hnvDb155qTO3Ks/knrynIT5TeRd2kSepbD4fnhN5kTCi+/ow4S1aftbt7/+67/e5BdhP22/v8ix/Dz2NzGm5/G+nycz3433g7bt9rQ58kabNm3atGl7L9sm1MzNo2t8Eb1n76DvwkNFrxc95x4ous49RKeEHVLPdfQNOLqPIbusBUnx+UgIikJ8QBDiDx9GnJ8/og74IHzvAYTt3ouIPXsQu9/j/eJzAFnB/sgPD0GKH0UZKTuwX3nbJPgdQsiuXVJ/n/KoiT2wD9EHDiJ018vCi4jctxsxQsLBfUj2PYi0AD+kBfoh2Wc/Uv0OIPeIH4rDD8MSHQJbXATKo8NQFM7zaUKQGxKI7CA/wRdFYUGwS7kzKQYFoTLeg/vVeTfZR46gLCYC1tgoOBKiUZ+RiLaCdPSWZWOgogQ9TgeGOroxsXARC1fv4viry7KQd8tCnqzi+OsrOPXGKk7fkPCGhBRilODCcItzkj4vXHh7TYXEW1yh+HJWyrYh/Zx7Z13BtCHibLFV1yg/LX2cfnMdJ2+s48Qb9MiRRbtAL53FGxJ/UxbwUr4d5gnSlhx/awPH3954Ir2ZLyx6QnJC8tVWK/LWYxnDY4kLDE1UmVG+lfYq3wH7OP22xBWsu2bAexQYbmddyt+rTykzx/gUTipk3rbxWObxscwj59IbuWeB28iOv/4kx16XudyEaZmn19bBrWsLr64a29VeNUSXeYp7woK8R4uvrQjuHe2Z3uK4cMILM70z3+Tyu1qo0abtb83MBRp/8Zp8kAs27/7Nfs08b7yNae+x7Cz/2zJzXL+o8Zj3+n6uYdY1eV5s57g+6LGxP/PdeD980Nf/u2zvZ+70fL23cX52ok2bNm2/TMbfFd5CTffEIgYu3Mbg5QcYuHR/G30X7qL37G10nn4HbXOvoKptArkFVUiNTUdiUDgS/Q8j2c9fecTwvJkoiisv70Xwrt3KMyZ8927E7t+LxEMHkOJ3COmBPsgPC1aHBSf5HkTGYT9khxxG5O6X4fed7yFq3z5ES/2IlynQGETt34c4nwNI9vdBsu8hpAX4qv5ipF6S9Jl1JADZR/yRK5REBKM8KhTWGBIGW3wkyiTMDg5Aks8+5Eid8uhQ1KbGoSIxGonSX4RcM9nfD8URIWrrlJXn18RHoCEjHi05CegpycSgrQAjVRYMu2owMzyKU2ev4cy1+zj7+hLO3VjCxbeWcfmdFVx5dxVXbsri2MMl4aJwQTj/7grOS50L76zi4juSJ+EFCc+/SxGGYsyaR9BhuCXA7BRmKAKZbHnXbEeJNeTNNVDcOCntTsi1TrztxkkJn8Wpd6W+cFrGZMC4V/qmkT6zg7Oe8VNMUvdDPOLSE5jlP4Hz7254YFr6ftctrOL8TSJxCZlWeSpknSf7Ma67Nb6t+BYc/1kpM0K5J5knY74NryU1pzKX9FLaBvO8oAcTOUneWFUeVCffkPn3iCYU9BZee4SZq48wfnEZPSfuo2r4DVg6L6N74V3MXnmIxesrUlfasN0mnn48qO1vTyDX3mQr/8pNLdRo0/Y3auYCw/xl+/rrr2NqagoDAwNYXFzE7du38ed//uc/98KNbdn/5cuXMTMzg3fffRd/+Zd/ib/4i7/AtWvXMDk5ibfeekulzfpkaWkJR48eRX9/vwrX1tZ+rnH8vLbzPm7evIm/+qu/8pR+MMZr3Lt3T/V/6tQprK6uqvl/mrHuK6+8op7X6dOn8ad/+qeekr994/Pl2MbHx/H222+r9+iDMt733bt3MT09je7ubnR1db0nvb29z938/G0a3+HR0dGnzhU/awsLC+qZ/cmf/MnP/dn/f9X4fr/xxhvq5+WNGzc+0PdbmzZt2v4u2E6hpmdiAcMXb2Hk8j0MX7qLoYt3MXjhNgbO3UTvqTfRMX8FdW2TyM+1IzE0Fol+gUjy81MH/qb4HpL4fiT47VPbnMJ270Hont0I4TalPXsRKfDgYB7sy4OAs4P9kRsahPj9e5Hqfwj54YclfRgx+yjO7Ea8zwGES9sjL7yEsF27EbV/P2IOHkC870HEHtwv15DwwH61/YkiEL1vEnx8kORzUMZyADlBfigMCURhsB+sUUdgiQ6GIzEK5YmRSA30UdcsCj+CygTDqyY3LARh0hfPy6FQY4uLEiJRHhWMivhw1KXGoDkrEd2FGRi25mG8Ih8DjkIMNtRibngcJ46fx4UrN3D59Vu4/OY9XH3nIa69u4RrNx8Jy3jl9iquCJdureCipC++SyT9rreIs4bzFBnecePs26ubYsuWpwwFAw+bIoIhJHgLJOckrfCIDQbSp1zrzE3p14uzO7kl9YRzm0g/wvk7Hm57kPgFCS9K2aWncFHuZRvMM9mRf+n2uuLiLYNL0q+CZV5cljqXVT7n8Sncdku5zKeM+5L0bbLtWh4436qeV9rAq76kKfwoZP7Om3Nszi/nXeafz+rsW9s5Q95cwWlyY1ltcyOn3ljB8deWsXD9ESYvLaFx+h2kN1zEnpRRfCOoA9/wb0FI7jjqh65j8tw9LF5bwYlXpd3r0v4Nt+LMDXn2Hs4K5zzhE7zphaSv3dJCjTZtf2PGxRd/ybrdbrVA8/X1xRe/+EV84hOfwEc/+lF86lOfwre+9S3k5ubi6tWr+LM/+zNPy5/eeK0HDx6goKAAL774oloM8pf7j370IzgcDnznO99BR0cHHj9+rOpT/Dh+/DgCAgLw6U9/Gr/927+Nb3zjG0pIepZo8Tdh5n0UFRXhpZdewuDgoFrMfpDGa8zNzan+o6OjlZDFReHTjHXtdjt+//d/H3FxcVhZWVF5z4P9+Mc/htVqxR/90R+hs7MT6+vrH9jY2A9FGr5LfDc+/OEPP5OPfOQj+NjHPob4+Hglev2yG+fu4cOH+MpXvoIPfehDT8wX5/N3f/d38dWvfhVRUVGYn59Xn9Pn5b16Xoyfe5fLhe9///tobm7+QN9vbdq0afu7YNuEmtl59I4vYOTsuxg6fRMDJ97GwLE30bfwGloGF2F1NCI7LQeJIcb2pkSeC8NDfwN5zkyA8kiJ99mP6AN7BZ4rsxdREsZy+9LefYjbtw+pfj7qm5jyQoOQHx6EhEN7ELNvF1L8DiLx0F7pxwdRe/ci5MWXEPC97+HICz9E1J7d6kwbEsu+9+9G/CF+O9RBJeRE7d2D8JdfQpyU0TOH3jpp0k+a/yFkB/kbYk2IP8oig2CJCYE9PkKuH4isI/7IDz0seWGwxQpxEUj0OSB9HEB+yGGUR4fDGsstUBEokbFao0NQnRyN+rRYtOYko680C0PWfOVh01uej4EKG4brGzDR1Y25iUmcOnkWFy6/hiuv38LVd5Zw9eYqrt5axeVbK7gs8cvvrOLSuyuGUPPuqhJuzt9cUV4iFzzigPIcecfgvMQvsoziwc01YV15k1yQPOZfUmwJFEqIkPDyJkxv5/IttxKPNrkjeXfWFVfubCgu3zUw01cY93DVg0pL2VXh2g5eEbzbss4rt6WMSJxs9qPqyLXvrSmuKtx45a5b6q3h+l2DazJOk1e84tdYz8Q7X2C9p2GUrcmY1hVXb8k1bxlxQq8ob88ohTyLy+/KnAqXNpHnozyk6B1lcP7tFZx7W57jW/IMhfNvruDMm8uYf+U+WmdvINZ2DN8M7cLv7W/ER3fV4hMvN+CLh1rwLX8X/OJ7kFEyi6a+a5g6cwenXlvC+bfk/ZD+LpC3hDfJmrBuhG/Jc39bwrdlLFLHGA89tpi3hlfvaKFGm7a/MaMYQo+QxMREJc786q/+Kr7+9a8rcSQ0NFQJBVy0Mf/AgQPqv+xcnPwsixG2uXPnDiIjI9W1Ghoa1OJvY2NDCUHMq62t3VzsMJ+LxP/0n/4TPve5zyEoKAjp6enK0+RvczHEa9OTg3P2+c9/Hm1tbeqPlA/S+IcPBSAulnft2oVz585tehrtNNZNS0vDv/yX/xJ75Y8TLsD/NufH2yi6paSk4Nd//dfhdDqVSPJBjY33TS8ZztF//+//XYl4u3fvVnOwT/6YY+jNoUOHUFlZqd6rX3bjM+BnkfP2D/7BP1CfeXPuCOMUaCni8PNHoa2np0cLETuMQmRJSYkStcvLyz/Q91ubNm3a/i6Yt1AzPS2LwpYxVNYfR7ljEhb7ICzl7SjNsyE/MRNZoZHIDAxECr+VSX0Nth8yAvzUV2UnB/gj3ucQYpRAs0eJKTxbJlbiiRKSVHq5HPFDXgjPpglE8qGDSJB6WUEHEX/AEGN4Tkzg976HoO//AKHy9xNFmHjJS/LZi7SAg0j2O4CwXT9QW6LoTcMza6L37VVn1iQekmv4Sx25DoUfcxtUcfgRlEUegTUmREHBpiw6RHn0kOKIIFhjQ1GVFI3ymHBk+B9CVsAhFIYeRllUqNoCxS1U6vDh+AipF4Xa5Cg0ZyWgPS8FA2U5GCjPxaCFgo1gLUGP3YLuCit662sw1N2D48fP4OL1N3Hprbu4+O4Szt18hDNvP8LJ15dx7NojnHh1GafeWMbJGxLeWFEeGWpBTgHnpiHsXLm1giu3l3BZuHiLoo6UUeThQlzqn+OiXcLL0uaytLly+xGu3l6WdsLtVVy9s4Jrd1Zlse7e4q5wTxbwXrx2f8Pg3oakBYkrJG6UPfawlW/Uk7wHj/G65L0uaZPN/ogq92JnHSk3WDe4z/EYvC688WADN4TX76+rtBHuxKi7na3y1+QeX/dgxhm+do9lXtxdl/lZx3WZJ3Lt9nZeubW2jas33Yor8kwMYYci3CNceFueFQ+Nlud74tpDDJ28hbyG09gd34Mv+jbhc/tb8Nn9zfj9PfX43J5GfO1gE77n34j9wa04EtmN2NR+lDhm0TF4BbPn70ofSzh1/SFOX7uPE1fuYf7cHcycvoXjlx/gjLxL515dwQW51qW3HuEieXMZF+S9uiDv1Wu3N7RQo03b34RxQcGFRVJSEv73//7f+NKXvoT6+nqcP39ebUHi1qTr16+rLTVcuP2P//E/lFhCz5qfxcXfXBxGREQoUYbXolBDAYLbB7itiaIR02Zdetlwkd/Y2KjqUCB5HrYXcPsM5+bYsWNqa9gHvfWJ/VGo+eQnP6nEsp8k1KSmpiqhZs+ePc+dUJOcnIxf+7Vf+8CFGs6RKdR87WtfU9uf6Hn02muvbULvKzMk9+/ff6Zn0i+T8RnwvaVQ88//+T9Xnmzm3Jlzxq19Q0ND8PPzU/X4WeRWvA9alPy7bKZQQzFbCzXatGn7ZTRvoWZqchq1Fa0oSK5FZlQpUkJSkBgYhmS/AKT7ByLTzx9Z/v7IORwgSDzQH5mer9imSBPHbUk+BxHns1/CfYg/tE+JL6mSzg6k8OGPojA/5IcdQk6oD2J3vyz5vsg9cgCxe19UW5aCX/gBQl98ATF7dyNB2sYfkrID+5DmL30E8+u4DyBq70vq8OEoqRO26yUV0hPG9MpJkusRijb0mCkKp3dMMGyxoXDE88yZcNgSIqQ/P2Qf8UVp1BEl1NBbpi4tXuqFI0fGlRfki+KwQFii+S1Q4bBEhaA8MhhVUq8yPgy1ieFoSI1GW04Seksy0W/NRV9ZFnqLJF6cjb6iDLgyYlGfl4r60kIMyO/qU6cu4NKrd3DqjQcYkwW2s/saCmrPwtZ2Fa7hG2geew3tE69j7OQdLF5+hDM3HuKiLPavUHh5VxbfN2Xh/y4PK17GvCzMFy8vY+bsffTPv4X28dcwtPCW5N3HSVnIn31jSbW5LO3pccOtV6/eXpbFuoc7ZBVv3F/HDfJAeLiBtx6uC2uecB1v70TqvUUk7o1RLu2l7E0P28u86xvXMett9i3523jAembdDYUap2e8TL/18LGnjpQTT58mqj65L20p2txz48Y9KTPvW7Em88C5cG/Ceoq7q4rXKGpJ+KoSu1ZxXebz2i0JhWu3VnBNntEr767i6jtuXHlnBZfeWcKFt+/Jc7iPE688wPyFe2geuooj6QP42qEmfG6vsM+FP9zTiC/tdeHLu+vxtT0u/PGBRrzk14R9gc0ICGlHSEQnImO6kZDUh/zSCdQ3nUZb13l09pxFc+sJVNXMw1E5i4bGY2jvPoOegfOYmr+OhVNvYOHk61g4IWu0469j/tgbOHfplvrMf5CmhRpt2nYYFxNc6HJx+5u/+ZtqsUtBhue/8APIchP+AuYZI/yvOwUWbxd/wvr0smFbnifDxTC3BnELDtuaH2jWfZpQw3Iu6B89eqQWPlxIs3+KExSP+N/q4eFh3Lp1a7M/9sXxs/3y8rK6HgUKbuEyz9TwNgorrEdvCl6DY+NYOWZej/lMc2sXYT/sj/1y8eV9HzRem2Nkn+yP4zGN/XFcvAb74HyYY2Pf3nWfZR+UUMOQ5Rw/74P3Yz4bjpvX8a7L8bGMdXdej+Xsh/PEezefA4UztmGeObccA+eWcW+hhmk+a/bBOef1dxrzOFecW/Ztjm+nsR6FGm7P49aTs2fPbop8z8I0xtk375Pj5n2b4+L88F3kM3yaqMO2vA7bsT6fL+vzfszrm8Y5Mt8FhmzDuWF973eZ7cx30Hw+LGc+8ziXvF+mOS8sf9rcmNcz30umn2ZsZwo1fG94DpI5dm/4uWEZ36v/+T//p/Lc4mfY7Nesx/njGHlvHD+vz/n0fr9onE/W47yzb94j72XnnLOddxnnwOzP29g383iv7JPX9/688Rrec8C+mc8xcMzmXPEabMPnwzreY6Yxzfkxn7nZP8dXXFyshRpt2rT90hp/xvLntSHUTKLBZoclPgHZR4KQygN7/Q8iyf+Q2pKUwm1OPLD3sK86iJeH/zKd6HsQCT70dvGR8IDUk/p+hhdMss8+ZB8+hKJQX1Sn8uuyA1Ea6Y/8YB/kBflIP4eQ5r8Psft2IXqP4PlGp/h9LyNF+ko4aGx3ygziYcPclrQHsQeNevyKboo03BoVqzxq9kr9vUg8uA9x+1+WuvuknQ+KIg6jNIrbnni4cBBKJW1PpFDDw4z9YYkLhi0uRJ1jY4s8DFsMvWgozoRK3UBYpZ0zMRIVCRGqzJkUifrUGNQlRyqhpimdW6GS0Jafgra8ZHTlp6K3IE1IR5eEbZJuyU9HU14Gem3lGG9rRUfrEIrs40jIn0dUziIihZjCY0gqWkBa6VFkWY6irPYMnC3n0TxwHU3Dr6Nh8FU0jryG6p5rKG44h+yKU8hznkFR7XnhHIpqzqFY2lgbL8DRchmWxotw9lxHefc15LguoLLrOnqn3sLYwtuYPnELE4vv4NjFe7jy1jJev7OmhJF3ltZx8+Ga4MbNJYZruCXxWyo0uC35tx4JLF9iPS+k7jvC2x7e8Soz679LpP07Ht5lf5sY9W7LWG4tbUh9GY/wDsWdBxt47faaGu+FNx7g6jvLeFXSFF3efvhYjZ91rt9cwfV3KUa51X29dssteat4hQc8v7WEy28+lPARrr0r9STfgN4mAkWYW8vqXCGKWq/fWdmE5a/eohjzCJffeoBz1+/i1NXbOPfqfVx845Hi/OtLOHPtAY6ev4XB+TfQOnINtsaTSC4cQ0RaP/aHtOJ7Pk345gEXvrqvDl8Rvn6gAX8k6T/a34BvH2jEdyT+om8jXvZvxN4AF/xD2xAc0YmwyE6ER3UgUoiL60Z66hAyMoeQnNqP1PQh5OaNorx0HLXOGTQ3zKKrbR79nUfR134U7a5JtDVMYnzw1DP/tvxZTQs12rTtMC4muDCkp8y///f/HtnZ2Wqh9KwPHxczNpsNBw8eVFsguNAxF0lcGPX19akFObec8D/vXDhz61Rra6ta2JmLn6cJNVxkNTU1qf/c8z/4HEdNTQ2++93v4t/+23+Lf/Ev/gU++9nP4tvf/rY63JiLLy6y+J//6upqHD58GN/73vfUWSU8g4SCE7dH8Zqm8awbegPxvBR653BsXHyWlpYqAYhbrn74wx8qDxmex0Hh4+WXX8YPfvADtVWL98cFGueH98ExVlVVISQkRJ2TwjExn+N69dVXUVdXp+6TY+K42Rfnh+fOcN5Z972M8/rzCjWEbeilRI8J3scLL7yg7iksLAwtLS3Kc8ocO6EXBcdNLyseJGsujFnGOA985jX4LnDRyjx6WLHv/Px8tQ2MffO9Kisrw4ULF5CQkLAp1PA94n1xGx2fBeeUfZvGOPM4V+yHnh3mGHYa858m1LwfY1s+p5iYGPUO8P3gOUn+/v5qfnx9fdV4+Y7xmZrG8fH5nTx5Um3XM9933g89Ky5evKjeafM94WKe7zbPGeJ7x3ONWJdbCycmJpT4QGHx0qVLahws43t45MgRdabPlStX1DVycnKUCMBnybnme8eynffLa/PMFH4mKK7ys+U9v6Yx72lCzdPM7JNiBO+Vc2V6tbEfjouH6VLE4XvOZ8F5rKio2Jw/cwz8XObl5SE2NlZ9Fvjzgc+Z98yfLZxzes7x5wR/znDeWMbtWHxf+E6an2v2yXFwccDxcZsktwlyjAz5DnGO+c6Zz4NeghkZGeo50IOPP4M4l/z5wXeW77B5Fpc5ZoacR75fPF+Lz4OfSW7po4DMz95v/dZvaaFGmzZtv5TGn6+bQo38zK0pK0FJZDByD/sgw/8A0kmQxIP9kBp4UIkfGSwT0gJ9kOJ/EBmBh5AZeEBtYWKYGbgfWYclDNiLrIB9yJV8S1QgmrNiYYsJRHGoD4rD/OU6h5HquwfxB3Yh6dBexO3bhdi9u1SYePBlYS+i98jPa17j8CGkSn+54X6I992N+IN7lCiT7HMAMWyzfzcSD+xRwlDCoQMI3/UiEpVXzQElxpREHUZpRADsMYdRHhkAS1wo8kN9URYTBEdCCCoTw1AeIWURgUrMKYmQ/PgwGTfPpgmCMzEczoQwOCjoxBxRwk19SixcabFoTI1BS0YcmjIknhaD1swEdOWlKLGmrzjDoCQT3QXpis6iTLSWFKOhrAaOsh4UlUwivXAOcXnzSM4/imLbKRSULyLPcgxFtpOwVJ6W8ARyrMeRYT2G1NKjyJY6efYzkndSwlPIdZxWZDvOIan0JGILTyAsexFB2QvYnzmPl9NmcSTnGDJsZ1Becxo1rjOwV52As+EsOvtfwcyxm7h0/SFef/cR3rq9irfurOKGhG/ecePteyt498HqJu/clzzGHwpLK3jn4QreuLOMVylgvEGR4iamTr2F45ekz9fuqfzXbz3Cm9LPW/dX8KZiVYkfl9+8L23u4Y2bS3KdZen7kcG9Vbx9dwU37i7jtVtLuHzjAWZOvoP2oWuo7biEquazaOy6gK7hVzA+/xZOXriFM5fvYO7Em+gZvIy23vPoHbmKvrFr6Bu9hq6hq2jpuYSGjnOobz+Lpu7zaO2/KP1dQfvAZYmzr8von7yG3rGr6By6iJ6JqxieuY6JueuYXngNU/OvYnzmFYxMXsXA2CV09Z5FW9dpdMi12vsuorHzHOz1x1HsnEdW8SRi0wYQmtCLgMhOHDzSgt0BjXjJ14WXfIzwRd8G/OBQPV6Q8CV/w4tml18LXjzkwi6fBuzxc2FvQAMOBjXBN7gZhw43wl/CwOAmHAlpQXh4OyKj2hAVbRAX34HUpE5kp8s7ldMPW/EwGisn0FE3ibbacbTVjGG4e0H+htZCjTZtv1DjL1Zu3eEZFNzSRHHCe3Gy07iw5bYjtuF/n83/5nPhxUUkPV8+85nP4Jvf/Cb++I//WMV5gOvHP/5xtaDlf555TS4Odwo1XPDz7BkeYsrFHfukUMMF87/7d/8Ov/Irv6LOgqFwwzNy2IaLJp458ulPf1odoktvny9/+ctq0c6x8L/c5rdK0Si0cCwcF8/e4Di5XYaLLYoVFHj+9b/+15tiBs874YKPZ+NwXH/4h3+oztQxRRYuJLmIpCcSF+D8I4VzxHFxkc12X/jCF9S12BfH9Ru/8Rsqn4tHiiPvZezLFGp431wIm54bO6Eww7FQ0PIWarjwptBB0YX3zXni4bE8IPb3fu/3VB7vm+IMnz2fDxevzOeYme+9KGacc/Bf/+t/VffIBTDz+EzYN8dKUYpt+Ty4UOZ87BRqeA3OB+eHYoN5DRrjFA04r1wMv/POO2pcTzNvoYYLbX6jk3kfO+H4TWi8DsUWPg++LxQJOXbCOfqd3/kdBRf1fD9Yn2357vHQbT4TzqH5jBlyDigQUMwyBRI+C77bXMhz3jk3PO+FYgbHTiGH4qCPj4/qj4Ik++O7zHFRfKBYScGPnzt+fiiCUDShuEihx9v4vCl48N0eGxtT7+XTjGN7v0IN5+/MmTNqjjkn5plM7IOfa4ql/Dzxs8hxcw45r7wfCl4UGc2fLZxLijnsh2IV55H3yznnPfEzyvnKyspSc8lr8l44f/T8488SvkPsi8+fQhBFV76z/BnBvji/vDZ//nC+KVLyc8v74PYuzj3zKcxwrPycM81rc5slP0MUi8xnTiGNW744Hr7jfEa8BttQtOG9c+uoFmq0adP2y2j82WoKNZPy901lcSFyQw4jw/+g+takvGB/5BzxRU6wL9L99ylygn2QHrAfGYEHkBfqj9LIQJSE+6E8mqEvisJ8UBByEPnB+1EYehCFRw7AGhmAqvgjqEuJhC0+VAk6iYf2INGXW6QkPMSv7d6LmD0vIWbfS0jw3YuwXS8iYtcLiDvwMpKkTtaRQ8iLCEDcwZcRL3mpfvvV13AnSjxBnU/D7U8HELVvD4688APEKyFnL3JD/VAWfQSlEf6oTAiGLeYw8kMOoUT6ssYeQVVymOSHwBEbIulgWCSvLIqeNUfgkLHaJa8qKRx1aVFwxB1BcZgvSsMDUJ0YhYaUGDSmRqMjOxHNabFwJUehMSUaLelx6OSWqIJU9BWmoSc/Bb1F6egvzUZPcSa6Jd4t+d3F2eh2VKPR0o3y3CGU5k+j0noMpeXzSC2YQmrOFNIyR1BmnYO96jhKnSeRVjCJ+IxhpOZOIrtwFjnFc8gtOYrMwnnEZk4gLG0M0bnziMxegH/qHPalzOHllFkcSJ5GYNI40gtm4KxeRF3tIqqrFuGsOI6qyuNoaTmHoeGrmJ27gam5NzE68zaG597Cscs3cemdR+orx8/fWML8ubtYOH8XV2+s4vVb67h8YwV9U9fgbDqN0oqTiMufQ2jGONKK51FRew6utrNo7z+DifnXsXD2Jo6fv4VT/Ar48cuoqp9GVd0U+obOYuH4Gzh17i2cu3RTwtuYWbghbW6gtfccHDVHkVUwhpyCWeSXLKCwbB4FpVMoKp2E1T4LZ9WcrD3mJTwKu20RpWVzKC6dRkm5UDaDguIp5BVNIl/CghKheELCCRSVTaG4XPopm0Bh6RiKyiWvfFz6n5A5HUVeyTDKbWOoqZ6Fq2YOTfULMm9HUVu3ALtjHiUyhqycIcQncntSG4IjW3A4rAVHwjoQFNKOI+HtCI3qQkBwCw741+NAQAN8Al3wD2pCYHAz/ISAkBb4UoQ5InlHJC1hQJBLqEdwqAvR0m9MXIcKExJaZe3TgYy0bqQldyI/owfWwmGU5PSjPH8IlsJRWIpGUFE2hlrbBGqsw6ixD6A0pwlJkaUoyqlRf399kKaFGm3adhh/sfK/wf/5P/9ntcDiV8v+pA8eFyAmNPZBAYQLF4oz9Bzggo4LfC6CCwsL1aKei27zv/9PE2roneMt1HDxZ37tMvvmIo3/ead3hllGkYZbMbgQpBcOz9XhNXlYLBeLf/AHf6AWkObCyRRq/tt/+2/q+lxMc6z0quBilwcDU6jhGPjffpbTO4KiAoUGtuNi2Vy08z4ojnDhRqGGC3PeB70FeB1671Bo4bjYD4UWektQdKLIQYHlvRZ0plDDeeIClv1x8UpR7Gnwm7r+4T/8h2rxSXGAz4ZzxYWt6QnB58MFOe+b3jT0VGAZ29OriM+H98u54yL0vYQajocLZrahUGPOLT05vOeWohuFIu+tT7x3LobZD8UKc9FPOI/01uFzoIcKRbxnmSnU8P2iqMEteRSGON87occKx2Nei/fC94Vt/8t/+S9KFOL8UOzh2OldY4pZ/JywHeeU88NFOp8732/eO/umpxefDwUIPgN+JTnnhuIKPU0oOFK84PvJ61K84HvM94lCA99xhvy6bL7nvA5FNPb3j//xP94Uaig48BlwfvgM+B5yXDSG9CbjZ4ZeIhRtniW+cA7er1DDuhTM+Gwp6vIbxvhcKL5w6yTfPcI5o7cN54PeMhQ9KQTzvvh+8XnxD3kKNZwPilt8xpw7zjvFVd4vDy7n+0cPGpZxrvjuUEShKGd+AxoFFI6Fc0fBxPy8cf4oUnG8fCeDg4M3PXH4XCgO8YBkions98SJE6odf0ZQ7KEwRg8dvoscM58RhTQKP+bPDo6J16BHFu/xP/7H/6g8yLRQo02btl824+8eU6ihR011WTEKIg8jL8QXBaF+KA4PUAKMJVrCqABYYwJhiwtCcdghFIceQlmkv6fMH/a4w7DHUuBgfeb7q/oUN+iJwq1EBaH+SDiwC5F7X0C8714kB+xH9L4XEbOf25leQtzB3YgVIvftQvAPv4+IXT9Eks/LSPPZjeygA8g+cgixe19Cut9+5Af7Ii/YB2m+u5ERxMODDyFHxh3y0ndVXxRu6LGTffgACqVewZEDMl6OleM7jELl2eMLm8SrEkJQlRiGingeGByCioRQNebyyEAUhRySewqCKyMGDQLT2QH7UB4WiMrYEOVR05YZp8SZJom3ZsQrOnIS0Z6TgPaseLQJ3QWp6CpMR3dRBnqErvw0dOWlSToN/eXFGK6oR5+jDa6SNhRltCElqQepib3ISO1HXvYwCvNHkC+L8ZzcQfnbbwjZkpeW2ofMjEHkZkl53hgK8seRkz+K3MJJ5BZNIzN/Cqn5k0gvmkJuyYzkzaDEMo/GugV0Ny9goH0Rfa3H0FYvedWzaK2bQU/zLDpbFtDUfAJ1TadQ23wW9W2XUNN6CfaGc7DWnEJl3Sk0NJ1AS/spVDecQLFtFkWWORSWz6PAuoh8CSkuOSS/0i6hY07WCHOoqppHbc1R1Ncehav+mITH4KpdRHP9Atpcx9DRLGNpWkBjA4WXaVQ4plBRKW0rj8JmmYLdMgGHZRwV9gnUVM+grnoeDdXSV/WcMC8sosG5gFqntK+a3aSW13UeRXXFPKpkLFUylmrpt5pjcnCM07BbJ2ET7LYpWMvHYSkbV6GtbBTlRTK/uQPIyRpASloPIuOaERzhQkRUM+Lj2pGe2ovMdD6rbqQldSE1ScKUbmSm9SpBJTmxXdJdyEhnXjeyhExJp0udtCQpj5fnLXUyUzuRm9GD/JxelBYOorywH9aifthLhlBZPoKqshH5jA5LOISKkgE4irpgyWlGcUYDSkh6DYpTK1CeWQFnfjWsWRYUJ+ejKDEHlrQCtNrrfuJ68ac1LdRo07bD+CGjUPIf/sN/UIsi73Mn3q+ZC2WKJu3t7WoBzjwuVBjSo4ULOC6WzO1BP0mo4UKWaY6F7c3/jnMhRy8e9svF6P/6X/9LeShwkWUuvtmGi1mKPRQgKAaYHhumUENRinHzP+yEfZpCDf+zz0Wb6QHAxSuvzXb0mDDH8TShhgKJxWJRWzm4UKUAxP7ZD/vjIpwLOs4JF64se5ZxTKZQw4UjF4mcB3MchHETLjz//t//+0ok4Bzwnim00BOIYgQX1FxEmvfMhTY9Qyge8Pnz+fAe6Fn1swg1XGBzftknn6n5PDjP9KzxPkyYbbgIp0jArxM3hSVC8YKiCe+P/ZpbbJ5mnCNTqOEc8SwjCiu8p51wAU6BgItutuO9UDDhmOmpwbF5b23j8+E9Uhygdxc9Xzg/fE84bnracPFvvpO8J4qdFOH4rNiG924KNXzugYGBm0Ifr8M2HD+fK4UYihK8hjnXrEsvDh72awo1bEMxiu8poTeO6d3GZ8qtO5wPfgbeSzRg/k8j1NCbi59b3gcFKvbNZ8V74ueW7z37Yx+8N46JggoFQgopFDX4+TeFGopjFFBMzxXOIbcc0ZuN46EAwvlkP+yPgh/FYG7T5Dwxn597CjX8+cP3l+8d6xKKONw6xfeSfVKsYxtTqGE/3MbEMZvPg3PPPP4c4L1SVGQ/FIL5btHDj3NvbhVkyHeU/fF+tFCjTZu2X0bjz09TqJmenEBzRTlq0iPhTDqC2tQw1KeHo1FoyY6CKy0MDamhaMqMQH1KMOqS6SETjNqUUNQkh6Ai7jCqEiVP2tWlhav2DekRStyoSI5WXi+hL/0QEXt+iATf3UgN3IvUgN3ICNyD9IA9SPXfg4zD+5EWuB+x+19E8qG9yJJ4UegBlET4oDTKF4XhPkg6sAvF4f6wxgap825yg/ahKELKwvajJNIXyX67kBawV3n+8CycwhBflEUEwBIVoMSZIsEefRjFIdJnmC8cEq9JDJX7iYArgwcKR6IqKQxVkq5MCEWZXMsRewTVkteYGadEnpIwP9gig5RQU5co9yh1G1Oi0JAUieY0CjcJaKF4kxlrkBGLthzJy05Ae24yOvJSJJ2M9pxUdOamoqcwDf0lGRiyFKCnvBhtJXY0F9ehpqARtrw2lOf2wpo/CFuRUDwER8kIKkpHZRE/LIv4UdRYJ1FrmUBV+RgqZDFfWT4KJz0q7BOoc0iZQ8KKcdRWTKJK8lwSb6uaRGftJLrqJtFeNYTWqm701HdhuLkPA00D6G4cQWfTJDoaZ9HaMAdX3TxqqueU6FFPgaRmRphCXfWM5M2ijgJMzaLUO4qm+nm01M+irW4arXVzaJa2zSqclfw5tEp5W4NBh2sena45dMk1FK5ZSc+g3SVt66fR0jAj7SSUcbbIeJtk3I1VExKfQmvtNNprpa6UtcpYmqukrnMarspJ1Ms91thH5f7HUM/7t0naOo5qmaMqmZ+KMs4dvVD6UZrfI/RJfACWogGUSbw8v1fCHpTl9aA4uwu5GR3ITGtHalIrkoXE+FYkxDYjJbEFWakdyEtvR2lON+wF3HY0AGtxH+yCrahHUWUZlGcwgmrrAJylPags6YG9sEeeaxcseZ0oy+mQ9hLmdclzZf0Bec6diipLj7TrRU15F6pL21Bd3IjaEhdqi5ywZ5WgLCUf5Wl5sKRlw5KaAXt6Juxp6ShPSoIlORF1OVloLcpHn9Oh/mb7IE0LNdq07TB+yLh1gkIN3f+56OIv25/GuCDhIpvbocwFOBc2jPMsDQoeFCXotWN6Jfy0Qg23FXgLNVxUcRH3r/7Vv1KLKi6gvRdGLOd/u7l44gKdYgcXVKZQw0Uix8W+TONc0Ovj3/ybf6POm9i52OI4uEjkf/Pp6UDR5WlCDa/DBT7/WOEinddgPgUALroplnC+eT/vtaWHxjFx7OyfohO9AzIzM9VZQjuhJwe9E/7RP/pHSpzigp5j6e/vV1syeM+8B+/r8f44BooRXEjzTB3O5c8q1HBu2YZza7ahUazaKdRwHKzH61BA4eKZbdgX55d9cSvSTxIPOUemUEMPjY997GOqP4pThHNihnwPec7JTqGG88syChXe7wSfG+eWIg7FAN4rny231nBRzveUnjf0HuE8Eb6jfBYUJjk/fA4UOCjUUPChdxPfbc4l4eeBz5TPiGemsL73/XKM9PKhOGIKNSxnn/TyoghBLxZTdKQwQq8tvvuzs7PqPX2W8fo/jVDDa9NDhu8vxSCKGPSe4dzxs8z3giKGORecF84P31t+/s17N4UavtP0eOPYzWtQjOF2KIqwfB9ZZs4Vf65wSxfHym1IvDc+Rz4T0yuO4zc/bxTROCbOEeeDz4ZtTKGG1+fPJPZrGueQnznO9/79+1U/HLP5HtDzjPfN8ZjG94I/u+hVo4Uabdq0/TIaf3aaQs3M1KQs1CswZMvAqD1dMV6RgYnKDIxYkzFcniQkY6A0AT2FMegtjkNHXiQ682PRXZiA7gLJL0pEb1GSlCWhr4R1UzBoy0JzQQqi9/wQwS9+R4kzlhgfVKcEoTr5MGpSDqMq+QgcCTy41w+22ACURfnAEu0Hu6SrkwJRlx4CZ9JhOOIDUHBkL6xSVpMieYn04qGQEiD4oyIuEPa4IOU1w+1XpeHSX5Q/6lMj0FWUhjJJOxNCYIsMQGVssMIZewS1iWGoTw5HU0YU2nJi0Zodi+bsONSlRKAqIRQNadGolzjT9WlRqIwPRo20qZay5sw4JcI0Z8SgJj4ErpRIJcwwvzE9Gg2pks6Kkz7j0ZmXhPbsBLQJrZLXmZuIzpxkCZPRJWXdecnozk9Gb2EqBvm139ZidJVb0VpahZYyF5osHWi09sAli3aXrR8NtiFhGM0V42itpPgyhrbqEXTUjqGrfkKYRLfQ0zAlTKLXNYXexinJm0BH1TDaKvrQXtGJ7uoODLjaMdbagcnWTow3d2K0pQvjrX2YaBvEePsIRlpGMdg0Lu0n0O0aR1fDODrrx9BRz3ASHXXTaKuZlmtPy3Wn0eOakXrT6JTrdjTIWFyT6JK2XS62l1DaM+xm2DAm45O+ajn2ESMt1+h2jXkYlfrDcp0RdNZJum4UvfWj6G8YlXGPoa9pVMrkfqpkPiw9qCvvQW1ZDxwFbagq6UR1aTecxd2oKOxEZVEXHBLaCjpRnteOkuwWlGQ1oyy3FbbCLtgFq5RVFHehsqRbCSoV0tZa2C7lQkEH7PRkye9CSU47inPaJGxDWU4ryrObFY7CDjiKpF6B9JnPdKv00YaKohaJN8Oe3whHfpOioqAJlYUtigqpZy9g/Ra5TiPKc6tRnGFHYboFBSnFKEzMQFlKOirlb5v6/DzUZqehJjMJ9dmJaMxPkXQCqrMSUZmRgNKESJTFR6I8IRrVmcloLsqWZ1uP/yt/f32QpoUabdp2GBc5FC+4iOJia+dCfqeZC6adsB960nBhxu099Kjgf/N59gsXVlzU8r/XXAB9EEINMb0MOH7vhRaNY+Iijf+t58Kdi0Eu3kyhhgtHbgnxFhN4D6ZQwwOCuehjP6ZxzNwmxHFQyKAIslOo4b2xDcfHxSNFAHrQcMsWt3dQXKIg9k/+yT9Rgg/H+F7zzTGZQg29EtgXxS8Kajsx59Q8o4aLas4rhRFuD2MZF5Q7jR4Y3kIBRbefVajhPdEThh4SHLtpzxJqeG16n3ArDd8ZPiM+Sy7o+R7wOjufw07jdUyhhu8w29DDigLBTigi0GPDfE6mUMNxc+G+853gM6bnCL1juBXLfMfpsUOxgOemUHCgB5MJ30sKQ/TIoBcH3wOKKny3KQywH96TaVz0833k3PDcF1OYMI3zxLFzjkyhhuWcJ4p+FCHo0cLrcLycC84Dt+6ZgtSzjP38NEINr8HPlOk5ws8ox8DPGIUpvi+8/53zwWdDUZXvC+/XFGroBUYhkc/DvAaFEdbjnPMgZfOzzTLeH7c5cqz0nqHownyOmZ8B/nwwP28cH+eAPzv4LPi54/2xD1OooYjLd91bnON882cYvdP4OeJ4+NwpGvKd5HZBfq68jePge833iF5FWqjRpk3bL5vxZ6cp1MxOT2GwuQrzrgLM1+dgtjYLc3XZEs+VMAdH6/Ow0JCPCWc6xipSMV2TJfEMTFdnY6Y6F5OVmSqcq83D0YZCzNflS1rKanIxXVuAtoJElEb5oCErHL0lcRgoS1D0SLwlJxzN2eFwZYShLjUYDenBqE0+jPq0YOGICmuSDqM6MRDOOH/Yog5KeRDqpW514mFUxAYIgbB7RBmKMY7Yw7BH+6E9h9fKQEtWLKriguCMpSfMYYkfQV0yv2I7Uok0jRI2Z0RJ/Rj0FCVhzJGH3uJUJcC05VCAMrxeGHbmJaIlMwZNaVFok34HyrLQU5ii8rvyk9GWHSf5cRKnaJWOPmlHIaZf4oRCTG9RKvqK09BTkKzasl9iHkA8WJqF4bIcDJXmYLC8AIO2UgzZyjFc4UCPxYr2Uguaiq1oLLahscSBhkK7xCsl7kSbtR6ddhe6nS3orWoVWtBX3Ya+mnZ0Sbzd3oDuyiYMN7Rhqr0Ls529Qh/mu/sx52G2S9I9/TjaK2mJT7f3Y6ZzCNPdQ5jqGsSExMfaBjDcOoihlkH0N/Wjp6EHPfU96G3oQ5+rz4jX96KPaQ/9jf1Sd8AImwcw0DQodQekTT86a3vQUdON7to+dNdJf0KXxDtretBeJTi70ebsQoezU+jwhJ1S1in5HWh2tKPJLtja0WhtR1VhPerLm+GSeIOlHXXlragtbUF1cZPySqkuaUKVhMQpcaeEFYUuOAoaJDRg3FFQv0mFpCuLXKgsdhl1PPGq4npUFdUo6sob0GB1CQwNXDLnjYLLJmlbPRolbFYhqYPLUoP6kkpUF9hgyyxSokx2bAKyomORFxeP8tQU1OVnoN2Sj25bAVoK09CUnwZXbjI65f0bqynBkLMQnSWZaMhORHVGPGqzpE2O1CvMQmN+OgZq7Vqo0abtF238xUqvBi7SuTDiIvRZCzWauZDiYpciAxfW7INxihv0VuA2JS6KeFgnF2k8N4KLTP4X/oMSargw4hYECjVcmDHtbRwnF5U8hJWeIvQ44DVMoYZnd3BLxbOEGtM7xnux9X6FGo6FC2uKH5wDjp0iC8fLxSnDf/bP/tlPLdRQAKHQwOfDce2E/Xh/6xMX9BQEKAzQO4GLVi4gdxrnhWfqsA4FEooK3LL1swg1XHibHive9/U0oYZ98f54yCvfPwoAfLd4fXqsUOzg++j9jJ5mplDD+eR8c+75jvD6OzHnyjT2TaGG46YIwj8wvYWNpwk17J/16b3Dd51iBOfbGz4rijT0wqDwZQo1FFUoYJoLfY6Fz4liJr01eB8s8x4j49y6R7HNFGpovB/OD98tCkb0QuL7aHpW8XwVfoa8+9ppLPtphBq+C/xMc6x8BzjW5uZmNT98tvzc8x3fOR8cN+eDIgbFOVOo4Tk6/FYqzrN5Db4DFO/4uaV495OEGo6X88B31zwgmJ5v/Jzx2TBNkZh53kINDyjmmUY7t9ZxXtk3hRq253j4DPle8z4pTJnCkmkcA+eDAp4WarRp0/bLaPzZ6S3UDLdV41hrEY635OFYU66Qh+PNRTjZUqI43V4uZUU40VaCUx1lKjzBstZSLLgKVXiqrVTqlUm8GKdaS6R9oRJ4Rm3pGLKmYNiWghFhmF46liQMWhIxUJ6ArsIYdORFozM/Bl0FsWjPjUJrdgQa00PQnBmGtpxINEmc6aaMUFVu1ItGS2YkXKlhqI4/DFdauKI1m94sYegrTEZHrixak4NVfmNGJGqTGKenS6z0Je0lbMngNzbJtfMT0FuYiKGyNAyWpqEjJw4d2fHozkvEYEkaZqqLMV9XJuUZ6MyJR09BEvqKUtBfnKryhsozMWKRhbMtB8MSn6wowJSzCLM1pdK2BCPWbPSX0GMmQ+4/CwOlsoD2MFiWKWRJP1nSNhuTtjxM2nMxU1WIqaoCjNlzpJzfHpWMdhlPY6bcV2osGjKTJExAfUYKatNT0JiTiabcLLQW5KKtKB/tQlthnizsc+DKz0VLUQF6LOUYqnRgpKYK4/V1mGhwYbqpBRNNzZiUvxEmmpqERkwKUxKfbm7FTGs7ZtpIB2bbuyTswqQw3tqJ0aZ2DDY0C60YcrVjqKEN/XUt6KttQU9NK7prWgyqhapmdDqbFB2VQkUT2oVWiheWOrTaG9BirfeCaZeHBjRJXiPxCB3NXvXYhxGvg6u0WsrqNtPsu9lSiyZLDZrKqyX0oOLMr0VjuZRJ2GytETzlEhppgxabYK+WcItWW5X04xDsaHdUyT1Voc1WiTa7QbujQsIKT+iQMgdayixwFZWgNjcfzoxM2FNSUB4fj2JZoxTHCHFRKIuPQmV6ojy3dHSUZmCwIh/jNcUYduSgS96Z9uJ09Mi7Ml5birkmOybkPRuQ96ajOANd5floLshCS2EmOstyMNVaq4Uabdp+0cZfrFyI8EBNLkwoNpiLyKcZF0YUDriQophCMYQLLy5iueiiKEHhgp4Z7IvfbMSFMA/2pdfOByXUcGHEhROFGv7XfefCiYskCjHcQmFuyfD2qPlJQg23mvysQg29Sbg9hEIHF+z0KuJZLBQk2I6LcW6r+FmEGm7netZCmv3sFGp4D9zaxkU+7/lpHjXc6sQxcqFNLwS+Dzz/g4tOvhfeYgnng9en2MDn+fMKNYR1za0zFADpzcB3gHPIBbL3M3ia7RRqTDHr/Zgp1Jjf1LRz3DuFGt4r54PPlt/eRQ8YCp3eW314DgrPjOG7zzy+E3wWfLfpecJ321uo4VxQpKJYRdGDnyfve2ac24sopngLNTTOD4UZeqxwaxYFNtOjhaLETgFzp7Hv9yvU8HPHc6H4jClwmN9aZnrU8F1hnPPBeTDng/C95+G73B7Jfkyhhh4tzGc/NI7npxFqmKZ4xs8gx8DPJ98zft54Xhbng950LKMHzU6hhj+X3o9Qw+fOMfG95HYsb48oGvvUHjXatGn7ZTb+7PQWakbaqpX4cq6rDOe6y3BWwjPt5YLFI9IUS3kxTnWU4kyn5CusONlahmNNxTjZUqqEHZOZ6kwsuPIwW52FaWcWJivSMFmZprZTTVVnY7Y2D1NVWRhzpCrhhtutBkqTMViWjL7iRPQUxqFXGCpPwZCFXiexaM0MlTAOnXmRqryvJEFtsWrPjkZXHrcT8TyYKCX6dOXFoy0jWtpEoj0/Dv3lqRiwyDWEEUcu+stkkVsieeWZGCihAJKEEauMszIPY7YMIQsjlkxMVRZiQhbGw2VpGLdn41ijFbNcLJene8jAqJUCTaYSeEYsRlvC+jNVBZirK5F+KVhlyzWkrjAqZWMCw1GpO2rLxbgjTzFmZ1wW4PZMmb8CzEv7Ccmn+DMkC/T+ohSZIxk/F+QFaWjPTUV7TjJ6JT1Qlq28eEhPkdQpSlNhR2EaWvJT0MK6eRnoLMiWvByDghx0FuaiszhPFv70zMhDe3GuEnm6SovQZy1Fv8OCIacDw1VODMrflIMVleijh4/dil6HHX2VFeh3Sn61lFdJWaUDnXYHmsqsgg0t1gq0WivRWi6h0GapRLvFKVSh3VolaafKb6fAYWG5xK1OdHhjc6JNaLUbtBHWlb7brA7BJu3tQgWaSy3Sn02QsLQMLUKr/M3MsK2sHO2Sb9Ihfwd00FOp3Iou+Xuky2YRyuWapZJfik5rmcrrdlgVPQ7bFhVy7xU2dFpKpE4ZBmSOSL/TJnPAuZF2tlJ0cyubrUTqFaFV5rYpJwN16cmoSoqDMykWzhSDmowE1GYkojEnFa0FGegukedZnosBq7w78t5OOfMxUZGLQb5v8p4M2PMw4MjHSFUxJmrLMOwsRp8tHz2WAnl2ueiWtoMVRVjsadZCjTZtv2jjYoKLFH7TChfeXAhygfW0xRp/CfNrcLng54KFB6lyGw4FD4oIXGhyEco6XExSaOEii94E/A8/Fz4flFDDxTmvzy0NPNiVCynvhRHHz8UyDxqmCMBFJRetv2ihhvfBa3DBRq8QLmx5BgwXk9zSwvnggaqci78JoYb3TI8FCiRcqO7ckkTj2R48i4PeHrxvzju9RnjOC58bvz3HW6jhfXMLFz1Kfl6hhsY54Tcb8f3j4prnrvAd8N4S8172Ny3U8JnTc4TihukBwza8H4YcM8UHtmPI9+hZQg2N98/zXnh+DUUX7zN52CfHyDb0Ctkp1LAtD7mlSEpRktvrKH7wPBye9eJ9L08z9v9+hBrW42edz+ZXf/VX1efH3CbG+aNww2dPkY336z0fHCMFLZ4lxfeK7+QHIdTwWizj+8l3l3AuOE5+3ih4cSx8j7jljJ5HP6tQw88uBRg+I3qm8RlwPKaxDsVOnlGjv55bmzZtv4zGn53bhZpaHG8rU14zx1sKcYLCTPMWx5uKVN6pdsNr5kRrMU62Gl41LDvWWChhPs52lOB0W5EsKJMxW5OFE01lONlcjmlnptQpwOnOcsEi15B20n5R2sw3ZONoQ47aZjVbk6u2Uc3U5KmtU7N1eZirZ50CtcWKZ+dQ1JlwZmO6Nk/CLIzZKQBJmYNbh2JlIZsh18vBuF3q2tIxwjN3VP0Cua4VR12lmK8vxnQ1haQCzFUVYroiRzFXk48ZZy6mKyUtfRxvLMd8baGMKQ+TFVmYUvn5EhZgqkIWzXZeJ8fwfHFyjHmYrsoXGEqbSrmHmiKJy98YLBemlJeMtJUywsU3y+dqSxSzCqaJLLJd5VhwWVQ/M9UcSwEmpP5oRSGGZFHeW5qJ7uIsCWVhXpSFjvx0tOaloTk/DU0qzECT5DXmpcIlaVdOGhqy01GfmY6GLEHiDVmpaMwW8jKkTgYacqRcaMjNlHQmmgqzN2ksyIIr36CB8QLJYz4pMnDJOBokvzY3C9XZGaiS6zCskf5qcjJQX5ADV2E+6vMLUJuTh+qsHCnPQV1+rqJecBUVoK20GB1lpUIJ2iXeVlyIFqG1pFDSBRLPV7RKvL28SIklXdYyNOTlSJ0iaVeM9hIpKy2UeJESVNgXaZV+mN9jLUKvowwDlVYMOSl2lGBQwpFqC8ZrrBittWFY4iM1FoxJfKTKInVIuWKgQsbHubfmo89RjG5bkfRZgK7yXLm2zFlBhpr75nyZ31wizyA7Ba6sRDTlJKu8liKpU5Am8WS05qeobwnrkmfaKfSUCtJPT0kmOopS0JyXiGbWk/r12QlwpsfAnhQBJ7fyZcahPitJnlsaqjOT4MxIkOeYiEEZ+871xM9rWqjRpu0pxgUFPRm4NYCeF1yEU+TgYoMLMX4QubCkgMOtHPzmE4ofXKRyMcRtGdx6wa0zXFgxj20I/+PP/0Dz/Aou7ClifBBCDfMplrAuF4hcjNEzhONlORfc3HrEcn9/fyUecTx/E0INvXe4NYSiARexvF/2zXHxoFcuQukJxHvnHzS8l2cZ2/08Qg3bc0FNYYELX3pdcMzsg/dOEY3eMRwLt4rQc4P3xfnith7eB70kzGfKMtahMMB7+CCEGtbjYp1CH7cAUTShyMUxeD+fZxnHZQo1XHzzHaEYwPxnwWvy+uz/pxVq+F7w3eI7zW8aovhAwYD98hlTOKDwxTkyzzN5L6GG7SgkcqsXvVIoNvDdN99lPnM+v3/6T//pE0IN29JLhfNG0YOfYfZDwYvj/EnGOfAWani2j/fc8bny2VPYoLcVny+vw/45RrbnO8Sv3ubz42eBP0vM+eD80TuL7xLHZR5u/EF51LCM/fNZ8B3ms2AdXptlHDd/nvHbwPgzhPfH8p9WqGE56/GZ8mcfP5PmM+K7ze2XfHb6W5+0adP2y2r82ekt1Ay31WKBXjEtxTjeWowTrca2plNtZZtQoDnTIaHA7U2n27nFqRDHG3MVp1oKcLa9CGfbiiWUsrYSnOm0KO+cU8yX8FJ/heDEhd5KXOxz4qKEZ7usONdlk3gFLnTb5BrlyovnJLdRMZRrn1AiUimOUTRqLpHxcQylWGzMx3xdDhZdZliE4xSHWiw41liGBVcx5huLMSf5R5tKsNhStkUzkT4bKTZJX1LXiEu+S+oyLfkL0p5t51yFmK0X6ooxU1eimK4twmR1AaZqClV8qroQE5Iel3CcW5acEq8qxJjERyvzVHy8uggjkj9cmY+hinwMO0ieqjtZXYzJmhKpVyb1SyWvDCMVJejnt0KV5Sp6GZbmo6skTxbyOWgryEITxZIiihs5qKeAkp8hyEI+Lx11uRmozU5XB9AqciSPHh05mSpkWV1mCuoyEuHMTENFVhYc8ndThfwdVJWVKfVZT9qzrvRVLX04pX5Feioc6VI/I13SGYrKzHRUZkk6S9LSlmGl5FeoetIuK03KU+FkH6osU1GRLnUyBOaRbGkr1ORkoy4vV+4hR8YgcYo9Mh6KPTVZSepA3drMZMlPQT1R4lIWqmRMNbIGqsvLU33wPhjW5uaq/GqBeVVyrbq8DNQX5aGxtBBNMqcVOVko4bcn5RaiQXnjFMJFkao4F81STmGqgUKV5Llk7mtknJUZqajOSUMV47ynjBQ4M5JVPueyWvrkXNdIWJufL8+F95JqzD2FqQJ5dvkUxTLQWMjr5KO5MBONBZlSJtcpKUKDPN/6XGmTkYS6tER5XgmozoyVeU+ALSUOdslzyv1zHHXZvHYiKqT/6oIcdNc41d9aH6RpoUabtmcYf7lyQc7FBrd0mOdr8OuFKaTQ48bHx0f915qLWv53mdueuFDhIZ48aJMeETyPhmfV8CtxKXZQOOAijX3yjBoe8slF6s8q1HAhxkUTF0FcDJlbdngNbrfi9iIKJlycceFOjxpTPGIbCjW85gct1HDrCa/LNlzkcTHHhSa377AvzgcFCh4ay69T5jW4+KeI8l4/6FhmCjUUEn6SUENPClOooUjGPN47nyOfG7cz8ZlQQCCcb46VC3Ce42OKOxS9eF88h4b3TDGH88iQogAXuLyOt1DDBfPPItQw5HX5jOmtwUU1zxt5v4tdjpdCDZ8B308+e259oShlwnszYZpiGueH79JPI9TwIFxej+8hhTN6WFCs4T3xGXObGYVB3iefAUUbXuO9hBrz/llOzw/zLBfON58b+2c+v82LZd5CDdvyWbE+P2MULHhdbr961nvibWxvCjXsn2c6sS/OEe+XcT4LiiP83BB6xtBLzPzs8P7otcXPIMdJkYXiLOeD98p54hlV/MzRg4zz936EGvbFn0neQg1FHm+hhu34GaKAQpGEP1P4OWQ7XpsCEgUillFM5lYoU8D5SUINf55xLjke5nHeeZYThV62pSBDTyHOEwUd3iO3NGqhRps2bb+Mxp+T2zxq2utwrI2iSClOtZcpr5ezXTac67bjbKdVca7bgvM9Fgm57akU50h7ES5SgOkpxwXJP98ldboYl7DbJvXtuNDrMOhxSD0HLvc6caW3Gpd7nJKWOqzfZcVFuRaFGl7rdLtFxkJsONluw6kOO053OIRKwYkzEp7prMJJiR9rc+BYe6UR73RisbMSCx0VWGivwFxrBaabKzHZVIGJRgfGhbEmB0aFEWFM8sddlRhrqMBoPZG8mnLFeK1FQguG6uzorxVqrOittqLHaRds6K6wotNRjg5HGdqFDom32cvQai1Hq8WO5nIrmssYt0ge80vRbi9Hi9WCxlIrXEJDSbnEhbJiWYwXSptitFhK0Sx1W+zSTq7R6rBKvzZ0OivQU12F3ppqCSslbUe7lHc5HZJ2oqvSic6KShmHQ9o50Ch/G7j4N5TVjroyUom6UoP68go0WByol3HWl9vQUGZBdX4RUiKTEB+ZjsSYbGQl5aOiqALt1Y1wqfpO6atK2jhRV16JypIKOKS8stSJ6vJqVJdVo6asBjXlgsRrJawrr5WQML8aVeVO1EgfNVapa5U8i9TzhNXWWjitDXBa6uEoq0VFeZ2RFiolr8beiHpbA2qE+opG1Ek/jUWF6iyejpICWOOiUZmVK9esketIm/JGVNlaUWFpgr1M+rG3CM2SdqHS1oRqRwtKCyqlrA7Vzk7UCJX2ViRkOBGSWIGAaBvScl2oq+5CnbMdVVK/uqIVDbXdqKvpRJWzFbXVso6p60WDpKsrmiTsQrNrEC5JN1S1o7mhF+2to2htHECT1G1r7EdXxyi6W/vRWtuC9oZOdHeOobt9BB01jWivbZb0KPoHptDX1IruOhd624cwNHQMA11j6KmtQ39FOYasBRi05qDfkYd+Zxn65PkPtPdiavwopoZGMOyqxkB9Fcb6BjE/vYjjC6e3/b38QZgWarRpe4bxw8YFN7fqcEFFwYaLbi7MuLhkyAUPv/aXi1H+IjYFEy6W+BW3XNRQxKBAwq0Q9AJgfQo+XEBxMcivtuXCkts7KGJwcc1DTylwcHsBPRUocHDha4or3MpADwsupr0P0+WCj94EbMNyLta4XYfw+hQUKEbwP/6sS6PnDa8ZFhb2hFDDOaDwwy0mzc3N6g8Ob+OClh4NHIcp1PA+uBWC9802vA9ej4IAx8RFHetzPrn1iMIGxQ6OkQu7nYvEncYx0cOCc8qFLc//eC+hhot9bgejYMYFpjlPnENel+PntblAJnymFCi42OS2KLNvzgvHRmGJ57Hw/riopccGnxsXoxQFeLYKxQvWpxcW75XeJDu/dpzCBAUiigkU8nYKNZwDCm0UsPiecH65KH8/xutQgOMYf+VXfkV5QtAzjB5ez4LjpCcYr8HtMLxHzu9OoYblHJfpjWSOm8+ZAgPvn/NCAYzzypDCF+eN4gUFKvZHUYhb9Si48d32FmpofEYUV/j+8fBbjo/PhkIjBVIKF3yuHCP78jbOPbcBsQ3vm58xigrm/L6XsQ7fYbb7e3/v7z0xdxSc+PnnvfHaFMC4Vc77nWUfnBeKIxwrt8vxs8jxc145P3xnzG1HrM955s8L1nmaUMN5pehGscdbqOF1KQrzG6TMr+fmzw2eQ8N5488p/tzivNGjjZ83zjuFFT4bil+ce3q20YOM9fje7rwf9k1xx/tzxM8G2/HnGUVF85lTeKU4yc8GRWbOkRZqtGnT9stm/F23zaOmvR7HO2w42WEVLCo8pbDhdIfdEEo6JS4w75SEx9stStw53maRuBWLwlyLBXPNFsy3WjHbYsV0i02wCw5MNNkw6rJgpMGKkXobBuus6K+zo6/Wji6nHR2VFWh3VqG1ogrNFbVoctQJNSpuUAeXvR51ljrUW+tQK2GlLOjtgkMW9cRW6oK1pNEDF+hNsMlC3SqLdpsHFVd5gpSznkXq20qbBakvfdjLGqU/qSvxcsm3lLZK3TaJtwptsJR1oKykDWXF/JbQVhRLXnFJi4StKC1tlzyhuB1FBSzvkL9NWjcpLGxFQUEbCgrbUFgkfZR2wmrpgKVc+pT2ZWVyDYlbrV2w2rphs/dKWTcctn7YBZu1X+r3Sp1uCXtgEcrKe1Fc1ouSsj6UWaTcPgCLow+llm6hB6VSXmrpQ4knLLNKXPKtFQOwVQ6qaziEzLwWpOa1IbukB/nSX5ljCI7qMTicQ7A7h+GoIiOwSdziHIW9ZkJhrRqDrXpchZbKUVidYyrfVj2BippJOGonVRnzKuunVbpCwqqGOTgbZiU9BUfdDCpcR+FwzcFSO42KxqNwNi/CISHzq5qPoa5lEU4VX5D4PFobR9DOb41qHES1rVn+Zh2S/BOobzuNysZjqGw6juqOM6hqO4WK5hNwtp5EjaSdrUa6pv00ajvPwdlOzqKu+xyqui/A1nEB5a3nUdV1CbXdQtcF1HSeR33PJbj6LkveRal7AQ0Sb+onF9HYfw5tw1fROvyKhFfQ1HdWpdvGXkXP5GtoG7yAztFX0CXxoZnX0Td2BS09p6XsOgZmXsXo7DV0D59Fz/gVDM+9gcn56xibvIS+obMYmb2B6aM3MDN9HjNj05jqasN4Sx1mZJ00PzaH4wuSP3ceg6PHMTF1GtNTx+TvpQuYl/zh0XmcOHkef+X19/IHYVqo0abtPYy/ZCmOcDHChS8XHFyUcPHPxSqFCC62uHDxFgu4IKH4Qo8KLsK5UOR/nrkg5ZYOLtrpgUCvnJGREbXI5XW4XYCChul1wMUat0bwv/jcvmIu0OhZw/+Ssz8uKk3RhcZ29LihmEGxgdfmf/zpMUFPCYpP3vUp7PCaFJYoMHgvynkfXPCyDy6avRdvNI6D/0Hnf+rpGcAFMu+DC3KKIKYXA/Mp6vBeeV4F55D3TkGK80chh1tHOEccz7OEFxrHxIUxr0lvoZ33722sywUmr8cDlikSmItFjonXpUcBnxGvzXNRGGcevaJ4v2Z9Ghe0FIY4l6zPeaX3E58XtyXxPBR6+/B5ch75HPiMuGDfuVDlgppzS4GH7wL/mPMuZ3vOFz0SuICmt5b3s3kvYz98Z/kMKHTwzCJ6Rr0XvHfOJeeF1+K4Ob98J7zHxXK+1/wsmNvYWE44P9wOyHeCz5fny9D7hp8TvgsUEMx7YF2+2xR7TK+wncb3nWIZ54/90ZOF7yq/zYnPgB4ePIeG5694G8fC6/EMFookfLd3iozvZXyH+fnmvO2cO4prfM70CuM88Nybne8JjffJzwfvjZ9VzoP53vNd5DvM+zPb8f3gfNNjiIKp92eAc8XPM+ecni/eZXwe/NnEvrkYYJqfB77b/HnCnx0s4/1wHNymx/45J5xLCr38OUOxi959fJ/53np/pjhG9s333RR2zHy+x/zsU/Dlu8zPBd87vts8e4pxbq/6aeZfmzZt2v5fMP4eMIWamekpdDfVYbjBhuE6CwZqyjBYaxHsErejv8om2NHrtKO70oZOhxUddisaLVbU0hOjpBzOYgscxVZYCqywFtoUpfkO5GXZkZthQ3aaFRmpdvm9X4nUlCoJq5CcXIXE1GqhFgkpdYgX4lJqEJNcg+jkOkQlNyAmVUhrQGyaC7ESjxcSVCjplAZESJ3wZBciUhsRmdqEiJQmRKW2StiMqLRWRXRmG6Iz2oU2xGV1IC6zAwlZnYhNb0O8kJjeigQhPkPIbEUc60n9zTC9XeoRo36C5MdLn4lZ7UjMJJ1IEBgmZXUhMVv6z5H6EsZJeUJOt8S7kZTbI2EXEiRMyOlEcn4PEnO7Jd6FtIIBJOf2ITW/X+iTdA8yinuRXihhUS/SCvuQXtSPzJJBCQeQUtAveYNSZ1i1zSiW/EIpLxpEXtko8stHkSfkW8aRUzqKnLIR5FlHkV02JPFh5FvHJBxFbvmYxKdQYJ1AkWUUhbYJ5BPrOIock4p82zgKJSx2TKHILvUcEyiulDaSV+KcRUnVrKSnUeycRlGVIGGhis+gpGYeZbXzKFXhUZTVLChKq4/CWn8CtvpTsNadhKX2hKRPwuo6gfKGY7A0HIet6RTsTadhc0m51LU2noZV0qUNJ1DWeBIVbWdQ1X4G9sbjsLuOoUqlz0ubc8JZONsuoqrjMmwt52BtPY+Kzktwdl6GQ/LtLZKW0NlxReVVSD1S2XUFFd1X4Oh+BY6uV1ApobP7GqqE6p5XUdv7Gup6X0W15Nf1vYb6gdfhGnpd4pdR03MRTcOvoXHkdbSNv4H6Xoo8F9E89gZaJ26gU6DoU9d7Be2jr6OLeWNSv/8SmvovoGv8NfTN3EDv5KvoGLuGttGr6By9gv6Jy+iffgWdwxfR3ncK3YPH0dszjsH+aUzNXsH43KvoGz+LjsF5tHZPYXDiAqZPvo2JxWsYGltAQ2MbOnt63/ff6e/XtFCjTdtPMC5GuDDiIp8LQi6AuDjjwoZijPkf8Z3GDysXYlzomm3M8zy4COIvb/bBxRzTXGBxgchrmItf9sHFLfPMxT+Nddkv+3vaIpH9mePldXl9LgSfNlaOkUITr81+dxqvT28Ec0zexvrsl9fhgo3lvLY5Zu825ph4LY6JfZpjYhnn8lnX8TaWsQ37Z/un3b+3meNn/7yOt5l/RJnPiPUYZ97TftjyOrxPXteszzjzCO/N3J5m1uUzYt7OuTWfLduY74RpbMv6XEhTjKBowrn7aYzPlXNEwelpUJQxYZr3wrnkuMxxc852jptj40KdfXu/k6axD94v+zP7ZT/s0/s5sZ35jrIf7zLGKfhQuKCQYL4vDDlfbEfBg94uFBF5PdPYlnNJMYfeIYGBgUrsedq7/SxjXX42vefLxBwD74lzvPP+vY1j4btqvttsa37md4qRvCbfJb5/T5srfj55XW9xh8a4Od+8ljkezoH5nHhd82cA2/PaO3+u8PocJ5/7zuvTmGf+zNt5z2zLZ8JyXof98trE+2eeNm3atP0yGX9W8u8JCjWTk1Ow2+qRmuRAYqwdCdF2xEVbERNdgqREKxITLUhLq0BhfjWKC+tQJBQU1CMprQ5hMVUIDK9AQHglfMIq4BNRiYPhDhwIc8A3womAiGoERFbDL6JKqMahUCf8wqvhH1kj1CIguhaBMXU4HFuPw3H1CGIYy3QdgiR9JMGF4IQGhCQ2IkTiYfH1CIurlbABwXGC5LHtEUkbuKQPF47ESUhizXyjLvsKVX01IljqMh6R1Iyo5BaEJzYhXPLDE12KiCSWSV58I6IljEmuR1xKHWJT65GY0Yzk7Fak5LQhLr1R8lyIT2uRsBkxqU2ITnMhkkJTWjOimZfSgLjkGkQlOBGf3oz4jHbEprVK2zYVT8ntUaTm9SrS8nuRkteDZCXi9CpRJ0XCtKJ+pBb2SbxP4gMSN9Kpkp+sxJ0BZJcMIUPKWDfXMqqEHdbJKBlAVtmgJxxGrnUUmaXDkh5BjhJ0RjzizhiKbJMotI6reIF1TAk4ZrrILmWOSeTZJ4RxFFRIunIKeQ4jnS9hvpQXSF6hk0yjtGYOloZjKKs7hgLnnKK0loLMKZTXn5T4cYXFdUKJNIZgI2HTSVgaJa/xlJSR07A1nZXy00q4sTWfgbX5tJSz3kmpf0o446lzFuWCtfk8bK0XFNaW81J+DjYJHa0XYZc8R5uUtZyFvf0iyiTP0n4Ftg6BoeBov4yqzquooVgjVEj9ys5LqOm9htr+11DX/wpqui6iQvpwDbyCxpHX0DJ2A/V9V+TeFuAafBWu0TfRNvYmGnsvwVozjdqWBbSPXEf7+BvK46aq/TjstVNo6j6L7sk30D3zNtpGrqKubR5ltnYUFlWgpLQWtQ2D6Bo6jsGJ0+juP4aauhHU1g2jsW0GXSOnMTBzCd0jp9DcM43Glj60NXZgYmoBF1658cTfRz+vaaFGm7afwrh42clPsmfV35k2bWfe0+rQnpXvbeY1TJ5lP6nsZyl/Vt5OTNuZ/kn2fuub9d6rrned96pn2rPq70z/tMa2XPRyIU3PCW4d4fYd0zPppzVzPO+XD8p+mr6fVsZfdPQG4VlA3CLIr7M2BT3OA71UeL4Kt8rR68gULzh3hOITvW+4DYeeVxQy3msMTzNz3O/F+7X32/ZZ+aa9V/l79emNaTvTpj0tz7RntTHNLP9J9bRp06btl8G8hZqJiSkUldXhcKQNQZGV8A91wC/UjoOBZYhObEBEfDXCYisQl1SpiEmsQmR8leTVIIhCS1StEl0OhVfDN0qIrBEklLRPWNVmeCCkAnuC7DgQ6oR/VB18pN4hYZ+kD0ZUY394lVCNvSFOlbcvzKn69JEyf7mOL0OpEyhhkFzPX8oC5No+cq2Dks96vhxLdL0agx/7lzr+0XXwYz0pZxhIMYiCTpwLRxKacCS+ESFCeEIzjsi4jsTW4khMjSIiyYW41AZk5DSgqNiFSkebOoekvXEAXS3D6GgeRnX9CAqtPYhJrkVYXDUiEmsQKfHoVJf0WYcwISKhGjHxDkRHW5CQWo+EzC0PncSsTiTl9CAhq0sRm06Pny6VF5fRiUQJKbbQ+4aYog29chJzpR4FnfxeJHm8c1IYz+9DQl4vkgv7kEyhR0ikGFQgaSmjsJMipJcOI61kRPIHkVVCD5tx5WmTJXmMF9gmlLdNnmUM+cr7Zgx5tjHkWKWOZQjZlhEVz5b8tJJhZEmdXNsUCipnkUshxzGhvGxKqmclnEOuY0bK5lFUvYCSmmMSLqLQuYAC51El1JTVn0Cx5DG/tO44yhtPKgqlbkndSSk/CXvzWSXwsE5Zg5TT86blrNQ7hcLaRZRIH+WNp2FpOo/SxrMokjblrlOwNp5R4kyp67TKp6Bjbz4tbc9J3imUN5+Drf0ibK1nUNF2VoWl0k9F+yVUd15GVccFONvOoah2Afa286jqfgVVva+iqucqrDKe4opF1Em8uv86qvqvwdl1AfkVkyiqmIDTNQd7ZS9ysiyID49HSlQyrLZWVDZOosAhzyfdisjD0chMzEdlVT9cHSdQXTuA7LQ8xAX5ozTWD7XFOXBWNErZUbT3HoerrguZsbEoS49DZbkVdfIu9o1fQN/AcTidTejpm8DcwjVML76Bc1eNczA/SNNCjTZt2rQ9J0YRgttPeMYPD8mlEMEtK/SE+KB/+D/PxkU+D8TlmUr8RjWeBcPtO9zGw61H3NLEQ5150C+3aVHAoScPvXB4QDPPgaLAxfNU3usMI23atGnTpu0XZd5CzfiELKxLaxAYZcHB4FIcCinHoeByHAgswcHDpdjvX4QDAaQYe/2FgFK87FeK3f7leFnYG2THy4E2vOhXjl3+FuwOtOLlAAv2HLap+G6Jv+RXpvJeOizpYDv2BDuwK8iGXUckVFQYYZBD6kh/Et8dXIG9IZXYR0KNkB45h0Iq4BdWCd8QhxJ/DoRXbUKxxy+mTgk/PlG18I2ux0GKNjH18Bf8JB2U0ITD8U3wj21AYBw9clwIkHy/CApOFHickq5GoMKJ7II2dVZMdVUvGl2DagFtrehFub0bxeXtyCxuR0I2t13VISS+BqGJdQhXW7IaEJboQmhKM8JSmhCd0oiYtEZEJJMmRKW1IJqktyEytU3CDkVkWjvCkltUXlxmF+KyuhCf3amgMEOBhnAbV2xmuyJe4olSzrz4HGkjxEvd+JwOpBd2I62gG6mFhmdOErdcFfQgrWwQycUDwhBSKdYUDiKtaAgZpaPIKhtHdvk4MkpGFYUVMyipnEFRxRQyy4aQbR1BgXMCBRX0oplAltTNopjDrVJSh2GekGsbV2l61+RLH/mV88h1zCGvYl7S8x7RxhBmSH7lLAqrmHcUJXXHlPCSL/Fc51HkOynenFBiTUntcUkfRZ60L64/jpKGk0psyXXOI90yiRzpu7ThNEpcZ5XIk2ubQI5tWuqdgqXlHMpbL0j+PAorJ1Eo/VtazsPecUV51xRXz8m9D6mQ3jTOzmtKpCmpmUZ6WZdcd1p51NT2XVfbosrl2nmlvSgoboO9bha2xhMor51GobUT2flOJMemIT7oCDJCg1AUHYTyuCPICQ1A8J49CDrgiyOHAnB4z16khwWjLDUFaVHxyErJQl5SImypkWjOi0ZrbgRyww7i0As/wMFdB5EUHo7S5Ag4MyIQtfeHePErf4TdPzyExIQ8VNhr0NUxgIHRUxhbfAvTx2/g+JnXtFCjTZs2bf+vGgUFnn/Eb3rityfxgGcKFvQS+WUzesnwAGWKMTxgl4fS8uBlfvMRv02JW574tdfmNh0KNdzuxAOUeagzz/XhQeA/izeNNm3atGnT9vPaNqFmfApZBVXYG1SCH/oU4QXfEsWLfsWSLsQLkveSn+QdKpB4ocr7oa/U8ymWOqXYFWDBC37l0qZM8kqlriHYULh5KdCKXcJLkt4VaMMLFHGOOPDiYavAtIkdP5R+dkn+S4HlePmwBbuP2FT73UF2iTuUuLM32C59l+FgqAMHQu3Yw3x64IRRpKnB/ogaHIqux96wShyIrMXBqDrsDpG4lB2KrFP1DoRX45DkH5S6StARlOeOlB+SPOW9E1kFv6gqj1hTg+D4WoQl1SoRJiypASHxDQhNcCEopg5B8fU4kuhCQFwtAmJrEShpgwZJSxjXoLZ1hUqdYCGI7aQ8Mr0FYWnNCEltVt49oUktCE/huTodCE9uFXjODs/XaUNMJmlHrBJnGG9FAs/Cye5UeTyLh2JNPL1z8nuQXswtUT1IyetEXmkfCm1DyLcNI72kH4n53UgpGUCmZRRpZcNIKx1GSvEQkgsGpN0IUouGkCrptNIRJEs8jWINvWwsI4r0siFkWIaRaR1GRrnEy0aQbZlAtm1MGEWOnaLImDCOXMeU1JOwYho5jhmJz0gf08i1zyDPQVHG8KbJlXheBQWcKeRXzaCodh6FtRRo5pAjZLPMuYiC6mMoqT+FIoovkpdbOYv8Gumj7jiKG05I+YLKK3DOoowCjtSlkFJeu4BiKSvmFivXKRQ3nUNR/QJK6uYkPI5C10kUNZyCrfkcSmqOKgGqrH4R1paLwlXYJb9U6mY5hlEg5RXtF9U5NVVdV1HZcAwFeXUI8Q9DwP5QRPjHIik0EvmJUagvSkF/ZS6mW8ox32nHeH0+usuT0Zgfi4bcWDTlxcOVm4D60nxUlhTCll+I7voGnJgexomxbsy0VaC3LBk1KeEojvRFXvgBWBMC0VYQh0FLAlzpgSgI90NGeCjy0/PR4OrH5PwljIwvwuJoQWZ+DaptNfj/2fsPJ02yK70P/jO+ILlLcOGBHQDjXc+0911VXd57733VW+b13ntf3nvvq9p7N90zPR5mrVaUSFHkLhWSKK30+27mAPqwEKUISYgA4lM+ESdu5jXn3szqqph85pznrE5MyP/j8PcJhahRoECBgj8SSP9RJ6X5SNoskkCsRNJIRMT/GyGRK9J/4EoizZIwrfROpIplUtUjqfqWpBfz2/pE0ruTdFok0V1JrFcSOpYikRRtFAUKFChQ8IfAbxM1uzJRk6SgzkNOtYesSjc5NaKtcpEtETS1PvLq/ORJba1fjPnIFZZV5SG72kummC9ZTrWPzHI32ZVesqvEnNoAGVVe2XLrQmTV+MW1j5y6IOmiL1PMT6/0fDNHXGdLPsX+8p51Ppm0yZX2rZcInBDFLRGZsMmvl3z5KGyJUtgclX3LkTiyRWWyJq9RIoLCFLXE5WidwuYYucJHiRSZI6ywMUypWF8irLQjRlGraCUSRyJ3hJV3JoXFqewSfRKZ0z1EWXtMJneqpIibnqSwEep7pAidcWp7pOidJLW9wzSrp6jrG6Oqa4gaKTVM0sgZmKRO0twRrXTfKuY090/QqpumTtbgGZcja1SmBTo10/Rop+kaHGfANIvesUSvaYoegySSPMmAbR6dcxGtaNXmeZm0kYicQcsiA5YFNPZlDM4VtHYpDWoBg2cVW3ALs28dnXtVjqYZdKzIGjWWwLYcIaP3rKMRa3QOae6OnNKk9WzINuhcQ+PewCRp2gS/IWq0XjFfEjb2Cx9S5ExY/BsKifHALgb/vrg/whoRFr2BIXiIMXwNXegQfegbgsYeEW30GhZ53nXRdwNH7BZmKfJFrJMIF1viNvbELayxa2L9IQax1pK4gy15T/SLNnEDW+wIc+w6lqE72Ifv4Bq9j2tIrIvsCX/X5DQoj6RvI+nWjD/GI/yYXWui/y6+6af4Zp4SmH2Ca+yWeNZVmVzyibn+6WeEZp8TmHmOb+qRON8Wjvi2uH9EUBIdlkWGXxKbF3NiG9j0Lnpqq9G11hFzWJgdHmV9dp7duTEOJ31cm3RwOGFnf1hY0s5m0srakI/5RISRkLCYVLksjEVjZnFshp8/f8i9g20Ol+bZHkuyk/CyE7WyHVKzG+qT7SCmZTtqZD3uYX18jPWVA3ZvfM7enV8K+4qdo8dEPH6S5gFuzSf5XxSiRoECBQr+/xdS9IykxyIRNBLJ8P/maBDp2X+T1iS9k9+8Fyny6D8XXir1SXN/M0eJpFGgQIECBX8o/OeImtwaF1lVEunyDUFztdJJSrmdq6IvpdxBaqWb1Aph5S4yKr2klbtJE/dXypxyX0qJk4wKD2mlv27FmETCZFf75GtpfbpE7NT6Sa8RfZWeXxM135A3kmXWiPm14r7eT0a1GJOuG4Nk1PnIEn1SdEx2bYAsYflNETlCRyKA8puicoROapnrm8icJsmfRBSJdaI/pylMep20PkqRuC6WInMaApS0Rihpj1Mg+vOlVKu2pByNU9gixlvDlHQmxJw4Za0xOaKnvC1BRXuUijbpWhJP/rWGTtew6IuJ64Ss01PTI6VbjVDTO0Zl57CchlWnGqOxf4KGwSkaNDNUif5qSexYO0WXZpxe3SQq/RStqiR9+kn0tnmMjgXRzjJgnqLfJMw4hd65gNm9iNWzjNm1jM6+iF6Y0bEo+pcxOpcwiH4pokbrXsEQWMfoX8fgWZPN6BWtMKNP9Asz+TewBDfRi7kW96rwIc0TbVCKtllDLfzJJsZkosYvRdtsMOgQY1LVKf8uxqj4NxSRomr2MQb2MfgPRHso9j7EEv0mIkYXPkIXPBR+j7AKM4lriaSxyNE1Yk5I6jvCJhE2kZvC30055ckWvy6uj77xI+7Nsdu/HvsmokbyLRM4Q/ewDT8Q7V3syW/GbRKBIwkYD9/DPfII39At7OIZnKL1Tj4W9gS/sPD0A/yj4lyhDVxivm/iMcFfCxBH5p7iH9vFEVslNHUPnxRlM/+S6OKnxBc/JjlxyMzIHJuTsyxPrTAxc8j40iOm1j5ifv0BC9MrLCfDLIeNLIcsrCVDrI5PsbSwy8z6IyY3njOxKJ7TNUy/ysb8xDJfffKSvd1b7Bw8Y3v/Y/b3HnA4O8lBVM+OX8Wmt5u1gJaloTjb6wccHj1jceUWifEdZtYesLb/hIWZRaY8ZhYCVm6szCpEjQIFChQoUKBAgQIFChT8MeN3iRqjI8nVUgupJTaZrLla7iCl1MblEiuXi61crXSRUuHicpmD9Eo3GWUuUkvtpFU4SC2zkSYROmI8tcwp1rrFHC+pVR6ZwMmu+CZiJkX4Tav2CPtmLE3Y1UphFRJh4/3GqoSJcam9Kkyal17rJ6MuINb5yBRtZo1fXpNTK65FnxRNIxEyefVhmSAqqA+QV+eRo4AyhP+8pgg5jWGy6iUiSIoOktKwpDk+iptCFDb+mrCRImyaI5RKBE6jlHYVoLBF3HckKOscIqc+RJG4r5QibdpjMiFTKWnjtCUoFmslfRxJHLmxf4ym/lFqVSNU9ozKqVjV3cM0SBE0mhma1NM0CquVInKk6lPaKVQmqTT4NF3acXp0k3LFKOle61gQJqU4zdCjF2PCpH6DfQG9GNPYJeHhWTTWeXRS9IxzUTaJpJGqQGldyxg8yxiFmTwr6MW96ddEjdqxiM61gtG3gV4iaERrcq1iFNdS5I3as4rWt44+sInGuy5r2uj9W2g90vWmTNBo/XvogvsYo0cYQ/uYQnty6pPGvSOTNZIWjUSwGGSSZl/42sMk+qX0J3P4OvbYLVm3xi7mSCSNOSQRO9+QL2Yx5kjcxT1yV46eMUupU9K82G2skgCxRLokb4l9DzAIsyTvyESNfeQ+9tF7uIbvyiXCLeFt4U+0Qw+wjT3BPvEU+9hjvJIAcFyK5tnDP3Gf0MwTQnNPZKHgiDApCscmkT2x64TEdXhG9M9/LGvZxBZfklj8hMjMUyLT9xhZuM/okiQw/JLo8mdEF6UKUS8ZW37K+MIdpibXWRwZZXlmg8XVx8xtfsbk5qeMb33BxM5XzIh2cukBHv8sM7MH7N/8hJWjz1g4+jlL13/F9q1fsnftBXvLa+wPedkZi7AjrncPHrN76yv27/4FB3d/xdLWQ4KRccI2C+MODSsRB/tr6zx59tl/9n8i/j+BQtQoUKBAgQIFChQoUKBAwe8Rv03USGLCZtcwmRV2rpZ9Y1eKLaRKBE2pTbZ0qb/SSap0XWonp1Iic8R1tZ3MGifpVVLrEa2HrFo/2cJ+E4GTVyORKz6uSARQrY+0Gi9pVV6Z9JEibtLkaBwHmdXfXF8pdQpzCD9iTbmDq6L/SrmTnPoAKRVOMoSv9AqXrHuTIfxnCh9Xim1kVYt+sV7SxMmUtHVqvVwqtAo/QTkCqLJjhEzRSilVKSVWmaiR5pW1hmWypkhKl6oTZ69xU9QSJkcicDoT5DWHKO0akske6bqiMyanP5VL6VLC8qUInY6EPLdU9Nf0StWlYrJmjZQ6Va+SqkyNUts7QotmWi45LgkKN/QkadVM0GGcoUM7jso8S6d+kj7rPF2iT2VdoEO6ty3QL677bXN0GSbo1E7IkTW9RjFmmWXAMo/BvYJaSoUSa1ViTCJgNM5lLIFN9PZ5LO5FTK5FtPYF1I4lTP5NuVKUVLbb6JWiadYZsH9TPUqqDDUoVYvyrKHxboh2gz7RPyD6ZIJGzJdMI+nbBHZFuyNH1hgk8WFxr/VuofftCTsQ9/tizS46MaYXYzYpHSp8hClwiDF0iCm4jzV0TTZz8ABH/Bq2xHVMUXEfvS5H19jiN7HEjjBI6VUSgRO/K0fVWES/ROBIY8bIoZz+5JCiYcbv4/11tajIuJjnX8MSPcQ68hDH+BM8UrnvqW9KewdGbmJ0z8uVqaLzHxOcfU5k7jlhqQS3JCA8fA29Z0qcb5vY3DNiS0/EvGfEF18wtPSChLgODu1hD64QFH5jvyZ5PMKvb2iH5MQ1hmcfMblwj+X5PcYm9olN3mN45SVjW18yuvUFw6svmVz/gun1l4yLeaPzNxlZeczE7udMHXzJzP5nTG99zPrqNXYX19ld32N14zoL2w/YuPEl27d+wc7tX7F182vWt+8zHvGzEdZyfdzH4foW67sPuf3RXypEjQIFChQoUKBAgQIFChT8MeN3iRqre4TiJj8X8g1cKbXIpMuFAgspJWYyK6xcKdCLMTMXi8xcKjaTWurkcoWTc+UWzpWJ/jKrnB6VXuUitdzOxUITKWVSVI5DJl+k1CcpguZCqY1LZXY50iaz0iNr0mSIvS4VW8gQ/lJKrXLqlJR+VdYaEj6Ef3GGs8VG8pqkNCq3MEn02Elxg5+cChcZYp9M4U+qMpVT45d1bS4Lf9m1XtGayRZnyhJnKqkLUlATEmd0k1nrIb3aKadIZYr7Yimlqj5ItvCR3Rwkv0WKnglS1hampNlPiXg3hY3CmgKUiLGSxqDoC1IorvObAxS3hShrD1HbG6euN0qjKkaTsA71EK2i7ZSEiAdH6DbO0W2YkcmUdvUoPaYZugxTqG1zDNrmGXQsCluiz75Ar1XMtczS51hgQPSrXUto3FI60zIDlikGzBMMilZrm0FtlaJv5rF4VjCLeUZhWucC/fZZjN4VjFJKlG9NJm7MAam60woDpnkMojV71zBJ+jWeDdSONbG/VL57XY6wsUrzJfFgtxh3b9BrXkQSH5bKcTuiu5j961hC2/J9v12sdW3JBIzOt4cpJGnX7GMVYyYpEkcihUQrVYKSq0BF9rCFd3CGjnBIZb3FGRyxfcyS7kz8OvakRNQc/Tra5hr6wCHawBH68E2MkVtyupMcVZO4iTVxW9zfwDt+G9/4LTxjUnsfz+g9/OOPcA3fxyaVBB97QGDyKeHZJzJZIwkL25N3cEraNlKEjZjrm/om7Smx+EKYuJ6+i3viJp7Je3innxCce05k8WOiSy+IC4vOPcQVmae9241KN4HBtyrezQaBkeskF58zuvYl4+ufM7X+CdNLj/AEl9E55ojO3GNkWYwLHxOrnzK18yWzR18zsf0C38gehuAawYnrwo+4NkWJhYbYXL/N6vWvWL/zc1aufcrQ3G0mlh8wv/cJs0vXmIsn2E1auD4b4MbeIQf3/oKdO7/g2j0lokaBAgUKFChQoECBAgUK/qjx20SNlPqktyfJqHJwodjC2UILpwvNorVyvsjCFZlYcXKhVFiZmCPsTJGVc8U2rlS45GgXKQLmcomdi6LvvFh/UYynibG0cgeXhI8Lwt/5fCOXxfWlAon8cZFZJtYWWzmbb5CJGmlM0rtJKXfJ6VVXKxxcLBX9ZTYu5BkorPWSIUXCVIuxYhNZZVa5L134KKrzk1vpoqDOS16tRN5Yyal0UFxjpbRaQ1G1npxqC3kNXnKFZVSL/Ws8FDYFqeqKUtwSoKZviKL2COU9SSqFlbWFaO4fpqkrQn2rn4bOCNVtQWo6wzSpktR1x2hQJajtiVMjrpt7k3QMjNCqitOlHaGlX9zrxugS1qMdpX1gCJV5hnat6DNO0q4fp9ciETWT6F2LDFjn6LfO06GfYMAxT591Fq1nGZVoB11L9EikjW2ebuMUGucig7Y5tKIdEOM6h2jNs6gtos+2gEaMqe1z9FmmMfslImZVJmq0wo9aFhleRGdfwuhcweBcxhHYwubbxOJZl9OfTO41uXKUZJbgtvCxhdG7IadJ2UI7MnljFdeO4Bb20CYmsYfBL9ZKosWhbWyxfbn0tSO0hzuyg82/gt2/KvbZxB/fF3ZAIHmER6quFNnF5Z3DE5jBGdnAHt3DLtb6hq/jTV4nKFqbf45BS5RB5wLO5E28o3fxjtzBM3aL4PgdwmKO3SWe3zaG1ruCT6r2NPGA0Iywqcf4x6WS3jfFXuLMnkUM4lym5H0cY0/xjj+Wy3P7p57gnXiEI3GA2buMU5zDOfYQ58QTfDPP5Gib0OxHBKYeEpy4g2/kmjjvFgO6JGqND4tjGHd8VyZuRlafC3tJYuUTEsufMCTasdVPCIs1vsg63vgmsbkHTG59zvSWFDHzkglxPbn7NVM7n5NcfMigMU5jQz/9vRYC0UXmNx+zev3nrFz/BSs3/oKNW3/N5o2vGZs+xGb2k3AMsjls4MbKOEeHd9i//RmHD/+G/cd/y72X/1ohahQoUKBAgQIFChQoUKDgjxn/lKg5wGCPU9YelDVnjmVoOFtkIb3Gw8lcvUzcpNf5uFBi4USOntN5Jq6UOThfYOJSoZnLkonrC3lGzuUZSCmVUqespJc7SZEJGDFWYOBivoE00Z9SZBZjDi6JNRI5c67AyNk8PSklNi6VOkivdpNaZhdrTGRU2UkvNZOap6O4xkteuZW8ChuFNW4ySi1yWyhF2ZRa5TazzExRnVPMtZNfZqSiUkt1RQ+lVf0UNZgob/dT0OCipNlHVWeEUtHWqWIUt7ip6ApTPyiV8BZt/wjVPTFqu6NyRExNq4+m3phcoruizU+rZoQGVZymviTtunGa1KM09A/RaZymUaxtHhwV1zPUD4zQIfqkykwduinatZPCJmgeGKbbMEmPfkImcgYsM6hM03Tpp+R0p07jFG1irFvSprHO0Sr6WnUTwsekmDdLn2lGJnZ6xbwewxS9YlwSJFaJa50k/OtYoN8sRd1MyYTNgG0OjWtJjtqRxozuFWzedfFzX0JjllKj1tBbF2RRYp11HqNTivpYkskYmxRVI+naOBflMt8mWe9mGbtvDbt/XcxZxRXdxh7ZwhYR44FV3Mk9HJEdnOFdOcrHFVzHHdwgmNjHH9sjIMwb28cmReaEdrCLNc7QKr64WBPfxyuRNEPX8CSu4RPmCa9hdIyjlwiU5BH+sVv4xm4SGLtNdPwucYk08UzS0eugRxsXa2/JZbddY3fwTtwXc+8RmriL2z+HqkdPe78DV3KfoBQhM/WNeceldKmH+EeO6NOG6e3zojaN40rckEt8e4fvimc8wOhZxOSewxPZwBfbwuWewe8eIxQaJTy2R2j6PsnFjxhZ+5ShleckFx4yPPeQ8aWnMlFkto2L8+4zKu5Hll8ysf4ZM9ufMrnxMSML90iMiXdmDtPVYcBmDpGIzTC9+oDVg89ZPvqC+aNfsXL9r1na/5K17XuEnW7GbH3cnnFzfTnBzs4Rmze+ZO/BX7P38K/Yu//XPPr834nf+d9vEQuFqFGgQIECBQoUKFCgQIGC3yN+l6hRG4PkVJnldKMP0/o4lqoiq0ZKZXLyYeYgpwt0VLRHuJir50RKH1dLLGRX2jmXPcD57EFyKx1kllq+uc9Vky3WZUhaNxIJk6WWhYpTikxiXEua6JfSp87kasmqdpNSZuN0toZMmbwxcjFfrK+2kVps4mqxjqpGF3mlelKE32JxpsxCHTllFopq3TKBU9noF+NmMgoMlNR7SBfjxdUWWju9VNZaqG8LUtrq51KFlZL2KJUtHorrrLT1x6jpCFDdGaJxIElBk5vStgBNfcOUt4WoUyWo6AxT1RWmTTdGjSpKuZhb15+gui9O/cAQbYOj1HVGaFOP0qafpEEzTu3gBPXaaapUI9T2jdDQP0zrwDD9phm6teOy+G9b/widor+tJ0avZoQ2sX9z/5BM4tT1Jmg3zdEileM2z1GnFnuL9W2GKbHPOO39o7T0xulSj6C1zaHST9AuzqzST9Ojn6JF8ivGNBJBY5yi1zAhR+d0ir3V9nkGLTMMmqfRWGZRi7MYHav06UWfZQ6zawWHf51BsZdZInRss9jcC+J6FodvBZNrHqt3Ebt/hUB8G5t3CUdgDZNTtKFNLOLaFdvBGd3BEd7GGd7BHRL3/k25lSJ3pCgcR3Bb2CZeMc8T2cEuETbhAzyJA5zJa9gTRzjjB3KKlDV0gC14iCtyhGf4Oq6hI9zD13CPXCM+dYuR2fskpx/hih+hD+6gFntZxLVXSn2auI938iHeiYeExZzk7CMS40eEIotyVI8zcU+u8hSeeSJr0ISmH+MevYt/5BCLJUZzdQeVVT2oNBHx3kO0DwYZtE2Ks+0QmLhNdPYZQ4ufMDp9l5nJBTyuEBrjMN6hG4Qm7xOdvk185jbJ+Uey2PDUyjMW18RZfTO09kewBDcYW/6IpCRiPHqEWuujq62PofgMM6v3mV57yMLyDSLRBXGm64xuv2Tt2i9YFO3Y7CEhp4P1hJHbsw5ursxxY/++mH/E5NxNFvc+Ze3m11x7/Dc8+fjvFKJGgQIFChQoUKBAgQIFCv6Y8b+LqBEfpRIRcuGqiqu5Gi5lqTmZppJJlwv5Gs5kaTiXp+NSgYEL2WrOX+0nS9J/qbDL5IpMwBSZyK6ycDm/n9ScXipqzMJMZBUMkpY7SEGlnfQSI5fy1GRXSgLFEnljpLDGSX65mvyiNmprusnMriOjqJe0CrPwO0huhZUC4TejQEdJnYOcUhMF5VbK6pykF2mpaHBS0+whv8JEXW+cgiYfObUu6rujlNQ7KWn0yNExBS1ByjtiVHVFyGt0U9kdoborQW6dj7L2CFXdMTnSpk01TF1XjKJGL029Q9R2SyW6/dT2hGhShWno9tGpjtNnGKW1O0Rnf5z2gQRNfTEahTUL61QnaVFF6VYPiQ/8pLgfoVs7RpM4R9vACI3Cp0rcd6uHaetP0K0bp1EiWHRSRM4wTYOjtGjGZZJHitKp7R8SY5N0iL5Osb5HzO/SjMrlvLvU48LPKIPGSVQaMV8VET/PSdT6UXSmKdE3IhMzA6KvX5fE5pzA6pqlQ6o2ZVkUtiALD1udc9ito3idY7icozjcU3iklCTPAjbrNAbrDFbHDG7PLEbrGBbnLHbPMm7/Kr7wCk7fMs7AOq6QML/kb1bsNY/Ht4ZfImWCG3jDW/gjwqI7uINbuES/xbuC1b+JI7yPM7KPQ5gzdijfu6NHeBM3sEcOsYcPcEX38ScPCI5cwzt8Dc+QROgcYYtcxxq+hUW0ev8epvAR7tE7+MbuEpt7QmBG0p55gGtMImbu4Rm5g1UiakZu4BFzghMPiUw8Ij4t5k/eliN77OI5VQN+6lp09BiTGAJrOIcOxfx7BKYfE557SnThOfH55yTnP2J08QHBxDrtvS66NVFxzj1ZODix8ISRtY+ZkMSC1z5hdO05o8uPsQWWaG6z0VivRaWy0942SI/KSTC5I1eLmtn5jIWDL1nY/5Th+dsYXFJlsCHxrhbw+cbxm/TM+fs5nPJyY3OVw+vP2L71FUf3f878xkM88XVxhk1GF+6Jvl/xj0rqkwIFChQoUKBAgQIFChT88eJ3iRqTNUpRhYWUDBVnUzo5L0XBFFk4ldLFuXQVGSU2TucbOJam4kqBjsIqKxdzNJzLN5JVF+BCoZgr7rNK9VSU91NR1EBzbTNtDR3U1/RTXKimpMxEdaOUkqSlqNJAdYufjGIbmYVa6hvVtDW1M9DSQU1ZkxhXkVMn9ii2klpupbjRTV6llaIqG1nFYs8SI4W1DjnyprDRK8zD1XIzBeK6oNlPSpmZktYgpS1SJScXVT0x8pt8smCxFDVULPYuanBTKxE0bVHhy01NR5jajhClwm99e4AGYXXNbto6QzR1SPde2ruDdEqETZuX5s4gLd1hGjr8tPRGZMKlsTtK+2CSdnWSJlWUWjFH0rNp7huipjNCfU+cFvUEtT0SQTMsPuhHaO2L09Aj9hZjrbpJGvuSVIlztOsmZNKmcWCEdilSRrS9mnG6ha9e9RBayxQdqphM+PSohS+xb79uhAH9KGrDGBrTpOgbplcidbTjsl+VYQKNZVKOxGnTzdJtnmfAvsigdRaL6PfYhkmGRetMYLNPYHNM4XTNiXYGs2jtrgm8jig+awCrJYrNOYXLJ5EyCzh9azg8G3iliBnnCD1dZhrqdBjFWcLRTaLJHWKJPaKJHUKRTfyhDTTGUTp6veK5Eli8q9iD29gCW/gTR7I2jVSVyRE5kDVx9LZ5VOJZjJKWTvhQNkmo2BLYxR65hjN6E1vomjyu961gFr4soX2ssSMco3dxSjo1Ew9wDt+UyRnP+D1xfQtn/BB3dA9fSJwpIJ7XN4XROY3eu4LOv4khtIV77JZM9kjmn3yAb/KhuH5McO4+4ak7RMZu4h/aJzhyIFopMuiQyOR9hhafk5REiedfMLL0CeMbnzCy/hHDi48JDa3T12smP62A7o5BfLEFwpO3SSy8YHr7S+b2vmJm9wsWDr9m4dovGV26j9s3TktFA1GDisNhM9cnnByuLrG1/5i1w5fs3/sVBw/+ko0bv2Dj5heMLV3DE5piZfWG/Dv/+4RC1ChQoECBAgUKFChQoEDB7xH/hKjZPWBQ5yclp5+iGjtns/t5P72P85Jgb5WNkxm9HM8aoKDRQ0qJkWOp3VwsVpNS6+SdfD0nKmykNAZ4N8/AyWwtBWVa8guaKSxuorZRTW2TgfyyAfIq9FS0eilpdJJfYyW1REdqqVEmMEpqzBRVaanq8FDU7KZQWEVXiEIplalUR3mjnawiNVnFeopr3aSXiLNVWMTamPDlIavSRU6lk8v5GnIrLVS1+8mtsZEtlw53cLFQnKvJK/rE3Con5WLPzHITBeL5JLKmuM5NTrmF0gYPtR1ByuudNHcEaGr3UinOViPO3NDmE62bxu4kTQPjVHYmxRmHqVNPUdY9TFZ9gNLOIap7hsQzeKlTDdFpmKG2R8zvG5b1Z9rUY5S3RSlqCtIixivFmaqEdQ0O0SwJFPfE6dKMydozHboJanoTYo8Y9ZLQsXiWhtYgGu0EfdoRetRDqE1T9AyO0G+cpFMzQn13hAHbPNVdUWrF2jaxf4N6kmbdDG36WVo1k/RJ5Ix1nk4pGkfsIevbqEfRmqfRGYexu8dxBebQWaaxepaxuCXR4QX04lptm8DuGMJtCxEKTmJ1TOILbeCVBITdq3iDu5htC2i1fspKWqgqV2E0jcqVjvyRNRyuBZmkiSf3iEQ3aaga5PhbZzl57Ao1dRpZaDg5eZfQ8HXc0V15T517kT5jkrSsao4fz6CuQc+AeRKTf1su9S2V/DYHd9C6VunTjdPS4SAzr5qs3CbURnHW5A6OIams903cw3eITD4iOHYPT+ImDqlsuGGaxkYb5QWN1ORlolYNogssYx69R3T2EbH5Z4SnHuAfu0N05hHDyx8TnnyCI3YDvW8VrX1Y+JmSCRrvyAOCUy8YXfuKoZXPCM4+ITL7mNGVT0gufExk6j6JyeuEQ9M01zZRkl+CxztKcvYG0cVHjG19xuL+14yvf8LwynMWDn/B4tEvmdz8jJGpQ3Sd/Qxru7gzauPBXJi7O/vsHX3G8tGv2LnzV+ze/iWr177i4OFfcfjob9m780vuXj/i+a0V8Tv/j7/+7f/9QCFqFChQoECBAgUKFChQoOD3iN8lagb0Ic5lDnJWWEaFnTMFOo5l9HEpX01KkY4z+Vo+yNVwodhMeqmBmg6pqpOeE2Le+TIz2Y0+UipdnJYqN0nlsGu9FDb7uFpuJKNML0e/FNY5yau1k1NlEdcOsisMlLc6Kaq3k19poazeSWWjm4Iqq7h2UdXkJr1IT7G4buiNU9Tgp7jJR3VHTJzBSl6Vk7quKJlVUglwmywOXNDkJ7PWTUV3lPy2ECmS0HCjn9KOENnSGaTS280hroo5GXUecht8chROXr2H/HqvbAV14gxivLgpQHlHlLKOMNni7AXiHNXtIXLq3eSIsYruYYpbY2TV+Slqi1LZk5DTqcpaAzSqhmlSjVAp+ivE3EZxtqpmP9VirLk3QVN3jHZVjGZx/hrR3z+QoKUrRl1rmLbepEy4SJWk6vpHqFGNUj8wTqt6jNr2IB2ir9c8Q0PfEK2SHk7PiLgepUk7Sc3AGPWaadol8WLDJI3qIbosYu7gGK26OVS2JTo1o+gsk2iMY/RphxgwjGN0LKK1zWOwz8o2aJmm3zyHxrGMxrlCv2UBnX0BtWUWo2sBl38Ju29J1rORiBynfwWPfw2HdwV/dAObS0p7msFkm5L7pPSoQHRT2Ba+0JZodwjGdvAJH3qNH70+iME2hjO4hc0vVZLawxLYxhPbwpvYw+hZoandQX1ZJbqWBvS9A6jUftr7pIpcdiqqesnOLCX9whUyzpwg8+x7FF05SV1RPm3NvZgdU8KnJFq8hck5L1dq6h0M0NHjFu8zJJ5rCoN5HLvOQdKqYyzgIxQaxxHZxDV0i9DUI8JTT/CNPsAVuy6XLjd5JcHmCM0NHRgHjdhdI7jEcwUmxbyppwSmnxCZf0Z86RMCE49wRrbpF8/Z1tyDV61mMepibmyC5PgRw3NPmNz8lLGtl4xuvGB65zNm979mdO0TknP3iManmIp42Zb0aKasHI3Z2F2cY2X3BXO7X7J1+y/ZFrZ2/Rfi+lfs3v4rNq//nKMbz7i9MsLL7YRC1ChQoECBAgUKFChQoEDBHzN+N/VJLz44L2cPcCpNxaU8LblVVtKK9ZzL6CYlf5CcChN5VXbSCjSy/kxRhZaqJhe5FRYxz0BaiYmCBi95TT7Sqp2cLzJyqdREaqmB4loHBWVW8stsFNXYKK2zk1OsoaTWTGmDlawyDQU1JnHtoLDaKgsBS6lHBWJdRrVDJj4q2sNcFddSVI+U0pRSbiOv3ktD3zA5zSFSaz1U9sYp6YqT2egXbYzK/mHSG8V5xLyq/iQFbUHSxXVJZ5S6gSGK28W8toCcjlQizl1U76FQSpMS8wolwqbBR3VnhIqOEPV9wl+rh6oWD3U9UXGGkLAw9d1J6rskLRyxtspGXYePll7hX5y/sTss69RIz1In9pHSojr6kjS2hWRr7YnIBE6F8FXdFaG2J0Z5R4SGAYmYGaZUjDUMTlDZOUxBe4Im9ZgccVPZPUSDfoJmwzS1vWN06edp1s5S3jdGi2WJWvUUNf1jdFrm5WpRzdpROgwzdBoWadfN029eRGOeZUA/LtopBkzTdKon6DXOorYuMGCYw2BfRWNfYdC6hMY2j945J5M0JvcKVt+aXMXJKenQuOdxBVYx2+cJBNbx+xdx+eZE3zIOMW7zLuAOSRWf1gkNbRMZ3cMb3cUb2RV+1uWS31apcpRYawtu45Y0agJbuMJ7mP3fVI1yRfewhrbQuWbRaL2YVAMUpaZy4eQlYRmc/+ACV0+doib9Asa6HIY11Uxbm0hqa7C0lVOXl0N1aT11TXraOm10d5lRDQYYNI/LZcWtUgWq0RtEJ2+RnDxiKLnA4vAQCZuJriaVeDfDGPy7wrbFe1jC5JoQZ1vAHtvBldgnMrROLDJEf7eK6qpemsTP1RLdl8WM3WMPhP9r4j2P0VzTTUNlA7pBAxNDS6zMb7K5uMRIeAKnZxHf6G3C808Y23zJ5PZnxJdfEJ26gdnkw6Pp5tqUi+drAR5vDHF7Y5bZiVks7gVGlp+yePgls7svWb3xFbv3/oKVa+L3+ug5j4+2eLEe4+ujCYWoUaBAgQIFChQoUKBAgYI/Zvw2UbO3d4DVlaC63ceFfDXHs/s5la2irMFBQbWZ9GItqYVa0koNZNXYSCszcDpLxbm8QdIrLGTX2DmT28/FAjWFjS4qO0OidXNZzL9crCOjWENVk4/cMjtnMzVczNGRVyXmtYQobZIIGTd5NS5hHjLLpQgbP+mlYm6OnlP5ekrawhS3BMls8JLf4qGqL0GOuC9qD1OhSnBRrD1V7iC7NUxGg1TdyUFOc4BG7QQVvUkKRH+TZlwub51R7SRTmJSKVFjnIaPUTEmdi24xt6k7SnWzhz51UnxYT8uETVG9i/oe8W66IuRW2SlrCtI1OCITLC29w7SqhqlvddPQ6qSi1kJNo4NOjfDd5JbfixQV02WYobzVR3ZZH22dFvSmOJ2DSSrFuRqlSBfbIoXqKXLaI1SL80qlu6UUsGpVlJKeJFWDU1SLefltAUrFuSv0czRopugUZ24QZ2wRZ+syz1MxMEaDboo+9ypdxlkae0doGZikU79IXf80vY4N+q1LtA5O0q6Zp0u7QIM4f7thCmNghwH7Mn2mOUzudXqE/379jJz65PAt4Q+v43QtEgxvYZBSpExTon9T2CqByBqRmBi3T2AwxOXIGK1zmsDYPsm5GwTH9/EO7TLomKNfPOuAbQm1cwGL8NnvWEDjWUfn20Pj20cTOJSFfiUxYVtI9Lk35LLlGvMoDY0GrqZW8/YbZ3j1ez/h7T/7Dhnvv426Kpdpezv3xow8mbZzGNPh7a6iNPU8H776Bh+89h4nPkihoKybHl0CgzizMbAtR8qEZ58SX3xOePqBOO8NAhM3SSw9ZHT+Bi57gqL0So69eZrsvHq61RE8sRV84+KME+K5Zu4xsfIJQ/NP8I3dQu+ao7Gul5Qz6WTnt8m6QxrHIk0N/eRdTKG9sp6R0SXxTu4SmvmY0eVnLG/dF+92irTMGtKyW9HZFghPPBS+H+Eb2qa7rQf/YDN7ST03Rwxcm/Szv33E6tZjhqZ2Ka3RUlypQSfe9+TGUzbv/JKlw6/YOPycw5197q8EeDzn5OX2BP/LPypEjQIFChQoUKBAgQIFChT80eJ3I2q0phD51VY5siS1zMypPA3Hs/pIrbSQWevgQpGOD7I1sqBwZq1L1n7JKjeTUawns8RIUZ2TnFo7KWW/JmeksWoHV0qlqk5WWXy4QhL6Fb6kKkxXxRopYien2k5Zi18WKE4t0ss+pWiWrAqrHOFS0hIgv85LTpWTqxUWilq9pAlfKeI6XUqXaveS2+AgS+xd0uKjoisqiwZLaU4VMmHkIb3cRm6Ni7ruuPDppqTBRW2rj17tGBVibrk4V6sqIUe4lFWbKRV+mzvDNHTFyK/1UtLspU07TIvmm7LdUipUu3GKBvUIRe0hiqVS3pKGTLM4a0OA6t4ELfoJmnTCJAJoIE6H2k+vIUi3PiLuxXr9uJzSVNwRpV74HbBP06OLYDb7SAbDeB1BNOYkNYNDVGknaTPO0mZZoE4zRqc2jskSR91vxmx0M6gL06kbptc6TYfwKwkX94o1/WLvAd24aEdp75f0a5KyqHCfcZIu0S9p1fTbFug0zdOqmaPPukS/eRatbRq7d0HYEgb7PFrRZ3IsobNIY7OYvcsYPcsMmheweFaxuuZweueJSGlKoQ3skU1syR104toY3qXXsUy/e51Bz7awLXSBLbT+LXqsC2LPKTSOeSy+TayBbbTeNfqlPvMwel0QvcpES3kdDXkFlFy8SPbx42Sc+pDqq+ex1uUybahjxdXCvKOV6GADqooCss6e5cz7Z7hwOpvc3Ca6VV4GDSOYXEuYxD72+DX8o5II8H384zdxDl0nMHGX6PRDYrOP8I7cxiZXnZLKlEeprdWit8zgiV/HN/KAyNQD4ktPiSx+hG/iKd7xh4QnH5GceoI7votq0M/li8W8985lUs9nUl9YTtAVJjG+J+bfxT/7lKG1T5jd+YLx5U9IzDzEE12nvsVCytU6iiv76VX70HR1MWbr5taEkTtTFq7PxNhbP2R++1Mmtr9m/uBz5jafYbSPUtfQR1uXBZt/nsTcbfa3r3NrOcGdGS03hjXcn4spRM0fC/7X//V//T+0/9z47+L/yvjv4v9sTIECBQoUKFCgQIECBX9Y/DZRs7N7QK8uwInMPs7kDpDb4OZihZV384wcKzBysdJOfltQtA5OFZk4Vajnao2D3FoH+VKETbG4L7eQWm0nQ6zNbvBwoUDHRTE3rcxGZYuf/AozeVI6VYVJjLtIq7KRJ+ZJ6VQS0ZOSqyG/Usxt9JKSr+Oq2KO42kp9R5jCKrGX8F/ZIubXWEgXvtLLTZQ1ucmtNJFeopOjfkqbXORLKUgNUkUnL2XCV61Yn18nRbc4qe2W9GJ85JVZyC810tQepKZNiuhxCt8+2nujtPWEKRbPUNnqp1M7Rnl7mLRar5w+Va4aprgjQVqdn+zmILWSZoxujNLuIar6RmnQTgqborRnhILuJOUD49QbZinqSlDWHadRM0SDeljMFdY/Sqtpmg7LLC26SXp0I1ico9hdUQLRYdTWOO3aIdSeJWELtJun6XQsoXVNEfFFGPG6CZsH8VtMqAf96CxTGB0zDBpGGdSNo9WMYTcm8dlCcqqQXW+mu8dMS3cAlWYUq2MRnW0WnX1O1p6R9Gg6teOopIgTc5S+freYl5THdPZlBk3iHNYl9C4pHWoWjW1OFhg2iT2lFCiDRdy7ltGIM3aZFhj0bqIJ7qD2b9Pv2RT3O/TY1uhzbjIg3XvWGXQJf5JejCGJ3hilo8tGec0ABfkNFKfnUZ95lebcNPpK00n0VbLmbGfN08VGoJuDeB83hwe4EVOz7e1m3NCCvrGBxvI6yivbqW93yClLeodU+nsHb/yI0MgNAslDPFEpWucIz+htAtN3CU7exS+uPcnrOGN72IKruEKbuENrcolrS2gbz9A1QuP3SMw+ITb9CN/YQ7zjj4iI+7gsNvwMd/wONt+GeHd+Mi7lkXk+jf6uASLhaaKjh3gn7hOZ+4iJ1ZdMSmLBS88ZWfqUma3PGVt7jnfkkE6Vm4wr2dQXZLPsU/Fswc7zVT+PNiY43LnB3OZLJja/ZPHwl6zd/DlzO58yufaUkdkD1MYINbUqDGo9N5fjPF1x8nTRzN1JI0/W4gpR88eC//6//+/57LPPePLkiWxPnz7ll7/8Jf/T//Q/yQTKf/pP/4m//du/lef83d/9ndz/G0jjf//3f89XX33F119/zX/4D/9B/mP+G/zP//P/zF//9V/zySef8F/+l/+lfP8bSPP+/b//93zxxRf8/Oc/5z/+x/+oEDYKFChQoECBAgUKFPwR4Z8QNXsH4kM8LFdGOpnTz6UiNWWtfs7l6njrch9vXlZxIqufmi4/ubV23krt45W0Ht7MGiSjzk1hq4+rNTZSKu1k1Loo7ghT0O4jvSHAh4V23iswcqxQT1qdh/OlVo7l6ThTYiav3k1de5DiKgvVjV5Kq53kCh8XxHhaiYGSOivn03u5mNFLSnYvNS0uqls8FNRYKK63Ud3uoXkwTn6Dg5x6F3ktAc6UO3iv0MSpUgslHUGulhu4LHxlifFyca460Vfb5qNC+GmUUova/VyqcXC+zEpho4+6ziiXSx1cLHOT0xCW05ZqBkbIEf1Foq2WymdrJslqipFWH6KiJ0nt4DiXqtxcrBJn64jTZJimfHCMAtUopX3jtJvnqR0Yp7gtSd3AGI26cZoNU7KmTn5rjOzmGJ3GKepVQ9T2DNEjacIElxmUSAzTJFrLBKbAMt3WKYy+eayOIZkMUA0EUOuTsiBxR88wdvssPjGuM06K/mlslji9DY3kXzxPQVoGJfnlDKgcuF3TBEJrspiwVOp7UDOO3TmBuk+PqqWOqtwscq/kU1KhlUuW95tmiSR28QU3CMV38Mc20RrG6O2LoNeHaO8w0NBsYcA6x4B9FZ13m27jPK26aQbd6+LsO3KFJqN/R9xv0KyZosc4Ta8mKdbpKCis4MKZc7zz6tu88r2f8tYP/pyUt35Ga/oZon2V3Bg28Pm6j6+2/Hy+4ubzjQAvhT2asfJ0Lsj9hRg7cwmGh+YIxrfQOZfFnru4h24QmbhJdOIWnuQNsf8+zvgRvuEjAqPXxdhduay3pCFjD63jDcwQTywIHyt4IjtizU0cw9eIzT1kZOkZwdFbOKP72ML7xGaeMLb6Kf7xu3KJb+/QLSyWGYpz6jjz3kk6GtqJxeaITN3CPXofr7DhhSdMrDwnMfecyOwLJtc/Zvng54yvfUFk/gWh6bto1T70zbVsxgZ4sWDms/UAHx/Ms7N7h7GlJyRXXrJw+AXrN79mavszxje+ZPXG16zc+YKxjZeMT22xNerm+ZqHl5sePt8J8mLNy8uDUfE7rxA1f3BIxIj0R9doNIpfHj1msxmr1crS0pJMnEh/lO/cuUM0GiUYDBKPx7l//75M7kh/tCUSZnl5mXA4LH7ZfczNzcl9EiHzP/6P/yNHR0ckEglCoZA8/ujRI7n/H//xH+V5Y2NjRCIReXxxcVEmc6QxBQoUKFCgQIECBQoU/OHxu0SNyhTmw3wNb15RcT6ji5yCVvJLejiZ2smHVwc5kaEhq9RCWZOLy6VaXhP3r2VoeTdjQI6MKW8Pca7IzPtZOt7P6ONElorCZg+plWZSqu1y9aXUCgf5DV6yapxUdoS5mj/IlUwVl652k12ooaDKwvncQc7karhcbKS2K0JNp5+8ahNlzV45tSmnLcTpUjOpEiHUFeNsjYsTlQ7OCZ95nVFSmwJcqPOR3hykrDtE7cAwl+r8XBZ9Be0x8sT4+QobHxabuNroI7ctwsUaH6fLPWQ0RintiMtltfNbImTWBShrDVHfP0xWo58L4vxS2zQwSk6tl4xqH5m1Pip6YzQbp6nsH5X1cMq7orSbpqgTe5d0J8X4EI2Do7QaZ8jviJLdIhE8w3SYZqkRvmuFvw79JGr7Ij36KRr7k3RokgyYxukeSGC0TqE2DtOmCtM5EENnnaBHN0q3dhStdQaHfwWtaZp+TQKTbQyDfYaOwQn6xRypTHZNtYq6ej1qdYTBwRg9qhh6cT5fcA2ndxm7MLNtiqbaLtLOn+bcsbe5cvocFcV16M0JbL5VPOEdvMENNIZZsdcUbv8YrS3dpF24yOl33uTihydpbuimq89Fn2EEg3sdvW+XXtsyfdZ5+kyTtPcGaGqzUV7RT/qVIq6eT+f9197lnZ/+iGOvfp9zb/05ZZfextaczaKjibsjGj5acPDpqpsv1r18vOzm8aSRu8NqbiYH2Yn2szs1xFhimUDsAJt/T9a1CYzeIDR+RyZjvMOHmCWR4tgRkdHbxCau4xsS83ybGG0S6TWFyTKFw7MgfGzgT+zgSBzhGblJZPIuQ/OPCE7cx5W4gW/kDuHJ+yQnHxAbu4srdohV7Gd1z+G1uPBpOzH3dOC0hAgP7+ESPtyTD4nOP5XLbccWnuIfvUd4/BHjKy+Z3f6UkeXnxOdfMDx1A6fZjq6hhAV3O7uRLq6P6bi9NsXB3h0m156RXHrK8PJTlg6+ZHLjY8Y2XrBw8AUbt37F3P7PWdj5lP3tPe7N+3g8Z+HFuodPNv08W3Hz6cGYQtT8MUD6w7u9vU1LSwujo6My6bK2tsbDhw/57/67/06OktFqtQwPD7O5uSkTKi6XS46A+W//2/9WJnTsdrtMskimVqvZ2NiQxz799FM0Gg3j4+Ps7u7KZE5PTw9/8zd/wz/8wz/I/RJBJO0nETwmk4n19XV5XwUKFChQoECBAgUKFPzh8U+IGqk8tznCuQIDJ9MGycpWUVXSQWlJC5fT2/jgUhfvXejmYloP+cUdFFU2klaq5b2rfbyfLlWJGqSiwUFZvYXU/F4uZnVzPqOH1II+ShqslEuETZGRU5mDfJDez4eZGlLLbHLa05XsPrIkrZpyE0WNLi6L9lypmdzmAOmVdi6V2uUonIwmP9kdIU5XOzlR6eRSrYe8jigFXTGuNkgki4+8tjApjUGOV7g4Jebkd0bIbgvxYZmLY0UOLlZ5yWuPc7khwOkqt5jrl8mV0p5Rzlf7OCXWXRV9ElGSUeXgUolUWSpARUdMrjCVUe0iu85LeYukbzNEr25ETrUqEFbbE5dLcueKObk1bmo6w3J6UIdhnOLOKCWdMZq0Y7Tox2lUS/o049QPTtBpnqVZM0xL/wjtfUO090paOVG5IlOHSqoK5adrMIHaOIZaP0J3f5RedRKjfR69ZZa+wSGZaLB6F+gzjtJvHscaWEaln6BD+JP0aQZFf9dgnD7dKCbnIjbPEmb3MlrHIg7/Em7fPHbHJFZHkvYuPW3tGjq7jGj0ASzuObRW8T1oXMTpXccX3sATWsHtnkLTZ6c0q4iKtMuoSlPw91YQ0Pbgc4ToHIjSLFe8clFZN0hZaQtFOeVcOHGBE2+8zemf/oiy88foyDmHqvgc5vo0Qt0FrLubuTPcz9NJDR/P6vl4wcKzBRePFoLcno2yPjnCctzNRmhQ1l7Zm/AyFp3CF9omOHZEUCJn4kfYg7u4Ivv444dER64THb5JMHmEM7Al3t0cXb0u6mo6UffZcDin8UR3ZTLHP3JL1q6JzDzAP3EHR/ImzuRtAhMPRd9jQlMPcMRvYw3uyRFJtbWDVOXX0lVTSdxrZ2p0k+Gxe+IsYv30UxIrLxhZekFs7jneqceifcLE8nPGlj8iOnn3m4if4Q0mYgGWAr3sh3u5MTTI/pCerdkkyxs3GFt7yfDqS6Z3XrJ89DmjSx+RmHvM1MZHbNz6mrndL5jZ/JLd7VvsT4c4SvRxGO/h+sgA14fFexrRcn8poKQ+/aEhRdNIkS9utxuLxSITJjs7O3z55ZdyCpP0B1kiZ9rb22XS5d/+23/LvXv3ZHJla2tLTmdyOp2MjIzI0TH/1X/1X8nRMR6PRyZ4pEgaae7Lly/5d//u38npUbm5udy6dYu//Mu/pKGhgdXVVXmdtH5oaEieL0XVKClQChQoUKBAgQIFChT84fHbRM3u7gEarZ+LKR2cON/A6XP15GR109JoISu3jyuZwrJ7ySpR09Ssx2wxUtdq5MN0Fa9d6eYnZ5s4dbWF2opG1J19VFQNcDylh7cvd/NhWjf5VWbyKrRcLhrkJ1dUvJI6yGvpGq5USALAHgqa3Fwo0vNB1gAnC3ScLbeS3eKnoidKSqWT1GoXV2ucZNS7uVIX4HiJg9zOIS7Venm3wMibuWJtsYXsjgQZbTHOVHs4LdZJETPlqrgcNXOuwsuFSq8cVZPRGORUmZP3841crfNT2DHMsRInx8Sc8/VByrsSlHcmyGsKk17jI1fs26YepkKK6Kl2klVho73Dy4AqSHaRgavCT36phY7eqEyyVDb7KGv009Adw+CYQOMYpViszW8MCN8xOdqmUT1GUWeS7KYIhS0RuTx2e3ecZjGvpzeCWjuM2TVHj2WSMuFHqnzVrRuj3zBK10Acreg3uRZQGSbp1k+gsk5Q0RmkVMxr7Ithcc+jNc2i0s3Sa5pGbZunWzNNi2oUg32B+NgBvvg2weQ+oeQO0dEdBixTtAyMinYWu38Rs3sKh38Bf+yblCeJGNKYJvEGlwkG5gkGZwn7xpgJh9hJalnxtmNvLaaxMI/US9l8eCKVV189xms/fo13f/Rjzrz6Y7KPv0przkm8rVmsO5u5OzTA0yk9z6Z1PJ/7hpj5aN7Kk1krj2bt3J0XvmdGmZ1YZHx6D3tiF2tklYXpee4vRrk/beHamIPlhB+HNYnRsYg3vkds4jaB5E08oSO8/n0czlXc3kWs9lFUKjPnTpzl5GuvUpubj1XvwRNcZ3juGcMLT3EMXccUOcIev0Fg8q5cFSo49QRb7CYW0a/3zNPaZSYnJYv8s6cYqK8kGh7GMyKlOT3Gkbwr689Mb7wkMv8M9/hTPGOPGFl5wfjGZ0TEPqHpJ4SGb2A1RemsKGbB08Gnm15ernh5vhrm7s4yS5v3iS69ILzykomtj1m99nOmNz9ldO0TpjY+YXX/C2bWXjC59pzV7cfcXJ3gxpCGg0g3u7EudqPdbAW72Ax0Me/qVIiaPzQkMkRKYWpqaqKiogKHw4HNZpOjYD766CP+m//mv8Hv92MwGGSSRvoj/Vd/9VdyCpNEwuzt7cnRNhK5I/3xllKWpMiZwcFBOSKnq6tLnvdf/9f/tTz2P/wP/wNVVVVMTk7y+PFjcnJyeP78uax5I41J5E9HR4dM8ijpTwoUKFCgQIECBQoU/OHx20TN/v6h+IgdoqLBTHqphnPZA6TmG8ivcFDdEuLs1T7eudDBq+e6efVUK2czOylucHEys5930no4kavmcomG2nYrXX12Smq1nMoe5J0MHW+mDfBuhor8ShX9KoPYQ8d7Of28kafnrRwN5yusFLTYKagxyZWa3i0w8Gq2kbezDWTUeyjtishVpi6XO3grU8fr2XpezzPyQZGZop4E+Z1RLta6OVNp52qTj5KeOKnVTi6WWSho9ZNZ7+JcqY1jeWbezNSTWuslq97HhVKrbNnVbuo74rI+TGaNi9QyB1dLrFR3RKhsDZJZaiet2ES5eN6mjhAZkpBygZ7CMiMtrR56++M0tEYorfFSWOWUxY8busLk13jIq5OicYK0GZNUqxPifCFO1wQ5X+uXxYcre5NyxaiKrjgt6nFU+hHU2gQtzR6aGh20dngwuGbpd0wx6JhFZZWib8ZpGByjWz9OXYefkgYnpW1BGgeS6NwrdJtmqO0boqFvmF7DDJ2aUdq1o/TbpggN7xBK7uKWqjIFVnGHN+lUj1HfM0y3YRZHYAOjaxGbbxmHf5FAaBWTZZIBzQhm+yL+4Dpe/wrByBrRmCSTsYxBE8c84MZvsJJ/6RIn33iLt37wY974/o95989/xpm33qT4/PvoqtOYNFZzGO/mwZREypj5bMnBZ6sevtjw89m6l0/XfbxcC3F/Icze3DBz07OMT28TnzzEEt7CFj8iPnOf6MxtRmevMTm+wub4OAcJO3thNZ6+Lga6dJiso+gdy1h84nns85gt4wTdEwTcY4Siq5jdi+g0IbwaFUOaSqaMzUz7nXg9kww617DE9vGP3iQ5+4jwzCMMQ9fRh3axepfo7LSSm3KV9DOn0DRWM2nrZsndzYTPjje0gmv4BkNSFM3qRwSm7uOZeIhv4jGTay8ZX/2YwMxzHOOPsEe30akdNOSkM2Ro49aEXS4t/mjOx421aebX7xKef0p48WPh6znr175gevMTRlc+ZnLjU9av/5yNvc+Z3ficpY1H3N3b4uOdJB+L9/l0UfiZt3B7XMvtCQProX62RhziW/z/pyv7+4BC1PxfhETUSGlGEvEiRbPcvHlTjnaRUpD6+vpkkV+JiJHIGinCRpr/r//1v5ajZqQ+KU1KInWkNZLujPRH/O7du6hUKm7cuEFtbS1TU1NyNI00JkXvSClWkt6NNC4RNVKUjUTKSGTN4eHh/xa989uCxQoUKFCgQIECBQoUKPjD4J8QNQeH+MPjVLY6ee9KB69f6OL18128ca6NywVacutcnC3Q8e7VAd7P0nKq0EBmnZ28Fi+XK628mzXAuzlq3sjs573MXtKrLVwsM/Nmah9vpQ/ydq6eKxVamts15OTVcrm4h+NFg3xQMMjpIjXpNTZK60y09Tq4WmbkRJ7Yo8jC6ULxUVzvoLLdS06lnqpuv6xF80axjTcKrJwod5HbEeNKnUcW8s1oCHC2xCp82jiea+Z8sZXijog4Z5DzpZI/E5fLbZS1RagQdqXQTGqBiVwx1tARpqDKRmaRifQcPeU1DupbfWQVGEgvMMqVoiTB48aOKFUtAbIrbaSXW6gQc5p6kuTVeEivcJNR4aKqI07L4DgFYt/UGi8ZzWFKVMOU9A+T0x0hvS1IbmecJt0kLdpJStuiFAqr6Q7RownR0eNiUBLr1Y3SJUwqDa4yj1Pfl6SoNUpJR4JWjegzDtGlDtPQE6CkNUBdT5w+w4Sc9tRvmsLomsMbWRftilg/h9Y5i8ExSVu/2Ls3idoyg82/gtE5h9o0icE6jc0t5ljG5TQrs20Gf2gNX2AJl28Wh0/4C81j9YyiNYQxaNz0tmkoy68h9WI6r73yFq//6FVOv/YaxeeOo6vMYmigmt1gD48ndXy8aOazNRdfbvr4civAVzsRvtpN8uXBJJ/szfBwY5bthSXGRxdIjG/jHdnDEN7DPXqL+OwDkrP3SE7fYmjmJuGRQ1yBbcaSG6yOjhIzdlKdnsqF909z8Wwe9Q029LoETvsIbue4+NZdJRDZJJC4LuwmkeEDZifWWB8d4vq4jQV3L/2NjVTUDjBgHccZP8Aau47Ov4favUKP2k9deR1Fly7TWVqMU2NiJDLB7NAEu6Mhbow7WUl4ifhGsQTWsSaPcI3eJD73kNn1TxmWSnlPSpWi7uGKrdDfM4ihrVKOdNmLqtkNadgJDbAetTAVEueWtIOSt4guPWPx8HMmVl8wtPQRo2vPWbn2JSuHXzK38SkLO5/JpbgfrY3w0VqIp8teYW4eL7i4Oa7jcExPf3UuLSXF/6QA0O8DClHzfwMSISLpzUgEjETaSH+EJcHfy5cvc/36dVlzRiJypOpM/0dEjUTw/IaokVKjfkPU1NTU/O+ImtbWVnm9NJ6dnf2/ETXSmCQ8LBE1UqqUQtQoUKBAgQIFChQoUPCHx28TNbt7B+jMASqb7VR3BDifq+ZktoYP0yVTkyqRGx1h3k7v50eXVPwwZYAfpap4P3eQ3LYA5yqsHCvQc6zQxOlSK5fEfXF7hOw6D5lVNk7k63mv0CjWq3jnUjsZZWZy63wcS1Xz/lWN8KPnQpGJvIp+MvMbyCnuoLS2n6ZuMz2DHlQaPy09Dtr6vdR0B0gT61OKrZzP03Ipt5/yZjfFzS4ul2mpV/koarLzYYGFN3JM8plyWnxkNfk4K5EwVS6K671kFRo4fUXF2dR+0rIGqW3w0CTmVJSbKSoVz1vloKbeTUtnjJxyO5fy9KQWmSlticgaMym1Hi7V+LhQ6aSgPUR5b4IrwvfFchcZNSFqVGO0WWao1UyQ3RLjipifWuukWp2krEeqNhWjbmCULvM0KusUJs8SDT3D5DeE5DPWdIXoMozT2D9Efd8wDf0jdBln6DHNUtUVoaDBL5cfb+/10d7nod88iiu8gd27ism5TK9min4xX2WapqYzSl1XHJVuhFBsAYdzDKOkeaMZQacfwmIbwWIdYlAbw2wbwx9aIJpYxe6cEt+FSUxijs8l+i0JEq4ww24rzt4G1FVFtGSlUZN6gbJLZykW1lOayYimnoNAF7djXTwY6eP5rInPlj18tRHi5xtBfrEd4fOtKJ/sjvFkZ4G9lTViQyu44lv4R4/QBXfQ+raITd5iauUJw3MP8I1cIzx5h8jYbbyxLYZnbzC7+oCp+TuEIusY9BFyMwo5+db7nH7nFHXVKhyOCfyRTQyeDRyRI6KjdxkVPmaXHzC59kD4uyV87TE6vMhASxen3zjOB2+f5P33LpNepKJDO0pHl4fstBJOvX6MspQUQiYNUyPLJIYOiI3dI5S4weLsAbe3lhh29tJQWEhmRg2NXW48yV1ZADg2+wy/mOsbu4XLM4Gxp40RawvXR3U8mtbzdM7I3RkPh4uzrE5O4DNqyUjJI7OgE3Nwjbh4/vjiJySXX8ikzfzeC0aWn8mpVKtbtzlcGOZoxMThsIG9hIaNUC9r/l7mnO3ETC1cOH6GlMulClHzh4ZEvEjpTRK5IrXSH2HJJL2YU6dOcXBwgNfrlXVjfkO2SGMSSROLxdjf35crRUnpTr+pAiWlQ/126pMkQvxv/s2/kcck8qWyslJOfZJKgEtEzccffyz/Q5CIHin1qa2tTUl9UqBAgQIFChQoUKDgjwTSf8f/hqjZ2d2nx+jjRH4vJZ1BTudp+PG5dr51po0/u9glkzJnKqwUdYc5K9qTZQ7eyzFyssDA+WK9TOLkNbq5UG7jjQw1r10d4I20QWEDXK2wcD5vkNfTenk7a5B3cwY5X2KiuidOaUuIi+L6XKmG47lqzgorqDJRWt1PS4eVhjYPx/O1vJE9yE8z+nkjS4zXWamot3A1u43i6l7xbaLGrjMyGgwQcTuJ+IOo1B6ulOi4LGndVNsorNBR12ynq8dLbkEvefkq8SGvE98wBiprHZSU2SguttLc5KdePMcVsVdK5gCZhTrqOyJUqUa5UhfkQm2QS6It6RsmpdHHh8Vmzpc7SG/wUasZp9O+SGF3kvSWOFdqA6TXemlSD1PeGaGoLUrtwBDd9im03hnU9nFKpfLhNV5SKzwUNYVp105R05mkvnuMlsFJmtUTDNiWqeqMk1MfpqA+QHv/CGbPGnrPElb/At7wAmpjnI6+KO2qBAPGKRp7k9R1DdHSP4rGtYQrtovWMkNf/xBdnT66OuyoB9xYTTHs1jE8njkC4SXC0UUMxgQ9vR7U6gBW4zB97Q60vXqsg91E9C2MmpuJD5YT7MhjwVrH9UQP9ye13BvXcWfMwKNpm1yZ6aNpAy+mjbyYtfB83spTYQ9nrDyYtHF32sf1xUlmxucJxJYJjBxgjuwz6N3CLc46vviQicXHBIav44ztEZq4hXf4Gt7kIVOLd1jcfER88jq24BbBkT3iyR0C7llc9hA93Uas9hGsvjk0zlVZZyY0cZvY+A2x9jFTK49JzNwQe+6RnL7L+MJDxhbuYA0ui38jRk6fPMcPvv1DvvudV/nw2CXef+1DTr/+Pj21tYxEh4nE14mO3sEzdBt38iaL65+wsvMxyakbmGwTpGeWc+LYOT549zypmXW0aofR+vfwxfcwaFx0Feez7Oni+ZKdlysePtsI82xjiDt7RyytfUxk7A6OwDRl1Z1cOHOVzKvl1Lc5Mfo2GFl4xOzWJ8RmHzGy+DEzqw+5vTXLnWkLd8Q7vyne/0FCzXZQxbqvmylrJy1Fubz66nGKqnoVouYPDYmo+du//VtZF0YqwS2RLRJBIqUgpaen8+LFC7kKkyT6+xd/8Rcy0SJp1+h0OrlSlJSiJJXylkpsS1WeJJ0ZKVpGEieWonSSyaScOvWrX/1KXvtf/Bf/BWlpafJektZNdXW1XCFKiuSRiCBJlFjyLUXtSGdToECBAgUKFChQoEDBHxa/TdRs7+7TqffxTnY3JwsHKWgPcq7EzAd5eo4XWvgw18jxbC0ZUrpTs5sTOQO8mz7I66kD/ORiD29c7iGt3Ep6tYNXU3p55VI/b6XreCdDzblCPbXdEXIkIeBSC+fzTZwR/k5naMgptZEpxqsbfKRl6zmZouL4FRUnL/VwJWuQypYA6U0BjkvCvyUuzlR5OVvtpLjVg2ZQz2jQxlTCSzzgRae20thhJKtGw4VScdYaJ9mlOjKyu8jL6aS6rAt1jw69ahBNWzt21QDdTVoKxPNm5enIzBPXFRYaeiNyBaeiZr/w4SK9zk1qnZMz1XZOVDk5L86a1RmmQj9BtX6GvNYoF6vcnCm3kd7gpqI/QUFbiOKOOFW9SZoGhtF7F+k2jlDe6iVH+MgTVid81PUNUdIVk8WEy1vjVKuGaTFMUSfaguYohc1iTncCnWuZPvs01sAizsAyBucCPcYZ2gdG0VsW6O4bpa5VzO2M0Sv6zUEpimRV7DlFvSpOq3oErXmawcEhesV9nzaJ3j6K3TmMzzuGRhOiqyfE4EAI3WCIljo1pfm15KTncu7D05x68y0uvfsq+afepCXzONbaVCY0ldxK9PH5qoOvt3xylMxfHiT41UGcX+wn5ZSmr7bjYizOx2sR7i9H2ZqKip/XMCPRSUZH5vDHZtF61jEEdohO3WJs4TbDM3fwRKVy2nt4hq5jiR1iix8Sn73P+MIjYkM38IS3CST3cYfXsHkmCIUmCPsniUZXsfrX0bg3xZoDvGJ9eOyGWHeXqeXHRMZvYYnu4h+7ztic6Jt/wOi0VC77njjDIQPmOfGN3Mc7b77HD7/9A9768c8ounoVp9HCSHKF+MiR8Cn2jx0xNPeQ6c0XTK48IzbzkNDUM9zJ+9iCqzS1Gfjw2BV+8L03eOu9S5RXq+lsHqCvPJd1Tw9PZsy8XLHx2VqAT7ZneHh4jaWNB0TnHhCae0ps/hETy/fQ60LkZ1Vy5lQaaRk14uccxBHcIjDxhJHZJxztHPByK8xnG24+2fDzfMUrCzDfm7Rye9zIhLWby+9+yMULReK9HvzegyYUoub/IiQyRCJJpHLbkp5MPB6XxX8LCwvlSBiJPPnlL39Jb28vAwMD8nh/f7+sYSORL3//938vpz9JkTNSepRU7UkidSTyRUqVksgaKUJGEiOWyBwp7Uny9Xd/93fyvjMzM/K+vyF3pHFJmFgijBQoUKBAgQIFChQoUPCHxz+JqNk7QG0Jc6lYw4nMXq5WGCluC/B2poYfXejhB+e6+cHZHn5yvofz+Xpya1x8kKnlHWFvpKt5N9fAyQIj2fVeCpoDnC8ycTJPz7vZWt7LMXC8wMx7mTpSS23klOg5camTY5d6eP9iL2fT+2WCpLkzSmGVg6sSmZOr4aywC4V6Sjv8ZAmfp8tdpDaH+bDcydvFDo6JMx4r13FGWEVvmJQKq9hLy4liq6xTk1Zuob7ZgXnQilslvl2aa+ivLqW5KJ+yvELycipIy2khr85BfmuUC+UOTheZhRnJbLBS1eOjsMFAeZOOxvYBajp0pNSbxb523i/zcaLCS1ZHhDr1EIUtHrIanGQ1eSls81PTlyRXIp/E3LQyOzm1bhoHhmk3jFPZFaC8IyyTMMUtAep6k5S1hMmqdJMj1tQNxDB6p3GJD36rdwW1dZZOzTj1vcM09sTp1orvr8FhasX7au8fRW2Ywepaxebfok1cV/SNUix8thsm0dgX6DVLlaMW6Xcsy9E1Ru8yLQMjcsnx2g4PGo2DzvoOqktaSLuSw+kPz/P+a8d47Xs/5Wff/j7HfvQDco6/jaokjRF1FXuhHp5M6PhiycrPN/2y3synK04+X/Hyi90ovzhI8sujSb4+mOH57iL7S0uMD88RSSwQSqyhtczK+jnOwBwLSzvMzu0yNL6PNbCL0X+AO3EokzSSRSZuE5+9J0fEmILbmANb4tt1n2HhJx6eJuIfYTgYwx+cRuteQ+/dxh0/wD9yRHTyJkMzd0lIgr7xG1iCe3iT1xibf8zk4gMSYweEh67jid0QfrexehZobzNx7uRl3vrJG2Scuoi5X4vXN0YgsS3mXcMZ2ic6dsTi1lNm1p8SnrhHcPwRwckHRKelaJePGVp4hCm0S4c6RnpWJa/88DWO/ex1OkvS2Qh282TGyCdLdj5dd/HRxjAPD6+zsvGIodkHYu0zxlY+Ymn/M2Y2PiYy/gCzcwFVr53z5zN4683TnD1fRJPKz/TkMs92x/h608VX2yE+2w7zbNnJw1mLMBt3pm1Y2qs48fqH9PUFWNh8zj/+4//y69/+3w8Uoub/BqQ/vFJ0y5L4xZCIFimtaWVlRY5qkZg0KUpGiqyRxIYlMmV8fFwuyy31S2ulik5SulMgEJDTpKT0pd+s/U//6T/JKU4S6SOV8ZZIoM8++0zul9ZKZbml8twSyRMMBuVUqt9Ul1KgQIECBQoUKFCgQMEfHv+EqNk9oFvr57WLbfzoZCOvnhMf7eU2smvdvJPSw/EsDWfyTZzO0nLuqoq8UhN17WGOZ/bxhrh/PVPD2zk63s4Y5GT2IHn1Tk4UGvjexU6+c76d71/o4mepfZzJHaS9K0Blk5fUEovsUyJ0jmX0cS5fQ0Gjj1M5Grkq05UaPx+Weniv2MLbhWZ+mqnmUq2HC3VBfpap4818I++VmDlf6aaoNUS7ZoiiWhvnMgc5caWLk5dauZzWRkO9muL8StIzq8W5u6lpd3CxxMhbuUZeydDwWqaBY4U+Cttj1LaZUXUP0NvaTkt1NYWpV0j58H2Ov/oKr/35zzidWkFOk5PqgQT5LT5Zg6e4wU+tKsGlUiMfZvVxqVDsV62mvsVKebOfiq4kea0BshulSKAATQNjZFY5SSmzklvnprIjjNa5iMm9iEGq7GQYp3lgRCZlWlVDDFrmqO2IUC3O16waps84hSeyidmzQGt/nOq2MGWNIVnQWOtcokU7Rot5BrV7GZ1rCVt4Ry65XdIapqDZR4sqiEoToqK6n8z0MtIvpvLha6/y/s9e4/2fvMYHP/kpp157hUtv/5TaKycIdJWxG1bxcFIra818vuziqw0/v9gOy/bZspMXc1YxZufleoyn6xNcX1pkIjkrvjXXcEc36bGv0GtbxeLbJDl5jdDYHp7oFlb3Kv7gKkPJNRzuWUwecT90yOTCfWEPsEf26XOtY/JvEIxv4fXNk4yMMzM8Ldo57GJ9ILTC8Kj49gxs4PIL/zM3vlk/+wBH+Aij7wh3QhL1vcfY4n0S4zcID18nmDjC7BLn868T8E3QUFZPyvFTpB4/w2BzB1HfEOHYLtbwLgOePSyhQ8bmH7K2/YL45H0ik7eJTN3BIft+wvK1zwnPiD2HbuIavy+//y6VlYsfnEBVnslWuJcHk2qezRp5Nu/gyfoQ9w6uMzJ1g+jsU0aXXgifd1g/+pLFnU+JzjyV+5PiOaYW72FwjpKVW8vbrx0n5fxl5kNGXqxZ+XLdKUfmPFtycXdS/41NGJl195Fy4gQnjqXjCKyysP85//h7/h5XiJr/m5Aia/7hH/6Bv/zLv5RJG+kP8W/IEmlMSluSCBlpXCJSpPvfpCb9Jirnb/7mb2T9mv/4H//jP1kr5bdJa6XIHGmtdP+btdI8ab60p5SC9dv7KlCgQIECBQoUKFCg4A+P3yVqVIawLCD8bmo/JzLVXC40UNXspURK+0nv5fjVXt5L6ebdy518kNpDdo0UAeLhzdRufnSunR+cbuHPTzfz2tlmTmf1UdERIqXMxNk84avYwIU8LeczVaQXDFDWGuBMgY4zpVbeKzDyWq6Rd4rtvC3s9XwLV1sipDUFeS1bz4+vavhJppb3pYpNZVZqWoM0dwfJkEiaPA1ns/s5J86XljdAZYubi0V6LoizFzR4xRldnMw382aWlZ+mmflJuoEM4Tu3NcqZKh9nakNcqA+R1hymoM1PU7OOvIupvPeTn/GT7/6QP//eK/z0x2/w9usfcPzDFM5fqRbvxElZh5e0Khvni4ykFGqpqh2gvU1NQX41xdlFFFy6Kj7Qz3A1s1K8xwExz8KlYpssylytitNlnqJVPUpNV5xCcc6cGgstfX70hgS1DU7y6yIUtcao7kqgdSziCW9h9y3J1Zxaeodo6YzTb5igzzRBfVeI5t4Y/ZphHI5pvMFlBsxj1HRGKJc0d9o8DGqDtLToqCxroSSnmFPvvsdPv/cd3vjOn/Hmd7/N69/+Fsd/8kOuvvMa1ZeO4WkvYM3Xyd1xHS+X7XyxauerFQtfrbr4cs3Hxys+PlkL8dVmlBcrIe4vJzlanGF9ZonJ0VVMdvF8mik69LNYg9uy1ow3fogvfoQntoM3sY01sEa/eRm1dQ1/dI1wZJpkchFvbAOjb13WZJGEfg3uebSmJA77EDb7KE7fCv74Np7EHnr/JlrPCvGhTVZn91hbPCI5sovFtYYrcEB49C7h8Zsk5+6QmL9PZOImjvC28LmBJ7hB2DvMfCTApn+QJVcXU24jk6EE08NzOLzLDLo2sEeuExy9x9DMHaaWHzE694TQyANckVuERP/M5hMm15/iG7+Pb/I+nrFb2CJb9Ax4KEzPxFCbx2FczYMJLY8mNTyZs/FobZijzUMmFx8Tnf9YXpucfcj2ta9Z3fuUofnHxOZfyClQc7svmd16SWDiDpbgGl0dWvx99dxIDvB0VsOLJQcfzdt5PGvi4YyJu1MGbk8Y6SjO5PVXPqS82oB3+AZTu18oRM0fGyQC5Tckyu/i/6j/N/g/Wyvh/4lvBQoUKFCgQIECBQoU/GHwu0RNvzHMmRwN716RCJleTqarSMnuo7DOxXuZGr53tovvnukQbQffP9fBT1N6SK+yUtzk4ky2ipNZ/RxP7eP45V5OpfaQktNHXYuX/DITV6QqUumDfJht4K0cA2/nm3i7wMyV5jCnqt18P1PHd7MMvCL1l9n5sNxCbleUir4Rzot5JzOl9SpOp3Zz4WofZfVu8ut9nC8xUNDiIrXKwbE8K28VWHklx8grmVpOl9nI74hxqcrFuXInFyu8pNb5uVrvoaRDqtw0xsVyu5y29U6eSdaYKWhyUN2o4dTZLM5eLORKWi3FJf2U1xlJzevnQo6W83kGMoqsVDYF6VUHKCks5NwH7/PGT37Gd77zQ/7Vv/ozvvsn3+HH3/o27/zsZ5TklaMxxGgZTFDbP0J2a4is5iA1fcOUNHtILxnkUk4rF9PLSE0t4OLFAlp7fXQMDtPQM0JtZ4I68S76DVP0aqdoFetUhknUlinMniVs3mV0hiE62v20t0pCwW4MYr8+lZvWhgFKc0tJP3+Wi++/yYmf/pC3vvctfvAv/hk/+pN/wfviOu3tP6cp7X0CnXksOhu5nuznybSej+dNfLnu5ss1Dy8XHDwdNfA42cfjUQ13J61cnwiwMzHK+twiQyNLmPxSetUaOu82rsgu7qAUTbOFO7GHO7yDN7aDNbiFyryA2r6If+iAkbnbJCaOsIc20DmX0Jin6dMnGLBMoLWO47AmcVgi2G1DOD1zchSONrBPl2sbc/SQydl7TC/cITJygNW7iUv48YaWsbmmCCTWGZ65wdD0LRJT97CFDtG6NrH7NzAakjRXtdJRmo2pIYs5dw/7y2OMT2xg9W/hje4RH94nGN0kNn6N6dVnTCw/ID59G0/8Fr74HTmFan7rI6LT9/CM3MM78RDP8HWGRzcIOZ10lOUS7q/henyAB2ODcnnyxxMG7i0l2VjZYnj+EaHpJ7jGHsoRORv7nzO3/hGJuUcML70Q7UfMbUvlt78kOfcC79RTgjN3WJyb46b4WdwZ7ufBlPA5Z5NJmvvytZlbEzrGLe2cev0d3n4nHVtgg8DEA6aEH4WoUaBAgQIFChQoUKBAgYI/YvwuUdOrDfHWhV5+8H6zbH/+QQupeQYu5qi5WKjjkmT5Bs5kqjkupUOldnHqSgu5JX1UN9s4fbWL0+mDnJeqQeXqeCdzgA9z1VwqNlAgRcekq/luqpo/E/bjLANvFFk5Ve2hYnCCvK4kx8X9u8VWfiD2+FaWmh8KO1fpoKIlxJU8LZnlNlJLrXJ0ylkx71i+np+JPc6UmSlTDfN2gZ6fSmXAS6ycE36lKJn0lggNhnlyhQ9JQ+fdXA3vCl8nCnQUNnlp1U1Q3hunXj1CgzpJr3GE0mo95zK6+CC1gw+vdnM+a5CaJg8t3VFKm3xUdcUpbpLSiMJyRauUnBbeePUEr37/FV7/zrc5/pMfkXPmHTrK0zCp6sVHuwmrI0qtVJK7NUyZWJ9bZ+VqfisXLxfx1ltn+O53X+Vb3/o+3/lX3+MHf/Ztzp84TXWdmspmL+XSM/QOMWCawxnYloV0u3UjVHeK87SFqWwPMqCLoeqx0trYR215PblXM7h4/EMuHnuPc2++zgff/w5Zx16j4epxik69SsXFd2jPOUOgNY8FSz1HkS4eTah5MW/lizWPTM58ue7h610/X257+XzTyyfLfh4vhLi1kGQiMYzJMkqHaoRe3ZRcfcnoX2NQqrIU2Sc4fEhsbE+0uwxa5sW/rTn5/BKRkpy8QWLqBv7hfWyRTVzJHWyhHfrMi/QbZtDowzR1aNCawngDy4Rj65htsxjNC9hcayRHr5GcufsNQZK8hj28g2/oOmb/DnrXOv7IDvGklNI0iTu8gsm3ic65gcMn/FjHqK7q4tKZFE68+jbZpz7A1NtCMjGFP7FNePy2OMstdJ59fOI9b6zdY3X1NqHRXVnfxj9ym+TsPaZWHzO5/ETWzgnMPMQSvY4lcMDE5Aq7MyHuzDm5Nqzj1vAA98cGeDKj5dmsjSfLo+yv7pIYv4YzeQv3xGOSS89Z3n3JzNJDhuceE5v9SPh9wOL2xxzc+RUj80+IzDwjvvIp08tHHM6GuZ7o51qil+tDKm6ODHzTDvcJG2Qt3EttdhqvfPddsnLb5WeKzT1naf/nClGjQIECBQoUKFCgQIECBX/M+KdEzT6dgx7eudzJ25e7eedKD8fS+jmbZySj3Eh3px1dr5Nz55o4drKJD8628eGFLj5M6eZcdh9NvVHqexO8lznA9y718C/Od/HPznfwpxfaeSVFRW5DmILeYY7XujhR7eVElYe3iy38LFfHq3lqsjsCnCwz8UrGAK/laHi1yMibxSZOllu5WO3hZJGZHImwqXLyk/RBfpQ2yI9TB3gjU8fxYhtFHRE6LNMU9CQ4J+YcLzTzZraW1zK1nBBrq/uTZNQ6ya73UN4VptM0RrtxjFJx5ssNIY5JVaWKTGQ3+Shr8ZNaoCW91EROjZPCBh/V7VE6tSN06MdIr5TSqexiDydniu1k1zhobE/zqmsAAP/0SURBVOqnubgAe1sVYcMAYbuVqDeAxRSgut5CZpmZKyVG0kpMlDc6qKrp59jbJ/n2n36PP/1n3+Jb/+Jb/PBb3+GN732LC29+m6qUt/AP1DMWiWKyj9GhHadRPFttW5hW0arEWcrFWYtqHeSVqigpruXq5csce/M1fvrd78jRMj/802/x6re/w+kff4fid1/BUHiGBWM516OdPBob5Mn4AJ/M6/hs0cJnSy6+XA3w+XqALzaCfCHaLzfE/YaXT7Yi3FpKsjgxTTi6hC2whCG0Tq12mpKucepUEwxaFkiOXWNy9jbe8CYq4xQduim0jmV80R1s3iVcgQ1C8QNCiS38Q1tofSuonBv0iLUWjzBrDO2AGYvZi9k1wYBY2+PYwh65RmzokFBwlWhil6nZO0zO3RE+rqFy7dBp3ULn32J47hbT8/dIjN3G7BZ91hW01kk01jHU+iQNdX2knrnC+5IGz1uvU5GXi9cRJjm6gz12iMZ9DZ1b7DNyl9HZ+yyuPiGR3CMc3yEY38QRWMefPGR86RFTG0+ITj/AGruFQZzPKZ5Rr/PQWZLDrKWO50tGni8aeDan48mckaeLTp6sTbCxuE9s5BqJ6XuERq8THLnD3PrHbBx8ytjcE7xDdwmM3Gd27WP2rn/J9PJjJlc/Ijn/mJGF2xyuLnB30sCdETU3hvo5jHezH+tiN9TGXqCV3XAP3t4a3vjRq7zx6gX0ljE5Qic49ZjZbUWjRoECBQoUKFCgQIECBQr+qPG7ETV9+jCnsnS8c2WA18/38sbFPl670s+HeWoMlhjtXXbeSZUqP3XxozNdfOd4K396vIUfX+wmrdJOcauPwo4A7xXqeS3fyFtFZl7L1fGzbC1v5ei4XO8kuyvEG9mD/ChF+MkY5KcZal7PUvN+gZETUnpSjYfizjiv5uj5s6sa/ixNw3fT1LwqziWlMpX3JqnoTZBW5+F4iYVjhSbeFnPfTB/kQrGFqs4kV2u9pNX7KOqMUdETp6YnSl13hJJGNznlFlJzBykTZylu9/NBqZn3y12cqw2Q0ugjv9lLc1+MDv0QpU0eUoT/c3lmTok9LornqusO02ealIV7O9QTtA+O0D4Qx2wbpV/loaHeQFG5kTTxPJKGTpM0Xz9Kc0+E+p4YTf0jMqFV0eImt1jFqZNpnHv3Lcovv4OmKoX4QCnr3hbujQ7w0byVm/MJHJYgKvUQvQND9KgSqFRh2lsMpKeUcPzdC7z2w9f56be/z4/+9M/46Z99m/d/+D0uv/4KVRePY6rOZs7UxFGoi8djaj5dMPPFsk2Ylc9W7Hy9G+SX+3F+sTfEL3aSfL0Z5vNVH58sOMV8HY9HNDyeDzOTGBHPPU2jYU7YDIPuZVyxPRzRLWzBdfTOFfrFmNayhNkt7h1LqG1zWH2rBBK7hIf2CcR3Rd8Cbbopeo0T2HyzGKxxNFovOn0AoyGKyTKOxb+MI7GJIbRJv2MTa3CX+MR1JuduMjRxiMm/TZ9N7OGRSnRfIzp+h9jEHYLD13BH9nBFDzH79xgwzjGgCVFT2cz5E+d45yc/4/ibr1KZn41DZyIWnpX1f/qcG1hDB/iGbxIZeyCLGE/P3GJk/DrBoSPxfDu4ApuMTO4TH93CH9vGJOZbojdwJW9i9S9RV99DzrlTOOpSuZno58t1H5+tOfh008un4t0+3l9jdVkq6f2AwNhtXIl9EtM32dh4xMLifYIjtwlKKVCzUorVM1a3P2Z68SlTS88ZnX/IxNwtrm2u82jJx5M5HU9nzTwR9lDSpRH2YNrAvQkd27E+atIv8qNv/5T8vCZc/hXcwzcIzjxlfv8rhahRoECBAgUKFChQoECBgj9m/C5Ro7HEuFhk4q3UAV5LGeSVSwN8/9wAP7zQR3qFkcJmD9853Sqsk1cuqHg9pZ93c4y8m2/lRL6JynYvgcgYNV0Wfna1h29f6ePbF7v4YWo/P87U8H6xmbK+JC36YdJqrLyVo+f7KdKcXv7kooo/udTLK2JdjkSi9EQ5W23hbJ2Dk8UWjhdbeb/Qynt5FrLq3OQ0eXg9vYe3sgc4W6Qno85LRe8QHYYp6vqHKWgJkS8J6Yr9UotNnL6q5kSqig9SOjmToSJD9DWrx2g3zZDfHuZyfYCT5U6xj9ivyE5GvY8aVYLcOju59W5qu8O09ycx2WexOKbo7I9S2eIlp8JBVqmdikYvnZoRCmrEfYmFwmqxviNOS/8Qndph9M45GrsjFDYEyKz1klrhJL3UQkOTlphFw3agi9vJXh5M6MUHt52bYz42RuJMJ4bQDjjp6vDSKqVf1TvoarPR1dzH+WOnefN7P+Kd736P0z95hcJTb9FffIFITyEL1hpuRrt4OjHIyzkjny/aZCHgrzY8/GIrzK/2Evxqf4i/vDYubIxf7Mb5csXHF0tu0Xp5MWfh4Ug/j8ZUPJoxc20mwlhsDINrHlNkG3N4B6NnBYNzDVdkH7VlgY7BGbo1M1i8awxN32Bk5gird4F+8Y579TPo7PPY/Iv0aqN0dNrpbtdi0Dix2Mfwx9cxupdQCT899mW03lUiY0dML94lNi6RMxvoXVs4A4eEhq9h8W/ijR4wOnWPxOh1oqM3cAT3GbBtyNE9Ts806h4T2RfT+fC1t3jnz38ork9iGFDhsMcx2GbF+i28Q9fQe/eFvwOm5u+zvnWfufmbBGM7+CJ7hMX42Mwt5tfuMzx+UyZsLOKZDML0rhX0tgnKS8spyThLRFPNgyktn61a+HJTvMedIJ/sDPHkcIutjduERm7gHLpLZPoBYwv3Wdp4zvjCPYIjB7ije3hiBwRHb7O6+xmLa88Ymnogxu4xOvuQg41rPF6N8vGylRfLFj5bd/Op+Hk+X3LwdN7G82Unj2ctbIZ6sDQW01VTg98/jVf4dA4d4hbvZ3rjY6U8twIFChQoUKBAgQIFChT8MeOfEDV7B3TpQ/zkUg9/+kELf3KshX9xrI1vnejkh2d7OZY1SN1AnKruGKmVbj7It/KzVDXfv6Tin53t4f9zqpMPc/twewI0tvVxudrCa3l63i+1fyPwm6HjBymDvJ9noHUwSruwDzIH+cHlPl65OsgbeRbeKbBxrtJFarWVyo4AVV1J3kk38IMLar59TsX3LqjkCB+p0lK7cVycJ0qbbhiLb56G3iBXKqy8nW3klStqsaafP7/UzwWxf51qhJwqOzmVdrkSVI6wy2U2zhaYKGmOUNExxKlCmzi/kXMlNjLrA6IvjMY2TjCxikobp3NASjvy0yulIHXFZa2ek1k6TmbruVRoIrfcSmd/Eqd/FZ15hgbxngqaA2IfB2eLHOQ2+OnUjVPdEaWiNSTOm6RbO0nvQBi3wc7BWISDpJN5vxOnxkpfh42eLid2+zAGXYS2ZhtdLR40fSEshigBzwjqDjX1OWnYmjNYtDVyL9HPZwtGvlg08pX4mP/5ip0vlqx8umjlqzUPv9iJ8sv9BL86TPKXR8P81eEQv9qL8cV2hKdLHj5dCfLzdT9fr7n5aMbIsxkDH80b+GzDxeebfj5a9rI3O4E/sECLZor6/ikaNPP0WmbxSelMsT0iUlWnyA4axyIm7yq20Bbdhgk61XEGBnyou9UUpKZSV16PVhdFbV+h07pOn3sTz9AR3ugujuAG0dEjhiavER3eJTxyXfjaRmVeoc+2gjexy/rWI2bm72DwbtJlWUft3sWfvIndu0Rfv4fCnApOv/kOF978GSWXT6Fuqmc0MsbI+A461woq64bwt4YtuM3E4j1Wt54xO3uNRGyJ0dEtxqcOiQztMzR+i8WVJ7JocUCcz+DbFs+2js05SWeHjqsXrlB06UPmPB08X3Px8YqNL9bs/ELS9dmN8XBvlcnpI/E8txmee4Jv+AG+oRssbDxl++AzQpP3MMdvYI4c4I9uMTklpY/dIzR8m/jUI6LT4lzz1/lob5YvtwPCfOJn4eaLTQ9fbvr4dNXNM6k0+pJE1Bi4NarmzoSVw+kkc0s38Y89xDt+j+DEEXPrjxSiRoECBQoUKFCgQIECBQr+mPHbRM3e/iHO8BQZjR7eSu/nnUwdb6ZreCWln5+k9vOjyz388EIHefVOLpaY+P65br59cZDvXx7kzy/38/pVDW9n6kkrs9AymOR0sYE/u9DLn5zr55+f6+NfXlDxwzQxJ9dAdrVUlSiKXm8nv0LD8Ww1r6YM8uNzvfzwfC8/uNjPu1Jlp1Y/DX1JrpTbyG30U9YWoajeR16Nk/RyI2dzBvggrYe0Yh1VnSHOlZh5J8/ImRIb58rspNQFSK3xktPopm4gRma1gw/Fc71zVccHGXrOF5goqHPSoR5Ca5uhoz9BS0+Utt4YGuMITW0BisVZrxSZOJut52yWhtRCLY09Ybo0I1S1+YUFqGzxUdUcoKLBS5V4fx29SUqbQqSWO8mudYtzB2jqiaAxDOP2zWC1TtDbLXx0BGjvDNLZ6cNqjOGzx+nrdNHS6KC1xUVftxejNkLIN00sNIffMYxdH0Xb40Pd5WegzUbQ5ODGZJAX0xa+XDDz5bKFr1aswpx8veblF9th/vpomL+7NSlsmr++PsIvj6J8uRvj4/Ukd+ZibE2NMhoZYm5kivurE3w07+K5+Oj/ZMnOy1UHL5Ysos/EszkjD6ZNbI36cLsSDFqn0LlWsQc3cUc28Sd28MT2GbCu0qVfpNMwxYBxiP4+N0W51Vw+fpqzb73Jm9//AalnzqPut2J0zdPjWGXQu4E3vs3U3A1h1wkmJEJkgQHbMgbXBqHhQ4ZnrsmROlKKk8WzgSO4K9YcYfJuojFN0dfroqakgssfHOPUG2+Qcf4MqqZqJmIxguIdDprm6betYw/vy+sCyRskJm4zMnub6PgRw5PC/8ge0cgaYxN7rG4/ZGXrCdGha5g8UsUqsV90B6drhvqaTrIunEdVfpW9qIqPFq1yqtMXG26+2onwxf4Ed7bXWVq9QXzyLq7EDZxiv+TMA9Z3XwjfH8mpVp6xe/inHuIbv824VPp75gbu8CbO4B6eyHVGpm7yYGeFzw8SfLnzDVHz9W6Ar0T7ctnGyxU7T+ek1Ccj29EB3N2VeAc6mB2bIzEtnmv+I0JzTwhP32P7xtdK6pMCBQoUKFCgQIECBQoU/DHjnxI1BxicYSp7vFwsN/Ld0+38yfF2/vkHDfyr0y1851wXP0nRklpqobI9zMksDa9e6efb53v5lhj7l2c6+RenOvhXp7o5nW+itDvGB0VW3i9x80GZm7fzLbyTb+ZNSQPn6gBZ5Wo6OgcpLmzgdFo3b13q4cNsDSnVdnLavBS2eylr99OgitOhHaK80Ul2uZkPU3p452Inb55v5e1LneIcatJKTdT0RGjXT1LcFuZiqZWTBWbezzPzbqZGFji+VGqkqidGfrObgmYPNW1B2oXvHvUwzb1hGntDFNe7uCrOfCXXTEm9l6auJJlFFi7k6MkUz11c56a6NSjMS1t/GLV5jOpGFznFZjIKjaTn68krsdAg5pgdC6gNE3SpInR2+elVhdGo49iso7idU7S3uqits1FR7aCixk1VrZuBvih26zg6dQSbaQSrcRiTfgjtYASLIU7YO4NJHUXV5kHdE8RqCRMNT7MwMsft+QSfr/n5ctXBlys2OSrmVzsR/uowyd9cH+Mvro3x5e4QH28N82BtnJvLcyyNzOC1j6E3TtGnnUVjmiHiH+NodoxnSz5eLJj5eNEiWhMfzel5Oq3h/mg/15N9LIa0+CxuTOK8/fppOjXT4uc0Qb9lGotnEYNJvNcWPTlpBVx47wSv/+DP+em/+pe89d0/JeP4qxgaclgJ6VgbCTE+OsvQ+Bbe2CYmsVZrn8ERlIR798X9Cr7YLsnJ68QnD4lPHOEJ7aAyrNBrWMJomyHgHkXd0Ut9YTYll09TeOFDWoszcRqMuMTz+BO7hJLXMfo2UFnW0Nm3GJq4wfLWIyZm7+IM7KNzS1o7OyTGDllYvMny2j2Gp44IDR0QG7uFN3Eo1i1hMiZpqqim6MoZ8Qx5bAS7eTSj5fmyhU/WXHy6FeTF3gT3Dw8Ym9yXo2ck/Znk1ANiE3eZW3vC/PpTmbCRSmbbEjdwDV1ndu0ZS7svcY3exhw5wimRQqFlNufneLkzzC8PEny9G+KrnQC/2A/z+YaHZ7NGngp7PGPgINZHb3kux988TkF2lTj7PsmFJ/gnHwh7yujKRzz78u/k3/nfJxSiRoECBQoUKFCgQIECBQp+j/htomZ7d4/WfivvZrRSNZDkgywNb6WoOJWn52Suhrcv9/L62V7ePtVGTpmdC7km/uS9Nv75e038yxOt/OBSH29m6viw0EpGrZeG3hhdxnE+yDfy3Qt9/OnpLv65JD78QSvfPdnOq6l9VLb5aKjvoEl80KsMYzT2jZBf5+dMnpmfXezju2d6+LNT3aRU2qjvClLXbCctp5O0Ig3ZNXYqOoLkivZCqYX3s9RcLDZS152QI3R+ermPtzP0XCyxUVDvpqknhNY8jC+yRI8uRm27m2bhs2NgnPNS2lWakdeuaHgjVc1baYOcyTbQ1B3B5Z1HYxilrjMoR/Kcz9FzWjzn6fQ+CqusqNTDlNfaqW900tkeRDc4Sm9ngO4OO077CEbdCP29SdrbguJZPVRVOjCYJmjtDlJQbqa4wkxVrZOurjgm/TiR0CxjI0sYNCE6O1w0S9E1wjpb3cJ3jNHkBrHYAvGRVTzxFTSuGXoM47jdC9yYm+PztQhfrzn5etXJz9d8fL7i5uVqiI9Wk9xamGQqNoHdNILOOo5/aBuze4Ue9QS96jF0lkm8wWWmxlY5mBnn2WKYTxbtfLJg4KOZQR6MS2Wg+5i3NqIuu0rm2eNkZeTT2RukuW+IVvUQHb0eWuraybpwlvQTJ7h65iJv/eQ1Xv/ut8h47xX+v+z9h3sbWZanCe9fMDvVVZVGSnnvvacsSZESRYkUPUUreu8tQBIkvCcAggDovffeSZRP+VRmKm2ZttOm2kz3tKnuMv1+AWTVbHXv7M58O/XM5EzHq+c8EYiIe++JGyDF+D3nnqNKvcGys4KP+mv5tL+G1z3VPO4zMNjkQOkWsOqGyJINItEOCfc4x/TMU9q6FwQ/RyhXDgvHh7G65tBZp5HK28hKL+LS+TN4HTxAwNGDVMYFMG4rZXGgCWODO9/NFPmqCaoN0zS2PqShZZnuoft09d/FUD+KzTGPq20VhUWYC/MkrvY7zMy+pnfooScHjjuSRmmewuaax1jfQWxYONdPHMBSFMu8o5wFZyGTtlxm7GUsNtVyp9fO3akpJiYe0DfyDEvzfeS2FWGuV5mcecPsnbcYmu5SaxPGb7mPo+8pLb2PGJl6Q0PHI5oGX2Fqf4LKvkJ/zwxvZlr4bNbKl9Pu5MR6vpiu58vZet6ManjaXcPDNilPumS0Vqdy9vB+tu05TUqekvr2u9R7Sn9/JGwf0Tv1ig/f/FAUakRERERERERERERERL7N/EuhZoHSaiPR6Wpu55rx8i9g39ksdp7OYtvJDLadzmbn2XyO++Thd7OMFLdwkWngUqyS4xEKjkVq2B1Ux9arEjZcLmfr5VICkzTcyrdxNrLGY/5xdYSna4nONnEry0REipbAKAmJ+RbCc6zsC6hk5+VK9vhXciRAwvGgGk6FK7kWryO90EJUTA7BwdGeaklewRIOBlZz9FqV57qzYbVciakjtcBKpaqDjLJGIlJ1pAp+ZhY1EHlbQ1CsHJ8I97KnKk4LY50NLCNauIekwgZuJum47l5ilWIgJt1MVLrRIwJFp2nIkzQTkazDXxjDL1xBYIyayCQtt7PNFFc60eq7qJLYyM/WkJ0pWJae0vIGZHXtpKSbiBSuD41WEhatIC5RQ0aOGYWmB4W2i+q6NuFaF/kFjaSmGUhJ1VPojpbRtSOttlNeZkJW40St7UVrGUdnHaWheQaDfZwCWTc50g5Ka7uQKVqxayw87KvnRV81T7rlLLfXM93uYrp/hE7XICpZMxXuqlGVHRSUt3qqUTlbZmluncHuEPp2J8lV9niijColdlz1zaz2O1hpraFPlYYiPYz4K+c4d2Af+7fuwOvwYQ7v3sfl81dJikkjISqOsCtXiQkKJTezCInUTHmVg6KiWnSVWUxbS3jSUsrLnkpe9dfwUZ+Ml91SPuyqZqm1Dm1NtTCfVpTmYSxNs5gdsyjdETXu5UZuYUY9RIWiiwqpjYK8Km74B3Bs9y7O7N1H3NXz2Cpiud8u4fWwkhdj9Uz1tFJv66NaN0Zd/TS29hV6hx7Q279KvWMapWmCOs04hnr3kqv7jE8+pW/wAWb7JMZG4fq2FRpblzCZ+5CUKwi+coXbQZewlyfSq0hnRJ/JjL2AyYYiJmxlzLaZWJ2dprdnyRPB09B2h9behzT1CmNOPKN/6iUNHY9p6H6Gqe0RusZVXN2PmFr6jPb+DzE03Uduv4fZXZ67b4mHY928mWjgsykzn0wYeDPmTlDcIOybeN6v5HG3jHstlcLzkVKUEMHOTQfwvhyJ3i58R3ofYex4iqb9Kdaex8zc+Zyl+5+LQo2IiIiIiIiIiIiIiMi3mX8t1ORWGDl5rYj4dC2BkVIO+xRwzL+Yc0FVnLtZw2lh63WzkhPBFXiFVZJQYMY3QcNm/wo+8KvkA99y9gSWczxShm+Knsj8eorrmpGo2ojJ0XE1vg7vCBlnb1Rx7Eo5+32K2XWxkBM3KkgsbiQq185ld6lsd46ZaBU+0WrOhcqFMRWcFNpcCiok6XYB4RFpBIaXcEW4JijZRESqnsScelKLbB5hJrnISny+jaDb7spKdcSla4S2pRy5UsKRq2WcCijDJ6SGm4LvsdlGssvs1Ki6uJWqJjBWgW+EkvMhdZwPqubiDQmRQj9lVW0UVzSTmGEkKcvsiaJxL3vKyDVQJmmgtFwYO11FdIKc0NhaIoW+C8qayCtuIOKW4IPQR1aulbKKJsornEikdpTqZo8Ak5FtIT7JQFyShkRh3rLyLSg0HTQ1j9HoHKFa1UmxvId8WR8ZUnfUSR+ahglM9nG0mjZarC666xX0GcpY6tQx2mrCZW5ErmqhrK6TUnk/yvpRVIZ+istclFe1I9cNoRGOmRonsTgnsTfPUC1vp1A4706WnCf4rlR1MNQ9jMugJfa6H6f27mbvpi1sW7/VY0d27uLg9h0cFY5fvXCO1JhYZOXVqBQNyOTuZVD9nkTDVapuwcdW7g86eDWi5s2QjI/6pLzoruRBazljpgLqMqO4fvEiN/yCKCuupU7ZQVltv3DPA8I99CPX9qPRtZGfU0mgz3VOHTrG8V3buXbiAIrkcKZM+bzok3j6fjum+SZ3y5CeO90OBpp76O2dx94yicYqzFm9+57nsLkWMQj7rR13GRh6SGf3HTp6VrE1zaM0j6Aw9mMyd1KeV0pKyBXKEq/Tqcxgqj6XEW0ag+okhnUpDBmyGWvSMNo9KIyzRNfgQ+ztq+gdC1halxmefsHU0htPaW6VfRWl8x6mzsd0DL5iYuaNp2KVxn2s7RGW9qc4XavM9A+w1KZgtbVKMAkPuuS8GDHwetzMM+G+HveqedSj4H6HjHZNAT6nvNi2+ZjwfA0YXHNomlcxdj7F0v8K5+BThmc/Zmz+Y1GoERERERERERERERER+Tbzm0KNuzx3aW0D3lHVXI+potY4QGKhlfMRMg4FVrDlYh5rz2TxnVN5/PtThcJ+Acf9SkkrsHArXUVUrpnMqhbyZG0klTsIStdy6VY1J68VE5yoJyrTwR7vctadLmLrpTL2+pZzPlSBf6yesBw7cfk2yhRdwtbKgSulwjWFbDlfyNZz+ey6UMiey2WcDZaQm6emIDsHuUSCWllPVqmOJKFN2G0Dl6OUnAiqZkdANVv8pZwOkRGXpiA+voDwqGxuRFcQnWYkq8xFYp6Z0NsafG7WciFQQmi8ilxJCz5h1ZwR+vCLqCEqRU9GgZ3CMgd5uQZP/pjiIjOpqSpycuuRSJvR6vtJSK7jRngV/kFS/G/W4Cf0GSi0j0uWozF242gaR63tpqzSRXaOkbQ0NSnJKlJTtJSU2ZHJ28gvMiCR2NHo+tDpB6mp66BM8EdjGEGqGSa5rI3EilbSpC2UyZyYtQ0stZq52yLh6aCGe11Whh0tDHfPUCXvIrm0h5iibmKFbXx5PynSDnT2CU8FoebOWbS2QcrkneRIujxWqRjA3rSEVjuIStPnibRxNk9hMA0gr3NRkFvD8aNebNuwlc0fbGT7ug0c3raVcwf3kBAZSU21FpWhE219H64OoR/rNOWKfo/vKvMEzS3TTI/NszLex4txOy965Sw1lqIuiMHnxCF2bNjBxve3c2T3Ic4fO0VEaBqlEheldV1IaluEeVcSdj2UI9t3sXPDFo7t2ERasA+jllpejRp4O6rjhxNmvprU8dm4nE8HFbzt1/K6t5bH/SpajVq0mm6k2gkqNGPUasZpbJpj6e5rxqcfYaofQy3MtdY0TkunMEdtcxgNrUQHhRJ4cg+m/Jue8tcfDat5NSTnwx6ZMPdlzDUWMOeoZLanl0abu2LVClrHHM0Dd2kbuEfn4COGJz5C13AHW8eHNPY/Qu1aQeNcZXjmE4bHX9Pc85S6hvvILPewuu4zOzTDuL2KyfpC5hvKmaovY75RxoNeDQ/6tMJzlzNllzJqLmZIuKY4OZqDe89w5sxNrM4pz3IqXfN9au2CL+2PGFr8jF53KfDRF2IyYRERERERERERERERkW8z/zKiZpFSpZNj7pwyAWUcj5ASlmviZIiE7Zfz2Xm1lAM3qzgWLeNSXB1BKRoiMkyUCi/7xepefJK0HAurYV9AOTt8i9jmV8yWqxXsuy7hTKiU20V2buUYuRqv4OItFRfjtZxP0HA4XMaOGzVs9JdwOLiK6DwbISkGvG5KuRBaw5VbCm4mqYjK0JOQaybevbQoV0tJkRppjY3bBVZOh9ayJ0DCjiuV7AysYneQjCPhSi5EyYnL0hKbWMzFswEkJZQQFlfL+ZvVeF2r5NTVcs5ck3LpppyASDmZhRYksmayC8xk5JhITtMQE19DUlId6WkqsrN1FJU0EJ+oIDK6ltCQMrIyNFRWOkhI1RIWW0f0bRVJmSYKihspLnFSVGynWtZEtbyFtGyDp21Kqo6MLBN5RQ1U1LSitQxhbZ5Are+mqNxBqjAHSbkNJOc1UFhmx2zupt7UhkZpptFkwlRVjLkii5EGDb1WC2aNnTKpjZwSO+VVreitY1Roe8iq6SCvtheJW3wxDKM3DKLT9VLfMEaV8MzyqzvIqekiX9aNRNWPQWjX0bdCW9cSCnU/JdIO8is7BR/aPcmQ83LK8TlzjhN79hFwwZfM22moVCaqau1IatqpVg14EgGrzQO0dM3TLlhn9zLdvas0ts5jcEyitg3Q2TWATSEj6oofh/YdZse2vezcuI89m/dzcNdh9gmf92zfw+VLAaTezicqOJrj+w5yaPtOzu0/SIy/F+ayNMaabAx39DDU3s+D0W4+nW7gswkNnw6reNUn42lvDaP1JUjSYzh79CQB/lHkF+ipVXZS3zhJT/8qLe2zuFrncDYvYrAI/umH0eq6kUm0RATcINrvNA2VCTzoqORpl1ToV87rQRXPeut42FXFaruE++0yZlrNtDV2ozaOUWecQmOdZmD0CbOLH9HUcx+lbYla8wJqxwqu3ocMTr2gZ/Q5uoYlzK4HWDueYW59RGvbLDMdRqbqixgzZDCsS2dUl8OkuYiJhhJGLUWCldGpyKZbk4+pIp6LJ45y9LA3qek1aCwTqBrvYPKU5Ras/ZEnSXHz0DN6596K5blFRERERERERERERES+zfxroSZTWs86v2Le8y1i1/VSwnPNlCm7CM3QEZJtJjS3noBULRdj5ZwIq2V3YA3notXcrurgRGQ1m4V2Wy+XsetqGYdCpJyOUQnXKj3JgAPj5SQX27ld5uJQWDXbb1Sy8UqZp2z3pkAJu4NlnI1UEplpRqLsoLjKRXp+vafsdVSqjptCe7/wKs4F13D6agUnBD/PBpWRkGshJM3C8ZvVnI4Urrmt41qynqB0M5fj1fgIvl4Ml3ItOIvEyGRSEgsJipJyOVRGQJSCyCQ1t9K+Wc6UmKakqLReeJFvI1XoNyFNR1SslJJiI8mpddyMkHAt1N1XGcHC2OEh5SQl1lJRYRde7nuQyVsoENpnCfOWkmogNlZFVIycW4kK8kttyIR+C4qtlFa1UCHvori2kyxpB8mSdtJr2pEZByiWNJGUoSUlW0NGlpL8nCqq8guwSIsxFGehKSumqrgMncqEUu0kv8QqzJOdlPwGj6XnWZDWttLStYCjfRa9xZ13posySSv5RU5yhWsk0ha0piGU9cPUGUfQNcygs04h149Q7V4SZRnFYJ2gXNZJYUULZZUOyopVFOcUkxwdT3pCNuUlWhTKFuobhjHbxj1LqWq1I9RpBzA3jNPRvcjw6F1Gph7i7FxA3TCNQhinWuhXaR9FoXeRfDuHYwe92LfzMLs272Pbul3s2bafHVt2sHfnLg7t3seR3Qc5tG0nx3bsIOjcSdR5CYzbZSz2ddHePIShYQyNaZymxmGWBvt4M9XIqyElD9qraa7J5FaAD/t2HGDDmt1sXreXC15XPKW1rZZuTNYhwY8BVMZh4T4mcLomsZg6yMsoJeC8NzGXT9GlSONRt4QX/VKedVfzql/hKVPuzqvzqLuGex1S7rdWMu+QoCvNJ+V2GZU1bVidM3QNPqK+eZn61lXsHY/Q2FeQ1c/SMfSU0ZlXNPU9xtx0T3gOS2gbH9LZd4+7k70st0iYt+YxZnAvr0pmRJfBpCmfAU0G3fIUuurSaKtOpqU2jdtB3uzcspPz54IxmgaxNd9B3XgPieUOCtcDmvueMLX8Bfr2hzhGXopCjYiIiIiIiIiIiIiIyLeZ3xRq5uYXqTO4SCwVXvwlzeRJG4XP3cRkmzkaXMWmy2Ws8S7hd84X8jvnCvjO6Vze8ypgy+USrrgrGQkv+rcKrARlGfFJVOAVXcfeQClbL0vYeKGcjedK2OldQWBqAzdzbJyOqMI7TsXNdDOJBRYS3REsufWk5lhJFI65BZQCSauw1XHQv4I9F4o5IIy773QOBy/kc9ivFJ8oOTGZRjTmYaq0fdxM1eJ9S83x4Gr2B1awO1DCtgApO67WcClcjk5tYMKlYNxho6rCREKSnsiYWm7eqiY6WU1yvpXbhQ1EZZrwi5HjG6sitbiB2FtZ3IrOIiKinBtBEmJia8nJ1iGtdFJa0UhqtrvEdh1VtS3kC9dH3lISHl5DZEQlt+JqyS4SxlP2UO+YxNW7RJGqh/ACJ9eyGwVr4mqmk+BcF0mlDdSoGigtKCPqehg+J87g63WWyJAQ8jILKMhTkJKtJ16Yo9SyFlSWYaSKNo84k1XgQCLrxGQZx1g/Sm1dJ3J1NwbTEFJJE3mFdnILGiksdAjnOrA1jtA7dIe+4YfU6AbJre4jRzZCdtWA8Oy7kQn9tjn6MVTpyE1Jpzg/H73GSl1tI1U1rd9Uiqrtp1zRh84yRmvHPE7XEN19C7T3rmCwTyHTD6GyjdAydB9z2xKqhhkMzjna+u/S0TOP2dRFZakGr5OX2bhmG9vW72T75t3s3rGX7Ru3sm3dRnat24T/4cPUJIUx5axhdcTJeP8YY+OruFpn0bsTAusnURtmsJlGuD8zzepwE1UpMXjtOsLWDbtZs2YL697fxt5dhzl25CSH9x3iwhkfCouUKDRd1Km7UOu60aqaSI6NxWvfTnKjfJl2VPKiv5bXg9W8GpTx8bCGV/11PO0t85Tkft5XxeOuUk8OGXNRChf2H2Xr+oOcPx9MVZUFpUH4XuqnkRiWqTEt0tj5gMGxZwyMvUBjX6DWNo+9/QEtvS+wNa+wOD7Jq2n7r8ZRCGPU8aizhocdMu63VTNhLmBIm0V3XQqO0lsURF7hyLbdfLB2D6HhBWity6hd96nvfoquRXiu5iUahf5HZj/GOfqSjtlX4tInERERERERERERERGRbzP/IkfN/CI1ageBMbWc8y/izKVMQm9VcbvAzt4rxWz0LWGdbylbAsrZFSjhaKicc9FaziSYuJhs5HqqhpRKB6fDy9nul89G70I2Xy5nh385+wIqOHpDyqVoFeHpJioVnUiV7aTmGYlOUhMSpyQoRon3TQmnr5Zz+FIxh3yLuBQi8ZR9DohXcupGOWduVHI5rJagRD3BKWYiMhsIjNPgH11LUqmTyFwbp0LrOBoimDvCJqyGi9F13Eg1EZFlIb/UitNoZbm/gQatkYxMNUWVTSQK93gt0SBcq+KEu71wb4fClBwNV+IXJycxQ8aVq+FEhCZRlK+mpNgqtDUTLfh8PaSaQLdPYXXExKuorGqhqNRGZp6JgnIXhbIOcmu7iBfuI6KokbhyB9XmCdIqOwjJshKRYyQkpY7rMSWERaYSHHgDv3Pnue57g4Rb2VRW6snIUxCXoSE2w12NqoFb2S5isxpJL7BhtI1hc4xjsQ2hNw5SLnGLRU6y8wXLc1Aj68RiGUat6Uap7UFbPyy80E9SqxsTnsEgdbpBdPZZytWDFNV2I61rxWxoobfRyUx7E63WenQaJ2pDL7bmSYzWcarkfZTU9CBRDyA3DWF1TdI7uMzU9H06e5fQWsaoNY1RZRpBZhxDYx6na+g+AxMP6B+7S0vHNCbLADpdH3WKVioqDNy8FsHxg8fYvHErGz/YxL7NG7l4YDtZYb50a3JZ7DQy0d2Fo3EIlXkEc8s0HYN3aG2fF+ZggsaWGYZG7zEsWJNzmOKCKs6e9WX7tqNs3rCPndv2sm3zLg7uPcze7bvZvXELXkfPkRibR2WFkbKiWsKvXufaicNUp15loamY533VfDIs582QnE/GNHw8rObDfhWr/Xru9jey2qlgxVWCqSAenyMn2bxmL2vf282mDbs5efQSiQnlFAvfL4lGmDPdLMbGZUYmX9DWdx+d8w619UvC/M1jd9xhYXyRj2bb+WxKz2fj7pLqWl4PqfhoRCuYnifdday0lHCvo0IYV8K8s4yCW9c5un0fB3YcIjOlFI1hDFn9PFLLAkrnAyydDxie/Yim3oeom+/TNf2pGFEjIiIiIiIiIiIiIiLybeZfJhNeIE94Yd13MZ/tJ7LYcyqTE5fziE1Xk1TSiHdsLRfjFJxPUHEqWsHxKDW7btSxMaCa9/xL2eCXh0+sjJh8G8eul3H6ZhXeMXUExNcRlqolIk3LrQwDkcL+rXQNlXXt5JbYuXStjJOXy9nvThgsjL37Qj77LhVxOKCcC6FSErJNSBUdZAsvvEEpRvwSTJwRxj56s5YD16rZ41/FnisSvEKrSCpuJK3USXCKjpsZZm5mmglMNXEjTdgmGQlNNZCSq0OhbCS3UEtcmtqTWyWlwMnJUCVHQlXsD1FwJFKDV4yeG6lmorNMpJc6iEuScsUvmIyUXHKyVIREyAgOlxMQLCMooo7IOCXpgq/FZY2otH0eMSS1opmQXBtXc2z4ZlvxSbcQkGEluaSBoqoGYm+XERIaz6WLvpw7c56rvgEEBydwM6qQoLhaT8nwjPImKlQ9pLirYmXYuJVlI6XQRUl1F7XqXrSmPhocIzTaR5FWt5CRayU1q4HkbAfZhc3U1HbicI7R3beEq2ORav0w2bJeMmsGyK4eIqeqx5NXxlDfjbRSgb5aykynizvjQ/R09KOrH6BcPUCJZoQqwwhW1xzOtkW09UPYW6fp6lugo3uO+sYRFIY+bK0zNLQvoLRMeEQanWWS1vYl+ofuMjC8zMDIMo7mUfTGPjT6AZS6XhSqJkrzKzh+4Ahb1m9h//btRF/xwliSyLRLycpgJ/MTc1iFMVT1oyjqJ6irH8PkmqZX6Hdy7iHTs4/o6V/B7JpBbRXOGwcpkgjPPDiWEwdPsXn9DjasFfredYTdW/awf/M29q3fzIFtB7h0xg+/0+e5efooxvwIVttLed5bwZuBaj4dVfPRsJaPhtSe6JoHQzYm+0dpaZ1ksKMLh7IKnxMX2brxEGvf38uad3axed2eb3LtbDnA5UuhZGUrqFF20Ny9Kvi3iMoyT33TQywt99E6lmltnuTlVCefTxn4avqbilVvxtS8GVHxyZiOlwNKHrZLedBRwaOeKh72VtOjTicrKoCbl3256etN3M0I8jMqKK9qplwzTbF2AXP7KhPLn2DvfYi29QFNAx+KQo2IiIiIiIiIiIiIiMi3mX8p1CxSWWPDP6Qab8Fu3tZwI66Oq1HVJBTZCCtoYFughO/7lPF97zLeuVjMuxcKeNe7gM2BpRyPFNqk66lStVGn6yQpz0REmoGwZC1+EVLOh0g5dLWU3ZeL2S60ORUsJbuyg/AEHUd9Sznok8+5kEpP9Exsbj0xmXpCEuT4R1TjF1pNVomT4CQV2wMq2HhZwi7/Sg5cLeNsRC03krSkFFhIydZSLrGTJW3B/7aWkGwLcYLfsTlmguPVXI6sE8ao8eS58RLu5cJ1KQFhMjKLm8ksayUgUU9EvpOMmi6SSxxEZFi4EmfgfOQ3ZcKjE6QY6lTUFRVTkKMgNVVPXp6Tkoom0ousnopSQbFaguJ0JOTZKVINcCOvAe9MC1cFX25mqAlLLOOK/03Onj7Nob372LdxAzevBxOZUM71eBk+t5RcuqUXxtRxKtrABaGvW7kmlOYBanX96K1DaE29yBRdFJU3kVviIkfwVVLTRqNjihpZO6Xlzcg1/TS4ZjDYxqgzjSARPhuc05hb5slXDJJVPUB+TQ+VMgflRTVkxyUiyc6kzdbAYNcQnT3z1BqGhJf+YeH6IQrVI8L+oKdsdffACnfvvqK/fwWNYYBqdQ9SdR8SRT/Vqm5MjnE6B+7SO7DK4Mg9T8Jeg2UEjWUYk32MPqFde9s09fV9qFQuYm8lc+rgSXav387pXQcojgqkS1nIYreL7pYeT7SQq22WvtEHnqpGKss4GusUtuY5JuefMb34hOn5D+kRxtTbpzz5cNxCjqZ+EIejj9LCSg7tO8aWddvYu/kg+zcf8oy1/f2NbHl/C7s37iDo/DE65Jl82C3l9YCE1/2VfDKk5LNxE59NGHg9oublhJOF0THqnXPUWhaoNU0jF+7bHTlzcN9FNqzdy5a17pLlB9n2wVbWv7OJg7uPcfKwF9evBlMlNVErzKdEO4NUN4vKdoeO/rs8mOnnzZCGt2MqvpzS8cWkgbfjOj4e03oia5731fKiv44nHdUewWahtYy4wEvs3ryTTeu2s3HNFmHcHRzZcRgfr2vcDCsgr7qXtqHHNPbdQ9K4jLHzEUMzYo4aERERERERERERERGRbzX/WqiRaZoISFBz6Holu/zL2HS+iA2Xytl1pZTwQgeXk/XsuFrC7oBSjgdLuJKg4UaKiph8E5GZWiLTVCTlaakz9BKapOTEtXL2+hSx60I+28/ns+1cPrt9StjlU+qJmLkYXkm5qoO04npiMvRCewM+UTJOBUk54V/CEd9iDviWcEzwxS9CQm51C34JKryj5AQLft5K0xKXYSQs1r30qIIbIeXE3laRJ2nzLGe6nW+jWNpEUGQF56+VcSagkpMBErzcy7CCqvALlREUo/ZUV1LXD6GzjZGYa8FfOHYpUsXZULlgdZwNr+FcWDUBkbWe3DZjrY3MdDTQaGglJVPH9Vta/CK1+EZo8A1T4htay7VQCcmZGjIKtQRH5xEUksi5M94cPXiac6d8uHYtgrCo23hfOEd0WAxpGRoux+q4FKXmXLQOrzgrfrfrCc2yUiBrQWvpo6lzBq1hgJJyF9mFDWQU2MgsaCS32EVpeSsqRRd9fXfp6lvxLHEqqXNXfeohu6bfY4XCvsI8iL6hl5raeqpKqylOTqY4NRtVtR6Dro06ZRtydRvO1gmc7TOeJUwS/ShyyySWlnm6Bu/R0bOCwzVFV+8Kjc2zKHQjSOX9VCt70Zj6aWyaYHjsvvCdekp79xwG25BwfBiVbtATRdNgHWCsa4h+m5nKpFskX79M5MVzpN68jEmSxESTitHWdprtA+gtQtv6cXTWcaxN03QP3qejd4H2niXGpp7T2beKo32Blu4VhsbcYs1DGlxzWF2z9I08ED4vYq7voLJCh59PEAd2HGbnB1vZumYj697dyIFNW4j2OUW7PJsHbVW86q3izaCMT0bkvB1V8+mYho/GtDwdcXFvZobR0XtYmxeE+Vii2rCIRDWOTNVPZWW9p6rU2ePe7N+yh43vrmfd9zdxcOdRDu89wvH9xzl56DxR0TkUVzqRKIfRmqeYHhji2aiJN0O1fDqq4LNxNZ9PfCPUvJ3Q89Gw0hPJ83LALdRUstompbEmlSM79rBuzQ7WvL+d976/lbXf38yB7fvZuXEnmzce5OTZUKRVjdTphyg2zVMs+Gsdei4KNSIiIiIiIiIiIiIiIt9m/rVQky+8bG6/VMAar3zeO1PIurNlbLlUzv4rxQTfrqNa3UF2uZ2YDC3x2QZupWsJva3CL7KaM8EVHL5WzKGAQpJKnISnGdhzKY8tXnlsdQs0l4o4GiDhUkQtfrEyriXruHZbR3SOieLaViITVZy8XMhe7yJ2XSphz/kCDviUcCRAik9EDdcT5aSU2KjR9lJQ3kBMvJRbMRKiYmoIi64l7JaC60LfV8PqOH+9kjOBFXgFlBCXqqOw3CWcq+aScPxyaC0hSXpisi3cLnISk2sjRPA1MKGOPEkTGWXNXI5S4xVUy9mbNXgLY4ek6EjItJJc0EBqvhFJpYmBRjMWdR3xSW7BR8GlmzJ8Q6oICJcQEFLK9evpXLscwiWvC5w5epxLZy5y7UoYEdG5RNyuIjhBybVYFQnuJMRFZTSqK6moNHqWbV1Lswlz2Ey+rIPSui4KJW1kFTWRXdyIytCPStdPruB7VmGj8NLv8iTENVoHMFtHBBumoWkco33cU1UqU9pOTk03xbJOSisbPLlYijIyKElLRFFSgFVjwqB1Ile2U13XjbS2G0ltG9XKVgwNA55y3d2C9Q+t0tY5902lJE0/crU7smeYpvY5mluXsFgncDRN0961QGv7LI3OEZqax+ntmaO9YxqdqR+DsY8WRz/DLS6mHQoW7UXMGjOY0mczpM9jrt3IwkA3I/2jDA7P09TmzmUzgco4hto8iqlhzJMDZ+XOK+6svqFvcBVHyyIW1xJmx7xw33P0D6wyPfOE+cVnDI7ex9Y0g946Low/gExmIyIkjn3bdrLl/bXs3riRtKBLjApjP2yp4HFLKc86KnjZU83LPhmvB2t5NqTixXQ7SyMzOFzTNLSt0j7woScJsMIyi8w0jqtzhdZud0nzVlJul3L6yAW2frCNzWu2c3DXUY4fOsHODTvZtm4b2zdv59L5QHJz5LQ0dvBkuEEYR8bbSSVfzej4ckrPF5N6Pp808OmEjo9GVDzvl/Gsr4ZHneWM24pIvhnAxrXuJMm72b/vHLt3nGTz+p0c2L2fte98wPvvbOCD9zdzcO95bobkepYNFuqn0PWIS59ERERERERERERERES+1fzrHDWFFWaO+ZVw/Fo53uESQhMVhMTVEZmqJq3AQFGZmdQCMz4RUg4HVrDVu5TNF0pZ71XE+2cL+Z5XPu+ezePAlWIS823EZtbjf6uO4GQDQYJdiVNzPrKWvQGlbPIvZa1vMeu8i/AKryG3pg3vyEqOXCvhYlgNwbe1RGSauZ6i40qSmtO35JyPUXAr3UBFTTNFJRYUim5CI2q4cLWMU5dLOCr0dcy3lMM+wta/hBNXivALLiUjR4vJPECptJWEbDNhaSZ84zSciVBwzJ14OLiO40EyLkXJSS21U63uJDFTT3apg/RCOzFp9QTeUuMbUsPFoCp8BP9uJQo+ZxQRdiOUyOgCwiOLCQlN5YyXD/v2HeHwnqP4n/cjOSGduMRCwhNquBZTh3+MShhbh/ctd/SMsB+rIL1AR29TA0vd9XQ6mlCq2ykoayU5x05Cmpk4d66ctAYikm0kZTRQU9tFU8s0DtckVtsIKm0XxVVNFEiFealspaiimTp1NzbnODJlCzU19eSk5JAUHkpObAzSnApqyjVo1Y10dUxgtY8iqW0X5qeN0up2pHXtaPQ9uJqn6OlfYnzyIV29S6hNg2iMo55S3HXaQdS6Ycz1I0yM32dl+Rl9A4sYLQNoTf3o3JE77iglYz8OxygDveMMNDm439/A8x4FL7okPOso40FzEQ86FSz1t9LTOYTR2u/Jf+NsnqZ/4C7d/Xew2Cc9NjT6kImpx3T3rdI//ICJ2Wf0DK1iccxicc5jb5lnVPB1evYx8/NPGRP2G4R+1NZxNJZx9OY+DDoHvhd8OL57OwW3rjBqyOZhS6lHpHnaUcmL7mqedQq+dUt5PljHy/luFsbnsTXOozDPU1e/gNK2REP7fVoHHtE79kgY5wlG+xQ12hFqlX2UlBi4ERDJzk172b/zMAd2HWTTuk1s+mAjm9ZuZNembVz1Os2gtZKnvVWeJVZvhuv4YlLLV9MGPp/QeyJqXgvH3ZE0v46oedwtwVqZyKm9R1mzZh/79p+lpFhBcaGCoOsR7N9zkPfe3ch3v7eB999dz/trNrN16z5PSfLouDL0DaP8/Be/+NVP/28HUagRERERERERERERERH5LfKbQo27PLdC00hSlpbI23LC4mUE35ISHCMhIEpKcoGFjOJ6dnvnsfFcHu+dyeH7Xu7om0LWncln/dl8Nl0q4tD1CvxiaonP1qPQ9xKdaeRksJTdfoVsuVzIeu9i1l8sYZ13CWt8i9ngX8rhoDJu5WhRWPrJlNgJzzHjE6vlVFgtx8MquRyv5GqSlhspZvwiVXjdqOJsYBmFFS1k5pq5fKMEr8slnL1cysUrpXgL565H1RCTriVN8Ds130JavolSWQt+wvHToXJO3KzjZIiCUzeVnAtV4hupICzVQFa5Hb1tEEvjBHGpeq4IPlwIruZckJRzgcK416RcEPwNCC8kNiaHkIBgzhw5xbGDJ9m7213+2YuAgHBuJVYQmaagqLaZkpo2QhKU+MdruBCn50K8yZMU+UaigehcC7k1zZgcA4z19LA60MyQy0VugY24JDPxyRZuJdUTlWIlPtOMVNaO1TJIZ+s4fT1zqNUdHgEqo9RFWrmT9KJGcovslJebqatWU5qRS8L1m2SER1FdWIGiykxlqY3yykbKpHaqpI04PVWjRlDq+1CbBrA3jdHSPkO98GLvFlzcy6ic7Yu0dC2hNgxhtI1jbhimqXWa8fEP6em9g6tlmrHJxzhbplDpepGre5Bruqmtc6KRGTxJdxsqU+lRZLJgyedFdw0fjRp4PdvBvblpWtrGUbrHsg6icW+NI8IzmGZw7BHjU/c8ETKjE488kSuNrYs0ti3T1LnE6PQTBkcf0yX4MDX3nL6Re9ha5qh3TdE7vMLAyB2crbNY7GMY9c2kxafgfWQfeRHeOKVxDGtSmDELPlmzWW0q5HF7OS+6qnnWJePhiIM7ws/FuPu+2lZRuyNozHNU1c+jaFiiY/Ah9x++ZWjwruDrDCrzNLWqMWrlgyiVbWSll3DB6xL7dx1i0/qdrPtgA5vXbuHEzp1Upd3gcXcVHw3WepZYfTau4cspA19Pmzw5aj4Z0fDRkIpXfXKe98gEvyqYthWQGOjHtvUHhP4OcNU/HI22zZOfqLqujfjEAvbvO8N6d7TN9zfz/jsb2fzBds4ePcuh3SeJuBnPz3/+81/99P92EIUaERERERERERERERGR3yL/WqiRa50Excs4d72EUwEl7L+Yy66z2Ww5lckh33xuF1i5kaxl68V81p4tYId3KSfc1ZmCJVyLVRMQo+JylIJzNySc9i8gILSSjNImzkXW8cGlQk/0zFafQg66I2BuVnMxWs4NdwLeFBVhSbWk5xsolLUQmKrharyewAQD/jFyfCLknnw3hy6XsudimTBuhSfXjde1YnJKG0krtBEU/U3lpZR0PUnZJiJTtNyIVwm+yTjiX8khvxIiUo3k1XTgJxz3cldsStATmW4mudBOSqmd+DwbIYlGAiKUZBc1UCht5UpULaevV3HpehlXgku4ciOHK9dvc+XKdU4dOcz+nTs4cfw0F3yDuB6eQURCFWG3Bf8TdXgLfQWlN1Ak76dMNUh4lo1rSUai85wklTWTK+8iT9lPSnUPUcXtJFW04XR0MdXZhkEqo7TUyO0sAxlFduFlvFV4Ke9Gq25HXmOnqtyEVuWkqWmcWlU3eeUOCirt5BeryUrJIzk8nPjr1/A/eZTchFiUlUpklTYqKh2UlNsFa6Ss3IVU0oJa0UpvzwyDI0v0DS7T2jaNwTKI3NBHlaqXGvdSJ0OvJ2/NwPAK3T3zniTB7V2LGKxDyPVDKI3j6OpHPRWenM5J1Kpmaqq0JN26jd+ps1w6speA47vIuuZFU1ksq70a7k/0Mdo/wcjoMh3di9Q7JlDXj6AQ+tOaRmgQPg+N3GV55Rkrd1/SO7iCs2MeS+ssRtcMNtccLe2LLC2/5MGDN0I/9zHbJ9HbptAJZhLat/YsMDlxjy5XJ0XJyUT7nqO+5DajumwG1bfpqomipyaWcXUas+YMFhtyuddaxbPxThZG53A0zdDYtkDX0ENa+h6idy4jtyzi6HrA2MwLevqXBR8f0zf0xOOPyjCG2jDh8aujc4aKch2BAdHs2XmQjR9sZMeGraSH+DHnKOH1QC0fD8k99nZMw2fj7kTCRmFfK5xT8LL3G5HmWU+N4FMl9cXxnN17mA/e28XeHScoK6zDYh2kVj2MTDtGtWZQeP4mrvpHsWvbXjav2cihbQe4cPQcuzfu5srFq/zsZz/71U//bwdRqBEREREREREREREREfkt8ptCzczcAgXSenb7FrDuVBabzuSy4VQ2m89kC9ss9lzIw+emFImijZxKFzfi1VwNr+VCUCXH/Ao5dCmfPWdz2CW023U6m12nMjjolUlQiDvyxcG12yqCbmsITVRx/VYNV0IlXAoowjeoDF9hPzBWTlCikoQ8M9XaXsLj5XhdLeOAdzl7L5Wy+2Ixuy8UCfvCWH4FnBPaBcfVkVfWiM4yLLzc9xMWX8eFEAknr0k47FvBEb9KDvlXcOBKOQf9yrkUUkNSfj1q2xAlta3cLrRxI8WIb4ya86E1eAVV4xVcy5kgOb4RapJzjFTLnMTGVBIclMzJk97s3XOIfXsOcOaEF2FBEWRllRGdXEFAXK3Qj4qLt9xRMwbOJ5g4H28iIKmeyEwzEnWn8MI/K4w9Tm5dD/EVbYQWOAnObyIgtwm/HCdXchqJL+zAaOhirK2eHqsGjVxDrbzBkxenvEhPSb6O0iJhv8RMRYmJumoLdls7tTVK8pJSiA0MICU6gtKcXKqKJaTGxHPd5xIV2UWoq6xCOwsVlTakEjty4d5stl66uhdoaZ3G6Rqnd2CFtvZFTIKfCtOg8PLfj0zThcU5Qv/YCiOjS4yO3aFv4A7G+iFqdb1Uqvqp1Y+h1A+i1bRjUDeSlpCCn9dJjmzfzMFN6/A9uIWK+EAmHSpWhjoZbB+g0TWM3jGMrXmCrq4Fhkbu4Wqfx2gZpb1jnpnpR4wNLdHWNkln5ywTk48YGLnvSRRsdc3Q0bPE3OJzJt3HB+8yMvGIjr5lzzIpQ/0sZtssba0TzPd3MmGtZECZwYQ2i0ctFbzukfFRv5wPO6U8aqvkfnMZd5sKWWqV8GiinbmxOVqa5jHblzE0LqKzzeNoX6V35AnDkx8yv/iSrp4VbM45YW4WBL9X6Bt+4klu3C4cH554LMzPGHXKAarqWklNKebSaR+unT9Njzabe84CnnZV8rSzgiftZbzur+WTYRVvx3TCvpyXvbWC1XmqUK22lDNmzCfsvBfb1uxg3Zqd+HuHUm/splV4VhbHAjL9BBLtNDXaYZTaNgqLq/A6cYHTh85w6sApdqzbwZULV0ShRkRERERERERERERE5NvMvxZqcirN7LxUwMYzOWw9m8fui4WcDijjcrSMsDQdcTkmwlOVFNe0cCNCwv6zWew4lcX2U9ns8soRLJudXhnsPJXMCe9Mrt0sIel2nUcUUBu6uRkl5ZxbZPHL5crNSm5E1RF+W4tPZDWHAt2VpoQ+/Su5El1Lhbyby6FV7PepZK93mbB1R/mUcj2uhrhcIxnlLsLTjVyOquVihJSiuh4Scq0cDyzjwNUK9vmWc0To7+S1CvwiZUSnGUgrdZFS4iKp0EqluoPA+FrOuJdBhag4cVPByaAaTgdJOH+znMCoAuJjs4kLieT8sRPs3bmHnTv2ce58ACFh2dyMkRKaUOPJDVMq7+RKqp4LiQbOxenwSTLjl9LAtZR6ksucVBuH0dinqDP209h1h1RpK0G5Tq7lthCQ08zVXBeBBU3cyHeRXt2FwTpMb/MAtQX5RAUEIimSUZCtJC9HTVGBkZJCI4V5SqpKlSgqZBSnpRIT4Ed2XDSS/BLqpAbKK/SeSkRV5XpqiyvoUEuYbrFjUzWgkjlw2QcY7puls2sSjbGHCncCYUUXWtOgJyGwq3XGs6+3DtLVt8Do+CqutjFP0mKjcKzNLe60T1OjaEOuE3xVdlErayQ3vYBr3t4c2bWNA5vXc3DLOm547cZcEstKr53F0WGanANYbeMY3OYUrHECm2OSnt5F5mYfMTvziMWFx/T3zNLmmqDJNYXTOeERbMbH7zEz9ZhRd6TN8gv6B5ZpapvD4prG1jxD7/B9T5nuxqYputvGWe5vYcFRzLI9myVLGndtmTxy5fOsvYKX3TJP4uDn3RKeC9unQwaeL46zNLPKwvwzOnvuYHUtoLXNCT4uY3XO0927wrNnX7K89JTO7jvYXHcw2mbR22Y854fHH/Hw8Vs6upfRmadR6Cap1oxQrexGI7fSoinnQacwXlcVL7oF6/m1VQtWw4temeBPtUeoed5Tx/P+Gu53VtNYcZv9m3ezfs1ONq7fTXZaFTrDECrdCC2d97G13aG2fpo68xgtgt9aywgV1TbCwlI4dfQSuzbsIeCiPz//mbj0SURERERERERERERE5FvLv04mXCqzcOFmGd5hlQQnabiRpOVKvJozIVL2Xy5ix4U81p7L41x4jacEttfVYvaezmD/6SxO+hZy8UYJ16OkRCbKiYitISxSytXrZVwPLqFcUk92ST03E5X4xcg5H1HHkWuV7PUtYbN3KesvlbLRp4wt3uXs8ZESnqIjT9rEjXgFAXFKbmWaSci1EZlRj++tWo4J/e7xL2e7XyXbrkg4FSIjs6LNU67bN7yay5EywpP1xOfbic2zexIau0tsnwiu4mhQFTcz6ylTDxGUqOdCaA0XIqT4hhXidyOZiz43OHfqFD4njnPu0AHOeZ0U7iOSG1FFXI2qwTu8VvBfjXeskWu3TRTKuslTdnEjy8CNdLMwppO86i4qdUMUq/pIrGjlZnYjIVl2EkvbqbXPkq3o50Z+M8GFzcRJ2oX2vdRZx5DpOykut5KeqiUrQ05cRBLXva+SGptNYa6a4lwlkoIaitMyybwVSnpUMCVpqVQXVFEnNSOttFFWKlhZg6fKU3lFA8oqCxPNDp6NOHjU7+LO8BR9nVNoDR3UKFqorGunvK6Lcplg1W0odR1097sjWFaZmrxHa4dwbX0vSkMXte68M27TdlPfOEpryyRKeQN5OeX4+wSwb/t2dqxfw94P1nL54G5KEoJoVJYw3NlKX9cIExMP6eiaxdY4Qr1tDINlzFOhyuaO5umf587yUx4++IjZmXv0dk3T4hzHYR/D5RwTxhqjp2uS1ZUnvHz+GVPTj2hy559xTmF0zKBvdOfVmaGrd5GJ0QnuDDh53lvDi65CnnaX8aCpgDlDMqv2bO4783nYXC6YO6FxMU96lDyZGWV4ZJl61yzN3XeYnHtN79BDHC1L1DsWaG5bYnr6Ob19K4LdZWTsOZ09D4VzUxjsM9ib51hafuGJ8BkdfUJ7x4pwf5MojMIcGYR7cQyy1KXnXlupJ5rG7dvT7iqeCfaovYK7rmIetlYI+5U86azmYYeUxx2l9GmyCPf2Yv2arXzw/na8TvphNQ+g0I8iVY9RZ5hE71jE3rmKs3WGgYnn1JhmKdeMUK7o5XZ6LadP+HDD/7oo1IiIiIiIiIiIiIiIiHyb+ZdCzSISlZNLUTIOXy1mv38JWy4V8P75XL7vlcv3zuTx7tlC3jlbzE7fQiJTldTp2klOVxAaKSU4qprLISV4BxRwNbCUa8FlhERVcSOymqBb1eSUWcmtcHImuJLNfuWs9Snj/UslrL1YxAeXill/qYhd/uWcuikjKMFAcq6V0uoWNJYhTzSMuxKUu9LUviul7POrZLdPBXv9Kth9uZSDgVJ8bilILbFhaBikStXmqVTlHSnjXFgtR4Kk7L0hZc/1KvYGyoStDK/wKpKz5ajkFhJi0rh+NYjjh46zf9c+Thw+QVBAMJmpucQlFOEfXoFvuJyzYQpOCnYqQsXpSC1nogycjVATcltLlbqDhrZpFOZBCuu6uF3WRFiOjcAMK/4ZDVxOs+Of7hQ+O4kvdniWQFlcM9TpB6lW9lBe1UxmvpHbaRoSk7XEJ2mJE7ZpqbWkJWTif+E8If7+JIaGU5SSijQnj5KsIk+i3u7WIdR1jVSWWahwCzQlVkqKLZSWmqmS2lArHPS29HN3eISX0528WWxhvKMNo7aLGkUr1YoOquSdwrYTubYTm2uMpo4ZuvqXGB67i90xiELXQY2ujxpVH9XyDmTyJuRKO1WVNQRe8ef44YPs3raNg5u2c/nofgpirjFgrGLEZcNlb8fiGMHkmBT6nqR3cNmTb8bR7I6kGaOlY5axqUeMTt73iDhNzZMMj9xldvYRfT3zNDmFa5rGGBxYEI49ZGT0Dn2Di0zOPGF86gkOt1jjmMVomcRq6ceg0CMvTMVWEsGDtgo+HVHw8ZCMl70SHjYV8byzktd9Mk9C48cdEh501fJosovhvmnhmcyhdc5hbFrE6Jqno18Yb/IZAyP3mF947kmcbGtcwOpYwNG0RFfPA/pHHtMpzNXs/FMG+lexC+0bnAt0dK/SM/hI8G+ZFtcUoy0u2moS6ZPFMqKKY9KQzLwlk3stJTzqqGSlsZBpYzqz5izut5Rzv7WM+YZ8KhKD2L1lN+98313e+xiZKeV0tAtjuBaQG6eodkft6CdQWaaYnHrGxNxHqGyLVGinKFaOUyofoKDMjFLdwC/Eqk8iIiIiIiIiIiIiIiLfXv6FUDO/SH6Vle0+Rbx3Kpe154p5/1wR73jl8u6ZLNZdzGbvtRIuRMiISNaSmqmlpEBPbZWDwMB8Llwp5nJoDTduyYlK1HI1rIbz1yo56lvCIaHP09dKyatpJyrXxlb/ctZ6l7LGu4hN3nkcvl7KlQQ1t/JsJBbauZGk4WJILeeDJMRlG6lU9XAqWMoOf4lnedSByxWexMJewZVcT1YTX+QiuaSFqFQDMYJvCm03sdlaj7Bz8HoNB67J2Hu1mj3+pRy9Uca58DJCYwupLq3EUJFP0nUfwi5f5FZwKOGhCUTFFBAWWUl+mY1CWTu+t7ScizJyLFTNiXANXuFGLkUo8YtVEZvvoFzZT5V+gEplG5rGcWJLndzIdXA53c6lFCu+yfVcSzcTkG4isqCBIkUnRusQna1T2C3D5OeaSUszECvc9y1hHmISlMQmykhKlVGUI6ckPY+b3me5fPwgadEx1FUoqakwU1lhp1LSiMncQ0fnFIo6B9JKK9IKwYStoqYRV+MAfX2zOOxDaBXNOI02ns10MNOux6E3otG2oDd2ozX0Um8fpalrFp1tiFrjMHLzODr7iEdYsTT0I5G3Ialupqa6kdKiGq5fucbR/XvZvXkDB7Zs5uSuncRdOUGrPI2VLjt9zX1YLH1YGycw2ifQCvdqbBjD4pygvWeO0cl7DI3eYWnlpSc3jrucuM0pzEnTDDbHOE2tk8zNP2NkcInx0bssLriXG83S0jWPs23GU3VqcOgeY1OPcbgmcFgHqCmpIMj7DBEX99NaFcWr/mq+nnIn6VXz6YicjwZqha2aT0a0fNhVxaM+Ay8Wx7i7cp/WzkUsriXMrkVUDcI8NC1hbVmiZ3CV12++ZmX5OW1t7lLdS5hsCxgts8K8zNHetcz9hx+xtPQUh2MOs20ebf08KqNwL83zniTHd8fHud+jYd6Wz6wplxlzBqOaBIaVscxbs1lxFDJvyRH2cz22ZMtl2phGW20Gwd4X2LzpIB+sPcSpY9dQK5rQG/ppblvxLHuq041SJ4ylNE8yu/gxLT33aOh4jLrhDqXqMSo0U8h0Izx4+jW/+MUvf/XT/9tBFGpERERERERERERERER+i/zriJryOjv7/It552QG6y/ls8s/H6/gMoITlUQmq4lMkBMUWoiPfwY+l9OJCC2mqFhPaq6KGzE1nkS+R/yK2Hshn53nCth2tpgtZwvZ5FXA5tMFnAwsoaC2lchMHefDJQTeVpOY30BCvo3QFC0XgsuF9oXs8S72VJTacamE/b7FxOdYSC9r4kJoNecjFATf1pFU0EhSYSORGSYuh9XiFSDlzNVqTl+p4VpkHcWyLkLSDBwLquTk9XL8bhRzNSidi5dvcvT4WY4ePMylE8e4cdmH6IhEbqdIib4ttI2qwidMuJcwBQGxGkrquilTduCfqOZ0hBL/OAOR6RZyJS2UKPvIre0hpshFQGq9YFZPkmCpdYqY0ib8Ui1cyWggLLeBzEoHUncEi76HYomDtAw1aWkK9NoeVKouklLdAo2aW7FykpJkZGSUkRx3m/ibwSQGXacsLRtJgZzyYqMw5zayixrJEuYuI9dKYVkjKn0X3T0z2K1dmAwttDUPM9g9S6tzDLm8jWKhTVl5I9XVTdRrW+lxNFBdmEJeZqFwfRNd3XM0Nk+hqB+kUtNDoaxTsB4q1H3ITQO42qcwmVuoqxKeWXQCJ/YfYuf6DWxdt54DmzYSfvEk9WXJLLfX8WTYxFJPG07nIPrGEZRCn/qGMcyNU+itE5hso/QMLHLn7kuePPmM2fknOJsmcTbPYXPOoLO5l0NNCP7MeqoqPX3yMc+ffkpv7zwO4boGl3uZ0SwO4Xqr0G9X1yydLf1U5OThc3Q3UT6HaKtL5eVAHV+MK/l6SsMXEyq+mtIJ+0bejmp5M6zmzWQD98cnaG+extG+wPD0h/SNPMTimMfQOI+xeZmGtkXmFl4yPHqf8bFHTE88pd2dbNk6jc48g1F41iPDD1hZeSX8DD1jcOQxjU2LqE1TyPVCP+Zp+tv7WehQ87CzwiMOuXPQPOup5HFnJQ/byz3RNKvNJUwZ0z0RNVOGdCb1KQyrU8gKD2DP1v2seX8PG9YdIiosC4O7/LlqEI1+VJizBdrdwoxrkcaWFSZm36BumKfKtIS59TGmtrvITMJctd7j1ZsfeX7mf5uIQo2IiIiIiMj/Bvzzf+Gf+6iIiIiIyP94flOoWVhYwGQ0k5NfxY24ci5HVnI1tAy/6/lcupLDuQvpnD2dwhmvJE56JXDO+zbp2UquhJdz0Cef3efy2eGVz7YzBWzxKmCTsL/hTB5bz2az71I+Z65LCYpXklZkRmHuI6/cSUCkjFOBlezzK2a3dyF7vUs8iYP3CLbbt5QD/mWcCaomPNlIraYfpWGAuKx6wT8d3uF1wjkpJ69JOXa1mqOCHfGXehIIe12XEBpXTW5BHQHXY/DxvsHJQ6fYt+MAxw6eJODKdUJC4wm7VURATA2Xomo5G1KHl2DnwpV4Rag4Fa3hYrRbgJIjrW1HZx2muLaTDGkLSZXNhOcL/qda8Uu24JtsxTetAZ90Gz6pZhJKm4SX5SlqjYOUKToplrVTWOEkM89IQqqK2EQFsQkK4m8L85GmQ1blwqhtJT+rlvSEQkKvhhLoe4Wo4FByUzNxmB2YNC6qqpooKrWTV9JAXpmDvFJ3n3ZyChookzTQ3jbK4uw9psdXcNl7UNW5hL6bkFY2UVHqoLK8UejDhVLehlnbjFVnJi4iipTYJLRKKwptB+WqHvLlgr/yToqE+y1X9iDTtFFXZyI9MRkfLy8O7tzJno0bObJzC+E+x1Dn32KoQc54u4u2xk4me7r4cKqdO+M9dHcPYml2R+aMo2kY95TXdi9zGh59QHvHAh1dSwyPu5cXPaSlc9YTfVNvn6bBMUVP7zLzc4+ZEO5nYvwO8/PP6Otbwe6YwWydpN4yRoN1CK3cRFLULfxPHqQg3JtRQy6vBxV8PqHhB7NGvp4z8uWUlq+n9Hw5oePNsIpXk07uT36TqFhrnkFVPyn4OEFb7yqDI8/o6HFXoFpkZuEVA4OruFyzOF3zdHauMDr6iKHhRzS3LNDbd487y58K97mKs2merh6h/dBD4bpldJZZmhzjTLnMDCiSGFXFMW1MZcmWxaI1g/n6LJasuaw6S3jQUsGqq4T7zcXCtpDlxgJaqhI5fWA/G9bsYsN7ezi07zw1UjM22ygKtTuR8BhqvTvB8wxNbXeYnnvtWWqltMxRqVvwmLxhCaPrPuMzL7l//yNRqBEREREREfnfAbeQ8otf/vevZ/7nf/5n/vHnP+U//eNf81f/8Of8xd//mbD9CX/z07/i73/2d/z8l+5ykaJgIyIiIvI/kt8UapYXFxhoMTDWJKeqWMaFC6mcPpvE8ZNJHDudxIlTtzl5LJ5TJ2LxOnMLX+8YIsMzCYmrYufFfNZ7FbHpdD6bz+QK20x2X8zmzPUSrifIic4xEZKmxzeqhvMhFdxIqPMIAJcjatjtXcqWi2WClbDLu4Q9lwo5erUEnxglYdlWYoubCM20etoX13VTUt3J+aAqjgRUCybjyBUpx69IOOpbzJmrhVy6nk+w4NeNwFDOHj/Bvm172L1lH6ePXSQgMI6b0XlkF2vIKtTiH1bN+Ug9J8LVnApXcCZcyfkIDT7RBi5E6ghMMJBS1EiNuge1sR+ra4TY3Houp5q4kGbiXJKBc/HCfpyFK+4cNGn1hOZaKKjrwOIYo71jEo22ndR0LbG3NUTG1xEVL/dYZJyMaMFSUlWUFSmpLqkgOiiIyGuBxIdGU5RTRkl+LcUFdSjljbS1TVFV20SZtJnKqnaKyh1k51kpLGlAb+6jo3uGto4pGhr66O6aoqNlHJ26XXixb6I430ZVuRNlXTu11c2Y9N10tY3TZO9CVaMjNzmLqOBIyirUlNc1UyLvJL+qmTKZC1mthdTETPzOXuTo7r3s2rKenVs3cOHILkpirjLSWMF8j5Mue4enXLTW0I/J1M1gxwDPFke5P97BSO83c9fVv8jswhPauuawu2ZocM1jsk54ymn3DNxjcu4pvUNLNLdMMj39hMX5pwwNLNDeOklH2zSD/cvMznxIv7A1mYaE8fqQS1QEXhCe7cmD1CQHsews91RQ+mxUxWfjar6c1PL1jMFjX0zo+XhUx6cLLby6u0B3xxx6ywIq8wJ1BrewJjwv6yzOlhWmZ57z4dMvmZp6RFvrDA7HDFb7LBbbNC7XHKPDj1leesXDB5/Q17uCq2lJuI8FHM3CfvM8Q0MP6B+4w8rYMC+H9NxzFbHckMv9pmKP3bHnM2vMECyTaV0aI4oE5uozuNOYI1gucw3F5IZdYdMHO1j73g42rd1DZEgKdls/HV3LwjgLaI2jqHTjqPQTmATf5hc/on/oKfa2B8hM85TrBNPPUWteYmrxNQ8efiEKNSIiIiIiIv8r4hZUfvHLn/Mf/+Ev+MO//jE//ssv+Oonn/AHf/0j/vLv/4y/+cf/yH/6lblFlv/4D3/On//dn/AXf/enHgHGffynP/t7/unn/8g//eIf+bt/+k+edn/wH3/Ip3/ynKe/f4d7P5zmzg8muPejGR7/3hKv/vAhX/zZR57x/uLv/5S//ulfeszdp7vt3wt9uIWcf/7nX3r885go6oiIiIj8d/ObQs2d5QXmuo087KhgpklLQkQOx08mc/R4PKdPx3DubBze5xO55nsbv/NhnD9xmaN7DuN38Tr+IfnsuOCOnMnjUnAZ0ZkG4vPqicrSczlWwaFr5Wz3LWSLTzFbvEvZKWyvJymQ6AY5HVjB3ovFHPIv52KkjKj8BuLKWwktdHEh2cDBiFr2hNSxN0LNiRg1BbVdJBfZOX6lnJNXqjh3tZQrQQVcC8rg0qXrHD5wgN3r17Jnw3oO7NvHJf9groZnEhhTyYVwCafCZPjGqiiq7SG9tJ1z4WpOhms4E67iYpSKq7FqotLNFFV3USJck1rkJCC6VjA5GYV2lLYpgvIbOZFi5miintO3DfgI+7FFDirV/agMg1RWOsjM1pCeLken6aCiooGIWzJCo5SE31J4ImqSbteQl1FJenwqCaFBBHmfJi0hhrJCCeUlRrKzjGTlCJanJ7fQgEzRTEfvPAp1NwXFdsor7VgtAwwPL3uqJWkNfRRLmymsdCKVNeNqnvIsCVIr2qirakVd24JB00Jby5hHxLHo2tHJm9HVNaGTmYWxkzl/9jwpqflU1TYiV7soLaniyvnzHNy+g52btrF1/Tb2b91OlO8x2pUZLArfl/GOTqzmLhTuEt3qQWoV3ci1vejN/fS0DPBwvJ/Xs508mhpieXaFlvYprI5JTA1TKA0jaMyjmBtm0BhGhXOz3Ln3jGdPX7Mwf0/w312We5K25jlaXNPYbUO0t0wxPXaPvu5hJEXF+Bw+xuWDe9BmhfGyV8bbsVo+G1fy6YiSz0bdQo2OH86a+Hxcx5tREx/NtPHR/UUe3fvQk4jY5phHbZhGoZ+hzjSNzDgl+LbA8vIrHt7/SPi5eMlA37LgxwxmyzRG87Qw79N0tizy4N4bPvzwE8YnHtPUuoilcV64l3lszkVsjdN8uLjK29lWTzTP54Ifn08Y+GRY5any9Ky72pPM+EFzKYuWHMZUCUzqbrNgTmXVWYC9JI4z+4/zwdr9rF2zi42bDlNZbsBoGURhHKRz4CHt3asY6yeQa4apd8wyPv0Sg3UOS8s9GrseI6tfpMIwg8K2wvD0K0bHnotCjYiIiIiIyP9KuMWPf/jZ3/Hnf/fH/ODP3/Lgx/OMfdpG32u7YA2MC/urP5z0CCtPfm9ZsCUe/+4i9388y8rX4x5zCzDu4x/90WM+/ePnfPLHz3jxB6vc/cEkY5+00i/0NfBRI4NvnAy9cXm2gx856P/I7rHxtx2s/GCch787z0NhfHef7rYv/uAen//pK77+80/53b/6ij/72z/ib37qFoT+wSMqiYiIiIj8f+M3hZqVpQXGOkzMOwqYsOSiKikkKCAV7wuRBPqGCi/s1zm65xwHd55i96YDbF+7ne1rNrFnw3aPWJOYXkNwghz/qFouhVZzPLCc3X7FbLtcymafMjb6lLLRu4SNl0rZ5lvGmeByssqsyA09xOUauJlp4Gq6iXO3jRyM1rEzXM32CA2bwzVsDFWzJULN/igFvglKckvN3Ior4uq1eIKvx3LxjB+njpzjxJHTXPC6iLfvDbyDErkUUYhXuJTjIdUcCqniYJicfWFqDoVp8YnVk1PVTqakjZA0ob8sG0mFDtJLHaQUWolM0XItVoFPhJwLoQrhnlRcFnyJzbNSqhsgXmgXXewkXdpKfk0rhRInWblGEuNquRVZRXRMLdG3qklLqaWuzkF1tYOMVCVZqdUkRKUT6h9KmHcgmdG3KMnIpaJARmG+ipxcPelZJjKzLGTm1gtmJjvfTGGxBb22g/7eOQb754TtLM2to+iMndQq2imTtlBY2Ux2SSMFFS7Kql1YbP0M9M3S1jxAi6PfUx7aYmhHK3d6BBqtW6QR9rW1NtQ1RooziwkNCCQiOJSgKwGcPXKM3Vu2s3vzFo7t2kKU32m0BQlMuFQsD3Ux3DmK1TyEsX4EhaEfmaYPpX4IjWEAo7kfe+MIs5N3PNErj8e7cRpN1Fu6MLtz1phGqbfPoKsfQyuYo2WGyZlHLK88ZWX5QxYW7jMwMEeLO39Mwxh26xDNTuE6Wx92vZ2shAT8Tx4i/NxRmqUJPOqQ8MmI3JOH5stJPZ+Paflq0sgPZur5Qvj8yZieN7MdPJqdYWpontHBeWan7jIz/YjOrmUMthlUphmMtjnGp14yMvKQttZZhgbvMz31IYNDD7A1zmBpmMHROMfi7AvmhOP9/XcZn3jG2MSHtHcu0+CY91R9Gh1Y4OPZHr4Sxv9q2iT4YPDYW8GvN0NKPhqU83ZUw8fDKk/Omg+7JDzuLONxazEPW8qw5IUQd/UcYT7nCPQ6TXjQLWzWfpTGYWSeyJ85LM4Fmjvu4nAvueq7S/fQE+TmRaTGORSNKxhbH2BsuUNDx0P6R58yPPxCTCYsIiIiIiLybcYTk/LP/8w//fynnoiYH/z5Z7z4w/secWToYxc9r60MvnF4xJrxT9s9x9wiy4BbXPGY41dbp3CuyXN+SNgf+A3hpU+wAcEGP3Iy/HEz05/1sPz1GPd/NMujHy94tm4hZuHLISbedgjXCP38WsD5z+bwCEW9r21Cfw2MftLC4lfDPP7dJV7/kTsS5zV/9fc/+ZVgI0bZiIiIiPz/w28KNYsL8zgtKqSZ4cRfOYPfyZOcOHyG3dsOcnT3QY7s2MuOD7aydcN2Nry3gQ+++z7rv/sem773PvuFl/nYW2n4RZSx63Ix2y+VCFbM5guFbLhUwEafAjZfymePXwmnQ2q4nmQgIbeR21lmSqsclKnbORUpZW+EjO1hGsG0bBJsY4SGDeEKNofIORBazYWoEmLSKwi6HsW5k2c5uHsvxw8c5sLJi8RFppCSUsGNyGIuhFVwPLSKQ0LbfSF17AmuY2+oUtjXsP+mlgPBWs6GKYlK02BqHKPeMUVumYuIVL1HnPGPruNSmIzzgq9nQ2rxEsa/EKz0VKIKilcjUbTR3reEyTpIcbGFlFQlsfFyom/VER4mJTxSQnBEKeFREuJjJOSmVaOp1lCWnkPsjRACzp0n7mYU2UnFGBQN2EzdFBXWk5VrIT2vnox8CxnC3LhFmjzheGGJlapqB422AYb6Z5iZukN/7xQKTSvSuhYqatooLHOSX2anoMxBaWULMkU7TtcQs1PL3F2+R3/XCCZNM3plK+o6JyqZE02tUxjfgb7WiqnWQnVepeDbOfZt3ezJQbN3/Wb2btjKhf1bKb51heF6GRMtLpobWnA5BpgYuUtPzywGUx9a4xAq0wBK4wAafT+NjlHGJu8xOX2fgZ5JBjr7PVW20hPTsRpbaWyYwGAeE2yYjs45FhafMjZ+j87uBU9kzcjYHe6sPKOnc1boaxy7bZAGUytKqYKbVy4LPu0l+co5OhXJPOst5+2YnM8nNR5Rxr3E6aspEz+YtfL5hJk3nuVObTydn2R8YI7BniUGu+YZ7J5ibGCB5flnDAzdx+6YZnb2NZOTT2lqmfN8duedaW5bYHjkseDfMzo7F1mYf8Hi3Au6O+/S3HKHpvYVOnvdy6WEfvof0N89y4vlST6bNnuqTb0dV/PxkDtnjrv6lOCfW0j61f7bUTWfCvZqQMaTzjKedVXwqK2MFVcxs41FzFhL6dOW0t3QSEvrJGrzBHLTPHLjDHUGYQ7ti7R2rLC0/IrmnrtUm2YpN8xTqpulStivb77L2Owb+oYf0dv3XBRqREREREREvs389Of/wJ/8zR/wyR8/5c4Pxj0ii1uccQstI5+0eMQT9zKlT9yRMX/ynGd/cJfVH05z94eTv2FT3PvhDI9+d0GwRY/w4l7StPDlILNf9DP7eR9LX414jr/4wwd8+icvPEuc3Eupvv7Jp57tl3/2hs//9DUf//Eznv/BqieSZlXo1z2We//+j2Y8vkx91s3EZ52MftLqEXDcQlDvK6tHDHJH8vzuX33JPwr3JC6JEhEREflv5zeFmtmZGfJzcti+cStrvr+ed767nu9/by0bPtjM5rUb2bJmPRvfXcuad9cI599jvWBb3n2Pje+8L5x7j73btnEzKo2jN8vY5I6gOV/M5osF7PEr4OzNSiIyzdwuaiQ+z8qVmDqO+hex37uIo75FZFU6yNP0sCtCwbpwFRvCNWwLV7I/XMqF2Er8ovI4ezmUo4dOc+7wafbs2MO+Aye4fDWam5EFBMVKiM/UItMPE5Ju4sjNanYHydgZrBC2dey5UcdewQ7dlOEVVcutAjtl8l7KZd1k5lqpqeuhrKYT79AaTgXVcOamO1GxjDM3hP1AKT5htYQmqiiQtiDT9FJW5aK0vAGXY4KSQhPh7nLfURLCo2WERcgICa8iQvicmFhFVkoJkvx8ylKiyI8NJy8pg5KcWrIzVSRnaMjJr8dqHcPROEFOgdUj0mQKll9oo6jQjFRqx+Eco7t7gfr6bmrrGtHp2ugfWKTRNYqkpomCUidF5c1UVLVRLWvBZOphbGSFscE57OZmNHVmhnun6OsYRa9woK5xoqptQl3rwKywo5aoSIuOx2vfPvasX8fWdRvYIDzvvZs2k+B7llZlDjNdFtob2zAaOjBb3ZE8w56y3mPjS4yMr1JvG0Gl7cdkHaGrd5Hluy8ZGl4SfB+h3jKIzdZPk7NXGF9PfEgstVIjjXbh//ex+zy6+4qx4WWaW6exOqYwC9bgHKe1dcKTp6ave5YGcxuy0mp8Tpzk+M5NZIWcZ7ahhI8GZXwy/I19Oirns3F3dScDv7vYwFezZj6dMPBqys7T5WlGB2fo7ZxhqGeWgc4petsm6e+YYbB7hpX5R7x+/gV3l1/Q2jIl+D0t+DBDfcMMFvucJ1JmoHeVp48+48WzT+nrXaalZQW7a4UG1zK2xjnB/3lPlM2LlUXeLjj5asbID+aMwlbPl9MGvpoWPs+a+Fowj0gzpha2OuG4gTdDdbzokfCorZhHrcW86P0mQuhVXx2rPUaWJ+YYn3hAW/cdTLZ5FLoZZNopFJZF7M5ZlpZe0Tv6BHPrXaqNM5Sqp6jQzqI0LzI+9YzRqReCfSYKNSIiIiIiIt823CLGL//5F/zl3/+Ej//4qUdQcS9Hci9vcosz818OcP9Hc7z8wwd89qevPEugfvyXX/Kjv/zCs//lT97wxb+yL3/y8TfCy59/4tl3CzHutm899pLP/+y1cP5jfvgXn3n6cff3X7JvxvjM09ev+3a3c/f5mdDH2z956RGMXv3RQ48wdOcHk4K/g54InM6XJqY+6/L4/cd/8/v84y9+KuaxEREREflv4DeFmpmZGXKyc9i5bTdr3tnId//9+3z3O+/y7vfeY8333mXd999j2wfrWfv+Ota+u4aN774rvNSv5eTuzYRe3E9epBdmSQpV1XLO3yziQkQdAQlqQtP0XE/ScSmqjiOB5ezwLWKLbymbfErY6F3MZu9Sjl+TkFvZRHxZAyejJZyNKMU/IpdLl0M5e/IcR3YfYt/2Axw95MUlnyD8QtLxDivkfGgZJ25Usv+aVNhWE5lmQqLuw/+2hoOhdey+UcPhYBmXYlSEZdaTXOokR9JEcq6ZsFsK/IKruBgk41qUkiJpC7kVbVyNVHD2ejUXb9YQGKMkMdtMfqWDwspG0nJNRCaqCYpWcENoczvTgFbXR0lBPdG3aoiMlhITU058TBG3wpIJ9A3A99xZooKvU5LpXt5US1amgsQ0DXEpOuIEfxNTTeTk2TCbh7HZx6iQOMkvNCGrc2Gx9NFoH0Gv66KuthmpxF21yUltbQsabRedHbM0Nk5SLetAJm/DZh2gr3uSwZ5xmm09GBUudHUOTOomLLpmettG6G8fx6Ztxyi3UVteR2ZcGn5e5zmya7tg2zi6Yyendm4l5NwR6rLjGGrQ0WNxYtE0ozN2Y7QMU6fqEcbrxlA/jLVxhNaOGQYG79DdNcf09CNmZh/T1TuPxT6M2TZMvXUUi3UEq6UfZ4NbrDGRl5aFUlrL9NA8fZ2TtDSP0+Ccor5xCpNtQuh3EovQtrV5iB5XO0WpGfiePIn/iYOUx11h2pbPi74q3o6o+GJCy1u3SDOm8lR2+uGsmR/MWXg7beOzhWY+mevg5fwYcyNTDHa5o3sm6O+YoE+w/o4pRnpneXz3KU/uvWR1+RkzUw9p71jE2jDpyUtjaZjHap9jZOgBD+++4d7KS+Zmn9PT+82yI4ttBrt9EadzltmRab68O8CPFiz8cN7MjwT74Zw7usfE1zPCds7M5+NaPhPMHWnz2bjGk0/ndX8Nb4Zqed5TyYcdpTzvrOCTATlPe6tZ6HXQ3jJBg32Wju67dPc/FOZ0Aa1pFqVpmsHRJwyNPUVjncHW/tBj8vo5pNoZ1PWLTM6+xtEqPJ+hV6JQIyIiIiIi8j+Xb0SKX4sVP/9VguAf/PmnnggUT0TKaxsTbzs90StukcMtrriFkv+aqPI/y9w+uX1z56rxROL82WtPFI47cscdDdT10szcFwOenDa/+5df8bf/9Nf88p9/u3+QiIiIiPzvxG8KNdPTM2RkZLHug61859+9z+/8u3dZ9/46Nn6wnnXvvsfa732Xre+/w/4Na/A+tJ3Eq8eRpQbSUBbOgDqOWXMCdx1ZrHbKseiNhNxW4BVczeGAMnb7l3oSCW+4VMS6C8WsO1fKxgtFbDyfx7ZLuZy6kk94eD6Z2aX4+IVx6sR5Th8+zqHtezl16CS+vte4HBDHpcBszgdVcMLdb1ANh27UsOdaFTuvVrE/oFoYr4bE/AYqdIMEp+kITNaTVNZCdmUbyXk2opP0XA+vxfe6cO2VKs5ckXLqqoSzgRICImoprGihuLKJmGQl2WWN5Fe4yMir53aalog4JTci5fiH1uIXKscnTMGNWDUJaRo0ilaKctSkJRQTF5mIr9cFfM6cIiLoJolxWSQnS8jM0JCeaSY21Uh4koYowRJSTSQkmUhKNZNbYPUIGQN987Q0jQgv/sNodJ1Iqx1UuAWa6mbKBX9KyxspE6xS0oTSvQSrdYqR4WWGB+YZ7p2krbELk6IBbY0Vs7oFXZ0TucTq2dp0rbRZOwVrpiwjl4Dzl9i3bQe7N23kwLaN+HkdIynYn5q0WPrNcpb62hlsH8KgbsWg76dW1UO1ohOVbgCDeRSdeRi1foCGxhFmZh/x5MnHrK4+p7tnGnvjKGab28YxWsaw2iZpbBwXbJCB3gn623uoyM4lKyGFBlMLTQ7hnhvdFaDGMbnbWUapN/cIY5tJjgjn0uF9XDm6A212KKstFXw8JONzjzij5vNxNW9HlR7B5kez3+SEeTNRz8dLI9wdH+fh5DivZwZ4Mt7HzOAwPW2jgo17hJrB7knuLT3h4Z3njPQt0Nc5y9zME2ZnntHSOi/4NIetYY7W1iXu3fmE0aFVOtrnGRt7wvzCa/oG7tLomMTpmGGwa45XiwN8PlPPD6e/qTTlLg/uKRHujq6ZNfPllJ5PRpSeaBq3uYWaj4cVvOit4mV/tWf7qL2UD9sreNUj48mAhpmBQaz2SVT6KfT1MzhblunseUBr+z2MwrzeufeWxra7VGpnqDUvonWsYBXOmZpWMQn+T869wmRfoqH1oSjUiIiIiIiI/I/EEz/yz//sEWTcSYHdS5vcW3cVJbfI8fqPHnP3BxOMftxC96t6Tz4Yd36Yj/7DY0/0yrdVnPmvmTvSx524+MGPhT9E3nZ58tm4BZuJT9s9x9xRQH/9j3/lEWzECBsRERGRf8m/FmpycvLZsH4n3/l3a3nnOx+w9vtr2fD+u+zZ+B7eR7aSHnKe+txgJoyp3HWl86glhSct6TxuzeRJew4v+0r5ZEjC3cEGMgtUbD5fyKaLRazzyuGD0/l8cKaAredL2XOujCPeeVwMzMYnII6oyGh8zp9h55YdrHn/fd75/vfZv303oUEJhEZXcC5EyiH/Yg74l7AvoIo912rYdVXKnoAa9l2rZcfVanZfk3E4UIZvtAq5YYCRqSfI9QOEJ2vwDq7mwnUZXoFVnBLs6BUJh/0kHLss4YynclQVPjeqSMs00tw8RWf3PKmZWoLCpFwPrSMgRIFvkIxLQTX4htXhHVbDOaFPn5AqbiVUUZRTTtqtaM4dPID36dNEhURTVaag0dJHRoaB+BQTsSkGIuJV3IxVEpGkIy7FSFyCjqhbCo+Ao1T30tezxPTkPaYm7iKV2CgutVNa6aREMHc57twSG/klForLGqiocFFv7mdyfJkHdx+wNL2EReOirtyCts6JQW2nTqJDUWnEpHBXdmpEKewrymXEBF7Ba/c29m34gM3r32PT+99n55rvc3HPRmRpkfQ1mHHZmnA09nqS7bqaJqlTd1GlasfQ4E4CPEWVrA2NsZ+m5glm5z5kbPIhze0zLK++ZmL6AS0t7lLhE9RbJzBZJrFYx4R+xpieuc/91Vee6J42ezuFGblEB0VgUllx2vtpsI9gtgxjM3Whr9Phd/4cR3duJeDEHtpkKXzYUc4nA1V8MarksxEln4zKeTum4stJtyhi8USrfDxh5OV8D1P9U7gcs9jt48wOj7PY34GmsoQOVyf97aMMdI5xb/kRTx++pq9rhhbnxDcVppqnGRq8y4MHn9Pfd5eO9gWePPqCibGHHvGm0TVPU8s8vf13ubv6KRMT9xnoneLFyjyfzVv4elbwZcYtyvxfpcHdy52+njV7ctO8HdfwieCzO6LmE+E+Xg/UCj8/ZTzulDJsyMNVdVu41zTB0plsqae/YxyjbYI6/Rh1uhnkghkts3R0PWBy5jl37r3BYJ+nQjuPRL9IpW4WmWkae+cjBiafMj79FK11kcb2J6JQIyIiIiIi8t+HW1T4l/brf9/wzf7PfvkzT/Ujdzlrdwlsd6nrBz+a81RtcueGWfpq2JMQuPuVxSPQjHzS7EnG+9xTSekjfvgXn+Muwf1fEkH+V7Ef/cUXfP2TT3jzHz7k4Y8XmPui35PHpuOF0bN157n5XeG6v/+nv/1VhM2v51BERETk3zb/OkdNYVYOR7ft4ujWLXgf2knYpUPk37pIQ0UkY4YkVhpSuOfMYLUpnXst6cJLczZP23M89mF7tmBZPG7JZMFRjFVZg09YERsv5LPxXAG7LxZw7HIupy+ncs43Hq/zQZw6dp5dm7ezZf1GNqxZy5p33uWDd95hy3vvcGr3HsJvJuETUsr+q+XsuSplr18Z269UsEPY3x1Qxf4bNRwKlnHWvRQpw0x8sYvkEiex2QZyymzItX3cjFdwLqiKk9eqOH61iiP+VRz1q+bM1Wp8gqq5GSPndqaZnBIXmfk24lM1lEibqZS1Exqn4GKQ1NP+fFANF0LqPBWtrkRIuBFVws3QJCJDwrjqcwG/C95EhSaQnCIhLklOfLKKWnkHBtMg6dkmYhJ1xN7WEyNYVIKG2CTtr/LjdHqW+NRbB6kWrnePrTMPecQijaab8opGitxJgksbyStroErmwlLfR3frJD1twzSaW7FoHXS39DPeO0WTtRN5jRlZlQl1jR19dQOyYgX5KTnEBAXjfewgp/Zu49Lxg1zzOk6Erxchvme4HXaV+toy2m12Gq1uv3swmfpw2kcZGVqlr3eJRucEeuMwWv0gja4JhkbvMjHzmPaeRWzNM1ibFwSbZGh8lampR3R0zOJyTuFsnKS7c5752YfMTNyho3mU9qYRmuz9gv9tngTBubfTqSqpot7YhNnQREl2Id4nTnBy3y7irp5hQJfriTb5qF/K25E6YVvNpyNyPh//ZumTO4rmyxkbn0w5eDrXz+iA0H/zFJbGacy2CRoaRnA0DlAlVZKWlIa2RsN43xSrC48Y7HZXxhqn2TUt+DvjseamWQZ6lj2Jhp8//Yx7q8/o7lmhpWOVprYVnM2zNLUu0dG5wszkPV7cWeTjhSa+WtB58tL8cM7M1zP6/0uoET5/MWP0CDQfj6r4aFjB2wmNsJXzpKuCh+0ltNcmEXDqGEf3HuDMgcMEXbpMp6uL3u4FTNZJ1MYpanWT1AimMMxgsM4zPfeC2fkXNHfcR2map0Y/T7lqBqlujmrjLL1jz5ice0lD6z26B1+KQo2ISF1dHf/H//F//DfZgQMH+PLLL3/VUkTk/477++H+nri/L48ePfrVUZH/ffiVBOPOqyKYu4LR3/3Tf+JvfvpX/P3P/paf//JnnmPupUs/+ovP+fRPnnkqND3+vUUe/HjWs3Rp6atRzzImtyDjFijc1vnC5Fne5K6U5E7u617y9OIP7/3n/DP/K0bQ/L+ZW3T66s8/4e2fvODp79/1VJj6dQ4bd3lxt2DziTB3P/nbP+bnv/iZZ85FRERE/i3zm0LN/OwMOmkx5ZHe6DOu0S6NYEgVzbwtkfvNGTxpzuSpYI9aMnjcnsnjNmG/OZvHTZk8cKazaEunty4aVdplcsPPc9P3AoE3b3Pueh5nrmZx9WY6Pr6BHDt0lF3bdrFlzSY2fW896/79GtZ+53tsfO99Nr37LtvfX8sewY6tf58rJ46Qk5nPxYgKdl2tZqd/NVt8yzwRNMdCldxINZNQZCehwEJUtpmARA1nwus4HFyLV2gtmSUOqpWdXI2s5ojQ5uiVSk4ElHPpZhW3Uo1kFzs8yXtj03QERMs9oszF4Gr8w2XklDaQX9mMX1g1F4LdxysJjJYQGVdM0I1oLp27wMUzpwm+foPwW0nC8VJuJdYRlaglNF4vmJbETAMyZQcNjgmy8yzcStASd1tDljCmQtOD0TKEUt9PRU0HuSVOkvKtJOTaSM5voEbdTXvnDEZ9D5WVTsqlTnQG4f/5zim6W4dpsbZjdC9xkjWgrrZhUjpob+hguGcUp60NndyKuspEeY6E0ICbHNu/j+3CnG5+77tsfv+7HNyylvDzx5HEh2BXSrGbTDisrdSb2jGYejGZBjEZ+qk3DuBsHGV4cIXRkVVcril6+haYnnvIwOgdWrvmaWydo941j8Y6jbp+jMaWGYZG7rIw/4TRoUWmx+9yZ+EJE4PznmVHzY2DuOwDnq3TNkCjqQtdtZbMhNskRkZwOzKKs8eOcnrfFrLCLjKoy+Z5bw2fjdTyxbiCz8eVfDpcx2dj7uVOat5OqPh0XOsRaV4vzXjGaW6dweKcwNgwick2jcE6id48gtk6iFZto6KgHGlRFZ1OYU5bx2hyjnvEmaamOZyuGZoE62ieE/x+wZNHr3nw4DXjE4/o7L4rPJd7tLQu0tyyTHPzLDOj03y6PMhXc0Z+NK/nh/MmfjDvFmvcSYO1fC746E4s/HZCy4v+Gl4N1vJ6WM7HYxqe9Uq511rEndZiimKusGv9Dtas2cmWjQdJi8/B6RjC1TpLR9994Xu0gMZT9Wmcau0E5sZF5hY/wu6YoqlVeDZtD9HZlqhUTVCln6fKOMPg5Ec0d67iaHvA9PxbUaj5tvHrP/7d9mt+89hv2q/5L51z2//bObf9P53/t4Yo1Ij8NhGFmv8V+NXvv//88u/e+3/45/69+J/3f8lPf/73/OTv/tgjNrz9k+d8+HvLrHw9xuJXI6z8YJx7P5r5z9WP3BEx7nwsHS8MtDxTC6ahXdjvellP/0eNTH/e66ma9E2bWU8Za0/+mT958a3OP/PbNHeEjVuI+vzPPvJEDrmTDruXRLnnyS1cuT+7K1C5o5DEHDYiIiL/lvlNoWZ5cZ6RZjXzlmQWTPHcsSaxakvivjPJI8o8acsWLIcHLcncb3KLN+msOAsYVN3GlBdE4pWTnNq9jY0fbODdd9zVodaye/se/C/4c/rAcY7u2u2pDrX233+PNf/nGtb/+/fZ8jvvsfV777Hxe99ly/e/w/bv/zv2vfcdzm1fR8714zSXhTFuzsas0eMTKuGQXyV+0XLii6wUyrtJLGjEN6yWE4ESDl+TevLU7AuoZedVBYdvKLgQIiW9oB5N/ST+YTICo2SkFFqplHeSlmPialgVF4JknLxew9EACccDqzgh7J8WzP9mNRn5DVTWtBITL/STWkb0zWiO7tzF+eNHiYu+TWaGhJjEKsISlNxM0hF8W09QvJagWDVh8UZiUszcSlaQV2zA4ZxAWuNCVz8gvDjPo64fJKukkYRsKzEZjcTlNBGb10hQioGQVCPpJS6q1G0MDa/Q7BhgsG+Wnq5h6nWNGGptGN3RMrJGtDUOlFI7mmo7ZoUTh7GN8Z4R2oxmbLJiInyP4rV7HYc3rWHX2u+z7b3fYfe675EUeI4BcxVzfc202pswaNowmYbRm/pRqjrRabqxmgepNw9gE3y12wYYH13h+bM3wt+iL+npnae5fYnm7hXMrmk01gkMjXOCzWKwT1LfMMTAwAyfvvmCF09f0y/43ukaoMU+gLOhn6bGQVocQzht/Tjqe2iub0EpqfJE0BzctJUzuzZSEOnFg44yXvVW8ulgFV+M1fH5uAJ3KW53Thp3bhq3CPLxmI43s8189niFF49fMTS4iqNpFovDnZx4Gr1lAqN1GpN1CkvDOH3CXC5OrVBTWk16Qjx2o41Ot1jjmKClaYGWZuHeXDMM96/w9MGnwtwv0tm5wIP7HzO/8Nyz/KmzY4W21kUGe2b5ZHWat5Nmwb9aTzLjL2d0fD3rruak95Tbfj1Q46n69HZSy/O+ap72SHk5WCvs1/C4s5zVlkI65In4Hj/EB+/s4r33hDnYd466Kiu1qm5qNMOe73D34Ie0dt9Fbx2jzjCGq32R6dkX6IxTqHRTwndrlva+p1ib7yIzCM+kYZaJuU+E6xeRC587eu+LQs23CfcLgfuX8N27d2lvb+dv/uZvPMd+9rOf8fXXX2Oz2SgtLcXlcnk+//znP/ec/+u//muWl5c9gkN1dTXz8/P85V8Kf9QKfbnt888/x2q1UlRU5Nn+wR/8wb9oOzExQVVVlaf9ysoKf/u3f+s592+FXws1PT09vzoiIvL/HVGo+fbi/r32jf3Ss/XkQvnVZ/e+2372y3/iL/7uT/kPf/N7/P5//AE/9izV+dRTeenJ7y17Ij+mP+v2iDB9r220P9d7hBh3rhW3uOAWY5qfqul4bmDo4yZmv+hj6esRjyDjFmPcZayf/O4Sz35/lU/++Nk3lZj+/FNP0l23/VsQZ/5L5r7nH/zFW0/FqGe/f9dTUtwdWeOOsHEnU773o2n+6K9/zM9+8U+/epoiIiIi/7b4TaHmztICk+1G7rnyeODKZKUxhXlLPCuCPXCmcN+RwrItkXFjAk2VIShSrpJ4+TTn9u9g75aNbFm7gY3vbWH9uxtY985a3vveu6xf+wFr31vH+++sZ/17H7Dpe2tY/513ef8732XD73yXrd/9Lju//10OfvA7+O7/gNv+BymL9qK1PIQJbRyzxjhhzBQWmiqxm8wUVTpIzrdwPV7O2ZsVHA6oZG+gjG1Xa9hxpYq9AVIOB0o5FFjD4WvuPDJVhCYqqdV04mgZo6LGxa1kPb6hdZy+XuURZE5dk3FCaH80oIbj16s5eUMitKsgKLyCmJh8stPzuO53Ff9z5wm5co3CnGKysqVEJ1ZzI7qK4DgVwbF6rt5SExCnITjRSFCcnpvResJjtCRlGiiV2ISX+3EmplaxO0fIKXZwO7eR+IJGbuVYicywEJFuISTVwM00ExHC59RCF5WKTjo6JliZX2WwW3hZlzegkX2TKFhbXY+mxoK8sh55RT1q4aVeV1OPqVaHvCiP4oRgZGk3kN72oyLBn4rYy0hjvZHE+5EdcYX66lKWx4eZHJ3GYR/CZBzwlPVWa7vQanvRafsw6HsF68DlGGawb4HlhQ+5t/KYh/dfMTb+gKb2WczOCQyOCawtc5hdc+is49iapukZWBHeAV8wPX2P5ZUPWV56QH/3OC2OPtpdw8J2mOaGAVzWTpz1LuEeqrh47DgHtmzA7+hudHlh3G0q4XVvBZ8OVfP5mHuZ069sQiOYirdjCj4dUfFmqoXny3NMjC8wO/eI+6uvGRlZpal1AUvjjEegqResqWnWc/z+3Y/oaZuh2dZPg7GR3JQcaitqabJ10dE0SZtrluH+VT589Akjg0u0Ns3T1LwkPAt3VavHHrGmr3eRIcGeLS/w1WITX01q+XJCydtRd94ZBV9Ou33UePLnuCs+fTGl9yx5etot4XlvNS8HZDzprPB8XmkppSDahz1bdgk/L/vYtH4fUSFJaNUdSOV9SNRjSFUjyAxj2FuXaetZxeqcYWDoLr19d9GaFqnRzCIVrqvTj2NxrWBpXqV7+BGjky+o1QnndHOYnAuiUPNt4dcvED/+8Y8JCwsTftnE8Kd/+qeeX8p/9Ed/hFKpxGg00tnZiUajwWKxeI7/wz/8g0eYUalUNDc3e0Sc8vLy/yy4/OEf/iEymcwj8vT19VFbW4tcLucnP/kJP/3pT5mamqKyslL4MnfgcDg817qFIve5fyuIQo3IbxNRqPmfj/Db9FcRMN+YW4BxJ+v9s7/9D56Ete6lNo9+vMDj3130VB16+Uf3efmH94X9VU8S3+nPujwigVuMcS/H6f/I4ckZ0/pM67GeV1ZPieyZz3u58/UEj4R+Pvy9FU9/biHGnXPGHR3jLk/tjo754s/eeEQYd+SIu6y12zyCzF/82xNk/mvmnhP33LjLfX/0Hz70CFwDwvy7l4dNfdbtmcd//Pk/eJ6yiIiIyL8l/oVQI7xwTnUaudeUy0NXGvccqcxbEpnSx9JdHY4lL4iSyAtEXT7O+QO72LthM+vfWccH3/9GjHnne2t4/3trWScce+877/H9//N7fP93viMc+x4fvLOGd4Vjm4VzW99dy6bvfZd9a7+L9571xPscQhpzAUfRdYaU0Uzq45gzxLHamMoDZwbPO4v4ZLiGD0fM2Aw2fG5Wcdhfwn6fYnb7lLHVX8rWKxKPSHNQsOOB1ZwLrSE4WU9KQSPZRXayC+qFF14X1eo2rkXVcPKahGOBlRy9JhX2qzkdIFhgDeeDKgmILCMoPJvIoEiC/fy4dPokIUFhxMVkkpwhQWnsQqXvJS5Zx41bKgJj1MJWsFgN12PVBAr714Vjt4TzxZVO4SW6H6NlELW+z1OqurN3gbKqVuKzbERn24jJsRGb00B8rp3YLCu3sizkVbUL4wyg1XWgkjuxmdsZ6BnDae1GKbWhlNhQVJiQlWmRV+pRV+n5/7H31+FxnefaN/z/931tYpLFYMkyU9yAmWWm2IkpZpZtWczMzIwjzYxmRiNmZpYFlmVM0qSMuxuKu7vdv2/dy1EfN2/a3Xb3fZq2c+a4joWz1r1g5LnOnNd5xQbF4uF4jyvvHWer9HxW2VjwxpJFbFppy+43bLl84A1SPE7TpoimMi+b4sxictKUaNU11NV2kpMt2oCriUsoJTpGTXiUUppXU5BfQUNtB031XVToWmXT3XJdC83Ng2j17WTk15KtaCEtv4GkrGpyC+tfkhlNQ6hL28ktaCBf0UBtfR8tLX3opPMpcvTkppSSl1JCflouzjdu4rDhLd5cvIjDG9aQ6X2OgWIvHpb58qgsgGlNIDNlouxJqGgieVYdz9PqSKaronnaVMhIcwNV5c2yV05RcRNVVcKweILGhmHyC5tIz3pZ0lRe1kl3x5h8HcWF0riy6inIrSI7XYGfqxeeTi5kJWVTrm6kr22UmvJ2iqT9srKbyMptJkM6Tl6+dJyKLpob+ulvbGO6pYiPGhL4WAoxFSqaZ7WxcsmTIGmEebDo9iS6O01ognmgDmRUFSCFP6PKQMZKg8gPvcLWtauxNluKqYn03Vr6Nv6e0rONKME/UodvVDle4Tq8I8sJihUlT03Se9RJW9sD6fqaiUxsJiimAZ+IKvwiKwiMqSUyuZmWrkdU1I4QEl+HV0QtSXndBqLmywKRTPzsZz8jKiqK06dPc+bMGb73ve/xq1/9SlbLODo6MjExIStlurq6CAoKktc/f/6c+Ph4MjMz+cY3viF/RiwLYuaTTz6RyRkfHx/5s//6r//K1NQUJ06cYGRkhO985zs4OzvLBIX4nNg/PT1dJoIEkSPG9M+Av4SoEYokQXiJz929e1cmzF7Fw4cPWbZsGW+//basaJqFuKfiGVy+fJm5c+fKn9+2bZv8/MTz/zzEOrFN7CP2tbKy4urVq/IxPv98Zo8ttov9xP7r1q2T3ynxPD8P8bxdXV1ZsmSJvK+YimWx/s/BF533D13TLIkh7rkYkxjb7PnFvRJk4efvpcCfc44f//jH7JX+sb558yYDAwMcP35c3n/Xrl2/exbix44gJI8dO8ZXvvIV+Zg3btyQr332fRAky09+8hP58+JZzszMyJ/9PFpbW+X9BZEqxjl7jeK4Q0NDn+1lwP/beJWYEaqL7//02zJJMquCEaSKMOoVZTWFY3Hkf0a6CDXMrE+MUMQINUzJg0R0k1mUP8yjQvqM8JMRprcdH74kZUSJztR3BuWSnGc/ePiSgPnx489CzM98RsQ8+adUx/y1QpA2orW3uN+iS1SR9NzEMxT39j9/86vPnrwBBhhgwD8H/p+Kmjg60m/SmXKZ1pRrqMMu4H52F7vX2LLCxgpzYxvMFlpjvtCGRVb20rw5NmaWmBmZMvc1I+Z/ZQFGXzFmzv9HqGbMWGxpzVILa2zmm2D5+gLsjUx4Z7ElJzbbEnptN2WRF6iJOUdt3DlaUq7QlnqN7uw7DBY48UDlwbjaU0rW/aRkN4SZimj6y5II9k9iiyBqdvmwTPjV7AtkyZ4AVjp4sfN0KFfcs/CKLOKmRzJHzgax64g/2w8FsPOYL/f98olJr8bhPW82HvZhg7R+835fHI74cPKsF++fvIrDxm28vcSeve9s4NLZy1y55ce7V8I4fDGWg5diee9WDMEJpUQlaTl9OZpj52I4dCaSfWciOPJBJB9cjcIvII+c/BpSssvxDinghosoccqSW4T7huVTrO3AM0TBB3fSuelZwHXXbC7cTsTFO5uUjBpiY5V4uscRFJBJWHABPtK1BPokUFZSTX66SvakCfSMJ9wnlsTQBCJ8AnhvnwPrl4jnZIm9pRmLzM2kqaVcQnT7+EY06d606HKpVGjIjC8lIjiP2OgiivIr0WmqaajvIj+3mvgEoaJRkZSgRK9tk4kN0dGopKhKikYK8mvJzNChKKqkvW2YlrYRsvJqyMypRa2T9u8fp6auF4WilezcBtKz60jLqiM3vw6drp2uznH06jqKMorJjs/gvJRD7tv6Dmf27eLWuw6kB1xjWBvGuC6Q6fIQnlXHMF0WzENtIE8rI3ksojySR/oIHjWXMNDaKeVbdeQrGskuaqGopIMSVRtKdQvtHeP09T1Cq2mjqqKHgd6HVJe1UlpcT2FendzhSVFYT252GYW5etIT0+VSqATpd3tTeQNq6RlmSs8jI6dBupY20jPrSJeWszJqqdW2MNNRwbO6VJ7WRfOiIUYmaoQvzfO6WB5XvWy9/WFjskzUTJWFMaYKYLDIm5ESP4alGCzxpbvYF6/LR7E1tcdk/mJMjOxZZrse5zsBxMZpCAgvxTeyAp+oGrwiqvCPqiUstob8whY6Oh5SXjVAWn4rofGN+EXU4h9Th3dkHb5R1TS2TqIr7yW3pJ9I0dZb0Wkgar4MEInFb37zG8rKymRlTExMDJcuXZLJE6GKyc7OllUvP/jBD+Q/0kJ1I5JCoaARZI0gbWpqauQ/3uI4dXV1+Pv7y2SMIGkyMjLkY4ltIgm+ePEiGo1GJm+Eemd0dJT//M//lLeJ47i4uMj/CIj9/xnwlypqxD09ePCgnJCL8rFZCOLg+vXr8nq1Wi0/XwFB7sTGxv6OGHB3d5fPvWXLFvn8V65ckcvdZiEUVUePHv0dySD2FZ8RnxUkj3iGs8cWEOoosV4QHx4eHjLhJgg/cb7PE0YPHjyQ9xPHun37tryvIDbE58W67u7uz/b84xDnF9c4e03iWEL9dejQIXnc4v0S1zGLWRJDXJeDgwOrVq3Cz89PDjEvPvN54uvPPccsUbNixQoWL14sbxf37sKFC3z3u9+Vn4MgMl99DrPnF/dEkFviuLNqmMTERHk5Pz9fXn4V4jsiygZNTEzkeyogCNDt27fL1ymu14C/HmQy5hVCRsRv/1v6u/brn/3ON+bR90T754aX3ZMeJMulSNlDYeQOR8jlSZXThbKZrzD1FWqNthcV8rKINil6pM8Klc3ktwfkzkQPvzvCtHRMYer7O9+YHz+VCRgDCfN/I14qbB5+Z5j6JyqZrBHE2ac/ec6vZbLGoKwxwAAD/jnwKlHT3tpClSKdygRX0t3OSMn9Vna8sZwl1vZYmSzCeL4FC+aaYS6TMxbYmFpgPs8Ui4UWLLJazqoVm9jw5i4WW67EdL411gsssZd+yywzM+bNRWac2rQMvw92kOv1HpUxF6iNP09D4gU60i/Tm3OT4WJnxtSujJe6MaX15aHOT1ZTzJQHyaUvDzU+jCi9aCqIw8s9irf3ebPmoDebTgRz9EI0110zueOZw4Wbcew/EcS2g/68c8CXNw/6sl5M9/ux/WgA9zyz8A1VcOB9f3Yfdeb9s868e/wDdm3exs633uT43n2cP3eNc9f9OXxFOs6FMLZeTmTrpTi2XYxn96VETt5JIyKtkpBYDWcvR3Pig0guOcbj5pdFbHIZcUka3HxyuOmSzcV7mbx/M4VTt1M5K33uglMq7kEFJOfU4x6Qj6NrKi7eWUQn6EhK1uDvm4aPRwq+npm4u6VwxzEWd5dkgqRjRwRloBJtrbMURPiHERsczO0LH7BJ+n0oCDE7SwtsLc1YYmXKOjszTu58g0Sf69QXpVJdlE9BaiFxkUVEhihk/5msdB0JsUVEh+dTqpR+w3QMolE3oVTU0FTXR0v9gDxfXFgtTevJy66WckA9mVIU5FWhKq6hpbGfjvZR2Th4cOChlDt0oCipJye/iWwp0jJrpagnLauarNxqioul30n17eTEx3H24AHW2duzaZUN7mf3UBp1i4r4W7RketBTHMiILoJxfRQT+kgmysLl0qGp8nAeaCN41KRksKVN+j3fQm5RIzmFTdK0nbxCoeJpobCkHaWmjcamAcZGHvH40Ye0NfVSXtpESX4dioIGivKlKKiTrq9emq+TTZqrdeVE+PoQGxiKMk9Dfm6l3O0qNa2e9PR6srNqKZSuY6S+jpn6dJ5VR/O8LpJnUgjPnGc1sci+OWVh0voEmaR5qA9nuMRXesdfxmiJHw80QfQoPMgPucmuN9ZjavySpLG1XM3xg2c5dvAD7t7yIyQkh4AwFb4RlfhFVOETXkVQpJ7aulEpb+slKbWaIs0gGQU9RCY0EBxfj0d4NRFJjVTVjcsdr2JSm8gs6kNXMyblGQai5m8KOdGQ/vAKBYbwlxkcHJTLm4RyQBABQgUjypWSkpLkebG/SDYF+ZKcnEx5ebmcKAqVjVDfiGP19fXJXjZinVAJKJXK33nWiCRVJMJCuSAUBSKJFcmkSDiFF45QBwiVzaNHj+R9/xnwlxI1Ai0tLXLCLwgb8bzE8xH3WxxPqKBeVXuIcjSxryApRNnaLAQpIYi1V8kAsU48J7G/WPfqs/j000/l8wmSYWxsTF4nvIZOnjzJjh07fu/Yr45HvCfiOQtSTpBxQiUi3rtX0dHRIZMOgij8vFLliyDIDDEOMR4xrlmI8Ypxi/ELbyTxbgrMEjViPIJw+Y//+A95vcAs8fUq6SHw555jlqgR5xAE5+ffY3HPxPE+/xzEd0QQbOJzImaJGjGWP3RPxHdx9+7d8r0Xz0Bg9vwGouavh1lC5r9++1+ykuJffv5DKVF/IataOj+qlT1jRLck7VQmqvFkCkdjZaVM1aMiWU0jSpGGv9EhG/UK4kWUIglfGNF16OkPp+RlOaT5F3KHJdEG+4tIA0P8rUKok8SzEwbMQvlUNVMkEzi//PXPZfLOAAMMMOAfHa8SNa3S78/U5HTc7rqxae16FpmYY7bAHIv5VtiY2mK60BLjheaYLpCm80ywtrBhzeo32bb9CA4HLnHo2B3ee/8++3a/h72ZLW/YWHNowyrundhK+NU96MI/oD7xEk3Jl2XVTkf6dQbyHBkrvseY2plxnRdTen8e6gRJI6Z+TJR6M67yYqzEg1GVk5TguvBA5U1NXgSe7jFccUrkhksq153SOXExkl1Hfdl8wJN39vrw1r4AVjv4smqfD6v3e7Nurzcb9vuw/7iX9Ps1ldvXXTi0Zz+nD+9j79aNHD54mAtX7nD2djD7r8Wy9WIMmy/H8Y48jWfzpXi2XEpi88UEtkvzJx3TiU6tIjldtNXOIzZRQ3RCKZ6BBVy+k8K5W0mcvJ7IievJvHczhdOOiZy8mcB7N4R5cAqBESVoytrJzqmQvWFCQ/Lxck/DzSWJu/fiuOEYi9P9BOn3aCpuzsk4303A4348ydGZZCdL+1w9y5FdW1hta4v1QhOsTI2wsTRjuZ0l+zYsw/3iIdSJQdQpC1EVlBIXkU94UC6xUcXkZVWRnlhKdFguMREFZKbqyM8pR1lYyUjvOGODk9RWtlGUX0VOZgXZGeVy5GZXkJ9bJRM2uVmVKAqqqClvYXp8hpmpJ3S09KMpbaKwpIHswjrSs2tJz6ojK6+J1MxqaVkvfV5FSkQYjmffZd87b7Bt7SruntpNVfIdRqRnOybFcLEX3QWedOZ605HhS1tOIJ15gXQrQhgpT2SmTcOTkWEaavtQKJrJL2ykoKiFvKI2MnOayc5rIbewjXxpW01dDxPj00w+mGK4b4y68jbUikZp7I0UFdRTIs2riptQKRpoaxyis2mAklw14X7BON24SVR4jHStGjIzqkhLbZCuvYbOxmaeNhfypCZeigie1YhOVMLkWHjURPCoPJzp8ghe1CfI3jQPSoNkFc2o0p9JbSgT2hDGSgPoKPTg5jEHllksZ6GxDRbmyznk8D5J8fn4+8Zx8ewNKa7h6RVHcKSWoKgK/CMriEiskHLuKSn3biIoXCzXkZrbRkFJH/GZLfhHVZGR106JZoCoxEY8w6oISmikUDdkIGr+1hAJiFADCLJAlCmJ/xsviBqRFIqkVCSPIokXJUkiERT7i4RWlHwIokav18sJeE9Pz++IGpFgenl5yUSMIHyEGkGUcMwSNU5OTjLRI9Q477//vmxMLBJ4sU2sE0TN9PS0TNz8M2CWqPlTQuz7KsQ9E2SA2Caex+PHj+UE/fMKFvFsxH0XCb9QOn0eoqxm48aNMsEmyACxj9hXqFxeVZfMYpYgmiVfZgmQa9euyf+IvwrxTu3bt4979+7JxMgskSAIhs+XRInt4t0T5XevkhhfhFevSbx/n4dQBwkVy6tlQ7Pj/EOlRLPqlVnS7C85x+z1ifszS7bMYpak+kPHmy1ZE2OY/ay4J+fPn/9C4mWWfBOqt1mI75oglYSqRtx7A/40zCplhJ+MaHEt1BK/+q9fyiGIGdHOWShdWp+Xy0m6bir793xjRKtrUaokfEwEOSM8Y4RZr/A6kVUwBvXL330IJZMwdRbPWJg4V0wXyM9YdIQSLdENhI0BBhjwj4xXiZpGKfn08I9j30lnjhw+j731YpYuksJiMdZGVhgvsMTU3I5Va9azfddhDh67zo79N9mw5x5v7HBi9ZY7vLXTiQ8+8MHt8mUSXN6jOPg99BHnqIm+QHPSVdrTb9CddZuhIhdGil0ZlWJClDfpfJkSofXlgcpT2uYme9O8DHcpwXWXknhnhorvMVzkRF+hG83FCQT4xLD7uB9fO+DH+r2evH3Amzf2e7Junydr9nix2kFa7+DP2/u92XbEjXfPuHPrhgcOm7axYekS3raz5va501y95cG+iwFsORfMpnNRbL4Yz4ZLsWy4IEiaWJmw2XEliW1SbL2UxK6LiZy6m0lcWgWVVR2oSmtx9s3i0r00zlxP5OyNZM7eTuK9W0kcv5bEyatiXQrnbqZy4VYinoH5ZOdUocgrp1LfSmaahgDfDFydU7hxKxZHpwScXBNxdUvG8XYETo4RBHgnEReaiLv0O37Hm2tYYWvJYktLLBeaYvz6PGwWzudrtlbceHcLRQme1KrzaamsJjU+T8oFUggLLiQrRbTDLiM2vFgmbZLji8nPLCM3o0xWznS2DdLZ0k1f1zDtrYOUFNeSma4nJ/MlSVNUUEN+Tg0FWbUocqtpqetjauQh3a19NNW0MdgzSn1DL7nS59LzqkjNqiI7v56cwgYpT9SRmZqL880r7HvnTY5t3sTNY7sJu3UUZcR12vI8GVD6MakP5WlVDE8qo3moDZVClAwFy9GeH0J/dSndTV20N/Uz2DdNfV0/SmUL+UWtcolSXkEzufnN5BU2U17VxdDgJM31HdRVNNPTPsDk6DQ1FW3S9TagLGpApWhCV9pKW2Mf3e0jaJT1FOfWUpxTTnZKJnevXcHjnpP0rErJyaqjrqyBmXY1z+tFiVMcH9bH8bw2hmc1L82Dp8vDmNa/NDwWLbkFYSMTNdK1jUtToa6Z0ITIRsLF4TfY/sY6zE3spO+XDfa26/BwDSU+SU1wpIrQ8EJCgqI5/f45zp+7Q0i4gtAonXQ/hWnykLRfNYHR1fhFVxAUW0VUsnSvS7opUPVRXTMi7ddGSHwDnhH1uEc1EJfXZSBq/tYQiYkoeRKJoCiLEd2ehJJCKCMEYSPIGuE5I0o9RAIo9hcJtOjeJMgbUeYklDgicRcGwOKPuFBFiJInkWjev3+fwsJCOSEX2wT5IlQ2Yp3wzxBKAEHKCMJBJLGNjY0yUfP06VOZAPhnwP+GqBEQviabNm2SE3zx3ETi/mrJk8BsOYwgTH70ox99tvYPY5awEO/AF0G8F4LYEYSAeC9mFTXi3KKMaVbd80WYJSvE8cX0448/lt+NPxezY/giwmcWs9eh1Wrl5VmiZnbcn4cgaMT+s0TNX3KOWaJm/fr18o+ZVzH7HP7Q8cQPIEF2ieO9SvIIIubVcQmI74cgykR51avKJEGsCYJNjEGMxYA/DpmY+c1/ym2vf/qrf+MH//Et2fBXdEZqeaan7rFKLmPSTr009BVqmeIHSbLJb8OTUro+rpPNgce/3Scn8TPffyArYwQ5I8pmvijhN8TfbwhlzZT0nBueauT3QD2RKr8nn/7Lc+kd+oWBrDHAAAP+YfEqUdPQ0IR3QDQH373JiXcvsGrxChZbLMLecjEr7NexYcN+9h2+xO537/D2vtus2u4ohSvLt7uxZKuLNHVlhTTd4nCf6JBIylLdaE69Qkea6BjlSE/2HQby7zOicJNJmhGFK+NqL6a0PkyUCtWMO8PSumGFy/+ZFrkwVHifofy79OfepjvnNm0ZNymPu0bE/TPcvOLIodNerNnrzpv7vXhjtxvrhHrmgC/rpelb+93Zuv8eR47d4vDeo+zesIF9b69l2wobuRxrpakRh7fv4Nx1b7Z8EMJb56J5R4rNH0Sx8ZI0vRTHJqGkuZogkzS7ryTy7u0k3EKURCRW4uZfwK378aSllxGdqOPS7RTO3kjlrGMyJ29I+15P5v0bKXxwK4Xrd9Nw98knOb2a1HQdAf7J+HkmEBuZh6q4gfDgLO7dicbdI11W0ty6EYzj9TC8XaOJkpJ1zzt3Obh9G28ut2OFtRm2pmZYmFtgZWrCaktjTu16m0TP2yjT4shKzyYyJpeiklq5PCktUUNaSrmUF2rw9ckiIbaEovxqWUmTHK+kVFlNR2sfZepaiguqURSU09EyIK3rp0QhlmukqCM7o4Ki3Co0ilp6moYY6xmnobIDdVE1xTk6qjX19HeNUVvXTZ70uaLiRooUDeTm6EmJy+T0kXd5a/kq3lq8ksNvrSLN6xzthd40ZbpTm+SEPuomVXF3acnwZlAZzoOyaMZ04YyoghhQhTBcq6Stqg29rgNlcRPVFd2MDD6mrW2MEmEkXNJKsfCokaKiooux0Uc01HaiVdajlK6rqqyVztYhhvqmaKztQa9tRqduoVbad7j3AdXlrWiUzRTnN6CSrleRVUFuciHe9925c/0Gypx8BqtVPKlL4klVBM9qY2Si5kWdIGteGggLouahIGqk+UeVkTIxMya6PEkxrgn+3XJLtjvXD29hqeVSjObbYSzF1o37iY/LJzy6hOAYLSExesIiiomOyOLqxVucfPc8AX4JlOnaKBAt0eMqCIiqkLtCBcZUERAtPGzKyCpoo6/3McWqTsITavEKr8I9XNo/0+BR8zeHSKZF1ybhSyMIGZF0Cg+ZDdIfJ0HGCINgQeQIk1eRtIokWxArgrgR64W/jJgXCaRIfEWSKMgeYdIqFAbieOLYwtdGfFb43Ihyp+bmZvkPvTiXKHcSKg5RWiWOIxQiolvUX5K8/z1ilqh5NQn/cyE8agRJIo7zRebCswTFH1LIvIpXiRRxLEG8fD6EL5Eghl5VeYj3YdagWIRQ9YhnL1Q+ny//ESTEks9MfEWI+VlfI3H+PwWzJUGCpBLGyl80TtG9TBx/luD6n+6DeAZi/9ln8ZecY5ao+SKi5E95DrPvw6tEjfguifv96udmy54+XxIltv+zEzWyOubV/6S/cy9Ll379O7XML379kpj5/n98iyc/mJQ7JgnD3srpApmUKXmQLKsmCkZeEjP6h3k0PdPR+/VGxr7ZI/vHCFJGdAEydE/65wpB1ggj5+6P6mRllXhPKqfzZfXUL379U+mN++f4t8sAAwz458LvEzWNeHv7sGnjRlYsXc661W+yeZMDexxOc+jYbXYfvsvbexxZuv0etttcsN3qwaLNHize6i6FK4u3uGAvxbLNzhw76UJhfCQ9+T4MF7oypnRnQu0lTwVBI0iY0RL3l8vFrgwVOTMoCJlCZ5mcEfN9eXfpy71Db85tunKvUZ14hRT393E758C+DetYbm3DMpsVHDl4nv0nPXnTwYuv7fXlnX1ebD/ozd5jnuw9fJU9Ox3YtHo5b1iasN5qIe/YmfKmlTFLFhhjM9+IZVamHDh8kvNOUWw5H87G89FsOhcpRbS0nMjmcwnsuRLPBWFSHKEmPL4cD78Czt1K4OCleA5fTuKiYyoJ6RXEpOi5dDeN964lc/xqCieuSjnY7QS8A/OJTyolJUVNRHgeXh7JeLgk4uIUx/270YQFZVNa0khyvALnu3HcvhKFx91YAtwjcXd05eS+Pby51Ao703ksksLGZD6LjU1YZWnNkY3rCLt7Gm1GBCU5OcTE5eEZlINnYB6hUUo0mlaa67tISVIREpov5XFqcrMrSUvWkJWmo6qilYa6DspK6+VyqKR4NQU5lWhKamiuFa2sh9Frm8jP1lOQXUG9tP9I1yhDnSNUlzZQLK3Ly9ChKapFX1xPubKWztYBKS/sQy0dQ1tSTn5KCqf3bmP9YitWWllwes9G4pzfRx91lYakWzSmOdKc6UxrjgfNWR7UpbtSnepKVbI7tWnetBVFMFKvpqu+DY26nbz8ZtmsWK1qo0LfRVfXJF3dE3K3J6W0rrqyl9GBaVrrOylXNVKcV4ta0SDfY5WintrKDob7J+iTrqGtqU+an6KpppMydRPq4mZZZaMsaECRXY8yt06aakiS8mBFrCcT5dE8lluFR/KsJkZW03xYHy+TNsKbRlbUlIfLpM2jCkHUhMkEjTASFr41gqgRCht11C3pvVyJhckyjOYvwdZyDY7X3YmT3oHQKBXB0aUExWml962aqGgdiXHFeLsFcfXcDdzveRATlkt0jI6AyDK8w/QERlfiE67HN7yChLQaujsfUl4+RG5RN2HxNTJZE5naaiBqvgwQ5U2ChBHKho8++kgmaERJkjD7FX+Qxf+tFyoXYR4rEmmhhhG+NYKwEcSLIGYEWSPKMIQJrFDTiDIqoRgQqhlB8ggvG3E80YZb+HCIP/KCmBHeN+Hh4XJSKggbcdySkpLfM7X9R8dfg6iZJQDEcYQy6vNqJHF/xbY/haiZTfTF/v9TvErUiGRYlFsJkkd4sLy635tvvvn/6EAkSEBBfrxK2IgQy5WVlX9QkTOL2Wv6U+IvJWr+knP8MaLmT3kOX0TUCCJGEDKv3u/ZsqfPmwyLZy++g3/Ks/5Hw3//92/5z9/8p2zu+9P//Hf+41f/xr//8if85Oc/5Lv//g0+kZJsoXR58v1xRr/RKZcxVT4qkNsvq8ZTKH6QiHo8VVbQiG1yh6VvdPHgW32yiuLxDyY+85AxEDP/7CHeAUHMTHx7gPonpXLXLkHaPP3BpEFZY4ABBvxD4lWipqmpkaiwIM6eOMmJE1fZd9SRLXsd+dr2W6zZ6sjyzXex3+yE3db7LNoiwlkKFxZJ62w33mXpVicp7rFmjwvvXgolNiKNDlUKwypvHijdGFUKwkaUMrkyKtQyhUJd48xIsYtM1AwU3KM/z1FWzvQJ9Uy2Iy3pjqjDzuN3dT/HtqzjDen35CILW8xEKdZccyyNrXlzzdtcOn+Xfe95sPW4J2cvePLB+1d4Z+3brLC25a3FVmxcasUKSyMWG8/FZuFcbBfOZ5GRKbbGZqw0M2bXG6sIdnPGKySLXZeiWH86gk1nQnG4FMsN7yJCk4VSQcVt1wxOXUnkwPlE9lxMZN/lJA5K00MXEjh3M5GwRB1RqWVccUri/O1kfEJLSEkrJyYmnwD/FHy9k/FwS8LZKYHbtyK54xiFi7Svl2sqQT6pKAsqSZUS9TC/BEK9AzjqsIO1djayKfMiYxOsjI2wNF3AYgsjtq+2xe2Dw5SmhaHKSSUuLgePgCycvDPxDlEQEKUkLFZNeKSS7Jw66uv70ZU2UJhdTmaylip9B421XZQW11CYU0F2mobMVBU5GVpZNZOfWUFJQR1NdZ0M9I7RWNdBT8cQY72jtNS0oCmuJD9DR4m0r664jpK8Cgqy9PJ8haae2vJ6WirrUSXHUBzpRKLru3hfcuDGkc2EXj+MMvgcrWl3GSzyp6fAl7ZsN+pT7qCNuIgq5CIVcXdoyvZloCyJgfoKWqo70Wl6yFc0yYqZoqJWihRtFBQ2oSmTfv+1jDA28lT6LS1Nhx/S3dxHfVkHOlHeVFBLSaEIaZxSaErqqNE3098zzIdPP6Sva5AqbQva4maZqJHLogobKBX+NfmNqPNq6alt4EFlMhNaH4aVXi9bb1dFy740L+rjeFoTzeOqSB5VhMshyJpxTRAPSgNlBY0gakTnp3FtEB257rie3S77PC00Xoq5xUp2bj1IbGQasXHS849WS8+ujJDYckLiquX52PhSEuJKSU/Mx8/Ng/cOn8XFOZLgCBV+4eX4R4gOYzoCI2tIzW6koXFM9rBJy2iiUNVPQmYrOSV9BqLmywSRGIsQapfg4GC5REb8URakSX19vUyiiA41glgRpU5ivShlEi26RbIokkPhTSP8Z0TpklBGCH+NqqoqOSEXhquiVEMQMuIPvVBZiMRekDXe3t5yiE5SgjD6vALjHxn/W6JG+KiIeyuSdiMjo98z+Z3Fn6LkmIUoYRNGxJ8nC/4ciOcnSrKEb85sNyWhSvmi1tviHRMlQYKgm+1A9UXX8HkI4kdc859DSPy5RM1fco4/RtSI74W4H3/seF9E1AiI75hYX1FRIZMx4rv0qjfOqxDH+HPG/GXH/1HF/FZufS2IGEHC/OsvfsSPf/59Kb4nxQ9kMka0Ux77Vi99X2+i86Ma2j982RpbmP3qH+ZS9jBHTqhLJ9PlUqbSiTSqZhSyr8zgp60yKSNMY4XKRrS9NpAyhvhjIdRUQl3T/KxMVtYInyJhNC2UWwYYYIAB/0h4lahpbmoiPzeb1NR8th9wY8XWeyzb7IT9ZhcWb3bGVopFW12w2ypNN9/HeuN9LDc6Y7fFhVU7XHnTwYVjV6O47ZPFZa9Ujl+Pxdc7iU5lDCNCOaN0ZkgQM0XOjCqcGBFETaETg3mO9ObeojvrOp2ZV2hPv0Jd4hXinQ5x6cBbbF2zlKXW1liZWLBwrinz55ixcJ4Z1iZWrFu6krX2S3lzxRrOnrrIiaPv47BhA9vWrGC52UJsF8xh8YLXsV34OlZG87A1NsXO2FhaXsgq6XfpzhWLcDq2mVyfMzRnu1OvyMTTL4WdFyI5755CaEIZ/pFKzt1N570rCRw5F8XB87Hsu5CAw6UkHC4ks+tcAvsuJXL0egrnbieSJDxd8qrIztaTlqLF0y0Bl/uxeLsn4XY/gTu3orjrGMPdu7HcvROD401p/kY0/u4JxATFkhIVx7kjx9i8dg025gsxmzNHbm1uJeUDdlYLWb/UhktHNlEQ6YImL4X4mCSCInJx9s/lrncWnsGFBESqCIhQ4hGYT7CU9CemVqAqbaKlqR9tSQ09rUM0V3egKqgkPUVDepKaouwKinPLyc/UkpNSSmFWOSX51agKK2iobuOjZ1/n4fhDGqV5VX4F+RlaShU1aJUN5GWUkZeuo7SwGrUUhVkqlFn53D93liNvr+XohlWc37MWRdAlegv8aEhzQRlykSz3k6Q6HafQ95z0zO8zoAhkqDiQthwPyhMcUUQ5MdBQJY9VV9pJcUkXWm0falUn+QphGNyMurQbpVraruukvXWETz/+JlMPpmhr6KFC3UplaRt6VROlRcJ7RlxPHZriOvTqesaGphgdnmR68ikd0r2p0XWhV3agVrSiKmlBVVQnXVMLDdp6HtYV8bg6jvFSP0aLvaTwZVTpJ62LYqYmiqefKWqEN40gbCZ1wYxrRMmTv7zfhDqAYYUfg9Jn4+6/y9dWLsPY2A4T48XY2qzh0rlbqIvLyc0pIypWRVRCOWFxlQRFaomK15GQoicluYJybQtFORpCA5M49e4H3LzhQWSMBt8QLd6hFfhGSc+mpB1deQ+xyXUERuilaQO5Cun6Gh8ZiJovIwRBI/4Iz5agiD/MwoNElLCI5Fkku2JZrBfJk9hP+NZMTk4yPj4uly2JZH+W+BHKGfFZocYRU9Hye3abIHqEmkd8TnxeJOz/LCbCs/jfEjWzZU9CqSTMncW8KC971YNl1mvlD3mziOd57tw5uRRNKKFEm/b/zZhehVCDzHYzEiTdH4MgeASpJ/Z91SD3iyDeUeED86f67gj8uUTNX3KOP0bU/KUeNQKzYxeKJXEcMaY/dB3i+Yn9/tQysi8rxN8IkfD+7D//Qzb0/c6/f4MXP3zE+Lf76fm4QS5FEuoXUa5UM1MsJcm5cuclzWSmTMSUTohIQzWRKq3LkMka0YlJmMG2PNfT9/VGuRPT9PdEJyYDMWOIvyzEOyPK4ISyRpTKCe+iH/70u3K5nQEGGGDAPwpeJWqamloIDkrEyzcF7/Ai1u50w37TfWylsNnsgtVWNyy3uGC32QO7TS7Yb77L+gMe7D0XxFnHeG5553HqbipbTkWy4ngASw4H8dbBIBKjk+nRxDBcco+RYidp6sZw8X36C5zoy7tHX85N+rOv05JyjeKQDwi6cYB3d65jpbUppvNNmT/XioWvmWA61xhrY3OW2diyxNIWG2MLuduR+Zw5WM19neUW5qy1tWbDEmveXGTOEqN5WM15Hav5C7AxMsL89dexnjeflRYWbFu1CLczO1BGXqVP4S4l3x5M632YKA+nqTSb7FyNrKC5cDeF/aI999kodp+JZu/ZaHZLsf1MFNs/iGPnuUQcPkjkwIUEjl1N4pZHFumZeppqO6nQNuLlEYvz/VgcHWO4cS2cm1fDuX8nDhenBO5J0zu3YnC9F02QVwyRfpHcu3SNrevewN7EFMsF0pjnzsVs/kJ5fo2dGUd2rCXR+xo1hXGU5BQSFp6Du18Wtz0ycfTOwiu8GK/QIjyDCvDwz8M/UkF4oobIeDUZWeW0NQ/wePIxvW0DKPMryEzWkJmiIVcasyhryhfTzDKKsvQockWUydfR0z4sd3R6MPKQlvpO6bN6dCVCqVJDdqqW/IwKtLL6pJzijGIyoxO49cEZ1i+y4w1rc45tXEaa+/v0F/lI9zmYSV0gD6ToK/GiMf0e5TG3UAZdpsjvHLkepygKuEy7OpKp3jomhx/KHjIliibU6k60ml6Uyk5y8htlDxaNto9SaX1tdS/jo9K1dQ4z2j/JSP+4TCpV6VrRq5qlMVfJY9QVN6AprpCup4fhgYdUVXRTXzPI2PBj+rpGqS3vpKykDbUUSmUrWuk6h+ormKlNYKYyjBnpHXlcHs2UJoiJUn9pXTiPKiPkUidB0IgSKKGomdAEMlUWwoQ2iFGVMBL2Y0TpS3ueF1cObcXazI6FRkswM1nK5g27iY9JJzdX+g1c1U2JsonktHIiY/WERGiIitOTkFwld56qr+knN6OSWKG6Ccrg1jVXKd+7hbNzJIHBKkJiytFVDFCsbiMsoUb6LlfKrb29Qsoo0Y0YiBoDDPjfEDWCIBMGwrMKlFl1jThebm6unOgKiGReJPXCb+WLuj6J8jZhSjub+M+W1YiORl9UhiZUHKKc6cqVKzKBIVqyCzWMUFvNnvNVzF6jIGoE4XDkyBFZtfPHyJL/iaiZLQcS4xQKr89jVnXyzjvvyASWwJ9L1Pwl5/hjRI0gTgSB8oe6PgkvJ+HtI8bweaJm9hkKokeQc+IYf8k782WGrJz5TD0jlDM/+fmP5FKl0dluS48KZRNfUaqkmciQiRj1eBrqiZdROpkhEzGChOn6qJbejxvp+3qz3Bp74tv9PPzOsKyWEQqIl2VMBn8ZQ/x1QpA1U98dksnAgtEY6d1r4Ce/+KGsAjPAAAMM+EfAq0RNQ2Mz3n5JHH7Xk9CoPG64ZLJ6pwuLNjpivVUQNaLs6Q7rdzpz8EwoF++ncMk1lcM3Ytl0OoQ1R/2xP+TPogNBWO31ZZEUyxwC2XXSl7TEZAY04QwKf5oiKfLv05t3j9as2+hiLhFz9yiX9r/FlnXLWLLIFlNTK4yMzFkghamxFUss7Vi1yJ4VNouwNTbBcp4xZnOMMJ0zj0XGxqy1W8TaxbbSNiPsF8zFZu7rUszFet48bBYYyQqatdYmnN6+mqjbh8n1PElVzBW6cu7JpVjjKjcm1e5MlbrxQBdKhzYbV+8U9pyNZsvpaHacimTb6Si2SrHljDT/QQw7LiayS5oevxyDq28hcYl64uI1+AVKn3VPJDVFQ0F+FW6usdy6FcEdxzjuSXHnZpQUEbg7xRDsnUSwVzhXTp1j36aNvGFvxxIzc2wWmmNlbIaViRnLrYw5sXUdsc6XUSUFoSvIobaqjqSkYjz9svAILMA9uADXkBzcQvJw8c/BJ1RBWIyGkKhSoqQxKdVNtLX201zXRmNVI90tvdSWt1GUUymXOWUkl5ISXyITNcq8KvIzSilX19PZPEhjXa9cMqUuqaWirJX+7jFG+idlZU5BhpYSaX9Vfg1FmRopigh2cePo9q1sWLmMTctsufXudrTxdxlV+fKwLJAnleHM6EOZKA1gUhMgTf3kqeiI1F/kTUeuF7U5oXRW6umo72RocIKR4Uc01vdRJkyEle3kF7Wg1nS/JGm0PVRX9TLc/5Cm2m5p3C1ytDX08WBoSrqGfnTKWiq1LZQpm9AW19Ep3Yuh/nEq9B2oSjpQK7tkX5ve7nHGhh7R2TRMuUaYELfQrNfRUhDFkDKcsdIIpivjeFQTy0x1jOw381D2pAmV5kOY0gkSKlheFvMPy0Lk5eFibybKAhgu9SfV/Txvr1gpvdd20jtuh6X5ck4c+4DMdBWJyRoSkjSo1K2UV/aTkV1HTJyOmPhKYqXQadupqewhNaFCysNKiYhQExNdhJ9XBBfP3ODSOSfCInKpku5HWlY1vhF6fCOr8YupwyO0nLTCbgNRY4ABfylRI9Qns625X/WlmSUjRFnMq92AZsmXo0eP/l7ra1Gedvv27d8jI2bbTot1wrNIEECzmN1fnFeUNomkerbzlCAZHj169NmeLyG8aASZJLYJIkIoeoTiR5BLokPYq8SOUF+JDmR/iFD6PMR4xRgdHBzksqJZiGOKY4tzvFpy9ecSNQJ/7jn+GFEjIAg18Zk/9BzE+UV8UdmZKHsSYzlw4MDv7uc/CkRC+/Nf/0xWznz3P77Jix9Oy2atwsRXqGFE6KayZCKm6alWJmIGP22TFTFCYSPIHDGd/u4oT34wwbMfPpTVN4KMMbTHNsT/jRDv2cg3u2RFl2IsXn4/hUfSq3/jDDDAAAP+XvF7RE1DM24+8Wzf68Sh/U7EJGrZezaUVbudsdvhxNoDbrx3K4a7gflccM9g27kQVh/1YcnBABbvD8DugD8me9wx2uuO+R5vrHf7YOPgw/JDoRw5H0h5UTrdCn9ZRdOafp3CkA+4dXwze762krW2ttiZW2JiZMaCeRYYzbHGeK6ltM6WVYuXYm+zSCYuLOYLpYkZxnMWYvTafExfm8dKaxtWWFhiOnc+JvOMMJs7D7N587E2XshSswWsX2TGBYc3SXM7SXXiNdqzbtCdfYOerFt0Zd5ksMiFMZWHbHb8UO3DtNafcSm5ripJ47p7PBvPRbHhRDhvn4xg89lYtp2PlaYR7LkUz/n7aSRmVMpGvR7uyVyX7s+ZC6FcuRaJ8/1o8nJ05GTp8HRPwPFmNNevRnD3diTu0rYQ71jcb95j51tvytdvb2EhXeMCWSVkZ2zOcqH8WWuHz5UDVKWHo8vMIjY8nsSoXNTF1ZRXdRISqcAvuAjPgCJuumfiHJBHSJyWMCm59w9VSAl+KfX1gmzpolwtvGSqKZLGpJfm+9r7aazuJiu9TCZqhIpGlV9FYaZOJjaG+yao1jejUTVRXFhDUV4VBbmVaJV1srqmt3OICk0j2uIa8tOKKUgr4O6VK2xct5z1K5bz1uIluJ3eTWu2Gw80/jwqD+ZJVRjPayKZKQ+RIpRH+lCmy0KYKguS7nkQQyp/xioSGGmtoaFSdHXqpKqyXfr9PM7jRx/R2jREiaoVTVkvWl0fGm2PNN/D5PgzOlsGqdS0o8ipQV0oxtVCXUWPdB3jdLX2UaltpqK0mdbaPiZHn1Gl76JU2S4TPypVO6WlwgOnk/aWEaYePKW9cYD+hg4m6gvoLgqgNvk+NUmu1KZ40ZIbxIguhvHyWCYro5ksD+eBNpiJMkHYhMnkzAN1gKyqEaVPg0Ue0j4hdBV6ceeEA3bWK1i40EYKa5Yt+RqBfrEkxSuJjy8nNl5PQkoFmbm11NQNoi3rJjm1mqgYPZ2d42jVzSTE6WX1TLS0b0SklqCAXGIiMrh3/Y5c/hcemkRCkh73ACVB0VX4RVThE1FJbEazgagxwIBZouZPDbG/gCAJBKEhyplEO+xZiKRAqGnEvqLkSKhCBASxk5aWJif6gigQfkPiWLO+MKKD0aveQC9evJDJCbFN7CP29fPz+53njFDEzB5bnFO0BBfHFp2fBNkijifOIc4l1r/aMlyYTs+uP3bsmGxG/eqxPz+WP4RXr0mcVxAw4rNnzpz53XWKc83iLyFq/txz/E9EjTieINZmPyvu0ey1C1XTihUr5DGKsX4erypunJycfo9Am8XsNf6hY3xZ8FI581t+9V+/4Ec/+56U6D5l4tt9MgFT/0RF2VS2XLIkFDRNz7Sy54wgZYQi5vH3x+UW2rOlSiI++vETAxljiL95CGJQdBBTjadSMp4sK7lE63cDDDDAgL93vErU1Dc04+odxzvbHdm87TZO92IIjynm1LVQLrklcN0njXfvZbHuTAS2h3yw3ueNqYM35nt9sXDwxWyHF5Z7fDBz8MTc4eW8+S4f7A+FsudyDNGJOdQWxJHh9T5Xjr7FWyvsMDM2Ze6cBcx7fSFzvrqA+XONsTKxZomFHYsW2mIx3xqzBeYsmG+K0QITzI1MWWW1GBszKcmdb4LJnIVYS+sXm5iz2GwRiy3tWWy1iKWWVryz1JqrB98k2+cUzWmODBa6yOqZYcV9+vMdGS1xZlQpWoHfl6cjJS4MFDnJ85NaN0ZKvSnKSuTM3Vg2nophsxS7zkRz8HwU5++nEhKnITWrkqCQXOl3ZDjnzgVx+kwQV6/HcONGrPR7PYK79yKk3+8VZKXruO8YibtzFEHe4bjfceHQjj2stF3EIlPpGoyNsVwozIKNWWphzLYVi7m2fwe5IU7UKdLJjcsgOjCdkMBsIqRpclQO1bomKiraiYhV4uyVh3ewkuAoNWHRpcTEackvqKW1eYi6ynZK8sooytTKChjhQ6MuqqBS20Bv+whtjX1oS2pR5lXK3jONVa30d4xSXdaKSlGHsqgORUE1eaLrk3Qtivwa1IKsaRugr2NYOraOvMR0rr9/kjeWSr957ezY8+Yqgq4cojffgxl9MI/LQ+UuSTPlYfLyjD6IR+UhTOtDmJANdwMY0wfysDWf6b42Whu6qRStsksbKde3U1PdRXvbEJMTzxnom6K2uht9WRc1Nf08GHtMd8cIVWUdaEpaUBY2UlzQKI27CUVeLeXaVpl0GuoZo6NpQCZpaqt6KC3tokTZgVLdJZdQlSg7USm7pXP2UV8/wMPhCSaadExXRPFQGvOENphxbSj9RX60pLtQnehERaILVWneNBdF0l4SSV9pJKNlMTwoi2RcE8qELpQhlS8DJR6MavwpDLvGhlX2mJstZqGRDRamtrx76CzpiUpiIkoIC1MRHVtOWJSOqPhyUjJq0FV0U17ejaq4meHecXJzqgkO0xIRo5NLo8IiyoiKKiM6UkVMZAHBAVFcPHuN2zc88JXezeDoCgKEd01oGTnKLgNRY4ABfwlR8/3vf19WZIhk/4tKcmZVK2L7qwSJmA4PD3P58mWZdBDbhddJW1ub/A/w5yGImMzMTLZt2yafe3Z/0cXr8ySBOPbU1BRXr16VCQixv5iKZbF+dgyzEAoU0RFstuuTGI8Yc2dn5xeO5Q/hi84rjimO/Xnz4r+EqBH4c87xPxE1AuL6xHUKkmqWsBElUWJ8Ymx/iGQR91wQNOL8Ql3zRfh7IGoESSM64wjz34ffHab9RSX6qVy5lEk7mSmTNBXTBXIJ0+g3u2Ri5vmPpmUyRhA6X5QgG8IQX5Z4/sNp2UNpthPUpz95zn/99p/HIN8AAwz4x8TvKWoam3Hzi2PrYReOfRCMm08GWQWVpBTpcbgQysrjftgd8cb8oA9m+30w3/uSqDFzkOZ3S+t3eWGx2wurPb7Y7w9k3fFg9t9M5KpPLje8MznvFIOLRwTvHznBYlMLTOZZMvc1M177yoKXJM0cYxZZ22NnZYeNiQXm88wxnWuGyVwTTF83w9LInLdWrebQls2sMF+ExRwTrIxMsTGzYLG1LSsWLWbjMnve3/YWAZf2ke31PrXxN+jLEabFL1uCi9bgI9J0oOCutOwkx1DRPSnuMyiFWD9aLBQ27jJpU5fhTqz0G/3E7Xj2XIjkumc6oTHFhIYX4uKZwcVrUlJ8JZKLl6Rt12O4fi2GS5ciuHghjItXpeVb8bi5xJOeXEBKXDp3rt7izLvHeGv1chZbWMoqIdN58+WwNFrAelszbh/bQmHIXcrTI8iJiicuKImY4GxiArMJ908lzC+Z+PBs0uILUSmqqKruJiWznGAp0fcLKCI7q5bqqm6qylsozi+nIKuMwmzdS8+ZPD35mRryM9SoCyvl8qa+9mF6Wgep0zcz0DlCR0MXlZoGypSNqIsaKCmqpbiwWiZrivKrKMirIS+nCo107vqySpIjgjmyayvrl9qybpEZRzeuJMvvCv3F/jzSB/K4PISnokOSFDP6MB6VhTCtC2FSG8jDsmCm9EGyN9Dj9mImelppbRAtt9vQljbJJI0cZW2U6ZplM+QHI495OPGC9rZBRkce0dv1gAppu7pEGq/ctalFGnMTBbnSuPPrpOUGKnWt9HUO8eLpR4wNT1FZ3oVa1YVSCoWqkyJlB4qSDtmsuFTTL52/lcbSEmoygunM9WaoJIhxTcjL9traIB6UeDNS7Mmw0o8+hT8tWV40ZvnQkONHdboHVake1KZ605YfTFtBAAPqcOozvLl6eCM24t1fuARTKd7+2jYigxJIiMwnNkpFRISKyBgdYVFawmPKiE2qID6pkmJFC31dEwx2Dcut1YNCVUTHlRMWqcM/SElMbDmRERoiQtTUV/WRlpiHk6M7l89ews83mrAEndy+OynD0J7bAAMMMOB3mPWhEQbG4ofQ5zHrcSOMoYVB9N8DZj1nZkN4z3zvP77J5HcGZaXMy7KmTLnEqeGphu6P6z/zlBmQCRqhmvmiZNgQhvgyx7MfPJRL9ApGoml7UcG//vLHBr8aAwww4O8arxI1jU0txKUW4B6azwfOaThcjuLQrSgyVXVccMmVlTGmO11ZuNsdIwdPTBy8MHfwwWy3n7TeB4s93tju92bDeyFcdJcSxZASPriXxJ7Tfmw47s2qAx5sOubJmcv+rFyxAaN5ZsyfY4S5iRUL55uxQBAyRlISu0CQFyZYGJlitdAMO3Nr1q5Yw4F9Jzj3wT3u3PJl2zs7sF5owSITa5ZaLma9/XKOb32TJPcPqIy/SXumI4NFrjwQrcFLfBhXSom1TNS4MFzkTH/+HQYKHBkovENf3i16cm/QX+TIUMFtab0TfQVSsh1zC68PDrFv4xYcb/oQFa0gJDyXe/djuX4zgffPRXDqfBTnLsZw+Wo8Fy6Ec+qUP1cuR3LzVjxXrsfwwTl/XG4HEejuw/uHDsreJMusrLAyMcdsgSkLX5+H2etfYbnZPI5sWUnwzQNUpoVQmpRGtF8GkcFZREgRG5ZLTFA6IV6xRAWlEhOSQUp0Ackx+RTmaGhq7CY9XYO2tI2mhn5KlbVye+3UeBXpSSpyhZomp4zcdDUFmRrZJFijqEZTWIG+pILxgXFeTD+jvb6NurImdMU1UjRSmF0hEzQFueXStIrCvAq5lCs3TUN5UTmB9+6x9+01rF5kydcWW3N570ZKQq4xoPBmqtSPJzJJE86jslAeV0TwSBA1UkxLy9OiREiajpdH8LhDzWR3Jw01bVRUtaPTtlBR3oFW00yZrhWNupHqyi4q9W3U13Qx0PuAj198nZHBMZrqutFr21BJ4y0ubECrapeJGoU0X1xQh1ohiJo2nkx/yOjwOFOTT+jumqRc30upphO1FIXFLajUXVJ0S8eop726iqbCcHTRN1H4XaTQ5wrqsGvUJDrRXeDPYEkwA8XecgcnYRA8KsVQsR9DyiD6igNpyfaiIdMPfYILJeHXKQ6/TZLXTc4fPSiXPZkZr8DGci1HDp4iIzGf5NgiEmLVRMeUSu9YCWHRWimECXQZMbGV0j2vZWRgmta6Xmore0hOLpP21RIeqSMwWE1klI7oKC2J8Vq62sbJTC4lNCiHsIA40iLD0Rdlk5mmIk/RYSBqDDDAgH8eCCLG2dlZ7rD1zW9+87O1/wezXaFOnjwpd+L6PGZLn4SB8awn0ZcZgpT5j1/9Kz/86Xf41r9+LCsLpr87TPMz3e86MdXMlND1UZ3cFntGKGd++PBlSZOsnvniJNgQhvh7iKnvDMnvePGDJNlo+Fe/+eVn3wwDDDDAgL8//B5R09xKYFwOG08HsOSgD+b7fLE57MfB69EkFbSw7VIslnsCMN7lxUIHL0z3+WCy3R3r3d6sOhzA7ouRnPdIwyk0j7P3E9l6IpA1Dp4s3eXKol1uLDrgz3LpuFuOe3PyzH1Wr1yHrYUF5gstmD9noRxGc00wnmeKmZEZy+zs2L5pE5c+uMLlu4EcvhjE5vek85wL4dxVL95Z9yb731jO/Xe3k+N7geYsV4aVngyL8iWFKw9K3GViRqhlhhXOMkEzKEiY3Dv05wtFjVh/j/68W/Tl35aSb9GF6i76qOv4XzqEw7pV2JktwsTIjjeXv4XrLS/uO4Zz8j0fTp0N4cKlGC5eieXMB+G8fzaUM9K4rlwRyppoLl8O49JFb+5evY/7tetsX7NGNgm2MzHB2sgEiwXmUphhZ2rCrrWL8L92mNJEb3TZyVJinUqITwohIdkE+qcTFphJuDSNDsokIiidyKA0EsKyiQ8VBE4mWUlFdNR3MDU6SXdnP7lZGlIT1VJoSJcS9sw0aZqiJi1ZRVpSCSV5FWhL6uRyp3JVDSNdg4z1DDHY0cPU0ASN5W1oCmtQFdSiLKxDkV8lK2ryssvkUOToKMkswN/RkZ3r3mCNrR1bVy3G58I+2rO9GVK480Ap/H785ZbUo8U+TErzD4XJrkzQhLw03hVETXkMH3bpmOrppam2i8qabkr1LejLXyppXpI1QlkjVDbSsq6N+uouJscfMTMxI3ew6ukYoFzXglbdgrKoURpvvTTeJrm9dqkUlboOhvof0tf9gKqKDmqlc4yPP2Ogf5Kami7UatHi+2UJVKkguvT1tBcn0ZXny4DCh74iX7pyfahPdkETfp0C/wvk+V8i3fsiJZGO1KW70VXgzaDSV9rXg36FJ73StK/Ym4FiLzry3FFFOXJy5wbWLFuNvd06Ftt9jbfW78TbPYTqsmaqytpJTdYSG6chMlZDRKyWiDgdIVEaYuLKUJY0MdAzQV56hfxM6mv7KCxsJDq2jNBwaZ+YcqIiS8nPrZHuTy8ZyVWEh+oID1dSklNKd0UJzapM+hrK+O1fOdcwEDUGGGDAlxZCUZKQkCCXLikUit8r8RJlTbNt0WdNmgWEp43YT5ShBQUF/clGy/83Maua+cWvfy77zXzjJx/KHjLCn6P/k2Zan1dQ91hJ9aMi1OOpsn+HMAUWXZmmvjvMU2lfYcT6RcmuIQzx9xqCcBQlUEVj8fL7LtrL/8bQstsAAwz4O8WrRE19Uwv3gtNZfCwQYwdfjPf5Y7bfD9uD3twOzMczVs2qY+FY7QvAco8XSw54sfNCKGfuJ3LZPZ1Td5LZdTac9Yf9WLHfm2X7PFns4MFiaV87By9s90nTPZ6s2ufD3lMB7DtwFktTS9mXZv5cI9kI2NrEgjdWvcH+vfs5/cEt3r3oyZ4zPnztuD8rj/qzQhrb+hPBHDgfiutdLxLunaEy8jx9uY6MFt1jVHGPwRxH+rJu0pd9k57Ma/RmX6c/9yaD+XdkomYg765M2jxQujAm2oUrnOjIcSLH5wx3393BvrfWs8JmMVbGVpgssGTBfCvMTGx5e+0GHG+4cfNGEBel8587G8r7p4M5dTaYi5ciuHQpkvPnArlxxZfrl+5x4tBRNqxdyTo7a1aYW2C30JRFCxdiY2yKvak5O9cux+PMTtThH1CXE0xWdDyh3smE+KYR5JdGgE8iwX7JhAekERWURXRwDpFBOUQHZUvzGSRF5lCYqaKxql02/dWpaqRkfpQyTQNpiSoyUkrJztDKZE1aUik5meVkp5dJyb6U+BcIL5oWelt6aShrpFxRTnlxOc0VTQy2D9JQ0SHtI0qHqinOrZJDkaNHma8lPiSSM/sPsHnlctYvtmf32mUkuX5AZ64nEzp/Hopyp886O42r/aXwkdYFMFUeLG0PYlIb/DIq4pnuLOP5xChPJh/T1txPRVUnlTW9VFd3y0TNy/InQdI0U1PZQW1FO2ODUwz3DtFS1UxXYxeTQxM8GJikpaaH8tJWlEWi9KkZjbKVcm073W0j9PU8QKdtpbS0A7VaOl5FJ12dY4wMT9PaMoC+rB21qoO68hYGqpQ0pXmjDbtGgc8pivzPoA69SHXcTZpS79GR7U53vhdNGa5UJTmhib1HYdhtcoKukeF7gVz/y2hj7lCX5iLte5/2LDei7p1l7eLF0nu0COOFi7AyX8a7h8+QmVJEaqoanXT+2tpe2VcoObWCiBgNkXFa2WsoIV5HnXQ/Gqo7yEjSkRSrkp6jnlJlszTmVtJTqogIUxMXo6NK3yOriBLiygkN1RASrpGOVUZKspqKkhLGOmoNRI0BBhjwzwXxA0d0iRKEzKFDh2Qj5VdNnV81aRYQnaZmTZZF3L179wv9df5W+K2UeArVzCdSYjr2zW7aXlRSM6OQ22crHyTJbbOFT4fwnKl+pHipoPmwVi59EuoZg3LGEP+48VQu36t5rJTJmr5Pmvjpf/67TGwaYIABBvy94VWipq6xhduB6VgfDmD+Hl85jPZ4YyMtbz0fSUBSGZe981l72I/9FyK55Z3N3cBsjt+IZOt7/qw/5MeK3X7Y7/Ri6V4fbPd4YbPXC1sHDxbtcmfxPj/spPX2UnztoBdnL7vzzlsbMFtojKWxCcvs7dl/+Chnrjlx9LwX29/3482Twaw4EYLd4UBspXHYHwlg5bFgNpwM5/KteErTI6iOv0R/1k1GC+4yrrjHRLELQ3mO9OfekomavuwbDObfYzDvPv3ZjtL0LoMFovTpNr2Fzmjjb+BzcS97165ghYUd5kZWGM03Y/5cC+bNMZPCFNOFlixfvJTN72zG0z2My+cDOH3CjwsXojh/JZbT58P44Iw3d28EcOb4eTaue4PlNuYsMn3ZfcrG2EwOe1NT3rAx5cSmVWR6X6Al7Q7DhffoVUZQlptLsGciAR5p+Lqn4u+ZQkRgBtFBWUQGZBIuSqECs4gJySIpOo/S4hqa6vrIzS4jOjZfSvhLKVFU0dk2jEZZJxM1SbFFMlGTk1FBXlYlOWla8tLUtNV20dPUTZW6CmW2BkWGCnWuDr2igsbyRoZ7RqmtaKE4r5Ki7ArZhLg0X0eUfwgHNm/la0uXsd7OhsPvrCTa8QTDJcE81AUwUxnEo4oQZirCZOPgCU0Ak9L6Kb0/U+VBcjekiVJpWh7H484KBjs66WjtZ3R4Wu7c1No8QG1NF9VVneh1LVSWd1Be1kpVeSsV2kZGhClw1xCt1S3UqGup09bTUtXCeN8Y0yMztNb3UaXrQKdup6y0lbamPrlkSChptNoOFIoW1OpOtJpOudV3R/sI01PP6eudoL66h3a9lly/S6iDpAi5SGW8Iw1prmjCr5Hp9i4Zrkdl8kaorurT7tJZ6EW/KpDuYj/qM73JD7qNz4VDeF48TMjd06T5XCIn8DaXDu7BTnq3jBYsYsE8a2wslnPt4l2y09XEJ2qIS5KenfTMmpoG0WhaiU/QEhenl55pOVkZVbQ1D6EpriZd2i8+uoSEGDXJCWoKcqule9RNXk4NiXEa2htGyZI+ExaqJiREQ0CQhuDIcoLDNcRHlVBf3slvDaVPBhhgwD8bhMmw6CT1p5g0f/zxx+zevVs2Wxbt2P/lX/7lsy1/W/z2t7/hJz//odwKu/frjb9Tywi/mYrpfGpnSmh+qqPzwxr6P2l52T77W/0vFTQ/EAoaA0FjiH/8EO+5ePeFikw7lSW3nRclgQYYYIABf2/4PFHjGJiOzZEgFu71w/RgEMYHApjvIFQ1AXzgnEhVdSehKWru+GZw4Gwg6w96s3SfJ3Z73Fl50Bf73V4s2eUlTxfv9cZ6ryBrPLHfJ23b48PK/a5se8+Noycd2e9wmLdWr5ZJjWOHT3Lhhhf7PvDjjcOerJHOvXx/MMsOB7HseBC2RwJZLI1riTRddjSQVUcC+NpxP+64RlGRFUN9/DXqY84wlH+HKaU7kyo3eV6QNEMFdz8jal6WOfXk36Yly5HCoAv4XDnM9vWrWGxug9k8S4zmLpJiMQvn2DJ3jjkLF1iw1HYZthbSdiNjjBcYs37tBlzuB3PtejRnz0dw5pw/To4hOF66w7avbZDVMqKT0yLjlySNhbGJtGzCSmtT3t26lkTX0zSl3JXGco8RhZM0Vne581G/JoGqwmIi/JLwdkkh0DuTIK9UIvwzCHBPJMQ7hZjQDClZL6JWJjKaiYpSEBhSQFhMCRGxJURGFZGepqK9dRBlUQ3JcUVkpqrJTtPJnYXUheUMdQzSUtmCrqBMJmfyUkoozFBTmK5GmaNDlVtKtbacB4OjNFe3y9vKFGUEuXmxYcUK1tnasd7ehnN736Qs1lFuQ/1Q48fj8gCeVocyUyk8aEJ4qAti6rOY0PrzsCxIinCmK5N53iv9jmzroq5mgDJdFxUVXQwNPuL5k08Y7BujurKVmqoO2ZOmuvylkkaQNKPStqbKRpr0LVQUV1OjrqdaVUdrVQvDXcN8+Phj+qTrq6/sorVpkJnp5zTW9aNRt6Moakar7Uat7kJT2ota1UmFvpumhj6mxmd4NDzAg5pseov8UYddIdX5OOFXdxN/bx+5fu9THneDpgwXGtKdKI24SLbrCTLuHyff633Koq/TkuNOrzKEYumzGd7vy2VReaH3cbt0hn1bHdj0jgOrVmzExnIVb72xg+iIdOLjSoiN1xETpyMpqYyc7FpZWVNX1yfNV5CWqkWpaJCuoZecdB1pyWpio6VnHaogNkpJnPTck5OUVFV2S/erl+7WByRGKwkL1RAYWEpwqJqwKDX+wYVERZRRmGPwqDHAAAMM+LuCUAOIRPNb//p1ej6qRzuZRcmDZLmNduPTl220x77VIxMygsR59sOHcsviD3/0WC5veqmgMXRuMsQ/T4jvQNuLKllV0/ysjB//7PsGY2EDDDDg7w6fJ2puBaRhe0wQNb5YHgpkxfvh7Lkey/v30rjmlU1wZAHZilqOXApl9UFvluz1ZOleMfVh0S5PbHd7Yr/HEztB1OzzxW6fFyv3e+Lwvg93nPyJ8PMgzOUa104c5b0jxzhzzpFjZ93Z9Z4nbxzyZMV+H1Yc9GeJNLU/EMCSw4EsPSrFkWCWHwqStgVK00BWHgrgjeNBnLkdS35GPl3KeOpTblOfcJHGuIt0Z96kP+c2g/mODBfepT/3Nn05jtQmXCfF4wy33nNg2xurWGpji6XpIkwX2LBwrg3z59lgbGSLjfkyKWwxnm+KyXwz5n51PnNfM5I7U1ma27Bz217u3/Hl8gUnzr13iYsnTrHWfimLTM2wNjLGYv5CLOYuwEqaX2xuwtaVVvhf2Y8+9gadWfekcTkxVuzKpNqDMZUr40oPJtSBDGml317ZL7s7ebok4ueWSIB7grycHJOHWlGOTl1HVoaWqKgioqJVhEoJu39YEf4hBQQG5xEbW0JOlp6m+l5qK1pRCDImQ0W1voHWunYqVFUU55RSkKkmP71UjoIMDYWZGvJSlZRkaVHn6Sgv0dFR10h2fDKOFy6ydf06VtpYsXHFUq7uf5uyaGEaLF2DzofHlcE8qQ6Vp4/0wb8jaERnpymhotFIy/pwHtZm8bi7ib7WbmqrOijVtqMt66Kqso/G+gH6ex7wcPIJw4OTNDf0yH40jbW9vyNp2uvaaJauqU7TKKtpatQ1NOiaqC9rpLmymYH2Pp5MPmJq5CEzky/obBuhqrwHVUmbXNqkUrWjVHZK0YVG04OmtJsyTRvdTW1MNhcwXh4qGwP3FbkyqPanR+FDY7oT+ujrFAdeJdfrPJmep8n0OiXFGYpDL6MOu0hp6HlKgs+jCL5CvNMxUtzeI83jFIG3TuGweRPWFkuwtVnDiuXvsG71Zm7fcCcpsZDoOKVc3pSYXEFM/MtpYnIZKnWLrCrSqJtoaRxAr20mNVEYBiuIjCghPKyYyEiFvBwdqSQxViVdZxtDPZNyS/LwMOm9CNUQFqnBN7CIoJASIqR1OZnVBqLGAAMMMODvBYKk+eV//ZwXP3xE41MNygfJ6B/myu21h7/RyaPvjcmtiT+UCRkDGWMIQ4gQ5KQwEy6fzkM5nsz4t/v41X8ZjIUNMMCAvy/8nkdNYwt3g9OxO+bDmlPBHLufzpWAfE7cTWLXmRDePurLhsNehMTm4h1ewor9/tg5eGK/0wdbKRbv9WXRHnfsHZxZus9L9qnZftqD+y7e5EX50ZYXwKAigLbcEJIiIjlz3Z8d73nzxlF/luz1w9ZBmBgHYSsdx06a2h0MZPGhlwqaFYcCWLY/gFUHg1kjrd98MphrHtmExZUQHJiKIimDXnU87VmO1MddoSHhKh2pV+jJuEpv1nW6pPVFAee4fngLG1asxtbcHpOF1syfb8X8eVYsnGeN8RxrLEztWGq3nMU2izE1Mmfea0a8/pUFL1uIf8VIWl7Iwvmm0nZ7Du7ay/a3N7F6yTJWCMLHyATzBQswnzcf49cXYjnPjDcX23Dl0NukuL8rjc2JoUJnRoru86DEjQdKD8bVnjxQezCl8eFxWRAz5eH0axJRZ2Tj4RSDv0cSQV4J5Kapqda3yt2XIsJyiQgvJFxK2IOlhN3TLwfvwHz8gguJkJL2qCgloWEFZKSr6W4boKuli572Hhoqm1HmCzNgLTmpJeRnllKQpaUwUysfvzBLI61TosguozC9FE2eguQQX95z2MUby1eyfNEitq62I/jaYeqSnRhTejKh8WKmMphnNZE8qQrjUXkwM2XBTIsW1io/RtW+PNAEMqYJYbwqjenuJnpa+qivGUCnaZMJiYrKPsrLeygv65Tbind2jPH40XOmJ5/S0dzLxPAMD4cf0lHfRnN1s0zKNArPmtJq6rS11OvqaCirk6eiJGqgvZdPnn/MR0+/TlvzABXScXWaLlTKNkrVnRQr2ikt7aVE1UaJtFyn72SyrZqpyiiGSjzozb3HkMKVMZUPo0ofhoulZ6QJYEQTRHeRr1wKVRZ9m1y/c6S5v0fc7UNEXdtPmuv7pHmcJtnjFIUhl4mS1h94ezlWJha89tWFcit604V27NjsQHxMFjHRBUTHlxKXqCNeijhR7iRFQmI5SUl6igobaGocZHr8MTpVPcnxOsJDFUSEKokMU0rvQYH0rIsJDSkmNqKYck0TjTW9MjFVWNBAdJSG8HANQSEqAoOl/aXPiZblf+3GJQaixgADDDDg/wUIs+Cf/fqnctemyukCuZNN7WMlI9/s4skPJl92ajIoZQxhiC+MF9L3o+/rzSjGEqieUfCdf/+E3/z3f3327TLAAAMM+PLjVaJGdH2KTi3ELaqEe6ElHLwRy4pD7tjscsN6hys221xY5uDJ7pP+RKWUcuZuKkv2+WG7V9pnnw8WO3yw2+nLyn3e7DvjQaifPxXxbnRn3acjy5mOonAqshKo1ZRx3zeFDSeCWLXPXTqGK/aClDkQjN3+YGkahN1eP1YcCWbNsZCXJM4+X2nZl02nfbnunUyYlNDed03ivZNunDjuxumTzihTkhhQRTCscONBiQsjhXfpyLyBLuoifud3ssXeEpuFliycb4vR/EXMn2fNgnmWzJ9jjoXxItYsW8sK+1WYG1kw/7WFvC5CSrBf+4oRc14zwmjOXMwXLGSpzRLZb8TGzAbjOQsxm2+CmWgnPn8BZgvmY7VwIastrTm1/U2yAs7TnHmHzqwbDOTfY7jIhaFC0W3KRTY2Hi1xZbosgJnyYB5XhPFIF8yoOoBeTTLl+cUkRWShVZZRUV5PRHgeXt6ZBIcppOS7EL/AfO67peDhk0VQeDEhESVEx2jw9csmIrKQtNRiWuraeTI1w2B3H0VZSnJTleSlC1JGkDVKmaTJTlKRl6ohJ6UERbaagvRiirMKSI4IZc87b7BikS3Lbe3Y+9ZysnwuMKjwYVzty5TGXxqzaLsdytPKCNk8WMTjMmmqC5G2BzCm8mVUG8JEXRZPhzrpbOqgrqZHNsIVrcTLdC/Lj3TStFTdSlVVH9XVvbS1vixb+vYn3+LDR0/oa+mio66NxooGmqtbqdXWUPdZNEr3plpdQYO+XtreyJPJJzwan+HhxGM+fP6pXAKl13ag03aiVoouUv0Ul7RTouqkTNvFZHcbU3UZPKuL5YHaj/FSf9lbpyfHiU7p2Y2IFtxyeL9UBulCGSnxZUS6B4Mqf9rzvCmPv0dh8HVCrh3C/fQWIh2PkOl/le2r7TB6bT5f+f8u4Kv/PxMWWa7k7vX7JMXlEROtICZWTVKKXp4mJJYRH68jKbGcxARhAKxHX9bC9INH9LaNUpBXLZc9RYYVExEqPe/APCKk+ZhIFbGRBdRWdsrtyeNiS8nKqkWr7ZGOUUFQcCEh4UrCwqRzxZcZiBoDDDDAgC83/lsu0/jJL37I8Dekf7ymXpY6iRIOYQgsypoMBI0hDPHHQ3xHZr73gLrHKhRjiQx80sLPDMbCBhhgwN8Rfo+oaWohODaHA+eDeWOfK0t3u2KzyxWLHS6Yb3PGYqsL1ttcWL3fn7OOscRnl7HjdCQrHLxZ5eDG9hPuXLzlS0JIEPV5wfQp/ekpDKEqPYbkkEhu3/TnxPse3LgVQWZBPUeuJbDsUAB2h/2xPRiIzf4A7A8HY3coCPsjwSyV1q04EMCbx0LYezmcK+6pePhl4uYay+kzvhw84sm+g57sPeDK/qNuXL3kjSY9hX5lIO0Zdyj0PYvfxQMc3byeNdZ2WC+wY+E8W+a9bsW8ORYsmGeF8QJrzBdas2TRMqzNbaTtZsx/3ZQ5XzVhzuvGzHlNCmlqNN+UJTbWrLFfgq2JJQu+Ml9KwBcw/ytz5UTcdJ6UhC8wY5WVFce2rSX85kEq4q7RmeXIQO5dRgtdGSlyozfHkf7Puk6Nqzx4qPNlSuvLRKkPE2p/JkuDGFf7MSTdu66SSDrKNJRklxLon4WPbw4+/rl4SyHIGVfPDHwD8giUEvGgkCL8A/MJDS2UkvkiCnPKaKpup6GiGV2Jnv7OfjqbuinOLSU3rYT8DJUUpWQnq8hKUstETX5KCUUZRSRHxHLj7Cl2vr2WN+ztWWO7iPP7NqAIvcKgwo1JrT+PyoJ4UhkqE0xi/lFZiByCqHkkxZQmULqWACbKIpioy2Gyu5Hu9n4a6vsoLxNdnIRhcK9shKvXdaBRt8iKmqrKHmpr+uT9xkdneDEj/Xv79BkP+kdpq22lqaKRBn0DHbVtNJU30Kivp76sTpo20FrTKu33gKnRaVoaeqmv7aG3W5RSPaena5zqSulc2m50mj5UpV3SfA+Dzb087ijiSUMsT6oieFQeymNpKmK2dOuhUAjpQ+T5MZUfk9K1ifKoUWl+TLrGUem5ySE9uwFlMDUpzmR6f8DF/W9jb2bKvNdMeF16n+a+bsaKJW8SG5ZEdpqKjDQtSYlqEhM1RMeoZFVNfHwZsTEaEhP0ZKZX0Ncl/caobEFTUk9lRTuq4jqS4kuIkp5zlFDXhCiIDCsiNVFFU/2g9JlKggKKCQ6Wnmt2LYriVjIza4iNLZXWlZCeVmcgagwwwAADvqwQSeRvfvtrvv1vn8jlTSUPkmRTVGEQ/Oh7o5+11DaQNIYwxJ8SH/3oMSPf6JI7oZU/zJNLov5L+n4ZYIABBvw94POlT07+ydjvdmPRVmdspLDc5ozZlvuYb5HmN99n0TY3rLe78daRALyCc4mWks0zV4K55xSE160LNOR4MSkl7tPVidTkJxHoF8npi0HsOOzD2p1urNvpys6jvvgH5xCepueNU2EsPhyK3b4AlhwIZPF+f+wPBbP4SJhsGHzwcrQ0pjz8QvO4eyeKi2cCOHrAg1173dl+wJNtB93ZfdiDvYekOOjGjSs+lGUlEHzrDA5vrGaZpR2WxnYYz7dl/uuLWDjvJVljPN9GLn+yWGgtLZtjNN+c+XPNpWTalDlSYi2m8+aaMneONC+FsZEFiyyssTG1wHSuMUZCYfO6ESZzF2I+3wRrY3PWLbLE+fRuNJGXaM+4QW/ObYbynXio9mZC5cmAaA0uLYvpdJlQowQyow9gXNr+QOnFYIErE2pfxpQ+jCg85bKbXnUcmqwiAn1y8PLKxtM7E1f3NLx9c/ALyCcwqAA/vxwC/HMJD1MQH6NAV1xDa3UbqrxSspMKKcxUU6rQ0d3aRXdbD8pCLTlpCllZk56gICOhhNxkJYr0YpJCIzm5dy/rFy9mtbU16+2sObtjHRUxt5gs9eaR3ocnlSE8q46QS53kTk/6lyTNbExqg5jQBPJAIy03FfJ8tJv+zh65Q5VO14Fe30lj/SD1tf1UlHeiLW2hqryLmspu6mv6pehhbPAhE6MzdLcPSNNpnk0/Y3zgAW3VLbTXCJ+aRmnaSmtVs7yupbqZsb4xHo0/prGmk+rKHsp03dRVD9LZPip3dnow+pjmhiHpXP2UlnbTUtvF445ynjYmMVMrDJCD5bbigrB5XhvD05qol23GRQcroXaSu1hJ16X2l2NcHcRIsa+swJmSnqcoAZvQ+DGi8kcfd48DG9dK75klc1+zZN4cSyzNF3Py+BmKspXUVAiz5E5ys8tJiFeRmCQ6d2lITNQTGaGUiRpFYQMjfePkZWplf5r0NA3lZS2ywXJaopK4CIVM1kSFFaAubpCNmWNjtPj7lxAQoCQkVEWUtFxQ2IyyuIW4OB35hW0GjxoDDDDAgC8jXpI0/8U3//Ujap8oKRyNkw2DBz5p5cn3Jw1ttQ1hiL8gnv5gkpbneun7FEv3R3X89Ff/Jn/XDDDAAAO+7Ph9M+FmHP2TWXzQG+PNTphvdcN4owtWG1ww33wf8x3OmG53wWybO+sOeHDjuj9N6kz6laF05HkSfsOBFmUipTlZ3LkViMNhD97e68na3R4s2+rMyh2uLN3mzCppedcRL6JSSgiTEtW1B0NkbxqbfV4sOeLPyqP+7L8QSkiCjrDoYi5dCeTwu54cOOrB5u132CmNb8dhKY66s+uYO9sOuLJt13127nXn0HFPnO4Gc+vKPZbYrcHISJQ4WcittufPtcR0gRUrbFfy1uq3WWy55KV65nUzvvqaGa9JCfWcOeZyO25hGizImXnSdO7rC1k4zxRTUeI03wxT6Tgm0jGNF5hjNd+CdZZWXNq/kUS3d6lPuS63BO/JvEVP9h1GS9yZ1HjzUOfNYJEoeXJlWh/Ik6pQKfEPlLaJMiIvJkulhF/tw5Tej4lSLwbynKmNuUGmz1Xunz9NekIe3m7JODklyKVNgqAJCFLg6ZGJr2eW7FGSllhMW30fTZUdpEZnkRqTRU5yMQUZarKSC8hJzaerpZPh3iHUBRry0lVkp2hIj1OQm5hDwH13NqxYw0q7JSyzsWfjEmsCLh+gLcuDSZUPT+SuTmE8r43kRV2U7Esjyp5mykPksq3pslDpGl6WO43rI3nSruLTqRG+/uQxLx6/oLG6A72ujfKKbhrrBmWFi7a0lbqqXmoqumQFTE1lKyP94zx5+JxWYSZc0/OZoW4fHz75mGcPn9DT1CmTM521HXTVddLT2M1w9yAzE4+lz/TSUN1PZfkAFRXDaDU90nn6aajp48mjj3jx9BPamoepr+jh+UA3L5ozpWuKYqoskGlxHZ8RNY8rP4sq6Tqk7U+qoqTtYYyXBkrP0ZMxtSiPCpKVNePaAEal+zMhTYeLvaTvgjORd0+wwlIQg7bSu2SD0VwbNr2zg8TYNNITC8lO11Bb1UVHyxC52Xoy0ipISCiTIy5eTVKiRvaaaZPuQaIokYpQER+nJDm+GEV+NU31AygLq4mPLCAiMJf2xgEq9Z3EROtw98jBP6CE8HA9bt6FBIWWkJfXiE7XR790bw1EjQEGGGDA5yB+DAlPmL8d/pvf/Pdv5HKNqkeF5I9Ey74aD77VZyh1MoQh/hchCM4H3+qVVTVlU9ny98nQrtsAAwz4e8DvETUNzdz1SWHJLg+sttzHZJMjplvvYb7VCYtt96X1rrx9yJMLlzxICvGnMUckpr4MaCKoLognxDOAG1f8OXjck60HPFm3yw37zc4s2ezC8m2u0vQ+K3d6sHqnG2/sduXgByEkFzRyx7+IDadC2CTFkWsRcutv36A8Ll8L48gJL/Yc8WbbAQ827nFm2343tu51Yet+F3YccGPTrvts2efKzgPu7NrnzqGj3tL4QgkJTub82atYmS/DeL4dJqLsab41VmZ2LLdbjoWxFSZGLz1qRBnUnNfM+OpXjJn7mom0rzn2NkuwsVzMgrkmMmljNNcUk3kLMZtnhonwtDEyZ4W1BUc2riXy1nFq4m/SmelId7YjA/l36M+7w2DBfcZVgqTx55E+kAcqL6ak+Wm98DkJkJdHS4ShsI+835jSi0m1N0MKF5oy7xPrfIrdb65h5SJ7Du48ip9nNEFBmXj5ZOLqkY2TawY+XhnEhOdTnFdBvb4FVZ6e1Jg8shMVZCYUkZlYSGpsDmlxueSnl6Au0NJR305/ex/KfA0Z0vqchExcblzjayvtsV+0iFV2tuz52nKSXM/Qky98WQKYqQjhRW0kH9ZFSxHJs+pwntdESdMonlYJwiZcLgkaKpKuRRfFdFMxTwY6Ge4aYLR/lCcPn/B46hld7SM01PXRUDsgEzV11b001PTTXD8ore9idHCcmYkZulsHaWscoELXhq60jVppv+72YWYmH/N4/BGD7f101XfQ3djJSNcQHz7+kP7uMflYFbpuysv6KdcPotf3U1bWR3VVPy1Nw0yMPuHJ1Asmu7p4WJvP89p4HpYFMCE9l5eqmZftxZ+Ia3olpsvDmSoLY0wVyKjKn/FSURYVwojSTw5B3AwWutKV5Ywy/Crvbn8Hy4X20jtnJ71DtvL04N6TZCQVkhhdREqChrRkLfqyDpoahlAq6slO15MQV0pKajlpKRramgfRKOtIiC4hPkZFSqKGhKiX88nSvF7TilZZT0FGBSM9ExQX1MidnXx9CgkJ0eDvr8RFmg+NLiMiUkdSgp6ZqUn5O//XhIGoMcAAA/7u8d3vfpfs7GwyMjJQKBTSPx56Ghsb6enpYWxsjCdPnvDpp5/y4x//mF/+8pd/ZVLnpSfNd/79Uyo/I2nqnqiY/O4QHxlUNIYwxP86nv1witbnFRSNxtH5UQ3/9st/+RsTswYYYIAB/zN+r/SpoRkn7ySWb3fF/J07WG53wmL7PWx33GPLUXfOnruDv8stkj3PUR7vSG2qO6XpkQT6RfD++UC2HfFn7S6hnHFm8SYnWT2zZMt9Vu1wZ+lmZ5ZtcWHldndW73JjubTfWweDOHkxmvziagIjC/ELy8HbN5kbN8I5+V4Au/a5snWvK5v3e/L2bhe27HNnq7Ruy14XNjs4s8XBTQoPth+QQtq2/4gnd50TCQzNwt0tmvt3gji87xTLbddIsVI2DDZZYMVCIyuMREjzC+ZaYDTHFKPXTWQTYWtTa8wWmGGx0JIFc8x+L4znWmI53xJbIzPeXmLH3RPbUEdeoiP7FmNFToyXuDOicKUz4wbdWbcZKnSRyZiJUl9myoPkjkiCpJmWpqMlngwKY+EiV4YV7vKy6AI1Iq2riL+Dx8WjvL1qOWamL8dqZb6YPTsOEhqaiId7CnfvpOLplUVCrIIKbQO1+kaZnEmOyiUlJo+MhCJSonOJD8sgNSaHrMQispNeRkGagnp9La01jSSFRXLr9Ck2rV2F2cJ52Fmbc2zLGpKc3pXG5s10WSCPpDE/r42SSZqP6qN5URshlz69qImSIkYuE5opD5OuNYh+RTAzrRoe93cx2N5Hjb6VqrJmetoHePboBR8+/oi+rlEaanpoaeynuaGPjtYRmqX5wf4HPJ5+Rm/noLS9iwpdi/TZDmore2RiR3Q0am/sY3pshk+ffZ0HfUOM9gy8nB+aoq1pkJqKfvS6Psr1QlEzRFmZtCzUNZX91NYO01o/xIuJCZ50SGOsjpc9dibL/JmSno9Q0wg/GtmnRpQ8CYNkKR7qQ5nUSftpgxkp8eNBaaC0LoIJbQjdOS60pNxmoMiTvvz7tGU5c/voVlbaLMPYyJ6Fou37AlsszVfg6RZCcnwBibFK4qKUJCeVk5RcQYmiibqqLppqu8nOKCc9rZLCvArpvvSRk64hIVpJdLhCetZK4qNKiQhVyR2dkuI0cslTW6N0H/omyUoTXaFUBAUqCQxQEuCvxCdIiV9QCb7SfFKcnv6Odn5rUNQYYIABBvw+PvnkE6qqqlAqlRQUFJCVlUVKSgpxcXFEREQQFBQkR1hYGNHR0SQlJZGTk4NKpZI/19raysDAAJOTk7x48YLvfOc7/Nu//Rv/9V//c5cZkTD++Offp+GJWiZpah+X8PC7wwaSxhCG+CuF+C4JVY1mMhP977xqDB2gDDDAgC83Pq+ocfSKZ/EuF2y232P5zpvsPHqb4++e4dL7JzizZyOX9r9DmMdNgnwCOHfRj81HfXhzvztv7PVg0WYnVuzwYIk0XSrF8i3OUkjHetOR5dvcWL7VTSZsVu4UZI0HWw+54+KVgk7TRENVO443wjj6rjcO0vpdgoDZ58VOQcLsvS8rdN7e5cyGXU5s2+vCtn1SHPCW1kv7HHLFyT2GhJQS7jrHcvykL8eOB/C+NHVxCufwgePYWCzCZL4NC+ZaskAQNEY2zBcdn14T/jJWrF2yijXL12JhbI2RKJWaYy5tM2eBMB2WwmiOFRbS5wRB43xqN0VBV6hPuk1H1m1ZPTNccJ+BPCe6sxzpzLhJR/pNeb4r87bc7vmBypsprb9MyAwVuTGkcKNfSuwHCoSpsDeTGtHK2p+sgEsc3/oWy6yXYWZsxxxpzPMWLGKhkTU2VovZtcWB6JAUokIyyUxR01bfiyqvjPiwdFKj82WiJi2ugITwLOJC08lKFB40haTFFkjLGWTGF5KbVIAqt4gIH192b3iHFXaLWWZly1orU24f30pVwj0G8t3plq5jMP+udH1OsupEkBrCT+ehzo+nVWE8qxJkTQxPqyOZ1ofysCqZZ701TPV00d/aR2N1D0U5FVSqW2ir7aOvbYjJkSm+/uITJken6e0YkmKUtuZ+Hjx4yIunHzLYM0pDbQ+60iaq9O00CMVNVQ915T1UajporRuivVHav3+Sb3z4Cd/6+FNmxp/I6pvayj702j6qK0dlkqaqagS9flCeVlaKUqtBepr6+XiwkWeNiTypDpfLzkQp2pR0fcI8WJA0wqtG+NGIUqfpivCXvjSlAYypAxlUeDOiFGVPIdI9CZeXO7Pu0yfdr36FB3XpThx5axVLLCyxMDXB0tQMWwtbdm11ICOlgNjIPJLjNSQlaElNrSAxsUya6snOLKe2qpeO1geUKGqpr+mUS8WyUnSkSPvHxyiJi1aSEKMlOLAYf38Fwf7Sc00uk667g/GRR5RpWwkOLpTyCA1hoVr8/Yrx8i3CL6CYgGC1dH4dY73NBqLGAAMMMODz+MUvfiETKz/60Y9kdc03vvENPv74Y549e8ajR4+YmJhgcHCQtrY2qqur0Wg0FBcXk5eXJ6twBHETExMjEzkBAQGEhITIBI8getLT0ykqKkKn01FfX09XVxejo6M8fvxYJog++fbXaZjWkj8cTcV0vtzZyUDSGMIQf92QvWqe6Skai2fwk1Z+/uufffbtN8AAAwz4cuLzihpX/wTe3HeXTfsus3fvcba89SZvL7fn/T0buXHmLNevunLugje7Dt5n/W5Xlu/0YOk2d1bsdJfm3Viy1UUmZFZtk+Y33MN+031puytL5fWufG2fF5uPeHP6WgIeor20f7o0H0t0UikFRdUcPubJzv1e7NrnIXvO7HBwZvueu2zccZete51lNc2GPW7sPODJwRM+XLwZhU9gHu5eGRx/35P9xz3ZdzSAPQf92HfEl5Nn/LhzO5jN7+zFVJgKS7HQyFYuezI3scHWyp61S1ezxHoppkaCyBHdoCwxWmDNAkHsLLDBdKE1yy0XcWbX26T5nKc23ZmOfE96CzzoL3ypiunNuU9P9j368+5L83fpy3VisMCFvjwnmZARpI3YPlQoJfT5ojW3OwP5zvK2jmwXVOE38bp4mHdWrcbWcilG8615fY6xFNbMmWfDvHkWmCy0YqnlEk4fPk5KdDxV6mqyE/JJCMkgNapQWldAYkQuEf7JxIakyYRNSnS+TNIkRWaRHpcn7Z9Dcbq0j48P2772BsttRccrK7atXoLfBQfaspwYUXjI4+/OvE1Xxg3aUq8zrvLhaVU4j/TBconQy5KnCNmb5qE+hMe1KbzoqWKyu5v2uk7qRIeiolr0yiaaKqR1tQPU6tupr+5gcnSK7376bR5PPWGge5iJBw/58MWHjAyO0tc1Rn2NIFxaqavukb1lmqSo0nZSX9FHS+0QzTX9dDT08OHMC77/ze/KKp3+7gnpc4NSjFFdNUJN9RhVlUPSb+JR6mpHpN/VI9RX9fCwq50njdmyx44gaIT5r1ANTesCGSn2/D+KGunaBFkjlDRjaj/Zi2ZM5c9AoZdc6iQImv4CT4al+VGVL8PF3vTku1GZcJMYp7P4XX8Xt8uHcD5/GJfLp4kNCiEpJks2e06IVZGSrCMhoVQKjfTbXkVqajmpKWWoShppbxUlWg/Rq+pIjVcTF1lCgrRPVLj0HOPLiIxQERpSQlhwMUkJZXL78dKSGooVDRQWNZOSUk1oaClu7nn4BxZLeYMOLx9hKl1KWV4UvzV0fTLAAAMM+PMhWub96le/4qc//Sk/+clP+MEPfsC3v/1tuSRK/IgS5VEPHz6US6VEyZQonRIlVEJ1U1hYKJdWpaamEh8fT2RkJMHBwQQGBhIYHMh9X0ec/G8RFOdLam4SBapcSitLqGzW09RTR9dYG8OP+5j6+hjPv//oCxNRQxjCEH84hIpGtLtXPkiSVWvf+fdPZPNuAwwwwIAvK14lahobmwgMCOXIngPsemMde95czaGd23n/2BnC/AIJC81g+2Fv1jp4smK7M8t3uLBoqxv2Oz1YstON5bs9sd/uiv02N6zevsvizc4s3e7OMkHi7HBm94kgrjul4O6bzQ1peuBsJOsPB7DyYAAHr4STlltBaJiC/cd82LHPje177slqmo2777N1rzS/z5XNu53Zedida46xBATn4uGVysWLETgc9Gb7IW+2HfJj634/Nu/1YfN+X3Ye8ePCxVCcHEN5Y90mTMzsMDOxZfnipaxbvpbldiuwltaJkijjhdYYLbBk/gILFppYY2KyCFvzxTi8uQ6vC3soDDhLS7YPLYpkStOT6NZmMKIRZUyujJV4yATHcJGb7DUjFDTCe2ZM6cmQ7F0i1DV3GMhzk8KFIZmscaE16z4hN4+xa90qlljas9BoEXNet+SrXzXn9TkWvDbXSp7Oe90ES2PRdcqGVYtt2b99K/EhUSSFSb/5gtNJDMsjOiiLcL9UogJTSYrKIT22iNiQbBLCs0mPyyY/NY/U8GjunT/DrnfWs3SRBbYWC9m22pboOyfolcY2VerBtM6fCWnswj+nLfkq/bn35bbbz6qEJ000L+rieFEbz7OaGCbLQ5mqTuJ5bzWTnZ0MtQ5TpW1FXVyHXt1IU3U3LdU9VJa2oCyqpbm2l+HOUWbGZmSC5cOnz/n0ow8ZGx6jo6VfNtitko2FhY9NP41SVJd30lDZR2NVL43VfdRXdDM+MMWnzz/l6eRjvvHhN3j2+GP6uidpbhyluWGU6sph6mpHaWgYpL5+SJrvZ7x3gMctSmncoptTiEzUiFK0mYpgWe0kum299KgRhsKRMlEzoQ1ipMRbJmqGS3wZUvjIpU8DhZ505bjI60bVXtLUh7okJ9I8TpHuc5kM38vkB95AHXWfysxI6rVlJMbkkRSvJD62hNQUHXFxShITtdK0lORkvfTbvZQ0aX2ZpplnM89ob+wlL6uC2AgFibFqufQpMV5LTLSS0JBC2Y8mIV4jl45lJWuIipSWk3So1B1kZNXh5VdIqCiFCtDg5Z2PtqCY/po0A1FjgAEGGPD/JkQp069//Wv5x9W///u/y7423/ve9/jmN7/5O5XOzMwMIw+GKahOJzjfndAsH1LzE6UfQskkpscTkxRFeGwYweGB+Af54unrgbe/F/7BvvK6qPgIkjISyC7MoFhXQFltKbXtlbQNNtI/1cWD50M8/pboFGUwITaEIWbj0ffGZJJGNZ7CxLf7+eWvfy6+sS+/uAYYYIABXzL8PlHTSLCXO+f2bsHX8TqON+5y8MRtNu115tiZAGLTVNy8n8qaXW4s2+GGzSYnlu/xYfF2N2y3OsulT8t2uWO3yZllO71YvsuD1bud2HncG1f/AryDC/jgaiQ7D/qw8UiwtI8PKw6GsPxoCOuPh3HwgzAKVLU4e6ayTRgEHxL+NC6yR80GaQzb99/n9p1YKVEtwtUthhPve3D0RCC7D/qzXYoth3x5a68n7zh4skU6x1ZpedeRAPYf9uLYUXdu3vBj3ZpN2FnYsmqxPYstl2JttgQzY3uMjRZhtNCvViXpAAD/9ElEQVSS+UY2cqcoc+NFvLF0KW5ndqMOu0hHkS+NxYlkx8TjejuUe3ejiQhOYqBSwbg2hEmdJxMaQcx4yUm/8KV5Sdh4yV41Qj0jyJmRQjdGiz3oznVEGXKWa4ffYbmdPRYmizGZa8Wc1y1kkua11wRRY8ncOeaYLLDga6vWssLGDqO5RhgvMMLO2po9W3eTGJZIekw2od5JhPlmEBeaQ3J0LinRgrjJICmigLTYXIoy8onwke7F5s2sXbyIZdbmrLIxxmG9LQnOJ2jLusekypMZTaBc1iRab0+XBTCicGesxJvH5WEv/Wiqoz8jbGKYKo9muj6LT0Y7GGltpaepl9qydlT5NdRXdsllWT2tQ1RqW9CWNNBQ1UVPyyBDHWM0VXQw1veAb3/9U7719Y95MDROi7R/tb6TloZhOltHaW8ZobayU27r3dYwSEfTEI3VXQz1TPDph9+UlTmj/ROMDTzkw6cf88lH32RsZEZWmDTWDVFTPUiNNK1v6Gesf4jpNh3TlXE80QcwI9qjV4bKJsnCO+ilf5AoZ3qpqBFEjVDTDCm8XnZ2KpXuRYlQ1YgOT/4yQTNQ4smIyodhpSflsTe5c3IfX5PemdVLVvCGFBuXr+bQhs2Ee/ihyNaSLIiZ2BIS45UkJKikUJOYqJNLoGJjX6prUpPVtDX20d85Sk15Bx1t4xQX1BEX9ZKsiY5SEROjJixMQUS4Wu4W1dk2Im0vItC/EG+fAuKTtBQpG8kvbCUqspTwEDUBASUoMzLp0CQYiBoDDDDAgL81fis6PP34CdqJTPIHY2h/XMP4R4OMvxhm5Ek/Aw+76RnvoHOkhdaBBhq7a6loKkNdUUy+KoeM/DRSshKJT4mRSZuwqGACQvzxCfDGy88T30AfAkP9pfUhxCXHkJaTLH9OJX2+olFHY08tnaOtDD3qZerjUZ5/79GXmtQR43zxg5kv3GYIQ/yp8eGPZuj7uJGSsSSan5Xxg59+WzbyNsAAAwz4MuLzRE10VDy3bnux791bvLH3Fkt23WPlHg9W7HHlg3ux5Jc0suu9IJmEsd/hgfWm+9hsvi/Nu7F4hyt221xYtceHdbs9cHjPn+seqXiHl3Dmegzb3vXlrWNBrDsSjL2DD0v3B2K/1w/7/b6sPBLG146GcNU1icz8Oi5ej3hpEizF7sOunDofKP3uyJQS0RTOnvLl4CE39oluUPu82HbQj437pHPudOVNQers92LzQR82H/Dhnd1ubHdw5d0TXty/E8DJQ6ewt1jGEit7Fpkvxtp8CRZmSzEzWYKpkR1WZva8vXwFp3e8Q4Tje1RnONFSFIQ+O5tArxiuXguWxhbF6YshXLwWSnJUGn1leYzKLZo9ZSXNQ12ArKQZKXaXVTWC7BDzQ8LHJt+VqoQ7RN07yZFNq1lqbc38hTZ8dY4VX/2KaBFuzuuvW0ghyBozzIytWbl0NXaWdhjPMWLeawswmrMQs/mm2JnbcWTXAdJiUkmMyCA6KJ240GxpPof48ExSYwrJii8kLSoZt1u32bRmDcutLVliacr6xWZcO/Am6rCr9OS5MK704EmZP88rI3hRGyW34H5SGcrTyjC5q5MgaD6sjZFLnmak9dOVkTxqyuP5QCszfQP0NXZTq2+jpKCKam0rPc0DDHaNUF/RQUVpC2110u/OthH62oZpqGynt32Yj2c+5OnkQz598SFff/YRQz3jdDaP0FzbR1fLiDQ/RHvToBQDsi+NiN6OYT588nUeTT5luH+Cga5x+jsnmByZ5sOnH/GtT7/D+OgMPZ1jNDUOSzFCT3sfz4cama5NlImZh2ovZvSBMlHzpCpcVtU8LJNCHyJ3rhKEjeh0Nar0YaDIg0HFS8WMUNIIbxpR9jRQ5EV/sRtD0nMdUHhQFHydnevWYrzAlvkLBPEnvV8my9j+1i7y0hSU5FWSlaolIbaYVKF+iSoiMVFDdLSSlJRyufxJEDV5OTomhqao0XeSn1MjmwuLzlgaVRNZ6XoiIpRERCrxD8zD37+Q/NwaaXsnsVElBAUUS98PBYHBxYRHKUhNr0RT2kFGqp7goBJyY6NI9bxiIGoMMMAAA/6WEIqbH/3sezQ8KaVgNEZOGJ/8YPJ/bMH94Q8e8/Q7D3n0jXEmPxpl7NkgQzO99E120T3WRvtQE8199bKypqyulGJdIbnFWaTnppCUHk9scjQRsyqdYD+8PqfSiYgLIzE9jqzCdIo0+WhrVNS0VdA60Cido1M+38w3J/joR//3/XM00liyCjPksbz4voGwMcRfGk+Z+s4QFdMFqCfSmfn+GL/6zS8/+2YaYIABBny58CpR09DYgkdACuv3uWO33RnTzfew2OaCyYa7WO9w453DfviF5xOeWsk7x4KlfdyxFj4025xZvM1Nmrqydr8bB65EcNs7E1f/XD64k8zmkyGsPhDAEodA7Pb6s2i/H3b7/aV5P2x3e7F0rxfLDvix6kgYW05E4B1WRImqmbMfhHPpajTefun4+aVw8VIwB494sGuvCzv2urPFwZ2Nez15a483m/f5sUU6xqaDXmzc78pbu9x5e7eH3M771BlvvJz9Cbh3jQsHd3Jo49vse/tr7HhjLRvXrmH9qjWsXryCdYuW8f6ujSS4nKYhzZl+VRh1BYnEBsdz43oMZy5GcOxcIEfPBvL+hTBOfhDMhctBJIYn0V6cSFPKHTqz7jAmzIG1fnJpjVDXDOY7M1jgTE+eMwVB5znv8DZrbZdhYbKEOfOteO11E77yuqkU5nz1dQtee82UeXNMpaTfArOFFliYWjPnNRM55r1mJHepMp5jhsU8U9bZr+DM0ZMkRiaQHJ1BZEAq0cEZpMfnk5mQQ3p0EpffPcl6+8XYmpuzyMxEOrcpbuccqEu8w3ixG5NqD6Y1fjwtD+F5TTjPaiJlAkOQGsKH5kVdDC9qYz/zpYlkpjKEh1XRvOirZnpgiAnRFlvXhLa4moaqDoY6RxjpGqa+vJkyZQP1ZR0MtAzT1zxInb6V9qY+PnryEVNDY4x29zPeP8yL6cd888NvMj40RWdzH601PXQ2DdDf+YDedkHaDNDXMcxHz77O05nnTIzOMDY0w0DPFP3dDxnpn5aWHzI99YRvfP07PJeOP9A7SU/bKE8Ge3jens+TmjAmNT7S9fowI12rIJxmKmZVNSLCeFwpvGlC5TKo/gI3+vLdGCryYqDAgz4pROlTvzQVpU8duffoL3SmO88Vv8tHWWNjz4I51sx9zVqa2rDEagWujh5oiqtoa+hHp6onNUkphZaEeDVJSRqSEjVy+VNiwsuo0DUzMTxFbloliXFaIkIKyUkvk42VRUmY8LaJjBS+M0rCwkvRa9vRqeuJi9Pg41Mglzj5+BYREqIiJLiItJRyVMoWSgob0GYGo09x5je/+euWZBuIGgMMMMCAPxH/Lf33i1//jIFPWlGMxcsJo+jwJNQ1X5xY/vnx0Y+eygqZx9+aYvqTB0y8GGb0ST+D0z30TsyqdBplVU1Vs57SKiWFpblkFaSTmp1EQloc0YmRhEWHEhgWgG+g9CPK10NW6wSE+hMSGURsUhSpOcnklWSjKldQ3qijoauGjuEW+TyCSHr63Yd/NZVOZmE6t27fxNXDhcS0eBq6awxePYb4i+LFjx7R+WGNbCrc8WEVP/75D2SFmwEGGGDAlw2/Zybc2IyLXzJLdzhhK0qbtrthudkF652eWG5zwX6nC+8c8SQpu4y7fkUsldav2OPB8k33eXuPK6dvRuMRkc8Vj0QcLgSx4b0g1h8NYeluH1bs82epgx92u7xZLC3bS9NFW11ZudebVXt9WLnHR9ruxZpDARy9EI1GWUeNvoFgvyxOn/Vl71FPdh32YvsBT/Ye8mXrHmksu114a48nb+71YMsBL7bsl5Z33WGjg5ustDn0ritu9/xQJUXQmhdIXdI9yiKvog27jC7iGqURV1FIkR10gXTv82R5XaQi/jZtBYE0FSWSEhrFvRv+XL8RxZkL4Rw7E8xRKQ6fCuLQewEcOR3EsVOB3LgRRnpMGnW5MZSGX0YbcormxGv8/9n76/iqruz/H//+8fvMzHtqFHfXuo/P1I0WKO7u7i7FIbgEYsTdXSCuEA+QkAR3lxbi0Ndvr7XPuTkJtzodCule78frvffZR+695x7uZD/7Wmvv3zEJ0bvHYb/lWHhvEH9fDPoI/3mzCzq17YjWzV9A8yZd0ICLBrfWRE6aJmjVoi1effFltG3eEvXF9vPPNcWzzzTCc0IEahrVb8mwpsXzTdC5VWe8+9d/4ssPP8SG5Wux28IGO9ZZYd8uOzhY7kKPD95F11Zt0K5Zc3Rq2QL/erUT5g77CFF7ZnMR5FS7abzq1BHv5cj3W8kAI9+fUp/W8mpOtPR2cYgFCoM28GpIVEg4z3MFcjxWIzfEFvnJMYgLiYWfSzAiA2KQEJ6A5KgkhPpEwMc1GDGhSYgnJ0xEGsK8D3DqU1FeIXJTM3EwOhnJkYlCychIOIT8zMM4d+IMjmQeQWr0IaTEHELigYNIiRfHJuVwelPR0SIczj6G3KxCpKXk4WDqUaQkHkZaagESEnKRkpyL9LTDOHvyAs4Un8Xx7GwciXBCfuBGfv857ks5jYsAFMEogjI5XuSUWaqt+rSaHTXpzhLI0GpOpESbObwtIc0CdtXE2c5G0r7Z8N00GR+89QpaNWmHhs+3ZbVp+QL6ftkf+/a4YusGB9haeiMqLFEoCVaWXtizywfbtrhxTZrNVFx4qxe2bnJlF1FkaCJ2bfXB+jVOWL/aCbs3e8Byuyf27vZFkF88HPcFwGK9i5A7wgITYLvXC+vWu2HeQhus+NoRK792xpJF+7B0qS1WLLOHhYUXXGz8sXfZaNisGKlAjQoVKlT8VkHFS4uvH4Znzh6uk0HFTY9fzzc7oXwUOn4tH8cuHcbRs9mcAkW1bahoMdW5ic+MRvTBSEQlhSIkJgA+oR5w9naAtdMe7LbdyTVyNu3YiHWb1mDl2hVYunIJp10tFFqyYjFWrF6GtRtXMfjZs28X7N1t4RHoioAoH75mYlYM0o+lsEOI3oe596eLwNCw4cMwaNAgjBg5AjNnz+A6PsHRfgylzJ2jpGRO5FzLupAE71wreOXuReG1XFRUKVeNChUqHr+oAWrCIjFr2U68/sUiNP3LZLT610y0/ddstBFts79OQYf356DbR/PQd9TX2Grljz4jLPD2JzPRf9R6LFq9DzOXW+Kjvivxlx5L8WrPJej6+RJxzgK83H0FOrw3Hx1Fv9MHC9D1g4Xo+u58vErwRoy9+PFCvPrZIrzTfQk+H7oaqze6YaeFLTydPbFGXLdX/6+5UPC/Pp2Hdz9bgL++OwP//GQu/vnpArwt3hO1f/14Fv7y0XR8+CUBmkWYNHEJ9m1fBw+LmfDbOJrTkg7RCk22M3Bw30wkWk1DrOUUxO6ZyKsbJVrNQMK+hYh33QTnXbswfcpKDBy8BENGrMNXA1ag96Dl6DVoJT75ajE+670YvYesRq9+yzFoqPjbQXz+UaNXwGanLSIctyJs2wSEbxsFr6/7wnVFX1hM74kef38DL7XvhFYtqQZORzRu1AUNG3REg/odUO+5NmggJvdNG7ZGl7bt8NoLL6JNi1ZirJHY1wTPPduE23rPNkYD0W9cryma1muMto2bo0OLzni126vo1q4NPvn3f7Bn007YbtuLFXPmYED3j9C1dQu0aiKOa9kc3f/WDTvmD0HU3rlc+DjDcTZy3BeigACNEK1+lOu5jIFGUTAVDbZgUFMo+gWBVFx3FUOMTNfFyHQR8lyL7BA75MYdwAH/MMRFJCA2PAH+bqHwdQlFZMABHIpLRXp8OkK9IhAXFo/ivELkpKTjUGwKDkanIDE8Hin7U5AUlYjUmGRkp2bi4snzOJV/HHkHc5GZkoP05BycLDyDsyfOIjfzMI5kFyMr4xgyMwoY1GQeKkRK8lEkJx5GaopQUi5y0gtx/cw5nMsIQ37wZl7V6aD4zPTZyBVEIhh12JvSnZZxqlOm2xJkuS9FhraKEwMZh4VItJvLLW1HW05jWJPqsADxdjMRvnsmlo7pic7ie23SoBrUdGr/GsaPnIqdWxyxcY09tlm4wnK7G0KDEhARlgBH+wBs3+yGXdu9sI1AzA5/2O7xR2psNlztg7Frmy/WrXXGhrWu2LbBHVvWu2P5kn2w2u2HQFpRyykM9jYhiA5PgbWlJztsFi62xapVzgxq5s3Zi69XOGD1KiesXOkIq61OsJjVBzbLxypQo0KFChW/RZCb5kbJFUQWesExfTMOFPvzksGUjmFuQvk4iZwxlHJUcEFz6Rw/xJAl9Qi5dGK53g0VMqYVqgL3+8Ij0IXTp6jY8U7rbZxStXHrOqzZuAor1pBLZxEXSGaXzsolDHrIxUN1dyhdy8XHgcFQaGwAotMisWDxfAwZOoRBjS4CNzNmTWdQRHV3jnLxZPPvX0nJqMJreThQ5AfHjK1IOBmGWyXX8Z2qVaNChYrHLGqDmqkLt6DbR3PQ5v3ZaPnvmWj9r1lo9tepaP+eGPvPHLR/fx5e+3QWFq3cC3fXMKzb6IbJi6zx8ZANeO2zZej2ySJxzFy0e28B2n2wCJ0+WoQO781D5w8XyvaDhejy4QK8JI7r8tF8dPt0IV77YhF6j1uP+Sv2iknlLowftxh9+s3GtCkbYGvrj5li0vmf7gvxjw9n418fSrfMvz6dj399shB//3A+/vLeDPzzo1n49LP5mD52JWw3b0CcuwUyPJci03kO0hxni0n2dGQ4zkCO61zkey/GEc8FYt90pDtMRZqDOMZjI4Ltd2H1gjUYMWIleg1Zj+5DVuHz/svRe9DX6DFgqeaiEX2hXkKDh6xB3wErxf5V6D9sDWbMtEC4lxcyA7cjyXEWwvZMxurJ/fGfV95G2+ad0bhpOzRqLNoGXdCwfkc8X789nn++HerXa4U2zTvizZfewCtdu6FZ46ao92xDdtcQoCFHTf3nKfVJtM80RrPnGqJLy9Z4rcuL4jxaYrwTmjVshI4tW+G9d/6GEX364i8vvYDOrVqwK+eFdq0w8OM34LphDBL2zUac5STE7hiLQ/tmIc9jKY5SMV2q0+K1DFRUN99/jQnSELAhoEFFdvO8qJYLrZC0TPSXI8djBbJ91iEnyBq5MSFIjoqFh3MgnG19EeUfjUMxaUiNTkZUYBTiIxNw/Ag5adKRciABaQeSkRQRj2QxniDa+MhE0SYhZX8yjqTn4Nq587hy9gJOHjvBzpiLZy6iuOA48nOLkJNegNzsYlZ2VjEOpRUgNeUotwdFmxKfg5y0XJzLScaJqF04FrCKU9COeK9Egd8aHPMnN81adgeRi4YgDQEaqkmT4boEh5wWINV+PhcPpiW4qR4NFRDOdFvOgIZWx6KUqAS7WbCY3hf/fuUFcf+rIU2j+m3xxiv/wuplW7Bm+V5YrHfDxrVu2LrRHdu3uMLbMwIx+w/C3zsGu7eTW8YLu7d5IdArGklRB2G13Rs7tnlj9WpnWGxwx46NnrBY7YYVSxzF+T6w3OUFN6dwTvuiwsM7t7qwe2ax+HdIYGbV185YtMCWz1+5ah8WLrKC015X2K0cgqBdCxWoUaFChYrfIsqqSpF5PgHOmds45YlqZZz4FVOeHheduFaAQnLpnMvh5cTJpXMoX/wPPBdIjkYMuXSSwxAaF8gpU1TgmFKoqEDy9j1buPgxu3TWyQLJ5NAZPWY0Bg8eXAPU6Bo6dCimzZjKx3sFuyNPvKZa7Urph0SphhnnEthR45Nnw9tV9yu1f6kqVKhQ8XgEgZrS0lKcOHFCgprFm9Hx/Wlo9/4CtP73PLT8+wy0+sccoZno8sEsvDtwGaYvs8PXax3g6Oov/nc1GB8MXI8XPl+G9v+Zj84fLkLb/8xC+3fnoeMHi8V15qHtv2ZxylOHj5aKayzAyx8vwIsfzsNfus/BwIkbMW+FDWbN3ohhQ+bjy16z8e/PZ+Pvny9Aj77LMG/OFrg5h2Dg6LX418fzGNS8++k8/OP9ufinuNY/PpqLD7rPwPhR82C1cR0OOG1Ant96doEUhaxFYcAaZDrOQ7LVBGS7zEa26xxku81FnudcMUlfhOyAbQh3tMK6pesxctwyDByxCl8NXokvBizHl0PW4LO+K9C990r0GrRBjGmQZvBq9BywCn0HrGVAM3Dkasybtxv79oVin60XvPfZw3nDEozt+SHeefkVtG9N8KUTmjZqj8YN2qFx/Q54Xkzon6/fBg0atkaLZu3wUueX0b6V2N+oBerXb4rnyElDoKZeUzxfrxka1m+BhvWao3nDFnj7xVfwetcX0KJhU9R75nk0qt8YDZ6pj5YNmqFDc3LltOfiw7S61VtdOmHmoI/htWEsEu1nIs1xDtfMSXcgR808pNrOEPdjMYOXfL9VnBJEKU8y7WkD12zJ8VzObpN0Z6q9sxyHvb7GUV9KG1qDPFrC2mc1IuwtEODohECvMEQHRSMxLA4pUSmI9DvAEKYg5yiykw8iLZpSncTfamGxOBSTipT9YjsqAfEEa8ITxP5UpMelIj8jF5dOncWtq9dw/dJlnDlxmosFFx45jmNHTuJY/lkGNTlZxcjOKELWoSKkpx5FRko+0pNyUXgoCUUHHFAUsA5HvJeJ972MlxjP91stJFOecg0pT7SqU4b4jOSmOeS8CGkO89lFE2s1EzF7pvPqTwfFeKrDIiTbz0esGIveOxOzBnyKDi3ao1EDckW1Ed9RW/E9d0TPzwdj20Z7rFpmgy0W3li/xo1TldasItjihX3W/tgfnoqw4EQ42Ppjzw43JMelIyowFvaWAdi22Z2X2yZQY7HaGWtX2GPNSid22Gxa74p1K/bx8cnxB+HhFo5VK+2weqUjNq53w5LFtpg7xxIrljpgxXJbLF9qixA3T0TunYFMbwtVTFiFChUqHnVUPqjkFWf8DtvBJXM7kk9Hoeja7ztlh106V4+i4GIeDp+hAsmHkMEuHSqQHIs4dulEICwuEOMnjDMLaXQRxBk2bBimTJvMkIfq7tAKWr9F4WOlJ0PHruZyIW+qVXPwTDS+Lb+jXDUqVKh4rEIHNadOnUJE1AHMXWWJl79YiKZvTUXbf1Ftmnno8J/ZePvT2Zi0YA/mb3RCnwkb8V7/FRg0ZR08/eMxcpY1Fwl++bMVnCrV4YP56CjU/r15aPXvWej82SK0fnc2un28CK9+sgBvfDIbn/ZfgmVrbPH16t0YMHQ2Pug+BZ9/tQBvvjcVb3w4G++I4/728Wz07DsXmyz2wcY+BL0GrMS7ny/Em/+cin9/Oh8fiOv27j0X65atQNi+1cjyXY/8wLU4EUJLSa9Egf8KHAukArJLkO44G4W+S3HMh9wgS5DlvRRpvjvgtGsPRg9fggEDKbVpFT7utwKf9V+J3kPX46Ney/BJnxXoMWidGFuFLwevRu/ha/HBlwvRW4z1G7YJA4evwarVVrwqz9erHTF+2lYsXLoXm9da4ouPeqBtmxfQrEknNGnUAU0atkGjhq3RqAkBmdZivDWaN2+HJo1boXHDlmjcoAU7ZxrUby4dNEL1uN8cjZ5viSb1yR3TBS917IqWTVuhYQOx79kGaPhsfV4RqmX9ZmjRSKhpS3Rs0QnvdOyAFaM/Q/j2yUi0ncbOonSn+chyWcy1Wg45zEOm8yKuOcN1W/zXMsw4FrgetDy1vvoRO07clsiUJ7fFyKUaNUKZ7ktw0HURIq1nY8bA7hj8RR84WzngUHQCDgREI8A9DAdCYnE8rxDZSemICYrimjSU7pQUEceQ5lBMCvfjQmO0ejUJSI9NZRUfPobbV67g25vXcenceZw9dQbHDheh6OgpHD92Dvl5J5GXRdtnkZ9zBrnphUiLz0ZhVg7ywu1xxG8djojPkOuxWLTSKUSpT+ScyfFcijzxDOTyCl2LeIyW4SZIk+o4H2mU+uSwADF7ZiBq52TEW8/kZbjTXJYi2WG+2J4L740T8cU7r/Gy6g3qtxBqjYb126FD69cxZ+rX2LTWARvWUC0ZN2za4Ib1a12xepULt1s2e2LPbj+EBIl7FZkKL5dQ5GbmcUFmR+sgbBXHb9nogU3i3M0bPLHma0fRumObhQfWrbLDmmU2SE3IhK9nCIL8Y+HmEo4tFi7YuMYZCxfsxZw5u7B6uSNWrdiHdSsdkBzshXT3tSgI36VAjQoVKlQ8yqDlf8/fOYXwAg9209Dk8OjlTOX6+ImiGjaTpkx6CM4MGSJToYYPH455i+ZyLRwXX0dEJIYg5XACCi78esWMleqe6NlIOxsDt+xdCDzqiHPi3yjVkPq58Z1Q1YPvUHH/O3xHGypUqFDxKwWBmvLycpw/fx4JiSmYv8YGL3yyEO3/NRdd3p+D94evxNjFOzB11T58MXYj3u61GF0/nY8XeszDi5/MwYylltjtGIx3h65Hh08XosOHC9H23QXspGn33hx0/mg+2r4/E13Esa99Nhc9R67EnMW7sWLlHgwcNhf//nQ83np/Ct76YAZe/c9kvPmpOO7jOXjz4/l4+9MF+PeX8/FFn/liUuuJjRbO+PCzRfjPZ/PxZZ+5WDBnOfxt1iHLZx0Kg9aiMHgNjgWICbnfMuT7UkrPUuQHLEd+4HKxfyWKA1ehMNQCuUG7kRHuDcutdujdfwk+6/81PvpqCT7tswKf9P0an/dfhU96r8AX/Vdzv/vA1egpPl/PgWvwZb+v0XfwavQfuhLTZm2HjbU/9lgHYOoiKwyatAUDJgiNtcCUGduwYtl2/Ofvn6JVs05o1KAt6jdog4aN26BJkzZiMt8er734Ktq1oTQoucpT/XpNhZpxv2GDFppaam6aZmjSoDlaNmqJFkJNhBo1bCHGmqJFw2Zo1agFq2WzjujQqh3ef7kzVo/qjjibGUhzmIF051nIdF2ALNfFSHdcgLR9c3DQYR5vE7wgQCOdMqu5oC4X2fVczg4TruFCtVtcFnGb47WMXSjpbsvht2UKxn71b7zWqQte7fwWPvnnZ7DZthuR/mEI9QlDYXY+clMykRgeh8SIeMQGH0B8aAzSDiQhlUFNKjts2Fkj2rToZKTHpSEvLQtXz17A1fMXcP3SRXx76xauXLiE4vxiFB4pxqmiszhx7LTon8CxvOMoPHwK2YcKUCBerygxCHn+4nv2JMC0SHw+8Rz4rxLPgnTSZLkvEe9ffA7PxQxqyCl0yGkhMtzEZxQiYJNkOxsHdk9Bgs1sdtYk0QpQDnMQs3cm4sWY38aJGNvjH3ixTQfUf46KQBNga4PmTTqh+4f9sGmtDVYtt8YWC0+sX+PMkGXFMjusWe2MdWtdsXmTF9avd8XObd7w8TyAI1mFyE3PgYdjIGx3+2PLOg9ss/DChrUuWL/aFV8v28fQxmKtM9assMX2jS5IjsuC1R5fbBJ9x32BCPCNhu1eXyxfbM1umjUr7bFksRU2rLLF4RgfFEdY4mScrfg3r0CNChUqVDySoKW4b5feQMLJUDhlbEPQUWfkXEzFiRu/XQHhJ01U3JhWfNJr1AwV7cw5spiwg+c+Xm0qISuGU6yoho6CM0o/RSeFjl7JQnC++CMqcxuyLiTjXsW3/G+WgAvpgVB55Xe4VfIdTl59gIMn7iPmaBUOHKlW1OEqBGRWwudQJUKyK7FfG4/Nr0JSYRXyzt7HzbsPcF+ZdVSoUPEzg36PqqqqcEtMhAsKj8PC0ht/67kYAyZtwYT5uzFsxja8O2IdXu+zBF17LEKbjxegw+eL0PqT2ej4yQL8s+9irNjkiDU7/fBSD9q3BG3eE+1HC9Hlk4Xo+tE8vPr5PPQevQ5zl+7F+Lnb8NVoKso7F3/7bBpefm8i3vh4DrtoXn9/Kl79cAZeFdsvfzgLr326UOybh/90n48Ro1dg925XrF29B1MnLMaOlUvguWU2Mr2W47DnfBT4LhJagiPeixnQHPZaJCblS1AQsAJHhfIDVuFI4FaEOe7ExlUWWL1iB5wcgzB3wW581nMJPuu9Ch99tZxdNN0J0AxYjU/7fI0eg9biE0p/Etv9Bq/DwMGrMHrcGmywcMYuSx/MWuaEPpN2offE7fhy9CZ8NW4b+o3fhoFjLTB19g7MnrUe/3jnI7Ro2hENG7dDq5Yd8cYrr+PVbi+iQ+sO7KR5vl5TWSxYSHfUMKwRbaumrdGxDS373ByN6rdAk4at0ZRgT6NWaNyoJZo2ai5BTeMWaC+OfaVdR4z44u/Yu3AwIrdPQrLtZKTZT0e601xkuS1AhvN8BjXpTguR67FcaBkDGurnuMv0IIIwVI8m13M5gxly0zCwEdt53mKf7zK+77ZLR2DAh3/BC527onWrTpzi9VLnN/D5e59h9eKvkRgZj/T4NMSHxyIhLA4xQfuRKPoEbdJj0xjKUJ+ADYlgDY3lJGfgwonTuHLuAi6cOYvzp8/g6qVL+Pb2HVy5cBmnj5/C6eJTOH/qHM4eP8N1bPIPF+FYXgFOZyejIGyH+O6/RqbrXOR4LES+Py07Xp3KxfV2vOmzSEcNu4XIYeSyGCkO85BsT6s8zUK05VTEW8/iFZ6S9s1FstM8xFhOw/7dU2EnPvvbXTqiRaO2qC++p+efbyW+l074918/xLb1u7FxrS1WfW2nrc7kho3rXLFyxT5soP4GdyEPrFhhj82bfGBnFYTsg4eRk5aN2IhU2O3xx7aNHthKsvAUz6qTkCM285gXNq5xgbtTOIJ8orF9q4e4Fl3fCXt2e8PbMwy2Vl5Yv9oey5baY8F8O+za7ICjMQ444m+BY1G7FKhRoUKFikcVlfcrcORyOjxyLOGda41DZ2NRfP2o2YmjknnFpkdh0bIFWGuxGnau1rwCVVzGAS5mTHVwFJhR+jkiQFN0tQg554uRcrII/rkHYJO2EyH57jh98zwu367CsYv3kVZ8H2E5lfBMq8S++ApYhJRjjmsZxtuVYqxttUbblGLonhLW8L0lGGNbwuMT9pVimmMplnmXwSW5AgXimqUVVFJcunBUqFCh4qcEwZqKigrcuHkbsUnZsHPbj1Vb3dBrzCr8hVwmE7bj5d5L8UKvpXin/xq8PWgFOn62EG8PXImPRlmg/wQL+IcmYsJyR7zQcyleE+f8ddAGvNVrBd7puQQrtnnAztEP06etwqd9l+KLUZvxrx4z8Y8vZ+MLcY0PeyzF37rPQ89hX+PfPRfgnc/n48PBq/FXca2/fbEIvYasRa/hX2PZiu3wdbbGjMG9EWK9HJliwn1MTMIL/ZajOHAFO2kKg9bgeJgFT86P+H2No1RzJXQTTiU4Y7/HPsycvBhDhi/DlGkW2LndGeERyZg+czu+GrgOXwxajRHis/YZth49h67F6Cm70G/EBvQZuQFDxm/F+InbMX36Nvj6xsPNIwzTaOnwKXswbKY9Phu3HcPnO2LodCtxP7ZiymI7TJpnjdkLLLFk4Ua8/urf8OJLb+Hj9z9G9w8+wqvdXkLXzi+hU4cX0KH9C2jbpgvatu6M9u26oaO23b5dF7z/z3/hr2+8hS7tX0LnDq+hU6fX0bnza+ja5VWhV/BClxfxUucX8Vq3V/DWi69ifK+PEWo9F/H2s5DsMBcHnRdyIdxDLkuR6bEMeZQK5L0aOV6rcdR/PfIDNnI/y2OlaFeJsQ04TOOBG3l/nu9a5PqsxpGA9TgWsgX5QRtQGL4OqR4rMGvwJ/jbW/9A5xf+ig5dXka3bi/jtZfewV/e+Cd6ftQDezftxuFDuUiLSUVCmCwcnBadxMqIP4jUA0m8RDc5aDITDvEKUbTvdMFx3Lh0BVfOX8AloYvnLuDKxUu4ee0aSu/eY2hz4fRZXL9wGVdp39nzOF58EhdPHEd+tIt4/2twNFB8Jq/FOBa8DkUhG1Ecthmn9u9CUdhWHBGf61iIhfhMa0WfPt8a5HivQYa4B8mOixBvNw8H9swQ7XwxtgqZXmuQ5roMqeI+prt9jbh9C7BmYk+80UV8f21fEt+f+K7av4JXX/4HRg8eAz+3QGzd5Ijt272weaMr9uzyF9ue2LbZC1u3emL7Nl9s2+aHzVu8sXWbPzycY1B0+CSig2NwUPz7S4jJhs0eP+zZ6SPkj/WrnTkNaouFG7ZZeGLrRk8cCE+Dh1MItm9xxmYxvmG92L/ZG5a73BEZGo8Av/2w2OSOlas84ebgi8JEBxwN2oJj+/fI/0r0K4YCNSpUqFDxPXHt7kVEFHpxylPc8WBe5YmWBzY3gVQyr7zTmaAixOSsoTSok9fV/VP6aaJVwE4IHbtShEOnTyDq6Gm4HzwHy+iL2Bh6GSsDrmChdzHWRrjBJm07HFMzYXngW6wOKMMctzKGLgRfRlmXMqCZ4VyGRV5lWGLQUu8yfO1XhlX+ZVjhI7cXi3E6bp57mQnmrA4oh/fBShw6WcXunGvfUrqUdO3oDh4VKlSoMBcEayorq3CvpBR3vrmLG7e+wcUrN3FB6Pzlmzh76QbrnNCZS9dx5qLUebF97cYdcc49XL52W+4X4+cu3eQ+6frNO7glrnf16g1couuJ889fvMbtBbH//AXaFufQmDZO1z0rxs+JcTrm0uUbuHHjFr79RlzrxjV8c+sayr69ifJvb7AqqL1LuomKe7d4rIzHaPs2yu7ewd07t3Hj+k1cuXJDvJebuH37W3wj3vc18b4vi/d1UXzOS0LU0mtevnKLRe+Z2itCdCydc+fOXfG5b+PKtTu4dPWOuFfiWNG/fPW22BbHiv616yRx7cviM52/gLNnz3GK2cULon/mDM6QTp/BaU2nTp029Ulnz5xlnTt7VhwrdFq2tI+3NenHnT93DlcvXcTd29dQcue60DWUfnNdSNwL1nXZ8j0T907cGxLdR136WO391dvi3or2nrj21Uvn+TXPnDmH06b3ck6833O4cukKbt28hZJ7JSgVz5TelpZQq/VpTKhM9I2qKC/HffEsVlVWimdSilxf90n378vxigrRymNIBBorysS5Jd+ivPb3L94zPRP0HND7r/E5heg4/b7Q/aJ7d+/2Ve3+0fhNlPI+Kbq/t65dwjnxeU+L70x+b+J7OncBl/lz3+Zn69atb3FbE/Vrb9+8Se1d3L1L96cM9+7eEy31xb9B8XzRNejYmze+EdcU0s6jfd+KZ/CbO2K/9jq36FrimNvi39ndb0vw7bf3cFP0b4qxb+58g/KSO3xfqsru0r92+Y/+VwoFalSoUKHCTFTeL+c0J5es7Qg44qClPKnitj9XyjGj9HNFgKbwahFSTpyAd8ZZ7Nh/ESsDrmK263WMsrmFgbvuYJDlLYywuomR1lcw33c/tsRtwbKgIEx2vIBJ9iWY5VKKJd5lWBtYjs1h5bA8UAHX5EoEZlYhOKtaIdlViMyTKVARuXKbxgMzKxnM0Hlz3csY+Iy0LsE891KsCyrHzsgKuCRVIDSnCodO3MeZ6w84zYr+RDNKhQoVKigI1lDNmioxGa4Qk+DSsgpWiUHmtssrxMRZTKKp1ffr55IIAJHKy8pRpo+Xltc4xiQz4/o5NBmXk/RyVAk9qKowr/uVZrblhL68nK4n3odo6T1VVYnPKt43bdPrlJWLvvaa3Ne3RVuuic6hz2vaL1Rq6JP4WHFdFl+7DCUEJ0pLUSZES6LX1r17D48x0Pie42uLjisXr3NffGapckPfcD/M6Mf2S1Xf16rKcvFa+nt7+P2VlZahQnxuAis/RVTgVm/pGZQpwg9L/D/Zf1BznLYppefB/aoa77NaYkx7Dh7eJ2W6V+KzSVXfF30f9emzV5SXMXAyfmZ5/8s1uCSf+R8T/Tuj5+n+ffHvjkHUA1aNYyqkKnVp55iO0fbrx9A+fq61/QS0TJ/9V16am0KBGhUqVKioFfQ/TJe+OYvQAjd20yScDEfRtcNmJ5VKSkq/XARldOdM3oViRBecgmvqOWyNuIwlPtcw3v4mBu6+jSF7bmGc3Q3MdL2Cpb4XsTb4HDZHnMHWyDPYHZsKy6Q92Bi9F9v3F8I2rhTuKZUIypQQhmrOUG2a+GP3kVxUUylCqcVSKSTDvqTC+4gW53mnVTKYIbfNdKdSTLArxfC9pRhsKdOk5rqVYV1gOVySK5F79j7ulHyHqgfSbWN03Dwk+q3RRGHsUxj7KlSoUKFChYrfVyhQo0KFChW1oqTiLtLPxrGbJvioM/IuHlRuGiWlX0EMZrT2+LUiZJw5jrDDp2Ebfx6rA69glut1jLS+hT7bv8EQy1uY7HiVwYxF2FlYxpyCY/IJeGUUwT+7EIE5UgE5uXA85ALL5E3wykxC9NE7SDhWJUGMBmF+qej8xEJZhDgosxJuyZWwi63A7v0V2BBczq6d6c6lGLanRLzfEizwKMOOyHJ4pFYgNLuSz6PCxPEFVcg8VYWzNx7gyp3vcPHWd7j6jSx0fKf0O3wjRG3tbVJp5Xc/CnxUqFChQoUKFXUrFKhRoUKFCkPQctw0ofTLs4N79m6knN6PouvKTaOk9N/I5Jy5Xojc88XwzzqDzWGXsdj7GqY43sAQy9vovf0ORlhL18zXARewLfIMbBNOwjO9GAHZhQjKPYaQvGMIO1yA8CPVCjtyFF7Z4bBJ2waXDDdEF1xASnGlWfDy34jAT8Kx+4gvuI/Y/PucLkXwhtw7VtEVWOpThjE2pRiwUxYnHmNbikkOQvalmCLaOa6lWOFXhjWBsiYOtRuCy7AxpAwWoeWiLedtKnxMonHSlrBy7IiswK6oCtgnVHBKVnJRFU5dfYBb975D5f2aIEeFChUqVKhQ8eSHAjUqVKhQocV34v94Oe4ToXDM2ILIQi9eAlgVEFZS+nHpTpnaKr4miwEHZp/B3tgLWO53FePsbuKrbXfQd8dtjLa9jnkel7A+5By7ZpxSjsM3sxBBOebBjDkF5R6C/SFrWKdtFttHkVxUZha2/JrS06TIcUPwhmrbOCVWYldkOdfGWeZThkWeZVgoNN+9jGHNsL3SeaOnTvXfWYJ+O4S0lreF+tOYpq+2laDHZqEtcnvInhJMcSzlosfrgsqw50A5AjIqkXHyPi7feYDKqloOHO33TYUKFSpUqFDx5IQCNSpUqFChRcX9chy9kslOGu9cK6SfS8DxG/lmJ6VKSkrVIiBzXOjIxWLEHDsFl9Rz2BZJ8OUyVvhfxWy36xhrexMDdt1Br63fYKTVTU5p2hZ1BjbxJ+F2ULpmgnOPIfQwuWTMA5nvU9jhI3DL8Mbe1I3wyY5C/LFbSP0fuGp+SAxtjpHbpgoRebIwMRUvJgVkVMErrRKOidIV4yRah/gK2MVVwDbWINquJeuYCuw9UAHL/RVcGHmFXzmmOZVihBWBm3vos12ubjXNsYzhEIGb/YeruMBxWUV1nRwVKlSoUKFCxZMTCtSoUKFChQguIPztWYTku8A5cztijwfh2LVcMQlVbholJaNqO2fyLxfhQP4pWMVewBKfq5jkcBND9tzGV9u+QY8t36D7pm85rWms3XUs8LrE9WYIznhnFFWDmZ/gmvkx+eXEwjZtBztrDuSfRUpxhVmg8r+WXpTYWJhYFxUo/qUiCEQ1b8Jzq+B7qIpXsSLQsy2inAsdU5FjgjbkwBnFK1SVwXK/hDbHrzzAvfLvcP+BwWmj4I0KFSpUqFDx2IYCNSpUqPjdB0Gab8tuI/X0fk55Cs53weFL6WISqgoIKykZRWCGVmgq0pbPdkg8z3Bm/L6b6L/zDnpu+QaDLW9imvMVrPC/gPUhZ7Ep/Ax2R5+CQ9IJeKYXITDnl7lmfkwhh3PgcMgee1M3IDgvE0mF95BaXPUQSHnSZVydigAOOXjCcqrgc6iSXTpU74aWJ6daOX13SGgzw1nWxyE3T0pRFW7cfYDK+8CDB9qPoAoVKlSoUKHisQoFan5h0MSO1qKX67lXmtal1/eRaM122kct7dfjp55bUVHB697r+yh+6FwVKlT8sqh6UIUT1/PhkbMH7jmWOHg2BsfFtrmJqpLS70W6c+bEjSIUXSvCsStFyDp7HEE5p7Ep7DKmOd3AYMvb6Ln1GwyyvIk57pfZLWMdfxKuacXwzaJVmY4hOE+CGXNw5ddVPjwzg2CVuonToOKOXUNdBDXmxPBGiOANLSlO6VaOCXJlqpkuZRhqWSq+pxIM3FWCCftKscSrjFOtsk/fx92y71BZJaEN/Tmh/qJQoUKFChUqfvtQoOYXBIGRsrIyFBUVITg4GBEREThz5gyDFdpHcOXmzZtIS0tDUFAQDh06hFu3bpmgCh138uRJREZGso4fP47S0lLeR8fQuSkpKfDz8+Nz79y5YzpXf92wsDBERUXh9OnTKC8v530qVKj4+aEXEI47EQynjK2IKvJBwdUcVUBY6XctgjPHrhbh6KVixBWe5LQmWqFpmvMNjLa9iX47ZSHgqU5XsS74HKcyeRyqdsuYByn/ewXmpsHu4G5Yp21B1NFTv1n6028tgjbktjlwWEIbj9RKrnWzJqAckx1KuSgxQRvqU92bsNxKnLjygJcFL6+i/2Ck/UCqUKFChQoVKn6TUKDmFwSBmLi4OCxZsgQbNmzAunXrMGvWLOTl5TGEuXHjBvbt24elS5fyvmXLlsHV1ZXHaX96ejo2bdqE1atXY/ny5Vi1ahUyMjIY1hDQ2b17N49ZWFhg5syZcHZ2ZlhD5xK4odel665cuRJr167l1yV3jQoVKn5ufIeqBxUoupYHt+xd8M61RtaFJDFJVSlPSr8v6e4Zcs5QQWCCM07J57Em8Aovn03OGdMqTTY3sNjnInYeOA2X1ONcBPjXqDHza4iKCjulO2FPyloE5qYgsfCuWZDxexOBm4RjVYjKq4JfehXs4yvwtV85hu0pwYBdJRhrSzVtSrHnQAXiC6pw/uYDdtpU3ZcuGxUqVKhQoULFow0Fan5mkHPl3r17+Prrr2FnZ4fc3FwcOXIEU6ZMgbW1NcMYctJMnTqVnTZHjx6Ft7c3AxkaP3fuHCwtLRnUEHTJysriaxHYuXDhArtk5s6dy21hYSFCQ0MxZMgQvs7169cZzmzfvh05OTlITU1lULRnzx4GPMpVo0LFzwv6N3Or9Bqij/uzm+ZAsR8Kr+WZncgqKdVFmeDMpWJknDmOsLzT2BpxidOaRlrdwsBdtzFw9y3McLkCi/CzsIqVtWa80ovk0tlmYMlvq3x4ZYXCOs0CLhkeiDt2HY969afHXQRtqDBxRG4V3FPkSlKzXUsx1LKEwc1E+1J87VcGv/RKFF56gNsl33E9GxUqVKhQoULFowsFan5BEKgJDAzk9CUCM2fPnmVHDQGYixcvwtHREfPnz8fly5fZfUOpSgRUXFxckJSUxLDFx8cHd+/e5Vo0np6e7KAh+ELt1q1bGdrQud988w0GDhzIKVT5+fkYPHgwX4PSneh8Ly8vzJs3j1OgKD1KhQoVPz0q75fXctMkKzeNUp2U7pgp1hwzmWePI+3UCSQUneSaMzbxF7DM96qYpN9k98xgy1tcEHh14HlYxpzimjOU1vS4OGd+SDL9aRenP+3PP4Xk32n6008RFSU+cESmR9GS4euCZGrUEMsSjLEpxWKvMrilVCDnzH1cvvMAJRXfyeW+td9QFSpUqFChQsX/JhSo+QVBAOX27dtcL4ZSoNavX4++ffviwIEDuHLlCqclbdy40eRyIeiya9cu7Ny5kwEPpUTRsXQ+wRW6xsKFC5GQkIDJkyfDwcGBARDtI5AzadIk2NjYIDExEX369GFgQ++BUqGoxs2MGTPYcUPHqlCh4qcF1aa5U3YT0ccD4JS5DdHF/spNo1QnRYCGltA+ePoEIo6cxr7E81gdeAWzXK8zmBljdxMjrG8xnBllcwPzPS9h+/4zcE49Dr+sQoTk/forNP0vFXr4CJzTnbE3dR0CcpORVESrP5kHFUpS7LIpvM+pUT6HqrA7qgLz3Mow0qoUo61LeRWpHZHlvMLU2RvVwEaFChUqVKhQ8b8JBWp+QRB8IREsiYmJYQfMoEGDOPWJnC1Uk2bHjh1cV4aOI2cNuW22bdvGThoCNfHx8eyKIRiTnJzMDpzY2FiMHTuW69lQQWEd1EyfPp3r1kRHR6Nfv37s0KHXpn0EfKiOzeHDh1WdGhUqfkZUPagUE9gCuGfvgleuFbKVm0apjojADOnEdZnSlFh8Em5p5xjOTHG8iVE2NzF8700M3SPbCfbXMM/jEtaHnIN13Em4HyxGUO6T4Z4xr3x4Z4fDKtUCzhkuiD92E7+X1Z9+DZHLJuZoFQIyqmAVXcGumnG2pQxtpjiWYlt4BaKPVOH4ZVl8+D6tFqX9rqpQoUKFChUqfp1QoOYXBDlZyC2jFw6m1CcPDw/079+fCwVTgV+jo4bSoYyOGqpXQ9Dl+xw1lDpV21Fja2vLKU/mHDUEamhMOWpUqPhpQf8uvy2/jfjjwXDM2IKoQh/lplGqE6LUppzzxUg5cQLhh0/DPvE8lvhcxSibWwxlRtvewGy3K1gbfB67ok/BLuEEnFKOw+NQMfyfQPfM9yko7xBs03YyrNmffxopqk7NzxYBm7j8KoRmV8ElqRLrg8oxxaEMo6xLMXFfKVYHlCM4qxLFl6XDRvysqlChQoUKFSp+pVCg5mcGTfCuXbvGzhhyzxAsIWhChYHfe+89LvBrb2/PDplLly4xPKGiwJQeRU4Zcs/Qak90/rfffssuGII8eo2aNWvWmGrU0LnkyjHWqKHCwpQCRZCHzlc1alSo+Plx/0EVztwqhmfOHnjkWCLzfKJy0yg9cdLrzhy/XoS8C8VIKD4J38yz2BNzASsD5GpNI61vYoSVdM2sDLiAPbGn4JJWLI4rRPAT7Zr5YYUdodWfnHn1p4DcJCQVlZiFEUo/TZQWFZlXBdfkSmwILsd051KMtinBBLsSWISUI/poFS7ceoDKKvo7SfuhVaFChQoVKlT84lCg5meGDmoovYlcLuSgyc7O5pWYyA1z/PhxpKSkYNq0aQgICOBltwnQrFixwrTq0969e9lxQw4aOpYcNrSCFMEZcsgQeAkODuYVpXx9fTF8+HBeWYpelwoRb968GQcPHmQnDrl3aNUnSpWi96ZChYofj9LKe0g6FcFumohjXjh2NcfsRFhJ6XHViRuFEs4UnURA9hlYxV3AYu9r7JwZYUW1Zm5inN11zHK7jHUh52CXeAI+GUV1Gs7UFKU/RWFv6kZerlulP/06otWiog5THZtKbI8ox0xnSokqwRSHUljHlCPt+H1cvv2A06FUqFChQoUKFb88FKj5BUFulpCQEIYtlNJE9WfIEbN//352uVBBYUpfsrCw4HQnWoqbnC8EWuhcct9QzRmqWUPuGQIvBHRKS0tx9epVBkA0Ttcl9w2tFkXFi6mmDYEdWkGKrkvnU0tOHNqnQoWKH48H3z3A5W/PcV0a16ydOHQ2Tkx6881OhpWUHhfpdWcKLhch+fgJBGSdwd6YC1jmdxXj98liwFQIeKLDNSz0uoQNIeewN1au1kTuGVpK2zzQqKvKR1BeJmwP7oJV6kZEHT2OlKJys/BB6ecrmVaLOlwFj1SZEjXJXgKbee5lsIujVbaqcO1bCWzUf0JSoUKFChUqfn4oUPMLgpwrBE7ISUMOmKioKHa/0FLael0ZqktDNWXCw8M5HYoKCtM4nUvLahcUFDDYIdGKTQR4aB+df/78eT43LCyMWwI/lF6ln0uvRa9JdW6OHTuGkpIS5aZRoeInBK30VFFVhoxz8XDI2ILgfBcUXM0WE+FjD02MlZQeFxVdLULGmeOIPHIKjknnsTJAwpnhe29xzZlJDtewwOsSNoadxb7EE/A8VMyrNf1+3DPmFXbkKJzT3Tj9yTc7Wq3+9D+QnhLlmFCBFb5lmGxfKp7LEl4lykGMZZy8j9slaoUoFSpUqFCh4ueGAjX/RZCLhYAN1ZGhWjNGWELA5d69e7yfQErt+jF0PIEdEtW5MZ5LfTqXihGTy6b2PjqeXpPOVQWEVaj46fHddw9wo+QqAo7YwylzK1JOH8Bx5aZRegyk15uhYsDZ52RKU1jeaXinn4VdwgVsDLuM2W7XMcr6FoZrNWfIOWMRdha2CXKlJoIzoXnmocXvU/nwzY7B3tQNcDhki/hjN6DSn/43iiuoQmhOFezjJbCZsK8Uw/aUYKFnGdxSKpF1+j5u3VMrRKlQoUKFChU/NRSoUaFCxe8maEnu3IupcMrYwrDm6OVMMUFWbhql31YEaPIvF+FAwSk4Jp/H5vDLWOp7FdOdb2C0zS0MsbyNoXtvYZzdDcxyvYw1QedhFXcSHgf1lZp+386ZH1JIXjanPxGsiTxajJQiSssxDxuU/jvRKlHxBGyyq2AXW4Gl3mXimS3FiL0lvMS3U2IF0k/ex/VvJbBRoUKFChUqVHx/KFCjQoWK30WQG+1O2U0EHXWEQ/pmLiZ8/PoRsxNnJaX/pfR6M0XXinDw9AkuBrw7+gLme17DSKtbGLrnFsbY3sBkh2uY6XqFnTOrAs9jx/7TcEw+Dp+MQgT9ztOafqoo/cklww17UtfCNycWiSr96X8ufVnvoKwqWEVXYKmPdNhQDRty2FANmxSqYfONAjYqVKhQoULF94UCNSpUqPhdxIPv7uPo5Qx20/getsUR0VduGqVHIUpr0tsT14uQefY4wg+fgk28XEZ7ssMNDNp9G8P33sQMlyti7Dy2RJzhYsBOKcfheaiICwIH5hzj1KYwM0BC6ftE6U/R7KhxTHdQqz89QlHB4dj8KgRnVcEmpgJf+5ZhopYSNceVVomqQNrxKk6JouxwlRKlQoUKFSpUVIcCNSpUqKjzQW6au+V3EJzvjH2HNiLxZBiKlZtG6X8o3TVDy2hTWlNi8UmuN7Nr/0WGMzNdrmPontsYYnlLrtTkfRGbw8/CPkkuo+2fLV0zCsz8t8pHcF4WbNK2wzptC6KOnlLpT49Y1cCmkt00K/3K2WFDRYfnuZViX3wFMk/dx50S5bBRoUKFChUq9FCgRoUKFXU+CNQUXz8Mp4yt8MqxwuFLh5SbRulXlV4MmFR4tQgpJ0/AP+sMrOMuYH3IZSzwvI5xdrfQd8cdDNh1G2PtrmOex2VsCD0Hq7hTcD9UjIBsVW/mfyFKf3JKd2JXTUBuEpKKSswCBaX/rQjYUEoU1bCxj6/EKv9yjLMtxVDLEsx3L+NCxLln7+Ne+XfiN1s5bFSoUKFCxe87FKhRoUJFnQ9KezpQ7Ae7Q+sRczwQRdcPm51sKyn9HBnhDK3WdPDUCXbNbA6/hAWe1zDB/ianNPXZ/g3XnZnqdA1LfS/CIvws9sScgkvqcS4GrOrN/K+VD++sCOxN2QCXDHckFN42CxKUHo0I2MTn35dFh+MqsdynDKOtS8S/kRIs8CiDS1IFCi7cR0m5WtZbhQoVKlT8fkOBGhUqVNTp+E783+3S63DP2Q37dAtkX0gRE+sCsxNvJSVzMgIZI5jJOV+MuKKT8M44gx37L2Kh1zWMsb3FYGbgLi2lyesS1ofIQsD2iSfEsUVcayaY0poOq7SmR6XgvAxYp26Gbdp2HCg4h5TiSrMQQenRiYFNwX2EZBGwkatEUf0afVlvh4QKZJ++j7tlEtgoZqNChQoVKn5PoUCNChUq6nRQ2lPepYPYl24B/yP2OHY1x+xkXEnJnAjKUJ2ZgstFXN/ELuE8LMIuYZnvVczzuI6pTjcwyuYW+u68g347b2OC/TUs97uA7VGnsS/xBDy0lCZyzai0pt9OYUeOwOGQHaxSNyIw96BKf3qMpAMbvejwIs8yTocavLsEM1zKsOdAOfLO3kdJhUyJUqFChQoVKn4PoUCNChUq6myQm6byfgWC811gnbYGyacicfz6UbMTcqXft8y5Zo5fL0L2uWKuNbM26DIm2t/EwN130HPrN+i+6Vv02iZTmiY7XsMSn4vYGnlGFgPOLKx2zCgw81iI6tR4ZoUwqHHN8ERC4R2z0EDptxMt6x1fIFeJ2hdXgeU+5RhiWYJ+O0ow07kUbikVuHT7AaruE4CXUqFChQoVKupqKFCjQoWKOhsEai59cxbOmdu5kLAqIqxkTrxs9g1aOlvCmcMXixGSexqbwy9jput1jLC6hV5bKZ3pNma5XsGaoPMMZSxjTsE24SScU45zSlMQLZ+t0pkeU+Wzk8Y6dQvs0nbhQP5ZpBSr1Z8eRxGwSTh2H+E5VXBOqsAynzL02ykdNou9yhCWU4nb2gpRCtaoUKFChYq6Go8VqKEUBaNUqFCh4r8J+h1JPxcH20MbEFbgjsJreWYn6kp1X7pLhoAMwRiqMVMkdOxqETLOHkf44dOwiT+P1YFXMMvtOsbY3ELv7XfQY8sdjLa9jmW+F7gAsPvBYl46O0RbNltBmSdHoYfz4JhuD+u0zQjMTVXpT0+AkooksLGOqcAUh1L02lqCkVYlWBVQhrDcSnbYlFdWQxv1l6MKFSpUqKgr8diAGppQ3bp1C9euXcM333yD0tJS3L9/X9urQoUKFT8/Ku+XI/CoI6xSV+Pg2VgxSc83O4lXqrtiOHO9CMeuUBrTccQXnURg9hnYJchls+d7yjozY+1uYbDlbYYzX227g5HWN7DQ+yLXmnGgdKaMIhOcMQcBlB5/UZ0ar+wI8XtgAddMSn9Sqz89KaKUKP/0KuyIqMAEu1L02V6CUdbSYeOWXIH8C/fxTSmluipYo0KFChUq6kY8VqAmPj4ekydPxooVK+Du7o7c3FxcvnwZd+7cQVlZGYObBw8e8LHKcaNChYofCvqNuHjnDFyydnDa05HLGWLirtKe6qKM9WXILUNOmfwrMoUp48xxRB09DavYC1jsfQ2THW9gjN0tDNt7C/133uaUpj7bb2OUzQ3Mcb+M9SHnYBl9mmvNeKUTnDmm4EydUT6Ccg/BJm077A5a4kD+GZX+9AQpRSj2aBV8D1ViW0QFpjmWin/DcpWo2a6lXIg44+R9XP/2AUorNJeN9r8HKlSoUKFCxZMWjxWoycrKwuzZs9G7d290794d/fr1w5QpU7BlyxYEBwfj6NGjuHjxIoObiooKBWtUqFBhNqg2zYPvHiDzfCIvyR1a4KbSnuqoiq8XIf9yEXIvSCjDjpmcM7CNv4C1wVcw2+06xu+7iaF7bmPArtsYtvcmL5s9z+MS15qhZbOt4k6ya4bSmmiFJlVnpu4q5HAuHNMdYZ22FYF5aSr96QkUAZuYo1Xwz5ApUbRK1LC9JeLfeAnDG4vQckTkVeL0tQe8tDcBGxUqVKhQoeJJi8cK1Hz77bcoLi5Gamoq/P39sWnTJsyaNQsjRozAwIEDMWbMGCxbtgz29vaIi4vD6dOnUVJSooCNChUqagSBmvKqUgY0NgfXIe1MNI6rtKcnTrpLxqiiq0U4eqmY05jSTp1AxJHTcEo+h83hl7DQ6xqmON7EOLtbGGktU5moAPAIa+mWsQg/C5v4k3BKOc7LZvtlabVm1MpMvxuFHT7Cqz9Zp26CR6a/Wv3pCRYBm/hjVQjJroJjQgW+9ivDGJtSBjbj7Uqwyr8MwVmVKLr0ADe+/a7aZaP+ZFShQoUKFU9APJbFhCnFiVKdrl69yuAmPT0dgYGB2LBhA8aNG4fPP/8c7777LhYuXIgjR46gqqpKu4IKFSpUyN+SS9+cgUe2JZwzt+Hw5XS12tMTIkpjIpdMwZUi5F0oRubZ4zh06jiST5xAQtFJBOechl3Cea4vw24Zu5sYZS1TmYbsuYXh5Jixv4b57Jg5h50HTmNfouaWyVFumd+7wo7kwz83CTapW+BwyBbRBRfFhL/SLAhQejJEwCaxUBYd9kipxJawCkx3KhW/BSUYa1vCjhta7pvq3BRfltCGatmoUKFChQoVj3M8VqCGgiZYVIeGYA25ZS5duoSCggJER0djx44dmDRpEoOav/3tb5g+fTpycnJQWVmpna3CXNB/PTJJG1Ohoi4GPd+kB+Jhz76QDIf0TQjOd8Wxq7kmRwat+kOFZfMuHEfW2eNIP3Mch05LUeoMOTUojebIJXJuVMMC2pdz/jhv0zil2xReFbomRXVR6NpG94dRtE9faYhAxPceq8EKcxDjSZHZz2VGdA/oHlItmSzNIRNXdBKheWfglnYOe2MuwCL0Mr72v4p5ntcwzekGpzGNsrmJ4Va3MHTPLYy2uYGZrlewwv8Ctked4eWyHckxc7AYvpmFCM49phwzSgblIzgvAw4HbWF7cCdCD+ciuajMLABQevKUXHQfB45UwftgJXZElnPtmtHWpey0mWxfimXeZbzk9+nrD1ClYI0KFSpUqHiM47ECNQRoaOWnEydO4ODBg/D19cXGjRs5/WnkyJEYPXo09y0sLLjYMNW0oXo1KvXph+PqN9/hjPij5PLt70yrIqhQUdei6v53KKn4DrdLvsONu+UIK/CGVeo6hB6NxsFThUg/fVy0JxBdcApe6WdhHXcBWyMvYUPoZawOuoI1QZexUfS3R13C3tgLsE86zyk1NuK4zRGXsCn8MnYduMjbjmLcNfUcfDLOwjdTyj/rLMIOn+ZUHHOi5Z+Dcs6I485wDZXII6e4nkqK+L1LPXkCaULpp08wDDpyqZgBxvHrEnzokOdxBjgEXug9FlyWcEuHYPTZUoSST5xEYvFJ/szkjCEgE3X0FPwyaQWm8/xdLPe7iunONzDO7iZG29zCKGtyy0iNtBGyvoEJ9tcw1+My15chtwwV/XU7WMyrMgVpUEY5ZpR+SARn3DN9YZ26Gd7ZkUgqumt20q/05IqATfSRKgRkVMEutgJrA8sxw7kUY21KMXFfKRKPVaFM/Tc+FSpUqFDxGMdjVaPm3LlzcHBwwPLly3n1JwIzEydOxNKlS7F7926EhYWxg+bMmTO4ffs2pzwpSPPDQbeHcrS3hZfDRvyxEpBeiaTCKhRefIBrbP+loqvyOBUqHpeg55EkHk9UVH0n/qCWulf+HW7f+w7XxbNLIghJBSOPnKM/zKsQmVcFP/GM+2eeh12aNTbHbsfG8CPYFH6RQcu64CuY5XodY2zJiUEwQJPtDZPG2N6sIbmf+rTv4f10LZbdLV7i+XvFx93kdqxoJ9rfxDyPa+wWWRVIoOgKLMIuY/eBi7BPPA+PQ2cZYoTknuHlpAkGheSeZrgRc0yoUCqu6BSSjp9kIEIg6tBp2aacqB7TRfvIHUTuFaPI0UKQRXf50MpJBFzIXUROI4IsBFhi6TXFa0cL7c8/xe+FFH7kNL83n4wzcE6RcGtHlLznBMFWBlxhCLPI6yoWaqLPPoVWYBL3Qv8eyClDqy8RjJnlegVLvC9y+tLmiDPYHX0a1vEn4Zh8nNOYyC3DYMbMRFxJ6YdEy3T75kTDKnUTnNNdEHfsupjcVz002Vd68pVSJJf2jsil/22o4pWhNgaXI/PUfZSrrHkVjzhozqKkpFS39L+MxwbUkJsmJCSEU5r+8Y9/MKSxtLRESkoKO2yuXbuG0tJS0/LcKn5aEIRxS67k/5I0YV8pxtvJdrlvGZwSK7gQ37GLD3jSq2zAKh6HoGeWYEzRpftIOy6XY406LBWaUwWvtEo4JwklVsI+vgKbQssx103+V1L5fJdgsV8atsRtw4oQd0xwOAMCLAxibCRwmeZ8FYu8L2FlwAWsCz4Hi7Cz2Bh6lvsrA85jic9FLPC8xCsDLfK+iFWB57Em+Dyn19C++WIfFaed7nIF08W1SFOFCDCM30erDD0s2jfZ8Sq/9hRHcZzddYyxofekAyD5/hhWWMtiuCOsSLdla01LSN/i5aWpNssc92ssSgla5nuVgcj6kCvsCiIgpQMg6tM47wu7zM4Vcg1t3y+1Q4hWSPLNOMuuHwIvwbln4Jx8Hjv3X8SGEEo9uoKF4nX015zpeh1TnG5gksNNll68l94ntfT+9Xtt1FjxmccZJe7LFHFP6F6vEvd9c/hZ7I09xTCGXDK0PLZfZiGvxEQpTKq+jNKvo3xe8cnu4C7YH9yLyCNFYkJfbnair1R3RNAmrqAK+8X/lpy78QBVajUoFY8gaM5C5Rxotdry8nKuwamkpFQ3RP+m6d82/Rv/X/CJxwrUJCQkoH///lyDhlZ6WrFiBac4JSUloaioyOSiUbDmpwdNeumPE7u4CmwJK8cK3zITtBlrKya39qVYHVAOl6QK/gMm/8J9XL79gFNIxG0W91mTdj0VKn6toGfK9HwJ0bNKRR6zTt/n+gJrg8ow1bEaLhpFzy2BGX17skMpZrmUYbFXGb72u4s14YHYlrABWw5EYl3ICawNPseghUAMpcvQqj+eh4rhnVHEzgxa/YdEfRrzTC/iVYHIueF5qIjTanxonxinbRonkOCSJpR6nOUsRNf9IdEx+rF2CSexI+o0r0REIlBE6TzL/C4wCJrpehlTnK7yUtIEeKZS3/5aTRhkL9uxdgRBhMixI1qGIgxGakoCE6MbSIrgyhibW5jmfIMdR5MdbtSALXQugRXT62qvTe+FRO9rogNBqCsMsAiCEdSiz0MQbJP4fFsizmCHuPd0/0nkkDGtwCTuJd1j/2xahUnVlFH63yskLwsu6a6wSdsG/5x4JKr0p9+N6D8AXLmjlu1W8b8PHdLcu3cP169fx8WLF3H+/HkWZREo/TSp+6X0OIqeS/o3TYsf3b17l2vm/tp84rFKfaL6NARlXFxceGnu+fPncwoUFQ2mFZ527tyJgIAAZGRk8I0hiqWAzQ8H3R1amjLhmCywF55bBd9DlbCOqWBAQ5NbmvSOtikRE94SrPAr431BmZVIKarC0Qv3ceHmA9wtkylSKlT8GlFeKVOXqHbSiasPUCCes6TC++zymu9RhtHWJRhnW4oZTmW8vdirnLXUp5yf240hFdgQTG05du+vgGtyJdciCM2pRGDWFdikOGBvymZ4ZCTANzMfvgRhNBgTlPPfgwBydfy3Cs0rQKB4LwQnWEZQpEEi1zQJdqh1TStmqGGXcAJ7Yk7BUohaAh5bI88wEFkfcg7rhNaHnmM4QgBog+jrImBF7iByDZGbiPS10AKvSwyCJjno0OUaZrtdZthCcIucLjv2n4ZltPa6sacYstB7sUs8AYekEwyf3MR7JMBFThgCL/R56LORI4ZEn5fSlXQpKKP0Wyns8GF4Z0XCOnULXDM8EXvsKlJU+tPvQgrUqHhUQf9hmf6r++XLl3mV2pTUVCQkJiE+IVEoQWt/TOaO+6ljSnVLj+J7/7Hr/dT38FPf139zvUfxGkbV3E//llNSUpGdk4tz5y/g7r17/G/+14zHqpgwQRf6Qbtx4wbXoaFiwbQst5WVFVauXInZs2dj6tSpmDt3LlavXs37aFWoX/um1KUgtkIT4YPiDxP9jxQqshebL6GNz6FKWEVXYJU/rY5QhikOpRhnJ902M1xKsdK/jCfClG6ScEwubUkFiekPHGJkipP9PoO+dvru6Tn4VjwPl25/h7MadCkSz8ixi/e5bkze2fvIEco4RSCmil1blMLkn16JffEV2BZRjs2h5VgTUI6pjmUYZV2KCeL5I2fMrqhyfu6CsqoQki1FqU9UayAqT9ajoTb6aBUSj0lbO9WZCDtyWEtpsEFQ7kExKct/aJL2pIqgRmjeMU4DIhHsCBSiZad1R5AuAj+6U4jSh0g07pNBKmIgpIvgCqUbUQ0YSj2yjjsJ19RidhCZYIsGWfTXJshCsImkYIvSk6d8BOSmYN/BvbA/ZCW2j4r/bVTpT78HKVCj4lGF7qY5efIk9scmwNo1AFttvWFh5Y1NuqzltmlMbG+y9sFmIWrltrfYFrIR47rMjf0MbbHxxRZbX2y2FX2W3K6p7xv/BbLTZG7fz5F+DdFuFi2pxrhx+6e8nnYcX8fQmvbpx5lkvCe/4v1hVV+PP5v+fYlxKTm2ifr6PjPaYmZMynBNowzP0SaS2H6oNYm2ddUco2dWPpey5X36M6094/yc6+O87WWQPu6FTXtJnrAwSez/XmnH7NFkOscDG8U2Se6j7e+Te61Wk6XYNqfdbrAQ7RYrT9i4hSMoOgu5hRdx+9syVP2K/+PyWIEaPQjYkMhC9M033zCJzsvLg6urK6/69Omnn+Kll17i9KhDhw6p5bl/IMyBGl0pQuRiIGhDk19y2lCKFE2cl/mUYY5bKaeekLNhpFUJQ5x1QeXsXjggJsfZZ+7j7I1qt41iNr+PIEBDRagpxz+p6D7cUioY5m2LqIBFSDk/I+R6We5bjqXe5VgiNM9dpjFRmtJIq1IM31uC0TalmGRfys8ViUDhSv9yLvYYlFXJAIaeTwIw9Kzqqv0cG5VSVAGf7ChYpW7kVV1CDufUmpwpmRM7fA5TOkg1iFHwRamuK+RwNlwzvWCdtkX8bhxAYqFKf/o9SIEaFY8qCNRQSkRhYSECQqMwerUnWg73RuOBXmg60BtNBwkN9kYT0TYRY9Q2H+KL5oN80Eq0rQaL/lBftBjmh5bD/NFquD9ajwhAa9G2FKLtViOkaLwNaaTW0nGa2owIRNuRQqMC0W5UkJBoaXt0ENqOEdtjg9GeFaK1Uu3G1FT7MSHoKNR+dDA6iO2O4ngS9U3b40OrRfuE6PrtxovzJoSivRgn0XaNY3WNC+VzWKJv3CfPq75G23EhaEvXFq1xnPsTwvj19PEOQnTt2tejYzpMlMfS9eg8OkdeQx7D16d94j3xfRH3jdSe7okYp/dK+/T3zePiuA6mfdq2fp9oP91H7Tz93Op7Lr6X0YFoI0TfEY21EWOthVqKsRajAtBSqLX4HluLtpX4zlvT9276juX3Td99W228WvpzIZ8ZfoY00TPVcrh41kx9f/H8+fHz12yIDz+bLTU1E89lU4NaaOP0zJJaCrWg51c856QmuuiZF2oxwBvNBnihUT8PNBRqLNREqGlfqWZ9XVlN+jijUR8XNOzjioa9XdGotxsafSXU0w0Ne4ntXi5i20n096FhT3FcD3FcT0c06OUg5Ijnv3QSEts97NGgpz3q99iH57+wE7JF/S9F290W9bpbod4Xe4VsxLG0bSMk2s9t8OxnVnj2U9JePCf0vOg///Ee1PtgN+p9uFNoB57/aAcafLIbfxnjhss37qH8V1xe+bFz1JCoDg0tu11QUIDo6Gg4Oztjw4YNmDZtGsOZYcOGYcyYMbwSFBUaph9CFebjh0BNbSWLSXFcviy0R+4FzzQJbrZHlPMEerarrBcy0rqEa4Is9i7DlrAKOCZUIDiLJtVVnMJy8+4DLkzM8EaTiic79O+xtOI75J65D/906YYhuEIQj54LHbpMcypjzXAu49Q60hxxHKUwLRRaIp6br/3KYBFaDssDFZxqZxsrXVthOVVcPJhcX+ae0R9WFRKO3YZLhjuDGpp4UXpD7cmZkpKSEolWf/LJOcDLdNPvRkzBJaQUV5r5bVGqS1KgRsWjCpqffPvttzh27Bh8gyMxZIUXGg7yQb3+vni+nw/rOVJ/OVZP9Bv080XD/n5oONAfDXQN8hfnaRpc3W80OACNhgSg8ZBANBkayK1RNNZkaBCr6TBSMJppaj48BM2Emg4PRtMRoi9Erd43p+ZCLUaEosVIqeaiX0M0PirMpJZ8nOiPDkOzMUKibU77qBUyHislz28p9pF4zHBNOodFfX2b++K1uS9aOnZ0OJqZOUa/jul6mvRj6TwSn6O9X5bo0zZfnz43fy55veYjxX3RxvS+6f4IyXsn7nmt+/h999n0XYjvpclw8d1xK9VYqJEYazAsEA3Fd9uIvnPR55a+a/7OxTmibaQ9A/yMCOnPhL6ti54jer501R/oh+c1cX+AH+qxfFFftA3Es0nPKD2vz2p6Tqi+GKNxEvWfF6Jn+9k+3g/pud5eqN9L6rlennimhwee6emBp4Wo/6zQcz3chFzFtgueFu1TXwp94YKnujvj6e6uePoLN01i7AtH/Lm7Pf78mQv+/KnQZ6L/OckBf/rMEX/61BH/J8b+9Ok+/OkTO1P7x49t8YePrEW7V7SW+KPo/+FDa/y/D/YKWbH+f+/vFdqD/98Hu/H/3t+NP7y7C3/4zy78v3/txB/+tV1om9S/t+Ploc44f/UuyirqIKghQEPFeKKiorBnzx5eknvs2LEYPHgwRo4cyXVq1q5di3379iE0NBSZmZmqTs1PCLozPxXUGEUuhkQCNwUytYTSpGgivUdMrNcElmOhp5yMj7EpxZDdJQxvpjuX8gScjiHIQ2kpWadkjRuqSaJ/TaZWNioes9C/F/qeqE/tndLvUHjpPrwOVmKpdxlG7BXfuZX4zp1KsVJ85zsiK/h7J+hiF0erMVXCKbESLklCyZXwSK2Eb3olArmOjExboppJBGXi8iUgpOdNpi/9MlF9icijxbA/ZA27g7s5rSHsyFGzEzQlJSUlUmBuKuwPWnMKVOjhHCQVlZr9fVGqO1KgRsWjitqgZuhyLzQe6GOa7NKElgENSUyC6xOgEWMEagjQ1DfCGh3YGCfaGqQxJ33SboQzzcREnwCNUUZg8GOgphmBh1GhaDpS9DUoQi2BDrldE4a0HCnF8GNMeI0xUisx3lITwZuWtJ+kj4k+wQ7q07EkBj8MQqqP18EIX1e/hlHGc8Tr6O+vFUtcV1Nr/XVEn16TIE0T+ryjxWcUYphTS9WQxrzovhF00e8f3TtdNe7tQyKApp2nSwNrjYcFsYwQR/+e+Xs3PAcEbOhZMW0bnx8hI6jh582w/bzYJlCjgxt+BrVn93n9uRWifm1QU0+IQM0zfbxZz/XW5YXnvvJCva+8pQjW9PDEMz09a4KaL91F6y623cQ+d4Y1z3zpgme+cMaz3UUrxNDmCyfROuLPnwl96iRFoIa1D//3qSat/8eP7RjS0PafPrXDHz6ywR8+tmJQ8/8+rIYzsjWAmvcJ1OzCH96ToOYP/ybtwB/+tVWDNb8DUBMfH89gpnfv3uyYWb58OUMbPz8/LjJcXFzMMIfSoQjQqNo0Px400f4loKa2dHATo0EbPzHppok4pbxQUVdaTWquu1yJZ+ieEhYVKSagsymknF03dC4VNr517zteFpMcN0bXDb1XFb9N0L3XvwdKa7p0+wGvvkRAxTOVAB25qsowwooATSkWeZWxo4ZATGh2FaKPVPH3S2l0DF4K7iOedEyKashQGhM5ZX4sfemXikBNQG4ibNK2wiXDDcF5GWIiVnfq0ygpKf36ovRIt0w/LirslRUqfq9uit8TVVS4LkuBGhWPKmqCmigMW04pTz5oJCa7jfv5iVZMcgf4SkgjJsHslKHJ8AB/NCKJfiMxZpKYWOsOGX3iTXpoW6ipGNOdM1LUrwVqxOSfpQEFXd/r9iDAQGCG3CWjhXSniZDuljHCDB3IsINmTDhDk1ZimwBJa4IjYyJMsIba1uIYHZa0pOPFeXwOHU/jdD2To6f6+rUlAQydEyFfRxvn90TXNl1XvJ5BEtjIcWrpM5qcQEL65zJJfx/adm1IY7qv1JLEvWsi7qEuHYyZB2QEaWqCmtrfm3TdaKBGiL5v+t6Nz4PuqjI+HyQTqDGowSBSNaihZ5JhDbtr5FjjgeI86mtQhqAiO2j6+nCrixw1NFavj7eQaHuLlsTb3nimtxee+UpCm+d7eeHpHh54isGMBDXPfklyx9NfuomxalDz7BdOeJYBjTOe6u7EbpqnPneQThqGNKL/mT2e+tRebO8TfVuWdNLYMayhlsWuGhshK/zxk72am8ZKtBLYmPS+0Ht78Add71rij//ZhT/+ezv+8G+CNDqocarboIbq0NjZ2cHT0xNxcXGc06mDmdLS0hpLc+tS8cNBd+jXADVGEbShSTetJEUTc3JGkEuCllTeFydTYtYG0io9ZZjmWMqT+wG7SjDZvhQrfMs5lYrADdXEoTSr9JNVOH3tAe6Wa7VujNI+g4r/PvR7yRL/T9d9cdPJMXPiygMGKlRzZlNoOacqUWHpwbtLMFB8f1RTZq6bLC4dmCmdVvQM/DcumF9TiYXfwiPLH1apFvDKDhcTsDyzEzMlJSUlXeS688uJg13aLjim70Pk0UJVVLiOS4EaFY8qHgI1K7zQRAM1TRjUVLsVnh/kJybCfmgsJsMEbBqLSXNTMSluNihQanAgmgrJybdhMi5ampzr49TSNjksSDSxNzlqtO0aEhP+FhoEqAEFDLChhkZJh4sJeGjS05lMAEfrtxijpxKFoxWJgIt+/pgItBwbgRZCrYTaiO12oyPQVojOI1hDAKXtiDC0Ea/delSYPF+Mc5qS2GbHjDiGYYn2enxNOobeq36M9pp0HvfFWKuRdH2COVLVx0rwwvBFXIOvq22bJN6PSbwtpEEkhkJCdL+q7yVdSxvTRNDLCG14XP8OGKqZgWsG0TFS4nzx3dKz0ERLcTM9H4Olm0YHMzxm2NZTpHQ11GANQ0Oxn4GNkA5veL8B1NAzzLCGnmUh3WWjw5rn+vowsHm+D8kb9UT/WaGn+5LThpw1XmjQS7Q9PfGcpmc1dw3Bm6cZ3hCo0WGNM575wkmmPGkOm2e6i+3PnfH0Z65CYlyDNeSaYVcN6dN9ePqTfXhK6M8apCFY88dPbIVs8MePCNDI1CcGNu8LfUAS4+/vxZ/elfrDe0Lv7sYf/rMdfyS9q0n0XxnmhPPX6jCooeW5L1y4ACoefPPmTQY0VC2dII05katG1af54aBJ+a8NasypOlVKum7IiRGQUcmFh/dEVzC4metGq0nJST+JAA65bqj2DS0LvjNSrvKTXFiFk1ce8GpCeq0bI8BR8dODbpd+3/T7SI6Zb0q+Q/FluWQ7QbMtYVT8V6azDbUswZA9JZjiSM6Zck512x4h68gQXKPvl+oZmXsOfksdyD8rJloOsEnbKSZe8Vx/wtzETElJScmo4LxMrlFjk7ZF/HbEMPQ19xujVDekQI2KRxVGUOMXHIURK7zRcrAENKYJruZWeJ4mwqIltwK5agjUEJwxyghqdDhDIgDDLhrR6mIw8wOTfFILIXKo6CLIQCCBYYMGIyRkkDCCIYa2j10now3QhaTBFR2ycF+MMxwR/dZjI1gmYEP9cRLSkNqNjUT7MZEMa+i4tuPC8fL4ULw8NhAdx4ahjdhHMIeObTkuUl6HJa9JQEW/ViveL8eNx0kQI7fJcdNKE/cNx/L7pPdO9+F7xNfSt+keCXHalDZmvHe69DGSTBuToKaZkGmcQU1NEGMCOCaQIyS+Y/271NOidIcNnWd8RvSUKOOz832ghiENSQM1RunPa8MB1c8xiVKiqIYNpTwRoDGBmn4S1DTo68tiUEMpUX298Vwfbzzf2xsNOA2K6tXImjUEa6hmja5nuXUXojQoVzzdwwVPkb50YWDzDNetEfpcbFP9ms8duUbN/32+T7RST31mj6c/1UANpT4RqNHEsOZjEgEbG+mo+XAP9Fo1f/jAGn96zwp/JEjDoMYSf3x3J/7E2mGCNa8Mr+OgJi0tjZfgHjduXA2NHz/+IU2YMAHbtm1j1w05bVSYD5qoPwpQU1sEbijNhRwaBG+oXg1N8h3i5QpB+pLMlEJDqwEN21uCfjtKGBLQNtVB2RRSxg4dAj5UK4dXmbr+APfIeSP+wNIBhFlpn/33FLXvAf0RervkOxy/LJfG9hf3kerFWMXI1ZnI8USrMA3YWYL+4t6PsirFTJcy8b2UcZFfgmwBGRK6xebLVCZ9FSZz3/lvqypOdbJN2wmnQ04IzDuIMJX2pKSk9BNEUNc7O8qUNrk//4z4nasw8zujVBekQI2KRxUPgZrlGqjRUpu4Fo2Y3OoTYwI1DbWUpyZiwkywhtRETJgJ0jTRQA2JJts86dYm6zRR50k7TeI1UEMOD30ibxQ7PzTp29IFIkGBESzoYhAjjmkljiVxqhCNjdb2iWMoPYmBh9ZvOzZSKAKtCZjQPuprajNO7NPFx0Wi3bgoFm+PiUTnCRHotTQGQ9ZG49VJwTxGoIYh0DhxHXEuXYevqb+GaNvQ+XztKN5fQ4bXb82QSFxLiNrq96ddV7umDmRM7iGtrwMd6utpX7XTv0jyPsnrmMbpPgvRPdWvT+O664YcNgxdqBXimjbaeFPRUvFmAm30/UmoI0T7hIwgh8GdBmd4W+sb4YwuSpMieKO7asyJU6CE6PltbJCeAtWgnwSQ5LbR69jQuA506ottKj5MEIdSoAjUPN+7OjWKUqFI5Kp57isJbJ7mGjVu7Kh5uqcbnhL9P/d0FaqGNbKoMKVCUc0aau3x5+77WE+RdGhD6U8EajSnjQ5qGNp8KosL/+EjK/zxY0vRUjoUgRrpqvnj+2Kc9B65a/YI7ZagRnPXvDLcue6CGkpp8vb2RqdOndCiRQt8+OGHGDRoEIYOHYrhw4c/JFr9ycLCgleGUqDm+4NgxW8BamrLlC4lJvtUw4RqmtCS4JRCQ4WHHRIqsDOqnAvTznCWyzf33X4P/XdWO29mOpcxXCCHBy3hTOfSBJ1WISq4eB+Xbz9AWaX846uGC0feijoZ9Nl0MEPwqur+d5xGRnWEdon7udq/HAvcyzjtjAoAD9pVgj7b6d7KWjO0atP64DIuBOyYWAHvQ/J7oe+IINv/sqbMr6nkojJ4ZYVhb8oGeGQGIeRwrtkJmZKSkpI5BeYeZEeebdouBOUdRFJRidnfGqUnXwrUqHhUUTv1afhKbzQbLCeyTfr7S4lJLqU4NSZII8QpTwRnhBoOqU5X0Z0QtVsd1NQWgxjjtjZGzhmuE6OJHTLcaiIAMVo6SfQ+O1CE2gi1HRUhFI52lC6kuVAIfpAIyrQdI9VG7NP7lMrErQZQdGhiAjRaS9cghw2BknajI/HChEiMXhuDzW4H8fGcQHQgt43YR4BFhzR8HU1G0EOwRt9vlA5pSK3Gic+mifrVoEYDOfq2eO9SGpwS94ZaPk4TuXgovYvSvGrXtNHdR0Ygw/dXu/86tNHHSQRlGNCQ64auKcaosLFMlRJjdLzYLyGbBDcMcTQZwZ0O5HRQUxvQ8POl6eF98hnUnTZ6vSR6Xo2gprF4pnWZXDZUe4lApOib4A0BGqH6fUWfUqEI0HxlLDYsx+p/5cWFhnVQ82xPVyE37v+5l4eQG54SY7qzhtXDUbRCXzjjz90dpKh+zef2eIocNt01lw2nQsnUJ71Wzf8RrCFXzUfVkmlQ5K4R+mAvAxsCNeSukalQlqK/Q2i76OupT9+irOLX4xKPlaPm8OHDmDp1Kt58801069aNiwpv3LiRV4LKyMhAVlYWKzs7Gzk5Obw09927d/lcFeaD7szjAGpqi8CN7rqhNBqCOLTyDwEGct44J1XAKlo6b772o7SpMi5UPMSyBD223GPYQC4cWhKaVh6a5SohDhU2piXFyYUTf6wKR849DHB0sPGTRfeR/t+vFPr1fg3dLfsO528+wNHz97lmzO795VjgUYZR1iXoJe7TV1vvMfSie0QFnzeK+0NpTLQ6k3NSJfzT5XLsVGvGVOxXyNx39viqCrEFl+GS7sYFQX2zoxF2WKU9KSkp/XSFir8/CPJapW6CZ1YQ4o5d5wLl5n9zlJ5kKVCj4lFFbVAzYqUPmg2VjgSCMk2Emg8IQLOBAaIvJsQ0CRaTYqNzxpiuojtlassEYzQQwwBA65vGtHEjpCExMNA1OtyU+lM9Jo7ToAQDEgITYyLQTnO3MMCgfaKlbQlnIk1ghtKYuO6M6Nd2uBBsaTteByw0FoFW4wl60HlReHECwa39cAzKxNCV4eg6VjtugrimOE8HNBLSCPFryOsS8DG+luk16f2b+uKzim3dTUPAxfRZ9HMI+PA+0WqfkYAVf1Z6PU10DLtmxL3Ta9ro95CdRuJ4070V+/leG9OkGMjoCmPXDAMXgjD6fqplo0lPgTIVFhZqPCKY1WRksNgWzwbBGRIdS+lQhmeGnimW9nzpqglppOQzKeFhU/HMknRAw6BRqHl/fzSjbdE2IhGgYUm3DUEactboKVH1+/qwuHaNwVFjEjtrPPEsLd9tSn/ywFO93E0idw2lQbG+cMXTBGm+dOBVoJ76jIoMSz1Nq0Lxct2aaoMaIXbZfEzSgM2H1kJWQntZf6D2g734v/eF3tuDP723W2gn/vjuDoY0f3x3G14e6oALdRXUUFDdmePHj3MhYRsbG06D6tu3LwYOHIj169fz+LVr17g2TWVlJf8AKkjzw0F353EENd8nHd7oxYr1pcGDMqvgc1DWvOGCxeHlWOJdxgCCAA4tE07umx6b77FbhFadGmNbymlU89zLGPZsC6+AU2IFQrKrxPUlxDkl7g39wXbj7ne4KUT/tuiPN13kUqnhzjFKu78/J+g8vp5+bcPrGF+X68iUfYeTV+8j4xTdiypEHa5EUFYl3MQ92Btdjg3BZZwiNsdNfk4q9ttrq3QhzXIpxVZxj+zjK+CeUslpT3QfeUnsfHlvkzQo8yQ4Zn5INJkKF5Ms+0NWcDhkp5blVlJS+gXK14oK74ZTugMijxaJ30dVVLguSoEaFY8qHkp9WumDFsOrHQrknmlOtWcGkeRkmIq/6hNmamlSzc4ZIR3IfJ8IxtQGMTqgMQdpeIUjDR5UQwRNhn0MKghsCFHtF4IZDGMYUEhIwbBE9I3isdERaE+whrcfBjVtxkehHYn3RaD1BDnWfkwUO2r6LYuEV0QOZm6LxkvjxbUY5oSJ40WfIY98nfYTxDW012wtxlsJGV+LxO9HXNu4rUMW+frys1EtG/0Yk+jaDKAMn8+wrV/HdC8JzowiF5L87Ay1aL8YJzBDLbtstG09ZYqXOh8tHTmUAqWnoul93tZEfR3YEKjRCxOzE0eTCejUelb4udKBjQ5l6PnT+2ZE6XfN6JmlZ1UDjQRpmg0QYwQcNZcYp/WxZJpfbVDD0kANjXPtmt5emiSoMaVAMagR6uEJLi5MaVC9qF6NVE1Q4yTkIPqOXKeGatfIQsPUd2A9TStCaWlPRnhDY099KsYZ2NjgTx9Z4U8fW4k+ARsJa/6kg5r3LYV2sshRI2vUbMOrw53qNqgh6EKiHzYqJEz1Z/bv3w9LS0vMmjWLU6GoZg0t2U0Omzt37vCxKr4/CCQ8SaCmtggisHSooIlWmwrLkQWLyYFDRYjJIUL1V2jFomU+5VxvheBF3x0l+HLTPfTcUsL1WCiVarxdKa9IRYWM57uXsQuFlhJf5lPGRXXXBZUz6LCJrYBHWgXXaSEgkHXqPvIv3Of0IvpD7+o3sjBveaVQFYEeKWNfF7l66JycM/f5fdsnVDB0IucQrZRFr2ch3jstg03vgRxCs8T7m+xQyqsvkUuG3DGUvtR7+z18IT4TuYuoMDOBqunO0lHkmFjJaWF0j3SHjH4fzd3jJ120QgsVALVO2wS3DB8E52XxpMv8ZExJSUnJvILyMuCc7sq1agJyk1X6Ux2VAjUqHlXUBjWU+tR8GNX6kGkk+rLI5KBhtwK1GqRpPFTWoTFNqg19kp7WRI4Zo2vGCGI4rUkDNcZxfTlqdnqMlQ4S3fHBBXkNcMYIKrhArxADD3LB6JBFU3saI9eLOJbhhTiuvWg70LbYR6CGj52wn9VGqC0BFu1ccte0nSi2Jx5Ax/EH0E30v1gYCd+oPKyxjcPrE4PQYbx4z0LtxoWjPZ0nrtF+vJT+Gm3ENVsLtdVehyWOZTBDrd4Xos9mGte2jWOmvpD8bLrkZ2TR5+L3L46n+ybGCNzwPdBgDoEauq98r+mea9BGdy0xGGPJMV5Fivdpx9Tq66BGhzU1AI74zpuKZ4OKC+uwpjag0Z8jo+gZ+z6HjV50uKkQF7am51WI3GDkpKGWUvgYzAz0l0vLi74uPS2qIYMZDdBokEY6a3Q3TTWsoT4VF5aOGm/RFxL953q6a+MEa1zxDNWuoWW8v3QSfSFquxOckYDm6c8c8KxoSQRqnjYAGrkilB0XGNZFrpr/+8RGyJpBDUMb0gd7GNT8+QNL/N8Hu0ygRpcsJlyHQY0xdGhD9WdoBaj8/HyEhYVh06ZNDGsoLWrVqlX846dq1Hx/POmg5sdkBDkEJaiuCq1KRO4RghW0ZDi5cGjFoh0RFQxglnhLiEOFdEdal/Dy01xQV4hgzpebS9Brm6zlQsuKD9tDS1OXsHOHoMk0TrWSTh0SAZ4lXtVa7lPGq1xtDKkpgkB0PK2mRLBokLbsNb0GvRapt3jdHtp7oD4dR69JtWR0kEQ1emiVpr0HKri2j1tKJbuNAsTnJccMF/w13KO6rrhjN+CW6QPrtC3wzo5EqFqWW0lJ6Rco7PBReGaFwCp1IzwyAxFXcE38llaa/d1RenKlQI2KRxW1Qc3IlT5oOUxz1JDEpLf+EGrFJJcmwDQRFpNjLgCrTZ6r4YzmqNHGCMAYIQ2DGa1tTUBGhzE1JCENuTzY4SFamvwbwYEJNGhwQgcXJHLAkFuFgQtpfE0ROCE4QdCFoY3Y7ijaDoZtBiuaCNKQ9OPbT9yPdpPEvokH0IlAzeQD+HBuFLwjDmOPWzL+Pj0InSdGiHMi0UG8jw4EaMR1OmjX420huibBGh3SGF+TZHzPPyQCL3qfoRC/T+119PcsZLoX4tr6vZJgp1rV7iPtfoqW4Rjdfw3g6HV9GOqIcRPYob4mhjS6THBGwhv6zvVlwgnWGJf75ufIKO35qiFDelRT8bwZ3TaNqNCwEMMactYMEc8jaVAgO2zIacN1lQbKgsMMa3RII0TOm6YEa2hZ+r7VdWxM4EYTARtWb9lSChS5agjSUM2a53t6oD7DGqFeHmKfK8OaZ3kZbxfROkt96STkiGe+0GCNJqpVYxQXGCZ3zSd2eMoEbGwZ0LBMsGYv/u/Dvfiz5qj58/u78WcN1ujA5tURzpqjpg4WE64dBGmowDBBmJKSEty4cQNHjhyBlZUVQ5ouXbpwUeH09HROg1JhPuo6qPmpojo4tPoU1WMhJw5BHN2JQ6lBBHNoRSRyozgkVLKTxpJWpwqr4IK8Cz3KuJjxFAe5xDg7WzTQQoCFAA8Blp5bS9BLiCALpWAZReMEg8jNQ2lbBG82h1HNmHJ+LVppaW90Bacr0XtwFu+FCi37pUuHTGh2FcLFe48SnyEmv4qhlO6Woc/4e4IzRkUcOQb7Q7bYd9Aa/jkJalluJSWlXyxa2t/uoCUc0u34t4UKlZv73VF6cqVAjYpHFbVBzZiVPmhHThkxuSXHTAOaAGuiSTFBmhoTZyGGMwaxQ0aT0SVTW1xHhSf+kSYAYHJ3EKghEQRgSFMNDwgoEHzQYYR0i0jXCLtWCK6Mj+JzTRCjFggxSYMbOqh5eL8UvZYRunQUfQlqYvCPWWHwCM+DS0AaPpkbgBcmiX3iPXQeH42OE0gHWJ3IhaOdT04aAjUkeq/8PoT01+HXEtsSRmmQhY4R55G+b5vO49fQztffvw616Bi9ZYl7WUP0WproPlORZf17MIEccb4EOnKMvjeGa6KvgxqjTNDGMFYb6LDrRkhPiTI+TwRnmhOgIfcNtRrY4W3tGeRnk1rxnOoOGwI1xqXjed9gCSH1Zea54LAQ1V9ix80A0e8nC2lTHZvG/Ui+aNTHC436eaGhUIM+nmgothv28RZ9KirsiedZXqIviwzXZ2hDY+SscWNo82wPkiw6/EwPZ+msEeI0KB3YcEqUvQQ3WsvLdnPak41obfG0aKn/1Cc2+PMn1kJ7hfbgzx9a4qmP9uKpD63w5/eFPiBnzS7prBGi/msjXXChrq76ZAwCNPfu3cOVK1cYznh6emLZsmUYNmwYBgwYgClTpmD79u1ISkrCrVu3+HgV5kOBGvMyOXFImhvHKIIgtBw1rU5FaU8ESQIzquCfXgkfA+AhNwtBHqckoUTZksuFQA+lNBlFS5PTsQSICBaR+4WuH3u0il+LRLVjCCrp78P4Ps19jt+7UooqOUWB3DQuGe4IyksXky2V9qSkpPTLFJyXCWcqTC5+UwJyk5BYeNfsb4/SkysFalQ8qqgNakav9EHbYTLNiUBN42E13TMko5NGlzG1yVQoWLS6U4bAjLn0pmpAo9WI0UANi7YJCBAY0KTDCAYR46r7OgAxAQghI8DQt82JwQtBFKHa+3TIQurAksd3Ev0uE6LxwqRYvD0tDPZB2Qg8kIWBy4Px0qRIdBHX6jIhBp0nRgtJSKOLXqfdxP1oI9SWHDraa+mfhV+DPp/QD71vKfnZCPYQ0DHeEx3UmD6/3urn0jHaObroO5Ct7EvJ7RrfBbmaTN+V9h2K/QzVCNwIUR0dvRYOp0QxnJH1blqMCjVBGhOsoQLFYpxTpMTzU720t3jW6Jmjvg5pNFBT43nUWj0dihxgugja6ACHxMWHxTOup0exBvijOcGa/uSs8UdjIV71rJ8vmvbzQeN+BGs8WY37i35fb4Y1Etpo4IZcNl95adCGQA05awjUuNcANc/1chGthDUMaSgV6gtHPCv03BdO3BKk0YENgZpnPreToEbTM58StLHG05/swVMfC31kiac/3ounP7LGUx8IfUiyZEDz5w93i/7uug1qyEFDRYIJztDqT15eXvj66695GW6CM5MmTeK0p9DQUOTl5eHq1auoqKjg81R8fyhQ87+VDlCMQIVBj1YM2SgdvNS+htIvFa1WdQeeWcGwSrXgVqU9KSkp/TciRx6lP1mnbYZHZgBiCi6L322V/lSXpECNikcVD6U+rfJBqxHSfcDuBYNrwSQDnOEUFq1fG8TwtpiAm8ZEn1KbdLeMaYKvTfirQY2ENrw9TpMBNuggQneOmMDEOOkWMTpGakINoYniWBKdO/EAi9KYOkyKFtK2DfskXIlmMMOwRhvrIo7vOiEaL06KxWtTIrHTKwORCTmYtikMr02OYBhDkKbLpBh0Fsd2FtemVr8OvY+2kySooT6DIm0fv57Y5s9Fx2rvp8bnMMnwGekeGO5PDUijHVPjnmjHdah1jqlvADj6vTVCMwIz1TBHbtM4p6hRShTBHNoW3yetNEWgxghm2F1jcNbwsuH6PvG8GGGNDmy4pg09lwxqqvdVS+yndCgN1hBs5PQofdsgctk0HyRadtPIGjYEahjOMKgJYFhD6VDN+/uKlmCNNztrGom2cT8f0QoRsOnrpcmTHTek+l95sLumXi8P1KOaNVrtmmd70DLeEtSwejhJaaBG1zNfUCqUvUyJIneNBmye/swOz3xqh2c/scWzn9rgmU/24umP9zCwIVDz5w+MjhpKfxIiYMOgxrVug5qjR49i6dKl6N69O95//3306dMHc+fOhb29PQ4cOIDc3FycOXMGly5dwuXLl9lNo2DND4cCNUp1VVTceX/+KTilO/FKLb45MVxjwtzkS0lJSemnKR/+uQmwP0iryNnyGBUsN/cbpPRkSoEaFY8qHgI1q33FxFlMbA2TYeNkuYUY49a0rTloNFVDGXLLSDdNdYpTuJjQV0OYHxLDAYIK4zW4QOBgQjVEINUGNZSOVNs1ogOXatGYHO9IYGZytNABtOf+AXQS2zTeiaCKUBex3WWyBlsIoIh9OoTpJkSg5uWp0VjnlIqYlFystD6At6aGi2vIY03nUt90DfEa/LrytU2vJ66rO25MsIZAjvgc/F55u1oEaehY2RefySDdYaTfh++Vds+M91FXbVAjlyfXIA2p1nf2kONG61e7bGRNG3LYmFw3JlATalpVikCNDvqo2LQOA2mJb1r+2+iq0Z9Lo3SgSICxybAgdoWRmmjQxghqWnD9Gk0MbKSzhmHNgABWs/5+LHLZNOlXLUqJYlijgZoGfTxQv4+7kGyf702gRtatqdfLHfV6euK5HgRsXDW5COmwxtnkqNHFKVEEaxjYVK8Ixe4a0sc2ePYTkpXoS1jz1EckK3bTMKj5kCCNpo924/UxbnUX1FD6UmBgIF566SU0atQIf/vb39hJM3XqVCxfvhxr1qzB2rVrTVq3bh3c3d1x9uxZ/iF81EFwiETvm1QbFun79ON+zn7j2Pft+6FrG4P2KFCjVBeVXFSB4LwM2B3cxbAmMDcNYSrtSUlJ6b9UyOFsuKS7wyp1M6dWqvSnuiUFalQ8qngo9WmNH9qN1lbpEZNeci9Qy0CGHA4GMKP32SEhJtSUskKuGaNbRoc0ciIvW570a5N7IwgwBwcYGkzQpAEEk/NEawlK0ApMBC0IPhDckGBDtnq/elvCGJY4R+6XfQI1ujpPjmHYUkO0j6CK6BN4eXFSDF4W/SXW8YhOy4OlRzL+PjMcHadEifMPyGsYrqmLQI0uOUbXp9ckqGN4fwbVvgYfb5LYT+9fO7Ya5sjPLSW3jeLxWmM14JhWmFiXDnZkTaDq74+/X3JD0fdK20LUN7mmqE/7tJaOpefClBpHcIbbaun7+BkTMrd6lAniaM+ocZtTpcTz24SAzVCtho0GasgxRoWGW5CrRq9hM0imQ+nLekuXjT+aD6DlvQnUkHzRRLSUDtVE9KXDxhMNhRjS9HZDg74eDG0a9PYUojQo6a5p0MsD9YWobdDLHc/3dEE9Ug9nPEegRkt/ek60lP5UT/TrifZ5oee6O4gxSotywLOfkZPGGs98YiVaqWc+3SsdNeyqkc4aKZkS9dTHlvjzJ5Z4bax73QY1ERER+Oyzz/DPf/4Tn3/+Ob766isuHEwid01trVy5kmvY/BarPlGa1okTJ5CWlobU1FQUFRWhrKzMBE5o6XB6b7S/oKCAt+kzUlDx4wsXLvAS46Rz587VOPf27dt8Ll2X2rt375rADDmITp8+zUWUMzMz+To/VExZgRqluqrEwm/hkx0F69QtcM/0F5OrHLOTLiUlJaWfIwK+nlmhWvpToEp/qmNSoEbFo4raoGbUah+0HSUmr2KC22K4mCAL0aSXl9HWZExlYmhDLS3fPFq6JWrAGS2lSZ/M6xN7c2IQoLW6yCVDMMa0bYIzGpgQknVgotmF8jBsqe4b9RAE0VXrOAYnZkT7yG3TdRLVqYnGzB0xiDl4BF5hmfhkQTi6Td2PblNixLGk6nP0trZqj5veV61x/Vo1JF6f3rsOZ3Tp1/hRUGM4p/Z+AjP6fde/AxadK9qa32HNbb3OjTGVTW7r0mFehFyG3QBnjNu6u0aHNQwGSRqo0d1dsi6S3CbpoMaYrqc7bZoNFc+3EMEaY7FhUrPBcoWo5gRpCNYwpPFFU2qFyEXTuC+lQfmwk4Zq1zTu7yn6HiwGNdynosOeqN/bHfW/cmc4Q2r4ldjH266o39MFz/dwZlhD6U/1SF86of6Xzmgo1IBAzeeOqNfdUS7fTSlQn9niuc9t8Oxn1tUiYPOZAdgwrJGSoGYPFxyu06CGIARBh9jYWERGRtYQAZzaY1FRUQw5aDUoHYA8qqAf3kOHDmHnzp1YsWIF19LZuHEjQ5nS0lJ88803XEuHxsgNRLV19u/fz+MElQoLC+Ho6IjVq1czbKKVrGiMIAz9oJOziM6ha5OTiM6lla/oXII+u3fv5vNIDg4OOHny5Pe6ihSoUaqrOlBwjgsI26Xtgk/2foQdPmx20qWkpKT0c+Wfmwj7g3s5/Umt/lS3pECNikcVDztqfNBuTJCY8NLEV0ySR0TwRJmW05YTZw3SaNLrjOg1SSidRU7AqyfmJDlx/2FQQ6oBA4R4dSWCMpoYSkzUtgnQiG1ytuji/ZOrxa6VHwAeRmcLqQYAEeoyJaaGOjN8Efv0Me7HYqxFHA6kHsWB+BwMWBmGl6fuxwtivPb5OgyqfX39miTer/WNY/p5xnP0912dRiWO0+6BXnOnpsR9NYAbCXPk8dTSuBHU1P4+dOngpvp7o3a/+I5rfp/GZ+D7pAMbHdqQjH1+zoQI1JggDT13Gjg0Ob0MLUlPgSKxy0aMUfoU9zVo04ycNkNkwWGuyyS2yWHDGuQvNdBPwhohaslJQ/VqmvQTonaABDV6oWEd2DTsJ8VOm6/c0JDUyw2NDP2GvVzRoKcLAxtKgyKXDW03JPUQfSHpqCFQQ7JHve778Hx3Ozz3uRBBm89E+6mENQRqWFrdGmq5yLDmtnljrEfdBTUU9INGThVyl+jt94n2k5PkUUMa3fFCEIWASXJyMrtbNm/ejMWLF+P8+fNcS2f+/Pnw9vbm/QRTKF1LL4Ls7OwMCwsLrrsTHR3NK1rRylbXrl1jF82iRYvg5+fHMMjFxQWTJ0/G8ePH+XUJDhEASkxMZGBFKWCurq4MgcyFAjVKdVFUn4YKB1NtGsdD9gjITUHYEVWfRklJ6dcRpT85p7vCOnUzAnNTtfSnqod+i5SePClQo+JRRQ1QExKFMWv80H6MnADrMKY2oJGOGSlyPjCkERNrLh6rTbjbiwl4zYm87OsTfXPb5sYJCJggDLlmCNZoDhqWts90zGQJHYxgowbo0CCHro5TojVRvyYc4WOnxqKrQSZIQq24Xhc6d1oChqyNR0TSERw8mIcpW6Pw+hQCNXHoJs4h8blTH4YwdC3jden1jDCGt0WrH1tjn1AnTfrn0I+l19EdNeYkHUR0jBTfH+7L/QxxhCQg22+CY6bvydjXpH/XPyZzsIZUe78OalqPkilS1StG6aCm+pnUn1PpqhH7NRjzU0Rwxihy2UhQE2CANf5oIdpmA/X0J180Iw0g+aApwxopHdg0MoEaNzz/lSsDGl0MaoTIVSNBjSvq9aJUKGcxRtvO3Cd48wwv3e3AdWso9el5BjX78Nxn9kL7UO9z6hOwsRaSzhoSgxrNYaMDnDfHeeDC9ToMap6UuH79Ovbu3ctAhhw05IQJDw9Hv379kJ+fz9Bl5syZOHXqFAOl7Oxsdsb4+vqyC4j6BGBu3rzJaU379u3Dhg0b+Nxt27Yx1KG0KrouuYz69+/PUKa4uBijRo3i16Lly+l8JycnLsBM6VPmoJUCNUp1UUlFJfDLieNJlFuGN0LyssTkStWnUVJS+nVE4NcjK4jTn2gVqNiCqyr9qY5IgRoVjyoeBjW+6DA2GK1GhYjJr6w5I0GNTEGhVnc71E5hIfEkW69dwi6Lh2GMTF3S+/p2be2XYGaidNGYVk8iYGCQBDQxsiWIMbkaYugyghAduOhjOtjQ1YVdMHFiv67q4/kcTfr5XadGo9u0OPRcEQvfmCPIzirAavtE/HVWJF4Sx7wgjiFQ01mo09Sa7+mHpB/3faDIuJ8l+gylNJBDLUMhTUZAw59V26+PG6UDGx2C0ffA34m43x1Fn+vUiO+nhvOGHDrUMmyR0Ma4mhRJBzGkmst/mwM1UeJ5ihLPGYmgTSRak7uGnkN6JgkSGp7L2tLdNcbUKBJtGyGNUc2GiXaY2C9EqVGNtSW8KQ3KJK1ujal+DbUDKC3Km501LAY21aCmQV93dtg00tSQtvu4o0FvN65pQxDneQI2QpQG1ainqxA5bJxYz/RwwDNfUo0aB9Trbo/nP9+H+p/bo97nYvszagnWUCpUdfqT3jeOKVDzGAUBFFp5ipw9BEcImuzatYudL/RjTGlLBFsIpJADhyDKjh07YGlpiZCQEHbQEHjRzydnDblxyH0zY8YM2NnZsbuGfuDptcaNG8euHHLbEAwiZw6lQREECgsLYyhEr2uuVo8CNUp1T1WIKbgEt0xv2KbtgHdWBEJV2pOSktKvqnz45cTC7uBuOKU7Iir/JFKKKsz8Hik9aVKgRsWjiodBjQ86jA0SE+EQMTmuCWh0h0NbbgnYyAm2uTQno4yT9drSQY0OZCSc0QCBDgp0acd0nRzDYiij9Vk6vKgFLQhwEEwxAo+uU2RL4zX3GSFN9bh+HZLRJdNtagxemBaLT5YegEtErpj/FGKvzyF8OD8Sr4j9L4lrdBPqIo7pLKRf48f08PuqHu9qGDcep392fR+PaeMEZ3QwI4FU9X3Sx6ntJO6jfiyvWCW+C/3ed9TSpR6WHCeQY+471iW/65rAhsZl3ziugxoJaORzJbd1MCgdXRIOfh+s0UGNngpFMMYcqJHpUVTPJgRNTS0VHqZUqAA0HxKIFlrdmprQRpcfmtQANZ4sBjVaGhTDGt4maCPVoI+bdNv0dkW9r8hR48qFhOv3cEYDdtPIZbuf6+GIekJUTFgHNc9/bod6n4t+d4I0VLOGatVUQxputbo1UgrUPHZBAIZEjhh/f39MmTKFHTOU+kQghlKUqIAwHUNLiROkIbeMj48P74+Pj2fQQqCGAA2lSlF9nrFjx3IqE0Ee2kfwZdq0adizZw+nSZG7hgoX048/pX5R/RoCNVR02FxRYQVqlOqaaLIUdvgI9nH9CDv45ySptCclJaVfXbSqnOMhB9ikbkXo4RwkF5Wa/U1SerKkQI2KRxXmHDXtDaCGHAxyUlw9MTZCGSOY0Sfdxsl5tcyPE6TRXTI6sGFQMzlGc8loEMagblNia8g4bgIUGogwQgtdBFleMAAOXXKM4IdRtY6ZHicUz8eSXiTNiMUHS/Zjb0AmjuYXwysiG32W7cfr4nwCNS+I8zpT2hNdQzuPrqVDFhJdU38tft/U17bNqbbT5odE12MIQ8BFtDrA0mUco+LHNcY1UEPfBde+0Vw3tWENj4uWv0Mh/m5rfdc/pmpIY3BpcTodQcGaS7vrsEZPi6otAjVc6FqT3KZ0vmpwozttmg2jFaF0BaLZ8CChQNEPEPv80WKo0JAANCdYI9RUAzW0nDct5c2OmoFUq0bCGnLTVMMaTzTWxiS4ke4aHdaQo4ZdNUL1etOS3bJOjaxZI1eEIncN1at5niDOFw5o0N1eaB/qcwqULep9bo163YU0WGNeBGr2KFDzOAUBGHK9UAoTQRYqDkwuGwIslNq0ZcsWrilDx9E41bMhVw1BHQI1BGV0UEP1ZhYsWMDwZuLEiVzDRi+STKCGIBAVHKb9ffv25R98HdRQUWVy4Rw9elQ5apR+F0os/Ib/S7dN2la4ZniJyZRKe1JSUvr1RUDYNcMbe1M38G9OQuFt8Ruk6tQ86VKgRsWjitqgZuw6P3QaHyImuyRZj4YmyzRRlhPmCBOYMYom2uSW0CfdnCqjT9jFuBHE0MSfYIzeN7lmNChgDsYYRW4Yvf8COVZ4LMbkkvkhSTASixenx+PFGQkmOEKg5MXpcUK0j7alXpxB4/HSRSPOY0ijQRUd1LwwIwb/Xrgfmz0O4mhBMcJiczFmfQzeFOe/PC0eL00XryOuTaDGeH43sY/eA8s0Ru/n+wFNbZkDNjJ9y8w479MgjCZ9W5c8X9vWAJgOzfh7MzlvpGSqlAZp6PvURN87ARv9Gagt47Oii54jhjAMZITGhWsiYCOfQwlpdFAjYQ61BGfYgSO2dVBjlAQ2EtRwvSUh3V3TggoMjwhmOFNTAWK/P5oP9UPzIaIdEsgiWEPQpgW7aij9SewfVJ3+RPVqTBqoOW36ezKsaUzgpp8HQxsSOWr0FKh6fVwZ2FAqVH3NYVO/hysaf+nCatDDGQ17OKHRlw5o+IU96n9hh/rdbfF8dxuT6gkZ69Toeu5zqbcneCpQ8ziE7pKxsbHh+jBUNJhqyRAoIYeNra0tj1MtG4ItVG+G0qGoFk1MTAyvEhUUFMQrOdGPOK3yRMWJqX7NkiVL2H1D16d9lB41dOhQfg2qiUOOGipeTJCG6uMEBARg9uzZ/Bp0fO1QoEaprim64LyYPHnA9uAuLe0pz+wkS0lJSem/lXd2OKzTtnKqZUzBRaQUq/SnJ10K1Kh4VFEb1Ixb64/OE6qhDEManiSHiglzKNqPDzeBmWpFmdwTenqLdMZUgxkJYmgSL/vsliEZQEBt94wOY4yqDR90Z4u+/RCg0JwxL0yPEYrGi6KVIshCzhgNuhCYmaHtmyZee4Y4T0gHKy8xUJF9giqylW6al2fE4e9zY7By30HkF5xCbMpRLNiVhLdnROOV6QmQoCYencXx1PI1+TWpTWC9KI7R+yx9Wz9WSEIc+bl0qMPv3bCP6uvo0oEPQRd9P99DAjJ0jzUgw9CG3DP6NvUN0mv/6KDGlCYltnU3lCzybCz8LLf1fUZwZw7sMfAbK1paNWp8JDqIZ7D9eM1Bo7tsGBiSdFgjgY0R2uh9KQIy5J4Jk+KaSyFoSWOkkQRpgoUC0Vyo2YgANBnpg6bDA9GC0qGGB6PJiCA0H+aDZpQCpakZQxt/bpsN9kNzoRaDfNFskDhuoDdLBzZGh01zGusn+n09WHqdGioq3IhhjausV0OghrYZ1Lig4ZcuaETSQE3DLx1Rn0GNbQ2ZYM3nsqiwXlyY6tforpt3JnjhogI1v20QpKGaNORwmTVrFjw8PLjILzlpaOUlgi8EY8gZQ6s2UfoT1aAhcEMuGlq9iVaIotSos2fPsttm/fr17Lg5ffo0A5m5c+cytKFr0ZLfffr0YThz8eJFhjIEgsjNc+bMGXbuEASibXpvtUOBGqW6pJSiSv6v3LZpuzjtKSBHrfakpKT0v1NAbjL2HbQS2oPIo0VILio3+9uk9ORIgRoVjyoectRooIbgjEw1IWeD7m4IY1BDE2QjrKHJOC+jTS2BGtGnSTlP1rWJe23pMIbhjA5hRN8IZcyKHDQGMEEtQRQdfBA8ofQkCWdkn8EKQZcZBGqi8dL0GKFYvESOFtrHx0mYQ5DmJXHsizPFmNCLMwnSkPNFvI7Wf3lmguyL/XTsyzNj8Jc5sZhnmYojBaeRcvAoNjoexN9nR+O12Yl8zgu6+PWqRYCGHDUMZkyS47IVx4nPRq0OiKrPleL7Ie6FDmxqi+8N9TX3UfW9lPeP7iOptsNGhzx6S9LhDYEaE2AT0sGM8TvWv3uGNboY5Bm2hSTEoWcpWltNSjxbEyIY2OguG1307Bm3Sfoxxn3UbzMmjJ9j6bCRy3xz6pMmgjiU4tdyFC1HHyjkj+ajfMUxQWg7PACtCdKMDEGrYf5CAWgp1EL0mw+VajaEnDYaqBnsi+aDfFgthHRgo4ugTfP+3kLUeqFJP08GNY2EmvR2R2Mh2iZYwy4bIV4ZqqcrGvd0YTXq6SS2HdGwhwMafCn0hZ3Ul3Y1QI0R2Jj61H5ho0DN4xAEQ6iYb48ePfDuu+9yod958+Zh4cKFvGw21aghALN9+3Z2zqxevZpbKhBM+8hxQ8CGVnlatWoVVq5cieXLl3NaE/2YE3yhWjZ0HhUkJocNQR0CMeSgiYiI4OMpvYrOpeW5k5KS2HljLhSoUao7qkJC4TfwzYmFdeoWTnsKycs2O7lSUlJS+jUUcjgXTukusEq1QFDeIbVMdx2QAjUqHlUYQY0/OWrW+YsJdyjajqNJrhCnnYiJ8Dgx+R1HLgdy1NDS29WgRndLGCfd7KoRfXLQ6FCGwYyYuH8fkNGPqT1O6U0k6YCpBjQMK2YkQHe7EBCRIEUCFCl9XPRnEoQhSBODl+k4cf5LM6QrRoIaAiJ0DkEZCWqopf2kl2YSlInDy7PEeaIvt2Px6qxovDk3FuO3JSM3/wwyMo/CxjcdHyw4gFfn0PFC9D6nE7SR77daGvgRLcEg4+eQYxLk6DLBG62VoIbeOx0v74O8jryWlDyP75vx3mr3kcaNUIalgRnTtklynKV9n+y40aAMf8dC7KAiiWfCKDpG38d9MVYNbKLF86SlSjG4qenc0oEMu29qSY4boQ09t+FoI55h6a6JhKxnQytH6atHSVDTenSQ6AcKBaClUMcxwXhrUgBeGu2FtqOC0HpYIKvVcAlqaojSogb7sqOGRX0N2hCwIVGfYE2LAdWgprnocxpUXw80Zcm0KE596u2KBkINv6IlvV3RhNTLBQ17OaJ+TwdWgx4OaNRjH0sHNTVgjb5tko3YtsFfJipQ85sHgRpyvtjb2/NKT+SsoRQoAjHkrqF0J4ImhYWFnNJEhYFpZSZy0tAKTpQKdevWLXbK0DLedA6BFjqPftAppamgoIBTo6hWDV3j5MmTPE7nUu0agjru7u58Pl1Hr4VjLhSoUaorShGTo+iCc3DJcINt2k54Z0ciTK329MQqLO8otri645PefdC4eXP8f//f/4eWbdvhkz59eZz2mztPSelRipfpzgyEdepmeGWFIe7YNf4tMvcbpfRkSIEaFY8qHgI16/3QZSKlOYWxOO1pTBTDGnY4jI+QE2gNxhghDck0Qdcm4vrk3Qhh9LoyPyYjoHmRWgOsIUBhhB3VIkARw2IoQ9BFGyeoQnplZpxQvFCC2BbH8Hg8wxQGOHSOCchQq0EeoVdmiXNnC4kxal+eHYtXZ+/H63NjMGhDIg7mnkNu7jF4RWaix4r9eG1eNF4Sx9BrvTojSXsNel1d2muI16T3RK/Joj7t4/du/IzVcEc6eySEkaCGRJ+X7gGBLF3VsIaLH9P9rOEmkucT8GEYo6WLEZR5SCaAo8n0vcpWd0gZ3Tb6Mfp2NaSpfkaoL+sWCU2g5cBj0HG8eLY0SNNRgzbSeaONUV8DOg+DGw0ucrqUaEfL5b6l9rNajwlnUNNqdJDoB6Pl6GC0ENvdxgSh77IIfD7bU/R90WpEEFoOF/uHB4k+pUX5o7kmWWjYDy01V42ulnp/UDWwaanDGg3YkMumGUGbfrLl2jV9PdhN06CPKxoJNe5NoMYFjRnUSNGKUA17OqFRT3sGNQ01YEOtOWhD/QZCDb+0xd8meTOoKVeg5rcNKgJMsIVcLroItNAYARWCJgRlKO2JwAqlRNG2DlMIuJA7htKlSHqtGj2M51KrX5OCjqPUKzqPXo+uQ9f7vlCgRqmuKLmoDKGHsxnSOB7ah8DcNDGJUkWEn0T5HcxAj8FDGM58n74YOAheyWlmz1dSenSiZbrjYHdwFxzT7XEg/wxSiivN/kYpPRlSoEbFo4raoGb8ej90nSRTnEziyS9NimXtkA4TotBxIsEa0YqJsl6fxAhnaKLejaRBl66TSRqoESLoQi3JBGZ0GQANpSdRjZeXplOrS4INgioMJcS2hBdSDGIIsvAx1RCExl5lJUjxGMEXcsVIcCMhDoEVDegQmGGJbdG+qkluxzLEeXl2NF4X6rUqAdGZZ5AnfpdDk3IxdN1+vD1Pvq4OhmRreA+0j64nXkteV7xfQ0ufh9OuNOlwR0Im8RnFNV4U16BULRKBKOkGiudUK5Mbh2EM3SsJaHibXUnifn+fptHS49HoNvUAi7a7To1G1yk0JtV1ygGD5PdOIIdXjxJ6CNKI58T0jNSS7q7RoU1n8Wx1Fs9Yp/FC4yJN0KZa4rlkeCgBomx1UKM5cIQY1HBalBwnEXhsPZrSn4IZ0rQSajEmBG1HhqDrmCAMWRWOMSv88Oo4X7QYGYTWDGmERgaiuVZkuKVoWw6jtCh/tB4q2iF+LAlqCN5owGZQTXdN84FCDGukmplAjTurUT83NOrrhiYsVzTq7cLOmka9xDilQ/WiNChHNOohQY2U7OtQhqRDGh77Ugc1PgrUPC5B4KS2asf3jevxQ/v/m3ONQUcoUKNUFxR/7Aa8s8J4tSf3TF+EHM4xM6lSetwVlJWL3iNGmYBM9wEDsc3dC55JqdgbEIQ+I0fh/556ivd9OWgIAjNVepvSb6vgvCw4HLKFVeomsX1U1al5wqVAjYpHFQ+DGn8JaiZEoOPECA3MEKDZz3Cm46QIdJ5E9WgkrOk0kfpiQm0ANdWApto5Y3LRaBN3ao2ghsGMEc5oovSkl6cnaNK2NfBCoMMIMhhgMIiRktClGoJUj+uiMYI0sXhtNu2jYyWkedV0TrXoGP04k8hdI/TmnFh0Xx6PgKQTOFxQiLj0o5i+IxZ/m58gzpF6XUh/D9UyXEuIwY8Qu3bIsSPeJztu9M8mrvEKSfRJL7OrR3x+AjTaNWj8xZkJYjuRHTfswhFtTZeNuNd83wjgiO+ACigL8apX2v2UqWOUKhaNF6YRqBEtA5tqUPOiBnII1HRhSVDDrhvNZWOCNVTfZpI4ZrI4XkuXku4rgjcS9klXFvX3i7FIdJ0YiS7i2esynpw20r1lBDX0bEpIQxLPqlbXhsGidpwENHr9GuqTQ0zWsGk9JgRtxoaitVCLsSFoNyoYXcYEYvDKMMzdGIh3Jvhw/Zo2wwPRckQAmgu10NpWIwPQhjRcaJi/kGwJ1rQcIiFNbRHEMdWyGSCuPcCbRU6bpv090KQ/wRo3VhOSDmp6i35vsb+3O5p8JfpfOaNxT3uTyF3T8Es7k6qdNdWOGoI1f2VQc0+lPqn46aFAjVLdUBX255/iyZLdQUv45sQg7MiRhyZUSo+/LBydUb9RIwYxo2bNRkhuze+Rtmmc9hOwWWdnX2O/ktKjFqU/0UpztEy3f04C18pSdWqeXClQo+JRxUOgZoM/uk0OZ1BDBV07TgwXk+dIE5DpNCkKncVEm2ANT6g1MXzRoAuJl8omaeM6qCEwQ0CGXDIEX2pCGblNsIb6r8xIZNUANTOqQQuBmlcMYpjBYEbCFgYuDGFqwpDX9FaMvzZLwhcpfbx67PU5BFkkUNG3a2huEl6bm4i35sTjk8XxcI4qRH7RcRzKKcBah2T8e0Gc2JeANzW9zteNM7UPvY4QAZpXxfW4z0DG8BkJ5MyWeoVEUMcgep90b14Ux5LbRqZRSXhDDp3q2joEhQgCSdAlIY74foQI0khYo4GaGdHivlNdH+obwY3Q9APoJlqGNQxvxHcuxIWMdTjHouegGup0nbJfa6UI3kiQE40uYl+XKZHoMikcXcSz11U8d10nkMOGnDayBpIR1OiiZ5XE0EarV0PAhgGN2OZlvrnmklGycHYboVa0qtmoQHQbG4jBK0Kx3jIU707xQptREsiQm4agTQtNBG5aC7UVkqBGqq3Wth4qHTa6WmpuGx3UUCpUy4FeJjXv74Fm/d3RrJ8UQZrGpD4unALV+Ct3ITchqlnjhKa9HESrgxqZ+qSnQeniMQ3cNOxhpzlq7ilHjYqfHgrUKNUFJReVcCFP67QtcEx3QnBehphAqbSnJ02heUfQf+x4hjCvvPMXuMTEmT3OJUb88fT2O3zcyBkzzR6jpPQoRct0k5vPNdMLMccuq/SnJ1gK1Kh4VFEb1EzY4I8XJhOcIbdMpJg4R4gJc4TmdhAT5Un6pLp6ci1TXDRAYwQ2NSbqNaHNS7Qk9VQCNAl4mcFMtThFiCDNTINm0JiQBmmqQQ2BDOoT2CDHCsEWCWe+T6/PiWdQIpWIN+aQCKLEagCFwImEJ2/MlfuMQKWmEhnWvCX2fbggDju8c3Gs+BRy8gqwLyALHyyKwdviuLfmkOsmXlxLv3bNPsEjfg1x7Gu0TRLbps9Hn422xXVY4r2+SmI4I2UCNSTxudh5Q+ewaEw6duR+EkEcoRnSsaPLCGqqAU20Jtl/cfqBh8RLoGv1bVj0/RO0IRGoYZBDQEc8NwxqqkXjss4NFTUWY1PpuYtEF3LWsKLYZaPXQpIri5EiWRImhos+uWpIBGuork2t9Cixn1Ywo8LYBG7aa6Kx1uND0G50ALqOCcCAJcHYYRuO7jN90GG0P9qKsVba6lBU04b75KphSBPAqU9tRcurRRGoEds0ZkyJInBDrhp20wi1GuQl5CnbgV5o0d8Dzfu7ozmBGtE26SdBTZO+LgxtmvZ2Z3Fx4a+c0ewrRyGCNQ5o3FOCmcYGSMOgRnPYEKRhUDNZgRoVPzMUqFF68lXFBTw9sgLERGmbaAMRejjP7GRK6fGWf3oWJi9eir++9x76jxmH4Gzz3yOlQb35j38yqKFaNYGZKs1N6bcV1cSiJbpt03awuy+5uMLMb5XSkyAFalQ8qqgNaiZuCMBLk6WTodukKLwgJsgvTohiVwNBmo6TpatBpqtQ+oqcXHedHKeJJuUSxtSWTG2K1USQJlG0CULksIlDjbSjmQlCiVIMYqTbhfrVsEaO1QAwZvTGXAIqEoy8Kfo/rsRaqt5H1yLp/de4jcfbs+Px3rxYrLA7iILjp3E4/xiCY/PRa+kB/GVOEt6eE4M3CdbMk+e9Tu9XyNx1jWMEbNhdQwBHbL8uzjdJvK4RQJF0aCP7JLqG0GxdNe9lzfspJLZ1WCMLL1dDGiq8TNsv1wI1NSGO+K61WjbU8ipalE4l+pwypTlxqp01JAI1QvwcCZHDZkokOk8mRUmHzWQpeu4krIlBZyFKmeoqntGuEwjqRKLThHB0nhAhWip6LZ027cdTzaVQ0Q/THDehJnUQ+zqODUEH0rhgtB8bjK5jA9F7fiCsnKMxZJ4/uo3xR7uxQWg9OlhCGk1tRgqNEBoeKCHNUM1JQ64arS+dNVK6o0bKBy2GeKDVEHe0JlhD6U8DPYXchdzQfIArmvd3RjNSPyc06+uM5r1d0ewrVzTt5YKmX4mxrxxMImdNU62tAWqEmvTah8Y97dC4ly3+NlkVE1bxM0OBGqUnXSlFlYjKPykmSZY8UfLPTeBUBHOTKaW6oe9z1LjHJ+Gv773P47RS1A5P7xrn6bILjUCXV17h4+h4Os/ccUpKP1Whhw/DKd0Je1PXIzgvXS3T/QRLgRoVjypqgpr9mLQxEK+ISTJBGpaY/BKs6UauBkpNmUy1RmTNkZqK5Ym27p4xwRkGMtV6WUzaXyanxnTaplQnSmmK4zEGNbNiIGFDvIQ1DBPiqtOVxDYBBxrXXS61YQVBGVNfSAc0b82rCV2MMoISctCww0Zr6XyTDMfxsfNEK/TO3ET8Z0ECpm5NxJGicygQ9zMxvRBjN8bi7+Ia78yNF68v3gcdz69R83rfB5LeEO/59RqqCWr4fHGe8fPy5ydYw+MS0LDzRwM1+r00Ahu6rwxthLiIMUuCGgIz1TBGisc0SEMAh1fPIlAjvkNacYvdNeywIahD15BpVC9Op/OkZH0b6bIhUEPFiF+YKp4dMd51CqXYSXWaJIENi1Lu2FmjpUlNPoCu4jntOjGC69l0Hh/BoIagTWcCN+LcjpwSFcagxigd1nQU6jROtOOCGdZ0GR+Mz+cGwsYtDhNWBODVcf48zst4s5uGlvIORJtRBlAj1G6EGBsRgFbDqyGNEdToqVCyXo0PWg7xFNseaD3IA60Y0pA8GNS0GOCKlgNcWARsmvdzRos+LmjRW0i0zfsQuJGOmma9HURfApumeiqUDmt0pw3Bml52+PsUBWpU/MxQoEbpSVdi0V0E5CbDJm2LmCi5IPhwlpg4qbSnuipalnvq8q8ZspirUbPRwcm0nPcHPXrCNy29xn5y7ZALR4c5dLxxv5LSL1M+PLNCYJW6GW4ZPohVy3Q/sVKgRsWjitqgZjKBmqlReGGymDjzBDiSYU03MUF+YXJMDRgjRelMYkI+VUzCTW4Z3T1DThkjpNFADTkzZsQJxUtxXRlafSkGr84mUBPDMKEaxJAzhmCDBA2UniRBRzXwIDihww4dXpDenFsNaYygpvZ2tRLF+dJJw2lPYky/lrye2BYynT9f6i2hfy5KxLA1scg8eg7FxUXIySvGEptk/GdeHN7RjnuTztFgjUk8pqnW+Bvzk/C66JtkADWvEajR3xvt01py+EhoI+8J9fle0T7tnukpXibRcUIyJUp8RwRpGJhJWKNLhzIEanTRuJ569bL47mgZ8xdnRuNFsc8EZkRfOm6kOJ2KQA47b2SdGz0Fis4hcNNlShS6aIBG1q2hlsYIGsrUO06dmkSQJpzBIhcfFupKcGdiBDqJfZ0mhQmFMqyR0EaKgQ1BGqHO48PQeVwIOo0NFv0QvDc7CNZucZi9gQoK+6OjGGsj9tEKUa3HkLsmCG1HB7OrhiGNBmpaUy2bEQFcYJjSoEgMbHRQY6pb4yvkzSJQ03qwh5YG5YGWA92EXNFKiFpWfxe07OusSfZb9HFiWENOGt1ZI0GNBmdEq4tcNU162eEfU9SqTyp+ZihQo/SkK/bYVTEx8oJt2nYxUQpVaU91VFREeI9/IK/0pK/69GPFhklz129E2GEJ7qidv9HCdP6EBYtM+5SU/ltR+hMVM6daWVFHT6j0pydUCtSoeFRhDtS8SqBmipg8E6zR9IKYFL84WUzAa4EackBQaku1qP6MBmVmkFuG+tTqNWYklDG5Yyg1h10dsQxpXpsTLdpovDZbrsTErhYNmkhYI2FEDaBB0iFHLdihA5Uf09sEW6g/P0n0ScncpzEJUeS1q48X+4RMoGZBEv6+OAlfLY1CQuZJnDp5CgX5J7DbLwsfLozB22L/Gwuqz9f10LX196HpTX4NIdGX7ppqUCPBD50rIQzdG/1zGwHOW4axmildGogS0oHOq3M0Ub9WDZzaMgIcXQRpXiJII0StdNpIUFMNbgjSEKCR/RcpHYrdOQRpxLM2TaZCdaV0KAY2QpQqpY1JaCPVdTJBxQjxXEaIVq4SxXBxUpSsrTQ5HB0nhaCTUMeJoeg4oRrWEKihbR3UdBkXii5jgxnK/GVaACxdY7FkWyD+Odlf7A9Fu3EhaDc2BG2F2tCS3iPJQROEdkLtCdhQ/Rpy24iW+jqooVQoAjTSXSNa7hOo8UGrwb4MadoMcUebwV5Cnmg9yB2tBrkxqCG1pv4A0e/nglb9hfo5oyU5bPo6oXkfRy4qrIMaE6wRkoWGCdBQnxw1tvgHOWpu3EN5pQI1Kn5iKFCj9CSL0p4ijxbDNm0n9h3ci4DcFJX2VMdEy29/3q+/CbyQWrZtx8CFlvI2d45HYjL+/sGHfCylOFkHhfI4te27dOHxT/v2Y3dN7XOVlH6pwg4fgXO6K/akruPVnxILvxW/U8pV86RJgRoVjyoeSn2yCMIrYrIs01H04q80QRbbnJpCLgiqQyJTVCh9hUQTb1l4VqY1EZghcENjMn2J0pUIylSnMklQQ4BAl0zfkQ4Q3R0iIYMRPnBfHydQIVoT2NDGa8AOsS3hS7V43HBM7f0EaqiVgERcT/Q5zWm+3NbhDAGYtxck4x2hvy9KxicLo+AXX4DTp8+gqLAYvtH56LEsBu8sFO99oXhNcRydxxLXJDBD1yPwIl+n+r3o71F/n/p70V9f1xtClBZFIEf/PPp90FX7XprGxP3UIQ2nS1FL2/qYJh3OGMcIzBj3MbxhxUh3jQZuXmRp4IYdNRq4mS7r1VTXu6k5pteyIXCjQxqZIkWKEtvkrolEN6EXGdjIvlFdhTpNCkdHLpAdjs6sMHShdkI4ulBNG3LTjBf98RFCBG6C8OZUP2xzioOFVQQ+mh2AbuND0GF0MDqOkfVs2jO0CUbbMUFoNyoI7YXaUs0arW5N2xHksPFntR1OCkDbYYFaOpQP2gz3YrUe6oWWWq2aNoPc0VaozUA3k1oPdEULAjYDXNG2v6sENP2cGNKw+shaNUZXjdzW4IzmqGkq+s2+ssO/pvooUKPi54UCNUpPrqqQWPQtAnITYZ22mSdIIYdVUdm6Jp+0Q/jnxx/XADWkl954E2tt93EqlLnzqD6NngLVe8QohjeUCkXbRnijpPRryjs7ih01TumOiC24olZ/egKlQI2KRxU1QE2oBDWvzqDJsV47hFQNbgjQsGtGqznCk25ySTCkIVFKE7lnaKUmfRIvQQ3XSpkdjzfE9hvUaqLaKdX1YGrCBCNUoFYHESQj0DAnc/tqn6Nv6yLgYtwmcGKEMm+RK0YHLdoYnUP628JkvL8gGvtCcnH6zAUUFx1HdFoxhm+IF/vi8dbCpJqgRohhi97S6xhem1/f8N5J+nHVSuL0KII0JAY72n3S+/q90yGXUbSPQM3rc2RtGx2GsbT9DHMMgIal7de3jbBGV21oQyK4U13z5gD3q0HNAe1ZehjYGEGNLtomUNOVaioRuNHADMkIaqgocSda7pu3IzhVitw2lC5FoIbFoIZE0CYIr0/xxzq7WOx22I++iwLw0sRgdBoTjI6jg7XCwyFoR8WHRcvgRoy3GxlkUKCQH9oSqGE4Q24agjUEbXzRZrg3q/Uwb7Qa6oXWQzzRdrAHgxqTBkpXjZ4GRW6a5izpqGFnDblqaqU/sXpLWEPummbcEqjZh39P9cUlBWpU/JxQoEbpSRXVf6DVnlwy3Hm1J6+scIQdPmx28qT05IpcM5Z+AQxanKPjMHfdBnR+6SUGLpTCRM4ac+lLNEapTfpxf3v/A1N/gcXmh45XUvo1FJyXAfuDVrBKFc/lkaNILioz+/ul9PhKgRoVjypqg5rJm4Lw2kzpbqCJ8AvsaNBFKSvVgOZldknQZFuHNJQOIybtvJy2vlpTrHTPaBP6N0T/DXHMmzPj8fasBLw1h2BCbVUDmRpgQYMP+j5SbaDxQ9vU1gYxumj/O6LV97/DAEaMa3p7YTVgob4uI1j5q9j+98I4bHLLwIlTl3Ci+BTSc4oxZ28S/r0gAX+haxvPFdciSGO6JrXiOsb3rYs/D4EcOocADbc1pb8XPvZHVOO+ChnHTYDGIAlzqiGOvq1/ryzD9yy/d00zY8QzoUEaTXqqlGmMwI0OaxjiEBTcz88hSbpraoIaXV3EcSQGNhqgeWFKFMMb6hOg6Sz2VYMcCWu6kbgIsWy7TQxH1wlh6DIhBK9ODsRiq1jYu0VjzNf+eG1SIKdFdRobgo4EZxjUSGcN9TuMCUb70UEGBaL9KH+0Hyk0IgDthMhZ055dNjL1SVfroT5C3mg71BNth3ignWjbEbgZ5M6OGlOdGqHmg2TbWkuBaqXVraEUqJqQRlsJSgM1BGmaK1Cj4peEAjVKT6qSiyoQlX8Ctgd38WpPMu1J1Rv5PcglJs60ulOr9u0Z5Jg7jgoJ6y4aXQPGjX+oro2S0q8lgjNumT7Ym7oBHpmBSCi8LX6vVPrTkyQFalQ8qngI1FgE4rUZUTxJ1p0NutPhZVq9h9OZKIWFdEBMsqtBjZx4E6yhWjT6ykyx7MbQV196a04C3p5drbdmJ+KtuVLmQI0RIDCEMIAII8jQAUXtsdoiEPOXhVLSCSPHqNXH9P28rckIaKj/ziJtH58r9bdFKfjn4iQstU5DfvFFnDpxGrmHC7HBQ/wdsCgJ/1iYir/QeeI4qZrQhl9DXEd/n1I137909SSZAM9b4hij9HNrnCNkvDc1YBfBHxJvS2hDYIa2qS+39XQzctEQqJEwRl9hSoc3NUTft9CbdAzDGk2iz44b8azIOkQEeOiZkbDmFX6utGdJjDO0oWePW/EsksuGAA612rPJoIbT9cRzK/TilP0MakgvktNGqIsYZ3BDmhyJbpOkXqjRhos2QigcL08KxtRt++HqHYtZGwPx1pRAdBsfii7jwuQKUaJP9W06UH8sFSEWGheCjmOCxDYpUPQD0JGAzYgAIS0VarhUm+F+aCtEoKbtMB8xJjTMC22GeKDNUE9u2w52Z7UZ5IaWg1zRQrTNB0uXTZsBLgxr2gyQ0IacNS36OLLIYUNq1kdCm2a97dG8jz1aCr073U+BGhU/LxSoUXpSlVh0DwG5SZxmINOess1OnJTqpmi1J70o8Lh5C8weQ9rl7YfmbdrwcR26deOluc0dp6T0a4l+l2zTdsAmbSv2559Ciioq/ERJgRoVjyqMoCYgdD+mWohJ6cz9eEVMgF/RnTJiokwT6FcY1kTjVdF/TYy/JvrUviom4Hq6i5yE04RcTuTfFJN2XW8JvS0m/DWViHfmJeJtTTpA0OGCcVuXORBhlA5fZL8apOj6y8IU/HWR1F+ECJQY4Um1xH46Voha/Xz9XNM1tP1/Fef8Q2j6jjRkFZzB6dOnkFdQAPvwPHy+Ign/WJzKMKfGuZqM740AkLymHKup2p9VGze8P5LxGP04aqvvpxDfJ2oJgiXgLaE358XjDVpGfL6QaN/S2jfmiu9zbizrjXnieyWJMf17pYLFb82lfpxopd6m8Vni/Jmai4rcVEIEbwjivD4nRjwj0WJMOm4Y3ojnx+TCES3BmlfpWaPnjJ5Dei6FdPcNO23Y7SX1Mu0X7UukqfvxEkEb0Zrq22gtuWx05w27b8hpo7lsXpgYgZcnhmLEujC4+ydhxc4I/G1GMLpN0FeHIok+S24TwOFixDQ2NkgoEJ3GCI0OQsdRJB3U+MlWqMMIP7Qf7iPkJca90JZq1gzzEPJE66EeaCvUjhw2BGwGuaH1YJI7FxfmGjYDCNhIUGNy2GjpUFS/plk/RzTv6yj6jmjZxwEtFKhR8UtCgRqlJ1NViD92U0t72qrSnn6HolSo1//6NwYwtNx2YObD9YlqrwBFMrdSlJLSryn6LSJ4vDdlHXyyDyCx6C7/Zpn/LVN63KRAjYpHFbVBzbRNgXh7VpSYGEeLiXOcaEliokwOB5o8i/7rM8VkXejNGUI0Cdcn3mJSzS4KMRl/S7RvzY4Xk3Uxgdcm8wxmCBL8iGoDmtrgoTbAoJSi2ts66NAhii6CLjp4YUiyWOodvSVoooEa3k/Hi5YBi6lfE7jox9D+fy5Mw9hNqUjKPYkz504iv+gYAhPy0W9tPP61JBl/J1gjpJ9L19Fleo+GPn8e/hzGzySkf85an1f/fHSefr8I7vAYrWRluqe0T/QJ0hj0lhBBGAI0by8Q3xtpvvhO54vvWrQ0TqCGgA2BmprQjb5jEo0LiWfg7VnxeEfTWwRphBjgCP3/2fvr7zqubO8X/gveccd4x7i/3HHv85yG0xxGxxAwMzMzi8kCS5YtCyxmBpNkMTPT3tqkLTLEQYepO+lO0p3knOf7zjlX1daW7O6nc99un6RP1RmfsVatql0bqqLj9ek552JR86RPJ51HzxQLGXqmuJX0OGqfoOdNnjN+3vi582A5yM+gFmFD/NZTS5XyIE53iDx84jQ9uyxzOPLmlIJljS5zRNjo0TWEpEOxpNHlzfFWPHq8GRvP1uNa3TAS8tuxwLMWvz3WJGlSel2bXx0hXJJG49C0qPnlwTqVLiWyplbSoH62v1pq1/yUYFHz872VRDn1y/GTvarA8P/cXSb8dA+xuxQ/21mKn+64jp9sV3BKlLRussZd2PwPqWEzLWr+b03U/D+bivDiaUPUGNv33AxRY/BjhFd7ap96S1Z7yjenG6s9/TekbGAYT82dJ/KFV4Xi1aFmnxNbVOIqKKxH1fA+j88+18DgH8cUKh3dyBlOkLTMjpvvGFE1PyIMUWNsD2u7T9TE1+BZn1aaJHO0DE2miadocsxyhiMcuC4NT6Blwu2lJuK6kHmW05p4wk6TcN6fOYlXsChwL4YrqUwsDQR3ucDyQYP6ev0YNe4uMWZKDV1+8Ov04zIWPDzd10TLnGAihPqhGtTXZY0ucNxFCsOiRYevw9djCcL7HDEz74wJO2KG0Gi6i7fffQuvvvYaeiyTOJLYhZdC+tX5bqjPMi1uGL4Wt67vT+jH+DPofbU/+1zuT+/rvxl/Rvkdtd9EHePfnO5LEKOkDUfSKElDYyJp6F4TTwd20z7dbxnjKJseupe9Eg0lEVHa/X2WxnRR86wvHfehVuD+NPzccAoVi5qnfTpc6VHc6oic0cQgR3SxLOR9XRqKoHGDI75Y0jx5is7llchOq1Sp353qwCNca+mUFlXDckaTNHpEDYsaHRE1J1qwLLAGl+uHkHu9Fct9avHY8Watlo0659earHEXNb+QgsO1RA3+ndpfHKwTUcP9n+2vmkZETSV+tqdCiZp95RJRI5JGi67hSJufMbtK8fOdpfjZ9uv42Q7qEz/bXoqf0r6eAsWRNO6RNbwy1P+1WYumIf4foQgveRqixti+52aIGoMfH99h4M7XqBszyUSoxHLZSHv6F+FKVy+WrN+AXz36GPxj4h54jk5xWyd+/fgTIl+2HDqCxrGZUTLXewdcdWx4qe6smnrXkt3PLngR13r6Z5xvYPCPpGHMieKRIomqqRrtQv9tjqp50N8zgx8ahqgxtoe1zRQ1bfCIr8Zzvi14kqMZvPuppQk4R854c12SbjzGNWdoEs1y5jkfmphLrRmaeDM0MecaNCoNhibvPIHXJvJ6epO7qNHrsoioCRpUBCpZo4TCtFSYQ60uG3ThIvta3zUm8mJ6jKNinj8zjBdYyGjHZsgWGn9BEzXS0v7zfG6ISeDXzUB/nYb7tebS8bkhg9gQNYBrnTdx77338eYbb8M2fgtBOX1YfHZAySFC/5z6dfTPpva149q5al/JGvVe2piMa9/T7bdQY+6/3/QY/xZK3qiomueCqCVUNI0uaHR4nwVNlwb31TkcecPpUs/6z0QiakTgUF+kDcNRNISbsHmGnicVadVFz1K7Kx2K06AUKmqLYYHDKVAsaETeaKJGilnLylEKTo164nQHnjzVgcdZ0GjpUY9Q/1EaY2EjkTVSy4bTnlTqk9S0keW9NY634pETLXjJuwr5NQMorWnH5qA6PHmyGb851orfEpweNS1qVMqTpD0drCdqp1OfRNRwClQNfn6wSnFAYx9TiZ/trRB+QvybthqUkjUqqubn1P/5LmJHmZI1xE+3XcdPtl2TqJp/k5o1s1KgOKpmS4lE1oio2VxMx4rxineNIWqM7ftthqgx+LHBqz1xgc5rthsiam7Ym9BopD39S1DWP4Sn5qkoGS4CzMWAH3QewyKHz2POpmbMOMapTbtPecgx9wia6Pwi/H//z/9Txvm4kQJl8M9jChWOTvobdQkF5nS0Tb6OoTtGVM2PAUPUGNvD2mZH1HjE1+B53zZJN3naiybSXjShpv5TNFF2TaY1MfOcd58gkTQSQdMvgmYaHuMJe7+KlGEpQ62OGpuO8pA6K4KbjCGUxBgWMeOOLjZeYKlCx13CQ2SH4nluWbCEKvEi52vH+HUvhAzRMXoNwS3LGgUdCzVrrRvyGu1a0jdjrrR8Pb7OINZGDiGrdhRvvfM+3nzrbYzfvIu4ayNYem4Ac+ka8/i62ud4IHydYJY6A9QflH1Xy59R9hUumcPfn+Ex4vlg+g01ucO/Jf8uLnmj/eZK1qjznpWoml5q6V4R3MpYYA+13USXoGQNj9N9D+jBc/49eF6Do2m4ILFKr6L7z1KO7v9TMsbyjq7vqyJsnvGh6/iyxKFr+3YQdG3fTqIDT0uUjf78udW48eoiOKJLRdc85t2JR7068BjxuCZqOOXp0dPteMSjDb/15FWjpkXNo6fa6VgbndOGR041Ea1EG353ot3Fb0/wfisePdmCFzwqkVnej9qmHuw/V49nT9NrjtH7HGnBb4+yqGmSAsO/mkEDfnmkFr84XENwq0mbQ26i5mC14gCnQlXhp3sr8ROhStWwkTo2vF+Of9t7A/+2u0z46c4yiajhaBqRNduvCT/ZdhU/oVYJG5X69D+3Kv6Hu6jZWoSXvasNUWNs328zRI3Bjw2e7HDaE6c85ZvSjNWe/oWYvaS2X3QsmsbuT2lLvVGBXz76qJzHUTJcr8b9uLuQca9J4y5w+PoXcvJmvM7A4B8JR9VctlyRqJoyez16b/+e/oYZtWp+6Biixtge1vYgUTPHt13kzDPeOj1SX0TVneFJtiZqfPsEV8oTT9CpfY7a5/wHaPLOrRZNo0kZiZ7RJQ0hwsAt8mM2LBoeJDNYSogg0fqu8WAWGFrLAoMFSpgJc0S0mDGXYFEyL8xM5/E4nesmauaEDWp9df59okZjLr2e4evMl5Y+D732hbAhrDo3jItXLXjt3vt4+97bmLj9KtKqHFge2U/nqM8tn4E/D/V19O+ghAxdi5jLbciA1h+i8/TIHe08l8hxG6PzWNQw6vdgUcPShvdVOwOROhxZowTN89TX9587w/Ti2TP0HJzpopbFjSZyAukZCOjB8wG9mMN9TeBM0w+9QDGLGo6uYVHzHLXPcUvP0LO+dF2/dqIDzxLPsbTx0cQNHZfnTatx85w3vT/BzySLwyd8uPhwB3g5+Sc82kXWKNrxmGcrHqX2UR4/zagoG+l7tBLN1G/FY6fa8NhJOk/owCMnuG3D46da8OyJKsRf7kFz2yC8Y+sxz7MGjx6n1x5txu+o/e3xZqIJvz7a4EY9fnmkBr8ifn20jlolbX55uBq/OFSNf2cOcssrQqnImp/tr1TwUt77eDWoSvzbXkalQ+lIKtQuTdbsmBY1LGh0UeNi6xWBRQ2Lm/+xtQT/c1sJXvExImqM7Xtuhqgx+LExeOdrtdrTMK/2dMVIe/oXwz1liWXK6u07kXT9htSkKWxtxz4vb/x//o//Q47/3//2E8QVX57xel66+9Fnn5PjD0pxcj/OLe+7Hzcw+McxherRfuSakokkNI075e/Xg/6uGfxwMESNsT2sbbao8YyvxVzfdppEd9PEuJPaTpocT8sZjoLgdCeWM8/50SReh4UMyxd/muQLakz6ATypH1S1Xwg9UuZvoZ+nR8CwVHGXGu68EKz3h5XMYNESMog5LDFCaSzMLKKGI2D0iBaXJAlj+Bx6DTEndIDaQW2MzmUJc3aE+krMKGj8LGPGfIb2558dov1BzAsfwrJzJgTlmTD5xru49+49jN96FfHXzVh+foCup70/X9dN1Kjvp2TLXP7MIov483NUTb9qWda4hAy3/D3pWMiA9Gd+f+03EFnDMkZF6Myhc6VPrb6vyxuWM0rwqHN0kcOy5tmgHmrpmQimNqhfRAyLGomqEUlDfYKjclR6lOpLMWKubcN1bzgliiUN8bx/H54XYdOJZ/za6FgHjXfied8OFxxt8xRH4BBz6Bmc491NdNFzqeThU/R8Pundjqe82vG0Rxue9Owg2vGkF/W9uM5SO6EkzpOniVO0f5qOnW4lWvCUB50jfRo7RedxytTJNmrV8WdO1uNcfjda2ocRldaERV5VeOxEEx4/0YDfnWjGb6n/uxON+M0xXhGqTvjt8Xrar9Goxa+O1uCXR6qFXxyqwi9E2NTg3yXiRokbPR3qZyJtqvCTfZVEhfBTreXoGsYla3aW4eciba5LoWFd2gi0PzO6hpfxpnbbZbziU4f3PzNEjbF9j80QNQY/Lr5D/+0vRNBkD1/CDUeLsdrTvyAsV15ZvUZkyl/jN088idTyyhmvq7M7sWHvfjnOETUcWeN+XOdsarpraW8+n1/3oPMMDP7/hf8+XbdVI2soBles19B960MMvfrtA/62GfxQMESNsT2szV3U1Da2wyehDgv8aKJMk+A5MmFmWaPSVUTOEM9zdIMeRcMRNCJqBpSoEVmjpI3UQAmkyX7gELUPkDQSNcMyYOa4K43JDZY1utT4m0jaEosWJSxYprAU4UgaFQGj5IsSLKpV0oUZVrKF4OgYvoYuavg6uqCZPwN6DZ03n14zP5xFzQAWRgzjROoQrLfewtvvvIvRiduIyOvDssghLAjX3k8+B39e/txKvvBn58gcBX9+TpVSzAtj6DOJvFGoY/0KOaa+sztK8GhChmCx83xwP/XdYVnDUox+f13SiKjRZI3s8+t68HxIL42xuGF6FWfoeeCoG9nvAadL8b4qPtwjooZXjmJZ8xwLGkJaqXHTjecC6FnzJ/y6iE68QM/fC/4d9Bx10WvoHD96X+8uvEDPJMORNc8wvGKUbzv12/GsF7VeHeCl5Z/WRM2Tnixv2vGUBx073YanqeX+Ux5teOp0K9GiwX0lc54SkdNCNOOZU40ISO9Aa4cJOSWdWOVbg0dPNOKxk3V45BTLmib87rgSNb85piTNb4/X4TfHa4ka6tfi18dqJcJGZM3havyKo2uO8BhH2lRrsqZK0IUNyxmXoHHjpxJ1o5bz/tlurltThn/XZc32axJV4x5ZowTNFfwPreWxRb4NeP+zrwxRY2x//2aIGoMfE1yfpn3qTflfqPNMKah1DtNkyEh7+leE05RiCouxaO0618pNHEkzf8lSBMbFo9piv+817gJm6+Ejf7UGjbvQ4fP5dQ86z8DgH0Ht2AgKzNnIGY5HjXMQA3e+fODfN4MfBoaoMbaHtd0nauJrscCvHc/7qKgGjnh4ntNUfGlC7UuTdB+asFMrKU8STUOTf3+CWpY1ks4kkkYVB3alNQWymFErL+kpTdNixg2WMq66L24Ea3BfSz8S5FzFvNARLBDxMoz54SxChml/RAmZMGq5L5KExxW6cFlA5zMcGeOOGqfXM5qYWRA+jTpv0MXc8H68HNGPffFD6LO/ibffeQ825034p3VhaeSgvGYu8QIxj16rp0wtCB+g1w/Q2ADtc39QxAwLGzlPrs/ns0BS5zDzzvZrcJ/PV6JHiRo+l8dY0rCQ6dNQguaFUH2MBQ799hKB04fnZ6DEjsCSJqSH+ixm+kTGPHeGpcw0LGpUTRu9z5E1qlWpUvQ6F/T8UPu8fy/mSJ0bep0/PW+MX6dIHLXCVBeeFWFIz6NA+4wv4dehZI0PCxvq03FeReopxrsdTxPPeLXhWRY2HG3DkTcaHIXDKDmjeIKjbCQtqpH2G3D8Ujta2k0orR7A5pA6PH6qCY+dbMIjJ1T60++OtxCcAtUg/E4iauokmka1dfjV0Vr8mvjtEcWvD9cInB7FEkdEjat+jRI1ejoU9zkF6if7yjV5o+rWsKzRRQ2vCMXokTXu9WpcwoZbGl/o12iIGmP7fpshagx+PHyHwTt/QbWzD9nDccZqTwYGBj8KmiYmJPqPowCLRvLROvkq/S37s/xNe/DfOoP/SgxRY2wPa5ud+uSdUIv5mqh5jibMnI4yx6+bJtKEH02ofWly70eTe3+auAfQxJ5hWUNwnyNk5mhRMry8tUqlUQKGVxwSScP7ITxO50qKzkxUhIlblAwxI11J32f54oYeKcNy5UUmwkztCO0z6pgSLUM0zhKG+3yeLmqGqc/QcQ01ruDz+Di/Xsf9XDk/YhAvRwxga8wA6vru4N67H8AyOgWPpHYsPTeIl+g68+k6LJJepM/y4ln1uvnhA5gX3k+fb0C7torQ4f5sGcTHdPh1LuiYRBJJNA5H2HAUjhZ1E8ZMR+CwpJkpavhecKQOjQX3iozhY/p5L4QqySOyRo6xvGGRM1PW8L4+ploVZeOKuAlQwob7XNNGiRolaZ4L6FKihto5LGcIWRo8gJ5DfhZ9u8ApeZwy9bxEd9F1uMYNp0n5tuJpnzYROk/T/pM+7dS2i8R51pvGvdrwtGcbnmK82ok2PONJx1jgnNZkjQgcFjUteNKzhc5pwZ4LrahvMaO+2YSjURxl0yDpT48cbyHa8OiJVjx2kvqSDqX47bG66f5xTotSooblzG80uK8ibVjUqMgaia45qNes0dKhNFnjLml4Naif8GpQmqj5xe4b0rKo0aNq3KNruP3pTpUitdC3AR8YosbYvs9miBqDHw/fof/On0TQZA3HotxIezIwMPiRUD9mp79dJfK3i1Og6sdG0HPzYy0NShc23P49zP7baPCPxBA1xvawtvtFTR3ma/VCeNIsE2eWNdS+QBNqiZ7xp8k8tUrUDGEutfP8hzCHo2bODOEFLTpGlo8OUWkzErEhUTEcMTN4P66UHrq+pPTweRwxw1KGo0Q4EsYk0TELwkYUZy0SMaOYljTzZ4gUXcToUTAsU3RYdkyPi2w5p8F9QZc3xDlmCC/p52i8RMdeomPMy9IOYV3UEPLrx/HWvfcxMnoTJxPasOwcp0Xx6+m8SBMWnTNhIQsb+cz0/SL48/NnUYKGURJGlzbT4y74O2hI6pXIHBV5o+DfU0uP0mFho40ruK///nyv+hShRJgG913or1HXEIEzS9i4pE0I9TlliuBCxBxd8wy13H8+qA9ziOcDuvFCQBeeD+wSWaOLmucCOuj8DjwdqKJsVGqUEoYqqouuzatGcVSNH0uadoL77XiK+rzsN/OsKzWqTdKiOFXKXdQ840HncUoUSxuua+PRgidON4u42RTeivJGE9rbhxCW1o55HjV4io49fqpZVoZ69CS3jXjkZD0xLWd+I2lQCj2yRo+o0UWNHlGjSxqVBqWlQkkalFZk2BVdo0TNT4ifEf/OgkaTNBxRo9ermS1rOMqGj/185zUs8TNEjbF9z80QNQY/FvS0pzwpzMlpTyaaABlpTwYGBj98miYmpbBw8UgRcocTUGDOQKmtBg3jdqlbM3Dnz/Q37htpe2/9Hl0330fH1NvEW/R37w20Tt1Fx8230Xf7c1n5jv8eGtLmn4MhaoztYW2zRY1XYh3my8SYJso0cdYnzXOofSGARQ1N1AOIwAHMIZ4PGMC8wEF6zRBe0FKaVAoTEaLqxahoDJrUi3jRxzjigyM/VASIpPhINIguGDh9x0ywoOGIEpWmtIB4McyMF88yKlLGPeqFJY1EtojIGMRL50x4SYuEUSi5ossNXcaIbOHjLF40AaP60xJGiGSG8DK1LvRj9D6vENxfdWEYMVdH8Npb78I2cQeeye1YGdmPRecGsZBev+hcP1ZdHMay84N0Dfq+9F7zI+k70GdgWaNLoZmfU/9ebmjHdZSsUWlQrggcrVWpUgqOsGHJIhE3jNyTaXkzHXXTR8cZFjwaPC73k1st0oaljCZoXJJGatpocBFioRfPirjppeeEniMmqJueJ03UcEvP2wscwRXQQfsdeJafR+05ZGGjig5zZI2270vnSJqegqNoVDQN9+kYR4dxWhSnQbG0kTSpNjzjxQKHjnvSMZY0Imra8KRnK57kqBqPDqwKacXl2iF0dfYjubgbi3yr6bwmSY3iFCiWNI+ebCDqtX7jjGgaToX63QmtPUZwweGjtfiNFmXDxYbdRY1aGUqJGgVLGo6oKcfPCJY03P/53nKJpNGjaWbLGkavXaPz7zuvYpm/IWqM7Xtuhqgx+LHAE5MqZ4+kPRmrPRkYGPzY4AhArlFTaqtFwQjXrLkkwuaqtRRl9kaJEuRlvK/ZKnDFeh2XrVeIy/T3rgTFliLpX7dVosLRLoKn8+a7GHz1L27S5scsbvTP7v5dvsPQnW8xcOdr9N/+k8ApY/x9Z37nBzH7+n8/hqgxtoe1PUjUzKPJMaeazAnsxtyAHszlGiKB/TSR7qfJM03Ag3pokt1Dk+xegib7QSxrBmh8gCbhbilNrmK2HIUxoNKWtBWNVKtgKaPqwag0H73OisD7ZzmqRKX/vBg+jJdcUTAqEsYdXWZwO0Ow/L1oMof7HPXC6MdYyLikjBs89gqfyxEyEWYROcuihhGYM4DJu/cwducOzmS1YVXkABbRuSvOm7Ajbgi7EwaxIaYfi87T9+L34feV9+f3VLiEEV2T0YWNfE9CT3u6X9ioSJzZv4/rHDqmv1ZHCTW+V0rG6KhCxoqZkTgz4ddy2pR+DdnXJI5L4BCuc6hl+FkSgrrpGeqWdq5/N+YTc1nasKShZ5FlzbMBnXiGnk2un/SCbyfm+tFxaudILSXCj8WNjhI3stw3wXVsWNKIzPGejq5huO+KtvFslf4Tnu1YEtCMrPJ+dHd3o7CiH2vONOBpbxY5TXiC69UQuqBh3PcfO8FpUvXCo4QeYcMFhvU6Nr/WVoWaIWtE2FThFwcr8YsDlfj5/gr8fF85/p3b/eWqT/xij879skZH1a+hdgeLmitY6l9niBpj+36bIWoMfizwP9B5spI5dFEmKk3jDy4Ua2BgYPBDhevVsGSuGu2V1aAKR3KRY0qUlKis4RhkU5sznIA8UyryzZkoMGehUMil/XSpc8OCh/uXLZe1FNAJicqZljYP/hv6w0LJlmm+Ve2db9B/50t03/wQrRO3UeMcQKm9Ftes5QL3K0c7UT9ukwjLrpsfyHfv5pbou/0Hugb/Dup6/2/EjSFqjO1hbfelPiXVY8EZjqBRE2OOohFRI2kqNHEnRNLQBHsuTbbnBWui5gxN4FnShGi1TrR0JjXZVxN3VQBYyRsRNFJnRo+IUdJF1WN5sIjhujIvcpSMti8pTu7igo9rokVHlx+z5YqOyJf7ZIxJxMvC82YlYAhuX4lU+wIfI/RzFl0Yof4IFkWO0Pgwll004VhiD/ptd+G8dRfn8tuxNqofS+n4nngTLhQO4+CZHGz3SceusBvYeqEHS+jzv0Lvze8vn4ejdehajC5q9M/p+o7nBgVXFJAmYnhMCZnp30/BYzMFjYzRudzXhYwejaMKFLOg0cQN9+VeanLGra+P64JmNhx9My+Y6ZV2Lj9Dmqx5gZ8pN+YF9mABP3v0HIqkITjaRuDn0r9LSRw3JPLLDXdJM1PaKGHjEjgzRA23rXia2qe8W7EwsBnxVwfQ09uPyqZ+7DnXjOfpmIq4aZE0qcc5FYpgSSOihtuTjXj8lOIJbk824BGJrlHRNrqoUbKmFr86witCuVOFXx1SsKzRYVHz7wcqlLTZqyJrWNr8uxZhowsbXdro/Puu68RVLA2oN0SNsX2/zRA1Bj8G+B/cnAaQO5xEk5ok1I6ZadJjpD0ZGBj8GJlC0/ikCJtq5wDKHe0SSVNmbxDxwiK6crQbVaM9InSqR/skbYr3yx2tuGatRPFIoUibrKFYFJgzJfqm3NGMlsmb6L/9hYiK/72kmBYZ08LkflQUy2zx8f8O/Zq9t3+P1sk79BuMom7MIkXiWcDwb3DNVi4SqmgkR5NY0bK8OZM5fBHZpjjkmdPoNyiQaCMVdaTgSCQVcTRKv8UttE+9jq6b70k6GaeW6e8/+/O4f0ZD1Bjbw9oeJGpePNONuRw1Q5PkuTRhnh/AUQ8MTbaDVAQET6Z5ks0T7vnB/cJcTocJpYm+CxoPpeM0QefCti+cNWPuWU5lGsZ8rjejpTKxqOFImdlSQaSLa58FA0saLtarJMUCkRO6uFCoSJRpmcGtHhmjo8sXPqYLF5YjruMiYEawUOTLtJDR++77OixqFGp/SZQJO6N70Nj/Km7efRsZpb3YG9uFrTEmnC2gfz922rF+3Q4seHElVm04gKj8Tmy+2I3F54fo86nPz2JmWtTw99DGGZE0mrwR1PksbATqS+qU67fU0AVOhC5q+rV9DTpXr4cjokakjUKXOO68wIikUftKzE1LG3fmhvRjnqAkDbfS1/b1Z4rb+fzcBXJKVLc8bxKNo0fcUH8eH2MhE6DS81wpegzXsqFWUqNcETYdWn+61SNvZMUohiWNTyv1W/Gsr2pfDGjFuYIB9AwOoaVjED7x7XjRt0WibqSWzQNQwkbJGXe44LCOiq7hJb0VLGx+e6Qavz2s+A3LmkNV+LXWMr/kCBuNaVFzQ9pfEL/k6JpZ6VAudpfi53uuYUmgkfpkbN9zM0SNwY8B/od0NU1Ysodj6B/jnPY0+oDJj4GBgcGPiSk0ibSZQOP4mMARNzOZdIP26VwWPLVjJlQ6OiVNiqNyRNoMx6JgJEvG6set6Ln1Cf3tvF9OMGrsW4lAaZt8DXVjI6ga7UbFaCcqHG0oczRI9MpVW5nID07Pum6rktQtrpnDaUiqVs63kp7EMmfgzlfU6tEsM2F5xK+rH7OIjGKxVDiSjXxzGvJMKcgxJSDbdElETNbQRYkq4miiy9ZrIm9YvlQ4OnDD3izpXyWWYok6YpGTK3XLFFlD0fJb8HX5tyii36bYUigSp8xWR5+/nz6DlX7rUfmNODKHV+HqufWxpFjxZ+Xf58PP/9MQNcb2T9/cRQ0vz+2dXI8Fwd2Ye0ZJmHlBvVhA/enIB03UaBPt+TQBZxGzgCbgMjkPo4k4j2ksCKVj3D87hOfDhkXWSBFgiaJRYkBEjVbbRZcrjC4Z3EUDC4pXzmk1YjSBoZ+vi5YZ0kUTL/q+LlW41aXLdETMbOkyiyhN3jDaefprpl9L16J2MbUbz/ehpHEcU7dex9WyDoSmdSLumh3N/bdwe/I2+jq6UVtZh7qKGgyYJnAmbxCrLg7S6/kzM+o7vnJhmN5TjS3kce17ibjRRM2MqBsdkTbqt1GSRo3rskZETgSnTenSRl9xitHvDZ+rj81E6uBQq4udF2l/QRiNaZLuQbJmBvTcuCKzaJ+fMZ0FZ+jZomePn8M5LA1pjJ87hmXNXBY1WtQXR9zMCaRn0k3S6HBEjivahmvbEEriuKdKdUiNm2d92/CcX5sImme8WyXqZl5AOwKy+tAzbEJ3twkXs3uw2L8BT4uo0VeIUjVtuACxRNf8FVHD6VC6pHlE6tbU4bda+hPzu6O1Ln57pMYlan55UImaXx9S0oaFzS/3V+DXeytEzvxyzw38am+5oMsaXdC4omp2aaImyBA1xvY9N0PUGPzw+U7+AV00UojMoQvyD3ZjtScDA4P/vnA0IQueKZE2Nc5hVI524ar1BvLMqZIeyvKDV8i7YW9C3ZgZLRO30XnzHUkp6py6h8ZxJ/0tbcUV61UUmnNEcrDg4NQrhq/Bf2/TByOQMXhOtUPnRaDw+VespXTtBtxwNIjAUTV1ruKq7QaNN0r0D0sdlj8sWnilq8KRHCkGL5ExdG1O35LaOxZ6HX12vg7X6mEho79eSZVxTVQpqaWicEa0KKPeGXB0Eosqjjji9+Noo1xTkqSV8XfKGY6Xz8CSh38jhoUQyxyWUvx7VY624/VP3sF3//Gd+oeSsRnbP2mbLWp8khvwUkgP5tEEeb6WnsLRNFL8lZD0FQ1dxjAv0uR8gVukBU/YX6T2RWpfogm8RMbwRJ4m9DKxF1GgZIESCZpMYBkjcmGmnNGFA6NLFxExLDJcKJmh5IySGiw4RHJoLbMoioWKmfoKXcTo8sUddVw/n6+pSZlZ57nOjxrB4gtWLLpowqooE85kdKOrzwHToAOTk+/i9p0PcPf2G3j91m28eesOrIMWDPYM4NbNWyhuHMeO2EEsoc+/iKHvtOgCEcWiRkf7PnTs5cgh1RIz5YzW/yvwb64zI5pGQ78v0tfuAYsZJWXcmU6PkmXF6X6/xPebngWGnwvXqlEPwpUSp+Bom/kccUPPmTx/LGuonRdEz6NIm+nUKJY3LzAsbLT+PJYyvp2Yy/h13QeLGhVRo1BRNQ+iHWoFqS7M82vHiZRuDAybMdA3hKxr/VgV1KKW+/ZoFZ463aLBK0URp1X9Gj3lieE6NXrL9WoeO04cq8Ojx+uk0LAeVcP1a351rAa/OlqNXx9RcBrUrwXaP0QcqMSv91XgN/vLqWVBU4Zf7CnDL3ffEH6hSZqZ0TXX8cs917E8qNEQNcb2/TZD1Bj88PkOrVOvyQSBJxP8D3Q1UXnQBMbAwMDgvx8sMrjAMKdJ8WpSLFM4woaLr7OYUNEl+SIwikbytHo3cXKOEiYluMp1YGyVmjCpF+EiaViODmrbUGarF/mjR66w/BBY6gxHKYai5JocIcPncaufx3KEV726bq2S63LaF/89ZxnTMGYXAaMk/CTxff7GK3El8kp+B4fIqVrnsMge/k0qHJ30u9ThiqVUvkOxpVhri+j7Z4qkypRonFj63AmY+nAM3/7HN+ofSsZmbP+kbYaoaVKi5sWQ6bQmV2qKBkc+8IScEUnDrTZBZymj1zaRWjJnh/Ay9bmmjCCTfl0E0LguFLjVuG8lJRYz96UlTUfCsKRg7hMwLqHyYFGzUEckzAiNWTS47w4d11h8cQSL+RyRMtxaZN/FRQsW0jmLLlqxJGYEm2OGkXB9BM6x13Fnkph4DTfH7hBTuEV/K26PT6H6ahUSzsXi1pgT11rGsStuEMvoey2hz7WYvpdE6ERNo38H+U7a9+bvpv8O3OffdIa8ccNd0vDvrffdJY1+X2aLGh2WNKqvBI1+zxmRcQRH1/CxuWf7BRYzvHqUu6jh2kUCP1eEHpnFglAXhdyypOFWj+ZyFbOmllP0OOpGWk7V8+/CC3563RreVxE1KqqGI2imRc10CtRMdInDomauXzv2xXWg38SyzYSyGhO2hDRjLhch9mgVnvZQokaXNMKpJjx+Qoum0STNDOgYyxoWNY9yhA1H1xxXNWt4JSjGXdQolKj57YEq/HY/ixola3617wZ+uacMv+LIGo6w0QSNirYpx7/vZlFTSv1SLA9qMkSNsX2/zRA1Bj90OKyeQ+X5fw3l/xW3Ydzp9g90AwMDA4NppiRahqNsKkY7wAWLWUjwKlOSYjScKG3RSIFEnrCA0YUJCw6WJfw3VqJYpGC7Lkz4uuN0nkXEB9fKYfGhhE4zXadDaszo43ztq9YyaUvtNZqY6dfeZ1SiY+7/7P88+P04tax+zCbfgT+H3tY4hySChz97mb2WqMHdj9/At0ZEjbH9k7cZNWqa2uGd0oAFoSrVhCfR+gRaoImztCxoCEl1YTRJI/JGJui0T5P4l1nU0ISeJc3LEcNYeG4YXH/FlbJzjsUMSwUWA4MCH9NTe1R6j2pd4oWQyJVZIsZdpEzLlJmiRUfO53NZqkSp1yxhuSKMYEk0H+Pr6dDYRTonevrafK77e8lrqb+M+ssuWLA21oyAHAsGbW/htclX8ZrzDm7bb8I6ZENfZz+aaxvQ3tCI2uuVqCy5gaH+YeTUj2N73BCWnKfPp0XwqGge7bsQ8h3lc09/F0aPKtL3ZYxwlzQ6ImO0Pv/+akyhj+tj7oKGo6Jc0o1hgcMih/ru5+lIceKz9KxoaVWMiBsWNaH8fPXQ89SDeZxqR8wPUXJGh0Uhy5m5+nMnY0razIZljYqwITiyRo+0oX2utaRq2HDaU6esIiUrSbkibFQKlHuUjfRp7AVi+4V2dA9NwDo8graWERyObMaLvPy3Z5tL1jzl0YLHPZrxxOkmPH26Gc+casZTp1jYqGLCOlJgWJM1vKy3rAzF0TUsbU4oYfObIzUSPfObI0yNtBxRI+lPB6vwGxE1lfjtASVq9MgaToFSUTRlLkkj+27RNcsCmg1RY2zfbzNEjcEPm+/Qd+tzFJnzJFSe/zHN/4vpg/4hbmBgYGAwjYouUcV6a51D4BWUpDCxs5/2TSJmuO7NtIz5e9Hr6rDQcc6IgtHH+dosRTjKh+vB/L97n4eJ23eacOKtzz7BdzSJNjZj+2dusyNqWNS8GMaTaJpQ0+RYImhYyrgYwMuc3hJGLU3GlaBRERQLOLpC0prUJJ6Pv8JwXyJjlKRR6UlK2oi4Oa9kjV6LRZcTs1OTZsLjZiwmlkRRy2hSRQTKRQXLFXd00cGoMV3QUF/OV6KGWRqj71uo73aOS+pMs5Th85hYCzYmDCOuzIzm9h5cy89HQWYBctLykJuah7S4VFwMDkO4jxciA88gIjgWAeeysS+2FauiB6S+DUf7sExSQoZbxfRvon1nOa6Q1+h9Tda4w+JGT5US+LeX33+aGaJGkzUSYcP3kOB7ySzU9iXqSSv67C5xlLwZnCFruJ13ts/FAuLFMMWCEJY2vSIG9Ugu98LDDKdCLQhierEgkPa1SBudF4J7lNgJ4tQ9TdqwsCFUTZsuzHXDvZbNtKyZ5jmfTszx68C6s81o7h2D0+qAqc+GwIQOLPRrk/Qnd57y4iLDLXj2dLPwlB5dwwKHl/NmaP9xXhHqRCMe00TNE8xxLS1KImzq8LtjtYqjNVKvRjhcjd8Rjxyqwu8OVuK3BytE1vxaZA3XrGFho1qWNjoquuYGfrWvHCuCWgxRY2zfbzNEjcEPGS54yZMNDp/PN6XRhMP6gH9gGxgYGBgY/GPg1aLe/uz3+M6oJmxs/+TtvtSnlAa8FEaT4FAVxcCShqWMO6+EuUXLUMuShifm8yNoYs5RGDKJH6bJPBE+LBN7ntDzCk0vc7QIR8VIa4IUxz0/HQ2ii4YZ6HJGol+mRQv3l10wYwW9bimnBl0kos0iVmYzW9DoLQsYkTBu5+ro4/o5s1nC0PFlco4ZS+PMWB5nxcZEO3wLrajtm0R//wDS45PQXNuMjsZ2XMkqxFkfP+zbsBmbFy/E6UOHERiaiqORNdhycQCrok1YTt+Dl/dewt+HrruYvhOzKJpFjRWLL9D70e+xlGUNfQ8WOu6pXC454/4bajzoPBE4Oixs3GSNDkuZhXRvWdAspHu9mOC+Lm50ecP3XO43ISlTnFLlFlHDq0zJSlPES7T/svZMcbuAC1FrxahZFEqxYRE2mrxhWUMtFxpWwoae0SA1JrWUgjkSjFOhlKjhFctY0HDLy33zKlLzA7qwQOvrhYYlAse/e4a4YaTYsH87VgQ3obLVhgnHBBxmB6KyerA4QC3l/YxXq/CcZyue1eD+cx4teNqjGU95NuNxjyY8Tu1jntTS2OOnmvHECeJko5I0Ghxlo8uaR47VCo8eqcFjzOEa6lfj0cNVImoeOVQp/E6TNbq00aNsOB2Ka9f8ai8LGmI/9Q+UYUWIkfpkbN9zM0SNwQ8XtSxsqb0OvDwr103g/7XzQf+wNjAwMDAw+EdgiBpje1jbbFHjl9qIV86ypOlVkTQ0cdYFjdSb0eCUp/k0EWf0OiaSykQskon8sLDonAkL3VKZuL/4vBlLWDREWbBEIkWUNJghFFz7LGS0NKOLs4QLwalGy/lavB9Nx7UIGB0RKjyuHZ99bFms7f7xaKtExnCfjz+QGMaK5XTOcpE0JiyNH8HaGAsCihwYuPk+PvjwfTQ2NSL0bDRyM/JxdM9+zHv8aTzx05/j2V89gpepf2z/YdS0DKC4ZRKB2VbsjhnCmqgBuraJ3t9MLX3XaPrNoum3jBnGK/y56HdYfsGCFfS9dVGjo/827r/lX+NBIkeXNe4sJBbzfTtHbQTf1yEspXu7hEUcyxuNRXRcZA0/B5FcX4ieC60eEdcmUnVwBhTh9Exxepz2bL3CfYLHODJrHqfdhSlYGLKkYRkj4iZYpUEt0JiOwKFzGHdhw7VrNHhJby44zNE00heJo2TNbEmj4JSpDiwKakJBjQnOsSnYLaM4n9GFpUFteN6nXZjj3YYXPGlflzRuPOvViic1WfOkV5OImye56PCpFldalJ4K9cQpJWp0WcPFhh8/WosnjygeP6qLmkppmd9RnyWNkjaVKhXqgOLX+25Ms78Uvzl0DStDjFWfjO17boaoMfjh8h06pu6h0JyFnOFLUkfBSHsyMDAwMPhnYogaY3tY22xR45/ahCXh/XiZU5wIFT3jhkyoNTlDk/EFBLccMcMihsUMT+KXRpiw5BxN/iNV4V+pLUPoksYlai5aXJLAXTLoEkEiaOQ8q4YSKPq5vM9pR65jvB+jRbzQee59XbLoY4z7/uz+8jgd+33o11oeY8eKWAfWXrJhV/IIoq6PwsQrO917H23dgzgWmo5j52+gpKwdddX1CPIKxNI5S/DSvI144Zl1WPzSBpyPjIXJaseg4xbKe24h6poFx9LM2B5vwZqYQayIGaLPz6KGf6Nh+o4mLONoIpZX/Fu4weKL4ZQw9dtN/6byu17gKBr1+7KUUdE190syHS5mzDVzlsq9VWJmEbGY7r/s070XaEwxiFekBo7OkKRPSb0beo0s982ij54hkX4sADUJ+DJH2LDAOcuCsA/zWdSEcnQXS8NeqZk0h4sPh/aDV4daEEznEVKAmMZE7jCarJEiw+6wrHkAHFnzIEmji5oXA5oRc6UPlrEpWG1jCElpw+LAFsz1bcdcn3bM9+4g2jHHq00JGmqfZ3HjQX0uNuzZQjTjWY9GPENIpM1ptYw316zhWjWSDsWtW2QN16t59Ni0sHlMi6gRWaNJGndY2Kh6NUrO6PVrfnuAuUHHr2NVSCM+NESNsX2fzRA1Bj9Uhu58I0vO8iocly2XpebBD7vGgYGBgYHBjx1D1Bjbw9ruFzWNWBrej4U0cV54libe1L7iBqe9cHoLR85IxISkxgzT5FxFXSw5Z8Kyc2YsiVRShgWNiBraX3p+BMuIpbQvqTsiYJRIcIkXXTq4xqivixquJ8MyYgYsVmxYetEm50g0zCzpMlO+TEsWfV8fUy2fN1vUTLMszqr62vGV8VZsTLDhaPoI0uomMPX2R7j3/vtoaO+H18Wr2B7ZhD1JZjSb38SHn3yGmxOTCA+OxZZjCVh3ugir98Zg43Z/pKcXw2IZwahzHLbx19HQdwsZ1XZ45pmwM6kf6y+ZsJLee8VFTo0apu+rIm44gmgallYWLGM0kbOUxQ39ju4iRv9tRcoImrDRjrtLGq6Xs4TvFyG1c5jzw5K2tlhLX5NlxDnyRp6DaVHzMkPPiIsIgp4fPWXuFXm+uFXPlkgaevZE2LCs4To2Yb0ibXh/PiGrRWnpUCxoWNboooaX+2aZIyl7wb2udCmJxOFUqCBVs0YXNPM1OC1qWtZwfRquWaNWjXrevwPzA1vhm9mOIecUbKOTCExqxeKgZrzg244XvNsxz6cDC6jllaCeJziKhtEjbJ7xbMEzXs14ThM1T3F0zWmuW9OMx6l9TCsy/ARH1TAnlKj53QleursWjxCPHtNSnwhd2LCskUgad1HD0TT7OYKG0UVNBX4nsqYMq0OaDFFjbN9vM0SNwQ+T79B962OUWIpkWVdeHlYVo3zwP6wNDAwMDAz+ERiixtge1na/qGnAkvBevBI2IClMizh9iSbTguzPqktyTk3al0Ry1AVN6DUhs4TQa8tI9AxLmsgRrGCoz+lKLBJklSXmPgEzE1226PuSdqQJFpWqRP0Yh4LGHoQuZfTXzR5T8HX/NisujWBl/AhWX7Jhe5IFwZctaHW8hbc++j0+/PgjNHUNwiv6GrZGtmFN7Ah2pdjRaL2H3//pj/j97z9BZ8cQTpyvwsaLw9hwYQAbg2uw5WQCLl+rw0B/P0ZHRzF+cwIOuic942+guH0SIUVm7Erox/pok6pjEz2MZcSSGDP1tZo20ZwCZqU+Qb/tigv0ebmezUX6zbTIGh2JZKLWVZvm4rSo0dGFjRQt5ggdjWlJw6lR9AwwF1TrXuPmlXM0Rs/Iogh6RljkcdqUpE4NKwkYxgxiYeggFlFfpT6pNCh3QbiQn0WJvGEhw6JG1VDi1DyOrBF0UcOROHwshNOjWNZwoeEehSZllKCha2jwmEKlQylZwys+dWGOXzvmBbTgYGwTukYmMOq8iYCEFiwOapJjz3Hqk08H5mlRNS/Q/nPeXFyYI2tY2LThae9WPEVwVM1THE2jc7pFyRquWXOyCU+faMRTxxvw5LF6PHGMiwrXEjX43bEaPHKsGo+wpDlaLSlQj2t9SX/SCgu7yxqWNL/SRc1+Okbt7w6UiqgxUp+M7Xtthqgx+CHCS3Lzsqm5piQUjuTKqiVGNI2BgYGBwT8bQ9QY28PaZouagLRGLI3oo4nygNQiEVHDE22ecPM+T7TPafVK9CgaFjXnzVgWqRBRo0kaXp1oCSFShvsc4aFFeahUJWrdRIwuY9z33WWLvj9TrHCEC/VjHYoZ4mU6WmY2K4iVlxwC99U4n8syxiZMyxkbnWfDGnqf1fF2bEwawakcE4o6buLmux/hnQ/fxZ27r6G6oQcnzpVi+8VerI2zYM0lO/ak2NFkfQeff/kVPv/DZ7BaxhCU0oL10cNYGW3F2mgTtkd14kR0LdKKmlFT3wmz1QLHhAPjN8eI2xhxvoaKjjGcK7bgSMowtlwyY32MBaujRwgrVhEr6HfjVKzl0fQ7RbGsYWmjRdho8G/PUTYib+i35+LLi1jSXKB7GUX38YKCo2cEHiPU/rA6rp3H+8yi8/RcCNSncR2WOfpzIs+NS9TQuSxgOIqGnjM9UkuiapgwNaan23H6HQsdPtdVM4nGeRUyFjI6HE0zW9S4s+CMQo+kmY6oUYJGR5bu5pWh/LswL6CDxtqxKbwOdb1OjI/fQnByC5YFt+A5FjWyjHcHXvDtwFyfNrzoS1D7Aosab6ZNEzdtWmRNq6Q+Mc/wylAibJrw9MkmPHOiEU8fb1DCRgoM1wmPH6/FYxxZc7QGjx2rEVHzBPWfoL57dI0eWcP85mCFEjUHWNBwRM0NPHKwFKuCG4yIGmP7fpshagx+eHyH3lt/wFXrDUl7KrM3oHF87IH/oDYwMDAwMPhHYogaY3tY24NEzbJz/VgUPqiKAdMEWq3mQ5yjCbYWGcE1Szh6hiNpFkfSBJ7a5Rw1Q7CoWXrBQpN4JWx4+ewlFwktVUcvessFgHnFJI6O4agYJWg0KcPpTCxltP3ZkkVnxSWWKAT345RweRByLnOJmT5v+jpK2KyMt89EEzTcX0Wsp/7OJDuCihxotr+Ku+/fw7vvv4WpqZsoq+3AyQtXsT26C2voPD5/Lb3f3hQ7mi3v4Is/fYU/fvE5xpyTCMlowfqYQayKtRI2rKXvvjl6EB6p3cipsaOqxYThEScco6OYcI7h5uQkvQcLm9dR2XMTF8vsOJnJUTbD2BhnwWq6xkr6rdYQq+h3W37RIoWO5fflPhNFfR3aX8rpUlK0mO7nhWEaJy5qLbGUoXFB3yeWCEN0b4nzQ1jMRHJL45q04xWpuNUlDYsYPSJLPVuKRREEty7oOSPUylG8mtggXjqr1bFhgSMoeaPG+vFSaB/RK4WHWdQs0ESNu6zhVKhpehRnGE6F6sL8ICVpXMt3s7QJ6sSCwA461ilFeK80WzE5eQcXsjqxIqQVc/w78Lx/p7Rz/TqwIKAFy860YEVQMxZ4N2KOdwue927DHD0NSiJsVCrUsx4teO50M57xaMLTpxrx7EkdTdicaMBTJ+rw5HHCTdg8QTx5rAZPaqLmcWpZ3LiEDS/dzZE1mqzhVaEeOVCBRw+V47HDpVgb2ogPf2+IGmP7Hpshagx+eKglufPN6UQGapxDRhFhAwMDA4OHgiFqjO1hbQ8SNcvP9UvUg0Q+6JJGgyfSSyJM09EzEkGjis3qombZBZYBVpE1SgwoUbOYVzCKsYiQYYGw4qISChLtEc1ShiNolKQRWeOGLlRUxIs7FoEFjB4d8zeJd2BV/Cih+krITI/fP8awdLFhdYID25NGEVU6Dtvt9/DW+2/jjXuvYuKmE8UVLTgRVYWtFwewLs6K1fRe6+KchB37ku1osdzDH7/8Cl/96Y+YmLyJ0KxmETVr48x0jgXr6Duui3VgwyULdiWZ4JExgLRKO5q6xzDMKTeOUYyNWjEx7sTUzSnYbr6KVusdZDeOwTd3GDviB7EuZhhr6TdeRb/xitgRrKT+CvpNV9BvuzLahpUX6fei35x/d/nt6R7wilJLo4exPIpgWXORWqmDw+lU09LGJW64Po7e19FkzpLz1IqomZZ3sk99FVlDz865QSyOUCzRCddbOs7PHMHP2ss05kqxO6sicAQtwoZTojjya2FYP15hYSN1bdQqUgxH3LwYwvRp9M5ACZtuYf4ZJWt0YTMvsAtzRdS0i6hZHNSIpNI+ug9TiC/sxuqzbRJtM5dr2AR04UXfDmw+142TcV04FF6DzWdq8bJ3LV7wacEcrxbM9WpVwoZgYfOcZwue92jCc8Szpxrw7ElmWtZw+/SJeqIOLGxY0EyLGiVrWNToPE7cJ2sOVkpa1CMH3URNmCFqfpDb//pf/0tw3/SxBx3j7fscn739rWOzNz7jnydqvnMx5M6dbzFw52v03f4cPbc+QdfN99Ex9Tbap95A++Sb6Lx5D903P6Tjf8Tgnb/Qa77VrvOg9zD41+I7eja+wg1Ho0TTXLNWakWEH/wPagMDAwMDg38khqgxtoe1PVDURA64JtMuaIK9hCbaS2nCvZQLBmui5j7Oj2D5eYtIG2l5GekoLZpDojiUqNGFwUomSpMH0VZJYVoW4wbtu6JfXNKGznWlJ9E5Imy0yJg4B1bGjWLlpVGsIh4sa7RoGWJFArUJDmkFTfgomUMkOrA60YaNSTbsTnYg9sYEbLffx7177+P1t+9idHIUBWUNOHz+BnbGDmIDfeYN9P4bLzmxgd5/PV3vQIodLdZ38Mcv/4yvv/wjpm6/ioi8VqyPM2ENfXaGI28ULHgc2BTvwI4EC06lDSK21IKy9lF0D43CbLXBMerA2LgTY1PjGL31OvpGuY7NbZwptGFvihmb6POuoddzmtaaGPp96ffm1KhV0fR70e+nfnMLtXw/6J4Ryy8qeN8F7XPtGzl2ge55lAlLCW55nFs+JuMuWaOibBQsbrSxSMVSN/h5YpS0oTFGkzVLzmqiUIdr2nAaFMH9xdQuDtNRNWxY3HDEjR59w7wUSoT04eXgPrxEvMgt7TNK2PS4mCFtiHlnOoUFZzrwclALQvP7YBt9Ffnlg9gc3owlIV1YygR3YnlwO4LzBtFleQ179vlg/U4fHAi7isX+DZjn34q53oRXC14gnvfkwsLNmEPtC9w/3ahkjYbab8QzJ+tdqOiaWpEy3Op9kTRaKtRjhxWPHqrGI8xBJW0ePVSBRw/fwKNHSrHmrCFqfpDbu+++iz/96U8zxMm3334r4zdv3sT7778v+/rG533xxRd49dVXcffuXXz++ef4z/+c/gfDd999h3feeQcTExP44IMP5A+9vumvvX37trz2yy+//JvC5p8haljGsGDpu/0Fem59jM6pe2idfBWNE2OoH7ehfmwENc5BVI520oS8CaX2Gly13cAV6zVcsVzHdVs5yuz1qBrtdtUm6bz5Dvpv/4mubwibf22+Q/vUWyi2FCDXlEjPQI9RRNjAwMDA4KFhiBpje1jbbFETmN6E5ZH9EvngPqlmlvHEO3JYhAyLmBUsYe6DBY06xgJm1UWbwBEdK2JsIlsYTtNZFW0XebCa2tUx1Gcpo4kZPXpmJbUcncKsoj7vr6TXr6JjzGwJ4xIsxGomYRbxdK14VWdmDcHpSSxsViWwkHFgTaJ2XqKT+k6so7ENSU7sT7UjqWIMY3c/wLvvvYt7b74F06gT6dcbcCiqHDvih7Ah3oZN8U5sukRwS2yk6x5MdUjq0x+//Au+pjnRq3ffQFRBOzZfMomYUShJszZuFGuI1ZcYB9bFWrEl3kTXGEJIkQV59TbU9TvRbxmDzTGO8fExmsdNYuL2HZjGX0NZ9y1cuGbH0XQrtifYsZ6/G8snTrGKsRDqN5cIG7kfFiznCByNZcTSmBFhWTShCZwVUcRFurc0JuKGJQ2NMXxM77PQEanDnGf4mZl+ftxxf7bk+DkiYhqOspEUKU0WcprUQm557OyACBp3Fp7txysErxClw1E2r4T2YWFoL14OoTHiJRczRY27sJnPgiaoHQvOtEufOZ7UjfZ+O4rK2uAb14LTiX0IyhrGuQIzLl0xo6lPpacV5+Qh8VISCq804cSFRiwKbMULPh2Y76XJGm+OruEoG+p7NmOOR5NE1+iIqCHcBc4zhB5do+Mua6RmzdE6PH6k1iVrHj1YRVTisUOVePxwOR4/Wob14U2GqPmhbCxHGJYwsbGxIlVYxvDY119/jcHBQeTk5CA9PR15eXkwmUwyzkLm3r17qKmpQUZGBlJSUnDjxg0ZY0HzzTffoLu7G/n5+a7jIyMj+Mtf/iKvZYFz5coVZGZmyrUrKyvvkznuG38e57tvoWnShoZxO9qmXhfBwlEsLFyUGJkZETN458/ovfUZOqfepUn1m2idvEvcpn/gTKJx3ClFYGuc/agc7cANRwOu2SpQYilBgTkbeeZU5JmSpeXUlgJzJgppvHAkB0UjeQL3eTzPROea01BkyZdrVI/20XtMoIMm8j23PpWonOloG0Pg/CvAgo/vM0uay5Yr9CxZ6Z4bRYQNDAwMDB4Ohqgxtoe1uYuauqZ2BKU3YcV5JWlmT6wVNBGXaJlpUcNCRqSMxkqa0HO0xipiTbSNUCJmpYgYJWpYyqyJdWANja+J4egPIs6BVZfcIl4uKUnD4oKPMSwzuECvLjaUxKHj8QoWMSpdicZZvrhJmjXEOmJ94ig2aKyjc9YS67hPrNUEDbfriM2JYzicZkVO0yRuvfUB3nv/Pbz55j0MWm2Iy6/D4ZgGbIsflmuy1GE5s1kkzZiwkcZY1HAxYRY1f/7qa7z++tuIKezA1rhhrKPPyd9FWv7M2m/A0UDcro3j72nF+ksjdP4I9iVY4Jk9gujrFlxpcqJ9aAwjjkk4nROYnJrE5J2bsE29hmbz60ivnYRvnhW7Es3YQK9dE2vBWvq95V4Qci84MonGWdKwsFnGgkZkjeqzmFlBqHuqUGLGRPfejFUPYOUFOkbPic7yyGEXD36mNM4NYlnEgLTLOYKL+osj+jUGsEiD95eEE2dpPKxPcbYPr4T34iWhT3iZ+i+f5RXMekXULAzVIm7+LlHThQUsa4JZ0nTgRWr3RTWjor6H5sCDGBi+Rb/7m3CMvYWx8bcwOf4Gbk+8hjv099sxbEd9RR0qS+tQcH0YG0KaMN+nHQu82zDPq1UKDXNUDUfUMO6SRkSNS9ZMR9kwImiO186QNU8drxOBI1E2x+pE1khkzaFqPHawGo8frMIThyvxxJFyOn4DGyKaDVHzQ9lYqoyPj+PSpUt4+umn0d7ejj//+c/yR5kjZcLDw5Gbm4va2lqkpqYiPj5eImD+8Ic/oKqqCjExMSJoysrKEBoaivr6evz+97/H5OSkvLawsBCNjY3y2sDAQBE0HLVz+fJlnD9/HtXV1bh27RouXLiAuro6iax50Paf/+s/MfB6F4osGcg3p+Gy9QoqRltFtrRO3JY0pK6b70laEouYepo4V4/2otzehOu2ClyxXqcJdQmKLUUiWZRgSZaJdp4pRWRM4Ug2HctHieUynXtNXnPVWk6vr0aZrZ6uRf/xOdpROdolUTYVjjYpIHvNWkHnX6XXFshn4+sVjeTSa0vleLWzV9Ji+LP13vpUJvmGsPlx03XrQ3k+coYTUO5oNYoIGxgYGBg8VAxRY2wPa5spajoQlNFMk22aMLtNoPUoCYVZomYUs0SNRM9wy5JmBKuiWdRYRdas5ggaTdCsYukikkZrNUkjUTOERLgQLF04hWctC5q4Uay7xEyLjXXxoyJr1vI49VnCrNWEzFqRLqov0TFJSr6sJzawrHHhcOvTa5LoOgSftzVlDAfSbMhumsTUm+/i3ffexmuv30YfTcTDU6twMLoD21ii0GdZn8jYXZE0roga+gwHUh1oHLmHL776C/789V/wxhvvIL64C9vjhrCePj+/fgN/fhZN9BkE6q+R76a+79o4G9bT78efd2OiDTsTR3AkeRDBecNIrxpDbe9N9FkmYRsbw/gUfd5bdzFG86de65sobJxEUP4IDiSbsJ0/Kxc6puuxqFkRq6WRcTsLjsJZGcNROBa6f5w+xelSStQwK4m/JmqE8wydy8KGaxj970SNRNXQs6ex5NyARHaxpGE5s0jgPo0zLGuIxWdpnHhZEzRK1vTiFeq/crYPC8P6sIhwpUZJOhTXrrlf0jAsaqQf2osFIV14MbgDG6O6kNs8iSGzE6MjDkzax3HTeZO4hdvOO7jFjE5hwjGO4b4RpManIzE6FdcrTdgaUo8XvVqxwKcN81nWUMuyhtOgGCVrOAWKBU2TRNNw6pO+r6dCSc2ak4qnqM+SRlEPKTrMy3qzqDlSg8cOVomkefwQU4Enj5TjqWPl2BjRYoiaH8LGUSqvvfaayJTk5GQ89thjaG5uFlHDNDQ0wNPTE2P0H/THH3+MgYEBREZGinhhucMROBwx89Zbb0k0THp6OhISEnDnzh2Jvjl37py89tNPP5U/7lu2bEFfXx/efPNNnDhxQqJoOJKH91kG8bX5Ovy5Zm//i/7P9KYZ1+1lKLYUI9+cKZKFBUsJ7fPKOxzNwmlJLFt4PNeUJNEuBeYsWTqZRUqxpRAlI8W4bLks516z3VAixt4gE25OY+KisJzKVD9mQ8OYXSRLw/ioROHwhLyRvrtqnTJeT+fUOs302j7csDfSdUvlfTgCh98/15QsEojfj1OlKh2ddH0TWiRV6l1JlZoZGfRgOWDww2Doznd0zy1yb/lZq3EOG0WEDQwMDAweKoaoMbaHtT1I1KyOGlLpKw+YTPO4PlFXk/URl6hRsobhJaMtUh/lfmxYG+NwsSZOpeawmNFbXdRwOhJHu7DE2CCCwSGiRkmamYhoSbwfjopZkzQmcJ+vtZGu4ZI1nNrE52r765JoP9mJbUmjOJZpQ079JG6+/RHeee8tvPHGXbT3D+BcRjX2R3ViK52/IZGuK9dRSKQO7W+i99nM70X7+9OdaLa8K6Lm6z9/gzff/gAJV7qxLW6QzuMoHDr/Ep1LLQsihq8p34u/H/0uInQIFRlE5xAb4hzYHGvH9gQrjmUM4cJVE0pax9A8NIlh+004xm9j8s5ruHn3TfQ730Zx26sIKx7FobRhxaMN6AAA//RJREFUbEkcEQHG9XAkNSrOIsWHV9H94YgbVd+GV5Gavnd8T0XAaRJOImz4GeCWcH8uhAuMknkqCmvmMzVTAM5Mk+IUO71+jT6mp0DNZlG4Snv6e3klrE94mQl9cJ2aF4PV/ksh3Xg5uBPnro+ix/o6Wpvb0dnaiYH2HgwSvS3d6GzoQGtNM+pLq1FeVIaMmAzEhMbiQkQqLma2Y8OZBrzo04oFvu0SWTPfR8kavWbNHE+OpGnG86dbBF4N6rlTLG6mx56nPkfVsKThNKhnTjaIoHFHRM0xToeqJqrw+NFKPH6kgijXRM0NbDQian4YGwsRrj/D6UwcAbNw4UK0traKpOE/yJyuFBERgU8++UTSlVjIJCUlSSoUn3f27FmRNl999ZX8EWfJw1E1fD0/Pz9kZ2fjo48+kmN8zQMHDki6k8ViwebNm2G32yXNio9xJI63t7dIHj5/9sbqxvnOG2icsMnEuNzRhuu2Ki2SJV/SlVSKUg6KR4pwxcISpkLECAsYjoKpGu2VdBWuO1PrNEm6ymwJ0zQ+oU26v18aSxOdz69VKVUWep9+ib7hSByOymGZxMKIpU3O8CVqU+hz5kvNG4764RSspolxdE29KylbhrD5oaKW5C611SB7OA6l9jp5fh70TBgYGBgYGPyzMESNsT2sbbaoOZPJoub+SbQ7StCoCTpP2FfrdWYuUntRTejdJ/hrY6cn/Jx6I5ImViERMvE0xlxSdWNcNWRon8dY0rD80FtdqujIMYGFDaEJE2kTOIVpDGuTxugYpyM5RYhsSuRoF46uGZNzNiRypIoa35YyjhPZNpS038Trb32A9997G7devY36zmEEpzdiX3wXtibZsZWvR9fmGjaMel8VRbOJPg+Lmk1JoziQ4USz9V38kSNq/vIXvP3OB0i51osdcYNyjpynfS7378f9jdzy9xZGsY6/D39eOp+LFkubOC7vuTXRin2pdvjkWhFXasHl5lG0DE7CNHoT41N3MXnrDVjG7qK+5xaSK8fhmWPHbnoNrzTFKVYqyslG94V+d7pn7vdNh++tfn91cSOt1mdc0sZd1HDtItp3f4YYfd9d4OhMS5vpNDz3VaMUHGGjZI2eHqUfU2OqvV/mqGgbqWnjJm14me+XRND04GXilTPdWBpM/11kdaGtx4Kqihs0Hw5DfUU1ettY0rSjobwWxZlZuBAcgpOHTmP7dk9s2R2G9UeSsNq3HAv9mmVVKBY1Sta0KbxbMc+tyPALnq14waMVc2bhkjenG0XS6KlQLGu40LBaHUqTNRxZc5wLDlcTVXjyWCWePFpBaKIm3BA1P5iNa8mwaOHCvsuXL0dbW5uIEy4MzJKGxQynObHU4WgXrjfD0Tec9sRSpqenx1V3hiNuOL2Jx44cOSJS5rPPPpNjnGJ1+vRpqUnDtWtY1HAhYf7jz7KGU668vLxcNXJmbyxqJt59D21Tt0SksFSpH3OIcGEBU+HoEHnD0SrVzgGJcKkft9N5LGFYwIwrCaOJGBYrD/qHzz8GXdpw1A1H3LBcGpTPWGZvFMHE0TXFnCplSpf0GU7D0tOlWCq1Tt5B/+0/utW2eZA0MHjYcNQT398icw54SW5OrzOiaQwMDAwMHjaGqDG2h7XdL2paXKLGfSKtT6a5FUFzUUVUcAQN16CZRk3u18qE/354CWodJWpYPlDLcPSIe8vSRZMVOiJkRIgomcFjEpFCiOjQhMb0+SxQxrAuaYz2x6R+zGYaE1HDgiVxXK61MckuY7uTx+GRZcWVztuqJs27b9Oc5iYqWgbglViH3QkD2ELnbkgaxxZ6rS5qNibT9Rl+H7rOZmILHRNRk8kRNe+IqPkLzcPeffcDpJf1YfelQWyhzyifR4uoke/n9vlns54+//pL9H5csJjYHOeglr6zpH9xBA59RzpvV7IVR9PNCC6wIKlqFBVd4+gbmcKo4zbGnXdhGX0dzcN3kV43Bf8CK/anWLD1kg0b46zYEGvFeiaO7hfXyImdeQ/dhc2D0KWN1CnSIq2UsHFLm9JljvaM6c+W3ueImtmSRo1Prxal4BSpaXRJowsaPSqHixIv4qW8Z8gaBcsaF1q0jRDajxWhvdgd1Y7qnpuYvP0mii5XYNPuUyi5WonqimpcOBuJvZu3Y9vKtfA45o2DxyOwxTMba/xuYIVvNRb6tuAl/068GED4abLGp02lQbkJG0mJ8uIomzbM8VBRNO6iRtBq1yhY1tRPw8JGImu4dk0NUU39KqKSxivx1LEKasuxSUt9+sYQNT+cjWXNihUrZogaTl36a6KG05ZmixouPKyLmsOHD98najw8POT1LGo2bdrkEjV8rKOjQ0QNp1T9dVHzPtqmuBiw/g+VKSVdRIpwOhLLGOKfLmK+L/rnVClTHIHBtXWqnVrUjb0BV61lkpolETemBBSPFOKGvUnO56XBh+58A0PY/NfD8qzC0Yqc4XhJt2MJx/f3wffdwMDAwMDgn4MhaoztYW0PEjVrLppUNITbpJojaGSfa5DQvkzIaSK+WmrQ2GnyzhN6h5IwNLl3R0/bkT6n28SOUjuq5AKNr0lQcE0ZFQWjJIx7VImOu6hh0cJyZUuCOxzlQuNJLEkI2mdBszFpHJsTx+U4i5HNydQSck6yDVtS7NiePImTWWMobr2J19/5EO+89zYmX72D0oZueCdWY0eiCRuTHdhM78uSZnPihFyX5cym5HFhA12T06E2s8ghNiU7cSBjFI3meyJqvqV52Pvvfoic8gHsuTQg6VPyebRWPjuhvi9HztB3ZXGjwaKGf7eNxCb6DTfF0fn0m268ZKPfhqOPeKUnjhJiYcTyyUqfcwSHUkdwtsCKgpoxNPZOYch6E2Njr2Js4i302F5HfpMTwYVm7E8awbZLFrrmCDbEWele3S9qJPpGImyUmFF9Gz0HMyNueJ9FHi/PPlvUuD9fOiJqpKaNQu3PjrbR9jWRwyJGFzpLdSnjLmr0fRY1MxhwiZmZ4qZXatooWTOErRf6kFnnxOtvf4AB000EXCjDbr9i+J7LRWFxCcKDQ/DKs/Pwwm+eQUzEJZRVd+NCfgcORDdhTWgLlgd2Y3FgL14K7MRL/h140U9F1cyIrPFplXYBp0V5t0tkzRzGg2WNSnuS1CgpNjwtap47Xa84VSc8e6IOz5yoJarw9IlKkTQM7z9D+yxqNp9rxUeGqPlhbbNFDf9BTktLk4K/umx5++23RdJkZWWhpaVFigVzq68Cxf2QkBAMDw/Dx8dH6tdwbRs+xvKFU5+4iLDVahVRw/VrWNKw6NHr4fyt1Kf7Rc2PF0mVcskbJ034rRIJxGlaV63XwUWJOUWKa9uwxOHixUaUzX8136Fl4pak2vH94egtvn8Pur8GBgYGBgb/TAxRY2wPa7tf1LRirYgZLhKs0FNaFNMTcX3irtJlVPTFX0OXNVxzRaSDiAglXkTOaOKFU3hknAWFds60uNDg81jSaDKGV2biNKRthIpymaBxligTIlO2uFCyRoSNiBq6Dsua1FHsTrPDK8eJy11v4Pa9D/HOO2/COTGBkppO+CQ3YU/SEDalOAg7vc6hiR66Pr+H9j78nuuTx7Fe5A19DhE1YziY4USDiJo/49u/fIP33/8U+ZVD2BM/iC30PTaLUOLvqb6r+/fdcInFDAsbJW3cfzslb/j3ZOw0pkHnymsTbPS72qjvAEfu7KLzDiaOwCPbhPNXLMittqOmw4lu0wSGHLfRbrqDy823cP6yA8fThrH90gjWxboJmlmsiVWyRkkZTn9jeGwmSurNrGPj3pd95gKdc56hfqQma6hlecMsY2hfYcLScyoVSpc1SyJY1KgoG06DWho+OIPFZwexSGMhoUfR6FE1nA61MKyH6JVVpNZGdiGp0oHbb38Ih30S51NqsTmkBmuC63HpygDefOcDvHX3Lkqyi7Fu1RGsW38UaZnFqG/qxvXqfsTm9+BYTCc2hHZgeUAbFge04mU/FjIsZpSc4XaBbwuNtUifU6Fe8GrGHEKlQ+nFhpvw/KkGot6NOsw5VYsXTtVg3slqzD9VhRc9qjD/dDnmnCzDMyduiJx5+ngFniGeO34DW8+1GKLmh7bNFjUMyxMu+svFflm0OBwOkTM8zpEvUVFRKCoqklWe+HyOluHVo1i2cB0brmHz+uuvy2vfe+89rFmzRooJc62bQ4cOSV0aXuWJRRAXNOZrc3HhBxcT/tcSNfczLW64UC2nP12zVUpBYhY2OaZ4FI7kSepUy8RtKUBsyJqHyXfou/0HWfkrm+7HFYmmMZbkNjAwMDD4r8EQNcb2sLYZoqa5A8EsanhizYWBCa45s4bFjB4lofHA1KYHiRlCr7HC/Y0JM8XLjOgYlibcynF1jru8EETQMBy1wmJGsVVDj3QRUaOLFJY01G5JmpwWKyxaUug6KWPYlTEJ71w7yrpexe03PsS9e+/A7nQgp6wDp5M6sD/JjB1JDmxLttNrxrExZRIbpGVZoyJnOIKGP9PGFHpvOsbjPMbtocwxNIy8gy+++jO++cu3+OCjz1Bca8LehH567SidNw2nSvF31n+f6d+CPqtE3PCYYxZ0LtfYSdCIp3O03286KocFDq9KxedYsT3JggMpI/DKHkLUlRHk19lR3T2B5sE7qOu7jay6cZzKVPVr1sVZ5Z66165R95lbvQaRiqqaXYBYoGdHZA0h0Vki/BTuooZXjFp9nloNfdUofeUoljbTooZhQcMrlE1H1LC8Uf1BLI14kKgZwqJwRkXWLOTaNQSvGrUkTK0OtSyiB5uju5BQbcXo7bdx8+ZdJOU3YW9EPVaGtGFlaDNirw7i3nuf4qN330N/jwWHAwuwbF8Mdh0/j/IbTWis7URDXR9KKvtxPrcbhy40YX1II1YEtmKhXwde8uvEAl93UdNM/RbMY7wVUrtGX8bbowlzTjdQW4/nT9cKc07VYd6pGrx0uhovnyrHYs8KLPOuxDKfSrzieQMvnCrD8yfK8NyJG5hDzD1eiu3nmgxR80PbWNSsXLlSasVwhAv/UeYVoQICAiTFiVdxCg4OlpWZeJxr2nD6ExcN5qLDnCLFUoeX8eZUKU5r4ggZjsjhKBouFMzn6stzX716FUePHpXonMTERDlXL0z8oO1fX9S4o2rccI2dmlGOsmmT2jW8yhAXsC0cyQEvDd4x9bZWePhBYsHgH8nQnW9FonGEE684VjnaLffowffPwMDAwMDgn4shaoztYW2zRU1IVhvW0+SaoyN0UaOns8yOpNGljPv+tJxRouGvISlMLBC4FVHDKAkjESZucob3dbYQW5PGCSVmOIqG4f0tLE2SJwglZFjUsLDRkXFikyZTtqSOYWeqA6ezRlDadQdvvfsJ3r33JhxjE0i92oYTSV3YlTqKbalqFajtXMeGXr8hZQobUun69PqtqfRZ+FrJToGjdFgAbUumz8Wfh97rcPY4Gi1K1PzlGyVqrjaYsS++m76PnT6rg147OoNpecPf332fU6/cUePucoejamScfp9NnAbF90Jkjo32rdgYb1MkKDYR2xNMOJYxiLCiIaRUWJFZPwG/QpZAZrqfLGo4ZW1axCmmRY0qEq2nROnyRvXdnx939GO6vFkdZcZaETYmrIwcwqrzw1hzYRirqWVE1pwf0SQNp0Dx6mQsagYUvPw3R9roAidiyMVSjrYJn4WkR3H0zSCWhNPrz/ZhaXgvdsa2I6dxFFNvvocJmg8Ul7Zjd0QNlod1YGlYD9GCqMuDeJuelw/eex9DJicORdVgTVgjlp4uhm9UKUorulBf3Ybm2lY01PfgWg39tvTf1h6WPYGteCWgS0uFYlnTJCzwbdZoIfToGhVRw5E1c6md591I1GGeVy0WeNRgsUcV1vhUYZ1vOdZ4l2Kl53Ws8irDSq9yLDpdhpdOlmLB8VJqy/DKqVLsP9+Ij/9giJof1MZyJiYmRtKROAKGo1o4SoajaFjSxMXFSfSM0+mUcU5n+vDDDyXdidOhWLZwpA1HxPAfdC5SzClOnP7Ey3jz8ttcKJjH+TjXu+GCxPw6Fj28ipS+utSDtv9eokaHozU0aTNmQ9Voj6RB5QwnSlQHryRV5zSj99ZnbjVsjCibfwbdNz+UlZ64Ns01ayXdD7t2fx503wwMDAwMDP65GKLG2B7WNlvUhGa1YmOMBWsv0mSbieZJuBIx06joCp64c82ZDRwpo0dxSPSGLgwUsq+n7tC+Hu3hkjGanPl74JSlrcnj2JZEJE9gO7UMj21hYaKxOWUCm1MnqT+JrQQLHImk4fG0KWxNn8Tu9DH45tlR2n0br977AG++dQ/9FieSrrbiRMoAdqaOYmuaA9tSHdjO/RR6f7rm5rRJbErj60yIqNmeRqSO0XksblS7jc7dnuKkfScOZzu1iJq/0JzsW3z88e9xo2kEh+K7JUpnSzKLmvvZrEkcZlrg8JjOTFHj6uvHaGyL/MY8Rr89jW1KpGMsbKR2jYWwamP0Oai/PcmKXckj2JVios9moWMWulc2NwHHLd17RhM1LlnzV9CFjB5ZoyTNCFbHmKlPsKS5SGNMlJkwabCoGcJabi8OK4GjRdhIlM0FLkA8SAxQfwCrIoewMpKFzhCWRQ5geSQdO0d9F8MibBiuXaPgFCkWNP1YFdGPbVFtyKwZgW38NsZHJ3G1ohMno2qxNqKDzunC0rAuLAtrw/mSYbz93sc0X/4IVtsUTsTUYvnZNiwO6cDakDp4JjbiUn4Trpa1oLayFY01baita0fRjU5EZLbhQFQLVge3YJF/C172a8FLmpyZL3B0TZNE1XDEzVyJrqExrybM9aylfg1e9K7BYmpX+dZgvW8lNvlXYp1fBdb5VmCNZxlWEktOE6duYLlHBVZ4lmOJRykOXDBEzQ9uY0Fy7949iXbRU4+4ZWnDS2y/8cYbUm9Glzj6cU5d4to1DL9WFy18jOvPsMy5e/euSBje11/L5/H5nFbF78uRNH9N0vD231PUzIRTo1jY8OpRvAQ5y5o8UwouW6/KsuMdU/T/PG7/SaQNr070IOFg8H35DoN3vkatc1gKPReac+S3NqJpDAwMDAz+KzFEjbE9rO1+UdOCTTSBXk+TaY6sYdwn3SqyQluxSSsKzEtLy2pK8WMzhIwg+yxw1DFOxWHhokfK6KlLCi7SS+0MMcPRKjpjEr3CwmRr8gTBEmZCola2pGqk0WsEOj+NjqdOYhvB5wl0zub0KezKGod3oQMVvW/gztsf4e6bb6B72IHYknYcS+kSSbMlzSnRNEq4KAmzJY3fYxoWNSJmOOombXQaicQZpeMOHMl2KFHz9Tf45ptvad70B1S32HEsoQc7Uu1yztYUglve1/pc4HiLiBw7Nv8VNol8mSlqFErwTMscbuk1WstyhoXOJq5hI3VsGK5xo1KjuL6N6uu1b7ivcBUtvsQCR4maB7E29n6UqDFjTYyJGFZEc3FqG7X0OmLtRTPBcmaIWiJ6iI4RIm5MWM1RNhorLwxhxYVBOncQW+ha66m/NmoIK6P6sTJyACtY1mjpUcsj6Vxtf/k5GjvXj2URvVhOrIrsx5aoHqRWjsA0OgXn6BgqajrhFVOJjWEtWC6RNF1YerYDK0LbEVk0gDff/QgfffgxHM678IxrxJrwDiwObseSMy1YHdKEbRGN8EyoR3xhC66Ud6Gmph31dS2oorawrBcR2V3Yf74Fa4ObsSygGa/4teJF3za85NtMNLoibOZyFI1XAxZ41mO+V61E08z3qsHLntVY7FWNpV6VWOJZicW0v4z2Wcws87iBxadvYOnpcqym4+t8yrHKqxSHo+rxiSFqfjybLlf+2sbH/9o5+rG/dfzv2QxRMw1LAl5+vNRehwJztqRD5ZqSpMhtmb0evCR4160PMXD7T5IaNXjnL0re3PlWEzhG5M3fC/9mbZOv4bLlMnKHE1Fmq5dVux50XwwMDAwMDB4Whqgxtoe1PVDUxJqwPtZMjBAWmmDrkkalNrGsYRmjImVGZbUiXnGJhY2sRqRFzDC86pLUjEkYF9RqSG4iJnHMVV+Go2Q4rYmlzDZdrGiwbBFSWIywrKFxETUECxkmnVs6lkbXk5Zfx/BrqKV9GaPzTubacLX7Fu598DHeeusN9JgcuJDfjiNpQ9iRbBVRwoJmF11rJ7Gd2JbO0DX4/eX6dF1CRdQ4qR11MS1t7CJq6s0cUcOi5jt8+skfUNtmx/HEbuyg4/xeMyQPocbUuAgcd3lDSD+Z+knUsnxJVFJGonGkpfvCUTksdO4TNdOIsOGIGt7nayQQ8QpVz8YdFja8uhQRbyW4VbJmfRzXsmF4X/EgcaPSofiZMmN1zLDA0TUsaTiihgtZc/QMi5lVMYN0fEiEzToNjq5Ze4HGNFYTq6IGaHwAm6MHsDV2EBtj++k6vXR8AKsjB7Hy/ACWEysiB7CS97k9R0T0UdtLx/uwMaoH56+OwHbrTTid46hr6sPx86XYGt6IlWE9skz38vBuLIvoxMqzHThXyKLmQ3zy8acYn3wTAQnN2BDegWUhnVga3IElxCJiaWAL1oc24eilZiQVt6O0uhNNdS1or2tES10nSqsGcD6nC3si6rAyoBGL/bmGDcHLevs1YYFfI+b5NGCBTz1e5HQnz1rM86zHXGIe9V8kXvKoljSo+R7UP12NRbTP4mapZzmWnS7HitOlWOd1HRt9ruNUdB0+/cOX+PY7Q9QY29+5GaJmNlMiZGqcQ7hhb0aJpQS5pkRZ2jvfnC7Le5fZ6lBLx5vGx9A6+So6p+6h59an6Lv9BQZvf6WlSz1YUBj8h0it7lsf4oajETnDCbhsuSqC7Ie19LuBgYGBwX9HDFFjbA9ru0/U5DRj06VhmlibaPJt1ibgqiaJnv7CqS8cUaEK1E5P7Kcn9xzhodWXSVSiRsGiZlrSbOYIGmoljUknWZMws1CiRpcuDEubKTrGckaHJYqKfOFzt9PYdjqX05KYHWlj2JMxBo88G6513sLNNz/AndfeQPPAKM4X9+J46jD2aOftSBvFznQi1YkdLGHSndhGsLARXNcc16Dz6Hyd7W4czXGg3vQOPv/qG3z7zX/gs0//gIZOO44ltmNnmn2GoJmNSBo3dFHDbEqyKlnD8Bi1InSI6XElbRTufcW0tOHrcUtjfO/kHrLEcRc1HH1jvY8NCRZBhI2IG13SsJAZkVbBY+oYjzNrGE6DiqZ9Yl2MmRgiBml8CGt1olnUcLSMiphh1p2n/oVBGh/A+qh+bLjYR/RgQ3QP7ffS8X6sjezH6vMDWMVw30UfVhKr6JxNFzoRVjiADsttjI460dDch6CEKuyIaMHasG6sCKNzz/ZooqYLq852IJJFzTsf4uOPPsXU1FsIS27E5ohWrAhlWaNEDbP0TCeWBbVh5ZkmbD5bj+OXmnAhtxX519tQUdWKhsZO1Df343JVH85ltePghQasD27EUv8mvMyixrcJ830bMd+nAS9yVA0xn/GmMc86GqvDy161WMh41mCZZzVWe1dhvU8F1nuXYq3nNaz3uortAdewP/g6ziTU47PPvzJEjbH9/Zshav46jePjqBsbQaWjG9dt1SgayROxkMvSxpSGAnMWjeWi2FIgQqfUVos65zDaJ99A760/SGqPseT3TFjS8CpPNc4B5JlT5TesdHTBWI7bwMDAwOCHgCFqjO1hbQ8UNQnDWHfJRJNus6z6s+GSHRsv0URdJAyjIiu4IO1m6utsYSSyg9OadEnDUkaPpNFI5pQmhdSbYTnDfZY2yUrKbE+d0tAjaWhchI0SNdtF2mjyRotskegWlifEzrQJ7EqbxI70cexMH8MuYl/mGLwKx3Cl+1XcefN93Hn1LdR1jSK0oBcH0kewh16/O02duyvDiZ0ZmqxJVxJmO+3v4H4aHaNzGJY622mfo2jcRc1Oeb26xtHcUdSb3sXnX36D7775D/z+08/R3OPA8cR2ei+7vHZ2JI7ed5c0EmHDrduYiq5hIaOibNzHmc2MLmZS3Ftd0MxEUqmSRrWWRQ0Lm1GXqGEhs5Hr1sxCyRqVMrU+3krPjy5nRrCenyEaU2lS0xKHj+kyR4SORHFxNNcw1scMYX30EDaItBmi40rYiMS5SMeYC9SPGqTzBrApph8biQ3RfdjIRPVj/fk+rIvsw5rIfqw5PyAtC5o1NL5GJE0vXaMHXmndaOqfgN0xhra2bpxNvoEd5xqw8WwPVoeypOnFivBuogfLqGVRE57XhzfufYhPPvoMt2+9jaj0Zmw/14KVoW1YFtqBJSGdWBLahSXBnVgc1EG0Y3FwB5YFt2JtWCP2RzchJKMVGVc7caO6E/WN3aht6EbRjW6cz2zH4fP1WHumHov8m/CSbxNe9GnEfO8mjUYs8K7HfM8aLCBe8arBQs8qLPfmosJV2OpbgZ1+N7DL7xp2+F7HNt+r2OZXgr2BJQhNajBEjbF9v80QNf97msYn0TDuQK3TJKsSldnrcNlyRaJreKWofHOaRNxw5I2KuimQc/g1XTffV/VtRNg8WF78d4ElTf/tP9LvYkeROUfqAJXZG7SUJyOaxsDAwMDgvx5D1Bjbw9pmi5qwnGZsTTBhY/wITa5HsCnegs2XaLIvETO6lKExDS5AuzXRNg1N7lW0BkfLqDQnfUUkqS0jNWamkVSmGbCQmSJualCfxQ1LFxcTGhzJwqJEiQ2OgtmVptKVWLjsZqGSQcczJiSSxjPPjsudr+H1dz/Fq6+9ifquUQRnD+BQuhU76JwdmRNuguV+duj9dLdxkTgzo2lcx4hdImqcqDO/K6lP//HNd/jDp5+jvc+J00md2Mvn0+dm+POLqJH6NpqUkX3V52srkTMtbLZTn1FpUow6Z4awSaY+19lx1fihe5nMBYX1e6XD4yx2bApJleKoGx0VxcNiRm836q0bEl2TMIJ1l1jEuIsaC9aymBFJw7KGj5s1OM3OhA06MUPYwKKGI2kYXdKIqBnE+ig6FmXC+ovDStTE9mNjbC82RvdjEx3fHEVjF3vpnD6s49SoC0NYG0mc534/tUw3DsS1obb/FpzOm+jr7kfopSvYfa4Oa8N7sCq8HyvD+4gerIzoxoqzvVhOcOpTWE4fXn/zYxE1r716D7FZbdgd2YZVoe1K0IR0Y2FwB9HuYtGZdiwOaiOasfhME5YHNWJLSAO8YhsQn9+C61WdaGruRXPzAMqq+xGd1YpD4TVY41eDRb4NmO/TiAXEi94NeMm7Hgu8a7HAqxoveVTiZQ+1PPdqrwps8ynDTu/LOOB/BYcCS7Er4Bo2+pRgvVcJThupT8b2fTdD1Hw/OD2HU6PqxiyoHTOjxjmMamc/Kke7RM5wZA1H23BtG44WuWYrR/3YCDpvvoN+To268xf894uw+U7SwXgVLZY0xZZC+X2uWStQ57TQ72pIGgMDAwODHwaGqDG2h7W5i5r65g6czWnBtngTNtMkm9lCE+wt8bZpEhgaY0GTRH2aqHPrQku32ZoySrAYmGY6belvwZEyLGdUNA2LmZ3p7ihBs1MiZcbvkyS7aH93BsFtmpIme7IncSrfieK225i6+z5u3XkD5Z12hBQN41CGHXszJuh1k9ieMTYtYzR2ZY4JO5lZx3TkOLX8Wtf5rmMOHM1zoNZ0T1Z9+u6b7/DFZ1+ge9AJj6Q27E13SOHiXfxZCf176PJJwTJG9XV549rXmL0/HV3Dfb4XLMrU76vG+B6pVCh1r0blvrkkjUvWcKSNJmo0icOSZjb3y5oRrI9XkmY2usBZd8nshomOmbAhjqB9btfFDWNdrJI1my6qdn30IDZQf6OOPhbNETV91A7I8Q0XB7ExilOhWNT0Yw3LmvMDWBc5gPXn+yWSZn98LwrqHBgfn0J3zyAuZZVjb2QlHe/B6oh+ogerCJY0AgsbYk14O0JyuvHqWx/JCl5vvPYuLuV0YMe5Nkl9WhLahcUh3VKjZlEwR9K0u9olZ9qw+EwLFp1pxsLgViwOasXyoCZsCKnHkYt1iMhoQuaVVlyt6kVZZTdKrrUhOr0JhyI5wqYOS/xq8IpPHV7yrsXL3lVY4luJpb4VWORdjsVeFVjtXSG1aHb4Xcb+gMs4EHgVO32LscG7CCs9S3D4Qg0++cOXRjFhY/v7N0PU/COYkpWjODKEU6WqRrtxzVaJwpFciRrJN2fgirVU0n1aJ++i59Ynkhb1ry5sOIJmgL5n761PpXAw/y6cPsarPKnfY1iilR78mxoYGBgYGDx8DFFjbA9ru1/UtGJbohmbEizYRBPtLfEWTdZYsTWBocm7HkkjokaDJvCuWikpNhEB21KcBAuavy1ppiNkHowuZUTMpHG6kYpimRHZwmhjuzPGXOzNcsKrcBQFbXcwcfdDjE+9gdIWCwILB3Awy4bdmZN03hR2ZfytaBolX3ZnucmaWeJmV+a4rCS1m1tN1qjXOHA834E681v44quv8e233+GL33+BPtMYfJJbsT/DoaQSsctNOLmuTeP6mEJLs2IxQ/uuSBoROO4RNtPSRlak4nugiRo9YkcJGiVzZIUqFjcSgaPfR60vzIq2+SvCZnPytLjZQM+ORNJQy2lPal8TOIJZw4R1XBdJkzUM10hay30WNzHD2Bw9jE3RQ9gYM0h9BUfObIzRRc2ARNNsoD5H2aylY+ui+6jfS1AbxWlOfVh3gSNu+rArpgPJ5VYM22/CZhpCXlEV/OLKcCiuCRujOrD2QjfWnu/EmsguogdrzvVg3bkubIroxJaIFoTltOP2Wx/io09/jzffeB/JBV3Yc64Fa8PasOpsF1aEdWM516vRWBpCcF9kTavImsXBHFlDbRDtB7ZiSUALVp+pw46IOngkNOFCThOyrrWgpLwDmZc7EZrWgn3narA6sBoLfaqx0r8Km4KqsDGoEqv8K7HSpwJriA0+N7DV9xp2+JRgF7HTtwibfYqwxqsER6MMUWNs33MzRM0/HpUqZUe1c0BWkCocyUeeKVWlRVmKUO5oRtPEODqn3kHv7d9LapRaRWqagTt/Qv+dL4WBO1/RGC8N/kNeXeo7+Wy8mlM/fXaWUfz9GsedKOeizCNFkiLGv8E1a7ksy20sxW1gYGBg8EPDEDXG9rC22aImLLcVW5JGsCGJIyNo4k1sYzFDsKRhtiXZXRE0LGm4DopM6lNpIp9CY4RKy1HFd0WupI7JKkosb1wFf/W6MjrpnMakxlVaE4saXdKMYRe1Uj+GRQZLC5EZLEwUKpJlHHsymTHsy5rAiXwncttu4dabH8A5eRcl9Vb45Axjf/YodmfxeRPYQ+ftynRKXRolWMblGIsXdyEzLV+UjOFWZ0/2hGrpWnuzJ6VldtP7HMvnVZ/eFFHzDYuaP/wRQ5ZJ+Ke14UDmqHxWlkpSF0f7blIfh1C1cpSY0qOHVPTMzLHpcV3WqH1d1Mi9EGFGv7EmalzCRu4Vn6tF2dC9nI7I0ZDoGxY2mqiZJWh0SSPPgkgcen5oTC39TS09PzMibrSomw0JZg0T1lO7jonXYEkTa8JGYlP0MDbHDmFrHBE7iO0xg9hB/W3EZl7pifY3EVLThs6VZb9jB7COa9dE92FzFHGxB+upvy2mG+H5fegdmYLNZsH1azeQmlOH+LxOxOV14Ux6Ow5fasOO6DZsjerApvNd2BDZgx3nu3E4then47sQX9JNz9R7+OjTz/DW2+8j53I3fOPbcSyuC/uiu7ApvA2rQ1uxPLRdhM3yEFVkeHlwu9SpWRLcMi1szrRhSRCNB7ZLuyiwBUsDG7HmTA22RVTDK74esdkt9B6dSC3qhXdcM9b7V2BDYA22BFZhg18F1vlXYo1POVZ63sDq06XY4HENG09fxqZTRdjiWYgtPkXY7FsCz9haI/XJ2L7fZoiafx56lA2vIFVmb0KJ5TIKzJnIM6ehcCQb16w3UDnaidoxk5zHUkMxKulSHJ3DsPRppmu10f+T67z5rkgQrvXCQofFyIPFyfeDJQunZSlRxC3Dq1f974WQyJnbX6Br6l20Tt6Rz8wy6orlmnxfFjTc8vfnlbQ43cmIpDEwMDAw+CFiiBpje1jbbFETnqsiajZLVI0ZW7UaNJuJLYl2OkYT/CSCJu3beBlrmpRv5Ym9hj7J1yUBS4EdKQpZQYna7QL1eT9tDDtZxlDLaUuSuiSMCjLGkkREBo1Rn2GxslsTJ3JM60uETJYTB3PGcDpvHJkNUxi59Q5sN+8gr3YYvjnDOEDn786+SWhChSULyxn9enwdl4Thvs60mHE/h1/vIouvOc3u7DEcL3Ci3vw2vvjyz/jmOxY1f8Kw9SYCWNRksTCafo/p70UtfY9ddHxnJksbJaWmI2u4T78d/z50rpI56phILJFkKvpG7gXdE2ZHihssarT75M5sQcORN9sI1Vf3WEQNR88INldfZI1goX2L9LeInGH5N6KJGhY03DdjY5KJWhM2JA4TZoKOacc52mbjJSLWhC1xZknJ2x4/jB3xQ9gRN4i9CYM4mDSIfQkD2B7Xjy1cpyZmQAoRr4uh61G7QUTNADZxFM7FXuyI6YNPWjfahyZgNttw40Y94tNKkVzQjsT8DqTmtyGpoBNRud2IyOpBSHovvBO7cCK2C8dj2uGd0IrQ5DbkXu/BndffwceffoZ7776Hyqo+5F3pR2GZGbmlZkTl9MIjrhm7LzRjc2Qb1p1txcrQFqwMacHykGYsDSVCpkXN4jMcaaOKDi8MaMWiwGYsCWjEMv8mrKJ2w5la7I2shkdsIw5HNWFNYBWW+9VgqU+VsJzxrsIy7wqs8i7HOq9ybPC8gQ1e17HZ9yq2+l/F9sBr8EtoxKd/MIoJG9v32AxR88+H69o0jDtlCepKRyeuWsslLSrfnCkCQ5E1g0I3ZGwkC8WWfKl5U+5opWsN0jVtEpnTQtdvofdpmbwjKUbtk69Ly2lWsj/1ptTI6b75gSyLrdN16wMRPx1Tb9Hrb6FxzI4GZtzhEkfNkzfpGq+KJGJ4OfLWydsiZPj63GchVePsx3VrBYrMufR5+ftkSFs4kidpYEpImeW6xjLcBgYGBgY/VAxRY2wPa5staiLz2rAn2YydScwIYcM2rdAsFwreTihJY8P2FCu2p9qwkyb0uwhut2uihif8LAhkhSQmdVRaLvTLUTFc6HcPwUV/dVHDAmYvsY+O76F2dwZHm9BY1igO5DglCuYAsZ/3Bae0vL+P+nuzxokp7M91wqNwHKlVU7DffBumsTvIqhmCZ44JBzLp2plKouyT85VokSgYTbaIgMnWo2SmJQqzh4+54f4aXfq4sy9nHCcLx1A/8jY+/+rPNEH+Bl98/kdYHLdwJq0VByWyZ+Z76OzJ5paPM9PiRmCZ4yaolMjhcboPmbrMoXugtTpcC0fq4bBAI3SRoy8lru9zapWItJQxwkn3le4t39dUuvd8jzm9LdmKbUkWabk2kbQpI/SsEEmcGkfH6BniCK1N9ExtFFGj4IibTXSeGjcJm1gQJoxgczy1xCYN2b/EdZOGiEFsI3bGD2F/0iCOpfTjeHIfDif0YV9iL3bH94rE2RZnwvbYAeyK68f2mAFsiVFyxzujDxUd47IMd3V1M6ITyxCe0ITw1BZEZrQiOrMZl7JbEJ/bRrQiIb8DsbldOJ/ZgXC6X+FpjbiQ2ozcK5149bV38Olnf8A7772H2ro+5Be14lppN+pqh1FXbcL1skFcyu2Ef0oH9l9sxtaIFmyOaMO68FasPNuCZWEsa6gNVvJmRXAzlp+h/aA2LAlsxeKAJiwKaJZ2cWAD9WuxLLCajtXgFX/Crxov+1bhJZ8qvOJdhUVedMyrCsu8KrGK9td4VxLlRCnW+ZRig28pPGKbDFFjbN9vM0TNw2QKvAx1/ZgN1aP9uOFoFolxxXpdok24ELHOFes1GeeWj/FKUrzClBI5SoRwGpFKJ1IpRQUj2VKot8RSJEuGF1nyiAKUWC/T+9xAqb0WZfZ6F7x/3VZB73FVInz067iQJcgzpa5MkSVfXW8kV6QRfxbe5756HS+1nYFCcw69/xW6bg0qHO0STVQ/ZhehZBQNNjAwMDD4oWOIGmN7WJu7qGls6cClonZ4ZNlwPMOCY2kjOJJmxb5kC3bQJHx7soNaB3Ym2wgrdqdasYc4kDGKAzTJ30sT+d00iZdJfrpToj1YtOzPHMW+DAf2pnPhXhYqYyJZDmU5cCCTXkPHuZbL3pxRHOYIlKxxHKZz9tNrWcQcoXGfojEEFTkQXGRHUPEo/Aod8MgjCpw4mefE4RyOohnHgVwuHDyB1NpJWG+9j0Hbq8iqNMMzZwQHcljITGFfJsEpSvQee7OpzZmcRhM23N8nY+PYk6OkyZ5s+uzZ4/Ka2ULGJW4IuSaxjzjAooYjaiz38PnXX9ME+S/44vPPYRu9JRN//g34ukrKsIxRkkaPqOHUKWZPDp9np74Du2h/l0gbOo/ej1O1RNTw76idL1E2AkfksLwhOCJJopXotXx/5D65o6JyRNRQK2Itld6D9nel2bEn3Ya99DzsTbXQfbdgX6oZB1JMIvZ2p9iEnTS+LXWEnpMR7E4awa4kM7bS8S0pZmxOGZFIGwX1eZ9gWcNspnM3J5iwOd6ELcKwwPsbhSFiEJtY1lC7O3EQR1MG4JHaB6+UHnim9uB0ai+OJ/fjUEIf9l/qwvGkPhxP7MfhhAGcSu7ClRYHbON30Nrej0uZlQhOqId/fCvOJDQiLLkRZ1MaEJFSjwvp9YjKqMfFrEZczGzGxYwWxNL9upjahKjkZmQVdeD2q+/ik0+VqKmr60NqZiOSidyiVlRV9qOlwYQG4nrlENKL++j6nTgd04wj0c04cLEF2yMbseVsE3afa8LBC404GFmPraG1WHumQVaEWhrYhCWBLVjM0TWBtB/QQG09FvvXYKFfNV7yq8GLvtVYQLzoW4OXvGqxyLNGhM1iryos8azEEo8KLOYVoU7fwDLPcnqfZnzyh6+MGjXG9vdvhqj5r4FTfzhihSVG/ZjFleZUq8GrSvG4fozTo6pH+ySaptReg6vWMlwWuaNJmZF8jTyJYhG5osHROyxWCs3ZInN0eF/G6TifV2IpFinEYkegfb5moXnm9fT3Uu/D/QIRSjfsjfIZJV2Lvlfj+LgRPWNgYGBg8KPCEDXG9rC22aImpbgF5wtHEF1iw8ViG84XO+CTY8V+mlDvTLETDuxOttMk3Y6DGQ7sp8n7QZrUH8xw4gBN6EXW0D7XkeGIGBY0hzLtOJRlx5Fsh0gVr/xxBBaOIaRgFIH5DnjlOnA6xwavAgdCSsYQSUQQAQU2eOZaCRvOltiReMOBtHIHkm6MIuraKIKL6LPl2XAqx47jOQ4cy3XieMEYoq7fQaftHobG7iClzAJv+vyHsiewP2eMGBdJsy+T2mwlY/blspCZwB6GzmN4X46x3Mkdp/0xQfZpfFrScH9KxuQaLHLoPRgWNQdp/HThBOpG7uGzr2iCzKLmi8/hcN5GZGY7jtDn3pvjdLE7WzEtb1gQsaixEzY6xtBvTMd30XFGFzscaaOOERKFQ/eD+nvo999N92EP3Y/9WfS5uIYPR9+wjKFWUqXSHbSv7t2eNL6vDrqfDhyk+3mA7vWBdAsOZ1hwPNOCE1kjOJ1tpt/VjMA8C3yyzDiZMYKjaXyOFQczzThGnM6k3z3VjJ2pJmyjdmsKY5J2M4sZTd5wZA1H22xmEk3YnDAsbI1XsKzZlEgkDNH4ELYwElkzhD2XBnAsoRveqd3wTemEf1oXAtN7qd8Fj6Ru+Kf2IIjGQzJ6kFk+hJHRW+gbsiI2qwaByY3wSW5BYGoLzqW14EJ6MyKJiNQGnE2qRWRyAy4kNyEqtRkxdDw2tRFRKXVCekEzbt5+R0TNe+++h8aGASQk1+BCQjWdW4PsohZUV/ejuXEAzXV9qK/uQ+mNPmSWtCOxoA2X8jtwIbMV4Un0vvT+0XTtSHovv7hGHDxfj+3h9Vh3ph4rgjiaplFYEtAk6VCL/euw0K9GRI3AosaHRU0NFnqwqKnBK55V1K/EK6eJU5XSX0xj+6La8LEhaozt+2yGqPmxwNE4LHfGJDWJo3JY5uiCp06WCh8SUVI12isRO7zKFC8dXjXaI9EtN+xNKLM3uuD9CkebLC1e7RzUrsPXnIaL/qrrDEhbQ+fV0vtwq8aGJKWpfswq4onToIzIGQMDAwODHyuGqDG2h7W5i5qmlg6kljThQuEQLl0eQfxlC2Ku2BBaZKUJug17aMK+M80u0RX7iP3p1BL7uZ82KuzjlgVOpoIjZg5mjuIwcSTLAc98JwILR3GueBQxlx2IKbEjkvpnibDLowgvseLiZRviro0i+qoDkVccuHDVibjro0gqtSP1hh3x12mcXhta4sSZIicCCp3wodaXrnu2xIaKvjfQbH4dCaUjOJVtw8EcJ/blOrGX2JczJpE1LFH2i6ihfu64Io9bFjT3wxJmGl3GUJ8lDbEvh+DX8jXkOmNyzYM07lE0KaLm919xjZpv8cUfv8Do+Gs4n9WBwzk2us6oiz0aLFtY0HAED39mOZ5rJ/j70G9Kx/fl2LE7l87j49mME7v5tXwu9Tmt6gRd/0SOFUezrHQPuHXgGI0zLM/2M3yfRLBYcCTTTvfaCt88B/zo+gHZdvjROb5ZNvhkWeCTMwK/XDPO5A8jomgYcSUjSCgxI7rIhPA8E84WjCCscBjnCk2IKDAhMN+Mw+lD2J1iwu5UE/YRe5PN2ElsJ7YRWzgNSuogjWBLookYFrbFD2E7sZUQQcP9hGFsJ7bJPvVp7EBCH04m98ArpQv+qZ0ITuvCucxunM/uQxRxMbMNGZc7MWy7LXVp8krq4ZtQh+PxLTgV34rA5BacT2tGDEfNZLXifGoDwlnUpDQiIrGOqMX5lFpcSK7B+WTqJ1UjNbseY5Nv4uOPP8UH732AluYhxCRVIjS6HOGXapCY2YjC4lZUVHSirqYDDdWdqK/qRVVFD66VdqL4agdyC9qQlt2CtKwmpKbXI4ElUFIjguMb4BVTh/0RNVh/plaiaBZy6pNE1Shp80pAHV7yr8XLfjV4xbcGC330SBrFIg/idBUWEotOV9J+lYiaAxfb8fEfuKi1IWqM7e/cDFHzrwNHr7DM4dWUWJi4oH0WPFykmGvE6PA+j3M6lhIsD7quWnrcHTWmjxtSxsDAwMDgXwdD1Bjbw9pmi5rk4iaE00Q7sogm3DTJDso1wT9nGB7ZNprE22hSTxP6DAsOptkl2uJgmho/ShN5jpxhScNyhpF+xijhlIibo9ljOJHrxOm8UQQUOnC22C6RMoEFDvjnO+BXaEdAsQ3BRTaEFdkRUmBFKLXhl52IuDKOs9SGFjtwpmgUPvlOkT6eeXQ9uuYJbgucCL8yhvy2m7hw3YZTLCtYztCxvXlj2Js/Jv0DuUrWHMiZxH6WK7qkIfbnTQg8JpE0fEw7Zy+9zoXIE03WSOSNhn4tavcTh3In4ekSNd9IMeE//umPGJt6HVG5nTjC0Uo5o8I+hj8vsTeXxYxTRQARh6h/PM8OH/7Nro3h4o0JhF0ZhW/xKE7kj+JQDn0vETt8nTFJFwui3ymubAyXypyIvGpHaIkVwYU2+Q3DSuh3pL5/vpVQrV++Bb65IwjMG6Hfnsgz42z+CGFGhNYPotaPzgnIMdHYIBKLBpBWMkgMIFkYlDaF2vjCflwsHERwNj0/aSacILxzLPDKNuNYxhA9O8PYm2LCzkQzdiRasT1pBNuSTNiaOCxsJ3ZoLbOT9zU5w6KGpc2OxCHsSejH/oReHCKOJ3bBJ7kDYekdiMzqQHRWN9KLOtE56MCYcxxlZc2ISquFb2onPJI64JnQhuDkdhprRVxmCy6mNyEypR7nkhsQmdyIsEvVCIuvElFzPqkG5xIJ2k/LbXKJmvff/QDtbWZEJ1YhKLICZ2PqkJjRjLyCNpRcaUXp9VbcuN6GitJOlF3vwNWrrSguaUZ2biOSWdCk1ko0TkJiNWISahBxqRaB0VU4faEKu8NrsOZMPZYFcERNAxb7N2NhQBNeof5CiaypwyKfGiz2qcVSYrFXDRZ5sqhhQVOFxdQuof0lntR6VeFgtCZqjBo1xvb3boaoMTAwMDAwMDBQGKLG2B7WNjv1Kb6gCUE0CQ8vtCMsz4aA7BH4ZZkQQhP5EJrIB9GknUXKaZYzaTacojaowE6Tfzu88ywibA5nj+KgVn+Go2kOZY4Rozia7cTxXBY2DpzIteMkXV/I5cgPJ07mjOJ0/ig8CK88anPsOJVH5+YT1B7jfi7jxDGWEXS9I9njOCTCZRKH8iZwPH8SpwrG6dwxHM6dwMHcMSkuzOJjD7GPrnuQjh2UYxMuUaMLmv351CdURIySJtKn17DkEfh6WqqSHKdjfB3+DLrUcYkauqZn8QRqzW/j919+SxPk/8Qfv/wTJm+9gej8TvoeNhEsB+i7cMFkdT0Nee8J+n7jkhoWc92J6+13UNvzKup7XsP1ppvIq5tCzI0J+ORZ4Zlnl1Sqw3QtH+onljlQUD2KoppR5FU5kFHhQEqpA8mldiRdp+PX7Ii/akXslRFcvGxFRJEVwXkm4UzuMD0Hw9SaqTUjMNuEoNwR+GZb4JVlgQc9EwHZg4jIHUBU3hCi8/ro+/QgpqCX2l6cp/3wnH6EZfYjNHMQZ7KGEZAzBD8a887ogWd2P45nDuNQmgl7kljCmLAzyYQdbrCc2cZyhthF7Es0Y088nUuwqFEMYjuxI36Axgew91IfDsV34ERiG3xT2hGe0YyKZhPso5OorWtHQlYdIjNbEZHZhXMZ3ThH7cXsLomkictqQlQaS5p6RCQ1ITyhAWGXOKKmDudTGhF+qRqhsVUIj6tCSlYjnBNvaBE1H6Kr04LoxHIEnitH8IVqxKbUIiO3Ebn5DSgoaERRUTOulLQRLSgpbkJJUSOys2pxKakSMYlViE2sRmJSDRJSahCVUIXgixXwOFeJQxGV2B5Sjc1BNVgbVItlnP4U2ITFAfXCEv96LPWrwzLfOiz1IbyVrFnsWS0oScNFhqvpWDUOxRiixti+52aIGgMDAwMDAwMDhSFqjO1hbe6ipqGlAxcLWnAiw0QT8RH40KSc012CadJ/sZgm91dtSC+1IemaA2FFDnjl2ODLAuHqKJLLHLh41Y7AQhrPH8PxHE51GsVhwSktpz4dybJT345D2Q4thUcVEGbhwgWE+dwjtM/RN4foGEeKCHweX5P6XDj4sAgaOl/OG6Nr8f44XY8jSyZln6NKDtM5LGsOiExxEnRN6h/KUxKFOUgcEElDbf64sF+ib/h1tM+vFfj1Gvq+QOflT9J5UzhILcPX49ceJjyKx1E9/DY++9M3+Pa7/8SfvvwTpu68ibiiLvqeVvnMnJ51QLs2Cxq5JkOf/UTeKKJLx1Hb+SqGTa/CZr0Dq+UuBodfR2vPqyiuGxcpE31tFH4Fdnjk2hFWaENWuQ1Xah24WmNHcaUVeTdGkHXdjIxrZqReMSHt6giSLpsQUzSIC4XDCMvjCCqOliFyLfDLtdE9tuNUphXH0s04kW4hbDiWYcWRdBNOZA7jdMYwPNKH4Z0xAN+MXvhm9sEno4/G+nEsbRCHU9TKTCcz+uGZMwCvTOqn9OF4ygAOpQxhf+ow9iQPY1eSEjXucGoUCxuWOLsTTNiXMIx9LGo4miZxcCY0tp3O2XWJV3rqwe74bhyO70BccRf6LGNoaulGZFIpgjhKJr0NsVl0LLMd8dkdSMrvQEJuC2IyGxCRXIuwxHqEXKpHUHQdUYuQuDqExtUi+GIVzhChMdWIS62DY/x1fPzxJ/jog4/Q021FbFI5zlwoR8jFakSnVCMxvQbJGdVIz6pFRlY9MrPqkJVTh5zcWuTl1SIlpRJRMWU4F3MD4dFlOB9bgdjESsQmVyEirho+kVU4FVmJk5HVOHquBnvCarHuTCNWBTVieWAdlrKoIZb614uoETiqxrtGiRkvanVR4037PlU4FGuIGmP7npshagwMDAwMDAwMFIaoMbaHtc0WNefzmyUl5WDaCA6njtBk2wzvbAtC8myIKbEh+ZoVCVdsOE/9oHw7AvNHEXNtHMmlo4i/5sCFK1xvxgkfGucImRPZThxl+cLCRqtVw9KFBQ0jMoYlDJ2nGBMBw/KFxQuLliNu8L4ImlwibxxHGD5G+/o5R+l1R/Mm5BwlZHRon1+XS9flaBduaZw5SLCg4ZZRkTVjOEjtjGtor9PPl9cUEPkTwiHaP0ztYX5/4iid51k8KqLm0z/x8tz/gS+/ot/77luIL+rGiVwLjsrn0YQR9VnWHMlz4pSkdtkQftWJkuZb6B+6C7v1Dkbtd+Bw3IXV9jqN3UFL1y3Utt/G5YYJxF23I6yYU8esiLtiQWaZHTllVmReMyOleAAJhb2ILRzE+YJhnGUxwzVnJErGhtPEyUwrTmRxwWArjnN0lKS0WTWon2GT1Lf96SYcIA7S83GASR2mlsXLoMYQ9nI9mjSLtPu044f42Uqh1ybTWMoI9tAztptaZhfXrhFJo2rY7KBzdjJJKqKGV3nalTiA7SxmkgaxhdptDPW3JQ5hd8IwDsUPYl9CH/YQ/pk9aOsbQ2P7IC5mV+HkpTocvdSCkwlt8E1sRXAKFxFuRnQGS5oWRKU3ITC2Fj7RdfCMqsGp89U4fa4Knucq4R1RAZ/wCmpvwC+yEheTa2Bx3sVHH32Mjz/8EIMDDsQlcURNKYIvVuPcpSqEawLmXEy5SJjztH8h7gai4ssQnVCOiIt07rnrCIy4Bv/wq/A/ew1hkTcQefEGIug1ITFVCLpYBd/zFfCKKMfxsAqRNRuDa7EqoBbLA3kVKMUyv3pJfWKWsKhhMUNwuhO3S72rsMy3CkfiOvCJIWqM7ftshqgxMDAwMDAwMFAYosbYHtbmLmrqWzoQmd+M/TSZ3kcT6AMEr9rD0RSnM0bgT5P64HwzwgpHEFpgRUCuHb45owgqcCC8yI6zBTYat9O4FZ45HNkxpkQNCxiJqNFljIqQcYfHdBEjETMsXPI0CcP93PGZ0DGdYyxEtPFjwiSNTeIIwQLkCB1nWJzo/ekxJWBYrhxyEywsaA4WUF/GpoWOem81zue7o58r186fxFFBiZqq4Tfx6Zcsar7Dl199iTuv3UNiSTdO5ZgkHew4fdbj9HpueWWs0KtjiK2YwIWrVuTUTqKx+1UMDtzEiPmWJmteg8N+FybTTQwM3Ebf4F20dN9CXpVNUpnCiy0Ip/sUVWTGxcIhXMzrx/mcHkRkdyMkd1DqzJzKsuIYRzhJMWEHDtI9OijpanYNGw4Q+zOsGjbskyW6LYQZe9NHZMnuPWlW7Eq1EGZhNx1zwefQ2N4Ugp4nXtZbh5f5ZqZFjZI1u5OGsTd5GHtShrA7eRB7kgaxL0n1dyQNYDv1uTbNLpYz0h8UebM3fgBHEgZxOKkPJ1K6UdzsxMCwBSn5TTiZ2I7dl4i4dhyg9ghxMrEFPsnNCEhsQlBSK84ktsI7hs692IAjUfU4cKEOh87V4tjZapwOrcLps+XwOHcDPhHliEqqxsjoHSVqPvgApsFRxCaUwT/8mhwPjCqn9jo8Qi/DM+wKfM5eg2/oVfjQvm9oCfzCL8P7bAk8Q6/g9JkrOBV4FScCrsDjzHV4h16ncTr3bCm8wq/jJJ1zgvZPhN3AwbAqbDlTjTUBtVgZWI+lxLLAOizzq8VS3xosI1jSCLxEtw6LGp8qHI5tN0SNsX2/zRA1BgYGBgYGBgYKQ9QY28Pa7hM1Ba3YT5Nrnozvown4wXQLjqSbCQuO8hLMmcM4maOKwnIExpEMO45wJAbBURne3Of6NVkOHBdJo0XL6ClL/xs4teloroKX2+aWo2Wmpcw4judNiJxhKSNyRvZVqx9jmcLChFt1fHrMHRYsHAmjSxw+Rz/vcL6K2NFfz8y+vv46JWj0z+h2Pl3Du8SBatMb+Oyrr+m/6W/x5Vdf4c5r7yL1Wi9O5ZnommPwoNfxClZRpZOIumpFQcMUylpu4nLdKGrbJtHZcxtdXePo7B5FX98k7Na7sNvuwGK+CYvpDqzm12AmGjomkFdpQXTJMM6XWBBRZEFQ9iD8M/rhS/hkDsIjy0z3htPPRnEwdxQHckaxP9tBjGKfO1m8nDeR6cA+us970xmHkjP0POxJt0p/dxpjxW7Zt4icmcaMPSx1Uq0En2dX59LzxdE0CiVudqUQyWbsSzHhcNowjmcM4lgqp0n14WRqPw4n9WNP8iB2pgxLXZsDSYPEAA4mD1DbjwMJvTic2IsTKZ1IKhtCr/VVFJW1wzuhFXsv9WPnpV5qO3EkoRNHE7txPLkLJ5PacTSuGUfi2nAkphXHY5twLKYRB6ObsDuaXnehBQcjGnE0rA4nI6rgcaEc/lHViE6uxYjjDj76+GN88uFHGBkeQ0JqFXzDr+NE8HWcDLuO4yFXcTigBAf8inDIvwjH/ItxIrAEp4JLcPJMEY4G0XhAEfZ6F2OX5xXs9L6KbT5XsNm7BJs9irHD5xp2BVzHjoCr2B54HTvPlGNXcCW2BFVjXUAdVrGgCazF8oBarPCvwXKNZX41WOqjImqYZdRfRu1yao/EGBE1xvY9N0PUGBgYGBgYGBgoDFFjbA9rmy1qzouo4UgHK/YTB2hCfTTTgmM0sefVnQ5mjuBwJk30s7hwsB0Hs2gsywFe8ekktV40wT9Bk36OnjmU6ZRIGi4uzPVlVOQMo1KbJI2Jo2tyNDQpw4WAVWSManVJIxIld1qUTMNyZEyEx/E8p8iRY4SKUOHz+bj2+lkcYUlDcF/kiuv9xnA0X/ss8nqWLpNyPf2acg61ImjoGscY/Tpy3jhOFozB97IDtcNv4rOv/kz/TX+Hr6i9+8b7yCzthXfuEHzzeRnyMeTW3kRZ6y2Ut0ygtnUCDURj+wTau2+io2sK7Z0TaO0cRRsxODQJm+22iJrhwSmYhm7DPHwH3b2TqG62I7fcjPgrZkQUqkgoD0lnovuYxUt026RW0BH9XmSN0z104gDdKyVnlLRhSXOA+sw+XsVLoPEMFjccXWO9j7387EjEzQj2CGZN+tH5xF5ij348dQS7U80uYbNb29+fasLhVK59MwDfzEEEZBFpvfBJG8TJNF4taggHkjlyZgBHU/pwLKUbJ1N76FgPThGRRT1oHhjH9doBBCU341BCD/bG9+FQIh1P7oJnUjs8EzrhlUR9ljWJnTgSzwKnQyJvTie24WRCOw7EdGLfxTYcJI5cbMXp2Ab4xFXjTFwtolNrYbbfxkcff4JPPvoINssEktOr4Rd+HcfPlOJI0GUcCijGQf9i7PMtwn7fYhwNvIITwddwPPgKDvkX4IBPAfZ4F2C7ZzE2eVzGeu9rWBNQhlUB5VjjX4n1AbVYH1iLtUE1WB1YgzXUX0/tOhpfE1gvomYFI6KmFssFJWo4smaZb61L0izzrhJRcyyuUxM1/7j/32KImn/xzRA1BgYGBgYGBgYKQ9QY28PaHiRqDqSPYJ8ualItOMTRNNl24VCGVTjMZLoVBqZjx6nvlePAqRwlAVjCKDGjRI0gKU6TOJjLaUlcW4bOofZwnkKiZwQlR0SS5CtpwulER/KmcDRPSyvS0ptYtrCYOUHnnM53wqPQiVMFYzhZoMmaWQJF0MZZvhxjAeO2Ly29/jhdT0HXLpggpuS4ei1fe0w+G6P29WN8DXWdU3TMv9iB2sE38dmf/ozvvvsOX3/1F7z29vsorOxFZMGg1PbJqxpHWeMEqpudqG1yoIHaxhYn6tvG0ES0dYyjo3McTa2jaG4fRWePE6Zhjqa5jYG+CYmyGRy8haHBm2jrHkNZgw0Z1zntiVdwssIj14GjdG/4vhzje5Rrx2nimAg0pxQ0FpHGYo04RHAqlC5q9Mgafen1A7IUu0qF0ltBEzh70xRK4Ewfc41Ly5Fb03Cq1C6ua8M1bIijKUMiZjwzBuCT3o2AjF6cyRlEYPYgfNMH4JXaB4/UHpxO64R3egd80roQnNuO0uYR1LaYcDGrCR7JbTia1ItDib04ntJNr+lEQGoHgpM6EUz9kPROnKHX+6V04XRCO05easEpao+zuInrxoHoDuyLacf+mA6cjG+Bf1KdFBuOzqjHkO02PvxIiRqn/SZSMmpk1adToRU4HnwdR4Ou4BBH1ARcwT6/yzjgV4KD/peJEuzxLsRu7yLs9inBDp/L2OpzFRv9S7H2TDVWhzRgdXAT1gY3Yg21q0KIM01YE0T7GqsD6ZwgTdawqAmow8qAeqzwr8Nyv1qCW8K3Bss5moZFjW81jrKo+dwQNcb2PTZD1BgYGBgYGBgYKAxRY2wPa7tf1LTgQLoZ+1It2J9GpI7gAE2iOQXqsBSTVaJGZA3t80pOhxkWNTl2eOY6cJL6skQ3SwCWA7ogEDEzISsyKUnjwPF8rs/CkSlOHMlnIaMiWlimKHHCIoSOFTjlmBIhYzhJrznB+wVK2rAoOV0wBv8CG8IvO3D2mhPeBVacyh/FCTrneD5LFiVYRKyIeFGIZHHtT2qwnNHRx6c0Zh0v1D+r/lrtWjR2kt4roMSBmsE38Okfv8a3332LP3/9Dd58+32U1vQh69oQiqsduF7rwI06m1Bea0FVnR2VBO9X1FlR3WBDfbMDdS2jqGmxobHNga7uCfT130JXzyQ6Osdof5z2p9DdP4mW7klUt0ygsMqB2Cs2BOTzMuj0e9M98czhJdVtCCm0wYt+Hx6TVDORbXyvHDjEtWskWsqupIxE03AE1UxY0vBxrmWjw2Nc04YljV7fRo+42UfPkc5fEzV7UojkYSk2vD/FjMOpg/BI74F/eicisntwKa8fl3K55k4fzmR2IjCrA8E53Qilc5KvtKOx24zk3CaEpbXBM7UDHsndOJnSheNp3fBI7UJASgfO0vi59Hacz2xHdHYnYuhavFy3b0Irjka3YX90N/bHdmNfXDd2x3RjV3QXjsa3wTe5AWFJDbiYXot+60188NHH+OyjjzA1egcp6XXwCy+HZ3gtToSW4+iZqzjAUsa3BNu9CrHdowA7qd3tW4y9/lexK+Aa9gWX42BYBQ6FV2P32WpsPVuH9aGNWBvagnWhTVgX1oTV1K4OacYaN1mzOkiJGoUmbQLqsdK/Hst9WdRossa3Bit8WdIojsS1a6LGSH0ytr9zM0SNgYGBgYGBgYHCEDXG9rC2B4mag+km7KOJMwsaXdIwHFnjLmkUXKOGU51UrZqj2TSWQ5P4HJrsi6CxytixbCeO54zjdO4Y/ApG4cPLSOc7cCrPiZMsCTjtiYUMixkRNW7RMPnjOFk4Bv8iByKujuHC9TFElY4jqGQMPkVjCCoeR9S1MaSUj6GwbgK1nXdQ3XELV5tvIaF8HAGFDpyk67BE4SgbJVjGtHY27rKF33dCg15bOCWoyBoVUcORN+p1usxxv9YEThfS57w8hjq3iJo/f/0X3HvnXVTV9aDgej+KKy0oIS5XjkhbUmHGtWobrlXZcIX2r1SN4FrNCK7XmHG9ltpaM27UjaCq3oqaJiVvGprtaGp1oL3TiY7uMXT1TKCzZwqNHZO40jCK5HIbIi/bEFHswPliK6KLLcQIwgqs8MuzwCvPCv9CO3xyrTiZY6P7whKHxnO5ng3d/+xRHGD5xlFVGkrWsMxRHHDvi7SxCvszpuXM32JPOhcf5iLEJmGPFl3Dy3ifTuFlv3sQkt2DizmdiM7pQExuFyKzOxGa1YWz2b04T/3rdWbklbQhPKURAantOJXMRYM7cSy5B0dTunEssQsnEzrhmdABn6QOBKXQuWktuJDeiuiMNlzI6oQfjXOK0MG4DuyL7cCemG7sju2l/XZ4JjYgJLEeMRm1GLLewocsaj7+GFPjd5GaXQ//yHJ4RNTgRFg5DgdfxYGgK9gbcBm7/Agfwvcy9vhewf6gUhw6W4VDdO6BiFrsi6jD3vB67A5vwJbwRqxnwhqwNrQBa0IbsSakCWs1UaO306JGoUSNiqjhVCjBr5qoIippv1Jq8Xzy+VeGqDG2v38zRI2BgYGBgYGBgcIQNcb2sLYHRtRkTIsaETQ00RZBQ5NvxiVpaEKuRI2GRNLQRD2HJvJaJM0xmvSfoP1TNMn3zHUipNCBuKt2xJaOSuQLF9ANLHTCi6VHvhMsUDgyxiN/FB4Fo9TnSJlxBBU5kHRjDCWNU7jSNCnLVafXTiH2+iiyam6irOU2Gjtuoqv3DoaGXoXFfBcm8+uo776L9OpJBJew6BmHH79fiRMBl+k9qS8pUoXTYuUER8VIZAz1WcoUTeFkEUsaJWpY0pzUhMwxl8yh1xaq849Lq+TOKcKzaAIhV8dRN/wWfv+nv0iNGiVq3kdVXTdyLncjv9SEvOtmwoRc6udcH0LBDRMKiYIyE/LLhlFQTmMVQyiuHCYGiQFcrhrGlSozrhGl1C+vMaG+2Y7mNhY2o+jo4DQpB6qarSiuGUF2uRVp14lrI0i9akZiyTDiis04V2BCSN4wIgotCM8fQVC+he6JFSFFIzhTYKb7xqLGLkWHD2ppbof4PmuwoBG4r4+5j2dZhf2ZVuzLtGAfixsXNEatWkGKyBhRskaDa9zsTx3GkZQBHM/oh2dmHwIzuxGc1Y1QasMyuhCc0Y2gjF6cy+1CUlE3ziXVwz+hHgHJrfBIasfxpC4cSurFweRuHE7swZGEXhy51I2j8V2S5uQT34Az8XWIoNddTG9BZHoHzqR2wie5jV7fgWPxnTgU1y3LegemNiMqowXpha0YZlHz8Sf49ONPcXPqNWQVNCI0pgr+vLx3ZBVORNzAkdAy7Au8hl3+VySCZrf/VezhNKjAqzh2thwnImtwKLIOO8NrsTOsBrvO1mF7RCPWn9VETUgD1oQ0UtuMdcEtWHumGWuDiTMcWVOP1YE6dbJk90p/BRcXZknDUTQcUbPSr4LGKnD0Uqshaozt+22GqDEwMDAwMDAwUBiixtge1uYuahpaOnCBJqCHMkdwUI+coUn0EZpcH6ZJNksaXrL5EE2+D9H+QRrnMU6VYY5yCk02keXAMWo5peZEjgOnc23wybMitMSG2Os2pJdZkFVhQ1o5M4rUG+OIuT6BkOJRBBY7cJb650vHEX7FgTAaO395DAW1t9DYcRdtnbfQ3DWFhu5bqOu5g5pOmjv03EVH32309t/C8NBd2C2vw+l4DePON2Chfnv/XVxvuYX8upvIrZlAQd04ChomkVw1juDLo/AuckrR31MsYApvCqcKp3C6aAoeRZM4VTQhsLA5zrJGpM04jtP+iaJxGleRN0rU8PHp13oVTyH06iTqTG/h919+Rb/3t/j6z9/grXc+QHV9H7JKupFzdRjZV8zIujyMzCtDyLjcj8yr/ci+PoCc0iFkXRsg+pBD+4U3hlFYPoD8/x9778Ed23Gdif6S954neII9nhnLtmTJpEQx3XwvLnLOOecMNDK6gc45B3Q3UqPRyDln4OZLUoFKFkVJjJekopXme3sXbtM0h/ayRIoaj85e61t1Tp06dSp37a93VYV2CfR8lML5t+EM7MBNYUanjhGZv4P5FbawuYWl1TtYWLuNyfkzeCePYA9SfIFDGEb2ofPuQe3Zw5D7AAr3EQZcx+h2HQrSpsF+gjr7KWrtZ6hwUB3bmaBhKylezsZE3C3k2m4TmMA5t6DKFbiDHOvtfxHZllvnoPaTRWByRhA0j10BsU8SL8E7FpsL5xpOCEeEAxTqD1CsPUCJfh9l+h1U6LdRrt9FlXELNZoVwhLqVPNoVC2iUrmMQvUmctQ7yNZsIY/Ae9YUKbdRpN5GGT2rUS6hYXgWLcoZdCpnIVPNoUu/iG7TIjqMS2jSraBRt4Ze2waGnRvQOlZgcS9j/+RFfP+11/DWm4/wta98C77AChSaWXQNz6CxP4L6gWmUd4eR2zwqLGoS631IqfMhs94rlkQVNgdQ1jGBAtkU0jqmkNIeQlpnBEmd87jZvkRYRExbFEu40baMmBYGW9TMiw2F/xGzuNYYwdWGaVxhMElTO4XLdY9RHyL/CRQNL0lEjSS/nUhEjQQJEiRIkCBBwjkkokaST0s+TNT0kwJaYD5GHinLBaQsFxKKmawRpM25JU0hKdmFFiZv6LnltjjlqYwU+BJyBUhhFySN/Z7YF6XScQdN7rvo9N3G8Ogt2EK34Q6fwRk6gX3yDNbJuzBNnC9d0oUewEiwhh/COfMC3HMvILDwEmbWvorVNd6L5QWsb5G78yJWd17C+u5X6Z5cXu6z+wB7+y/i+OirODv9Gm7fZquar2Ft+yGmVx9icvkBphYJ8/eEG1p5EbbIQ8jH7qEzcB8tvhdQ532R8AJavPcwPPkidJEX0Td2F63+e6jxPnifsCkT7rnlzD+B5yWUu19EJT1ja5pzouY+Zo++ibd/9GPq07/Az3/+C7z66mtYXDqAzb8F5/gpXBO3hGsfP4Z19BAm/zlZYw7swziyA8PIFiyBHTiC+7AH9wRxwzD5t4W/fZQQ2CZ3D77QMUYjp2Jvm/nlu4K0mZw9hWf8AFYR3x7Urm0BlXMHKvc+VB4mag7Q6dxHo/0YVbZbgmTjfYeKGUzEPV7ixvsRvb/86QNgAkdcU5v48HIoYVnzeClU1MLmnyyNIrDFjbC6eWxhk2M8Ro6BwVY1vGcS+bGll+4EudpjZOuPyP8Q+bp9FOv2xKlP1fpNwjrqtKtoEBY1qyjWbKKAyRn1Dsq026jRb6NWxxYzmxSOrWdW0GlYhEwzj04VW9bMokc3hz4jwTSPQcsilI4VaF0r0DmWYbQvweFeFUTNq6+9hrffehff/Pp3MDm+CpNpFnJNGDLFlLCuaRkMo1I2gYLWIFIbfUiu9SC52o1UQnq1B1l0zxY2WS1jyOmYRE5nGKkds4hrm0ds+wJi2hjzwuXNhW+0zOF6ywyuPT4JSpAzBHavN02TXxhXGgkNU7hS/0GExGlSJcPLElEjyW8nElEjQYIECRIkSJBwDomokeTTkg8TNQPuZRSZj5BPSnKR6QTFpDCXGM9QbLqFYjMp7Obb4pjnsseoIIW72noLtfbb5N5GFV0zMVPpfAzHbdQ5b6PNdRuD/juwhO7CP3sbY7O3MBq5Bd/0LbjCd+EI3YNz6j5GIg8QiNxDcPYBwosvYHb1IRY2XsDSxotYIZePqN7YegGbOy9ga/ccG9sPsb51n9x72N55KE5A4k119wibOy9SHPcwsXAbocU7mFq4i8nZu5iYu4vIygOElu7DO3sP1vAD6McfYHjsviBuLNMPMLv1NWwcvIyZjZfgXXwRmtADtI/cR63nISrYaiZqOeMl1/siuQ8FqjwPUOO9j3rffbSNPMTgxF0sHr+Mt9/7EfXpn+NnP/sZfkB6z9rKIbwTOxgJn8EbOoVn6hSu0LGwojH4dqHz7EDv3YZhZBvmwA6swV3Ymbzx7kHn5mc7MPp3YBkl/zG2uNmB1rctlv+YAwdwj5/AHzrBWOSU3GO42TrHz+9uQ0vvs0WNzrNPOIDavQ+Few993mO0ufmUqDsosT9Aie2BINzK7eeneZVYeB+iOyiw3QWf9sVL3aKkzfsEDoXhpVFRf8b5vjVshRUlaM7Etbg3nZ37URsT10zasEtt79yShkHX4ujuf4SwuKFnefojlOj2UGvmJVCbqDdtoE6/jhrtGqp05BrIz7CNBv0WmvR82tMaZMY1dJnW0GlcQbt+ETLdIno0BO08+g3zGDIvQGleIiwS5qGxL0BnX4TBtgijdRF21wr2jl/Aq6+9jrfffgff/sZ3MR1ah8M+D7UhDIV2GkPaOQxoZtAyGEJV9wRyW/1IrfUgsdJFcCOt2oucBh9K2oOCzGGUyUJi35qUzlnEd8whtmMeMe3ktjF5E8HNtmlcb4/gamsE15vpmtH0GM3hx0TNFK40hAQ5Iwgaur5GuNE4iVKlRNRI8luKRNRIkCBBggQJEiScQyJqJPm05MNEjdy9hArLEcpMx6i0nBBOUUFKdTnDcktc15hPUGc9JZygxXkL7c4ztNlP0UnXPZ676Pfcw4DvPnp8d9HuOUHXyDEUgVNYQnfgZ5Jk9hYmImeEWxiP3MbYzB1y7yI0dw9htnYhTC89pPTwcdT3sbL2ACvrL2Bp7SHhAdY2H4rNcrcFUfMQGzt8/wAbW/fFyUeb2y+R+5KwvllavYfIAn1v5gShmWOMTx/DP3WMQPgUk3Nn9L1bCM3fxsTCXUrHXQRm72F04T5Wd7+Ok+Ov497ZV3F68lVsH1D5bH4V9pkX0eN/iFoXW828hErfS8ICp9HLx3DfR8PIPXQE76Nv/AEGJu5DN/0CXPOUttOv4wdvvIkf//RdPHr0Jr7x9ZcxG1mFf2JDLEti4spH6fKEj+EMHcEwsguVcwsqxwZMIzuwBXbhHNsXVjGO4BG0nh0oHZvQuDdhDu7COroDS3AHCscauo3L6LOs07tbMLj53QNY/Acw+fbPSRoX+fvoneAhbKPHYrmVkZ5pfYdQ+s/Q67uNetcdsclzme0BypmocfCR3rzfEG8Mfef8JC8CH/l9fuz3+f5EhfScwdcCbH3F/uL6HGLZnOl82Rwvrzu/voV8Cnv+7ByCqCHkCRwRDpFnOCQ/XgJF93omaU5RwESNfh/1xm20GNfQbF4ldx11hg3UGtbRTH7d5nX0mTcIa+in8lGYVzBsX4HCvox+8zK6dQvoVS+gRzOLbnUEfeppDKhnINfNYlAXQb92iq4jUBnnoTEtCMJma/8BXv3ha3j09jv4+29/D5GpDdht81AbwxjUTEGlm4NSz0uhptA4EEJ+awCpNW4kVrgQX+5CWq0P5V3jaFZMQjY0hW5FmNxptCrnUNo/g1RZBPGds4hrn0Vm1yzye2eQIptGTMcMrpHfjZYIbjBh0xIWJE0UV5umcLWRlzpN4kr95GOiZhLXmaiRLGok+W1FImokSJAgQYIECRLOIRE1knxa8kGiZmF5DSrPApqte2iz7kNm30en/RDtjmO02Y/E3iWtNl4ec4Ae9xF6XIfoo+tB9wG5+xige6X3DNqRO6T034HKdwvK4C1ox2/BPHEGd+g2RqfvYnLmLkLTtwm3MBW5jfDsXYTn7mJ26QHmVxj3CfewsEruErmL9zBH7hyfbrRyB8vr97Cx9RDb2y9giy1rCBtbD8QGuqsb9x/jAVbX72N5jd+7jZnFM0QWTjE+c4yRqWN4QyfilKXg9OMTlWbPMEEYn7uDibnb4r2D/ZdwcvwVHB2/hM29h1ikOMcW78My/QJ6/A/Q4r8L2dhdDI3fhWnyAUwhQuQ+vHP3ML5AYRfuw79A15T2ncMX8cYbb+Gn//Aj/Ogn7+A73/kOFufXERhfxfTCGcILdxCgtPBmwa7JA2Epo3FvQ+/ZgWvsQBA0fEKUg61qRvfFsii2uFFTGCZ19L5NGL2bGLLx0dMraDesotu4Arl5HSrnLobsOxi0bmGAj6K2rkPt2jq31vGxZc4uDN59cg+h8Z1A7jtDq+sWqhx3hTVN6eNlbKV8vLedl0LdFu759fk9n+xVZGVS5hRFtlvkx9ePYbmFAssZubxU7hQFZt6c+rZYRncOes7gZ5YT8Zz9842nFI5gZhwiz3SAXBO55hO6JhiOkC8Im0PkE4p5zxrDJqoMy6jXr6FRv4FG4zo6TGvoN69BYWGsYtiyApV1GUrbIoYJQ9YlKEyLGNTNoVcVIUyjRxlGzzC70+gaDkE2NIE+8h/UzKKfwsi1M1jdvosfvPYa3nnnXXz3O9/D1OQadLowBpTj6FVOYFA1RZimd8Oo751AcesoMmo9SK3m5U9epNB1YZsfdb1BtA6MomNwAm3942jqn0D1QBi5XWEktE8jpXMGJT0zqOkNo6R3Ctldk0jrCCGpLYxYQkzbNGJap3GjJYwbj8maa41TAteb6J7dxhBdT6BUKe1RI8lvKRJRI0GCBAkSJEiQcA6JqJHk05IPEjVLy2sw++cw5GFLDVLiPdswiuU3e9B6ds/hI/j3YAwymbAPI90bvEwqbEFHyr7Od0hhjqH1ngqYgrdgHT8T+6/4Js8QnLqF8fBtTITPMD51gtD0GaZm7iA8eweRBSZnHmBl4yGW1x9gafU+FpicWbyHWT6Geuku5pbvUJi7gozZ2HyI9e0XBFY3HwgCZ2n9LhbX7orTjthdpLALK7y57jlZMxY5gmfyGPbgEWwEx9ghnBOHcE8dwT99gnFh3XMbkzOn4lvrWy9gY/cFrGw9wNzaPYzN3xZLpSzh+9BM3IJ5+g7s07fhCt9BYPY+pji99M0V+vYq5WFxndP2EHfvfAM/fu+n1Kd/gX/4xc/wGin4OzsnCI6vY3ruDDP0XmiOj+Q+gXt8H9YAW7zswTt5SOk5wSRhhNJp9lG9eLdg8u9Q/WxC5dmict6mst+ke6oDxw76zRvoMKyiXb+CLsMauk0baNOuolW3ijbdCjr1bEWyjkHrGuT2dSid21C5uI4PKZ4j6KjO+ny30Og4E0ugSh1M0Dwma5i8cbAfwXnulthvo1jgDCX0TonjFvnfEvdFNoL1DIUCJ3R9Isic832OGGxlw0TNGbnH9Oz4MWFzvgfSOWnDzw4FWZNvOkKeiTcXPkae8QAFJoKR/Jm0IbfYtIcKwxZq9Fuo12+ixbgBGeW/j/NrWsGgcREK0wKGTPNQGGcxaJiB3DCHYdOScHtUUwK96mn0qWfQPTyNTnlIgC1jmMjpGQ6jXx3GwvoZXv3BDwRR88rfv4qpyXWoNWyJM4W+4Qn0DY1DJp9AU884ylsDKGoJIK/ZL6xqkqs9SOS9amqcyG/yoLwjgCoZhZONitOiirrCyJKFkdQRRgohtzOM4o4QirtDKKRwhR1jyG4dR2LLhFgOFdM6g5gWcpvCuCHA5MwUbjRP41pjiO4JzRMoVUlEjSS/pUhEjQQJEiRIkCBBwjkkokaST0s+SNQsr6zBG5yFK7gOr38dI/5V+APkBjbh828QNhEY3UFgfB/+8T34GGO7FHYTDt8G7Lyx7cgOjN49aDwH0Hr5qOlbcE/egmfyDL7QKUYmTxCYOMHE9C1hUTM5fUa4hamZ25iev4v55XtYWb+P9c0XBNbWX8Di8n0ssJXN6n3MrtzFzPKdc8KGrpfW6NnaOTkyS34zS0zIkCtAYRkLdxCZv43QzAl9/wD2wAH0Yl8WSiPv0eI7gMHPJygdwjdxBn+I03sCb+gY47O3EF6i9/m7Kw/EPR+JPTp7BxPz9xGcuwfH9G3Ypm5jJMJLth5gkdK0tv0AmzsPsbX1AHs7D/DCw2/hJz/6OX5DCvIvf/kPeO21N7G7dxvB0Q1Mz5wiQmmcYque6VMEJo/hHt3DyNQ+xXeKlY3z5V9TM2dUN7vQudegca9D41qn9K/B4KPyH92Hg/Jlo7yY+CQn+wa6javo0K2gRbuMuuEF1A4voobcBuU8WjVL6DSsoNuyhj7bFgYce1C6qBy8+zCPnkDpP0Gn60TsL1TuvIsy5wOUO+6RywTNbcKtf8RjYoZJmlLnKbkndM8kzQkKCeye45hwdH5t/UcCR5A5hELrEQqshyiwkCssa6LWNedETYGZYDpEvvEIhaYTlJiPUUZhS8m/lPxLjQco1e+h3LCHSsMuakzbaDJtod2wTnldRY9hAX2GObH/jNq6AJV5HsNGujeQS8/k+ln0MslC6NeGyQ2jR0Vgq5qhMLqUYXSr6JrcAV0ES5u38b3v/wCPaKx+9ZUfYDq0iWG2yGFCRzGBLraQ6RtHXfcYKjpHUdY5hqK2IFJrXEiqciG+yo1EQgpvKlwfQE7zBLI6JpHZGUZ6xwySOiKI65hGXPsUEtumkExIbafnraPIaw4gvyWAdCZrWkOIbZ4iTONmU/icrGGLmoZzsuY6kzZNk7jePIoS1bxE1Ejy24lE1EiQIEGCBAkSJJxDImok+bTkg0TNysoa/MEZjARWESCMEsaCa5gc20BobFNgamwbkYl9hCf2EJrcw+TkLsbHtjBKGBndhsu/BcfIrtgTxexni5VTeEJn8E2dIRi+hVFhSXOGmYV7mFu8h+nZOwhFbhNuITxzB7MLd7GwdBcrqw+wsfmi2GuGyZrltftYXGdS5j7mVu8KQiayeE7KTM/dwhTvNcNEx8wpJiKnmIywpQ4TQEwGkV+YCZAjOIP70Lq3MeTcg9yxDwXDdYAh9z7UHkqz7xD2wLFIvzV4AM/UMUbCxxijeKfm72CcXN7nJkTuzPxdzFIeeH8Z99QJAkw6zVKalu5gdes+tncf4mDvRRwdPsRXX/o2fvxelKj5Bd54/S3s79+hcqYyjZwgzHmg9Ic47dO3MEbfnZw5wtzyCba272Nv9yUsr9xHcHIfJs8atK4N6DxbMHrXYPNvUrmeYJTS4GArJ8qfyr6Bft4sV7+Mdt0S2jRLaFEvoVY+hxr5LGoVc2hQLaJVR2FMm+ix70Hh3KX4CIEDyKksZK5jNLpuocJ5B2XO+48JG76+Tbj1GI9JGyZr+J7ccjuBSRv7CYoJRY9RaI8SNewycXOKArauYcJGXB8hnwkZyxEKLWxZc4xCEz1nmI9QIED+JiZqjlBqOhbkTLnpMcy8/GkPRQzDDiqMm2iybKHVtI42Iy9/WoHKtgKDg7EMrXURGgvBvIxh4yLkhln066bRpw2jVzuFAbpmQmZQT/7aGfKbQZ+OMQu5cQ4LG7fwyve/j7ffflsQNZGpbfQNTqK1L4j2/gCae4KokwVRLRtFZfc4yrsnkN82htQ6rzj5KbnWh6QaHxKrR5BSE0RKXRCpbRNI7ZwWR3THdzBmCHwfRmrrODJag8ht9iO/wSuO985uofdaxpHQHMJNQkwTuYSYRt5EePKxNQ0TNeRSuFKqc4mokeS3EomokSBBggQJEiRIOIdE1EjyacmHiZrg2CwCo+QG1jARWMfU6CbC41uYnthChDAzuYP50C4WpvYxT5ij6xlCZGoPk+O7GBnZgDewA8/oPlzBfTiDB3BNHMEzdSKIGt5AODRzSyxlYkJmjomW2duYIv+p6TuCrInM3cECPV9lsoZPedp4iNW1e2I5Ey97mlu+i+kFPnL63AJlLHyMIC9dCh1ihDF5iABhdPJIuCMTvMfLIeyUHt5EV+7YRI9tC73WXXRbd9Bj30G/Yw+DznOyRutlS5td6D3bYqNe3jNmhOIf4/1swkcYpesJ+maI7sMzZ4IgCk6fiKVTgcgpxmfJf+EMC5TO9bX72N19gJde+BZ+/N7PBFHzq8dEzdHBfYz4NzBGaWaCaZLe5TiZrJmKHFPcR5iZP8Lezn2cHn0FuzsPqcyYfDoR5Wvy8GbB63CM7AhiJzjBJ0JtYti+jgHzGvqMK2KfGpl+CYO8N41lEx2qJdQMzqBicA6ViiXUqdbQoltHl2WLyoWP7N6Cwr2DLucB2p2naHLeQrXzDspd91DhuotK521UkF+F8+zcZWJG4Eyg0n6GavstVDFZYz9F6ePlUMUCTNwcCzBhw9Y2TNBEUUD3BWLpEz0zH6GIXLaaKTUeo8R0IE4jK6R79mcrmnLzASpN+yg37Z1b1BBK9OTq9lFh2EOjaRvt1i10mNchM62LvXm0jjUY7cvQmhagMs5BZZqHkq4Vhnn06yPo04XRo51Cj2YKfdpp9PFSJl0EA/oZDBjmMMBHdutmMGicwdzq8WOi5hFe/d4PEJnehqwviLquEdR1+1At86GyPYiy9lEUdYwht30MWW2TSG+eQHKd/xz1QSTWjSKhltwaP9Jax5DSGUZi5xwSOhaQ2DGLpI5ppHeEkNcxjmKKp7wtgMoWipvc/NYA0pioaQnjZgsTNZO4+RgxzZO4wZY0j5c+8fNy9Qreeven+KVE1EjyrxWJqJEgQYIECRIkSDiHRNRI8mnJh4ma0dEZjAVXMe5fRWhkFeHAGqZHNxAZ38Ts5Dbmp3awPL2Llcg+liN7WArvYGlql1wmbfYwEdzE2PgOguN78Aa34fRvwxrYgX10F+6xAwQmDjEePkFk7hbmF+9gnpcrLbA1DS+FOt9gmK/n5u+cEzXrjHtY5X1nVm9TeLaiuS2sT8amjzEaOkJw8hB+gk8QMkwO7cIZ2IUruAdHYA82/67YS4c33x1ybKHHsgGZeZOwBZllE122HfQ59iB3HUDlOcSQaw+Djm0M2DahcG1AO7INy+ieOHXJQWDChy1zPGP8zUNB4nhCB3BPHcIVOoSb0uIhf9/EEQKhU7Hs6uz216icf4Lf/PpXgqh58423cXr8EB7fCrxjexgJMdl0jIlpXhZ2gjATNdNHiMwc4WDvIW6fvYTjowfY3ryDNSqL8MwprJ4NqKwrMLo2EWAyaWwbOucKBs3LgqTpJwjXtAol5YcxYF5H4/AiygcXUCZfRp1yDR2GTbGHy7Bjk7ABzcg+NMEzDHjOxEleTa7bqHXdRY3jDqodt1EpiJpzS5ty8oui0n6KBsexQLX9BOW2M5TZbxPOrWtKmbixnaLEyuDlT2xVcw5B2ljPLW2KLccoNh8Jl08ga7AdotG6ixrzHirM+ygz7aGK3FrTNmqNm6gw7KDIyETOMQrJLTHsodq8g2aq3zbzBtpNa+iyrFF9rmHYugSVaQ7D+hkodBFxkhPvTcMkTB/59Wqn0a0Oo5cJGrpnKxuFkZ5TuF7tOYkjU02iTxfCzNIhXnn1VbxDY/UPX/0h5uZ20NYbQGnbCErbAyjvDKK8YxS5DSNIrHTiRoUTiU1BpLVNIK15DGmNo0huIDRPkv8EkhvJv33qMVEzg8SOOSR3zIg9atLpndy2MZS0j6KqPYg63tOm3Y/85iBSm0NIaJlGbGtYWNUIoqZxnK4JFG+UvImn62r1skTUSPLbiUTUSJAgQYIECRIknEMiaiT5tOTDRM1YMIJx/womAqsYH1nBJF2Hg6uYGdvA/OQWFqe2sDqzjbWZnfexPrOLNUHa7GI2tI1waAuTFDY4tglvYBNOsRyK97HZhJtcJnDGQwcIzxxjZv4U03OnmJo5tybhZUrhyBlm5m5haekuNtbuY2frATY372N17Tbmls4oPB+1fYKx8BHGw8eC+Bkj+ENH8PHyJiZneDNeco2+beh5KZBzCwrbJvqZmDFvooOtSwidfG/dFhY1cicvgTrEgHMX/c59sRyoi97psW8IKxy1Z5uwAyXFpXRsiKOujb49ccy1JUjfHDuAffxQ3Jv8B+LIa977xkV+W3sv4r33foLf/CpK1DzC2emLcHoX4fDvwE7hvRRujK1pZm9R/s8wP38Li8t3xfKps5OXcHr8AvZ37lGZ3MEsPR8Z34fKvgqVdZXyfiz2CzK61yG3rKBHv4Q+hnZRuP0GJm2WxfHU7eol1MsXUN0/h7rBeTQPLaBTzfu3LGPYug5z4ECc0OWeegDz+F0MB0/R5ztDt+cW2pxnaHadot51jAb3KRo9p8Ktd52g0XmENtcBmhy7qHMcotJ+G+X2O6iwnaHCfkI4RbntNkqtZyi1MFlzjGLrEYptj8HXlmN6foxyJmnMh2i07UPuP4TKu4Nu2wZaqe4aCI2mLTQb19FiXEWDcQPVph2Um3dRRm4loZrqtZ6P6ab8drJ1EZURH2eudaxCb1uEzrIo9qjhDYX7eW8a3Qx6NDPo1kyLfWh6opY05M8Y1LMVzSw9D6NzeALdygmEIjv49rf/Hm+99gZe/fvvYXZ2G43d5xsGF7aNo6prCuVtY0gssuJargWXcgy4VKDHzQorUms8SK/1I6UugKTGcSS1hJDaFkEaEzOyCJIJKZ2zSKV7Jm94L5q0piCyKO68lhHkt3qR3eIlv1EkNk8hviUsiJo4BsUV1zyB2KYxwjhdTyKeyaCWCdRqJKJGkt9SJKJGggQJEiRIkCDhHBJRI8mnJf+UqFnFmH8aY95FjPuWMTayjMnAKiKjq5gb38DC5CYWpzaxGtnC2sw21md3sL24j62FfWzO72NtdhdLpLzOT+8gEtrG5MQmgsENeP0bcPvW4XSvwkFwetcEgROY2MHE9CEmI8diqc/0DFuSnNA1kzV0Tc/m5k6wuX5fWNWsrd3B/OIpInPHCM9SuBneK+actOFTkSYIvHxonBCYPoF7gskSXs6zCZVzE4OWdfSa1iEjBb+d3HbzBjqtW+iyMVGziwH7DvoYdD3oOcKA+wjddC2zsgXOOrofo8OwgnbdMrp43xPbFoacu9B6dsSyKkvgiL55AJ17DxqCimDw7WFp8wHeeecfiZq33nyEO7dfgs01DyOlTe/ahs3PljVHYhkUE1WLi3exvvECtrcfYn/vAQ72H2B/+x62Nu5ifp5JrWMYPesYNi3CPXoI//gBrCNbYu+aIdsqhswrUBLU1jUMEQbMq+g1rqJduYBmxTwaB+dQ1zuDiq5pFLZNolQWQWX/PKr6Z9Aon0WvdkWclNRtXECHZh4y3QrkNsrn6C2YJm/BEr4F6/Rtuj6FeuwA8pFd9Lm30UV5aXXuocFxghr7GWocp6im60oma2ynqLSeoopQYT9Gmf0QpbYDgXLbISoJNXTdSGiz76Gf4tKPMJG1A7V9lb5PcFBdMnlmX4PGuwXNyB6GvftUb2whtYEOQjvVtcy6ij5ylVR/WssatPSuzrYMg20JBrassSxAYT63pGFipks1BZlyCh1DIXQoJtE1PIluPgFKFYZcNwM5W9yoI/RsCp2KCYyMr+HrL38Tr//wNXzvO9/D7Mwu6joDSKsdQUqVF1lVHqSV2hCXa0JsrgXx+WbczFUjIV+N9GITUoqtSCpzIrbCg/i6UaS2TiGtPYKUDiZpppHWOYv0jmlktIcIE2JZVHJzACmtfoIPyS0jSBTLnkKIb5tCHL2fwGBipnEMcY1BgQS6TmDrHXq3Tj2PtyWiRpLfRiSiRoIECRIkSJAg4RwSUSPJpyUfSdR4FhF0L5C7hCn/KiLBFcyNrWF+Yp2whuXwBtZmtrAxty2ImnMcYHN+T1jYLEd2MDfF+9psYmJ0HQGKw+tdgcu9DLt7CTaCw7sKN58sNb6N4OQuJqYOxFKfaV7yw2TN9DEmw4d0fYS5+TPCCeYXTzC3cIJZup4ROMbswqmwsjnHLbGHyyKfCrV0B9MLtzFK8XjG9sQyJd4vx+TbxZB9E92kvHfattDp2EG3cxcDLlL2PftifxbGsGuXsAO5fQuDFJ7JAYVzG13mDTTrVtGoJejW0GpYI791DFB8w2KPl4PH2IOS4h6y70BF8cys3cXb7/xYlPcvf/lLvP32O7h376uwuuahtW1ARd/R0PsW7za8Y7si37Ozp1iifCwv38bq6m1sbNzF1sYdrNH17NwRlc++sE6yutfEJs6e4I4gbpS2ZQxZVzBsWYFGLI1ah8a+jl7tMuoH5lHUFkIWKe+ZjZNIrh5DTOUYLpeO4lrlBC5XjeL58gAulY0goTqArKZRFLaPoYxQ0TaK6o4JNPWFMaBfhM2/IzYwDhJ4w2V36BC20T2YgvvQ+A8wPHIIue8IvZ4jdDgP0Ww/QJP9EG2OQ8hcR2hz7qHNvY92QhsTYlwPdK3ysiXSASyBPbFszubfhmNkGybnKgyOVZjdG7B4NmH1srtO9+swONcojyvneWfYV6GkvKssy9BYlqAxzkNlmIOSoDLMni990vNGwRH0aabQow6hW8nkTAgyBR/HPQXZ8BS6lNPkTqNvOEx+42jpn0Rzfxitg1Pwh3bx7e++KjYTfv21N7CxdobSBieeyzTh6TQdnk3V4EKaFhcJ17OMuJalRXyuFlmFeuQXG5BdYkJqkRmxBWbcLLIirtSOm6Uu3Kz0ILbaK/asSa8fRXqdH2l1XqoPF+IqHcJNqeGjvd1IqvUhuS6IpIYxJFBdJYiNhc+vkxqDSG0MUD37kdfsQ3G7B126MB69+xOJqJHkXy8SUSNBggQJEiRIkHAOiaiR5NOSDxM14/5pTHgXMcZEDWFqZFkQNbNjq4KsmRtfxWJoTVjVMFGztbCL7cU97CztCXdjbleQNbxEanaST4lax6h/GSPeJbgoPodzHnaBBTjdS3B7V+Ab2UBwbAeToQOEpo4e41DgnLw536tldp4wd+7OPYa4XjzBwtKpwOLiKZaXzoQ7t3hGz4/pnWPMzJ4iQhin+HhPGfPYAbTBQygDRxj27WPIuy2W16j9e9D66Rn5adznJIvSSXDtQuc7xJBvD532DbRY1tFk2USjcQ3NplW0iX1QNjFg38WgY+/cOseyhV4zW39sIrxyF2+981Mq79/gV7/6JR49egf37n8NZucclJZVKCwbGKS4tLZ1uIPbmOCjuSMHWFy+hfkFzgcTVZQ/yhtfT07tYXxyD2OEwMQeXKNb0LlX0W9YQodqDs1Ds2gZnkeLYh7NijnUDsyRsh5CYuUYbpYHcbVkBFeKGH66DhD8uFk1ipiqcTxbEsRTBX48R8+u0LOEyiDySfHnZTyV7ZOobJtARccoOganoDevwOXbhSewB09wD3bfFszeDRjFRscbMHg2KV1Urq7zU6UGqTyHmAhzb0NJ4KVkGg8fOb4Lg28Het8GTN51WL1rsDIJ41qDwbkCnWMZal6uZFqAmsDkC1vHqM0Lwk9pXMCQcRbD5nkMic2B+X4Bw4Z5KPSzwiJmQDuDfu0s+jUR9KmnySVoI+QfEdfs18vHbyuYlJlGU18IJS1+FDf6UNkygop2P0rJLaj3oKDWCZtvDd/8+1fx5luP8Pprb2J76wyl9TY8maDC38Yr8dlYJT4fp8KT8Sp8MUGJLyUqcCVdhcRcLTLytcgpMSOr2IzUAj2SCQnkF5ujR0yOAXH5BiQXmZBcaBTkTlyOBnG5DLomJDByOLwWMdk6YbUTX2RBUoUTSXVepNT7kFnvR16DD8VNXpQ1e1DZ4RH77EhEjSS/lUhEjQQJEiRIkCBBwjkkokaST0s+TNRM+KcR8i4QFjHpmceUbxHT/qVzsmb0nLBZmFzFyvQmNud3sL20S2D38fXiLrbmdrEa2RbLpGbG1zFO7/s9C3A75+Cwz8Bhi8BuiZA7A6d9Hi5Swr2klAdHdzE2vo/xcT72+wDh8BGmp48wEznG3Mwx5ueOsCBwiMX5I8zP8tIowsIRFpdOBJYXTrDCoOvV1ROsr5xgY+WUcAurS7zvyzFmF8+wsPYAsysvYHrpAaYW7yK0eBtjcycIzpwiMHsbvsgp3NPHcE4ewTbKliKHsI4ewB0+hoP8dROHGBzZRZeDN6tdRodpDd28+bCbT5XaQj8vqTLSM8P5cqkJiv+tRz/Fb37zv6hf/0pY1Nx/8DVYXLMwODegdW1BR3DRd3jvnYnQPkLhA8xR2mYXbov9fCbCexifOcBE5AjjU0cYCe7C49+C078j9l+pH5pDUecUsprHkdUyiezWaWQ0hRFfPYqrpSO4UOTHpaJRXCwK0vUILpNfTLkPaTVB5NQHkVHjI0Xfj7iKUcIYYsm9TO/ElAWR3TSOotYgiluCKGmdQGHLOEromq1sGvtD6NcuQG1hKxbe5+YxLMti6ZXSsiaWX6l4M1/7KoYd5OdcgcpBftZ1aAg6Xp5E92rXMjQMxxL5L4llXYO80S/vIaOdRbealynNnkPLfo/9NXOEiEAPhelVzaJPFUE/hye3m+5lqhl00nWnkjH92D2/7hg+R5sigqa+KZRTXpPLHbiaa8KVbCPiC8xIKjYjucSIVAIvXdJa5/Hyt7+Ht956B6+/9hb29u6hrN6Kv4uT469i5fjrWA0+F6fF3yWo8aVkNb6cMoxnUpV4nnApTYXEHAOyiszILtQjp0iHzEIN0vJ1SM3jawPS8tRIzlUhPkuJuMxhxKcrBBIzh5BM9wmpCtxI7sf15D7Epw0hnu5j0xSIoWdJhTpklJqQU2lBfrUVBXUOFDZ5IKPykIgaSX4rkYgaCRIkSJAgQYKEc0hEjSSflvzvFjVhhLzz52SNjy1qFhEOLGGacG5Zs4KFyejyp01hVbMxvyWwPreJ9dlNrEU2sTS1jrnxNURG1zAZWEGAiRr7LOyWaViMYZhN57CYZ2AxzcFmW4TbswZ/YAvB0W2MTexiKnyIyPQR5qaPsThzjKXZIyzPkztHIHd+5hCzMwcCCwvHAstzp1idO8HG0im2106xs3ZGuI3d9dvCXV8+w8rSLazwcqKVe1hbvYf1tbvY3LiL3e372Nm5h83tu9jYvYu1nTtYpveWV+5gYek25hZvY2H5ljgifJrux/nkqdnb8Ezy0d978IVOMD5/D/7pW3CMHwuLHJlxTexlMz5/C28/+jF+Q+X9q1/9Cu+8/S5eevEb8FD5Oka24AzuCNfl38bI2C4C4zsIjO1gbPwQE1PHwmrGGdiAncrH7t+C1bMJrXUVQ4ZlyFQLKO6cQkrDGDJbxpFMbmzNGK5VjOJGWQBXikdwqciPC0VBPF8wigsFbEXjR0LNKJLrR5FaN4q02iAhgIz6IFIJ6Q0BZDWOIqU6gKRqXjozjsLmAAqa/MK6JrMugLQaH4UnNPLmtkGUyyZQ2x9G01AETcPThFm0KOch0yyKjYrFhsYmgmUF/eYV9DJMq+g3rQlron7jEgbNBBPBuEjhF9Gjm0O3dgZdTMJo58ldICyiUz0nSId2FX1DNYdWJUE1Q+4s2oZm0aGYhUwRQRelo1M5Q37nVkbNQzMCTfTs/HoWjfIIGuRTqO8PoaJzAtl1I4grsuJqrgWXc0y4nKVHbL4RcXl6JBcbkFVpRV6VHTrbPL7xrVfw1tvv4I3XH+H46CHq2514NmUIn08Ywufi1PibWCX+LlGNL6dq8fm4QfzVtT785ZUB/OWlfnz+xgAupKiQkK1FZpEeuaV6ZBfokJmrRVaBHql5aiRlqxCXMYTELCWSs4aQks0kjRzJ6XIkpclxPakXl5N6cI0Jm8Q+uu/HtaQ+XEnoxtXELvLvwY20PsRmDiK5QIOGLr9oh7/8pUTUSPKvFImokSBBggQJEiRIOIdE1Ejyack/IWqWVzE2EsKYe0Zg0juHSd88pvyLCBOmg0uIjC5jfmJVEDEr0+tYjWwQ2OX7NfI/t7iZG1tBJLBM7y5jcmQFfvcCnNYIrEzQGMMwGqag04eg1U5BownT9TSspPi63StiP5uRwAYCY9sYn9hBOLSP+ciRIGoWZw6xyC5hPnKImek9RPi0KSZsIgeYD9PzqQOs0vOdlVPsrd3G/vodHGzeIfcWdtduYXuVCZtbBHJXbmNj9Ra2CPsU5nj/Pk4Oz3G0fxcHu/ewu30P66t3sLx4Syw9Wlg+FcuQeI+cGd7cmPxnlm5jdvkOFtfvYWH1HiJLdzAxdwu28UNoPduYXb2LR2+f71HDRM27j97DV1/8Bkb8C3B4zpf6mFwrMNmX4fJtIjixj5HRbTjd67C712AjGJ0r0LI1ipVPcVpAi4I3Ag4jp2UciTUBpDZOoGJgAYVdc7hWFsDzRX5cLGYEcKE4iGcKgngqN4Av5/rwXIEHNyoCiK1m6xovns/34FKRGzcrz/dGSa72Iqvej+w6P9Jrfciq8yGX3MwqNzKrfUilcLxhbny5CwnkJtQQKl1IrXZTeCfS65xIq/MIFDSPoLlvCp1MjMjDaFbNoV2/jDbjKmFNoJ3QYVyGjNBF6DEwVtCpnUebOoJ29Sy5c2hTzdP1IlqU50u7mpRLqB9eQoNijhBBwwChJ4ym7hCaeyfFxr+yoTA66LtN/VOo7wuhjlDTf+7W9oRQ3TWGSpkfBY1uJJfacCPPhKs5RsTkWxFbYEV8gQkJBQbEFWjpXoW4Qh1SSk1QmiN4+RvfxVuP3sUbbzzCrbMXIev34VqWGk8mKvHZm0P4qxgF/prwmasD+G+X+/BnF/vwFxcH8ZkrQ/ifV/vxl1f68IUbA3guaQgJOWrkFpuRnqVCRp4GiTnDiM8ews2MISTRdVq2HOnZCqRmyJGUOiiImpspg7iU0IsrTNIQbiT242o83cd341Jc5zliO3A5vpPCdKG42oi33n4Pv/zlrx6PAB9fJKLm35j8r//1v/43/EsiETUSJEiQIEGCBAnnkIgaST4t+TBRE/RNIuiaxqg7gonHRM37ZE1g8X2iZjHEZA27K8IVBA1dz40vYWZ06ZykGVnCuGdBbEzsdczCbg7DbAjBbJyEXh+CWj2JoeFxKIbGoVRNCLLGYp2Fw3G+f43dtQiXdxljY1uYCe8LC5q56X3MRQ4EZul6emoH06FtzEzvYC68i/nwHuZDu1iY2sXq3CF2V2/haPMujrbv4mDzDPvrTN6cYWv1DJsrt7Cxcob15VOsLZ2QeyLC3T54SHiA0737ONy5i52N29hcu43lxRMsiX1wjsUyq/mFY8wx6H6e98hZvoUlipfBZA77T9PzqflT7O69gHcf/YTK+zf49a+ozN/5Mb7+0jfh9cxBb17A0OO9VXSWZdhcG/AGdwk7sDhXYLItwmydh9WxiGHTPDo1M6jqDyOzaRQx1QFcr/IjtiaIhLoxpPDmsw0h3Cgbw8WSIC6UBPAc4alCP57I8+GzWW78bY4bX8hz4+/yz6/Z7/OEL+Y48UyBE8/n2xFT7EZa5QhyeSPbSheSK53IqvEgp9p9TthU+5Bc7kFssQfxpYRyJxIqrEgst1JYG9Jr6R0Ky8dQlzT70dI9js6eMVQ1u5Bd50BOxygKKQ/lynnU6VfRYFpHo3kdLeaNcwJHuySIGLbQKesaR15LEOn1IwQ/MhpGCQHK/xjyWkPIbQwiv9GH0vYRVLQF6BsB1NI3q5s9aJL50dbtR1dvEDJCS3cATX0TKO8cpfy4kVHhQlq5HVnVDiQV84a/atwUljMWpJbYkFZiR0qRDYkFZsQUGHAhS4NnUjW4mKlDF7Xfr738Ct5+9CO89fo7uHfrK2jvcuFyyhC+nKzB52KH8T+uDeC/X+nDf7/cj/9yYQD/9ZIc/+PKED5zVYH/yc+uDuK/XZELEucLN/sRk6FBSo4WqTkqcpVIyBhCXIYSKdlK5BYOIz1rECnpciSmsEWNAkn07HrSAC7F9eAy4WpCH67E9+JybDcuxXTiSmwXLt3sxMWYDjx/vRWFFTq8+da7+IVE1PxxCpMy7733Hubm5tDV1YX+/n5sbm7ixz/+8T9L2EhEjQQJEiRIkCBBwjkkokaST0v+JaJmzDODCe/sPyFswv4FzI4tYW58mbBI1wuCnFmYZAKHSRre02YRYT7am0ka5yx89ghc1mlYjSEYdeMw6seg001iWDmOoeEJcicFUaPSTMJgZMuaWbHhsNUxJ1y3ZwmjwXWEQzuCnGHMhPcQmdpFJLyDyPS2OBJ8aXoPi/ycLWwIc/R8e+UMx9t3cbZ/D6e7d3Cyc1tgf+MMu+tn9PwEG8vHgqhZWTzG9uopDjZu4WDzNg637mCPsLl2ho21U6wTVij8MoVfWeFNi49J32FLnj2xX87C/DEWHpM5K8sUbpH8Zg+wOHeEo72HeFdY1PBmwr/Ge+/8CF//yrdgd81gQD2NbjWfPsQnEy1Da16B0bYGk2MVWssCDBbe22cBo4FNDOrmUNQxhrgaP66V+3GpPIALZQFcJFytGsWVCt4A2C/2oXmmkAkaH54s8OEL+V78ba4Hn8v24LM5HvwNXTM+m+3G35Lfl8jvQoEXlwo8uFrkQWJFAClVfmTW+JBV7UEmIafWg3xCXq0X2eSfWulBUrkbWVUulDS40NDlRa3Mh5qOEVQTqjrJ7fSjvW8MffIJDPSPom9wEgV1TsSXORBX4UISxZXROobCvhmUDy2hamgRNYOzqO2doncnUNUxjhJ6nlkbQHyFFzfLGSOIq6Tv1/lR2OJHTbsP7RS3jOKua/OhvsOP5q4AWmQjaKJnja1etHR6Iev2oZX8yhvpm+V2JBU7cTPPjus5FsQVWJBQaCZYkMjLjor1SC7SI6nIjJv5JlxM1+LJZDU+F6fCZ2PVeCpVh8aBUXz166/g0aP38OiNd/Dw9tfQ3efD1dRhPJ2kwedihvCZG3L8Nbl/EzOMP78wiD99fgD/8Xk5/vSCHP/+Qh/+Pd3/++cG8R+e78d/fr4bn7nSh8/f6MeX4gbxfNIwLicNITZVhaQsNeIz5IhLlyM2RY6YxH7EpwwiMU2BuGQ5rsb24sLNLjwbI8NzhEux3bhykxDTjUvXO3HxWjvdd6C0yoA333pPImr+WOXnP/85FhYW0NbWBo/HA7PZjO7ubmxvb4tnHyUSUSNBggQJEiRIkHAOiaiR5NOSDxM1Ae8E/M7wP5I1hHEPwT2DcdcMJjwzmBqZxXRgDhHCdGAWkeAcZkbnCQuY9s8j7JtHyLOAMeccRqwROEwhWPTjMBsmYdCNQa8dhVYzhuHhMSgU5AqiJgSVOgS9YRoWywxstllY6V2bja7ts/B5FzExto7I1A5mwruIhHYI23S/TffbWJrewWpkl1y6n9o6Xw4VJWp27uDWwV2c7jFRcwunu7fIj4mY29hdPcXW8jHWmXxZPMT60gm26J0Ncrd5mdQaL406JZxgffVYuHy/vkLhlw4xP8NWPduY431y5niD42Phri4eYW1+H6vkvzZ7iNP9+3j37R+J8hZLn955D1/72jdgpvJtHgyhomsS9b0RtCkW0DU0jwHlPDSGRegt87BYZ+D1LMHtXkNdzySS64O4XB7AxRI/niv24ctFI/hS4QieKWH48CzdM0nzxfwRfC7Pi79hMobcv83z4G+ZpMlx4XO5LjxB908XePF8oQ/XSnkTYV7yFEBGbRDJVSNIIqRVe5Fb50M2W9LUuJFT40JmlUtY2aQQMqudaOwcoboch8UUhkYfwqByAgqqywEl1a12AkPqMai1k1CrJtDVE0RulQOxhVbEFzuRVO5CYpkDSRVupNZ6kdXoR1FLEEXNfhQ3B8SGxYWNIyhsCiKngdJT60NCuRsplJ7CJi9ae0fpOyF0y8fRJAuirt2PRnIbZD60dI+gReZHQ9sIapvcaGh1o77Vi0JKc1aFCxllbiQU2nEj14y4wsdkTb4JSfkGpBbo6FqDmBwNLmdq8GyaGk8mK/HFJBWeTlHjRp4eHYpRfOXrf493Hr2LR28+wkv3X4ZcEcSlJAW+HDuEL8Qo8Nmbw/jLG0P4s0uD+E/PMyEziH93gdGP//e5fvx/zwzgTxjP9uPfPdeD//BsN/7DM134z8/34C8u9eCvL8vwxes9eCqmD1+M6cHTcX24EN+HS7E9iEkcQFzyIOISB3Ettg8XY7vx7I1OfPlaB56N6cKFG114/lonnr/ajkvX2nE9tgOlFXqJqPljFbaYeeONN1BTU4ORkRH84Ac/wLe+9S0YDAYaiBV48803P9KqRiJqJEiQIEGCBAkSziERNZJ8WvJRRM2IPSQQcIQRdIYxyuBr+znGXWFMeqYx5ZtBeISJm4i4DvlmEWLrG88sxhwz8FsjcBunYGErGk0QJj25dG3QjEGjGsXQUBCD8qBY+sRkzTAp3BrtFIxM1hinxTIpqzkMuz0Cj2sOwZFlhCc2MRMlaSYJoS3MTW1heXobqxE+FnyDwmxgip7NTO5gbe4Ah1u3cCLImTMcbh7T/Ykgao537uJw47ZYCrW9eoK1pUNhWbO2eIqV+WOsLrAfkzJMzhxjc+0YW+sn2Frjk6SOsL58iJXFIywTVnn51PIZlvgYbSZnmPRZ2MdaZB/rs/s43b+L9x69h9/8+leizN/70Xv46ssvQ22fRnqtBzfKRxBTEURC7QSym8KolvGJRYuwOVbh8yzAP7KGDvkUkmu8uFzmxcXSEVwu9uG5Qh++VDAiLGeeLvDgmSIPnivy4ZkCH57I8eKzeSP4bK4XX8jz4osU5qlCL54q9uD5Uh+ulPhwg+K5XuIVS53iypgs8SCtxoVEPuaZyZMKB9IqnUirciJdEDROJNOzxHI7cmpd6BqchM08Te1kGiE/n+A1DYMgbKZI/2MLqXGotQEYzFSv5hn0ysNiqVFciQMJxQ6kVzwmfspdSGErlzKzQGKpib5vRQalJZtQWO9BRfsYCpv8yKsfQXHzCJq6RtFL32/uGEFZgxv5FC6/2olSuq5scqGm1Y26Ni9du1FcbUMpobDKjswyC9LLHUgutiGuwISbBWbcLDSJDYNvZmuQmKsXuJatw+Vsvdiv5mqeAddydUgqMtE3HKhp9kBnmcbXXv423nn0Dh699QhfffhNKIfHcCNNgyspOjyVoML/uNiL//x8H/70wiD+5FkF/uS5AfzJ8734/57rwr97rhf//pkB/LunmbDpwf/zTDf+5BkZ/uPTMvy352T426syXEzswfXkfjx9XYbPX27HF67I8OWYHlyM7cflBLlY6nQtoRfX43pxlXCZ8Mz1Ljx1hQkbGZ6+2oEL1ztx6Xo7rtxoRXGZRlr69McqTMK8TINOYmIiTk9P8Ytf/AI//elPEYlEUFtbi29+85v4zW/+90nHOVHzQ4mokSBBggQJEiT80eN9ouYj5kySSPJJyj8lalYw4h6Dx0ywjMNnC2GEELBNwW9lhDFiYTeEoH0KY6Scj7HljWMKQQeTOZHHBM00vMYwXLopWNUT0CuD0Az7oVEGoFXxdRBKRRDywSAGBgLo6/ejn9xB+ahYDqXhJVDaSZh0E7CRMuxyzcLvmcekfwnTo2uIjG9idnIbsyHC5AbmQxviKPDF8BZmx9cxySdNTWwiQpib3MTawgF21k6wu36M3bVjHGzeEtY0R9t3hMv3e/R8Z/UYOytn2GRyZvEYa/NHWJ0/pOtDbK4cYW/zlOLgeAgb59im+DaXD4W7tXqE9SXe6HgXS3N7WF04xEpkD8uRHRzu3iaF/j38+je/IF2Iy/zHpOR/CxbvMkrbJ8QR2tcqxnClcgI3KifFfWZDALLhWehMC+hXzyK11oeYyhFcrwrgQokXz+Z78HQ+uQU+XCz24UqxFzFlI4itCIjNhJ8r8uPJPC++wHvS5DjxpQI3LpX5cFWQQhSuMoAbFD6m1IfYUi/iyj1IrPKIJUm8mXAKbxxc40ZatRtJlW4klDsRV2pHUoUDKeU2VLVTnammYLNFMOKJYNQ/Cxe1CbtzFlY7wTYNo2kCBtMUdMYpDAxPoLSe4i6zI5W+kV3lRGG9G4UNHmRVO5FKcfI+MYnFJiSQG09ufIkZiSUWpJU7KIxbILeal1p5Ud7gRgWhmC19ypzIrWQ4UFjjomceVDd5UVXvQXEV+dG3Cqrt4rSmLCaE2KIn34DEQgMySi10b0RCvh43czS4kavDxUwNPp+owt/Gq/F3hGfStLiSpUVsrhZ55SZU1luhNk7iK1/7Nh699a7Ayy9+m9rtFK6navCl2GH89dUB/MXFXvz5pfP9af70OV7m1C+WPDFR8x+e78WfPkP3T/fiT56he8J/vyjDl272ID5TjrIKDdpbzOhoNKKyZBhZOXJcS+jDczG9eOpqD754rQdPXe/CszdluBLfgyv0Hi+BevaaDM9clZHbSW47nr3ehgs3WnE5phXF5RJR80crTMLcuXMHCQkJYsDnwf+Xv/wlVldXUVVVhRdeeEGY+31YBFHz/R9i7aWvicmJBAkSJEiQIEHCHytWCK9IRI0kn4J8kKhZXl6BzxmE0xiEy8hkzQS8lkn4LCF4SCl16x/DcA72Y3iNE3RP0IcEnNoJWIfHYZKPQj8YhGpwBMMDPgwN+jAsrv1QEAb6A+jr86On14fuHq8gbBRDo1Apx6BVjQmixm6dhsc9i1HfgjgmfGZ0FbMTG5gLbZ2742uYnySENjA7uYnp0XWM+VcxGqBwoU3MTa1jlkmcyD6W5w6xNn+InZUTYUWzv3GKw60zHJB7sHaC/ZUj7K6cYnv5RGCTly/N7WN1bhcbi3v0zhH21o/pvRMcbJ6/e7RJ77Pf2jH2Vo+wTXGsLhxgPrInNj6eD/Mmx5vY3T7Fo0fv4te/+QfCr6jMf4KXv/kdeEdXoDQvo1OziIq+CPLaJpHeOIGYygCulXuRWutHCfnxcdg3KkZwvdKPi6VePJXvxpM5Hjyd58FNCptUw8uVAkivCiK9ZgwJlUFciVrc5DjwRI4NX8yz4/lCN64UeXC9hK14fHTtxlVCbJkP8XR/k+K+TtdxFT4kVLgpTo8gaZIJSZUuJJU7kFvvRX6dE6VNTrRRPRosYXi8swiM8BK1GTipvmwOXro2DbM5DIttBmr9FGR9ARTWOJBaakFmuRVVzR40y/yobvWigE+KIv/UEhNSik1IZpKmyIhYQgxbvRRakFBsp3dtyKu2o6jGifxKBzLoPr2UCRgXSuo8KK1zo7TGhYpaN+oaR1Be7UYBpbmg2oPsKnqfiR8+xSnfirh8PTJLjSiusSG10IDEfANu5urxfIYWT6ao8bcJarEfzV/HqPDZOBWeSFDi+VQV4vM0yKswYEA1ihe/8m28LYiad/DyV78NoyGMp2Pl+JvrCvzlNTk+c21QuH9xsQ9/9lwv/suFPvxHuv53F7rxn57vwX95tg//+dle/NmFHjwR04/raXKk58pRUiJHR7MefS16qLos6GnWoaxYgcRUPt2pH8/c6MKTV7vw+efa8cTFNjzH+9DckOF58v/SpXZB1vCyJyZpno1pxfM3W3EppgUFZepzouYXElHzRyc82J+dnSEpKUlY1vA9EzPr6+uorq7Gw4cPBXHzYWGi5rtvv4P73/s+7r3yqgQJEiRIkCBBwh8xvo83f/wT/OafOYRBEkk+KfknRM3SCrzOIByGIJyGUbgMY3Dqx2DXjsGmHoVFGSQEBMzDhKFzWOjaMhSEXuGHThGAVh6Ass+HoW4vFD0+DHR7MNDjQX+vB33k9vV40UPPerp96OkZQTdddxF6e0cgl49CrRqHlmDShmAjRd/jmsW4bwHTgUXMBJcxM7aKuYk14c6OrmB+fAWzY2uIjK1jKrCGoG8FgZElsVfN4uwG5sIUdnITs49Pg1qZ2cfq7J7YQ4atYTYX97G1sIdtut9aOMD24hF2lo+xvXSIdQ43s0Pht7GxuIOd1UNByuyvHQmC5ohwsHZIOMbeypEgdFYoHt5HZ3x0E6GJTUyOr2GN3nv06Ef49f/6FX4tLGp+gm9+67sIjC/A4piDK7AF5+gO7CNb0Du3UN0XQUKNH1dKRxBTFsDN8gAul3jxXIEbT+e78RTvL5Pnw7UKH9Ibx5BYOSJIlrgiN1LIL6ee93QZR3xlEBeKfXiqwI5nij14luJ4vtiN54tc+HKBE1/MsuHpbBsu0/XFfPLLceHvshx4MsOKZ8j/KoXjfWSKG72o7RpDcbMHpYT2vgl0DY5jkOrJYg3B54lQuUfg983CZpvGsHIUWsMUjJYZGK0zUGon0acYRWf/GKpbPKhvpXrvGUUX1X9TB1vG2FHV7EZ1qw+5VVZB2JwfiW1AfJEZ8aVWYVmTWmYWpE55gw/FNV5ksHVOuQ25tUzUuFFUZUdRhQXV9S5U1zhRRM9T8kxIKbQhtZjiyGfLGZOwqEkoMiKn0oaCcvLPM+Ai70MTp8AX4ocFSfN0shYX0o14KkWPv45T43OxajwRr8RTiYOIL9RBNjiKF178Nt566x28TXrsyy9/B2bK71OxAxR2SGwm/HnCF24O4W+u9uN/XurDXxD+68Vu/PnFTvz15T589nI//uZSFy4nK5BdqEFO/jAKCgZRXtqPnjYD9P1OqLst6G3Ro7xYgbSMfqSkDyAtS4745AFcienBM5dl+PKldjx1uR1fvtqJJy624OnLHbhI1xevt+PC9WZcvNGMS+TmlyjxxpsSUfNHKWxRw1Yz8fHx71vP8PKnpaUlQdR85StfET8IHyX/QGF//A+/IPwDfvxzwgfdD+Kj/D6MfynM7zPuKP5Qcf9L738acf9rwnyU3ycV90eF+UPFHcUfKu4o/lBx/0vvfxpx/2vCfJTfJxX3R4X5Q8UdxR8q7ij+UHH/S+9/GnH/a8J8lN8nFfdHhflDxR3FHyruKP5Qcf9L7/9vz36BX9J8SaJpJPl9y4eJGo8jCKs2AJsmADvBpj4nZoxDI9APeqEb8EDb64Kyx4WhbhfkBAWjy4l+Qm83ocuF7k4HZO12dLbZCOTStazDQa4THR0udMrckMk85BI6PZARurp86GOyZtAPJSn1muFxGNQTcJin4XfOYdw7h5A4eer8+O9pXgoVoOvgCrmr5L+GCd8KRjyL8LoXME5+c9PrWIisY26KiZodsWxqhve5EcTNJubDW1iY3sJSeBvLU9tYm9nD1sIRNhcOsD67i7UIb1K8g5UIhYlsYn1+VxA4DCZmdpf36HoHe6sH2Fk5xOrCDhZmtjE5vgE/pSUYXMPY6DpWlo7x1pvnmwkzfvyjn+Jb33wFwbFFaHgvF8sCzM4l2D0rsHvXoHOuoV01h+x6P9KqR5BQMYIb5X7cKBkRG/9eL/ML8ia2ykv+blwtduJ6iQvxpS7k1o+goTeE8vYgEiu9iKmg8OUues+N62wxU+7BjcoRXCkfwYVCFy4WOcWzq8VuuveKY7q/mGXF1UIbChoCaO4eR1dfEEOqEBSaaXTJJyHrH0fv4Dh0xmm43bPwOMOEaTjsM1CpxzGoCEKrn4LRFMawegz9Q0F0D/gg6/Ogu38ULe103e1HPy9/k5+ju8+PxlYXKurMqGywo5SP8S63IKPMhNRSA7kGZJcbUVBlQ3GVE6XVThTXuZHGJE6BGUn5FmSW2pFbYUV+pQnZJQakF5N/gQkpRWZkFFqRnGdCYr4ZN/OYADKSvwnJuQbEES5lMDGjxaVMPS5n6XE9W4P4fJ1YInUly4ALqTo8n6zB1Uwt4gv0aO3148GL38Bbb72Ntx+9i29963vweJZwM12Jq2lqXEoexo0MDa6lqXApRYkvxSvwdzcH8OW4AdxIG0J8hhoxKUNIylQip0CF3Dw5cnOHUJA/hNJiOTqbtFDIzOhv1aGxcghFuf1IT+tFeno/MjP7kZLSg6SUftyM78NltqjhvWhudOLCtXZcuNKOy1c7cZlPe7regms3W3H1RguKSlR4UyJq/jiF96h55ZVXqPFkYmNjAz/5yU/wzjvv0CAVREtLi3j2UXvUSCKJJJJIIokkkkgiiSSfrnyYqHHbAzCpRmAa9sGq8hMCMCsDMCh80Mu90Pa5oZQ5MNBuQzeTL202dDFarehot6KN0E73rS1WNDeZ0dJkIfccrS020gfsaGt1or3dLdDR8U8h6/Kgr5/JmiCGSXlXD43BqAnBbgzDY51GwDGDcc8iJr1LhEWERpYw5V9GyLeCCe8yRt2L8Djn4LLPwOuaw+ToEkLjy5gMrhDWCWuEVYEQYWpsHeHxDcyMb2KOMB/awsrMHmEHS+FNsUkxY3GaNy3ewEJ4A0t0vTq7g83FA2ws7GJtfhtbS3vYXNrH0hyfSLWJcfpOMLCGABM1YxtYWT7Gm2+8J47m5iO6maj5zre/h/GxBQwpvFAoRqFUT0BnjMBon4fZtQi9fQH9wxE0dk0ip3ZELG+6Xuw+3/i3lF0HLhfZ8WyhHc/T9bVyN5KqR5Ba40Fp+ygKW0aQQtcJlW7kNnqRU+dBXLkDNyuciKlwk+vBzXIPYkpdiCmj+Mr4mlDkQHq1E/VdVAeqaWg1UzDopmAzTUOvmcSQMoT+oUkolJMwmyNwOSJw2KZgt0WgpLBMxAypJmEyUL2Zw5Q3PwaHghggd0g1Ss/9aKa67xsYExtJK4cpvHwEHZ1OtHY40N/ngUEzLtpBbaMN1fU2cp2oa3KSa0dNgwO1fBx4sxtldXbkVzmRUWJDSoEVCbkmZJbaUFhvR3qFDXGFZsQXmpBeYkZ6gQnJebzEyYjYAgNu5mmRlK9HepGZ3jUimQkdChufq0VcjgqJeRqkFhqRkm8gmJDKS6aydQJJOTrUUXu99/DreOvNt8QR3d/59qviZLL8UiNS83RIzlYhq8iA1Bw1ErOUuCoIHAWSKe7cfDXSs+TIyB5CfqEaBfkK5OQMICtzkK6VKCkeQku9Fj2tBnQ2alFeNICczF6kpfYgJbUPiSk9hC6kZQyQ3wCSE3uRmNiDpKQeJCR04dq1Vly+TLjSghsxbYi52Y7rN1pRWqqRiJo/ZnnvvfegUqnQ19eHk5MTbG5uiuO5fT4f3n333cehJJFEEkkkkUQSSSSRRJI/pHyYqHHZgjAqR2AY8sEy7BcwE0wEJmvU/W7I2XKmzQZZiw0dzVaCBe2NZrQ2mdHUbEYjuQ0NRtTXM0yoqzMJt6HBgkZSvJua7GhudqC11YWWNoYTLe3kElo7Xejs8oh9a/r7/JAPBKGUj0GnnIBFNwkXEzaWCPyOeQScCxj1LGDcu/SYpFnGiGseThsTBxE4rWF4XbOPMYcR9yL8niUEPIsI0jt8itRYYA0TgXWEgry/zRZhE7O8CXFoC/OPNyheDPPGxVvnpM7oCoVZxszkGhbCvPcNW+RsYHl2S2COwk6NM1GzjvGxDYyNk0vxra+ekYL8Hn4lLGp+g5/85Of47ne+j/DYIpQDLvR2OtHZZka3zIkBXv6l4w14Q9DrI9Do5iGTR1DTO43sOp+wMmHigsuroNKI2GITbpQxAeMSFjS8l0xWgxeZ9W5kN/lQ0DyCflUYbT1+JJcbcbPMipgyuzgWO77YgbgSF24Wu3GT3NQKGxo7vVBrwmIJmo5g4D2HTFNw8XHppgj0hgi0hmmYLbNw2mfFSU9OexgGqh+2iClv4CO7vZT2KaqDCMyGKegpDqMhBAPlqaXdivpWO2Q9PnHqF6Ozy0Vtx4D+Xgd89mkE7ZMw60agGHRC3ueGRjEGea8X8n7yozYh63Sjg9pKVZ0ZBRUmlNbZUNHoRlaRBRnFVmSRXxKXSy6VT54RiXl6QcokEhLytMJNKtAjudCAdN5QuECH/BKKh611KgwoqdQhu0CNxGwV4nM0SKZ3Mgo1Aml5OgpvRGO3D3cefA1vv/kW3n30Hl75+1cRofaSU6LHjVQVbqYqkZipRkrOMJKyFYhNH0YKxZmeP4TcfBWyc4eQkT2IkhIlaqo1yM3tJ8hRVDSM4iI5Gsmvq9kkUFakQE62nDCI1LR+xCX2IC5JhhRhYdOHlMQupMTLkBzbgbTEbsQzMXO1GVevNOHK5UbhXqP7osJhiaj5YxZe7vTSSy8JsqahoYEG5EbYbDZx4tNHbSQsiSSSSCKJJJJIIokkknz68kGiZmlpBU6LH3q5Ryxx0vW7oe13QTPghk7hhWbQjaFeJ/o6bZC1npMzLQ0mtNSb0FxDimutEQ11BtTW6VFTS6jRo5b8auhZdbURVZWEKr43o66OlPUGO+obbahvsqGu0YraRou4bmpxoLXNJZZE8XIo3sdGPhCAangURs05YeMwTsNlmYHbFoHXEYHPOQuPfQYexwzs1jAs5imYjJOwmKbEtcU8DZs1IogFtrjxOCksveP1LGCESRvfMsZHVjHmWyF3BZOBVUzxCVMT6wJM0oyRP29qPOqbpzBLFGYFU8EVhAJLCAUXKfwSJshvlOIaFSQQb2pM9+SuLp/gjdfffd+i5qc//Rle+e6rmAktQzXggrzHie5WM2SNRrRQ+cnabegjv4FeDwb7RzEgD6F7cAKtbHXUZsVwtx39LTr0tOjR3GhCVa0ZlTUWVNRYUUJuXqUJWRUWZFZZhXVJO5VjU7MD+RVmZFfakFflRH45LxNyIIPclDI7Cvi47f4gTKZpGI0h9A36MKgch15H5WcIwUdlG6DysllnoKfyN1kicLvm4LKFYaUyHlIE0Evv17R5kVttRnvviDii22YNwWFhi5wQhRmhtDjRIw/QtzxolTnR3OZGV7eb2l4IAfsERl1TVL+jUCsc0Ay5YFIHMExtsZ/KQ0NtQEsYlvsxMBhATYNNLJNqkflQUWtFcaUdOWUWZJUbkFVmQHKBXljCpPGpTnkaxOVoEZ+jQ0IuuflaJBXpKIwauaV6FJUaUFVnQ3m1ntqgFXUNZhSVa5FZrEJ2iRrpeQpkFaqQU2xEVqkRdTIXbj/4Ct588028886750RNZBNJOQpcShrC1eRhggLXUwdxM02OuJQhpGQNIzVzEKnpA4R+JKd2Iy2jB0XFChQUDKCwcAjFRUrCMCpLVGiu1qGpQo3SgiFkU7xMysQndOFmfBfiyI2PlyExqRtJSb1ITuhFws0uJMbIyO3EzRutuH6tBVeuNeP5i/W4cKme4peImj9q4eVPvC/Nd77zHdy6dUucAvXqq69+5CbCkkgiiSSSSCKJJJJIIskfRv4JUbO4DId5BJoBF5S9Dgx12aHosmGw2w453Q/22NEns6KrlZTwZhOa641oqDWgjpTJ2kotaio1qCZUVqlRWUFupR4VFTqUk7JbVqpFKSnDpaU6lJaxHz2rNKKimlBjIuXYgLIq8qsyorrGgjpSmBsaHaQwO9Ha7kQnKcW9PWxR4YOKNy1WjcGonYTFOAkbKfgO6xTsVt58OASTYQI6/QTUugmoNONQa8eh0U5Aq6dnxjDslmlYKRy/Z7OF4bBH4HbOwueax4hnAQHv0jnR4l/BRGAZ4wS+Z2sdLxM8jgg8TPjY5wQ55LZNw2UNw03xuByzcNpmxNIrQQi5F+D1LGJh/hCvv/4u6UPne9T89Kc/xSuvfA+zkXXolCNQDrowILOhp8mIjloNWmvU6GjQo7VeRzBRmdup/D1QDRL66LrdgP5mHeTtRgy2GTFAddLbbERPqxGyNpOwbKqqtaCyzo4yKt/6JibGLKiptaFKkGRONNXa0c7WTS128qP3ut3nx6crg1Aqx9HOFizaMJUjlZtuHH7XjCClvJQvi3UWRuu0OOHJycdwG0Po6fNSHF60dvlQ1eZGE7lKPmrdOA6rKQTVUAC9vT50Uj12D4xQODtqWmxoanVDNRxA0BlCyDsNh2kMsi4LFAov9Co/tMN+DPZ7IKe8iyPeqf61w0H6nh+l1SZUN7vQ3DmCcmo3JTU2FFSaUNPsRG2znZ4z2WJBUYVV7FmTnM8kjV4cxZ1YrEdyiR5pxRrkVxhRTCin8JU11K4bzWhutqC5zS6WX7GVTVaBBrnFBqQXGRCbp0J5qxW37r2E1956XRA1333lVSws7KCwVIXk7GHEpCpwOWkAzyX04lJiH24mDiKF/DLS5cjMImTLkZHFpE0fsnPkyM7mvWf6kMPXOQrk0LPifAUqi1XIyRxEcnIfEpO6kJAkQ0IikzTdiIuV4cbNDlyP7cLNmz24GdONm9c7kBDbidibbbh2vQlXrjXg0pV6XCaUlEhEjSSSSCKJJJJIIokkkkgiyf/R8mGixmryQd5rQ3+XFb0dTMpY0ElKP6Oj2YS2RiOaa/VoYGuZagOqqnQor1ChrEIpUFo2jNJSJSmEKhQXq1FYpEIBIb+QQQqxwPl9QRE9L9GgqExL0JCCq0ExXZeU61HO1jc1ZtTUWVDfaEFLqw2dnU50dbrQ2+XBQN8IhgYDpLiPQq8bh5E35NVNQKsZg0o9hiHlGBTKCch5/5PHGCY/jXocJiZs9BMwGeg94zgs5pCwwnHZps+tbMQyqQVB2vg88/C52QKHLUdmBMljM4Vh1k3BqJ2CTjsJnW4SWu2EcHX6MLT0TKMNic10DcaIWCIUDu/gh6+9i1/+6tf41a9/JYia733vVczPbsKgCUCr8mF4wI3+dirveg06atWQNejQ1aCHrE6DgRYDdH1OaAfsUPZa0deqQ2+zFvI2E/rpWU+DFr1NhEZCs17E09NC5VZrQFODQewfJCN0tZhF/TVVatFVR+9y3dLzxhr6JtVvH73X1WxBN5Vzd+8ILPYFeL3zCIzMYWpsmbCCgHcBLioPkzmCAfkIevu9aO/yorDKgMJaC6raPGjo8otNh4e1vG9NCIOKsXNLqXYv2jq9aGy1o6rBipomJ2R9fqrDADz2SVgMY+gf8KKz2wsl1a1FNwajkp4Pj8BmproyjsJsmIBSTvFTO6hrdqC0zozqZie5FhTXmlFM6WimbzU1WVBLzyqqrCitsCO/yICSKhtyyszCuiazlC2P7Mil+7xSI3KKdSgqp3ZXa0VdI6WvxoBaSmMJtcX0XCVScjVib5oraRp8OWUY6fT8+M5LeP2tN/Ho3Xfxyve+j421Q7RQH+H2n5w+iGtJvbiY1I0ryb1ITJMjK0uJrAw50tL7hUVNeqZcWNckp/YKwoavk5iQISSn9iA5uQvpGf1ISO5HbAJDRs87kZJMbrwM8bGduHKtHU9fbsWFq524HtOFmGutiL3ZimsxDbh+vRZxN+uQkdaB5MRWVFcO4623qB1KRI0kkkgiiSSSSCKJJJJIIsn/mfJBomZxcRkGvQuyDgPaeElNAxMyOtRVPbaYqdCgulyDylIVykvVKGWSpViNghLl+8gvUiC/QI78/CHk5Q0jJ28IWbkKArsqZOaQoprD1/QsX4XcAhXymMwRhI0OxeV6UqrZusaISlL6q0nRruP9b0ix7+xwoEvmRg8vhyL0do9gsN+PoaHg+Ya05CoUAXHiUL98FL0EcarQIPnJ+dkohRuDTj0BvWYCOg1d60Ypz2Ok/DMJMAm7hfdVmRZWIgwHW9zQvc0yTWHC0DMBo5qEamgcQ4NjIv4eir9n0C/cbrpndA2co1c+BvnwJPz+VfzgB+/8E6Lm1Vd/gMWFbfo+k00BitMHebcdfW2Gc7KlxYjuRh3kbTroe8ywDjqh6jGhr0WHtjoVZI1aEWaAoGhnwkZH4TXoa9JjkOpPzvf1anSSH58g1NtqQF+rHl30vKveiD5GkwGyeqrf0iGx5Kq3xUzfswmo+nwY9SxjdmoN89NrWJjZwtz0ttgseWpyE0H/CizmsDiGW66aQmPXCKplPtSR29DtR5diEnL1NIa0Mxgkt703iMY2FzooTFOrB+W1btQ0+9BN5aRW+al8x6BUBdHZ60dbdwDtnS4ohwLQDvlh0IzCSvWj1Qag1o2jt88NxeCI2HC4sc2JBkJNix21rU5U1BnR3GwVZFNHh1MQL/klbFljRmkVuRUmZBcbkFFoRE6JFVnFJqQX6uhej8x8PbJLePNhIzLpnjcDTivQIjlPg8Q8HW5k6vBUogqfSxhGUrURB7dewutvnhM1r776Q+xun6GtyYySYhUysuRIZJIlvR9JmQNIzhhAamo/0gi8ITATMvGJvPkvgTcCTu6i533IzFAgLY2XRvUiPaMXafRubHI/YuL7kZhM4RI7kJLQjqS4dsTd7MTFq+344qU2fPlyOy5eaRfLna5dayD/WrquRlZqK/LTO5Ac20D9V3FO1PxSImok+TcovHSLf7D4ePGdnR3s7+/j5Zdfxs9+9jPx7MPy85//HN/4xjewu7srwn73u98VS784LIM3V7579y62trZw+/ZtvP3225/qyVecbt4fiJeifdTyM04j54F/oDm/BwcH+P73vy/2E+JnnNbXXntNbAy9vb0tyoXL56PK4pMUjp83n+bvcdkeHx+LdP1zeeAfvBdffFGU89HREX74wx++nwd2efkdx8FxcV75RLLfZz1Ev/uDH/wAp6enouzu3buHR48efeR3OTyXK4fhPJydndFA+pYIy8+4jr797W/j8PBQ1NG3vvUt4cfPfh/CE7fvfe97oj1HvxNNx9e+9jVRjpwWDsN18lHpYH9+zvWxt7eHr3/966KeonFxWdy/f1+0O+4bnF/+7ichHD+X3d///d+LNPzDP/zD+9/ldvXgwQNRzpwP7h//Ut/gsuYyZ3AdfLA8eF0yL+/k+uV+zqfcfZLtitPF7ZX74If3+OLv81jz8OFD0d4/quw4DJc5j2FcB1xnfPpedIzitHIb/WD/jtbRJyEcD6eb443WL/sxuA9y2vm73Ea4nj6cRxYOy22F64zri5fUcrlHw3IeOE+cN46L90jjOvqkhL/P4yi3VU4z37Pwd7lePti//7nxnd/h/EfbCrucp2h5cD1zHXFf4HridvZRbfK3FY6b2yS3Td7Yn3+jor8F0e9yufPYyN/lvv3BPH5Qom0lml+u0x//+MfCn8NzH+O2Gh0buE4+qTy88cYbot45D9xWo78F/Czavjlv/O2vfOUr4nf3w/XAYdkvOiZ9sK3wMwbnJ9omeQz+5/qVJJL83yTcxqNEzcLCEtRqOxoa1KipUaGSrWRKlSgtUaKocAiFBYR8hUBeLu+ZMSyIl8ycIWTkKB67fJJNPympA8jIlJOSKRd7cqRkKpCcyftzDCGNFNj0bAWFHUImx5OvRG6hmpRpLQrL9CguN6C04nwZVGWNCTW8B06LCQP9XigGAqSAeyDjvVo6vYK46e3xoK/XK9BD6O71iY1qO7q94hQpDtPd7RHLbgbpfeXQKFRKBhMEQWjUo9Cqg4QA9NoxmPTjMLElh24UdksYRv0kdLx8SjMOhTyAvr4RsXcOEw6tDIq7sdOJJrYU6fShocODJgEvWjopbE8ATuccfvj9R4+JGl769DMay36I5aVdGHRBGOibYsnRoBfybhv62wzob9ELqxltrwmWQSuMfVb0NKnQXDGE+vIhNFUNieVOA20mcnVQdJogbzcLq5qhdj203UYMd+gw3KnDQItO+Pc0qykOHbrr6LpWi74GDfoa9Wip1qC5WovuRhOUHXaoO61QErR9TjiNAUz4pzE9sYRIaA0zU1uYJcxMbZDfKgL+RXh8y7A6F6A3z2BYG4ZcM4Vh3TQUmjAGVdOQDU6gvX8UnX1+9MrHUVHnQkaxQ+yV09jhwxCf/qQcQzvVW361FemlJpQ2ONHOhA2VY3ff+fHdbTInugeoHQz7oVWNYkgxijZqCw1NDmFd09TuRHOHAz1UR+3tDmF1U0/PiqttKKriJVB6FJXrUVhqQG6REZkFfKKTDol5WqTQdWqBGVcyVHgmXYFrOXz6k15Y0STmqBGTocbT8cP4XIwcTyRRW68zYf/0Rbz++lt495138f1XX8PB7j00N1lRVKxFVvYQsqg/ZGUPir6Qmk79IG1AkDApyb3iaO3EpH4kJ/Wd3yd3I40ta+g6JbkH6Zm9yOV9cejdxMQ+xMR3Iym1h553ITWhA4mxrYiJacOFK2145koHnr7YgktX23AzthOXrjTg8o1zi5q0+EbkJrciPb4Z9ZUqvC0RNZL8WxWe9K2vr9OAQYNfby96enqg0+nE5JQnoh8UnvSxgmk2m0U4Dm80Gt9X/Dj89DQNUgoFDRRdGBwcRCgU+tTIGlZkWLnhU7e8Xq+YvH5QeGLKYXhSrdfr388D54cnwvzjzQoRvyuXy0U8XC48WeZy+n0KKzGrq6s0YVCLE8S4/Px+v1C8Pzxx5jxwmngDa05jf38/HA7H+2QNkzQulwsDAwMiHq1WK/LMytfvS7hsWSEYHR0V6Y+W7crKyv9W/xyW28rMDP24DQ+/n4fx8XFRDvyMFQquF84Dx2WxWIRCwQr3Jy2cNiZouJycTuf7bYHBCp3BYBB5ibYVzueH64Tj4Lri96Plzv2IlSxuO0yWLC8vi/xGy2Z2dlYoZJ9E3+B6537I7TYYDNKP6OsiXv42l3O0rXDdcBgu3w8rlVESxGSiyeHjcrdarUJB5bCseIfDfOykQqSf4+I8cd64Tj+u8DeYHKirq8PS0pJQIj8YL+eHFfCSkhLx3Y9qz9x2WMHl/s1p5Dx7PB5BLnP+uG65X/HYxPnjdsd9I6q8flzh7zMpUVZWJoiAKOHN/pwnpVL5fluy2+0f2Za4PLnfRMNyOUciEUGScFhuq9zfuY74Obs8Xn8SfYPTyuXOYxGXM5McXO7sz/2Yx8bo+MTtgNPF/h8sO75msoTbHYeJtnfOf5Ss4XFao9G8Xxbc97iOuB3/rsLfZdJlcnLy/XGF08ptnwkZrmPOT7SP8nP+LvfRjyK6uK0EAoH32zu3FSZGuE9xmXA747ijz7ivMOH0cfPAZed2u0U/5XLmuLmt8PjC+eO6jv5OcNlyO2GihX/vPlwP3L44rmh/jrYVzi+3Tf4d4d+4aF/gsYPb2ScxJkkiyf+pwmPQB4kapdKOmloNKkihKykZQhFbyBQOIid/ENm5g8jMHhD7aPCxwKmkzCanyQkDpEAOCPf8mhTQlN7zI4RJsUwg5TOeT6pJG0Q8hYvn56S0JgnIBYmTlj2MjFwVsvLVyCvSCAub/CItikqNKK/Uo3/AB61mEu0tDjTWW9FQzydIWdHcbEMLobXFTnCI4795iU1TqwMNpLjzZsV1DRaBxiY72tpdgrxhQqe3j8AET5+PxgMf/RZ6xXfk5KqH3LBbp2gOMIVBxQj6yK97wIOObg+aKI66FidqWshtdaFHMYbWLrfwq2v2oL7ZTd93oaXVjZY2t9gU2WoO4wevvvWYqOH5yM/xg++/hpXlXcqXD+rhAIbo20OUJkU3jcvtZgy2G6Hrs0Hfb4ZSpoWu3wrNoB395N/VpCNo0ddqRG+LHn0MJmvaLBhqt2K4wwh1lwGabgP0fWaoZWYMU5wDj8OxJU5/E83nGrToadShl97rbjGJpVaDFOcQfUPTY4WS94qRmaAesEM35IJZ7YfPHsGkfxmzk+uITK7C75uD2zNPc+15+j2eh8E8C7WB5rS6CPoUE2jq8KGywYWSWhvK622oanKgpMGNuAIbbuTbkFxqQ161HdnlFiQWmxFXYhfIa/Cips1H5epCRYOVytqB7v4RaHTjNO6f71vT0eFCG8Xf0uZFS7sHja02yHrcVM9U1200N+jziz14SmssyCs3oIz3sak0ooSuK6r42oLsYiOScrS4manB5TQVnk0dxlNpCjybxsdpq5CcoxPLnmIyVXg6bhDPJQzhRqYSZU1mHJ69hDdef4T33nlX1OfxwQtoajShoECFHCYvs/qRnSVHDi95YpIyg9o89YukpK7HR2n3IjmV96kZpL7Sh5T0HmRm9CI1SYbkZBky0vuQlT6ADOo3KdSneH+a2LhOxMXJcD2mFVdj2nHhWhsu3+jAzbguxMZ34eq1Fly+0ogbN5qQGNuInJQ25CW3ISOhVZwkJRE1kvyblOhErqOjQ0wEo/8y84SNJ7CsRLLSwBNWnryzosb+rATxhJXBJ13xxJgnl/wvX3FxsSBn+N85Vurq6+vFhPb3oWB/UDgv/O8n5+PGjRtikstpYn9WDpjE4Ak2T0J5Usrhov8ylpeX04/1gvjhZtKqtrZWKEr8nMNxeJ6Af1ih+qSEJ8VMgHG5j4yMCHKACS8mwdiflTxOPyvfXI58zaeLsQLK5cyWEpwHVq5YaZqfn0dra6u4539dmWjgiT0reL+vCTgrJ2tra5DJZKI9cNkxUcF5YssfzgMTSNyGWCFnpSzaVrh9sMJXU1Mjrrke+Xh7Vir4H3dWJrg+Ob9MpH1QGfm4wuli0oKVt5iYGPqRaxPKHNc1f4sVeiZn2LqE01JVVSUIFm5LnA8OywoStx1WTLkvcTmwkh7tK1zurByxQsQkAZcNk1Lt7e3vK00fR1jhYusGVhQvX74s0hwlALhPch9lAo3Llr/N5czEF/cPTjfngdPA7YvLmBVT7tvcF7j+OM1cFtxXWDnk+uV0cx01NTWJf/Q/jnLKwmXIhAkrnZ///OdF3NH+y8Iup4/LkJ9zflhp5fbMYxSXMZcDWzVwOXDZcx1wP2Zll9sX52FqakrkaXFxUeSBSSmuB25zH7dvcHq5jXBb/cxnPiPaSTSN3N6rq6uF4s/f5e9zOTOpw22J08b9mvs3+/EzLgMeCyYmJkQa+ZrDsj+PSdwvuP9z3+Z+x+XzcfsG99G5uTkxbn/uc58Tdcvp57bEJFphYaEoQ04LtxUeZ5jci7YfBvcpHne4HXI7598VzndLS4sgaLicOP1cRxwP11NnZ+f75Prvmgd+j9NbUVEh0sjlyHFzXpis4N8xHle5j3Lb5jbOZcfjIz/juuJ2wOnj9sz9mds7/zZwnfE4wOMD9y3+PeRr7t+cB46P2xnXFT/7XYXzwPExScb1wOM/E1xMXnIbZms3bt/cDzj9HJb7DBNG3Ne5P3NeuBy5Hph44TzwmMR54DLn/HM+uc9wnXC5cx1x2XC9bGxsfCQJKokk/7fIh4maoWE7KqtUKC1T0rxEiYLCIeQVDCInbwBZOaQwZg8gnZTPjMwBQdakpPUhmZD02BVETQopo6RYJpHimZzRj5RMUkIz5IhPJ5ACHJvCJ+DIEZs8iJtJg3SvIP8hJGWpkJGnEWRNNiG3SIfiMjWNnx7YHLOoruOTeQglehTz5sTlOpRVGMD72VRWmVFZbUEFo8aKSgJfl1aZUFxlRDEr5+RW8B4q9VbUNtlQ32xDQ7MdjS0ONLc50dbpQruwvrHDZpmkcW6K/Oxo6XSimRT/xjY76ihsZYMNZXWEer62o77VAbU+go4uN8XlQjOho92Dzg43Ottd6KE4zcYJfP97bwqihk99+tnPeC77BtZW9qFWeiDvc2Gg2wl5F7n0Ld53RtGhh7GfiRctXeug7DbBa/bDrHRgkPx4I2Heu6angcqoTQ85YaBZR+HNUHaahDWNqlMPbZfpnKhpMxD0UPASqCYdegmyGiVaK+XobtTSd41i+ZSKwpoGHNB2myk+3vtGh75WEz1n0sYGZY8TFnUAs6F1hCcW4XFHYLNHYLREoDNNQ6WbFlY0PfIptMhGUVpjR36lDTnlVmSUmsRpTDXtXqSVmXAtz4BrBSbcKDQgocyK+GILEsssSK20oozKsbNvhMb0cZoH8BK3ADSaURh0Y9Brghjo91EdWtEkllN5BAHXKXOgt4fqkOqyq9MtTofq7HSgtNqI/DI9yqpNKKO2UF5hJP3Ggrp6G7UfC/KKDEjMUuMStcVnk+V4JmkAV1OVuJ46jIRMFZKyh5GYQ9fZSqTlaZGep0J1E82HT14gXeptYVHz2g9ew2267+4wo7x0GHnUZzIz+5HJmwcT0piISe5CcnIn+fcgJ0suTmtKSOpBcjr1oZRO5GT3oDC3D/kZvchJ60VmShcyUzuRkdKBTHovOb4dN6614urVVly41IiLlxtw9XoTYmNbkBjbhsS4Vty83oj4G41IjW1Gxs16FKW0ojCpCdlxDWipHJaIGkn+bQpPCnlSxxNu/sHiiR0r+jwR5AkcKz2s3LFSxBNgnviyPxMBrBzxZI6PImclgid9PCnnCWbUwob9eDLLE0H+Ufx9CsfPxARPNAsKCsTElSfcrGSw0sCEAJMtrAzyRJ4nuaz08OSc/9llRYGVFP53lJUkJnRY+eCJME/0OfzHVag/SrgOOA2sWHAaWJFm4oAtB5gc4H9R+btMerFyx+QZKx+cxyiJw4oBK4esgPJyG3ZZAeWw/C5P0lmh4rz8vggzVmx4os/1zWXM7YiVM/4utyGuH1YwWbnktsMKDech2lZY+eF2xG2R2xnHw2G4DvndqBUE/zP+cUmBDwrHz0oWE3K5ublC2WLigr/B6WDSjp9zGXN7YfKJ08mKNROArOhxXXFb53Ln/sDPuNy5vjgstz9WFPk5K6rcb7itcdxc75yGj6OcMvnFyhxbUaWmpgrFjeOPEjVcdtz2ue7526zkMdHHyhpby3Bf4fQzocbp5TRxHbGyx+nm/sBtkvPO73IdcLvjOLnMuHy4bD6OcP1zH+Xyu3Dhgmg7nAbOH4PLM2rdcOXKFdE2uN9wnrh9sRLNeeC2x5YSbHHD6Wewcspp57xye2RrFB73+F3O882bNwXRxe3wdxVOI5fH2NiYIP2efPJJoWhHiRr2Z2Wb2wqXJZMePKZwW4u2QSbAuM9y3rgdcvvjfHPZ8BjEz7le2VonSp5xHngciI2NFfFynf+uwnnguDj9XGZPPPGEGPc5Tu4PrMynpaUJl+uG21xlZaUgADgtTGhwnplw4vrgtsK/K5wHrpuioiIRhss8Pj7+/TGVy4jHNx6XOa+/K2HG6ef08hjC5cRp5vrnsZGJLK5//n3g3zfuM9xmOb38jPPNZBrXE4+T3Lc5LOeDfwe5vfP7CQkJ74flMucxmvPA4x1/l8ct/u3gtPwuwu9xeXJbZ9KL88Blwr+7PKZzf+bfX04jj0mcLv59ZvKF08V9k9sGty9uS0wOMvnP19xWePy5fv26aFtMvObk5Ih8cTxcR0w8cV/h8vld8yCJJP+nyweJmvn5JRojrCgpHUJBoYLmJUPIy1cgJ3/g3KImT47sXAL55Yo9aOgZ3Wfx8gxCZq4CGdkKpGcNI50V2izGMJIzhgQxczWuHxdu9OCZKzJ8+VIHnnyuFV98vhVPXWzHly934JmrMlyI6cG1uD7EJnRTGgagUnrgdIyjonqIlOMBZBSokF2kRm6xBgXFOuQzSvQoKDWikBR/3gy2sNwgUEQoIOWcFfT8Mh3yyM0rNZBrRAGHqdCjuNJESrxFEDiV9Ra0yJyCFLLZptHaZkE1+VXXW1FdRy6HqSElvNosThMqrbaiXJyiZEF3jwcWSxiDcg862qzo6XShT+YmsOuCxTiBV5mo+SWT/f9I1PDms0qFk8LYxLHnA+1W9LdYoGg3QN2jg6JDiWG6VnZaoOm2wKVxI+SehHXIJogYRZuBwCSNBvJWDV3rxP40TLAMteug7jJC3WmGlt7V9VooHt67RovBRg1669XobdCgu06JzupBik8PTY8JpkE7zAM2qNopHg7HYdjypkGP3kYjBlvNMA15EBlbhFXvhkkXgF7HGzdPoLM/iKZOP+rb/CircaKo0o48Piac6ie12IBk3vOlWC/2lWnqdCKjRIOkQiPSy6woqnejtM6JkloT6jrdaGh3oqvbCYthAi7TOByGMRiUIzCq/FDLR9DT5UFtvRnNrTbIB33o7aFypPD93S70UPxd9L6S6qOv147yKj3Vm/V9kqa6yoIaJvTovorqkv0KSgxiidNNaq/JOUpqwxrEpSlwI1WO2HQFUrKHqZ2rkZWvQWaBhtqLEQdHDwRR84jmLj+keeT90wcwDHvQXKtBUQH1ifQBwqCwjElP60Z+dh8KmIjJ60N2Zp+wnElNbkNORjsKM9tRXdyP8rxeFKZT+6fwhakdqC3sRVF6I3IT65Ef14Kc2Bak32xC0o0GJF+vQ3pMHbLi6pEZW4e0mBqkXq9GDt0XMGJr0JDTjrLEGhTHVkNWPoBHb70jETWS/NsUnqBFSQn+8eJ/7NiSgSe3PFHkf0t5MssT06ji+cGlAvyPNSvcTBBETc2jkzxWQHjCz/HxxPf3IfwdVrB4YsoWKDzB5Qk2Tzb5+zzpZ0WOlQqecLOywxYGPDnl9/g55y87O1vkMT8/X0x8eRLMz3jiy5NvViQ+zj+l/5xw+nkSzRYObBXDSiQrSpwXnpCzMs0TbFY8eWLNChETHqy4sWLIdcaIkmQ8AWeFh/PEigjHz/nnPHAZ/L7+KeU0sKLARBcrmVzvbLnBE39OJ6eFiRwmoniCxO2Ew0XbCitUnGd+n//RjS4d4fbJcbOCx+2LLQi4PD4p4XSxssztl0kAbvd8z22DLSJYQeIy5W9+sK1wvbCyyuQIK56sQLFSxOmMljvnNdp2uA/wcowogcL5YtKA3+d+9rsqpyzcLjnNTHrx97jM+TscJyvBHH80/ZxuLtuoMsb55vbG4VkBZ4shVj6j5c7/4nOdcF1wellZZEWcn3HcrHwzwcL1x3n+XYUVXU4/T5y5fFlhjhI1nG7+Ptc/W6xkZWWJfhwlaniM4n7PCi2XP6eTCRF+xu9zf+HyZ8sztgjhPHEb5Gf8DSZ++BmPaR9HuG9yHrhMmfzh8TJK1HCaeNxhZZ77OJcjE2I89nJauMw5fJTk4P7BJC2/y32WFXGuJ1a0U1JSBLETjZvHj0uXLon29nHIJhYeI7ktMxHw3HPPifrguubv8G8DjztMKLMVCv8WMPnI/jzWchkyEcttieuK+zPnh9/lsmVSh0kEJtTj4uLEeMvPOH7u10lJSWK85fvfVbgvcHuPju1chvxdJmeYjOOxkcdVLlN+zuXORA2XJ+eD+ze3HSbyePzicZV/uzgsu2x1x+MTk0ycB67vaP54fOX2xX2R/X4XibZJ7pucBwanp7S0VPQzTgM/47rncuK8cl/m9sJlx2Mtt28mrDjvmZmZoryjYxLXE9crk/dsbcPx8pgQ/S7XT9Tihv0kkeT/RuG+849EzSL1HzNyc0m5zOKjgs8tAtiCJo3d7EG6JpCbKfakkQty5hy8P80gUilcQkoPrsfK8NyVdnzpQjO+8HQjPvulRvzVk/X4zBP1+KsnGvAZvib81ZMN+OxTTfjc0034/DNNeOK5Zly41oGsnD64HFNw2kOkQHfjuevN+OLlJjx/sx3xlK6sArUgaXKLtQJ8XVhuRFHFOTmTV6qj99QoIhQUny+nyuF9Qxh0LUD+2SUq5PKpU5UGNHXY4B9bhde3gLZ2Eynw/2ixU15pputzIoj30OHjxavonboaIxprDehsNUIz7MbE6IJwu+n9Xoqvt92GjkYT1KS8f++V12gc+5Uocx4nX3vtDWxtHEHRb0NniwHdrSaxlGmwzSD2pdH1aaFl0LW+xwpzjw1WhQVevRuLY7NwqGxQyfRQdRqF9QtbzyjbtVB26DBEGGzViCVMijYj9L126PsofLcBqg4NNO1qDDep0N+gEpY2g40qet8giBp9nwUamRHKVh3kzVphgTNI6eM9bmS1anTTOxPuMIKOccg7NRjsMGKgw47uDg+qam0oq7GhsNKKvDIT8sr5ZCVyq8xIL9UjtViPLHJr643QacMU3kz15qBytSOvkOqtgOqzSE1xmFHZ6EJNswODilHYjFMwqgLQKXwY7vWgs8mCprrz4+Eb63ToldnR2+VAZ5sVbbwcrtGBlmYrlAoXNEofaim+0goziqlt8BHxZQQ+XYw3ry6vNqG4Qi/2SMoqpLbCG1uXa1FYoqc2PYzUrCGkkZtXoEQxvZchToBSobzOgL1D3ifwLTx65128Tr/xD2+/KE7mqi+Vo4DacHZ6LwqYnMnuRkFWB0qyO1Ce3YnSzHaUpDNaUZbZiMrsBlSTW5XVTNftKCb/Erpurx5AW2k3KtMbUJJYi4IbVSiKrUVJQh2K4qpQHFeN4thK8qtEQVwF8mMrkBdThrzrZSi+WYHq5Cp0FLSgMr4EFbGl6CmT4dFbjz72/OiDIhE1knzqwoMoKzr8DzpPxHniypNZnhBGJ4Y8UWTlmhXyqBLEE1ZWnPgHj/8xZiWRJ4PRiR9PkHkizHH8PoQnxKxccLqZYOFJLVsI8OSVJ7WcDv5BZkWQfyRYUeKJKKeX/63k93ninZycLPz4H+Po0hZ+xsoElwfHzfF80sLpY8WGFR5OAxM2rCywssbKDltjcD1w+rlcWYHmMuZ64PriemPwO2zdwMo2Kwucp6jiyWXCShWb8nNcvw/hsmTljsuWl8Ow4sDEE9dF1GqGFVlW6Pmaw7A1SrStcNkyaREllJgAiJIyXA9MCHJ5MEnIZfBJCcfNaedyYcWSrQCiRA0rLVzOTMTwfbStsKLMihy/x4oop52Vc1Z6mEyLljv/M875YYWI4+GyiP7bzu9yv2ALkqgy+7tKNA9cLtyOWImOEjUs/D0Gp5mfMaHE5B2XLeebv89pZqWVSRzu35xfbldMfDDxyYod92+2POJ65Lj5e1zHnL9oPf6uwt/iPHCf5bpnBZnHD/4OK5+cL+6XrEBy++axKEpUsMvlyi4rqUyusaLK8bFw32WyifPCRCwTIlHFlfPPFgbcvj5u3+DvMbgsEhMT3ydqOG/8XSYimGzhfLDL6eTxk8NwXrmPs8tjFxNLXF+cP66nqCUI92+Oh4krrjN+zu9cvXpVkFgc9uMI1zuDx8KLFy++T5ww2GKH2wATTpw+Jm24XjgMtwXON4PbB483nF6+5nLmONmCjMdpJi65D7EFBz/juJmAYgsV7mvRevtdheNk8O8CE8Y81vAYyOnn5ZZMJkXLjscs7oc85nDa+XeK+zOXPZOWTC7zmMVhmQRicobDclvi3wr+RrSOeGxgC5UoAfVxJFpm/IcCWxJGiRj2iz5nkob7CY8x3O6jv3Fc5tymuN9kZGSIdhEdM9mf65XTz32Z64SJPo6P88cEaXNzs/htYT9JJPm/UXjM4X7O49zc3CI6u41ISu9BfAqBT6VJ6kViUrdAQmIXoZv8mYzpJXTRNSGpH3GJvYhJ6EB2ngLpGYP48jM1+PyTlfjck1X4qyer8T+eqMFfPFGLP3+iDv/1C7UEun+yBv/jyVr8zyfr8T+fasDfPN2CL11sQ2KKDF7fHMYmFlBR2YfGdhOevNiAzz9Thyeeq8dzV1oQEycTS0YSKQ2JiR00BsmQk9eHojKlOOab97jho8ELC4cJ5McKOJMz+UNIzx1Eaq4CKXmkhOcPI6dEjepGI8ZCGwiOLaOuQU0KOSvlGpSQsl5UokNBsRZ5xbwcS4nSYiVaqrToa2LrErZg0QiLluFODRx6N5Yim9ArXRjsNqG/3YzORgPd+/DqK+cHA/yaxsSf/5z/GH4D21vHUMrt6OIlTE0GsYRJ12+Dvo/JFw00BG2vDqY+Eyx9Fhh69bAMGjHlGsX23AocajvUXbxcicNboKdvDrdroOzUQdGug7zFCDmTPy16DLXzciottBReL9NCw6QOpV/RpMFQi5be04t41ARNpwGqNvJrpXy1UTx8HHijGj0NlFd6bzm8BLvGhQF6LqtTCWub/jYnOlocqK7Si2VpvCE0kyA1TXZxdHZuhQHZ5UZB3JRWG+j3PQTFkA+llXqUVBip7vTILWSiRiuspPLKzcinsJW1JnS12zHQ5UB/pw2d9Xq01urRWKVGS40GDRVytNYp0daoE6RNfY0BjfU2tLQ6oFJ6YTGMo5q+wcvmSqiuy4sUqCkaRG3ZEGoqlGKZUmkZ1Xm5XiyfKyvXoqyCCb5h5OcNojCvH6UUvrKMoaDftj5kZvejuk6Dvf37NBd7A4/eeQ+v//BNvHjva9D2W1FX2CUImbKsDpRntqEmrwO1Be2oym5EdVoDatMaUZfRTGhAfWYtGrJq0JRVj/qsBlSRX0VWI1oru0Td1uc0oiq1XljFlCZUoyyhFuV0XZFQifL4ClQQyuMr6XklShMrUBxfhqLYUhReL0ZrTgO6C5tRGVuIqrgi9FZ0SESNJP92hSdjPIiyMs3kACsEPInjydsHJ5t8zf9EMmnBCihP/PjdqPk0TyJZ8eBlF1GChBUI/ueYFWyeRP4+hH9sWWljhZEVfVYC+B9U/jeULSFY+YpOONnliSinkyftnG/OFyuhvGSElW0mnTgOntDyM/53mcmHj7v3wD8nnCZWCljhYUWfFWgue7YS4AkzWwNElWAGp4n/ked/6FnRiSpRPFHPy8sT5AZb1nxQ8eRyYMWJyZyPq4z+c8J1ziQYK8SsGLCizIoqK3XRf/+j9cB54DJl65UPkmmsOLA//wPMeWAlKkrUsEURtyP2iyodn6RwnNxWmajhf6J5QOd2xeXGSmQ0HdxWWEHjOosK+/O/8dwGowQnCyvVrERx2+Fy4b7BRAOH5/g5r5xnJhnY7+MKx/lhoibaZrht8/ejJCyXd7Q+WPiay5YtDrh/c365XXGb4TGBrSV4uRQr31ELIFYKuc1+0Prl4wq39Q8SNUyoMKHH7YHrg8ufrRpYeY1axUWFr3mM4r7B/Sf6LLpPB7crJkw4T9H2yO61a9dEvJyfT0I43R8maphc4rGF2xIr0jz+cF0xOch5jgrnl/34WZQE4LbJZAK3Fe7LTNTwuMvtjJ/z+7w3EZM3H5eoYeE4eTxnK50oUcPf4iWsPCZx/2YFhwkLJiB57OF0R4WJDU4vk87R3xGuCyYIOQ6uIy4fJhL4GcfP1i5MgnwSy7c4Th5/eHzhMYPLits7/8YxEcntIErUsBUSp5XHy2geOA5u40zUcJvj+uSwHAdbSnFY7kNcD1GrJ64jbkM8BvNYwH6/q/D3ubx4/OD0s6Ufj+tRcpHj5v7NVmTcn7mvcFv5YF/gcEy2MFHDxBTXH/vxb9jzzz8vxlMerzmPnFd+xvljUpP7D49v7CeJJP83Co8x3N55HJuZo3lKhw4XE2V4PpaXIXURunHhZhcu3ZTh8o12XInpwLXYbkGUxCfIqO93iesvP9+EJ56uw7OXWpCXq6G5pYfgIOVXhdg0Gb54uR6feaYOf/7FOvznL9Thv/5dHf7siXr82d/V0HU1/vzJOvzVU3VIzOiFyxPB9PQi8oq6kZZJ86NhD5670oBnLjbi0tUW3LjejtjrrbhxpRHxMU3ITZeR0q5CY+0w6urk9BvZjYK8HuTlDFJaBlBcoEBJ/hD58UlVcqRny5Gccb5vTlLmIKpqdZicXKf57gqqSOFPzuh+f8+ddAqTzdZD2X3ILyLlvEIhyApNmw7GDg1BDX2rCtoWNbRMarQq4Lf6sRhehl5lQU/zsCA4bJoRvPpdtnD8lTj16Wc07r722uv0G3IE9ZBNHJut7rHBpnTDOuSARqaDvtsArUwLZdsw1J0q8tNC1a4V/la5AQvjU9icW4VT68QgfX+gyUDhLBiitCla1Rhu02KomeLtMEPOy6Fa6L5TC003+2kJBrGsii1qhtr04pqtanRdBhjoG4YuyiO5HFZBeRto0aCvWQWvxYel8Dz0g2YMy4zC0qazhpdIGdBVr0VXowEddN1ar0dHkxHtLWY01ptQVaFDSZkGBWVqFFVo6ffGhtHgEtrbLKioNKKs0oByXo7Gm0kXsaUUW7nQPb1TWTKE+sphNFUq0F41hI4aXq41hO66YXTVygmDwvqkpUqBlmqVOMGqib4vH7DCaZmk9qFBTYUaDVR/7RX96CnvQU9ZFzrLetBUTChXoKpEiapSNarLlagoHUA5taOa4i7U5rcRWlBfRG5BGyrz2gmd9I1+HOzcwg++f07U8BKorzz8BqxKB1qK21Gf24z6nGY0ZDeiKacBzXmEXEJ2PZozatGc2YCmjDpCDZrSq9FC181ZdWjIqkVdbh203Vr01vVRHA2oTKtGeXIVKgSqUZlSjWpCZVIFyhPKUJFYTs8rUJFSKVBO/iWxxRis7oWssAVVCaWoTirFQHUX3pGIGkn+rQqTFazE8b/9rEzyJJYn19F/NXmyxuDJIU8ceRLHE/WoksBKKE/AeXLKE3P+lzWqeLJCwgoSK4482f19CP8Dyv9Os4LJyg1PunkzYf53lv8NZYIoOmnmfLDCyenlf1ijyigrD0zu8KSb089WDqxs8DNWBllB/ST+cf8o4TRxGpkk439+OQ38Xa4DVuQ5Lfz8g/XAk2xWOJhEEv9UUHhWoDmdnF6uI1ZOeSLC4VkZYXKKFZbfB8nBwhN7Jjm4rnnizwNi9F9pnvxHCRkWThMrnVwPUaWfn7PyzdYEnF6uh2iZc1xMnnH7/KAC/knKh4kaLldWfJlo4nYfVex4vwdua9zGo8L+rBRFSZlouXM/4bpgBY6toFjh4n7CcXMYtk5gZStavx9XuFw+TNQwuMyYbOFnbMERVTyj34y6vHyQ21CUbOL4WAnk97i/sMv1w0ohtzmuM16mxIo3ExKfhHyQqOFrTiuTZfzPP7cPtuTgzYSZcOHvfpAg4DRxG+cxILo8k/24D/GyMyZBuZ9z3Jx2LgOuR176FCUFPwn5KKKGx0Emtdh6ie+5f3M9cZv4YP/mMufxiNt6tH/zWMT1whZeTG4w4cNkU7SdMWHLpArXUXTc/jjCcX6YqOFvcbky2cd9lr/DlmfRPh8d3zkP3Hb494TbPLeVaHvneuXlXkw6MNnGYxU/4zxzvXFbipI3v6vwu1ELQm4r3A6iFjHcR3kc5PpnwoLzxSQGkx0fXM7L4Oc8HjNRznXFYZlk5d8WDst9iq+jhD/XM//e8HjHfY/j+F2Fv8VjB6eVLYKYnOP4OQ8Mrm8m67lP8zejJM0Hv8nX3Ma5n7AFV7St8JjMS584D9w+mViKEoLR31IuN87zx8mDJJL8nyzRMY2JmsjsIqpadHjiRgeeuNKKL11pxtPXmvB8XDNupLQhI7eHlGklmpvM4pSlpkabsFC4Gd+Bzz1Zib/8uypCNf7mC9V44qkaxCbKUFFtwIAiCKM1giHtJKro3fj0XjxxoR5/8WQ1/hOF/9MnqvHXz9YgJVuG4NgSAsEI/Ub04dqNZppjDEM1bEfMzSZcu9qEG1cbkRDTjLS4VnGKTUZCC3KT21CSKUNt6SD6eU8WuRlGjQvDCjvaWrVC6c7N7kZ8Yicux3bhws0eXIvvRXL6IJpbLFhe2MPKwhbNW7RIzOzGtcQu3EjoQmxCJ5KTO1BaOIDmKgX6m5RQt6tg6FDBQjB3KGGke12rCpqmYagbhzHcqICmU4UxZxDLVJ7GIQPkLYNwUnpe/Q4v3z+30OV51htvvIn9/WM4LT4E7GOYdE0g5J6AedAEVZsKqlY1NLxMqU0DZatGEBI99cPob9ZggL6p7NZgOhjGamQJQ51qtJQNoIPS2VWjwCClx9Clh75Ti8F6OeQUl6JdDWUXpbffAOOgFbo+u9jfhk+IUslMULTqoO40wthjhLlHD2uvDrZ+I7SPSaLhDnq/R42d1XUEHH7IO/j0KA2lR4/uekKtAbJqHbrqeImUUmxQ3NtEaFShh+5llUNoKe1HXbEMjRUDaK8dongmCdNortNRmzJAM+xHI7Wx6jIlSooUKCe3unL43GqmSk7xD2KwbggKzhNhsLaf0EfowUBNN3qrCNUD6KT4ZTWD0A8YEPaGMNg4hK7yHshKO4VVSW9FG3pKWtFV3ApZcTv5M2lD9Vzai6bybjSXd6KNwnSW0fOSNnSUtKOtuBntxS1oLWpBS2EL5akLR9vH9Hv4ulj69Nrrb+GrL74Ml9aDttIO1Oe2oF6QNI1ozmlAU1adIGlacurJrUNLdi2aMmtQn1aF+tQKNJLbkF6JhpwqDLf2w9yvp+93oCm/ETWZ1ahMrURNRjWq0irFdRWhMqUC5cnlKE8qQwVdsz/7lSWXkn8RtQEV2grqUZlYQihGP5WRRNRI8m9SeCLGk26ebLMixP+MsnLAfjy55QkoXzORw8oET3R5UstKNl/zhJQns9F/TnkCzst3eJLJ77Pyw/+Ef5L/Vn9YWCngSTMTMPxdzgNbNvCEmRUznuD+/+z9Z7Qt13UeCv7tHm6/Z7d7PNvDsmQ+S6JESUwCQRI5XODmdG44Oeewz84555xz3ifnnO6550bkHAgCzGAEEwCCEikSJG1/PWcdHOkS1nP3k0AZtusbY45Vu2rVWnOF2rvmt+eai/Vkd3Q2JtgQOCAPWGd+SWXSg/9d5Dbyeb7OLvj84sr/qHLfHCx/+V2Af7zYi4m9gLiv+AWbyQomCQ4Cu7L+rDsbpvzPMC9z4rbyNTaY2KWfyRk2JtjQY4KAX0LYEOXPTPocGF2/C3DfMdHBxhwbYPwSxMYAjwUblWx087/cPG+4vTxX+B9pHjPOy5/ZkOP2M5nBXhRsFDJpwu1jw4+NlgMC4oPG30fU8NxgwoiNNTawWXc29NmY4fnN97AnAD8jPFfYo4ufD35eOD8bU+xxwOPA5Bpf45QJTCaBmKji5RI8Rz8Io4jn561EDY81p0wgsScE181ziOvnecP5+ZgNWx4DNgC5z7mf+ZjzMpFwUB7PRS6Ldec5ymPFniIHy6g+CNxK1LCO/HzzPGJDnoXJO16qxMQHE0v8vcJznL8DeEy4r9mTgvuedeax4DnJzzePH4/xAeHHdTGxxsYsz7kP6tlgvW8lani+8jgfeMKwntznTL7w9w0/O9zf/N3L7eXvMiYa+DuB5xUvf+S5wiQ6l82EFbeBvxO4LG4bjwPP1w9iHrG+7ydq+HuHCS/+juLvQiYymMDkeXXQBn5Oec5wm5kc4PnO7eVrTIgwUcXL6/jZ4O8rHiNuH39ncXt4rvF8/Ie2ge/jfuTvayY5uM/5WeYyuZ+4Lq6T5wPPC66X28R183cqz+mDZ5efbf6dY48WHiueKxwXieOx8Thxm5jk4O9WLp/Hgp/193tI/d8B68/C35M8njzHub94XLkOfkb5N4vr5N8oJnmZKOL5z3Wyzjw/eMw4H48ZP8/8ncDt4mtM9h3Md76X28Pfz9we/g7m3wluJ9clQsT/rODvNJ7jBx41Mn0MdxzT4qE6A9r7PNCb0whFKijl5zFRXkY5Mwefs0Dvsx6cPa/Hgw/Jcce9MnzmLik+fecoPvH5UXzqs3Lc9nkFPnO3Gnc9pMGxMzp09rhhd+ZRqa7Qc7WLdG4JzVT+xx8YxScfkKG+zYLpqQ2M1WYxIrHj9EklGs8Z4Lak4XUlcPqMir6H1Th+TC140bRe0KGv2Yi+JiMGWiwYpvtHOsyQ9VqgGrbDZYkgGy9jZWYTyxz0NjODEUUIh86Z8fmjVhw6YRMCI6+s3MTm2nVEg0XYHTmcuKjF4TozTtVZ0NZIxvagCz5dBHEqL2cNI28PI2MJIWUIIqEPImYMIqTzI6ByI6Tywqfwwq8OIOmMYWN2ATtLa4jaQyjFyvjuN79Pv2u/FN6p+PeN35cee/RJ6tcpTBcnUImlMV+eQDFcQNAYQVAXRpTSlCWBsC4GhzwAO4lJFoBuNAgdpX5LFJfXtjBTmoRd6YNZ4odXs0/wZJxxZMnYD5kDyPhSmMpPYr46R3VNIRsowKsNw6UOCd44vHzLa4gJS6bi9hjdG0PBm0QpmBXanuTtwW1RTObG8PSNxxByxGFRhWFTR0lisKsTsMhisMnipEccVlUATirbo6HyVT7qHw88MifsI1ZYJRYYB41CmnJHsbO4jiiNcS03iUK0ROW4YJb6YJD4YKKUAx3bZR54lV6hjyNqFjeiahdiWheSBi+JB1GNA36FFV7FPmHjUDiQ9sexMbVIY+KCa9gM96gZnlETPBIjXCNm2EkPJmvsA0Y4SDe7xAob6WWXUD6phfKY4BxmIscIC4mD7vUqaX5JbfDrXXiS+uL7b7wh/Gb+gMbzS699HZX0BExUlrpHC3W3BqoOJTTtSihb5YK3jJYJmk4FdF2qfe8ZgaiRQdMsozwj0PTJMJYq0/h7YB40QN2ppDIUkLXKBJG3SKAgkTWPQNa0L5KGIUgbyd47kKYhyDuGUAwkYehWQNHIHjWDQt+IRI2I/yHBX5xsdPEOJfwvNQceZGKFX6jZw4P/feN/4Nm4YYOUX8DZ2OOXVyZo+GWYX+z4Hz82mPhFkF9U+eX94DobeWwg/a4IAn6x5RdUfill/Q7+5b31n1/WmV+6+QWWf5z5X0h+WWcdWVc2KPgHm41NfoFlQ4+JDjakuA28tIO/kP6hBsT/L3C5rDcbEVwvG8OsG/cdv7TzjxuTA6wHv5RzO5mUOcjHOh78A895+QWc/xXl89wGHiM2nPhl/nfVBu47XjLDfc99ynVzynOHjQTudyZfOE4O68H9yXOM23swDgdEDLePjVOeZwdt4PYxqXOrB8UHifcTNTxfeU5zv906V7gvD5bcsPHE55hUY515WQsbRXyOdeZ5xcY2Pxf8LDHhw+3l60zC8Zw8IIU+CLBOPO78DB4QNUxE8DbLDz74oOCxwM83E5Ps7cD6M8nCurKhymPEfcwG50G/s7HIY8H9zroyKXvQBiaxmCTgOflBkWc8N9iIZ72537hcHoeD55t1ZgOZ5z/PIb7GOvNcYZKA72Eyh/v+oJ+ZAODvKC6Dnw0m/Q7mJ3s1sbcWt/2DejZYByZleGkQ68zlsuHMfc71snAf8ncUfyexkczfSUwacD6eK+y5detc4X7n9vEYM3HA8+ygLG7DwXKuDwLvJ2r4M89RJmh4Phzoxd8//MzydxTrzYQNkwd8fOD1wfrxs8NzhePT8LzkZ41JpwMCkYXLPFhS+w8F68nP2Cc+8QnBa4TnCf+WMbnKfctzh3/H3v/dyIQaj//B8l8meHiucLv4O4t14/zcBiYxeHx5HLjP+fxBG9jDhefZP5S05HnC/czeXx/96EcFTy8mVbgNTD5x/zJxwyTgbbfdJvwpws8KX2c9eW4zAcljwn+ScBv4O4l/zw705Lly4GHD7eDniM/zGLHwvUw6fZAvtCJEfNhwK1GzubWDVHYMyewMFhcv4fLWFWwvb2J5ch4TmXEhcK2sx4Tzp0bw8OEh3H3/MD53jwS33yUViJrb2TPmjv3j2+j4L0j+5M5R/PmddP5uGeUfFQiX0REPcokpTI9twuEqQ6WPY2ZyE9OVWahG9BihOqQ9bmj7XZjMTsNm8OHECTnueVCOBx5S4uQJDRrP6dBVr0dngwGdjUZIumxQ9tgg7zJB0mHAcLsOsm4d3NoAcsECFicXsbF+BanCMrp5+c1ACLnsErK5KdS3mXCsTgdvYBxaYxJ1FzXoaXfAIQ8iYY4gY4sgT1IgyZgDSJA+UY0PEQ29X2v9CGg8CJKE6Rx/9qvpnM6PjDuClYk5TOXGheVCr3/tW9TXPxN+q5kw/9733sCN648jHkgj6Ykj5QqhEstiZXIVXn0IPk0QUUpTxjBSphgdc0yZmLBbk6zPDcWgTyBaSpEULi+voRgqIED5w+Yw8oEU5go1bM8t4drmJVzfuITt2WVMZSrIOPxI6J2IqF3wMYGi9sKh9pGw15APPp0XUQuVG8oh78siSeOesydR9KZxY20PSzROIUMEDt4tSh4QxDjqhYnEqQiRMKHkon6gPqL+DyjdCFJdXrkdHtk+yeEYMcM6qEVQb8US/VbNlsdweWkDUasXHiWTLQ74FKSf3Imgwom41ouk3iMQMikWvRs5i5fGxIui3YcipXmSrM2HpMWDELXPq7UjG6AxGJtEmD77qdyQxoaQyoowHQfkJEzqDBngIHFJTPBIrQKZw8d+mQOeURucEgusI0bY6JxVoqe+CWA8VkHI4sMT1x/B97/3Hbzzk7eF3/uvfPl1jBdmYaV2anvV0PVqoOtWQc/Lnrr5mFMliUI41jCJw8ugeNlTmwqqjlEk3VGaMxNwyW0wD9A7dKcCKhJFpxLyVimUTcMkQwKpo2gZoZSJG0pbRqFolEDeNCKIZViNSjANY6cKpg45/NRev8YhEjUi/scE/1jxyz//Q8cv1ZyygcD/uvG/umw08XU2RNl44PxsVPBLIBs3bFzwiyl/+fJLMgu/oLOhxIYWEyT88ssvrr8rguD94JdTfhnnf9v5pZ/rZaKAjQD+QuEXYU7Z+GRvGfZK4bxMcHBevodf0NnA5pdy7oeDtv8uwfVyX/OyE+5bNvLYSOL2cN38bye368Bln41j/rea+5nJDzai+IeQx4Dbwi/obEhwG7mtB6TV7wrcd/ziw4YCL0nhvuPx55d+1ofnAOvBevJnbgP/U8xeGdwGNpY4L+fjNvDcYxKB28bzjNvPc4+v/S7A+rDuPJ+5HdweFv4Xno2jg7lyQFjyNR4bHqcDsoXP81zifmfvE77vYM6xMBnH48tl8X1MCh7M0Q8C3DfcZ6wDzxP+zEY9G69sJHPKzzYb06wH52ESlXXhdnIfcB/zs3LQ71wejwWXxWPDY8TPN7eBjW1+3v+hhunfB+4PfuaYdPz7yuUfWr5+YExyvx48N6w7t4H7nL1w+DniMeNngb+j+Bo/IzwHeY7yvGNPD87P1z4osN4893m8WUceXy6f5wnPd342eL4fkLCsE5N/7KHCY8L3c17WjecRjw+3l/NxWXwPjzEb3FwWfw/w+H1QzwbXwSQYl39AUB/Uy88IfzcefL+zocPnD753+fnhNnC7eX7zHOG5wnOG28RtYz15PHiM+BqPEz/ffB/X8w8F38vl8FxnAvHgt4zJiAOSl+v4+55RHh/uQ/5tO5hb3N9MfvBYsZ48Huxtw3OO6+L5xn9kcDncVwdt/8e0gfVgXfn3+NY2sIcZzw+e66zL+3+vuZ/5d4r14zbxc3nQBp7/rB+P2cFc4XpY2KuIiSkuk9vJ43kwz0SI+J8VPPcPiJqtzW0kIhk4DT6EHRGkPFEkHQFE9S4ysB3Q91sx0mFEez3HhlHiyFE57n5Ags/fI8Hn7hrF5++W47N3SnE7L3+6W4HP3CvHp++W4DP3jODBw3KcO6tBS70efe1G6AaNCKocSNtDmK/NYX1uHTOFSTLSHWTIO+GWkFFuDOLqwgb8Ji/aLqpx7KgaR49pcfSwEsePKHHqmApnTmuoXC3aLmghaTVC1W2EYcgK3QB7NFioHjsccg+8KjfcGjcS3iTSkSJWZjdx4/IjyCSqOHxKgQdOGDEw4MJkZRnJQBE+HbWbyRZLWPCkyZLwccoUQMoYQFzvR1jtpTa4SJyU1ysQOkmLHzHKE9EHKA0h7YpgdWoeTz/6JN747hv0u/4r/Po3+99HP/7Rm3jmyReRDObg0pKOWhfithB2FmgcPBnY5NTvJEljCDlLDGljDCF1EE6pB5ZRH5yKMPzqEAJaLwpkkG/OLGN7fhVbc8u4vrGNKysbWJtcQC1dRjaQRo4JgFAM6/E4LqdTuJRKYyOVxAodT8eZiIki4wgjaQ8i7YlhujCBbDhP92aF8pfGpvHMo49haWIGWQ/vChWCV+OHQ+aEZcQKy7AFXoVTIGUi1J6sOYSY2o2w0k59ReeVtn1RWBFW2RHX2ZFzejCdyeAm/YZe3dhCLZFBzkv9bPciafUiZw+g6Ayi5o1gPBjDWDCKqjeIot2DnNlBYkfB5qTPLhRYHPtpzupA0mRHNRzFKr3vjcWSyLq8NI4uZIx26ksb0gYaN6UFgVE9wnITInQcVpoRUpgQ01Aea4D0iyBDknbxsxBC1OqDX+fARLJE87WKpx95jMb1e/gJ/Qa++eM38dUvfQOz1QVhWZSxXw1TvwbmPjUsvZzqBOLFOqyHRaKDaVADQy8vhVJA18HeNjJYZUbMFKcQMvthGdRB36WApl0KTaccKpZWCVRM0jQMQNk8AkXzsJCqWkgoZRKHvWfklMensiBu8kDfJoOa8scM1De+GP76nZ8Kv90fFESiRsQ/CfhljF/m+OWSX5xZ+MeLhV9q+YWaJzZ/uR5McD7HxhTfw8Iv3re+1PEP4MELMacHL7X/VOC6WKdb9eI2ss6sG5/jNnCbDtrA1w/ycsqf2ejmawekwu8aXC/3Fdd30He36sX6Hxg5jFvbwLr+t9rA+Q7u+12C62UdD+q9dfxZWI9bx4X7ldt7MN9unSus761lcft/l2040P3WPma8v59v1Z/T97fxVp3f3+/vH99b2/tB4f3z5OBZ/W8933x8MMf5HN9z0IZby2JdD/LztYNn44NsA5fF/XbrfL4V77/OctCvB3oetIF1/PvG7ODZ4H54/xh9EOA6WJ/3j+/BfD/Q69Y2sI4Hc5w/35r3/XOF09/1883lHcyRAxzUezD+nN7aBtb/oA2Mg3HhvJzeOlcO8vM1llvH6B8D7gsuj8f21vnO9R/oyXX9fX3H+r1/bt3aXi7j1v7g44P63j/P/qHg+7meA/1vbcOBbgdz99brB3PkoA0H8+WgDQf33NpeBh8fjNGt4ylCxP/M4OeEn4d9omYLyWCSDG+bsNTDOUqGN8uwAbY+AwzdBig69Rhq1aK32YiLdXocekiOe+6X4+77ZLj7XinuvV+Ge+9T4v77lTj2kAzN5zToa9ZD3mkkw9UKx4gLLqkLHqkNETLYU2QQz6TLmMhWBE+KgMyKoNSBiMyNuXgOT21uk8Huh7rbhPbzWrQ32XH2jB7Hjqtx+JgGh4+oUXdKh+Y6LQYaddD0WmCTMNnjhpXq0vXbYB50UH0euGVOuBUOeHVuMoYnUE2V4TEGIB2wY6jbDj3libhiuLy0iYlYDhlLEDlLVIhHkzIHkLaFkBbi0oSQMAYR1/kRFYgI0lfjIsM+vG/Y20NImoOUJyR8XpuexeOP3sAPf/CG8N3Ifc7f+W+SYf/csy8hGcrBSeV4VFSWwY+50gzmKgtw6wI0Fh4ysMPImPaJmrguhJAQm8WLgJrq1wfJIA/Ao/VhZXoBlzbWMFerYSyZI6M8jpQjiqg1iLDJh4IziLV4FNezSTxaSOFaIYnLpThuzhTw2NIYHlmawfWlBVyen8P11XVsLyxgZ2WF0mVsTM3i8soSHrt6idI15P0c/yaAuNFPulipv00CCSN4vBjd1F8+FJ2srxtRjY3ESvo7kTE6kDbYUbR7UXX7UPNRezNpPHPzKp5/8lFKr+Pq2iq2ZmawMTmFjYlJrFVrWC2VsVwsYDaVQsXlQcnmRM5so7GxIW91ouRwvycuFKxWlG1WlOxOTETjuLG+gSf2LmOlWqG8NhRMVhpXG3JG0ldtRFJFwqnaJEhcZUBCY6J22JGyuJB3BVAORjEWS2MmU8Fcroa5QhmXl1dI52fw3W99D2/RWP7wBz/EV177KuaqszTPLLAMamAZUMPap4KlWwknPVNMYsWsAWHJV5b6sBhIoehLIEl96ZAaUE0XBeE8lgEN9J1SaNskJKPQtI5C3TICA52z9Cnf86xhYoakYRCK+gFB9kmcQUTNTvjUBjiHddC1DsIpUWGH5sjP/+qv8Z9+88HZciJRI0KECBEiRIgQIUKECBEfIG4larY3t1CIJuFXmuAYVMMzZICb43IM6QQj09ZvhKFHB3WnFqOtBrTWaXD0YSkOH5Lj9HEVGs9p0HxejdaLWgy2ciBWB4IqjivigldigW/YCt+IDX6JTSBjglIy4OUuMtSr2FvZQFjvpXxM1jjhl9qxM7OAJ3a2ECPD3jlihqbTiNFOC1qpjvOnFDhzUoW6ExpcPKlBy2k1eqheda8dHmWQ2uCn1AOn3AOXzAePjD4rAnDKvHApvZgsT2JneQtOXl5DxnNA64J1xAKHwiksD7qxtoVqJIP43y49CiBh9AmeNHH9vrdNgo+1PoTkZBDLHQhpvMhYowKZkzT6kTGFBCOcPUVeeekFMuR/gF/9av+PUiZs3nzzLTz/3EtIRwvwaXzCUp+Q1oOkK4TLyztCHBnrqBsu6qOQNkD9wEuvIkgaQmTwe+keD/xUp1cdgN8Wwd7WJawszCDudiNldZMe7OXjR5ok7/FjLBjApVwGe+k4bhQSeHQij8cXanhkvoLHFmt4bmsBz+0s46mdNTx77RL1fw1bEyVslXPYrZRwdXYCV5fnMJ/JYtwfRckZRNbMsWEsiGitpJsHeYtXkPFgEtVAHHmnH1mbC3m7GxWXDyVKq5SOeQKouejY7cL6eBlP39jD7sYKJtJJzGYyWC2XsZDNYyaVxnQ8gTlKx4LUn04XCjYHClaHQNKkjRYk9Sbqa6twvupwoWK1o2i1YjIaw0Qig6lSFUG7E4VghPRxIWc2I2swoWC0Iq+jYyZllHoklTqk1AYkVXrE5BrEFVok6XNKa6R5qqH5qoJPpkZAoaO5YEc5EsdzTzyF73/v+/jpT94RiLdvfOV1bM6sIWrwwDtqoOdIA3OvAqYeOYwdUpi65DD1qmAeUMM2oqOx5Zg31H86J7KOMLYWlrC1uER9UIGjXwV9uwTa1hGom4egaRuBdUiDmNFL5dJz2MieNYOQN/RDXj8A6YV+yOr7oekYoTLNmKH+256dw+7MCs1HF4xdQ1jMlvFzet55Dn5QEIkaESJEiBAhQoQIESJEiPgA8V8RNaEEQjIzAhw0ddgI54BOMApt/SS8Q06f/j3ChrcftkLaaaXUBtOAE/YhB5wjTtikTjil7MVih1/uILHBI3jn2OBmMmTIAP+oFX6JBVGlRzBKr6xuImr0I6R0I6T2kuHqw5O713FtdQ1hDeWl/F6JDXa6R9dvgKrHIHjpKDtNUHfxDjsmOualT3oY+03wyJ2ImYIIGQLCTkweqYt0csNBqU1iRyGRx97mZfjUTHZwrBYmeNzw64KI2SPYnFvG1bUtJOnYq+QdhUh3jlkid1M+F93jQZiJG2tACLwbM0XgkVE5ChfCVGZcxwFufaiE09hbXcdLzz6LH/3wR3/rUcPpW2++hRdfeAW5WBFBlVuIGRPR+xAxe7C3uIGd6WUUrUEUeAkOpUwMFR1xlFxJRKhdPl4uxf2rcmE8V8bexjpuXN7CZCaNsUAERReTJLzcxyMsCRr3ebCWjGEnG8MjtTSeny/hxeUanl+s4oWlKl5em8QzS+N45ZE9PLK9ihtLc7g5M44bE1XslfO4sTiDlx6/gbTTgelgVFh+lLcwIeRAyuyk1IksScHuxVqxhkogjLzTjaLTIxA0ZYcHRZsLJZIyfS5Z7Sg57XhiZx1X11fw9M3rmIwnUXZ76bxL8Lipev2oeHwou7wkdA+dz1t5yZMDGdM+UZMymAWypmB37JM1Hi+W83msVaoo+mksF1ZQCsdhHZSiFoliIhoVPG/yRhuyOjMyGiPSagPicg2iUpWQsiTlWqQUOqSZxKHjhEKLiFKLMH2OqAyIUv2PX7uON773hkDUsFfN61/9JnYXt4UlR16JCq4hOeyDclj6pLB0S2DpYW8YheARY+qWQd8hga59hNIRmOhaJZrEbLmKhMMH26Aaps5RGCkPH8csPmRdUXqGDNA3DwvLmZT1/ZBe6BHIGnO3SgiU7OMYPzIjzP0jGIul4BrVw9A2BG1TD1Iml7j0SYQIESJEiBAhQoQIESI+zHg/UVMMpRDnHYxkDjgHTLD16Sk1wDlkhmPYAueIjYxPCzyU+mRuMgjd8EldCMo9iCh8dJ9zP2ip3E7nSWR2eKWW/c9UJt/roHJ97GEzYkJM5RKImr2VLfhU+/FNQnofEtYQHt2+iulsmc45BK+VIJUVUFjgJsPTL6d0xEjlmMkgNsE1bBK8bgQZNsIlMSKgttO9TrrHgYDMRp9dSDviwtbOlUQJ17b3EDZ4ENa54ad8Xs1+YN2QOYxiLIerGzsox7LwcYwerQsBgx8pTxy1ZBEL1WlsTC9gbWoec6VJZD1puOVuBLUexI2hfQ8bas9koiDs/vTSc8/hRz/4r4mal198FeVkCUmdC2WrD2W7HxWHH1empvHY8iK2Mhksx5KY9JJONh8yZi8qvgRq0TwCdE9Y40DK6sEu5d1enMWT165gPEnXQ5Tf7RPitHA8lrLZhjmnA8seBzYTflwrxvDy8hhe25zBqxss0/jC2iReubSElx+7ikvL81ivlDEXCWEhHMZsKIilYh4vPvk4Ei4XCk43slYn8tZ9b5m804O8w42MxYaS14f1apXq5wC/nMfxt0QNH2d52ZHFTsd2jIVCeOHmTSyNjePZxx7DZDyFtMmKlMGIjMEs5MtRPvaeYSKmaHfun7OwR41d8KQRvGoMJtLHjrLPjw0qazaTJX1YTx+urW9jc3IOAZUBY4k01ienMBWNo+zyIG2wIKM3I60xICZXIzKqREymRpK9aZickaqRojQp1yCmVCNBesW0RqT0VKfJgZs7u/jed76Ld5ioofH81je+Q/PmCmIWJtGUCKrUCKl1NBd0sPQMwNw9CGvfKGz9cli6pfR5FKYuCYwdw9C3DaIcjGF1fJr0zKPgj8M+oEREY8MUzZFSIEXPoBbGthFo6vugutgLZX0vjF1S+GX8HBhg7VFA2zwITUM/SReW8lXIGnohO98J1YUOek4N+OnbP8Fvfi0GExYhQoQIESJEiBAhQoSIDyVuJWq2NraQCWXgkLmg7zFC2coxMgxkYJqgbtdC2qLCSLMc+l4DvDInfDIb3KMWuEYdZEBayRDm4LoeMizdCCqZsOEde1yUvudRI7XDM2KHa9iOiNKFiIIMboMfy7kx7C5twqWyI+YIIxvKYqY4iccu38RMeRouhRPmXhPMpJNDIIxMcLMMGffTETM8lLIHUGCERELHUjN8JF72MCADloPFpkxugRTi5UmL5RlhN6SsM4iiO4aMK4GwJYyYLYwkHcdJSvECrlKeq1t7WJpawCOXr+Dlp5/As4/cwN7aOqYKFaQ9Yfh0djgVVjiVNozF88C59RwAAIdYSURBVKiGSvDzVtLUD6vVGWpLBS88/Qx++P0f/i1RwzFq3n7rbbzy4pcwnR/HGOkxbnOgqDciq9Rj0h/A41ur+NoLz+DG6jqVGcNsMoPJaBzFcAjzlaqwm1HRG8BUIo4bW+tYn5nB8488islUCmmHHXmPGxkqk2O4zNvdWLfasO214UY1i+1iCo/OTeGxlQU8sbZMsoQnN5fx2PYyXnr+KTzzxGNCfJhywI+JYBBT4bCwFOmLTz8r1L1QKKLk86Pk9AiBfJkUyVityLvs2Jzg6xk6x14vViSMFiTMFqRsdhS8Pszncri6sIilUhGXF5fx1PVHMUdteeZRSjN5pITlTBwnRi94y+wTN5QaWWgchWM6R/lilEcga8xWoey9xUVMpzNI0nUmX7ImG3aWqI6bN3BpaQXz1QkaswDGqR+3xicEwiauMyKm1CI0IkdgSCqk7FGTUe170rDEZSqEVUokzUaa31pEKX9EoceNzR18+5vfxts/+YlA1Hz7G9/Fjd2bWOd4QfOz2FuYxe70DNZoDoTpHvvACCx9LFLYSJwDCrgGFfCNaOAelKMWiWG1Ng2HlNrlDqEaTuLm2jbN10n4VVa4BjQwNA9D3zIMXfMgnP0qeibU0LYNQN3UDXU9yfkeqOs6oTzfgk1qr6KlD9Jz7dDUdyEo0+Onb4lEjQgRIkSIECFChAgRIkR8aHErUbO5vgm/NYS+c6PoPDOEjlODGLowClmTHKNNMkia5ZC1q2HsM5HBaYZz0AjHgB6WXh2M3VrY6Ng5rBfIkaDCjhDHXJE74B42klGqpXwkPTrY+4xwD5kEcsU/YsFssoKnrj2OpcllPH7lcWzObWGhPINyqoDRHglGmiWQNEghJz1UrSqoSfQdVFa3Xghy7BzkmDqkS78evmEzCZM4BiqfdJEYyAg2ICK3CDsILRXHENJYMZEs4Mr6DgJaGxn5QWTtcSSsEZSCaYzFiyhHCpjI1LBHhvh4qQqH3oyxVA7T2SLGEjkhmG7GE0eaA+aaQwgwOWVwY2t6CTlPEgG1B1GDH7vza6hEU3jx6Wffi1Fz4FHzLt5++y289oUvYzxTRZRjvBhIR7MdYY2J6k9ge2EJu2triHp8SHg8VNY0dqYnsTExgTWSrZlprI2PY2t2CrsrS1io1fDSU09ieWwM0+kk5rMZLGYymA9EMGt2YtFix4LXiUu1IubzadTCYZRDYRQCARR8flRDQaxP1PDsk4/jkevXUAiFEDIaUPZ5MREOYiGbxZefex5LlapQ73gsuh8zxs5eLxZkjCZMx8O4ubFEZVGZNjtqvgAmEwkazxLWp6dweXEBV3gHRzperJRxfWMdlXQeIacHzzzyKJaLlX0CRqtHVK0Tlk3VAhzzZ3+JU0JnIGGPln2yhkmWpMmCsj+AZd7lMBJFwcU7TtkQZw8YrYH6cRGvvfQynqbyq5kcjZMFCYMJFbcXc9E4JnxBZHQmhEZk8A9KECAJDo0iQp9DwyRDcoSHlYioNBinPgpTuQGJguauCnvLW/j2698Rdn16+8038S06fmTvMSxUpqlvE0ha3fCrjPRcqGDvlcPSMQJz5wisPVKomvqgbR2AurkPBjqvbxtCwu7GfHUcmi4JTL2jKIeTmCmMwaE2wD6qFYgZxYUekj4oSdh7RtnQA/nFTvrcAeV5krp2KM620HEjticmhZg6HokM+qZOeh71eOett0WiRoQIESJEiBAhQoQIESI+rHg/URNxRaDsIGOwRYGRCyMYbRyFtHmUUgmlUsiaZZA3SqFpkUPfroSR8urbVdB1sveNErY+lUCOhFWO/UC7vMuSxARbvxa2QROs/UbY++jzgAFuGXtBZPDk7iN4+akXsbmwjUq8jJDBD6/aDuWQDA/feRjNR9vJcNXC2KeDvlsFbYcaBvps6d2PmeMcYm8bLez9BnhHTAIx45fohW2XfZT6qP7AqBm1YAqr1WlEdTbM5mvYW9+FYUANn9wmLM3iZVIJCxMWGYzFC2SEbwqGvZEMcxcZyjGjk8SDmMlPKUuQ8oeRMIUQ1nmQ9UTxyOYlVAIpIfBw0RvH7vwqCv4IXn72efzw+z/Au+/+8j2i5pd4++038dorX8FYtga3yoyc04v5TB75YATbCyvIBmMImh3QDI4g7nAg73FRHjcyVheylLcUCmO+WMSNrU1sLs5jdWYKrzz3DK5vblA7K1jIpDEZDKFisqGms6CqN6NgMmK1WMD65DimYglMJ9OoxeLIen2kpw/zpTwykTDsRj2iVgtyLicKTjvGg3Qtm8SXn39WIGrmMlms1yoouJ3I2ywoWc0omi3YnaZ+XZpGymJD0erAbCSGuWwGk+kUxnhJViSKij9A5XowReeXKiXoJAo4tRY8ce0GVstVgYSJa/SI642YSaZQ9viQZa8ZJli0RsTUdE1joHz73jW81Go2nSFdvEjzsiqbQ4hZE1WpBWLn2sYmHr18FelgGFUqL2I0IyxXI67UIK7SIK01IEt1RaQK+Kivvf1D8A0Mw9M7BGf3IMwtPTC2dAveO2O+IOy9EpjbB2HvkWB7fgPf/Pq38ZO338Kbb/4Y3/rmd3Bz91HELEG4ZEbImnoxcq4Dw6dboajrgux0B0ZPtWP0dDv6jjei+2i9IH0nmtF/ogk2qQrLk9PQ94xC0dgFp1wLZa8UPRdb4FGZoG7qx+DxJgwcbUbf4SYMn2jF8MlW9B+px8iJFgwda8DAkfMYPnoOoyfO4NLUFEIcc0enhXNwGD6ZBj99WyRqRIgQIUKECBEiRIgQIeJDi1uJmp3tbUzVxpH3RRBT2RCRWWAf0EDTJoGqWQZtu/JvRd2mgKadpI2OW5XQd+vhk7sQ1XnJSA8ibYsKMW1coxb4FDZYeOcouQM+lRe2YSty/iyubuwJnjR7azvYWtzAYPMI7KMmOEeNAlES8YTQdKYND3zqKDpOtsOntCDrCAq75TiGjcIW3z6FAx6FHfZBPdwjpvcCFDtJHAhQOSG5mYRj5JiwUKhioVhDQGHAfGkMV7auQD+shZvyuCUaIU+Q6ojq7RiPZ/D01WtI+4MIWm3wqnVCkNyslQPn2hE3MLmjJx10VK+O2m5EwR/C3tIiYgbS0+zGYr6MrekZaksCX3zhRfzgje/jl7/4BfX5b/Dur36Bn/zkTbz26lcwU5tBIRhHzu3FZCqJ527ewMrkJEJWOxIOD+wjCsR0FsGDhD0iYkorglRfyurCVDKFy6vLePzaHl55/ml87QsvC+RN2e1GxekSdlYqmm0oGswo6EzIGy2YT6ewOl5Fjj1eAiHMpNOYLfEyrxU8/8QNjOWycOp1wvKpiteNqtOJqsuFyXgUrz3/DBZKJZScbmxUq1gs5JAxGVG2mjHp8+DZK+t49vouVvIlqteKjM6AjMVCfWZGwmhC2rTvNZS3ubBG9+e9HtiUBgy29OPGpT2sV8eQYpJGqcZYIIiFdBZ5yp9VG/eD/lIbEkzUqHQ0R3XCsqvpSFzwqonTed6hiT1uIlo9wmo1YnoDNufncWVzB2G7BymHCwG5Ev73ljhFR5VCXBrf4Cg8/SNw9Q7B1tkHa3svHN3DsHUMwtDcA1l9K2ZjKUTVJqjquyGv64SuuRfr06t4/YCoeevH+Na3vovH9h6nOWml+WpG3OKB5FwbRo43QH66GZKTzRg41oTeww3oPVovSP/xRkEGKI95SIIra+uIGhww947QGPig6JRgsKEDcasbw6fp3kPn0H3vWZI69Nx3Dp13nUbr50+g485T9LkO7XcdR/8DpzFw6Ci2xscRkWsQUSgQ0WmRcXnwV++8g9/8WgwmLEKECBEiRIgQIUKECBEfStxK1Fza2cH8xCTWJ6YxncigQkZiVmuDd0QHY7sShnYVjJ1K6LpUULbJIWslaZZD2aKkVAl1hxIeuR1RcxD2UQtsEiu8SjecMrsQfybjTyHhjmEyO46VyWVkQymEbEHU0hVcXruErgtdcKnNmMlXsTG7DJ/Vg4GOYbSd60Xn2S5ETW5MxtMYi6bgV5nhV9gQ0nsQ0LkRoPL9UjOCJAm1E1GVlQxUE0IyA0JyI4KU/8rSKhaLFcTI4J/K5HB15zLMozqMhxOoeTyounhraRsKTifWxqq4vrGGOJ33msxwq9QouT2YCPowGfRjKhQUdiFK6C0IynXI2NzYmJwQliFlzA4qx4O16ji1JYtyOIxXX3pJiFHzy1/8Er/5za/3iZp33qR+/ypmxmewWJ3E9vQ0Li1M48XHrmNrbgbVeBxhuw0uqRJJvRVVjx8VdxA5ixdJoxMlX0ggTa5vbeDGzhamSwW8/PRTmMlkkDNZUDCahR2Q8jY7cnoT8jojpWbMppK4vDAreMoUHU6UqV2VUAArExUsjpeRDQRgU6kQIsO+YLWgSvfzltfVgB+vPvMUVspVlB1ujAWDuLa4gKVcBsu5FK7PT+CR7QWMZxLI2alMDv5rtZK+FmRMJqT0BiS1JKRH0eXBcr6ABPWtVaaGQarGY9euYofmn7B1tsOOm0tLqDi9yGlMyCj1SLBnCElCqRO2zmaihgMLs/cNe9dwgOGM2SYsawrr9DRHVIhRvauzc7i8sQ270gDHiBT+IQl8fRL4+0YpHYGraxCOjn5YO/pgbu+FhVJjazfMNPdsnSMwdgzQnLZjvVij434ozrdBdqYZygvtWBlfeI+oeRtvv/Umvv2t7+GJ60/Dr3ZA2dCNrN2PiMYKbX0X5KeYqGmEpK4Vsosd0DT1QN3YhZHTjSRNGD7VCBvpd3NrCwmzE+5RJfKeIKTNg5C39aPgC2PoZD1GjlzEwP1nMMBkzP1n0X/fWXTfdQqdd59C732n0fK5Q5QeR/9Dx7AxMY6ATIWoUgH78ACuLS+L23OLECFChAgRIkSIECFCxIcZ7ydqJnNFIaDr1ZVlzKVSKJDBGJKZ4OjXwT6gh21YD/OIEXaZHTapA9IWOeStcmFZlLJDAU2fGkbKY5NaYBmxkOFphXnYBJeGjPZ4ActTC9icX8V4toKQzQ+n1oZMIIGZ8gRUA1Kszy5ge3kNIXcQTqML0n4lzCo33FofVqtzuLK4hOl0FvPZIuJGN+IWP3LuGCIqK8IyA2JkjJd4+2ajGeNuLwomCyrCls1+PHv5KrbHplC2eTBfzOPG3p6wrGQyHMNCJIjpkB+TET+qATeurMxhbXoCMQfVbbDAo9IJsU+YoJmLRrCSSWMukcCYP4i0xY5qMIQbayuYyWUFj5uc1YPlSg3FcBDlcAivvfwifviD9xM1b+ErX/46pqrT8GosqEYi2FmYxqOXN7E0VhHiuXBsGrdcSXVYUfJ6sF4bw1qpKshyoSTEqrlxaQtPXt3D2tQkXnjicUyn0gIhklJzoF0LxkMhpA1mZLVGZLR6TEbDuLo4j5LHS3rakDbRNYcdC6U8lipFRKnv7FSnR65ASqdF3mDAuMuFis+LLz79JC5NTWM2FMN0OIqlXA4rpSKKfjce3ZzHxmwFE9Q36s4eIfBvicot2W3Im81Ic3wZtU6IK8OBiKt+H0JqDexMungDeOLmNVxdmBOCEG9NT2FrfJLG0YaYVIXIsAwRiXx/RyaVXvCqSVAa4y2z6VzOaCV9aBwzWSzk8kJA5Rz1V9LpxNWtS9ha2RQ8dxwDEri7+0mG4OoehLNrELaOfphau2Fs64G9ZwjWzj4YWrugb+mFub0P+o4+rNQmaQycGK1rgPTMRega2mDtGsD65CJe/9q38JO3f4KfvPk2vvOt7+HJR55GRO+Gsakf5s5hlNwharMV+uZe2AdHEaGxyDt9yFlc9GyphdgxmottUF9sR0ClxWP0HEb1ZmG3qJI/AnnbEIyDKprnYSjPd0JxohGSh85i+NAZDD94BgP3nUbP3cfRfe8JQZo+cz+67j6C7geOYmN8nMoyIaLVwK+S4cr8LH7x85/jP4tEjQgRIkSIECFChAgRIkR8OHErUcPbc+cjSURNTownUpglg7cUipLBG8J4MoflsWksj89gOj+BfDADv84DdbcChgEd9H1aaPo0kHbJoOijc4N6GAcMdF5H1/XQ02en1oNsOI9iLI+F2jR2llZxfWcX44UyJkpV7G3sYGNxBR4yYB0GJxx6D6RU5miPhu43wq+xYXNiCo+sr2M+n8PuzAyW6b6C2y8QEXmjCVMeL1ZjUSzHI1jPZ7CQiGIhGcVKLotHljcwG88J219z0Nwnb94QiJqc3Y1xtxs1nwfjkSAmokFc31rGVD6LmN1FepvhVuqRtjpRcfv2vTwsDiSoziRJLRDEXCqDnalpJChPVGdB3GjDXKmCiNWKUiCAV55/Fj/4/vfxy1/+Er95b+nTO++8ha9++RuYqc3CLTcgaXdiY3YS04UM5gt5TCXTSFB9Xq0O62Ok7+4mntjZwkq5hJo/gCrJ1uQkLq8s4+b2Ji4tzAvbZ08kEoiQwS94naj1KLmoXf4QskYLMgYD0k4L8gEfgjoDAlIZMnqjILOJJFYqNYQ0BlhHZXCOjCKpUiKlUiBvMWE6FccXn30CG5M1xHU6xA1aVINebE2NY3ViTCCZMgEX5itleJRqIdBw2migeqlOHZMqKgRH5PDLlMi5XEjS+Sr1nVtjRDGexFVq23PXr2JjagKPX76MWiiGqFIH39Ao/IMjCA5JEZYoEGOvGoGo0ZFulFI7o1IVAqMKRLV6ZKne8XgcczR/F8pVrM0tYXVhFQ61Cd4RBUKDVN6ABN4+jkczAnffMBy9vG32AHwKJeJmM8qBEI1pFhuVKibjCazR3HeS7oMnz0J5rgGGxlY4+gexR3OKPWrefusnePvNn+CN77yBpx9/FnlnBO6uEZiaemGjtOgMYCpeRNEXRdbmp/pkMLX3Qt/UAWNTJ0zNXTCQBFQaPLG7C69cjbCG2uLyQ95B+smp/5NlGFqGMfTQOfTfexx9d5HcfRy9dx1D9x1H0X3PcfTcdxKNt92PrruOoufBE9iojaESDCBjt2Ehl0TOacNf//Sn+M1vxKVPIkSIECFChAgRIkSIEPGhxK1EzdbmJmIePxnpSjhlKjK4ayjE0ihHMlifmEElkkLSFYJdaYFZYoB5yADHqAUeuQ1ehR2mIR20QxroJDqo+tTQDxpgGjbBOKSHuk8Dl8aLmDMDnzECm8oGOxnOHqMZEbsTbq0JdoUBTrUZTq0dVoUVdpUD8h6lIF6NHQGNCdVwBLvzs3hscxVX5qfw1PY6ZlIxTIXJEPa6sBAIYDEcwko2iZ2pGm6uLeLRtWXsTE8h64sgbHQha/VhfXICLz/1JPxGB+ImO9JGCxnTboz5A2SgJ3GNyi+FowjqSA/S0zKsRFBlQERtRExrQZLuKfvC2JqYwuPUb+uTkyhEU7DL9Qip6brVhfFUhnTWkpHswItPP4nvM1Hz7rvU5wcxat7C1776DcyNz8EtY++JINYmx1EJBbFaqqAWjiNkc1O/qJH2eFAK+TGdTgneKLzEh7etXsjmBO+TXd5NaW0FLz/zFKbSaURVWkTJ2I8oNcLuSRPUbyWfD+WAF3OlLOJu6tuubqEu3tWJY8hwvJuV6jj8aj1MIzKo27sQlEgRk8mR1moxEQ3jKy8/ixvba1grF3FtYQaPrM5RP49hMpOFXipHwGrBYq0Gn1Il9GeFl4dpdELg3hjNKfaI4a2w2cMpQnn81DaXUkdzSo2rWxt44dFHcJnaUYjGaV6pEab7/CNyhCQKhEZJKGWy52AbbSZuOGXxDkoQkvLuTFoaIxorXg4VjCAbT+LK9i48OotA1ITpXl//CBydA7C29cFKqam9D+5hKWq+EMbpnhLpl7I5EFBr4FGoYBiQYLSxFd1HTkBZdxGWlnYESf9Hd6/im9/4Dt5++x2BrPn+d76P5554HnlPRIh3Y2rohKtrGHGaMxr6rOvsg47Oaepaob7QAkVdA0ZPnYf01AWMnrwAU08/nty9jCCNWZSDKafzsEp1kLcPQ9sjRfexBvQdPof+B05ikL1pDp2h41PovfcE+u8/TXIKrXcdxtCx8+g/egZLxQLmaM6EtToUaA5xmT99W9yeW4QIESJEiBAhQoQIESI+tPhtj5pNlBIxFLxOFMmgT/qCMCr0yASiSDidCOhM8KotZDiq4ZDrYR3WwDGsE3ZVCslt8MmtsMlMsKvtMEnNMI2a4VQ54FTb4NY5ELL6hV2d5srzQnyauCeAOBnyXp0egw2tMA4o4dM64NHYYZeb4Kb79P1kiNO9NfbsIR3m0gnMZ5JCXJS1Qh7XFmfx9JVtrFeLmAmTke3xYiGVwpWFWTy5dwlXlheEYLkZMry7GzvRfbFL2NlprljEF595GilPEAVfBH65FlGNEXkL1ZHMYHd5BSGDA36VDQ7SQ9M1Cmu/TNhueTKewXqNt8mexlw2jyIZwPlACPIBGVrPtAj9UnAFMR5NIKLhYLp2vPQeUfML9qj5zW/w7rvsUfM2vv6117EwNQ+/2oS5TE6IL5O2UnvDMUznSjQGEWjY+0NN+mn1qARDwtKqIC8HUmhR8wexUuIlUOO4srGGl595EtNURkihFoiaqEqHsEqDvNuD9akJ3NhaRSURglkyhJ4zdRiLRXBlcR7r4zVszk5jeWwcHqUeRokK3acbYekcgW9AirhchaLdjteo/NdeeAbXFhYwHYui5OQtstXwUH0d51ugH5VTObMIazVIGYyoun1CgN/AsBSBwVGEhmSIy/bjzHiHJXBJ5HDKdXAolHjyyh6e2rtCY1NCgNrI8Vp8MjncQ6Nw9o3A2T9M6ZBAgHj7eFemYbh7huAWdmcagKmtCy7Kw8IeMrb+USTcftSovMeu3YBHa4alqx+ujn7YO/uhbezB6JlWqBv3t8ceONUMXesArLzTU0c3TMLypw5o2zqh7OhD37mL6Dl2CvLT52Cj8zwfr+1cxjdf/zbeeusdkp/gB9/5Pl548gWkHPTstPbATHOOd45Kmq2QNLVCfqEJ8hMXoDh6AcrT9ZCdvoihY2fRf/gk+h8+AX1nN566vIepWJLusaAcjMAwqETf+Q6MkL5n7jqCnpMXMXC0DqOnGtF1+Ax6j9Sh79BZ9NzPMWpOof3BE1CTfta+PqxUCsg7XVA0tEPW2AG/0oh33n4bvxaJGhEiRIgQIUKECBEiRIj4cOJWomZncxNVMr7zVhN2ZicQc7thVWuhkwwjoFULQXbZU8EnU8E9oiQDmozsHgksrbyF8SCcvXLY+hRwK0zwaWxIWoMYi/AynipqiRyms0U6LuHaygry4RDiHi9CVgesChUU3X2wjKhR9MUFbwSf1gq3xgoTnQsb7Kj4gkgYDKh6XJgKBjAVCGI2Esd6uYpLS7PwG/UoeQK4OjuH3elprI3VMF8qYqFQwFg0jownDCNvl9w3itlSFY/vXcZrzz+LYiiGyURe2OkpojIhpjZjiomYmUV4dS7YZWY4qC3WYS2CKgvGoxlUggkkzG64JGo4h6TUDxIUvSF49E701vchH0xhOlMUzsV0VmEHnxeefBpvvPE9/OIXv9iPUfPuu/jpT9/B1772OhapLuuoGmXS0SczwEb9mrA7BcJjPFeCTamjzy6BlJlOpJCzuhCm/CmlATXe0judwer4OG5sb+ELzz2NWWpzVKlFnMknuVrYVnoqlcKTe7sCMRPV6+CRy2Dq7kVYqUbWYkXV68OlmWlcXVtH0OSAWWFE79kOqC72wdExCF/PoBBf5pUnn8AzN64jqbcgNKpClOZCYITmAemsH5AhH4/iib0tarcaAckowlK5sPtTcGQUvv4h+AeG97e+7h+GvasPZjrnUBthUyjxyKVtPLV7GUmzHS65HtruAbglUrgGR+DmJUp0n6O3H27SxcPxZdr74ezop/nXIywb4iDAvGOTs2cI5uZe6Bq7qd88AlHzxPWbNKfMsHZR/pYuyOqa0fnQOfQdrYfkTAvkF3rQ8cAF9B6uh+x8K9QNrTA3kbR0YKSuHr0Xm6HtHYKmvQtDx09BW9eAuNaItelZfP2rX8dbb76Nt956C9//zvfw8jMvIu2OwdAyAMOFNrj6hhClMdB09EJ+vhnSk+cRHVYgSvNHeorqO9MAGZ1TnDoHS28vnt7dQ5b0Nnb3wEX9q+mTovdcO4bquzBwvgUOqRo6aqO6uQcNdx9B17EL6HmoDq13H0fjnUfRfOg4AjT+6rZOmgtZTIYTGD7djJ7TTVC2DeLtH7+JX//qV+99A/zjIRI1IkSIECFChAgRIkSIEPEB4v0eNTmvF1GVAnsL03Bq1HAb9Eh4bGT4yeDpI8OajFfl+UYy4FsFA1l3oQUWMopNZBTrGzphau2Fe1iOlNGGqEIP35ACIbUZdqkOBX8URSZYCmlMZNMIWpzQDcqhGRrBUGsHzCMqVEJJTCQyiNm8CBo9sMmNqMayqIXiwtbYWYsNRYcHs+EUKp4IJqIprEyNoRSLwS3XoOj0oewOouAMouKPY7k8Rm0KIkN5HVoHfFY35ipVvPL0U/jSC89iOl9A1hNEwuSEm+r3jqoxmy1hoTIJn94Fh9IKp96BlCuMjCOEkN5J4kJY54RTooVtQArPqBIZNxM1LpglJswUJnB9fQu1eAJFfwQFXxxfePpFfP9738Pf/Pzn+PWvf4V33/0l3nnnJ/j611/H8twK9ENKeKVa+Ee1VJ4ak6kM9tbWUMsVYJKq4BpVIaUzIWUwIKnh+DMqMvRlyOqMGPcHsVyt4calHXzhuWcwlctSv0vhHxgVlghF1DphR6ntuRl4JKOwdHZD09GBvtNnYOrogm94FH4qaywcwQKVw7swWVVGyFoHaTwH4ewcEIiRlN6MLz71FF564nFEVAbYu4aE7ast7ZSvSwJzvwJ+vRE3N1Yw5vcgIJGSHhKERuXC0qcIfQ4PS0inYYG48dO4W/r74FTrYRiW4sr6Gp7a3YVbooBpQA55Ry+cUhks3T2CB42rfxD23j7YugZhJr00F/ugvNANdUMPlPU9wm5KapqHxpZe6C+007zsgZvaUs3n8djNmzQ+Fhg7+2Fuobna3Ac9z9n6dmhpLqvrO6isDijOt2Po+Hma483QNbVQvnaomjogbe+DjIMNU1vk9U10vhO23hHMlWr46pe/KhA1bzNR893v4ovPvYycPwGD8Hw0ICAdpTHQCkQNl8WBiM0NrTA1UDmU6i60wnixHfpzTXANDOK5y3s0twNw0Zi0HzmNvosdGKA2Str6YOgfgaqjB2ma50Onm9Bwx1Ec/9R9aLzzGNrvO43zn30YjYeOQNLQjOOfuQvVZBLTyTz6jjeg6dAZ9Jxpxps//DF+9a5I1IgQIUKECBEiRIgQIULEhxK/FaNmYwMppwsZixFrYyWYhobgNxuxXCvANzoMX18fXF1dcPQMwN0vEZabWMiQ9fcOk6HZAt35RlhbO2Fua0eADHJ7RzccXX2IkfGu6eom49KJUjiI+WoBO4vzqEXTSDsCsJERL+nshV9rRZYM0Go4hvFEASGTH8YRPbwGpxAfpxaJYSIex1gkgrI3gLzLj7lsicqaE+KiBNRGZBxO1EJh5MjQzXmjKEeTmMoWUEvk4TO5kfRGUImmcGlhEV9/5WUsjI0j5Qqg4AnDrzAgS/pUqa5iOIm4I4SYI4wwXSvFc1goTyHliQoEUpgkqHXALTXALTMIeb1mD/QDGjgVFsGDaIF0ClucdC2ALzzzEt747hv4+c8OiJq/Ebbn/sY3vonl+TUYpXoE1bzVtxZVX4h08mBjbg6VbE5YhmTukSIq1SCmUCCu5LgswwjS+MTkSmQ5Vk2xhEf2LgtBi6fzOSFeixAwd2AEs7EkJtMpTJBYaeys3X0wDgxi8MJFGGmM7N39wpKiij+E1YkpOJU6WBVaqDo4EG6/sH21q3cERbcPrzzzNF556imEVXpYOodgbh2AuX0Yph4ZzP0qGAfl2FlYwM21JaRNJtiobAuNrZ29Y3oH4CE58Khx9vTDMTQAv84kLKdjoubZ69fhoj4wDsqgl8io7+xwUFttpIuZytG1d0Nyrg39J9vQeO95XLznLLqOt6Lt4UY0PHAO3SdaIL/YA31jJxwdA3BJlIh4PLh6+TLcBhsUzT1QnGuBgVJn76hA6sjrWoSdnXRtHVA1tEBd3ybkGblQD79UBVPXEM3fEYy29cFOczVssmCorgHWQSVqmRK+9OqX94MJv/UWfvDd7+LV57+AUigLXWs/dM2dNK566h8JpC09MFE/qxpaoahrxPDZ89T/g5Cea0fvkfOkdxPNKz2euXEV06kMvDI1Gu45guaj5yCl+rXDMvi0etipX4z9I+g+XIf6zz6M4x+/Bw13HkPPw+dx+pP34MTtd2Kovhmtx06jEItitlBG39kWtFEdA2db8eYPfyQSNSJEiBAhQoQIESJEiBDxYcVvLX3a2kIpHMZSLo1C0A1ddzdCViuWq0XYB8iYJ/FLR4UlSAWnS9gxKK3WIEaGo7O9C5amFnh7+xGVKZAxmYWdgUIcH8Xlhl+thF9Ohm04gs25KWxMVBHT6amM/UCtw2TEjtZ3IUjGKcfzmMlWEbSFoZMYhCVF1UQOc8UK0i4P0nb2aDFjPJrGzvQ8rmysYG1qCkmbGxOJpOBdErN7ELEGMJ6rYHFsCiGLBy6dHfphHWwjBozFcvj6F1/F4vgMMr44Mq4ILANklA9qoO2RIWLywkx5LTIjwv4osrEMlqbm4dZZ4VaaESSdXFIDzH0qMqh5q3ILXAYXNENqaPvUMPRrEDR7UAin4De58MKTz/02UfOrn+Odn/4Yr7/+OlaXNqEcVMOnc1K5NiQdXpioT2dKZeSiceiGlZA09EDbNgi3TAPniALWriG4+0fhG5EiKFUKW5Y/89ij+MoXXsI69UVUoRG8aTxk0Fd9QQR4i+1MWui7BHuW9A9h8NwFmHi5UDeVOzSKlNWBS3OLiNmccGp00HR2w94zAHsXX5dgLBrBq88/iy8+9TSNnRnW3iHBa8Taw54xMlip7fp+qVD/WDSAuVgYEZkczu4+OEhsXUzqDEBHY61q6oKqsVsIrusnfXTDCmwuLuGpm49B1iWBvHsUkg6abwYzdKSDpVeCwTPNkFzsQvuxBrQcrsfQhS6MNvWi5Ugjzt13AV2n23HmrlNofbgB6rY+uAaVULcPwq4xY3N5AwGTB7KmPkjOtcI1LIdtQInBky2QnWuHvrMHOprDsotNGL3QBFVrF5w0j43dQxg624LRln6oB2QwKzXwGs2Qd/QIAaZ5x7LXXn0Fb775I7z91pv4wfe+hy+98ArKkTzswxqqvx9WmY7Grx9SJm6o3zX0jAw3tgtLu0ZIl5HzbfSsDUHZ3gaPQY0nb1xFJZoQ+qb+jgfQcfI8ZDRGMia8ZDKo6bkcrG+E5MxFNHz2ARz52O1ovfc4+o+fR8d9x9F7uh5Hb7sLpz53J0rREBbKZYw2dwskzfDZNpGoESFChAgRIkSIECFChIgPM24lai5tb2O6UMDmeA1+ow4RswVhu12I9aLvboejvw+B0WGEFApU/X4kyfiPyRVwkdHq7+mH5OhJqC82Qk9GLm9RPZ3MYiKeQtkbhK65DQYyhBcKRWzOz2BncgIVtx9RvRUBgxXqXjka7j0LDRnvbokSM9kyws4oTHITAhoLgjoTlspVBDUmIaivZUCOnCuEa8tr2FqcxebSAqZzFWRsIXg1NmR8UbjVZqxM07XFVcRcEdg0djL+R6FsG0U+lMBXv/AKipRGLD4EDR5YhrRQ0HVp4wDcKhtkbcOQdYzA6/Aj4PBhb/0SHCoztL1ksEv1GLzQDUXLMHxqJyTtEirfAYvSQga1DL3n+9B5vgcmqRF+swfPPPIkvvft7+BnP/tr/PrX7+Ldd38ueNS8/vq3BKLGorYhZPMjH0gIO2u51UbkwlFEfdR3Ei36G3uh6JQg5giSTsPQ96ugaB2CvKEL2o5BRFxePPP4Y3jtpRexWB2HvmsAxo4BKFs6qS0GjJKRX6SxmMtV4RrVwSXTQd01CF3nEPWnFM5RFXL+EK4sryJqtcOtM0Ld2Q9L9whsvRK4R+TIe3340ksv4LXnnhGWoUVVGnhGJAjJ1HCN8E5hHMfHgMsLi8g73HSsRlSthYWXDZ1vQ/PD59F1th0txy9S2oYLD55D55kW6jcTBjv6MV0Zx5M3nkBPfT/kPXK01bWj53w3+s91wiU3outkE3pOt8A6qsVQYwdU3YPQ9I6gm/K1HGvGYEMf9ZsdhiEVvFozZK09aDp6Dl6LB5c2dhCxB2GX6KDpGIJlWI6+M23oPd6M/qMX0Xe8DrILbTD20vw2meE26GjsZKg/dBKn7zoKWbcUij4ZNHSfemAIQ/U0z7sHMJHL44tfeBk/+tEP8NaPf4wffO8NvPria6glawjqHRht6oKhV4qhujZIm3uhpOdE0dMNm1YDy4gMXYdPQtvSDWVzJzQtrch5HHjh0etYLJTRceQMOg6dRs+pizT+7Rim9rScqkNP3Xkc++Rf4vxtd+LYn3waD/3hp9B8z1Gc+9x96KP2PvzHn8ahP/ok7v2PfwK/QY+lsQmM0nM1QjoM14keNSJEiBAhQoQIESJEiBDxocatRM3upR0sjI9ha3oS09kMcm4fAmS0zhVzsA31wNrZCU9vDxnmMkzH4mSMO8gIb4eLxNdBaWsrbK3tsHb3wzYgQcrmRMblg6VvBKbWTujaOjGTzeHq5hrWazWEFFoqVwaP1gjTqB5n7zwBTXO3EKx4LJFCxBWAXqImQ3dY2FVoOp1DQK6HrUcKc5cERVcYU6kM1uYmcXV3G+VYCrZBNTTdo/CS8V+LJjFH9axMz8OutsFKMtI+QgbzEArRNL7y8itCvJm8LwW/zgl9n5yMfykZ131CbJzRtgGoe2XwOwMIkVzd2IW0cxjaXjmk3SPQUn6n1ICA3gkF5bPrHFD0K9HX0IeWk2QUt0kFryCv0YNnH30K3//Od/Dzn/8VfvXrX+KXv+SlT2/hG69/C5trl6Ac1iDiDKEczcE0ooFdrsNYOo8MtcFEugw3D2C0dUDYKnykYxA99V2QtA1D1TEKRecI7CYrHrt5A88/+wxmK+PUhn5ou2QYrO9Gb0M3Ouo7kEtkUY7noOIdrKR6wVNnuLEXyo4RKqsfLqMVq5MzMA5Tu3QWDJFx33+2HV0nGjB0oR0xqxuvvfQSvvTCC4hQ/7KYe4ZhaB+AtnMQDhUvy1Fgc2YOpoFRGPpG0XemGa0PnKWxPYmHP3sCR+85g/6WAZx/+ALOPnAOLScaYdGY0d/Zj2qhjKceeYraNgBJlxwnH2rAnZ84jBN3noGc2qjsGUHbqXrSneaNTIeAcX9ZmUdrh4bGwjyiw0hzP7rZS6WlB+ruIXTWNSHiCeHRG48g6g5D1j4EWWs/Os82ovlwHToOX0Dng5QeOoume07g/F0Po+9CE4ba2qEbGMLwxXb0nGmFnsbHKNXBa7AJXjGDF+px4e4HkPT48IWXXhSImjd//GMhDtFrL72GSqoi7NbUcuQshjnuzbk2KGjcmo6fQVfdOagGB9F+og7dh09D09SN1vuPo+/ISSFo9xNXL2F9bBIX7z6G+//wNtTffZLuaUP3xQ40nrqAthPncOiPPoETTNJ85M9w/KN/ifrP3Ifzt9+DxjsfwJGPfhz3/v5H8fCffAJxuw3r07PQtA1Bcq4Dg2db8OYPRKJGhAgRIkSIECFChAgRIj60+C2Pmp0dzI3VMJVOIGUywjOigFOpxVwhC8tAF6wdnQiQgRknY3I8HEHZF0BSb0RSR0bzqESII+Ltk8DZ1Qtbdw8SFjPiNqfg1cHxP5wjo6jEYrhxaQur1TIc/YOw8jbKUhmcGgt669oRUGgQN5pQi8fhtzqgIx1G61vhkMkxlkrBOjAKe48ExvYBRLUWJG0OXFlfxhM3rmCuVIJHqoF1UAqvXCNcG89lsTw5DYfKCCcZ9AYyuM1DKhRiSXz55Vfg09hR8FG5UgMZ9hLoBhUYbuqBfkQFCdURtvgQ8Ubgtbixs7KFnottkLUNoLuhA5KWXmi6hhAg490k08Kus8Eg10Pdr4C0dQSDDQMwSU0CiXNz9xre+Pa38bOf/xTv/upv8Iv3PGq+8fo3sbW+C8WQBjFPDCFbAG0nmyDvGkY1nUcunoRFbsDA+U5oO0eQdAdhlqphkemgG1Ci51Qb9VsHfA4vnnjsUbzw/HOYqYxD0jSA/jPdaD7ciHMPnkf7+XbkEhlkogloBuRwqkwwjKowxFtUtwxgpG0QWip3YWIKsp4R2PU2dF9oR/eZdgzX92LgYqdAHr387LP48he+CK+KlyRxrBQVlK1U18V2OPQW6Knv12cXELV7oOmV48J953Dh3nM4/pkTOHnXeZx7qF4gHBTU14NU7uDFLuo3M4Z6BlAtlPDS08/TGGmhHdah7mgL7r3tOA5//iSajl6EqlcCbb9MIFs6T7ZQuzsxTPobh+RC/exx03G0EW2HG9D2cAP6Trdg4EIrgjQHb+5dQcwdojq7MNLQicHGDshaeyE534a2+6j8e46h9f4T6Hr4DHqP16H7+GkY2jvRcu9hXLzrMNSdQ9TfEhgGRtB5/BSk9c04e9chKtuNl154AT9kouZHP8T3vvk6Xn3uBWQCcZor7bjrT2/DvR+7HYc/eQ8GmvpQ9+AJdJyoQ+PDx6jcQ2i680F03X8MLXc8hLa7D6HnzBnsrC5iZWwc/acv4vRf3o3WQyfR39COgeZu9DW2o+WhEzj6xx9H3Z99Cmc/9gmc+4vPoO7jd+D4n9+OU5/8LI7QuYc/+hc4+iefhl06is3pGQycaYb0QhcG6njpkxhMWIQIESJEiBAhQoQIESI+tPhtomYbk8UC0lYTnELQ4GFYZBosVSuImbQIktGXM2gQkI8g43Ii6/TA2NkDn0yGgFoN28Ao9K190F7gXXGaUQkEUEukIGtqR/+ZOniVKsSdLsxP1rA6VoJroI/q6IddIoVbZ4OJDPSs1QlDVzcKgSACNhf0wzKMnL1A98oxlUvD2DsAfXsvzL3DSJocSFoduL65Rob4NmYLOdJFAc+oTFhmNRGOYbpYxMbMDHx6E9xaGzR9EmqLFcVEHF/6wkuIkBFfjqTg19vglBsw0tYLh1xPRnEnTFINTBIt/A4/HHR9d20LHipH3TOIo3c/jN7zHYLR71IZoB/VwGV0oI/jr/TK0FfXgf66LpgHdDD0q/Do7nV891vfwl//7B388t2f4Re//Cv85J0f43Uy7Lc3dqGW6JEKZOAxetFwpB6SjiH4rC6kY3FYlUYqrw2jF/frMo+qIWnpQ8/ZNnQfaUb38VZ4zC48++STePnFF7A4Po3hi10YPNNB1zrQ+HADBpp6UE7nEA+GoOkfhU2mhYH61qM2wTaqxWBjL4xKLRYmJiHpHIBdb0VfI5VPBr62ZxSDF9sQs7vw/NNP4ktf/CKs1EdMbnWfaYWqfRjq3lF4LE5KR7A0OQM/9cXFB8/iwn11qLv7NM7dQ8f3nkf7CZobfSNQtHai9eGzGDnfDi+Nh3xoBJOVCr74zDMI6ixwqizopvbVP3Qex+44Cg31qay5D31UX9uRC2g+dB4tD11E7+kmWIfklDaj8b5TuPD5o2i5/xylp3D+s8eEZUNurRaXV1cQMjug7hhA94k6ND18FEMXmyC92IKOB0+i+Z4jGDp9FiW7A7rGZvQeegjKc+fQetf9OHf7PZC3dUPa2g55C/XJ0ZNouOsBPPjxO+CkefHCc8/h+298B29863W8/uorePHGDWTdQWHZ1f2U5zP//s/wmd/7M3Sda0Xr8QvoOXIW9Xfch477D6PtnvtR9/Hb0HHHg2j9zL0487k7sDgxhkkaq7aHT+LeP/xznL/zQQw0tKPvAs2B5jY0fv4OnPjIf8DFP/9j9N1/J85+/JO44/c+ijs+8mdofuAYuo6cQNu9h3Hu0/fAQ8/czuwc9F3DkDf2CeSaSNSIECFChAgRIkSIECFCxIcY/1WMmkoZGasFNl7G1DcMi1KH+bEaEnYT/FIJwtIhJPQKFDxuZB0ejNTVQ9fcjsCIHAoy7DtP1kHR0AFFcwcm0llkImEou7oxdPKcsONQwGjC+tIsNifLSBsNCKu0cMlV8BusULb0wNLRK3gy5H0BBGwemOU6mDo7UbJZMJ/LYDwaRsLqhLShBSmLFWmvFzd3t3Ftaw2zmTTMPT3QdXbD3D2MsiuE8VgaG9Nz8OrMghdJ66l66HuHMVMu4WtffEmIy7JYG8NUqYCUxwc/x6DpHMLwhRYENEbYZCoEHT7Y3iNqOChrx7HzOH3nw2g/dgFdZ5pgUWgh5+2jmahp6oZ11EB5mtB433noBjRQdktxY+cavvPt71Bf/0QgaX7+83fwox9/H1/75texuXUJKrpHN2qGakCLM/fXoetEM1xqI5LBIKykexvV03GsHkaJGha5Hr0nm9B9rBG9R5vQR8d20uHJGzfwxZdfxur0AnrPNqP/TCu6KA97mQzVd6BGxn8qmhTIKptMA3nvEGQdA8JuRB3HLyBodmF1bgEDbV0wydUYbevBwLlW6o9hmAckKIZC+MJzT+LLr74Mv8WJkdZ+dJ1qwkh9O+RdvQgyyTE0gqXxSerLAIbPN0N2sRWyhnaaJx1ovu8cRusakTZoYe7qgLa+CQreWUmnhUOpwvr0NF5+4gn4jVb4zA4MNHaj5eh5yNoGoe+RofPoRfSfbhZ2MGo/dhFND5xGy6GTsA7I0Xn4AuppTNoOHcMQ9VX9XadR97nDuHj/Ebi1Gjy6s4m01Q5ZfQuk9a3oOHIaXcdPofvIUeibWqG52AjpmZNwdLfA29MB6dEjGDh0CO333Iv2u++HuqWT5lwzBurOoun+w3joY5/Cx//1f4BhRCUEQP7WV78skDRfe+E5PHt5D6VQEifuOo7P/uGncO9HP4H7//jPqK8uoPnwGZz9yztw7E/+Am2f/yya//ITuPAnf4TWT34S5z72cRz5sz/FTDqB8UgcdZ+9H3d/hImaQxg834SBEycgOXoXuj7zR+j42L/BwF9S/cfvQutn/gKf/de/h9v+zUdJ/hCf/3f/Eff8/sdwP9Uto2dhZ24OmuYuSM+30bw6jx+LMWpEiBAhQoQIESJEiBAh4sOL9xM1M7UqEmYjjI2NMJDxbVVrsTBeQT7oRtJiQ9HlQtxsEDxq0lYHhk6fwzAZoNJT9WQg16PrzEV4lWZYRpRI+UKI+4IYvNiMXjJutefPI6xT4srmAlbG8giolJjPFlAMRuHTW6Fu7YaprQv6tg7k/QF4TQ5YFXqoGhoRkUoxl0oJZIxNqsLAmQsIKhUI22149OourmytoxaPQdncClVbJxyDCiQNbgS0ViyPT8Gm0gk7Nqn6RoWAsdO5HL75pVcxlc1hbXoa8+NVRKxWaNp6IL/YBsm5BnilSoR0RrgNFujlKtJ7AzIqv+f4GbQ+eBR9ZPRyDBKnzgxFzxCcGhMGLrTATMcjpF/vkTMwjaqF3YKu7ezhm6+/jrff/jH+6q/fwre+9RW88sUX8eqXvoi11U10t0twx6eP4LMfP4TPfOxeNB+ph1NrQiIcgt1gRg+Vy8SHQ62GUSqn9jNRcxEdRy6gn45dGh0ev3EVr7z4HLbnF9BH+g/WNaGLg+SSkW4elmKc2pxLp6EblsEq10LRN4Kec02QNLdjpKEdHmrHyuwcOuubYFaoMNTSjn66PkBjq6N+iZlNeP7Ra/jyF16gfndjqJGXEXWhh8Zc2d0Lt4nGne5bmZig8fPC1NoCR0cHDM0dkJ3vQst9Z2l8OxHXyOEa6Ibh3Amoj94FT9tpmDsbUUtE8IWnn4aPxl0nVaP7QgcaHj4Lbc8I9H0SDJ9jYuoEjJ2dGDh5Bg33HELTQ8cga+1C20On0XLXg+g/cgwj5y6i7o7DOPTp+3Dkjgdo7NXYnptGwqSH7OIFml/tGDp+CgMPH0L//Xch0Efzpb0Z+ounYWo8BUfrBYwcug/td34WzZ/7JAbu/zx09WdgaDqP0VMPofeBh9Bw2+dx8lN/CbtMgWub23j5mafw4uOP4IndLVxeXETKE8ZDf/kA7vmTT6PlENVz/DDVXY/h02fQe+/nMXDP7ZA9cBtG7vgz9H/6DzF0+8fQ/5mPoeW2P0bOKEPJakTr5+7CkT/6UzTdfR/Nx9Poue8T6PrUv0HbR/8l2j7yz9H8B/8MDR/5Fzj/R/8WD/+HP8A9v/+HuOvf/j4e+Le/hwf+3R/goY/+OfrP12GtUoSuoQHDJ06i59gJ/PgHP8Cv3n33vW+AfzxEokaECBEiRIgQIUKECBEiPkDcStTsbG9jrFiARymD9sIFMs67YFWqMVfNI2TRwyFXw6nQIu10YSwaRdpmh7qpFYPH6tD/0Cn0HjmNjodPQtbQAfOwTNg1J+FyQdXcjJHDh6A4cR+8I+3YW53BbCmDnMeDvDeIQjgBt8EGVUc/NE3tUDY2oRQKImCxCwFqFRcb4OjuRTUQorqdUHYNYKSuETG1Flm/H49c2cXuxioyQT96jp+EtbcP2qYOKoe3WNZidXIaUacbfqMdhsFRGDp6BCLoG6++grTHTboUsTwxgbTbAy/pPEBljJw+C3vfoEDWGAaHoR7owSNbS3AM9aH/2FH0PXwEI8fPUFtbEXN4oOkZhFutE5Zt2Tqb4Oy4CDulMbMZAbMFN3Z38dWvfAlvfPfb+NpXv4hHbl7Gq198Hs898wQ2llfR3dSH//hv/gIf/YPb8YmPfhYdp6l9bi9SsSi8VIa0qRmq+ovIuF1wqjXQdwyi9UH2CqlDz6mziFpNePaRy3jx8au4PD8Fv0IOY0cnJHVnEVQrECPDf7qYQ7WYh0OjgYvGVUd92nPiFOSt7ZA1tsCr1WI8n0EXGfc2pRxDLc1oOXwMgyfOwNzWgohqBNeXp/Dy4zfg0+igpn5UNHWim65Lm1tpDI0wK9TC0p2AXgFz0zm4WxsgPXkaI2ea0HboNLRUT1ghg3uwC6bzd8P48B/CcfJjUJz5LMYSXnzp2WcQNDqgHJCh60IbWo+dhksmh3VwkObXQ5TvMCJDLVCeOoSu++9G+6EHoWhoRP/R4xg8fARDNDbDdWfQRp87Tp7FUFMLlafBSimJpFlN5XTCPdQDc0s9DGcehP7kXXC3nIDi+D0YeOAzkB+7G5YLxyF/6D703nU72j/zp1A+fDtsDUfgaDwMw+k7YDl7FNa60zBeOIeIUonVShk3VpdweaqGlXwKK9THcbMd5+44hNO3fQ6jdSehbjgJY+tFWJvPwHL6TuiOfBrqQx+H8r6PQXLHH6PnE/8eA3/5++i/8z8irehEWt6Dofs/jebb/hi9D38OWqq//3N/iNb/+L+j5T/8SzT/3j9H4+//M7R+7P9Az+0fRecdn0Lz5z6Nls98GvV/+hFc/NM/QMMnPoaOez6H+GgfDKcOY4ja1Hf4MN4UiRoRIkSIECFChAgRIkSI+PDiVqJma3MT8XAQNskwlGfOQNXYCr1EholCBvr+Xmi7BtFf1yAscYrqDXAMj5IB2gZDQwsUJ86i//6H0MXLRM6fR9KgxUTIi8VkGJ6edljr66A5cwT23g4s1iqopZLCTk5plxf5WBoukwPyjgF4R5Vk/DehGgkKO07Z5RqMnrkAPRn4BZcPfo0O8rY+9B0jI5nylv0B3NzZxM7qAjx6ynvuDLQXTkFNxrGyvh62YQlWqjXEbXZ41QbImtuhamhCyGDAl55/FkHSc5x0mS/XYKG8jsF+DB4/goGjR2BoaYX83HloOlpglfTg8c1F+EeHoKu/gIEH78fQgw9AS3UkzBYYu3oQ1qpg7GyEof4huNuPISHrxkzYj6TdjMtkyL/60gt4/Utfwd7mGl546iZeeuZRXLu0hvlaGdL2dtz3F7fh7k9+HsfueRD63n6BTEoFfAhoNdA0XYSu4QxSRi3MAz2Q1tVBer4OruFeGDvqUfZo8fzeAp7bXcTlsRx8A91QnDoK6cmHYOttpH7oRCXqx0whh6BOhbBiBNZWGsszpyG9cB7KxgbknGZMpMMYPH8C5qFuDFOdzQ88CNmp49Ceug/BgXO4MpHGM9sr8AwPYOjkcRjaWtHz8EOQXbxIY6OFRS7H3HgZfqMCirNHYLxwWoj3MnjqDJruO4T+Yydg7euDe6gLxnO3Q3vkDyG9/yOQnPgMxmI2fPGxawiqdDBLVFD1DaP//FkEFcNwdDfB0lYHX+8ZpEfOwNd5DIGhRqQMMqSNSkQUg0jqZchYtCi4LZhKhrBUSmFjooDt2QoukWxNlbExWcD6eAYblThWcl4sJKyYj9sxFjCj4tVjzG/AdMiKPOkfGulGSNKOnKYPFYcCRfMI0pouVKxKJOUDSChHkTHpsJhNYKUQx1TAhqmwA/PpEJI0TgM0j1ru+TykZw7D0HwKto6z8HWfgr/1PrhbH0Cw7wyikiYEBhvh7joPe8txGrdzKJiHUDQOIth/Gu7O44hJW5CUtUJ575+j6d/9bzj1//5/oOHf/++Q3/cx2BsfRGykkaQNCWkPkqO9SAy1wN5Ac+j0PTBdPALTmQehe+gvoTz2OagvnMBbP/ohfv0rkagRIUKECBEiRIgQIUKEiA8lbiVqtre2UM5n4RwlA/n+BzB6sQHGUTmqqTj0Pd2QXmxF99ETGD5xAu6+Hji7ezDy8FEoj5AheuIItMcPQ338YVgvnkRePYSUahgFkwq25gswnauD9MRJweMk7nahGA1D3d6OkFqDkN0Ju8YoxPAYPn0BcjL6Cz47nGoJLKMjGKD7FHXnUXR6EDEa4VeqYGciw2LGeDiAy0szWJ+bQCXuR1QzjLisE4nRDkRkPYLhvlktIGHSImnSwzHQA13TBcSNGrxwYw8ZtxW1WEjYgjztdiJh1SOulSI01EHGbytiklYkld1I6YewN1NEQjuCIF1zdtTD1dOMgKQbebseaZMaObsWMU0/fEMNCI40I0xGfsmhQcmpxS7d++z1HTx7YxfL4zk8vruMJ6+sY2dpHKu1LIpeK+ySAVglpL/djFokgIVCGsvVHOZzCUxE3JgMOzCb8KIWsqLiNdGxD3MxNyZ8JiynXLg+l8GVqQR2KmHUXNRe1RCiil7SbQRZlwKLpRC2JouoBW2o0f1VuwYx+QCC8kFEdXJMJ/yYzwQQVPQj59QhbFHAx2VQP6alLSgau7FW8OLaXAUFanNIOogC9ZdH0icQRimjDjGrAUuTJZTiPhRcRhRtOhScFpQCLmTddmQcVkwlgljIBjDlV6Ns6kHB2Iua30C65fDoxjzWKgUs0HjMFFKYzkapH2JYyoSwRPcsZT1YybiwnPFipRTBei2DtXIKG9SHGxM5bFAZW9NFbLPMlrFFsk36svDxxlQBm3xtqogtPiYRyJuJAlYnspRSebU0lvJRzMRcmAzZMEvpQi6E1VICS2XSpZzAYjFOesWxVExhtZrBxlgWq2X6XAhjNulF2WOieaFD0iBDxixH2a3FeMBMY6XHpFdNbddjOkJlJzyYoTGd4nGMujAdd2Mq6sB01ImKW4OCYRglmnt5eSd0hz6Fzj/+Vzj1b/9fqPujfwfp4c/D3nqSxrALea7DqkbFoERRM4iMogMpaQfy2mGkaTyjg42IDDcI9f/07bfwm1+LMWpEiBAhQoQIESJEiBAh4kOJ3176tIWJcgm6rg503nUHBs6egnl4COWAF8qmBgweP4P+w4cxevReaOuOwtvTDsmD90D5wG3QPHQblA99BqYzD8B58SGEe87D1XEOCWU/jPWnID9+BEPHj0Pf0wOHRoWs1w59ewOsnc2Ch4dbrYK2pxum7k74RocwSYZ+JeJG0e8kY1eNqsuMxUyEDOMkGcxkFBfT2BwrYmdmDJcXp7C7MCEY+muFIBnBWixETFhNe7BZTWJ7LIOVlA/zQTOJCeMuNVbSAVxfHMcmGfdbZKhvT1dwaW4Ml6bJaM96MO8cwZS+GTP6RszZujDrl2K54MFS1ouFuJPK82MpE8BSLoD1Sgyb4ylskZG/Wo5gjT6zHus5L1aiOqyFFdjLmXB9zIPLNQ+2Sm5cncvj0a153NiYxbXlSWFJ0eX5GvYWarg0U8bVpQlcX53F9c05XN+Yw7U1yrc6jauLY9ibL+HybBFb1K6NfBTbhQiu1JLYm0hiZyKByzMZ7EzlsDNZxKWJEqUF6qcC9VEJV9cmqZ1lbE/lcWWWyuE+K0axUohiq5ah/koJBNDGGPUv9cXWTJ7OJ3CpEsHl8Rh2p9JUdwmXpqi86RJ2Z6vYmChirZaje3NUbhk7pPslatPe0iSuLIwJbblKx7vz46TDOPaoDdtTWWxQuVtVJmFc1I9BKquCq3TfJSpze5oJFkoXa9iaq1Ad+X2dJtLYms7vkzDUTzsz+54yW5R/a6ZE95BuC1Xs0n07lG5RmVwOp5uTeSxSX03G3VRWCtt872yNyiJ95iilfDuUb32M+qSaFsZ1rUjjWYphtZLcJ4XGc1ihObPCKckq5V1hooaO12k81infMrVljgmYpA9zaT8mI3ZkLDKMBy37RIwgHkzTHFyg8ZvPRTCbCdHnEOazUcymmewJUX470joJEvJupJU98LSdgPrIp6E8+nlY2s4jJOtDyiBBwaFGxWvGmNuCrFqC6EAT4sONAlmZ046gYtej6iSxq7GaC+Pnf/UO/tNvfvPeN8A/HiJRI0KECBEi/i/xX/7Lf/lvyn/+z//57z0vQoQIESJE/K+M3/Ko2dzEWDoNY1MjZEcegKb+JOw9bSjaDRg5eQRDR49CduowbOcPwdlwFPHBDpjOHYbm6KegPn4bjHV3w3rxfkR66xAaaECYDMVxtx5x9TCC0n5E1XJknFZMZRNk+KawmPJinozYxXQQi/k4VtgQZqOXCYOxPHbJ+N4ZL2CH8m4Xw1hLu7BbieLGTAF7TBbM0XVKt6dy2JvOYqscxXY1jq1aDFtjMVydLeDqAhn64yksxC2omHpRNHRhxq/EXNiEnVqSrldwhcq5Sgb+tYUS1RXARlyNTU8XVk3nsaw6hUVDI1aiKlyeSePKfBGXpsmQp3s3J3PYJV2u0v1XyMBn4mJnvoLLy2O4ukzpZASLgVHMWJsxpTuLKc0prNouYNPfjetlBx5dLODaSo3yk1C6M0/3zxWxUIpifSKHy4sTuLIxh721GeyuTuHy6jSurc7g2tIk9kjf3Unqp4IfY84Rag+TTzZslwPYrIaxO5sXCJ8d0unSbJHKKgvkxZXlKdxYncXNlRncoOO9BSZ+qtiZyNN93Pc5rFL/79C5q6uTglxbHce1xQr2ZvLYnsxid75Gfb9PqtxYncP1lVlBbnCZpOu19RlcXZvG7tIYtY3uX3mvHpalcWxTnwnEEfXZpRlqM/XnFhMwUwVcpjxMllyiOrZ57KgeJkeEpUuUblOfb9OYr07mqZ/iWK7QOFAbN6YLWC4nBOJtnXTcmM5ji/KxF80m1cFeNFvjeawWY5igObdcCAmeN1tMCjFJw6nQX2WsltNYKcZpTvoxk3RhnebUciWG5WIUS4UoFildHUsLenFfLZaSwtxdqaUwnfSi6NSg4jViPsfEC83ttA+zUSdm4y5MRhyYiNoxEXdikmQmQefCVhRsvBytH1NhypcKYiLmRcamQd6mpudPgyoTMR4LMnop4sohFKxaVF0WStXIm+QoGJWouYyo0Odg7wU4mg4jMnhR8C7L6IZRtChRpfLWczH8zV/9VCRqRIgQIULEPw1+/etf46/+6q/w9ttvC/KTn/zkb49vPfc3f/M3gvzsZz/Db+hHSiRrRIgQIULE/8r4LY+arS2MJRPwD3bD2noWflkXErpRjPvMcA+0wTvUg5C8F0lNN7K6XtTscpRMI6g6pChbpRizjmLOo8Jy1IbldJCM4gS2xrJk6GaxVslihT1hqgUycNk7gkmBJNbKUWxUeOkKeyTkBeN3nb0zxsh4ryawmvNhOW7GYkCCZVcvFm09WAspsJmjOrJ2rOYdwvFm2oKtjBs7lQR2yfC/NJMTyJyrZPBfmS/j0hTVUQnQPQ6sFzzYKoexM57CFTLQbyyM49psAXtTcazE9Zi2tGBCegjF9k9jrPtzmNfXYSOto7wZ7M3lsTtfwM5CCXvLNVxlEmOFZHkC15eYlCBZn8H19UlcXyljbyaJS2N+XCrZsZ0yYsk/inmvBKtJI3YnoqQnlbdQxWUqh71dBK+ZFZYpXFubxs2NOdyg8vg8f762OoWri+PYHktivejHTjWMlbQJczEtpkJaLMas2CgGsD2Rxs5UHuuVKFap3VsT1C9zpM8S1bM0IZA0TNhcX6Py2VtneZz6qYori2O4THku0+eduRK2pjLYmUljKefCdFhPqQ+XKd8elXGF20r63Fybwc11KkNoN+tJOq5O4goTPaTzVcpzhfJfZuKGZZHaS2VsT5awMVnENpMyc+zRVBHK3aP2cbpLKXvSrBST2J0qYXeGxpHGa3dujHSie6ZLWJ/MC540TPLw0qeDdFEgVCJYoznEpBrLxgTNQ/Z6Gc9SvXmB4NkncniJVEVYAsWeMTz31stJLBWYQAxiuRTDEs2r2bQfeYcGYyEbJuIuLJbiwrK15VoGy1Tu8nhaINnmMn4s5UNYJh1mUz4sZgNYzASwkAlhhu6bCOlR9SqRNQ8go+9FRtOF+GgTEvI2jLnVlMeJqbQPtYgDZa9ZWEJV9pgxFrCj6rej5LHQeRtq9LnCRKiiF9GRDmG3qIJVRakURcMQCvSc5lVtKGnbUdR0oELP7EbKhb8RPWpEiBAhQsQ/FV599VWYzWY0NzejoaEB58+fx6lTp3D27FlcvHgR9fX1wvnp6WlUKhUYjUZ861vfEl5QRYgQIUKEiP9VcStRc2l7C7OlPKajXkyG7ZhKuDBFRuNCxof5lJ8kiPlMEHNk7E0H1ZhwyzETMWMx7cZMyIxprwZLUQtWs8H9uCFk9G4Jy2d4WUoVmxMVEjLO2XuDrm2QwbxaTWK5/F68j1KazpfIgKd8fC3nx0rKghn/CKraC6jJTyDXew9yQw+iZmjEtHsQk7YeTJtbMGVswZxzFCtJt0DUCDKVw5XZIvbYo2S+iF32hpnJ4fJUVvDAuTKbx/WFMdwguTqTx+VJMrwzZsz7hjGmPItk8+2I1n8Cid57UbV1YSlnJ93iVBYTNWVcWhoT5PLKOPZW3iMumGBhUoUJi41pXF+bwvXVcdxYKuPaXB6XxhNYK/qxXglSG+OkZx5XBE+Xif37VmdwlT1T1mdxc2MWj2zM/Z1szuLGBpW/PEb38fIvMv5pfDYKfmxWwlgvhQWvoj1q+9XFCi7PFbFZi9FYhIRlRtuT1EYmhXhpEHvMUD1XV2YFIuXqEp2n+65Qu64s1eh6GbMZL8peNbZqcawUfJgM6bGQdGBvrkB5qtTecUGENpJcY6JpbeK9NlOZa9PUN5O4tEz9szqBy9RGlj06JxAyCxO4tDBOfcgkzhSdI1lmUodkkZdKTVAfFaldNEdoTm2PZ3BpuoTLNJeuzI7j8mxN8LxhomV9nImXsrCcib1i1qpZLJfilKawUkkI84zj0fASKcF7hoTJmS3Kvz7FHjclrHOcmQrNAfacyfiFQMOLKaewlGmNPcCKCVSDdoxHnYJXzUo1jTW6h5c+LXE9Y0msTaQFIoiXQa2UY1ike5l4mUu4sZgJYzZiQ806iIz0PELdR2G78HkYT34c2qN/AkfzXUipmlFxKTAWsmCcvW9iLhSZrHEZUOO6Yx5MxH10zY1KwIKSV4+CQ4WscRRFqxJ5swIZgwRVqwxVfQ/KMprHvQ8gNXAY+dEzWA7I8fOfvo3/9Jtfv/cN8I+HSNSIECFChIj/S3z9619HLBaDQqGAVCrFhQsX8JGPfAR33nknent7MTo6KpxfX19HOBxGS0sLvvKVr4hEjQgRIkSI+F8av0XU7GxjbqyEhWIc84UISRjz+SAW8iEs5CJYLMTocxgzGRcmghrkzIMYCxowm3SRIerAYtpJRm4Qm2TAbpGBvUXG7+YMpTO8/IY9IgpkRBeEWCHs0cDeM2ts1NY4gGtWIHHYU+ISGeA7ZFRvVqJkKNswG1JhzNKLoqIe2eHjCHcfQlp2DhPOEUzYBzFl68O0vR8zbrmwlGqddFxLe7Aat2EhZsVaMUQGPulBBvkO6cNLgXZny7g8x6TFBC7PjwlxV67M5rBdDWIj78J6wogZ5wBJP6a9EsyEdZhJ2LBM7duZzmKXvUKWJ7HL5MMSEzWTtxA1TFLsExVXeCkQfb7BHiZ8z1ye2hsTZHsyjUvCEqCSELeF77/C3ifvkRzX+N6/Ff7MwiTItFDe1UX2FMpga4w9TrK4NJnBzjjHkCkIcWx253gpUUkgYa6zx8xCjfqely5VsMefqT5epsXLrbhdc3G7EIOHdVuuko4TSezN5nF1oSp4JV2eKwnkD+ssLDdbqOAqkzVLNRJe7lWjto6TcHwdJqmo/aQnL4Ha4+VPTNIskvDSLY7Jw3FsmOSi+4RrvBRrme7hmENz49ihecDEysZ4Bqs0F9eZbKJ6L9N8ukxjeXmax4+XSlWFIMkbvExupopLvJRppoxNysPnOebMBntx8Q5QM7zcqirk4/J5SdV6NSl4wKzSXJ8LGzHtHsWEpQ+T5g5MWHsx7VNhNRsQ8jEJs8rkDHvmUHlc5hrVu0xzfr4YETxveBnUcjWF5QoTRXGsl6IC2bOco2cnaEKw9xQMJz8J2T1/gL5P/Sv0f+Jfou/j/wJDd/weDOfuQskqFQIPT0Vd+8RoNoj5bAhzdP80pTMk0yk/phIeTMZcGA/bMB60YiJEqd+McY8eNZsME6Y+jKsbUZSdRUZyGqnBExin5+hn77yF//RrkagRIUKECBH/BPjFL36BN954A6+//jq+8Y1vYG5uDvfcc49A3Dz11FP42te+JpA5b775puB9c+PGDWEpFL+gHiyF4uVTP//5z4Xz/NLKS6M4ts27776Ld955R1ha9atf/eq3lkvxMd/H+Xl51cF94pIqESJEiBDxPwJuJWp2d3YwO17CfCWFhQoZr2R8LlXSZHCmsULCZIoQl2MiR+eTZJjGsVBKCjvgzOXJiMz46DiMlXISq9WsYBxzrBXeDpnjfKwWfGTwurCWcVLqwUrOL+z+wySQUD57T0zyMhY2sHkpVAKLBcqTcWEubsV0iHfMUWHCrcCEV41pMqoFcqjgpbLcQgDfS3QfB/XdrMawmLJjmerheCTbVOb2zBg2yYjfmicjnQMHz01gZ55lTFiKw7FqOA7LFtW7Ughglu5fyruxUgqAgwWzlw8H4eUlRFfYS4S9Qpb3CZoDoubq6sTfkhccQ4eXGrG3DC9lukIieLMwacWkB8ezYQJkYZ84Eco4IGnei/PCJM11lnX2fKHPq7O4tjJD99SE5Tw77AlEZVxZrAhlbk/nBSJqj8reoZTjtKxPZIU6rwj17cf24Xg1+zFkqN3sHTRFfVaJYSHlobFK4BLnI7125zgIb04guviYl2kx6bZHx9eoDCaBrlJbt6bYOypOfcxeOxVhedU1JpOWx4R822NpbJSj2OUlWRwMmHS5tFjF1jTNJxorjluzv+RqknQcp34uCwGFL82SrlTfJer3rfEklRHCet6H+bAJS3EHzSM/1t4jR1arvOSNvYHGBU8dJmJ2Znmc95dKXeJjOsdLp7gOXka1RXrNxSyYC2iwFtFhxtKJ8sgx5DruRq77bqS670NBdh7j1gHMxy00l9OCB846e+CQjny8xsGUSVZrOSyzdw09P7wz1BJ71BQjWKRnY6kQoXkcxETQjLxpGEVTP4LD56A6/VkM3vPH6Pvc/4mu2/5PSI9+Dmn9iBDLZlYIRhzAnEDS7BM2MykfppJegaiZSQUwTXmmWBJeTERcmIo46bmwo2xTIKfpQWq0CRl5MwqaDpR1XVgI6vDzd0SPGhEiRIgQ8U8IJkcO5JFHHsGRI0fgdDrx/e9/X3gRZdKF06effhqzs7P44Q9/KJAsTNqsra3h5ZdfFtJCoYD5+Xm89tpr+O53v4ubN2+iVqthcnISzz//vEDYHNTz05/+VDjH5eXzeczMzOCFF14QXnq5PhEiRIgQIeLDjP/Ko2a8hEX2BhBImRJWx0hqBRL2gNn3hOGlS8vVLBZKGcwXydAtpTFbTgmeOIv5KBbyESyXEmTwk3FOhvBqjYkPMjLJuJ72qjHjU2M2ZMJCkpeDBLFciAlEzcpYHivsoUDlr41z3I8kFmtxLJEhv1zlNC4sY+FyhdgjYwlsMsEwy4FjC2SA8xKnMnbmWJjwYYKCPUA4yG8Nm2Sgb5CBvjE/hq05NuJr2N89iEkIJizG6X427KtC/BMWvsZeQUIMFSZ0KM+V92LRXF3eX+Z0XYjNMiukN9ancHOdvV2q+4QRGfZbk1m6tyKQEByrZd+rZEI43l2oYHu+JCwN2id7pt4jZPZjuwjBg9/zquHzgqxM073j1L6c4KF0lb1Z6P4rq6T/EnunjJF+vNPS/mcmbzaoH3cmM/teMe8RQ0yW7C5VsUf9dZXat8PBkdnbaJ53TRoXCCz2ihIC6ZYiAsHC+u4xQUP3X+Oyqcwtkt2ZPHZmctRfHDOGxmGBPYS4fSVhuddqwoo5nwqbeRc2qyFsTmdwabEi9A17s2xSWwTPG8Hrhuqeoj6f4KVrHGeIdKR0OePGNAeC9kiRGq5DuOsoUpJ6jPt0gofL5gyPKRM9M9TOaRrHSep33uWKSZtxgcARyJsZJqBId57HGR8mHBJMmjowY2jE2OgRJBs+gdCxjyB46o/hP/MxRJtvR2bgCNU7io0KB3ouYm2SAxrvywp9XqbnY6XKkhOITQ5yvFSOYqkUE2LZLNLzwNuMz6SDmM0EhHg3E1Enii4NEupexGQdSKp6kNINo+TQYi7hwzyTNCQzJFNJD6Y4IHHUhZk49UPSKxA0E7y1d9KP6UQA01EfpsMuTAVtmPSbUaVyShYFyuZRlAxDKJuGsZb24uc/5Rg1IlEjQoQIESL+O+CAqHG5XPjBD37wt7s+8QtpsVgUlj7xSyl7y/j9fjQ1NUGv10OtVgtLpDimDaepVEqIfaNUKoU8MpkMTz75pOBZw4TNysqKcG54eBgqlQoDAwPo7+/H9va24KXDdYoQIUKECBEfVvxXRM1YSfAIWBGCpGaxUE5jLh/DfIGMTQ6wSgboIslCNYV5+jzLXjVVMrYpr3CejNG5bBjz2YggC3TfPBmqc0Xedpjj3LCHTJCM84jgecO7PK2PkWEreCDw7jnsWZPF+ngOi7UUFqtJrJIRvjqRJYM4K3jz8A4+G7w0igkUMuB5G+ZLQhBc3lWohst0vMufF2v7y64E4mEM2+xJw94aHPtkdt9TZKPGWy9HsSXEbxkXdlraJbm0wCQDyzjdv09aXOKts+epfCYhlpgIIVlmwoa9R6b2lz2tTOD6yhiuMQEyy0u9mEzh7aRLpN8+QXOJ7mfhgLtM0Ozy8p+1KVzhOC9M9vBOT1Su0Ab2xnnPs+ZABA+btX0PG6H+97x12BuHY+XsEzx8D8skOAbOZe4z6k/2iNnfzYny8HUq//Ice9TwEqGM0FesmxBcd5q9ajieC/chyRz190xeIII4Lg/3Ocd92ZzKCoTZYjmMdTrmna+4r3boOgdd3hmPYT1jx4xnFHFZPQomek8aTwjLvZiYYU8aXkK2u8JtZiIlj7m0G9MRMyZDRpovHuzO7MfkmfBrUDb2ITZ4Fqa6O6E6+VkkdH0Cqbc9x9t/T2N3bgqXZqifZ/YJmh1OheMxIfgv78a0WaP5lnZhNqBCVdeC8uhJFPrvQ7LpE7A/8K9h/Oz/Btu9/wfsh/4dHEd+H4Hzf4GS/DyWoyas03zeEDxnmEhkQjGP1fH8e89MBitjlNKcXqzSs1GOU740zW16RihdoHk+V4hghp4B3p57JuXBRNCAMa8KZZcCZacKabNM2MJ7NuHHbCqE2UwYM0kvxnwmTJDMRJ103YWxqA2TlE7FSKJuKseJcTeVZVOiZlGgZtOg5tRjzKHGuEOOSbdCiGe0vz23SNSIECFChIj/Dnj00UcFosbtdgtEzYEHDL+QRiIRHD58GF/4whcEokan0+FjH/sY7HY7Hn/8cYGI4ePbbrsNEokEly5dwosvvoh0Oi0EJ+ZgxEzSPPbYYwIpw0TOlStXhPKYIGKCp7W1VYyBI0KECBEiPvR4P1EzUy0IxIwQp4a9AMpkjJaS9JmJlJQQi2ORDM5FXhYlGKU5Mkp5OVRB8GrgoKpLpRTdsy9LZTJOeSnVe+UIZbwnHISVl1Ot1vY9EObyETL240KQVjaoVwXPGo4vwrv57Me6Odilhz1ceAvprTn+XKHzZODPkywwGcNkQ22fLOBznI8DxzI5Q3mZpFmdzGJzMk1lJ4R0m71q5seELaT3iZ5JSqfo3CSVM4HdpQmBNGFvDyZphC2neXei9+Q6fb7OHjGLNWxOUHtKYWzW4oLHibC8SVhm9F4ZvLxnaZ/o2KWUPWk4hsuV9zxmmIjhfEzU7BM6txA17xEwHP9ll9onePTQec5z4JHD+TgY8Y0NkrUpYakSb1vN/ch9sh8PZkIgZfboM+8ixfFr9okTjh+zLwKBIpwjHUkuCd5K+7tdMSHEOu+wZxL13cYYzQ/eoSsXFLyo9pcxcR0VbI/T2CesqNglwo5hRYcc6zRPuJ8FooY9b5isIv152djeAo3zOMd2CWKO4x9lvIJ31OYYzZl8EFMhI0oOKSoeFcbDJszkPFidydL48lIqkin21OFYNLzMiZc4UT9Turc4TccVLBdDpKcLCxEtZp0DmFCdRaH7DkQufhTeU/8e5vv+BbSf+39C97l/Bv2d/zv0d/8LOI79PuIdd2Jc14KlgAqzAQ1mokZhqR8TMPwcrJIwScMpPwdMZi5W6JmgZ2C5xGQNE53UT6UIlqgd87kA5tMezIXNmA9oMeEcRdk8jLxFiqmIA5NhJ6YTXixxbKhMEDWfETUnL/3TokpSctNx0ICKS4WCTUb9ocGYS42qaRQ1kjGrEmMOPd2jQ8koQUbRLni0/fynPxGJGhEiRIgQ8d8H//8QNbzU6YCo+eQnP4lr167hl7/8pRDvhoMO33fffUJejmvDHjlPPPGEQMDwOV42lUgkcPToUSE4MRM0vASKl1Xx5z//8z/H1taWUJ4IESJEiBDxYcX7iZrZWhHzZBjO5iLCv/8cp2Y/OCql1YwgSxyLg2SFvQjGC0IqkCocIJjSVfYwYMO1xsunstiY4OUxefDOPKtjHHy1uC90zEuqOC8vq2JSZnOyICw54q2S11n4HjKE16mszakiGf77xAsTDkzW7O/cU8UmG+iUHhA4AgmyyJ4wNWzRue05JnUo30yZdExRvRHSKwEOpMvkgxC3hYMLz9JnXkZF9+4yUbNAwqQNEzXsEfMeMXN1ic4xqUPCn5m8uSJc43gt1J5qDGuVqBC3hXdQuvoeicIEiJDSZyYz9u/llMuh8qgcIQjxe3k47s0+ScMeNAceNVNUVxXL5RiuUHn7RM1+2X/nTcPLsShlrx32UqH2cbwarnNfDyaCuG72CKJ7Vjjv3y2vYjKI6+ZgwwdEzVX21qH7rgvpPrmzxfFvprLYrsWxELVgNmDASi5AfVkR+maXd1jieEOVGBbTXiznw+Adv7aFoL/cXu5nHs8S6VLbX7LFQZfZG4nKXa/x7mFZ6tOSEAtpPOrCYoEDWvswmw2Bt87mGDdb0zw/aI6NUV6aN6vVFI1BWtglanuKPZtKpMuYsPPVasGP1awNS2E5Zm0dmFKdQrH7c4hd/BNE6v4I9gf+P7Df96+g+/w/h/L2fwbVHf8cxgf/NXznPoZMz90YU5xGTXMRE/Y+LKftWCZ99pf6UZ28w1SZdzGj56eUxAp7p9HxSi4s6L9E13hJFO8GtZIPYDHhwIRThWmHHBPmQVQMfSibhlA0j2IuYsNqnnSlPltMBzEXdaBikaCo60NO04uMrhdFYz8K+m6klS1ISpuRk3cgN9qCsrIDVd0AqhYlqnYd3TOKlKQZU065GExYhAgRIkT898P/HaKGlzw98MADf+sBw8uamLQ5ffq0EHOGlzAxmIjp6upCKBQStvbmZVLsddPe3g6tViuUwzI4OIjbb79diHPDgYpFiBAhQoSIDysOiJovf/nL2H1v6RN7vrAcLONgwmU/7sZ+cOGFSmY/JgfHlGGyRYjZUdiPX8PCwYPJwF6vJbFRi2KzEsR2lVLB6GZCpoT1yTLlrWBjan975I3p9zxlZjl+SFUQwRuGPm+zJw3v/sNG9xxdF0iYfdlZIJnn5URMqrD3C51f2r/GpI7w+T3hz9vTRTKSfZhLmil1U5l5gcgRCJ0p3s46TsZ+fP8eJmpYlnhJzgQuC0TMe+TK8oRAkvDSI8HDZnlKOGayhImiHfZimdwnqYQdrxbZk+XvSBpO+X4OAszbXXP8GN6piQmd/aVMTJjsBxT+O/KEP88IZMZ6NYbZlEsIVvx3xMyBsDfNnOBRc5M/r5Fu69SOlXGh/5ikEepncmZtjq6zzApEDZ/nug7InP1lUpyf2ki63FyfwyOU3lgewxX2SMp6sF0OY28iKQSJHnNJMRezCoTXHo/jTBVbvDsSky2TvAysJJB0W9MV8O5MApk2W8D6RILGJgcO6ry3UMUaxzaqJoR7tnlZFhN65aQQq2Ui6sJCJrQfvyXhxnI+iNVSVNgOm2MCMYE1k/ahGrbSWCapjH3CZ7WcwFo5ijWBqHFgxifBlOP/296ZNdd1nen5F+QiVfkDuclNkpukujqVdNrpbreddtlpS3Lc3R4kShRFDZwpDiDBASQBAgRJzNMBDuZ5JAGSGEhwkijJtixLtiTLki1Z1mRJnEeJ05v1LGDDhxBEk4rdPlV+H9eqffbea/z2coHfq2+t9ZC6Nz+g3s3fU8vae9Sw9B9UeO9/1pav/Hs9+Zf/Vkv/67/Rqr/6d9ryjf+gHd/5Lyp94C9Uu/Cv1bTiG2rNvV9d2zlpbKO6SzbH1Llrozp25qq7bEvo33Z1l+epvWil2vMXK527QE3blqipYKUatyxXetMydRauV2v+WjVtXqmO/NVqL3hSLVuWqnbVQ2ra+Jgach9WS94StW5bG9JqVa14QFXLv6t0zgKlVj+k8sXfVsnCb6ho3pdV+ui9qlr0HVU9cZ/ql39bLevmq27NY6pZu1SpnOWqX/N4FNIusJmwhRpjjDF/Cu5WqCEyhtOiiJxBqDly5IjuvffeKLZwEhQg1MyfP39GqOFEqS996UvKzc2NGxCn0+mY+E20DculqMsYY4zJVvi7yH+QeP311zV58KD6O5rjfjNT+2xMp+bquNypN12pgSaWdiC21GmYo49D2svRyO3hWXCG97dUa7QlXJtLNdpUrNH0No3U5gYnfp32pPK1r6lSIy3sa0J0C1EwzdoXnPZ9RL3EvWZYgtManPVWcYwyS1XY3Jb9Y9hjhL1ixgeaNUZKhBr2lhnonEqDbTpIFAlHQPd16GBvW9wkmFOKOD1otKNWPZWb1Vy4XF3sN9JcLqJz4sa5Xem4j8u+lqopoSbUMRbqGxtC5EBY6dRkSBwhfZDolqGucN8Vnx8anBJe4pHTXGMEDoIO0SgsYWqKAlISJYMYw/4wY53V2lOXr8GqzcFupVG04WSog0O00aNDw72aHKbNqc15iWwZ705psL5Qe9I74jKhQ0NEorCBcLiGfLHuvd1iedTRmLrjfRKpk4gxPEOoORrGcjw8OzpE1EyoY3gqwgbh6che+jq1Bw9iDkLNMeom8qerXmNNZfEY9fGOKo21cbJXgYbThZroqtFkL6docYx2gw52I75N7fEz0lYTo2zGgr3ZE2iUiJ+Ql6VcU0eohxQ3QEaoISqreurUrigE1ob6q0I7oa360nDdpb2pnRqqKVRv2dYoBhLd0l+3WwP1u6eibdrYfLpC3eUFUdThuPbBqm0aKN+g/pI16itarM68eWrKuU+t6/9ZjSvuU/m8/6Wy7/6l8r/5H1Vw739S+fy/Uu2iryq16GsqmffXqnr0y2pe81215C5US95StW5bqbbCtWrctiouQeoo2aS2XRvVWrhKzXlPqGnDI6pbdb8qV85T1ar5qlj+PZUs+hdVr1moypwlSm1ardr1y5TeskINeUtUnfOwqpZ+V0Xf/zvtnv91FT/yrVBugaqfJHpmnurWLlDD+sdV9+RDqnji20qvmqfK5feH54+qYd1jSoX3jRsXqSlvTah7jRrz1qpp00ql8560UGOMMeZPx90KNV/72tfi0d53KtRwFDh1U66zs1Nvv/22Pvzww5ief/55dXR0xPo4qtsYY4zJVvi7SPQn/wHi2WdOaP9QTxRnBpqrNNQ6tbyJPWhIcU+a8IxTnxBmWKa0vyMV7oPjHJz1kfRujTTsjBEWBxqKNJbK01hNjg5Ur9TesiVRrDmQ3qHx4HiPd3N8dGOMlhiNkTRp7WcJUh+iTHN4n9ZYqH88OPk47iyTYZPYib6OKKwcCHlHe9i0NuSPETQs5ZkSShAiogDAsptQnoiWsY5ajYV+jrVUhD4WaaByY3DsN2hvw67wPrQVI25YckOES2O4hmddof0+TmRqVYxY2dOtI8E+k3tCilEovb9Lw1MRLFORLOHddERLjHAZ6YzixySix3B7uGd5EvvcICCltLd+uzp2rlZfxRYNpAo11FQSBY1JxJVQx+Qw0SwsWQp97OGY6rIwhsKYDrSU6kB7hQ731+twbyoKJBzBzbHYRwaboqhzZIh9bKY3Hw6J/h3b16tj+/uiWBP3qQllJjr5LjU6OBhsQN8QlgYaY11R8IkbHXfreEiHEaKCnQ4Fm42zv09XnQ731Yc6KjXaVhpsXarR1t2aaC/TZGdNSCkdZmkZ1956TYZ+cZITIhz7DBEBFTdyRsxBAApl9jeVxWO9ORZ9vDOt4cZKtZXnx81893H6V7o0HvHeX5qnrsI1as9frsHKbeqv3qHOsu3qZ7lRamcoX6EDnMAVvv2+llC2aWfcM4ej3keqt2lo92o1rrpH9Uu/quYn71HzyvD78a+qbuHfKL3oK2pa9jV1rPuWujZ8Rx2596t68T9q5/yvqGrZd9Syeam6dqxTf9lm9ZZvVQdRNeE7dldt10DdLvWGviHidBSsilEx6bwcpTasUtXqR1Wbs1CtBWvUXLBezdty1Zqfq5b8HDXlP6n01pVKb1yumhUPquzxf1b5kgdUsmSeqtc8qrr1i1S/cZlq1y1R44blSq16TCWPfVfFj/6Lqtc+rpr1S1QZrrWblqphy1rVbVgd8q9W08ZV6tm9VRfOeI8aY4wxfyL+2EIN+9bs27dP9913XyxPe/wjlw2FOUWK059eeeWV2J4xxhiTrfC3kb97p06d0q9++YaemhyLYgxiDfvOsAfNYHNK/U3V08d2s79LRYyeIQ23ksq0h+VNzbu1v3GHhqqDo1q8Wp1bH1VP3v0a2Ha/+rfer8GiRzVcvkYHUvk60FiisdYqjeNAN5VrX6hznOOfg/PO0qn+mh3q2rVJe2uLg+NfOxXhwhKnrpa478j+0O6BzmpxJPR4Vyo4+VOCDcuT2B/lYE9w9tsqNdYR6u2q0aHuOk2E/o03FGmisUjjjds13rRDk11VOjrUrGMjnTo+3BET9+Md1dpbv2NqXB1VOtTXpHiqE5E0e6YiVG5ZNrSXY7rD++GpfWSmliIh3PC7PQofh4hY2dsWhZpjpGGO+W4JddfrYHfoYxfHXFdprLtakwNhDH3sm8P+LGUa7a4Kid/B3o27tS+9U6MsK2sq0USwwZH+hlC+Vvtadms0jHmC/C27NJIu1uHB5tCHjtCfqT4e29cd09GQYn+JwukJ9mmv1ERnjSb62MumMUbo0A/KH2FPmmBfxsIGxYeJFOrlSPPQz+5UtPVkTyqe5sQmwHtTBWEuFIQ+btdoulB7q7ZqX01BvA7XbNPe6nwN1RaG71MtTpMaZ1PoMN/i0qjGMvWG9wPVBarbvFwtRbmh3modCHMScWagLC/Mi1Bnwy4N1hTGzXjbtixTfc6Dast7PC4Vqt+wTO3Fm9Qd8vbXFWooXSKOGO+vy1d/xTr1FS9Vd8ESDZXkaqBohRqXfV3VD/13pZ/4qmoX/q1q5v8PVXz/L5Ra8D+VevRLalzyFTWv/IYaV92rmuX/V6m1D8WNfbt35altR26MomncnqO2ks3qqNwWBaWO8h3qLslXa+F6dRRvVPvOLWrdFd7tylfz9g1qzF+n1uLN6i7dHurZpnTeGtVuWK6mgpzwPOTftVUtBbmq4sjuDStUu3qxatYsVtOWtSHPOrWF8XXs2KzmvLVK5SxVbc4i1eYuUzW/Q/7UllWhjRylQ36Emtr1y9VXUagL3kzYGGPMn4q7EWrWrVsXhZq33nprRqg5evTobYWakydP6t1331VNTY0WLFgQT4diU2KO8WbDYTYUpl3qM8YYY7IZ/lbx9/DsmdN6+YUf6gDLgDhBp6c5HmU9MdgTUlf4PbVEhQiXA53BOQ/ONRvA4tTj3E/2poKzXqvRtrIo1rRveUypZf+otlX3qH31t9ST96AGixdrT3mOBso3a6SuWCOpnTESYaCmSPtbKqNQM0b9Lex5gpO/W4f7mmNkyuRQlyY4Kpt9S5pLQ76QP7RH1MjhPa1xHxb2VKGOyc5qHWrZrcn2Uh0J/Tran9ZkR6lGU1s1nt6m8cYCHWor0VNDaZ040KnnJvr13HhfSN06sb89iieHeut0dE+oqy+l4dA3lhQdGx3Q06ODOjE6pKfGptLTY4Ph2q+nQvmn+B3ePx2enxjfo2cmeD8Qng+E+1B2fFDHR/v0w8Mj+smxMT13cI+ePTgU2h3Qc6O03aaje5t0bBghpC6eTrSvZWcYa4UOD6R1dAShhDyhj3ta4sa+x0dY3hT6hoAyxBKjYJ/2Mo237tb+pmId2duqY/t7Qr9C/0Z7Qx/6YmTPJJE+CEl72nQwRuqUhzE3xs2HOeHpSLDpgc6aUF+9jg93xmcsOzse6jrGciyimRDE2qs00VahiY5qHe5v0sHOWh0K7R/rq9IzQykdDP0frtqsnqJVqst5WD3Fa3Sgrkjp/BXaky7W5AD1hLEhhA3Qlwb11hSEcZdob32Rhht2xuigyf4WHeqqC/NnswYqtsT5MlS3Sz1lW9W2fa16d61WV/4iNec+ovq1C9VZvF69IV9HmF/tlUVqKy9QT1VeeL5MnWEuDhQv1Ui4H9qZE+boP6l58dfVuuI+1S36B6We+LIqH/hvanj0b9S06KtqX/l/1Lr6mxosXKCh0lUariGyp0T7WSqHaJku0VBDaVxiNdxWLY6U72+oUl8NJzzt0lB9iUYQPzktLV2u1pLt6q7YraHGkC9VGpdxDdXuVv/03juD9WUhlYdy5WrfybHbuerM3xRsl6/2oi3qKi9Ue0WBOkoL1LYj/P+naldc2oXwU71upTqKtqqrpCCMn3a2qzP8btu5Td1Vxbp88byu/wEjvi3UGGOMuWPYb6aurk4TExPxKG1EGuAfo0TL1NbW6v33349Lk4iMYV8ZxBfy8eyNN96Ix3Bn7jPzzjvvxM2FKY94c/Xq1bjkaWRkRNXV1VHAqaioUE9PTyyflDPGGGOynam/f1d1+dJFXbpwXhcvnNPF8yR+Z96f06Uk8SwkrpfOn525Xjx3WufPnNS5Ux/q3Mfvh/SBzp/8rS6c/lAXznwcT51hnwz+y/7v0plQdygby5PCfUiXwu/LoX36FPtFH5L3tJm0OzvFd6F8SJcvUAflTuvi2VMxXQq/Z94Fx5V05dIFXZn+PVXvVEr6Rb2XL14INppO/E7SHM+uBFtS58y7zDzhOvV+Kk/MF9ue6j/9jW3TZxJjic+m30/3M9M2v3tPf7EfY0zsM50/pqm2bi2HvUjT33i6rplvPn2f1JOUm/kGIWX+Jk3ZPfzmWwWbnz/NnPgoXJkD4Z55EL59rJc2Yjuh3ljXGV0I/ed9nAexTr5heMez6efMm/PUFeo+H+bW+dMfxTbOneQa7mk3vD8XE/OS+/A8zM0LIe+F2JdQ9uT0XP3ofZ2N6T2d/fBdnSOF3+fDu/MnP9AFyjGHQ71xzsa5eDb0lf5OJexwIT4LKeSJKeP9efo88zwjzxwp5qXvp0M6FfoZrudPM44kTY0v8/5syDeTd+b5VMK+/P88+XfxHwILNcYYY+4Y/svgRx+FP9Lnzt2y/Ig/TJxuwTuEFu7Pnj0blzIl+8nwjPI8Y91+8scsCQ2nfBIpQ93cc1w3ETZE0Zw5cybW9Yf8I2iMMcb8seHvFn/X+K/tXzxdjena1U917dNPdPWTK+GapE/Cc1J4N5Om83KdLjuTwrOp33O3cWv6fe+nU2grpsxn10OZzHRLXaQkb/g9O+8XTtd1A1tP39/IfJfRbrRNZvuz+5B5n1Hu1jT9PLPcLflJc+S/5Xnms8yUWS4z763P4jjCv6OuMgfC9XffP/kWn63zM/Nh+t1UOa5JyqyP+pOU+XxWmj0XuWeuTifm7dVPLscUn90yh5lDs/t2a6LvMSV9zHx2N8+T+9hH+jr9O6bZv6fTzLgznk0nvjv/hv1D/hvVQo0xxhhjjDHGGGNMlmChxhhjjDHGGGOMMSZLsFBjjDHGGGOMMcYYkyVYqDHGGGOMMcYYY4zJEizUGGOMMcYYY4wxxmQJFmqMMcYYY4wxxhhjsgQLNcYYY4wxxhhjjDFZgoUaY4wxxhhjjDHGmCzBQo0xxhhjjDHGGGNMlmChxhhjjDHGGGOMMSZLsFBjjDHGGGOMMcYYkyVYqDHGGGOMMcYYY4zJEizUGGOMMcYYY4wxxmQJFmqMMcYYY4wxxhhjsgQLNcYYY4wxxhhjjDFZgoUaY4wxxhhjjDHGmCzBQo0xxhhjjDHGGGNMlmChxhhzC2cv3dRP376uE69f11O/yEiv/e76dLjy/sWQ78KVm7p5c7rwLG6GF+fOndMLL7yggwcPamxsLKajR4/q5Zdf1vnz53Xjxo3p3NkH/X/rrbf0zjvv6JNPPpl+evdcvf6pPr74gd469Zp+dfLV26a3T7+uS58Gu9z8fLvQrwsXLujVV1/VsWPH9Nxzz+k3v/mNPv300+kcvx/q+MUvfqHXXnttptz169f1/vvv68SJE3r77bfjPfmuXLmiX/3qV/r1r38d7fHmm2/q4sWL8d2dcu3aNX3wwQf65S9/eVf9vFuYT7/97W/j2Ob6Zrz/8MMP45ycnJzUkSNH9OKLL+rMmTNxvLeD8ZIPm509e/auxm+MMcYYY8ydYqHGGDMDbueP37qmvMErWtBwWQ+lMlLdrdf59ZeV23tFr757Q9c+x7/FkX399de1fft2rVq1Slu3blV+fn68J42OjkbHN1vFGsSFvr4+7d+/X6dOnfpCjvnN8L/Tlz/WU2+OqvvFGnW8UHHb1PdSSm+eek1Xb3y+mHHp0iU9++yzqqmpUWVlZUydnZ1RBKHPdwJjGRgY0M6dO2fGRr0jIyNaunSp2tvboxjEc0Sgtra2aIeJiYkotiF23Ol3o47Lly9HUaS1tTV+8z8WiDNPPfWU6uvrP/PN+P3uu++qt7dXu3fvjnOwqKhIO3bs0ODgoE6ePHnbMfEOgbG2tlY///nP79jWxhhjjDHG3A0WaowxM+DSjr50VQ/WXdbfF17U3+bfPn2n8pKOv3ZNn1ydKj8bHOOf/vSnys3NjaLC008/rR/+8IcxCqSuri6KNz/60Y+ic03eq1evRkeaaAiiIrhPnHyEARx8oluI6iCigefvvfdejPAgcieJAMGhJi/CBdEPOOC84zniA1Ej5KceokSIDuEdZXG+yU+d1F1VVaWOjo67EiYyoc4Pzv9Ge15uVvUzm1Xx9IbbJvK89P5zunLtMqWnKskg1vfBB9F+iB4/+clPogCC8IDIcvr06Tg+RArGQn76TsqMZGEsCBrz58+PdsA+H330kXbt2qXly5crLy8vtsNzvhGCzqFDh3T8+PEYEUVeEnamLWxNFA7RN7RJoo2PP/44inXYeWhoSCUlJTF/JkleIqzoS/L96S/v+NaU4UpkD9+Gb5/ZDv3gHeWHh4dVUFAQ6+B9AvkQB3nX3d0dI4eeeeaZ+H1XrlwZI2uSNhGtaIe+Y1PsQHr++eej4IjdyUvCDuTLnIck2qcsfeK3hR1jjDHGGHMnWKgxxsyASzv8wlXdX3NZf799bnEmM/1TxSVNvnxNV36PULNlyxYdOHAgOto4tjjZOK84x+l0OjqzPCNaA/GhsbExOs+IOogoCAA9PT0x6qGrq0upVCpGg7CciugI7hEpEBYQd1555ZWYl7oaGhpiBATOPyICkRBNTU3xPVEjvMd5pw+8J2KCOilLm08++WTsD442jv7dgg3eO/e2Bn6aVtWJ3y/UVJ3YpJ+8d0KXr16K0ThzgZA0Pj4eRSjs89JLL8XIEPqNDXiHvekziaigH/zgBzMRMsBYyDtv3rwoxDD2N954I4pqzc3N2rRpU7QFggV1IeCw1IrlQvv27Ysi1uHDh6MdE1tjZ94juCBU8O2JxMHefE/qIHqF/mdCXkQWviH5+SZExLA8ifa5Ju3wzRCpEH2YT4gf9Jt5Qb+JLCouLtbmzZvj2DOFGtqhH4hQCDSIKoybsVBvsgwMu/T398f66Dt1MqeYo9gqEWoQj1h2huhD3qRfiIn0m/5SlroRt+52uZgxxhhjjPnzxEKNMWaGW4SagrnFmcyEUHPoDoUaxAOc1wQcbJbsIAzgKBPdgAOM2EBeHGqiLxBWiHRYv369SktLo0iAI5+TkxOjXViOgyNMWcQIohsQbnCcqQcRZvXq1VEQQiAgIuSRRx5RS0tLfI8jznIsHG/EAkQZon+oF0ebvAgQ2STUIEYRQUKUDFEuLOHZsGFDjFhCJEFAQRBhfIgI2BEbIkok0C/usSvjRKiiPHZExCgvL4+2IzoHsQEbJAIG9sdW2I52EVdoCxtTH++wNZErfAuWSiGsrVmzJvZ1tlCDYLJ3794ZuyMMIbRQPxFW3BN9xTdLxLnHHnssCkn0mzbKyspiWYQS+rBx48bPCDX8ZskYtiFCiHFhK+YYET/YDpvQLqISwhF9r66uVkVFRVwCxhxLhBrmNoIS84/xc8UeiDJEEiEIMbeI8EFMy7S/McYYY4wxn4eFGmPMDP+aQg2iB44yy2yIrsGhJXoF0YDIGiIk2CsFBx/nGucbkQBRhygGnGAEAqIXcLRxzGkDMYHyPEO0QTTAsV67dm0sS8THww8/HKM0iIggQmLbtm3RIeddYWFhvFIWx5yy2RZRk4BIgVCDELNu3booLCB6ME4EBEQwRCrEC4SDzP7TLyJMsDOiBUIFUTEIXPzG1kSIIEgghFAHQgbCDwIbUSy857uxHAjxBeHkwQcfjLYlGmrhwoX68Y9/HPtJnZQj2mX20iciffgOJIQhlhDRJ6KEiHKh7WXLlkWRhLKINw888EBc8kWkFPOEb8YYib5CMOKbImRlCjWAwIUoyFgRX1gyRjuILNiN78xyMEQq5gB9Z74hDCJkUZb5zBixAcvHWPbEvOMdfcF2jCOJxmLsyfI6Y4wxxhhjfh8WaowxM/xrCzUIAAgJiCkPPfRQdHJx5nmOE434gnBDhAeCCdEwLD/BecfB3rNnTxQPcJKJwCDyAsGA/Ig41EN0BEusFi9eHIUXHHqcfpxyhAqcbMQD6kIUIuKDZS5E/LAMhjoQlP5/9qj5Qws11Emif4wXUYqoDyKOEAWwEQIOYsaSJUuiWDLXCUjJ9yFahTyJjRF72EcIWyCSEK2CSEJEyGyhhigYhDaifLARbSJsEEVC2wgWtINQgZA01x419I2IE6KosDfiBgIe0SmIP8wBhDra5LvQjwULFkRxDXGHqCcEG74nY2euMT8QWmg7AXsh7CWJuhFaiNDBBkRr/exnP9N9990Xl3lRH+XJy1yk/9iH+YyAxRzCzvQXYYxv8P3vfz/OF8SkFStWxHnFEq3MfhhjjDHGGHM7LNQYY2b4Yws1yR4dJAQWRBqW2ODwEuVCNAtREkTQJIlNahERiNzgHkccpxzxAMeZaAyiIBBqWPpCezjpiAg44DjztI9ogFDDUheEG8QdhBeEGqI3WHqDU404gbOO8IBjz5IfBIRsEWqoD/GDqCHGjXCBTYjiYKkRog1RI0TKIBQ88cQTUUzI3J8mE0QThCv2sUGsSMQQRAyWCCGsIAAhxvB8tlCDQIFdeYcwkgg12J3lSXxb7Eb72HcuoYbyRPLwTek335GIKb5pItSwZw6CHuIJwg7ROrSBYMLcYdz0ATGQaBi+6eyIGgQT5gT2wEbUw5yk37TFUjrq++Y3vxnnAPVRnv4RsYQQiLDDfEIgYokTc42lYPSRb4BolCnUJFFOc9neGGOMMcaYubBQY4yZ4Y8l1OAEE61CZEJyChBLT3C2cXZx4olGIIoiWUaD443TTnme3alQwx4mixYtis46DjYON2LF448/Hu8RguYSaogAIRKHZTA43Djv9AFnO5v2qKE+BAv6ibiE6EEUDRFICCos/WEJDiILmyEjqiQbASM8zYboFAQybIKNGTfjRGAhWgZbMn7aQST5PKGGd5lCDVFPLCFCTEEg4ZsRIYMQNluoQRxBmGEPGoQ5vhkRNCw34vfnCTWIfwhI7H1Dv5hb5GE8zIfZQg1zh0gr+oFoRF5EL+YVohICC3OU6CuWT1GevjPPmJsIhuRFqOFKXQg4LIniG5CPiBqEvUSoIUrHQo0xxhhjjLkbLNQYY2b4IkLNnZz6RMTG9773vbi0CUEAxxpHnCgOnGGcbxx0ohNw2HGk2WMEoYDn7AeSCDUIC4griVBDREQi1BDxgGPPEh7a4IoARFmiLnDqEWrYOyQRahAcEGqoK9m4FkcfZxwxhCVZiBHZItQA0SD0lwiaJPIE2yEYIJAQpYS4wti4x5ZErMw1BqJGEC3uueeeGG2CPQEBjO9DhAiCEM8pi/hD5Al1s0wpU6hBKEGoYZkU4kQS5UP/uLJPELadK6KG/hLRw3gQnbgi1CQnPlEHe9fQDoITQg1RRewhgziXfDPa4dvPtUcN/Ucwot/MMdpjLiC2IHJhK8QcljexHC6xLXUyFsbH3jvMKyJqiM5iHyD6iTDGfGVJFiIkglki1BA9ZqHGGGOMMcbcKRZqjDEz3CLU3Onx3K98vlADOOUICOx1giBA5AqREDi8RGAky0tYaoTzj5BCZAxXHGeWshBhQ9QFjjf5iXJgSQzOMOVwrol24B6nGLEG551oDqI7iIxhz5Vko12eUS/tUhdiEmWJ1KBPRPAgArDMhYifxIH/Is42Zd7/AkLNlavs5zN3e4kogg2xJUt5sAdjwd7YAjGLPjMmTnxiD5i5lj8hXmATbIVggn2BK1EifDsELNqkLFEo7OFDW9gV2yT1IqJhr+Q70RdEG+rG/vRr9ulTQB/59ggfjAdBjnyIIXwPBBrKJpEp9IVvQ/RLcgIW7/lmtE+blGf8s6EtvjXRU4hyCF6UYVzkxx7MDeZEMoeSuUpbXJmLzEm+AX2kz+x9hI2JZsL2zEPGkcxRY4wxxhhj7hQLNcaYGXDhT7x+TY83Xdb/LrqoLxdc1N+FxDUz8Qwh5+H6S3rx19d19fpU+bnA8SUCAieYhJNOwnnlXSY44DjSvOeaiDjkS/In97xLxAMS75N73iX10Db3XClHHvKSD5K6k7LJPeUpk5RP8t8tRMWcvPRbjb3Wq9pnt6ryxMbbpvofFOgXH72kT69/dvPfTOgnffs8WyX3JO4zxzwbylBHYgPgyn1itwSeUTfPuGbahmtm/uQ+6ePn9YN76sn8Zkle6kq+2ex6k/6SeE/527UDPEvGRVtJe0ldSZ7M/iRt85xrcp/8zhwfdSX2mV2vMcYYY4wxd4KFGmPMLZy+eFMvvHVdx35+TUdfvaYj04nfR1+9HlO8D++ff/O6zl3GUZ4ubOYE0eXDC+/qlydf0Rsf/2zO9Pr09c1TP9fFT8/pxs1bRSxjjDHGGGPMnwcWaowxt4DociOk6zc+m25Mp5n7kM8azZ1BVMXNmzeiAHO7RB5b1RhjjDHGmD9fLNQYY4wxxhhjjDHGZAkWaowxxhhjjDHGGGOyBAs1xhhjjDHGGGOMMVmChRpjjDHGGGOMMcaYLMFCjTHGGGOMMcYYY0yWYKHGGGOMMcYYY4wxJkuwUGOMMcYYY4wxxhiTJVioMcYYY4wxxhhjjMkSLNQYY4wxxhhjjDHGZAkWaowxxhhjjDHGGGOyBAs1xhhjjDHGGGOMMVmChRpjjDHGGGOMMcaYLMFCjTHGGGOMMcYYY0yWYKHGGGOMMcYYY4wxJkuwUGOMMcYYY4wxxhiTFUj/DzUcD+HfNxwkAAAAAElFTkSuQmCC)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "o5sbM_JPpdMR" + }, + "source": [ + "\n", + "# Target Audience\n", + "\n", + "This tutorial is designed for those interested in application of ML towards climate change. More specifically, those interested in material/catalyst discovery and Graph Nueral Networks (GNNs) will find lots of benefit here. Little to no domain chemistry knowledge is necessary as it will be covered in the tutorial. Experience with GNNs is a plus but not required. \n", + "\n", + "We have designed this notebook in a manner to get the ML communnity up to speed as far as background knowledge is concerned, and the catalysis community to better understand how to use the OCP's state-of-the-art models in their everyday workflows.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gQgijl46pYzn" + }, + "source": [ + "\n", + "# Background & Prerequisites\n", + "\n", + "Basic experience training ML models. Familiarity with PyTorch. Familiarity with Pytorch-Geometric could be helpful for development, but not required.\n", + "No background in chemistry is assumed.\n", + "\n", + "For those looking to apply our pretrained models on their datasets, familiarity with the [Atomic Simulation Environment](https://wiki.fysik.dtu.dk/ase/#:~:text=The%20Atomic%20Simulation%20Environment%20(ASE,under%20the%20GNU%20LGPL%20license.) is useful." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7BpQklEEIFDD" + }, + "source": [ + "\n", + "## Background References\n", + "\n", + "To gain an even better understanding of the Open Catalyst Project and the problems it seeks to address, we strongly recommend the following resources:\n", + "\n", + "* To learn more about electrocatalysis, see our [white paper](https://arxiv.org/pdf/2010.09435.pdf).\n", + "* To learn about the OC20 dataset and the associated tasks, please see the [OC20 dataset paper](https://arxiv.org/pdf/2010.09990.pdf).\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rSRCNgYzUwaf" + }, + "source": [ + "\n", + "# Software Requirements\n", + "\n", + "All required dependencies can be found here - https://github.com/Open-Catalyst-Project/ocp#installation.\n", + "\n", + "For the following Colab Notebook, we manually install the dependencies below.\n", + "\n", + "For the purpose of the demo, we hihgly recommend you use a GPU. Google Colab provides access to 1 GPU (Runtime -> Change runtime type -> select GPU). The tutorial will function without a GPU, but will be slower for training times." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "58AKzWydvkVu" + }, + "outputs": [], + "source": [ + "# %%bash\n", + "pip install torch==1.7.1+cu110 -f https://download.pytorch.org/whl/torch_stable.html \n", + "pip install demjson==2.2.4 lmdb==1.1.1 ase==3.21 pymatgen==2020.12.31 pyyaml==5.4 tensorboard==2.4 wandb==0.11.2\n", + "pip install torch-scatter==2.0.6 torch-sparse==0.6.9 torch-cluster==1.5.9 torch-spline-conv==1.2.1 torch-geometric==1.6.3 -f https://data.pyg.org/whl/torch-1.7.1+cu110.html\n", + "git clone https://github.com/Open-Catalyst-Project/ocp.git" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { "colab": { - "name": "CCAI - OCP Tutorial", - "provenance": [], - "collapsed_sections": [ - "PoF-BxSM5Jkc", - "bSt6h_Q-oqjK", - "pto2SpJPwlz1", - "gaauxWdNw_-4", - "TcUvAI81xoSt", - "TUH5BaaXo-ca" - ], - "toc_visible": true, - "include_colab_link": true - }, - "kernelspec": { - "display_name": "Python 3", - "name": "python3" - }, - "language_info": { - "name": "python" - }, - "accelerator": "GPU" + "base_uri": "https://localhost:8080/" + }, + "id": "0NDOYuyAvmtO", + "outputId": "e3508b8f-8ade-4000-cdd8-7c5f75865a96" + }, + "outputs": [], + "source": [ + "%cd ocp\n", + "!pip install -e ." + ] }, - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "view-in-github", - "colab_type": "text" - }, - "source": [ - "\"Open" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "dzeHYa5GCxN7" - }, - "source": [ - "# MIT License\n", - "#\n", - "#@title Copyright (c) 2021 CCAI Community Authors { display-mode: \"form\" }\n", - "#\n", - "# Permission is hereby granted, free of charge, to any person obtaining a\n", - "# copy of this software and associated documentation files (the \"Software\"),\n", - "# to deal in the Software without restriction, including without limitation\n", - "# the rights to use, copy, modify, merge, publish, distribute, sublicense,\n", - "# and/or sell copies of the Software, and to permit persons to whom the\n", - "# Software is furnished to do so, subject to the following conditions:\n", - "#\n", - "# The above copyright notice and this permission notice shall be included in\n", - "# all copies or substantial portions of the Software.\n", - "#\n", - "# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n", - "# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n", - "# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\n", - "# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n", - "# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n", - "# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n", - "# DEALINGS IN THE SOFTWARE." - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "13i7KQ9t-CV8" - }, - "source": [ - "# Open Catalyst Project Tutorial Notebook\n", - "Author(s):\n", - "* [Muhammed Shuaibi](https://mshuaibii.github.io/), CMU, mshuaibi@andrew.cmu.edu\n", - "* [Abhishek Das](https://abhishekdas.com/), FAIR, abhshkdz@fb.com \n", - "* [Adeesh Kolluru](https://adeeshkolluru.github.io/), CMU, akolluru@andrew.cmu.edu\n", - "* [Brandon Wood](https://wood-b.github.io/), NERSC, bwood@lbl.gov \n", - "* [Janice Lan](https://www.linkedin.com/in/janice-lan), FAIR, janlan@fb.com\n", - "* [Anuroop Sriram](https://www.linkedin.com/in/anuroopsriram), FAIR, anuroops@fb.com\n", - "* [Zachary Ulissi](https://ulissigroup.cheme.cmu.edu/), CMU, zulissi@andrew.cmu.edu\n", - "* [Larry Zitnick](http://larryzitnick.org/), FAIR, zitnick@fb.com\n", - "\n", - "FAIR - Facebook AI Research\n", - "\n", - "CMU - Carnegie Mellon University\n", - "\n", - "NERSC - National Energy Research Scientific Computing Center\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "E_qIKf8erkfC" - }, - "source": [ - "## Table of Contents\n", - "\n", - "* [Background](#background)\n", - "* [Objective](#objective)\n", - "* [Climate Impact](#climate-impact)\n", - "* [Target Audience](#target-audience)\n", - "* [Background & Prerequisites](#background-and-prereqs)\n", - "* [Software Requirements](#software-requirements)\n", - "* [Dataset Overview & Visualization](#data-description)\n", - " * [Download](#download)\n", - " * [Visualization](#visual)\n", - " * [Data contents](#contents)\n", - "* [Tasks](#tasks)\n", - " * [S2EF](#s2ef)\n", - " * [IS2RE](#is2re)\n", - " * [IS2RS](#is2rs)\n", - "* [OCP Calculator](#calc)\n", - "* [Model development](#model-dev)\n", - "* [Running on command line](#cmd)\n", - "* [Limitations](#limit)\n", - "* [Next steps](#steps)\n", - "* [References](#references)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "JkjKcVJ47hSN" - }, - "source": [ - "## Background \n", - "The discovery of efficient and economic catalysts (materials) are needed to enable the widespread use of renewable energy technologies. A common approach in discovering high performance catalysts is using molecular simulations. Specifically, each simulation models the interaction of a catalyst surface with molecules that are commonly seen in electrochemical reactions. By predicting these interactions accurately, the catalyst's impact on the overall rate of a chemical reaction may be estimated.\n", - "\n", - "An important quantity in screening catalysts is their adsorption energy for the molecules, referred to as `adsorbates', involved in the reaction of interest. The adsorption energy may be found by simulating the interaction of the adsorbate molecule on the surface of the catalyst to find their resting or relaxed energy, i.e., how tightly the adsorbate binds to the catalyst's surface (visualized below). The rate of the chemical reaction, a value of high practical importance, is then commonly approximated using simple functions of the adsorption energy. The goal of this tutorial specifically and the project overall is to encourage research and benchmark progress towards training ML models to approximate this relaxation.\n", - "\n", - "Specifically, during the course of a relaxation, given an initial set of atoms and their positions, the task is to iteratively estimate atomic forces and update atomic positions until a relaxed state is reached. The energy corresponding to the relaxed state is the structure's 'relaxed energy'.\n", - "\n", - "As part of the [Open Catalyst Project](https://github.com/Open-Catalyst-Project/ocp) (OCP), we identify three key tasks ML models need to perform well on in\n", - "order to effectively approximate DFT --\n", - "\n", - " 1) Given an **I**nitial **S**tructure, predict the **R**elaxed **E**nergy of the relaxed strucutre (**IS2RE**),\n", - "\n", - " 2) Given an **I**nitial **S**tructure, predict the **R**elaxed **S**tructure (**IS2RS**),\n", - "\n", - " 3) Given any **S**tructure, predict the structure **E**nergy and per-atom **F**orces (**S2EF**)." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "FPeCifZbtiKJ" - }, - "source": [ - "![Capture2.PNG](data:image/png;base64,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)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "PvjO99jp7xnh" - }, - "source": [ - "## Objective \n", - "This notebook serves as a tutorial for interacting with the Open Catalyst Project.\n", - "\n", - "By the end of this tutorial, users will have gained:\n", - "* Intuition to the dataset and it's properties\n", - "* Knowledge of the various OCP tasks: IS2RE, IS2RS, S2EF\n", - "* Steps to train, validate, and predict a model on the various tasks\n", - "* A walkthrough on creating your own model\n", - "* (Optional) Creating your own dataset for other molecular/catalyst applications \n", - "* (Optional) Using pretrained models directly with an [ASE](https://wiki.fysik.dtu.dk/ase/#:~:text=The%20Atomic%20Simulation%20Environment%20(ASE,under%20the%20GNU%20LGPL%20license.)-style calculator." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "99jkSa_KmrDH" - }, - "source": [ - "\n", - "# Climate Impact\n", - "\n", - "Scalable and cost-effective solutions to renewable energy storage are essential to addressing the world’s rising energy needs while reducing climate change. As illustrated in the figure below, as we increase our reliance on renewable energy sources such as wind and solar, which produce intermittent power, storage is needed to transfer power from times of peak generation to peak demand. This may require the storage of power for hours, days, or months. One solution that offers the potential of scaling to nation-sized grids is the conversion of renewable energy to other fuels, such as hydrogen. To be widely adopted, this process requires cost-effective solutions to running chemical reactions.\n", - "\n", - "An open challenge is finding low-cost catalysts to drive these reactions at high rates. Through the use of quantum mechanical simulations (Density Functional Theory, DFT), new catalyst structures can be tested and evaluated. Unfortunately, the high computational cost of these simulations limits the number of structures that may be tested. The use of AI or machine learning may provide a method to efficiently approximate these calculations; reducing the time required from 24} hours to a second. This capability would transform the search for new catalysts from the present day practice of evaluating O(1,000) of handpicked candidates to the brute force search over millions or even billions of candidates.\n", - "\n", - "As part of OCP, we publicly released the world's largest quantum mechanical simulation dataset -- [OC20](https://github.com/Open-Catalyst-Project/ocp/blob/master/DATASET.md) -- in the Fall of 2020 along with a suite of baselines and evaluation metrics. The creation of the dataset required over 70 million hours of compute. This dataset enables the exploration of techniques that will generalize across different catalyst materials and adsorbates. If successful, models trained on the dataset could enable the computational testing of millions of catalyst materials for a wide variety of chemical reactions. However, techniques that achieve the accuracies required** for practical impact are still beyond reach and remain an open area for research, thus encouraging research in this important area to help in meeting the world's energy needs in the decades ahead.\n", - "\n", - "** The computational catalysis community often aims for an adsorption energy MAE of 0.1-0.2 eV for practical relevance." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "jcpOlBcTsYVa" - }, - "source": [ - "![Capture.PNG](data:image/png;base64,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)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "o5sbM_JPpdMR" - }, - "source": [ - "\n", - "# Target Audience\n", - "\n", - "This tutorial is designed for those interested in application of ML towards climate change. More specifically, those interested in material/catalyst discovery and Graph Nueral Networks (GNNs) will find lots of benefit here. Little to no domain chemistry knowledge is necessary as it will be covered in the tutorial. Experience with GNNs is a plus but not required. \n", - "\n", - "We have designed this notebook in a manner to get the ML communnity up to speed as far as background knowledge is concerned, and the catalysis community to better understand how to use the OCP's state-of-the-art models in their everyday workflows.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "gQgijl46pYzn" - }, - "source": [ - "\n", - "# Background & Prerequisites\n", - "\n", - "Basic experience training ML models. Familiarity with PyTorch. Familiarity with Pytorch-Geometric could be helpful for development, but not required.\n", - "No background in chemistry is assumed.\n", - "\n", - "For those looking to apply our pretrained models on their datasets, familiarity with the [Atomic Simulation Environment](https://wiki.fysik.dtu.dk/ase/#:~:text=The%20Atomic%20Simulation%20Environment%20(ASE,under%20the%20GNU%20LGPL%20license.) is useful." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "7BpQklEEIFDD" - }, - "source": [ - "\n", - "## Background References\n", - "\n", - "To gain an even better understanding of the Open Catalyst Project and the problems it seeks to address, we strongly recommend the following resources:\n", - "\n", - "* To learn more about electrocatalysis, see our [white paper](https://arxiv.org/pdf/2010.09435.pdf).\n", - "* To learn about the OC20 dataset and the associated tasks, please see the [OC20 dataset paper](https://arxiv.org/pdf/2010.09990.pdf).\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "rSRCNgYzUwaf" - }, - "source": [ - "\n", - "# Software Requirements\n", - "\n", - "All required dependencies can be found here - https://github.com/Open-Catalyst-Project/ocp#installation.\n", - "\n", - "For the following Colab Notebook, we manually install the dependencies below.\n", - "\n", - "For the purpose of the demo, we hihgly recommend you use a GPU. Google Colab provides access to 1 GPU (Runtime -> Change runtime type -> select GPU). The tutorial will function without a GPU, but will be slower for training times." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "58AKzWydvkVu" - }, - "source": [ - "# %%bash\n", - "pip install torch==1.7.1+cu110 -f https://download.pytorch.org/whl/torch_stable.html \n", - "pip install demjson==2.2.4 lmdb==1.1.1 ase==3.21 pymatgen==2020.12.31 pyyaml==5.4 tensorboard==2.4 wandb==0.11.2\n", - "pip install torch-scatter==2.0.6 torch-sparse==0.6.9 torch-cluster==1.5.9 torch-spline-conv==1.2.1 torch-geometric==1.6.3 -f https://data.pyg.org/whl/torch-1.7.1+cu110.html\n", - "git clone https://github.com/Open-Catalyst-Project/ocp.git" - ], - "execution_count": 1, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "0NDOYuyAvmtO", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "e3508b8f-8ade-4000-cdd8-7c5f75865a96" - }, - "source": [ - "%cd ocp\n", - "!pip install -e ." - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "/content/ocp\n", - "Obtaining file:///content/ocp\n", - " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", - " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", - " Preparing wheel metadata ... \u001b[?25l\u001b[?25hdone\n", - "Installing collected packages: ocp-models\n", - " Running setup.py develop for ocp-models\n", - "Successfully installed ocp-models-0.0.3\n" - ] - } - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "LS0Tllp95tSu", - "outputId": "c2821fbe-093a-4a8d-ad43-6f2e61a9499a" - }, - "source": [ - "import torch\n", - "torch.cuda.is_available()" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "True" - ] - }, - "metadata": {}, - "execution_count": 3 - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "jXoiLncsU3pe" - }, - "source": [ - "\n", - "# Dataset Overview\n", - "\n", - "The Open Catalyst 2020 Dataset (OC20) will be used throughout this tutorial. More details can be found [here](https://github.com/Open-Catalyst-Project/ocp/blob/master/DATASET.md) and the corresponding [paper](https://arxiv.org/abs/2010.09990). Data is stored in PyTorch Geometric [Data](https://pytorch-geometric.readthedocs.io/en/latest/modules/data.html) objects and stored in LMDB files. For each task we include several sized training splits. Validation/Test splits are broken into several subsplits: In Domain (ID), Out of Domain Adsorbate (OOD-Ads), Out of Domain Catalyast (OOD-Cat) and Out of Domain Adsorbate and Catalyst (OOD-Both). Split sizes are summarized below:\n", - "\n", - "Train\n", - "* S2EF - 200k, 2M, 20M, 134M(All)\n", - "* IS2RE/IS2RS - 10k, 100k, 460k(All)\n", - "\n", - "Val/Test\n", - "* S2EF - ~1M across all subsplits\n", - "* IS2RE/IS2RS - ~25k across all splits\n", - "\n", - "#### **Tutorial Use**\n", - "\n", - "For the sake of this tutorial we provide much smaller splits (100 train, 20 val for all tasks) to allow users to easily store, train, and predict across the various tasks. Please refer [here](https://github.com/Open-Catalyst-Project/ocp#download-data) for details on how to download the full datasets for general use.\n", - "\n", - " " - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "FIiwpALzBKaH" - }, - "source": [ - "![oc20.png](data:image/png;base64,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)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "PoF-BxSM5Jkc" - }, - "source": [ - "## Data Download [~1min] \n", - "FOR TUTORIAL USE ONLY" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "LEITxr5no8kh" - }, - "source": [ - "%%bash\n", - "mkdir data\n", - "cd data\n", - "wget -q http://dl.fbaipublicfiles.com/opencatalystproject/data/tutorial_data.tar.gz -O tutorial_data.tar.gz\n", - "tar -xzvf tutorial_data.tar.gz\n", - "rm tutorial_data.tar.gz" - ], - "execution_count": 2, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "bSt6h_Q-oqjK" - }, - "source": [ - "## Data Visualization " - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "HodnfJpE8D0u" - }, - "source": [ - "import matplotlib\n", - "matplotlib.use('Agg')\n", - "\n", - "import os\n", - "import numpy as np\n", - "\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib inline\n", - "\n", - "params = {\n", - " 'axes.labelsize': 14,\n", - " 'font.size': 14,\n", - " 'font.family': ' DejaVu Sans',\n", - " 'legend.fontsize': 20,\n", - " 'xtick.labelsize': 20,\n", - " 'ytick.labelsize': 20,\n", - " 'axes.labelsize': 25,\n", - " 'axes.titlesize': 25,\n", - " 'text.usetex': False,\n", - " 'figure.figsize': [12, 12]\n", - "}\n", - "matplotlib.rcParams.update(params)\n", - "\n", - "\n", - "import ase.io\n", - "from ase.io.trajectory import Trajectory\n", - "from ase.io import extxyz\n", - "from ase.calculators.emt import EMT\n", - "from ase.build import fcc100, add_adsorbate, molecule\n", - "from ase.constraints import FixAtoms\n", - "from ase.optimize import LBFGS\n", - "from ase.visualize.plot import plot_atoms\n", - "from ase import Atoms\n", - "from IPython.display import Image" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "VRR5C88U8mH1" - }, - "source": [ - "### Understanding the data\n", - "We use the Atomic Simulation Environment (ASE) library to interact with our data. This notebook will provide you with some intuition on how atomic data is generated, how the data is structured, how to visualize the data, and the specific properties that are passed on to our models." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "hEDcCSGD86Hg" - }, - "source": [ - "### Generating sample data\n", - "\n", - "The OC20 dataset was generated using density functional theory (DFT), a quantum chemistry method for modeling atomistic environments. For more details, please see our dataset paper. In this notebook, we generate sample data in the same format as the OC20 dataset; however, we use a faster method that is less accurate called effective-medium theory (EMT) because our DFT calculations are too computationally expensive to run here. EMT is great for demonstration purposes but not accurate enough for our actual catalysis applications. Below is a structural relaxation of a catalyst system, a propane (C3H8) adsorbate on a copper (Cu) surface. Throughout this tutorial a surface may be referred to as a slab and the combination of an adsorbate and a surface as an adslab." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "y6Hx8JtXEbW-" - }, - "source": [ - "### Structural relaxations\n", - "\n", - "A structural relaxation or structure optimization is the process of iteratively updating atom positions to find the atom positions that minimize the energy of the structure. Standard optimization methods are used in structural relaxations — below we use the Limited-Memory Broyden–Fletcher–Goldfarb–Shanno (LBFGS) algorithm. The step number, time, energy, and force max are printed at each optimization step. Each step is considered one example because it provides all the information we need to train models for the S2EF task and the entire set of steps is referred to as a trajectory. Visualizing intermediate structures or viewing the entire trajectory can be illuminating to understand what is physically happening and to look for problems in the simulation, especially when we run ML-driven relaxations. Common problems one may look out for - atoms excessively overlapping/colliding with each other and atoms flying off into random directions." - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "GEpQz9In9GrX", - "outputId": "96cd7bc8-2877-4b35-e133-80a10ad81b61" - }, - "source": [ - "###DATA GENERATION - FEEL FREE TO SKIP###\n", - "\n", - "# This cell sets up and runs a structural relaxation \n", - "# of a propane (C3H8) adsorbate on a copper (Cu) surface\n", - "\n", - "adslab = fcc100(\"Cu\", size=(3, 3, 3))\n", - "adsorbate = molecule(\"C3H8\")\n", - "add_adsorbate(adslab, adsorbate, 3, offset=(1, 1)) # adslab = adsorbate + slab\n", - "\n", - "# tag all slab atoms below surface as 0, surface as 1, adsorbate as 2\n", - "tags = np.zeros(len(adslab))\n", - "tags[18:27] = 1\n", - "tags[27:] = 2\n", - "\n", - "adslab.set_tags(tags)\n", - "\n", - "# Fixed atoms are prevented from moving during a structure relaxation. \n", - "# We fix all slab atoms beneath the surface. \n", - "cons= FixAtoms(indices=[atom.index for atom in adslab if (atom.tag == 0)])\n", - "adslab.set_constraint(cons)\n", - "adslab.center(vacuum=13.0, axis=2)\n", - "adslab.set_pbc(True)\n", - "adslab.set_calculator(EMT())\n", - "\n", - "os.makedirs('data', exist_ok=True)\n", - "\n", - "# Define structure optimizer - LBFGS. Run for 100 steps, \n", - "# or if the max force on all atoms (fmax) is below 0 ev/A.\n", - "# fmax is typically set to 0.01-0.05 eV/A, \n", - "# for this demo however we run for the full 100 steps.\n", - "\n", - "dyn = LBFGS(adslab, trajectory=\"data/toy_c3h8_relax.traj\")\n", - "dyn.run(fmax=0, steps=100)\n", - "\n", - "traj = ase.io.read(\"data/toy_c3h8_relax.traj\", \":\")\n", - "\n", - "# convert traj format to extxyz format (used by OC20 dataset)\n", - "columns = (['symbols','positions', 'move_mask', 'tags'])\n", - "with open('data/toy_c3h8_relax.extxyz','w') as f:\n", - " extxyz.write_xyz(f, traj, columns=columns)" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - " Step Time Energy fmax\n", - "*Force-consistent energies used in optimization.\n", - "LBFGS: 0 01:59:21 15.804700* 6.7764\n", - "LBFGS: 1 01:59:21 12.190607* 4.3232\n", - "LBFGS: 2 01:59:21 10.240169* 2.2655\n", - "LBFGS: 3 01:59:22 9.779223* 0.9372\n", - "LBFGS: 4 01:59:22 9.671525* 0.7702\n", - "LBFGS: 5 01:59:22 9.574461* 0.6635\n", - "LBFGS: 6 01:59:22 9.537502* 0.5718\n", - "LBFGS: 7 01:59:22 9.516673* 0.4466\n", - "LBFGS: 8 01:59:22 9.481330* 0.4611\n", - "LBFGS: 9 01:59:22 9.462255* 0.2931\n", - "LBFGS: 10 01:59:22 9.448937* 0.2490\n", - "LBFGS: 11 01:59:22 9.433813* 0.2371\n", - "LBFGS: 12 01:59:22 9.418884* 0.2602\n", - "LBFGS: 13 01:59:23 9.409649* 0.2532\n", - "LBFGS: 14 01:59:23 9.404838* 0.1624\n", - "LBFGS: 15 01:59:23 9.401753* 0.1823\n", - "LBFGS: 16 01:59:23 9.397314* 0.2592\n", - "LBFGS: 17 01:59:23 9.387947* 0.3450\n", - "LBFGS: 18 01:59:23 9.370825* 0.4070\n", - "LBFGS: 19 01:59:23 9.342222* 0.4333\n", - "LBFGS: 20 01:59:23 9.286822* 0.5002\n", - "LBFGS: 21 01:59:23 9.249910* 0.5241\n", - "LBFGS: 22 01:59:23 9.187179* 0.5120\n", - "LBFGS: 23 01:59:24 9.124811* 0.5718\n", - "LBFGS: 24 01:59:24 9.066185* 0.5409\n", - "LBFGS: 25 01:59:24 9.000116* 1.0798\n", - "LBFGS: 26 01:59:24 8.893632* 0.7528\n", - "LBFGS: 27 01:59:24 8.845939* 0.3321\n", - "LBFGS: 28 01:59:24 8.815173* 0.2512\n", - "LBFGS: 29 01:59:24 8.808721* 0.2143\n", - "LBFGS: 30 01:59:24 8.794643* 0.1546\n", - "LBFGS: 31 01:59:24 8.789162* 0.2014\n", - "LBFGS: 32 01:59:24 8.782320* 0.1755\n", - "LBFGS: 33 01:59:25 8.780394* 0.1037\n", - "LBFGS: 34 01:59:25 8.778410* 0.1076\n", - "LBFGS: 35 01:59:25 8.775079* 0.1797\n", - "LBFGS: 36 01:59:25 8.766987* 0.3334\n", - "LBFGS: 37 01:59:25 8.750249* 0.5307\n", - "LBFGS: 38 01:59:25 8.725928* 0.6851\n", - "LBFGS: 39 01:59:25 8.702312* 0.5823\n", - "LBFGS: 40 01:59:25 8.661515* 0.3996\n", - "LBFGS: 41 01:59:25 8.643432* 0.5585\n", - "LBFGS: 42 01:59:25 8.621201* 0.3673\n", - "LBFGS: 43 01:59:26 8.614414* 0.1394\n", - "LBFGS: 44 01:59:26 8.610785* 0.1372\n", - "LBFGS: 45 01:59:26 8.608134* 0.1464\n", - "LBFGS: 46 01:59:26 8.604928* 0.1196\n", - "LBFGS: 47 01:59:26 8.599151* 0.1354\n", - "LBFGS: 48 01:59:26 8.594063* 0.1479\n", - "LBFGS: 49 01:59:26 8.589493* 0.1538\n", - "LBFGS: 50 01:59:26 8.587274* 0.0885\n", - "LBFGS: 51 01:59:26 8.584633* 0.0938\n", - "LBFGS: 52 01:59:26 8.580239* 0.1409\n", - "LBFGS: 53 01:59:27 8.572938* 0.2543\n", - "LBFGS: 54 01:59:27 8.563343* 0.2919\n", - "LBFGS: 55 01:59:27 8.554117* 0.1966\n", - "LBFGS: 56 01:59:27 8.547597* 0.1291\n", - "LBFGS: 57 01:59:27 8.542086* 0.1280\n", - "LBFGS: 58 01:59:27 8.535432* 0.0982\n", - "LBFGS: 59 01:59:27 8.533622* 0.1277\n", - "LBFGS: 60 01:59:27 8.527487* 0.1167\n", - "LBFGS: 61 01:59:27 8.523863* 0.1218\n", - "LBFGS: 62 01:59:28 8.519229* 0.1305\n", - "LBFGS: 63 01:59:28 8.515424* 0.1019\n", - "LBFGS: 64 01:59:28 8.511240* 0.2122\n", - "LBFGS: 65 01:59:28 8.507967* 0.2666\n", - "LBFGS: 66 01:59:28 8.503903* 0.2377\n", - "LBFGS: 67 01:59:28 8.497575* 0.1623\n", - "LBFGS: 68 01:59:28 8.485434* 0.2022\n", - "LBFGS: 69 01:59:28 8.466738* 0.2159\n", - "LBFGS: 70 01:59:28 8.467607* 0.3348\n", - "LBFGS: 71 01:59:29 8.454037* 0.1063\n", - "LBFGS: 72 01:59:29 8.448980* 0.1197\n", - "LBFGS: 73 01:59:29 8.446550* 0.0992\n", - "LBFGS: 74 01:59:29 8.444705* 0.0562\n", - "LBFGS: 75 01:59:29 8.443403* 0.0388\n", - "LBFGS: 76 01:59:29 8.442646* 0.0548\n", - "LBFGS: 77 01:59:29 8.442114* 0.0614\n", - "LBFGS: 78 01:59:29 8.440960* 0.0588\n", - "LBFGS: 79 01:59:29 8.439820* 0.0482\n", - "LBFGS: 80 01:59:29 8.438600* 0.0513\n", - "LBFGS: 81 01:59:30 8.437429* 0.0541\n", - "LBFGS: 82 01:59:30 8.435695* 0.0672\n", - "LBFGS: 83 01:59:30 8.431957* 0.0857\n", - "LBFGS: 84 01:59:30 8.423485* 0.1332\n", - "LBFGS: 85 01:59:30 8.413846* 0.2078\n", - "LBFGS: 86 01:59:30 8.404849* 0.1787\n", - "LBFGS: 87 01:59:30 8.385339* 0.1690\n", - "LBFGS: 88 01:59:30 8.386849* 0.1876\n", - "LBFGS: 89 01:59:30 8.371078* 0.1181\n", - "LBFGS: 90 01:59:31 8.368801* 0.0942\n", - "LBFGS: 91 01:59:31 8.366226* 0.0670\n", - "LBFGS: 92 01:59:31 8.361680* 0.0550\n", - "LBFGS: 93 01:59:31 8.360631* 0.0473\n", - "LBFGS: 94 01:59:31 8.359692* 0.0242\n", - "LBFGS: 95 01:59:31 8.359361* 0.0155\n", - "LBFGS: 96 01:59:31 8.359163* 0.0143\n", - "LBFGS: 97 01:59:31 8.359102* 0.0156\n", - "LBFGS: 98 01:59:31 8.359048* 0.0155\n", - "LBFGS: 99 01:59:31 8.358986* 0.0142\n", - "LBFGS: 100 01:59:32 8.358921* 0.0132\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.7/dist-packages/ase/io/extxyz.py:302: UserWarning: Skipping unhashable information adsorbate_info\n", - " '{0}'.format(key))\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Kb77jRtz9fws" - }, - "source": [ - "### Reading a trajectory" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "mUbvcij59d6I" - }, - "source": [ - "identifier = \"toy_c3h8_relax.extxyz\"\n", - "\n", - "# the `index` argument corresponds to what frame of the trajectory to read in, specifiying \":\" reads in the full trajectory.\n", - "traj = ase.io.read(f\"data/{identifier}\", index=\":\")" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "b_e6zDVx9pTC" - }, - "source": [ - "### Viewing a trajectory\n", - "\n", - "Below we visualize the initial, middle, and final steps in the structural relaxation trajectory from above. Copper atoms in the surface are colored orange, the propane adsorbate on the surface has grey colored carbon atoms and white colored hydrogen atoms. The adsorbate’s structure changes during the simulation and you can see how it relaxes on the surface. In this case, the relaxation looks normal; however, there can be instances where the adsorbate flies away (desorbs) from the surface or the adsorbate can break apart (dissociation), which are hard to detect without visualization. Additionally, visualizations can be used as a quick sanity check to ensure the initial system is set up correctly and there are no major issues with the simulation.\n" - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 680 - }, - "id": "CV5qe6IP9vZg", - "outputId": "256f97d6-daa7-40fa-ef50-7ba0ca005f9d" - }, - "source": [ - "fig, ax = plt.subplots(1, 3)\n", - "labels = ['initial', 'middle', 'final']\n", - "for i in range(3):\n", - " ax[i].axis('off')\n", - " ax[i].set_title(labels[i])\n", - "ase.visualize.plot.plot_atoms(traj[0], \n", - " ax[0], \n", - " radii=0.8, \n", - " rotation=(\"-75x, 45y, 10z\"))\n", - "ase.visualize.plot.plot_atoms(traj[50], \n", - " ax[1], \n", - " radii=0.8, \n", - " rotation=(\"-75x, 45y, 10z\"))\n", - "ase.visualize.plot.plot_atoms(traj[-1], \n", - " ax[2], \n", - " radii=0.8, \n", - " rotation=(\"-75x, 45y, 10z\"))" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "" - ] - }, - "metadata": {}, - "execution_count": 7 - }, - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "SSR1vQZ1_Ojq" - }, - "source": [ - "### Data contents \n", - "\n", - "Here we take a closer look at what information is contained within these trajectories." - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "9x8w3o17_May", - "outputId": "a6ed3414-774f-4e9c-f211-73379999f6a0" - }, - "source": [ - "i_structure = traj[0]\n", - "i_structure" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "Atoms(symbols='Cu27C3H8', pbc=True, cell=[7.65796644025031, 7.65796644025031, 33.266996999999996], energies=..., forces=..., tags=..., constraint=FixAtoms(indices=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]), calculator=SinglePointCalculator(...))" - ] - }, - "metadata": {}, - "execution_count": 8 - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "4CgeShkN_bdJ" - }, - "source": [ - "#### Atomic numbers" - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "cMGTQRIz_f2c", - "outputId": "20442973-b999-4723-ec66-ac169203dfbe" - }, - "source": [ - "numbers = i_structure.get_atomic_numbers()\n", - "print(numbers)" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "[29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29 29\n", - " 29 29 29 6 6 6 1 1 1 1 1 1 1 1]\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "ol4Zi2Gh_qU_" - }, - "source": [ - "#### Atomic symbols" - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "cwbxks-i_uVq", - "outputId": "4960d233-b6c8-42bb-979d-879b6a20cfd4" - }, - "source": [ - "symbols = np.array(i_structure.get_chemical_symbols())\n", - "print(symbols)" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "['Cu' 'Cu' 'Cu' 'Cu' 'Cu' 'Cu' 'Cu' 'Cu' 'Cu' 'Cu' 'Cu' 'Cu' 'Cu' 'Cu'\n", - " 'Cu' 'Cu' 'Cu' 'Cu' 'Cu' 'Cu' 'Cu' 'Cu' 'Cu' 'Cu' 'Cu' 'Cu' 'Cu' 'C' 'C'\n", - " 'C' 'H' 'H' 'H' 'H' 'H' 'H' 'H' 'H']\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "x57XplOw_yNw" - }, - "source": [ - "#### Unit cell\n", - "\n", - "The unit cell is the volume containing our system of interest. Express as a 3x3 array representing the directional vectors that make up the volume. Illustrated as the dashed box in the above visuals." - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "VWMMzn_i_0vM", - "outputId": "9fd0343a-9599-4fcb-911d-87ac48974bc0" - }, - "source": [ - "cell = np.array(i_structure.cell)\n", - "print(cell)" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "[[ 7.65796644 0. 0. ]\n", - " [ 0. 7.65796644 0. ]\n", - " [ 0. 0. 33.266997 ]]\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "XHRbOyaA_97r" - }, - "source": [ - "#### Periodic boundary conditions (PBC)\n", - "\n", - "x,y,z boolean representing whether a unit cell repeats in the corresponding directions. The OC20 dataset sets this to [True, True, True], with a large enough vacuum layer above the surface such that a unit cell does not see itself in the z direction. Although the original structure shown above is what get's passed into our models, the presence of PBC allows it to effectively repeat infinitely in the x and y directions. Below we visualize the same structure with a periodicity of 2 in all directions, what the model may effectively see." - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "htvwgCuFAOSB", - "outputId": "578202d3-f9c5-4857-c2c1-86ee6aaf5aa0" - }, - "source": [ - "pbc = i_structure.pbc\n", - "print(pbc)" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "[ True True True]\n" - ] - } - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 400 - }, - "id": "Flzo7aO-RgyA", - "outputId": "36835a5f-cc91-48d1-ee8b-8fc5112c0cb6" - }, - "source": [ - "fig, ax = plt.subplots(1, 3)\n", - "labels = ['initial', 'middle', 'final']\n", - "for i in range(3):\n", - " ax[i].axis('off')\n", - " ax[i].set_title(labels[i])\n", - "\n", - "ase.visualize.plot.plot_atoms(traj[0].repeat((2,2,1)), \n", - " ax[0], \n", - " radii=0.8, \n", - " rotation=(\"-75x, 45y, 10z\"))\n", - "ase.visualize.plot.plot_atoms(traj[50].repeat((2,2,1)), \n", - " ax[1], \n", - " radii=0.8, \n", - " rotation=(\"-75x, 45y, 10z\"))\n", - "ase.visualize.plot.plot_atoms(traj[-1].repeat((2,2,1)), \n", - " ax[2], \n", - " radii=0.8, \n", - " rotation=(\"-75x, 45y, 10z\"))" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "" - ] - }, - "metadata": {}, - "execution_count": 13 - }, - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "TWGXcH7AARpy" - }, - "source": [ - "#### Tags\n", - "\n", - "The OC20 dataset consists of systems with several different types of atoms. To help with identifying the index of certain atoms, we tag each atom according to where it is found in the system. There are three categories of atoms: \n", - "- *sub-surface slab atoms*: these are atoms in the bottom layers of the catalyst, furthest away from the adsorbate\n", - "- *surface slab atoms*: these are atoms in the top layers of the catalyst, close to where the adsorbate will be placed \n", - "- *adsorbate atoms*: atoms that make up the adsorbate molecule on top of the catalyst.\n", - "\n", - "Tag:\n", - "\n", - "0 - Sub-surface slab atoms\n", - "\n", - "1 - Surface slab atoms\n", - "\n", - "2 - Adsorbate atoms\n" - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "SGZzFhsrB5A2", - "outputId": "3b2e4e3e-b82f-4e1a-ed88-e53e3040240b" - }, - "source": [ - "tags = i_structure.get_tags()\n", - "print(tags)" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2\n", - " 2]\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "0zVhbDL2B8cd" - }, - "source": [ - "#### Fixed atoms constraint\n", - "\n", - "In reality, surfaces contain many, many more atoms beneath what we've illustrated as the surface. At an infinite depth, these subsurface atoms would look just like the bulk structure. We approximate a true surface by fixing the subsurface atoms into their “bulk” locations. This ensures that they cannot move at the “bottom” of the surface. If they could, this would throw off our calculations. Consistent with the above, we fix all atoms with tags=0, and denote them as \"fixed\". All other atoms are considered \"free\"." - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "FBMUmGrrCD_h", - "outputId": "4d0aad44-f6bd-491b-d734-5edf5be04031" - }, - "source": [ - "cons = i_structure.constraints[0]\n", - "print(cons, '\\n')\n", - "\n", - "# indices of fixed atoms\n", - "indices = cons.index\n", - "print(indices, '\\n')\n", - "\n", - "# fixed atoms correspond to tags = 0\n", - "print(tags[indices])" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "FixAtoms(indices=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]) \n", - "\n", - "[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17] \n", - "\n", - "[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "_DHAYeBUCHbN" - }, - "source": [ - "#### Adsorption energy\n", - "\n", - "The energy of the system is one of the properties of interest in the OC20 dataset. It's important to note that absolute energies provide little value to researchers and must be referenced properly to be useful. The OC20 dataset references all it's energies to the bare slab + gas references to arrive at adsorption energies. Adsorption energies are important in studying catalysts and their corresponding reaction rates. In addition to the structure relaxations of the OC20 dataset, bare slab and gas (N2, H2, H2O, CO) relaxations were carried out with DFT in order to calculate adsorption energies." - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "5XxYqdM7CMdd", - "outputId": "c2f5ea9c-1614-42ef-fbc0-75fddd7c976f" - }, - "source": [ - "final_structure = traj[-1]\n", - "relaxed_energy = final_structure.get_potential_energy()\n", - "print(f'Relaxed absolute energy = {relaxed_energy} eV')\n", - "\n", - "# Corresponding raw slab used in original adslab (adsorbate+slab) system. \n", - "raw_slab = fcc100(\"Cu\", size=(3, 3, 3))\n", - "raw_slab.set_calculator(EMT())\n", - "raw_slab_energy = raw_slab.get_potential_energy()\n", - "print(f'Raw slab energy = {raw_slab_energy} eV')\n", - "\n", - "\n", - "adsorbate = Atoms(\"C3H8\").get_chemical_symbols()\n", - "# For clarity, we define arbitrary gas reference energies here.\n", - "# A more detailed discussion of these calculations can be found in the corresponding paper's SI. \n", - "gas_reference_energies = {'H': .3, 'O': .45, 'C': .35, 'N': .50}\n", - "\n", - "adsorbate_reference_energy = 0\n", - "for ads in adsorbate:\n", - " adsorbate_reference_energy += gas_reference_energies[ads]\n", - "\n", - "print(f'Adsorbate reference energy = {adsorbate_reference_energy} eV\\n')\n", - "\n", - "adsorption_energy = relaxed_energy - raw_slab_energy - adsorbate_reference_energy\n", - "print(f'Adsorption energy: {adsorption_energy} eV')" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Relaxed absolute energy = 8.358921451420816 eV\n", - "Raw slab energy = 8.127167122751231 eV\n", - "Adsorbate reference energy = 3.4499999999999993 eV\n", - "\n", - "Adsorption energy: -3.218245671330415 eV\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "EchgyYxXCUit" - }, - "source": [ - "#### Plot energy profile of toy trajectory\n", - "\n", - "Plotting the energy profile of our trajectory is a good way to ensure nothing strange has occured. We expect to see a decreasing monotonic function. If the energy is consistently increasing or there's multiple large spikes this could be a sign of some issues in the optimization. This is particularly useful for when analyzing ML-driven relaxations and whether they make general physical sense." - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 482 - }, - "id": "WffoTL5pCSrg", - "outputId": "86e7a0fb-7a34-42ee-db58-edd30323eb54" - }, - "source": [ - "energies = [image.get_potential_energy() - raw_slab_energy - adsorbate_reference_energy for image in traj]\n", - "\n", - "plt.figure(figsize=(7, 7))\n", - "plt.plot(range(len(energies)), energies, lw=3)\n", - "plt.xlabel(\"Step\", fontsize=24)\n", - "plt.ylabel(\"Energy, eV\", fontsize=24)" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "Text(0, 0.5, 'Energy, eV')" - ] - }, - "metadata": {}, - "execution_count": 17 - }, - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - } - } - ] + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "LS0Tllp95tSu", + "outputId": "c2821fbe-093a-4a8d-ad43-6f2e61a9499a" + }, + "outputs": [], + "source": [ + "import torch\n", + "torch.cuda.is_available()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jXoiLncsU3pe" + }, + "source": [ + "\n", + "# Dataset Overview\n", + "\n", + "The Open Catalyst 2020 Dataset (OC20) will be used throughout this tutorial. More details can be found [here](https://github.com/Open-Catalyst-Project/ocp/blob/master/DATASET.md) and the corresponding [paper](https://arxiv.org/abs/2010.09990). Data is stored in PyTorch Geometric [Data](https://pytorch-geometric.readthedocs.io/en/latest/modules/data.html) objects and stored in LMDB files. For each task we include several sized training splits. Validation/Test splits are broken into several subsplits: In Domain (ID), Out of Domain Adsorbate (OOD-Ads), Out of Domain Catalyast (OOD-Cat) and Out of Domain Adsorbate and Catalyst (OOD-Both). Split sizes are summarized below:\n", + "\n", + "Train\n", + "* S2EF - 200k, 2M, 20M, 134M(All)\n", + "* IS2RE/IS2RS - 10k, 100k, 460k(All)\n", + "\n", + "Val/Test\n", + "* S2EF - ~1M across all subsplits\n", + "* IS2RE/IS2RS - ~25k across all splits\n", + "\n", + "#### **Tutorial Use**\n", + "\n", + "For the sake of this tutorial we provide much smaller splits (100 train, 20 val for all tasks) to allow users to easily store, train, and predict across the various tasks. Please refer [here](https://github.com/Open-Catalyst-Project/ocp#download-data) for details on how to download the full datasets for general use.\n", + "\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FIiwpALzBKaH" + }, + "source": [ + "![oc20.png](data:image/png;base64,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)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PoF-BxSM5Jkc" + }, + "source": [ + "## Data Download [~1min] \n", + "FOR TUTORIAL USE ONLY" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "LEITxr5no8kh" + }, + "outputs": [], + "source": [ + "%%bash\n", + "mkdir data\n", + "cd data\n", + "wget -q http://dl.fbaipublicfiles.com/opencatalystproject/data/tutorial_data.tar.gz -O tutorial_data.tar.gz\n", + "tar -xzvf tutorial_data.tar.gz\n", + "rm tutorial_data.tar.gz" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bSt6h_Q-oqjK" + }, + "source": [ + "## Data Visualization " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "HodnfJpE8D0u" + }, + "outputs": [], + "source": [ + "import matplotlib\n", + "matplotlib.use('Agg')\n", + "\n", + "import os\n", + "import numpy as np\n", + "\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "params = {\n", + " 'axes.labelsize': 14,\n", + " 'font.size': 14,\n", + " 'font.family': ' DejaVu Sans',\n", + " 'legend.fontsize': 20,\n", + " 'xtick.labelsize': 20,\n", + " 'ytick.labelsize': 20,\n", + " 'axes.labelsize': 25,\n", + " 'axes.titlesize': 25,\n", + " 'text.usetex': False,\n", + " 'figure.figsize': [12, 12]\n", + "}\n", + "matplotlib.rcParams.update(params)\n", + "\n", + "\n", + "import ase.io\n", + "from ase.io.trajectory import Trajectory\n", + "from ase.io import extxyz\n", + "from ase.calculators.emt import EMT\n", + "from ase.build import fcc100, add_adsorbate, molecule\n", + "from ase.constraints import FixAtoms\n", + "from ase.optimize import LBFGS\n", + "from ase.visualize.plot import plot_atoms\n", + "from ase import Atoms\n", + "from IPython.display import Image" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VRR5C88U8mH1" + }, + "source": [ + "### Understanding the data\n", + "We use the Atomic Simulation Environment (ASE) library to interact with our data. This notebook will provide you with some intuition on how atomic data is generated, how the data is structured, how to visualize the data, and the specific properties that are passed on to our models." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hEDcCSGD86Hg" + }, + "source": [ + "### Generating sample data\n", + "\n", + "The OC20 dataset was generated using density functional theory (DFT), a quantum chemistry method for modeling atomistic environments. For more details, please see our dataset paper. In this notebook, we generate sample data in the same format as the OC20 dataset; however, we use a faster method that is less accurate called effective-medium theory (EMT) because our DFT calculations are too computationally expensive to run here. EMT is great for demonstration purposes but not accurate enough for our actual catalysis applications. Below is a structural relaxation of a catalyst system, a propane (C3H8) adsorbate on a copper (Cu) surface. Throughout this tutorial a surface may be referred to as a slab and the combination of an adsorbate and a surface as an adslab." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "y6Hx8JtXEbW-" + }, + "source": [ + "### Structural relaxations\n", + "\n", + "A structural relaxation or structure optimization is the process of iteratively updating atom positions to find the atom positions that minimize the energy of the structure. Standard optimization methods are used in structural relaxations — below we use the Limited-Memory Broyden–Fletcher–Goldfarb–Shanno (LBFGS) algorithm. The step number, time, energy, and force max are printed at each optimization step. Each step is considered one example because it provides all the information we need to train models for the S2EF task and the entire set of steps is referred to as a trajectory. Visualizing intermediate structures or viewing the entire trajectory can be illuminating to understand what is physically happening and to look for problems in the simulation, especially when we run ML-driven relaxations. Common problems one may look out for - atoms excessively overlapping/colliding with each other and atoms flying off into random directions." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "GEpQz9In9GrX", + "outputId": "96cd7bc8-2877-4b35-e133-80a10ad81b61" + }, + "outputs": [], + "source": [ + "###DATA GENERATION - FEEL FREE TO SKIP###\n", + "\n", + "# This cell sets up and runs a structural relaxation \n", + "# of a propane (C3H8) adsorbate on a copper (Cu) surface\n", + "\n", + "adslab = fcc100(\"Cu\", size=(3, 3, 3))\n", + "adsorbate = molecule(\"C3H8\")\n", + "add_adsorbate(adslab, adsorbate, 3, offset=(1, 1)) # adslab = adsorbate + slab\n", + "\n", + "# tag all slab atoms below surface as 0, surface as 1, adsorbate as 2\n", + "tags = np.zeros(len(adslab))\n", + "tags[18:27] = 1\n", + "tags[27:] = 2\n", + "\n", + "adslab.set_tags(tags)\n", + "\n", + "# Fixed atoms are prevented from moving during a structure relaxation. \n", + "# We fix all slab atoms beneath the surface. \n", + "cons= FixAtoms(indices=[atom.index for atom in adslab if (atom.tag == 0)])\n", + "adslab.set_constraint(cons)\n", + "adslab.center(vacuum=13.0, axis=2)\n", + "adslab.set_pbc(True)\n", + "adslab.set_calculator(EMT())\n", + "\n", + "os.makedirs('data', exist_ok=True)\n", + "\n", + "# Define structure optimizer - LBFGS. Run for 100 steps, \n", + "# or if the max force on all atoms (fmax) is below 0 ev/A.\n", + "# fmax is typically set to 0.01-0.05 eV/A, \n", + "# for this demo however we run for the full 100 steps.\n", + "\n", + "dyn = LBFGS(adslab, trajectory=\"data/toy_c3h8_relax.traj\")\n", + "dyn.run(fmax=0, steps=100)\n", + "\n", + "traj = ase.io.read(\"data/toy_c3h8_relax.traj\", \":\")\n", + "\n", + "# convert traj format to extxyz format (used by OC20 dataset)\n", + "columns = (['symbols','positions', 'move_mask', 'tags'])\n", + "with open('data/toy_c3h8_relax.extxyz','w') as f:\n", + " extxyz.write_xyz(f, traj, columns=columns)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Kb77jRtz9fws" + }, + "source": [ + "### Reading a trajectory" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "mUbvcij59d6I" + }, + "outputs": [], + "source": [ + "identifier = \"toy_c3h8_relax.extxyz\"\n", + "\n", + "# the `index` argument corresponds to what frame of the trajectory to read in, specifiying \":\" reads in the full trajectory.\n", + "traj = ase.io.read(f\"data/{identifier}\", index=\":\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "b_e6zDVx9pTC" + }, + "source": [ + "### Viewing a trajectory\n", + "\n", + "Below we visualize the initial, middle, and final steps in the structural relaxation trajectory from above. Copper atoms in the surface are colored orange, the propane adsorbate on the surface has grey colored carbon atoms and white colored hydrogen atoms. The adsorbate’s structure changes during the simulation and you can see how it relaxes on the surface. In this case, the relaxation looks normal; however, there can be instances where the adsorbate flies away (desorbs) from the surface or the adsorbate can break apart (dissociation), which are hard to detect without visualization. Additionally, visualizations can be used as a quick sanity check to ensure the initial system is set up correctly and there are no major issues with the simulation.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 680 + }, + "id": "CV5qe6IP9vZg", + "outputId": "256f97d6-daa7-40fa-ef50-7ba0ca005f9d" + }, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(1, 3)\n", + "labels = ['initial', 'middle', 'final']\n", + "for i in range(3):\n", + " ax[i].axis('off')\n", + " ax[i].set_title(labels[i])\n", + "ase.visualize.plot.plot_atoms(traj[0], \n", + " ax[0], \n", + " radii=0.8, \n", + " rotation=(\"-75x, 45y, 10z\"))\n", + "ase.visualize.plot.plot_atoms(traj[50], \n", + " ax[1], \n", + " radii=0.8, \n", + " rotation=(\"-75x, 45y, 10z\"))\n", + "ase.visualize.plot.plot_atoms(traj[-1], \n", + " ax[2], \n", + " radii=0.8, \n", + " rotation=(\"-75x, 45y, 10z\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "SSR1vQZ1_Ojq" + }, + "source": [ + "### Data contents \n", + "\n", + "Here we take a closer look at what information is contained within these trajectories." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "9x8w3o17_May", + "outputId": "a6ed3414-774f-4e9c-f211-73379999f6a0" + }, + "outputs": [], + "source": [ + "i_structure = traj[0]\n", + "i_structure" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4CgeShkN_bdJ" + }, + "source": [ + "#### Atomic numbers" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cMGTQRIz_f2c", + "outputId": "20442973-b999-4723-ec66-ac169203dfbe" + }, + "outputs": [], + "source": [ + "numbers = i_structure.get_atomic_numbers()\n", + "print(numbers)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ol4Zi2Gh_qU_" + }, + "source": [ + "#### Atomic symbols" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cwbxks-i_uVq", + "outputId": "4960d233-b6c8-42bb-979d-879b6a20cfd4" + }, + "outputs": [], + "source": [ + "symbols = np.array(i_structure.get_chemical_symbols())\n", + "print(symbols)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "x57XplOw_yNw" + }, + "source": [ + "#### Unit cell\n", + "\n", + "The unit cell is the volume containing our system of interest. Express as a 3x3 array representing the directional vectors that make up the volume. Illustrated as the dashed box in the above visuals." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "VWMMzn_i_0vM", + "outputId": "9fd0343a-9599-4fcb-911d-87ac48974bc0" + }, + "outputs": [], + "source": [ + "cell = np.array(i_structure.cell)\n", + "print(cell)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XHRbOyaA_97r" + }, + "source": [ + "#### Periodic boundary conditions (PBC)\n", + "\n", + "x,y,z boolean representing whether a unit cell repeats in the corresponding directions. The OC20 dataset sets this to [True, True, True], with a large enough vacuum layer above the surface such that a unit cell does not see itself in the z direction. Although the original structure shown above is what get's passed into our models, the presence of PBC allows it to effectively repeat infinitely in the x and y directions. Below we visualize the same structure with a periodicity of 2 in all directions, what the model may effectively see." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "htvwgCuFAOSB", + "outputId": "578202d3-f9c5-4857-c2c1-86ee6aaf5aa0" + }, + "outputs": [], + "source": [ + "pbc = i_structure.pbc\n", + "print(pbc)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 400 + }, + "id": "Flzo7aO-RgyA", + "outputId": "36835a5f-cc91-48d1-ee8b-8fc5112c0cb6" + }, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(1, 3)\n", + "labels = ['initial', 'middle', 'final']\n", + "for i in range(3):\n", + " ax[i].axis('off')\n", + " ax[i].set_title(labels[i])\n", + "\n", + "ase.visualize.plot.plot_atoms(traj[0].repeat((2,2,1)), \n", + " ax[0], \n", + " radii=0.8, \n", + " rotation=(\"-75x, 45y, 10z\"))\n", + "ase.visualize.plot.plot_atoms(traj[50].repeat((2,2,1)), \n", + " ax[1], \n", + " radii=0.8, \n", + " rotation=(\"-75x, 45y, 10z\"))\n", + "ase.visualize.plot.plot_atoms(traj[-1].repeat((2,2,1)), \n", + " ax[2], \n", + " radii=0.8, \n", + " rotation=(\"-75x, 45y, 10z\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TWGXcH7AARpy" + }, + "source": [ + "#### Tags\n", + "\n", + "The OC20 dataset consists of systems with several different types of atoms. To help with identifying the index of certain atoms, we tag each atom according to where it is found in the system. There are three categories of atoms: \n", + "- *sub-surface slab atoms*: these are atoms in the bottom layers of the catalyst, furthest away from the adsorbate\n", + "- *surface slab atoms*: these are atoms in the top layers of the catalyst, close to where the adsorbate will be placed \n", + "- *adsorbate atoms*: atoms that make up the adsorbate molecule on top of the catalyst.\n", + "\n", + "Tag:\n", + "\n", + "0 - Sub-surface slab atoms\n", + "\n", + "1 - Surface slab atoms\n", + "\n", + "2 - Adsorbate atoms\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "SGZzFhsrB5A2", + "outputId": "3b2e4e3e-b82f-4e1a-ed88-e53e3040240b" + }, + "outputs": [], + "source": [ + "tags = i_structure.get_tags()\n", + "print(tags)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0zVhbDL2B8cd" + }, + "source": [ + "#### Fixed atoms constraint\n", + "\n", + "In reality, surfaces contain many, many more atoms beneath what we've illustrated as the surface. At an infinite depth, these subsurface atoms would look just like the bulk structure. We approximate a true surface by fixing the subsurface atoms into their “bulk” locations. This ensures that they cannot move at the “bottom” of the surface. If they could, this would throw off our calculations. Consistent with the above, we fix all atoms with tags=0, and denote them as \"fixed\". All other atoms are considered \"free\"." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "FBMUmGrrCD_h", + "outputId": "4d0aad44-f6bd-491b-d734-5edf5be04031" + }, + "outputs": [], + "source": [ + "cons = i_structure.constraints[0]\n", + "print(cons, '\\n')\n", + "\n", + "# indices of fixed atoms\n", + "indices = cons.index\n", + "print(indices, '\\n')\n", + "\n", + "# fixed atoms correspond to tags = 0\n", + "print(tags[indices])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_DHAYeBUCHbN" + }, + "source": [ + "#### Adsorption energy\n", + "\n", + "The energy of the system is one of the properties of interest in the OC20 dataset. It's important to note that absolute energies provide little value to researchers and must be referenced properly to be useful. The OC20 dataset references all it's energies to the bare slab + gas references to arrive at adsorption energies. Adsorption energies are important in studying catalysts and their corresponding reaction rates. In addition to the structure relaxations of the OC20 dataset, bare slab and gas (N2, H2, H2O, CO) relaxations were carried out with DFT in order to calculate adsorption energies." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "5XxYqdM7CMdd", + "outputId": "c2f5ea9c-1614-42ef-fbc0-75fddd7c976f" + }, + "outputs": [], + "source": [ + "final_structure = traj[-1]\n", + "relaxed_energy = final_structure.get_potential_energy()\n", + "print(f'Relaxed absolute energy = {relaxed_energy} eV')\n", + "\n", + "# Corresponding raw slab used in original adslab (adsorbate+slab) system. \n", + "raw_slab = fcc100(\"Cu\", size=(3, 3, 3))\n", + "raw_slab.set_calculator(EMT())\n", + "raw_slab_energy = raw_slab.get_potential_energy()\n", + "print(f'Raw slab energy = {raw_slab_energy} eV')\n", + "\n", + "\n", + "adsorbate = Atoms(\"C3H8\").get_chemical_symbols()\n", + "# For clarity, we define arbitrary gas reference energies here.\n", + "# A more detailed discussion of these calculations can be found in the corresponding paper's SI. \n", + "gas_reference_energies = {'H': .3, 'O': .45, 'C': .35, 'N': .50}\n", + "\n", + "adsorbate_reference_energy = 0\n", + "for ads in adsorbate:\n", + " adsorbate_reference_energy += gas_reference_energies[ads]\n", + "\n", + "print(f'Adsorbate reference energy = {adsorbate_reference_energy} eV\\n')\n", + "\n", + "adsorption_energy = relaxed_energy - raw_slab_energy - adsorbate_reference_energy\n", + "print(f'Adsorption energy: {adsorption_energy} eV')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EchgyYxXCUit" + }, + "source": [ + "#### Plot energy profile of toy trajectory\n", + "\n", + "Plotting the energy profile of our trajectory is a good way to ensure nothing strange has occured. We expect to see a decreasing monotonic function. If the energy is consistently increasing or there's multiple large spikes this could be a sign of some issues in the optimization. This is particularly useful for when analyzing ML-driven relaxations and whether they make general physical sense." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 482 + }, + "id": "WffoTL5pCSrg", + "outputId": "86e7a0fb-7a34-42ee-db58-edd30323eb54" + }, + "outputs": [], + "source": [ + "energies = [image.get_potential_energy() - raw_slab_energy - adsorbate_reference_energy for image in traj]\n", + "\n", + "plt.figure(figsize=(7, 7))\n", + "plt.plot(range(len(energies)), energies, lw=3)\n", + "plt.xlabel(\"Step\", fontsize=24)\n", + "plt.ylabel(\"Energy, eV\", fontsize=24)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "erpOSowgCeuS" + }, + "source": [ + "#### Force\n", + "\n", + "Forces are another important property of the OC20 dataset. Unlike datasets like QM9 which contain only ground state properties, the OC20 dataset contains per-atom forces necessary to carry out atomistic simulations. Physically, forces are the negative gradient of energy w.r.t atomic positions: $F = -\\frac{dE}{dx}$. Although not mandatory (depending on the application), maintaining this energy-force consistency is important for models that seek to make predictions on both properties.\n", + "\n", + "The \"apply_constraint\" argument controls whether to apply system constraints to the forces. In the OC20 dataset, this controls whether to return forces for fixed atoms (apply_constraint=False) or return 0s (apply_constraint=True)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NtgLDiT2Cmff", + "outputId": "61a720bd-4117-4403-eb07-4d49fd5ddc22" + }, + "outputs": [], + "source": [ + "# Returning forces for all atoms - regardless of whether \"fixed\" or \"free\"\n", + "i_structure.get_forces(apply_constraint=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "QVgvU-OgCqzx", + "outputId": "1a4bed0b-3554-4b42-b41e-7ca84741d66e" + }, + "outputs": [], + "source": [ + "# Applying the fixed atoms constraint to the forces\n", + "i_structure.get_forces(apply_constraint=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "uzDp10XsoHdo" + }, + "source": [ + "### Interacting with the OC20 datasets\n", + "\n", + "The OC20 datasets are stored in LMDBs. Here we show how to interact with the datasets directly in order to better understand the data. We use two seperate classes to read in the approriate datasets:\n", + "\n", + "*S2EF* - We use the [TrajectoryLmdbDataset](https://github.com/Open-Catalyst-Project/ocp/blob/master/ocpmodels/datasets/trajectory_lmdb.py) object to read in a **directory** of LMDB files containing the dataset.\n", + "\n", + "*IS2RE/IS2RS* - We use the [SinglePointLmdbDataset](https://github.com/Open-Catalyst-Project/ocp/blob/master/ocpmodels/datasets/single_point_lmdb.py) class to read in a **single LMDB file** containing the dataset.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "7F7BjxNQoGLn", + "outputId": "36fcd255-facc-43dd-efda-c238cac9c5d9" + }, + "outputs": [], + "source": [ + "from ocpmodels.datasets import TrajectoryLmdbDataset, SinglePointLmdbDataset\n", + "\n", + "# TrajectoryLmdbDataset is our custom Dataset method to read the lmdbs as Data objects. Note that we need to give the path to the folder containing lmdbs for S2EF\n", + "dataset = TrajectoryLmdbDataset({\"src\": \"data/s2ef/train_100/\"})\n", + "\n", + "print(\"Size of the dataset created:\", len(dataset))\n", + "print(dataset[0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "pD5B_TymoJ8S", + "outputId": "72b21c2a-9472-4b08-afe9-c1bd28a5b399" + }, + "outputs": [], + "source": [ + "data = dataset[0]\n", + "data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "rL4u0glIoL8h", + "outputId": "a29c8dfc-617f-48fa-9195-e851b23033e1" + }, + "outputs": [], + "source": [ + "energies = torch.tensor([data.y for data in dataset])\n", + "energies" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 737 + }, + "id": "mkOm2roAoNY2", + "outputId": "aed9b4de-99de-49ab-a21c-3a372166747a" + }, + "outputs": [], + "source": [ + "plt.hist(energies, bins = 50)\n", + "plt.yscale(\"log\")\n", + "plt.xlabel(\"Energies\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "RtECvWIPCu0b" + }, + "source": [ + "### Additional Resources\n", + "\n", + "More helpful resources, tutorials, and documentation can be found at ASE's webpage: https://wiki.fysik.dtu.dk/ase/index.html. We point to specific pages that may be of interest:\n", + "\n", + "* Interacting with Atoms Object: https://wiki.fysik.dtu.dk/ase/ase/atoms.html\n", + "* Visualization: https://wiki.fysik.dtu.dk/ase/ase/visualize/visualize.html\n", + "* Structure optimization: https://wiki.fysik.dtu.dk/ase/ase/optimize.html\n", + "* More ASE Tutorials: https://wiki.fysik.dtu.dk/ase/tutorials/tutorials.html" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qa9Iuu2GU52Z" + }, + "source": [ + "\n", + "# Tasks\n", + "\n", + "In this section, we cover the different types of tasks the OC20 dataset presents and how to train and predict their corresponding models.\n", + "\n", + "1. Structure to Energy and Forces (S2EF)\n", + "2. Initial Structure to Relaxed Energy (IS2RE)\n", + "3. Initial Structure to Relaxed Structure (IS2RS)\n", + "\n", + "Tasks can be interrelated. The figure below illustrates several approaches to solving the IS2RE task:\n", + "\n", + "(a) the traditional approach uses DFT along with an optimizer,\n", + "such as BFGS or conjugate gradient, to iteratively update\n", + "the atom positions until the relaxed structure and energy are found.\n", + "\n", + "(b) using ML models trained to predict the energy and forces of a\n", + "structure, S2EF can be used as a direct replacement for DFT. \n", + "\n", + "(c) the relaxed structure could potentially be directly regressed from\n", + "the initial structure and S2EF used to find the energy.\n", + "\n", + "(d) directly compute the relaxed energy from the initial state.\n", + "\n", + "\n", + "**NOTE** The following sections are intended to demonstrate the inner workings of our codebase and what goes into running the various tasks. We do not recommend training to completion within a notebook setting. Please see the [running on command line](#cmd) section for the preferred way to train/evaluate models." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "W7aZpLzmuNra" + }, + "source": [ + "![tasks.png](data:image/png;base64,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)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "yWXsiZ5freTG" + }, + "source": [ + "## Structure to Energy and Forces (S2EF) \n", + "\n", + "The S2EF task takes an atomic system as input and predicts the energy of the entire system and forces on each atom. This is our most general task, ultimately serving as a surrogate to DFT. A model that can perform well on this task can accelerate other applications like molecular dynamics and transitions tate calculations.\n", + "\n", + "### Steps for training an S2EF model\n", + "1) Define or load a configuration (config), which includes the following\n", + "* task\n", + "* model\n", + "* optimizer\n", + "* dataset\n", + "* trainer\n", + "\n", + "2) Create a ForcesTrainer object\n", + "\n", + "3) Train the model\n", + "\n", + "4) Validate the model\n", + "\n", + "**For storage and compute reasons we use a very small subset of the OC20 S2EF dataset for this tutorial. Results will be considerably worse than presented in our paper.**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2snWOAxnPPyd" + }, + "source": [ + "### Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "l-1rNyuk_1Mo" + }, + "outputs": [], + "source": [ + "from ocpmodels.trainers import OCPTrainer\n", + "from ocpmodels.datasets import LmdbDataset\n", + "from ocpmodels import models\n", + "from ocpmodels.common import logger\n", + "from ocpmodels.common.utils import setup_logging\n", + "setup_logging()\n", + "\n", + "import numpy as np\n", + "import copy\n", + "import os" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OmkUDMQgP5he" + }, + "source": [ + "### Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "1SHl_1eQP4mW" + }, + "outputs": [], + "source": [ + "train_src = \"data/s2ef/train_100\"\n", + "val_src = \"data/s2ef/val_20\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZUpFFV2OWyYJ" + }, + "source": [ + "### Normalize data\n", + "\n", + "If you wish to normalize the targets we must compute the mean and standard deviation for our energy values. Because forces are physically related by the negative gradient of energy, we use the same multiplicative energy factor for forces." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "HAJ3x4SnXE1o" + }, + "outputs": [], + "source": [ + "train_dataset = LmdbDataset({\"src\": train_src})\n", + "\n", + "energies = []\n", + "for data in train_dataset:\n", + " energies.append(data.y)\n", + "\n", + "mean = np.mean(energies)\n", + "stdev = np.std(energies)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ruspSf6CQIk4" + }, + "source": [ + "### Define the Config" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6R6IkYLCQPpH" + }, + "source": [ + "For this example, we will explicitly define the config; however, a set of default configs can be found [here](https://github.com/Open-Catalyst-Project/ocp/tree/master/configs). Default config yaml files can easily be loaded with the following [utility](https://github.com/Open-Catalyst-Project/ocp/blob/aa8e44d50229fce887b3a94a5661c4f85cd73eed/ocpmodels/common/utils.py#L361-L400). Loading a yaml config is preferrable when launching jobs from the command line. We have included our best models' config files here for reference. \n", + "\n", + "**Note** - we only train for a single epoch with a reduced batch size (GPU memory constraints) for demonstration purposes, modify accordingly for full convergence." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "id": "j6Z_XbkiPGR9" + }, + "outputs": [], + "source": [ + "# Task\n", + "task = {\n", + " 'dataset': 'trajectory_lmdb', # dataset used for the S2EF task\n", + " 'description': 'Regressing to energies and forces for DFT trajectories from OCP',\n", + " 'type': 'regression',\n", + " 'metric': 'mae',\n", + " 'labels': ['potential energy'],\n", + " 'grad_input': 'atomic forces',\n", + " 'train_on_free_atoms': True,\n", + " 'eval_on_free_atoms': True\n", + "}\n", + "# Model\n", + "model = {\n", + " \"name\": \"gemnet_oc\",\n", + " \"num_spherical\": 7,\n", + " \"num_radial\": 128,\n", + " \"num_blocks\": 4,\n", + " \"emb_size_atom\": 64,\n", + " \"emb_size_edge\": 64,\n", + " \"emb_size_trip_in\": 64,\n", + " \"emb_size_trip_out\": 64,\n", + " \"emb_size_quad_in\": 32,\n", + " \"emb_size_quad_out\": 32,\n", + " \"emb_size_aint_in\": 64,\n", + " \"emb_size_aint_out\": 64,\n", + " \"emb_size_rbf\": 16,\n", + " \"emb_size_cbf\": 16,\n", + " \"emb_size_sbf\": 32,\n", + " \"num_before_skip\": 2,\n", + " \"num_after_skip\": 2,\n", + " \"num_concat\": 1,\n", + " \"num_atom\": 3,\n", + " \"num_output_afteratom\": 3,\n", + " \"cutoff\": 12.0,\n", + " \"cutoff_qint\": 12.0,\n", + " \"cutoff_aeaint\": 12.0,\n", + " \"cutoff_aint\": 12.0,\n", + " \"max_neighbors\": 30,\n", + " \"max_neighbors_qint\": 8,\n", + " \"max_neighbors_aeaint\": 20,\n", + " \"max_neighbors_aint\": 1000,\n", + " \"rbf\": {\n", + " \"name\": \"gaussian\"\n", + " },\n", + " \"envelope\": {\n", + " \"name\": \"polynomial\",\n", + " \"exponent\": 5\n", + " },\n", + " \"cbf\": {\"name\": \"spherical_harmonics\"},\n", + " \"sbf\": {\"name\": \"legendre_outer\"},\n", + " \"extensive\": True,\n", + " \"output_init\": \"HeOrthogonal\",\n", + " \"activation\": \"silu\",\n", + " \"scale_file\": \"configs/s2ef/all/gemnet/scaling_factors/gemnet-oc.pt\",\n", + "\n", + " \"regress_forces\": True,\n", + " \"direct_forces\": True,\n", + " \"forces_coupled\": False,\n", + "\n", + " \"quad_interaction\": True,\n", + " \"atom_edge_interaction\": True,\n", + " \"edge_atom_interaction\": True,\n", + " \"atom_interaction\": True,\n", + " \n", + " \"num_atom_emb_layers\": 2,\n", + " \"num_global_out_layers\": 2,\n", + " \"qint_tags\": [1, 2],\n", + "}\n", + "\n", + "# Optimizer\n", + "optimizer = {\n", + " 'batch_size': 1, # originally 32\n", + " 'eval_batch_size': 1, # originally 32\n", + " 'num_workers': 2,\n", + " 'lr_initial': 5.e-4,\n", + " 'optimizer': 'AdamW',\n", + " 'optimizer_params': {\"amsgrad\": True},\n", + " 'scheduler': \"ReduceLROnPlateau\",\n", + " 'mode': \"min\",\n", + " 'factor': 0.8,\n", + " 'patience': 3,\n", + " 'max_epochs': 1, # used for demonstration purposes\n", + " 'force_coefficient': 100,\n", + " 'ema_decay': 0.999,\n", + " 'clip_grad_norm': 10,\n", + " 'loss_energy': 'mae',\n", + " 'loss_force': 'l2mae',\n", + "}\n", + "# Dataset\n", + "dataset = [\n", + " {'src': train_src,\n", + " 'normalize_labels': True,\n", + " \"target_mean\": mean,\n", + " \"target_std\": stdev,\n", + " \"grad_target_mean\": 0.0,\n", + " \"grad_target_std\": stdev\n", + " }, # train set \n", + " {'src': val_src}, # val set (optional)\n", + "]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8AsZpLjIQg-W" + }, + "source": [ + "### Create the trainer" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0it4gs6gPGGz", + "outputId": "e7a98c1d-6d4f-425b-878f-4a3a7b42b2ed" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "amp: true\n", + "cmd:\n", + " checkpoint_dir: ./checkpoints/2023-08-01-13-26-40-S2EF-example\n", + " commit: 0bd8935\n", + " identifier: S2EF-example\n", + " logs_dir: ./logs/tensorboard/2023-08-01-13-26-40-S2EF-example\n", + " print_every: 5\n", + " results_dir: ./results/2023-08-01-13-26-40-S2EF-example\n", + " seed: 0\n", + " timestamp_id: 2023-08-01-13-26-40-S2EF-example\n", + "dataset:\n", + " grad_target_mean: 0.0\n", + " grad_target_std: !!python/object/apply:numpy.core.multiarray.scalar\n", + " - &id001 !!python/object/apply:numpy.dtype\n", + " args:\n", + " - f8\n", + " - false\n", + " - true\n", + " state: !!python/tuple\n", + " - 3\n", + " - <\n", + " - null\n", + " - null\n", + " - null\n", + " - -1\n", + " - -1\n", + " - 0\n", + " - !!binary |\n", + " dPVlWhRA+D8=\n", + " normalize_labels: true\n", + " src: data/s2ef/train_100\n", + " target_mean: !!python/object/apply:numpy.core.multiarray.scalar\n", + " - *id001\n", + " - !!binary |\n", + " zSXlDMrm3D8=\n", + " target_std: !!python/object/apply:numpy.core.multiarray.scalar\n", + " - *id001\n", + " - !!binary |\n", + " dPVlWhRA+D8=\n", + "eval_metrics: {}\n", + "gpus: 1\n", + "logger: tensorboard\n", + "loss_fns: {}\n", + "model: gemnet_oc\n", + "model_attributes:\n", + " activation: silu\n", + " atom_edge_interaction: true\n", + " atom_interaction: true\n", + " cbf:\n", + " name: spherical_harmonics\n", + " cutoff: 12.0\n", + " cutoff_aeaint: 12.0\n", + " cutoff_aint: 12.0\n", + " cutoff_qint: 12.0\n", + " direct_forces: true\n", + " edge_atom_interaction: true\n", + " emb_size_aint_in: 64\n", + " emb_size_aint_out: 64\n", + " emb_size_atom: 64\n", + " emb_size_cbf: 16\n", + " emb_size_edge: 64\n", + " emb_size_quad_in: 32\n", + " emb_size_quad_out: 32\n", + " emb_size_rbf: 16\n", + " emb_size_sbf: 32\n", + " emb_size_trip_in: 64\n", + " emb_size_trip_out: 64\n", + " envelope:\n", + " exponent: 5\n", + " name: polynomial\n", + " extensive: true\n", + " forces_coupled: false\n", + " max_neighbors: 30\n", + " max_neighbors_aeaint: 20\n", + " max_neighbors_aint: 1000\n", + " max_neighbors_qint: 8\n", + " num_after_skip: 2\n", + " num_atom: 3\n", + " num_atom_emb_layers: 2\n", + " num_before_skip: 2\n", + " num_blocks: 4\n", + " num_concat: 1\n", + " num_global_out_layers: 2\n", + " num_output_afteratom: 3\n", + " num_radial: 128\n", + " num_spherical: 7\n", + " output_init: HeOrthogonal\n", + " qint_tags:\n", + " - 1\n", + " - 2\n", + " quad_interaction: true\n", + " rbf:\n", + " name: gaussian\n", + " regress_forces: true\n", + " sbf:\n", + " name: legendre_outer\n", + " scale_file: configs/s2ef/all/gemnet/scaling_factors/gemnet-oc.pt\n", + "noddp: false\n", + "optim:\n", + " batch_size: 1\n", + " clip_grad_norm: 10\n", + " ema_decay: 0.999\n", + " eval_batch_size: 1\n", + " factor: 0.8\n", + " force_coefficient: 100\n", + " loss_energy: mae\n", + " loss_force: l2mae\n", + " lr_initial: 0.0005\n", + " max_epochs: 1\n", + " mode: min\n", + " num_workers: 2\n", + " optimizer: AdamW\n", + " optimizer_params:\n", + " amsgrad: true\n", + " patience: 3\n", + " scheduler: ReduceLROnPlateau\n", + "outputs: {}\n", + "slurm: {}\n", + "task:\n", + " dataset: trajectory_lmdb\n", + " description: Regressing to energies and forces for DFT trajectories from OCP\n", + " eval_on_free_atoms: true\n", + " grad_input: atomic forces\n", + " labels:\n", + " - potential energy\n", + " metric: mae\n", + " train_on_free_atoms: true\n", + " type: regression\n", + "trainer: s2ef\n", + "val_dataset:\n", + " src: data/s2ef/val_20\n", + "\n", + "2023-08-01 13:26:43 (INFO): Loading dataset: lmdb\n", + "2023-08-01 13:26:43 (INFO): Batch balancing is disabled for single GPU training.\n", + "2023-08-01 13:26:43 (INFO): Batch balancing is disabled for single GPU training.\n", + "2023-08-01 13:26:43 (INFO): Loading model: gemnet_oc\n", + "2023-08-01 13:26:43 (INFO): Loaded GemNetOC with 2596214 parameters.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-08-01 13:26:43 (WARNING): Model gradient logging to tensorboard not yet supported.\n" + ] + } + ], + "source": [ + "trainer = OCPTrainer(\n", + " task=task,\n", + " model=copy.deepcopy(model), # copied for later use, not necessary in practice.\n", + " dataset=dataset,\n", + " optimizer=optimizer,\n", + " outputs={},\n", + " loss_fns={},\n", + " eval_metrics={},\n", + " name=\"s2ef\",\n", + " identifier=\"S2EF-example\",\n", + " run_dir=\".\", # directory to save results if is_debug=False. Prediction files are saved here so be careful not to override!\n", + " is_debug=False, # if True, do not save checkpoint, logs, or results\n", + " print_every=5,\n", + " seed=0, # random seed to use\n", + " logger=\"tensorboard\", # logger of choice (tensorboard and wandb supported)\n", + " local_rank=0,\n", + " amp=True, # use PyTorch Automatic Mixed Precision (faster training and less memory usage),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vA8nDKt4QqkO" + }, + "source": [ + "### Train the model" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "WFmssq5oPFd_", + "outputId": "a80e93f3-637a-4394-9ec8-4c38bac27461" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2023-08-01 13:26:47 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 1.11e+01, forcesx_mae: 4.63e-01, forcesy_mae: 7.30e-01, forcesz_mae: 5.88e-01, forces_mae: 5.94e-01, forces_cosine_similarity: -2.71e-02, forces_magnitude_error: 1.03e+00, loss: 1.71e+02, lr: 5.00e-04, epoch: 5.00e-02, step: 5.00e+00\n", + "2023-08-01 13:26:48 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 2.26e+01, forcesx_mae: 4.70e-01, forcesy_mae: 6.52e-01, forcesz_mae: 7.01e-01, forces_mae: 6.08e-01, forces_cosine_similarity: 1.11e-02, forces_magnitude_error: 1.12e+00, loss: 1.30e+02, lr: 5.00e-04, epoch: 1.00e-01, step: 1.00e+01\n", + "2023-08-01 13:26:49 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 2.47e+01, forcesx_mae: 4.45e-01, forcesy_mae: 6.03e-01, forcesz_mae: 6.59e-01, forces_mae: 5.69e-01, forces_cosine_similarity: 3.69e-03, forces_magnitude_error: 7.93e-01, loss: 9.21e+01, lr: 5.00e-04, epoch: 1.50e-01, step: 1.50e+01\n", + "2023-08-01 13:26:49 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 2.35e+01, forcesx_mae: 2.35e-01, forcesy_mae: 4.31e-01, forcesz_mae: 3.37e-01, forces_mae: 3.34e-01, forces_cosine_similarity: 8.77e-02, forces_magnitude_error: 4.51e-01, loss: 5.58e+01, lr: 5.00e-04, epoch: 2.00e-01, step: 2.00e+01\n", + "2023-08-01 13:26:50 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 1.33e+01, forcesx_mae: 1.33e-01, forcesy_mae: 1.48e-01, forcesz_mae: 1.77e-01, forces_mae: 1.53e-01, forces_cosine_similarity: -1.11e-02, forces_magnitude_error: 1.63e-01, loss: 2.86e+01, lr: 5.00e-04, epoch: 2.50e-01, step: 2.50e+01\n", + "2023-08-01 13:26:51 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 7.76e+00, forcesx_mae: 1.16e-01, forcesy_mae: 2.85e-01, forcesz_mae: 1.54e-01, forces_mae: 1.85e-01, forces_cosine_similarity: -1.37e-02, forces_magnitude_error: 2.51e-01, loss: 2.96e+01, lr: 5.00e-04, epoch: 3.00e-01, step: 3.00e+01\n", + "2023-08-01 13:26:52 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 7.79e+00, forcesx_mae: 5.18e-02, forcesy_mae: 5.56e-02, forcesz_mae: 5.98e-02, forces_mae: 5.57e-02, forces_cosine_similarity: 9.25e-02, forces_magnitude_error: 6.76e-02, loss: 1.25e+01, lr: 5.00e-04, epoch: 3.50e-01, step: 3.50e+01\n", + "2023-08-01 13:26:53 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 6.20e+00, forcesx_mae: 1.05e-01, forcesy_mae: 1.41e-01, forcesz_mae: 1.80e-01, forces_mae: 1.42e-01, forces_cosine_similarity: 1.38e-01, forces_magnitude_error: 1.89e-01, loss: 2.25e+01, lr: 5.00e-04, epoch: 4.00e-01, step: 4.00e+01\n", + "2023-08-01 13:26:53 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 2.79e+00, forcesx_mae: 1.42e-01, forcesy_mae: 2.08e-01, forcesz_mae: 2.35e-01, forces_mae: 1.95e-01, forces_cosine_similarity: 1.79e-01, forces_magnitude_error: 2.71e-01, loss: 2.65e+01, lr: 5.00e-04, epoch: 4.50e-01, step: 4.50e+01\n", + "2023-08-01 13:26:54 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 2.46e+00, forcesx_mae: 9.11e-02, forcesy_mae: 1.11e-01, forcesz_mae: 1.55e-01, forces_mae: 1.19e-01, forces_cosine_similarity: 1.48e-01, forces_magnitude_error: 1.79e-01, loss: 1.69e+01, lr: 5.00e-04, epoch: 5.00e-01, step: 5.00e+01\n", + "2023-08-01 13:26:55 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 1.65e+00, forcesx_mae: 1.61e-01, forcesy_mae: 1.62e-01, forcesz_mae: 2.43e-01, forces_mae: 1.89e-01, forces_cosine_similarity: 3.51e-01, forces_magnitude_error: 3.24e-01, loss: 2.62e+01, lr: 5.00e-04, epoch: 5.50e-01, step: 5.50e+01\n", + "2023-08-01 13:26:56 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 3.78e-01, forcesx_mae: 3.05e-02, forcesy_mae: 3.90e-02, forcesz_mae: 5.64e-02, forces_mae: 4.20e-02, forces_cosine_similarity: 1.70e-01, forces_magnitude_error: 5.91e-02, loss: 5.78e+00, lr: 5.00e-04, epoch: 6.00e-01, step: 6.00e+01\n", + "2023-08-01 13:26:57 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 8.06e+00, forcesx_mae: 3.03e-01, forcesy_mae: 5.27e-01, forcesz_mae: 4.00e-01, forces_mae: 4.10e-01, forces_cosine_similarity: 3.72e-01, forces_magnitude_error: 6.84e-01, loss: 5.42e+01, lr: 5.00e-04, epoch: 6.50e-01, step: 6.50e+01\n", + "2023-08-01 13:26:57 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 1.99e+00, forcesx_mae: 1.40e-01, forcesy_mae: 1.54e-01, forcesz_mae: 2.23e-01, forces_mae: 1.72e-01, forces_cosine_similarity: 4.15e-01, forces_magnitude_error: 2.86e-01, loss: 2.44e+01, lr: 5.00e-04, epoch: 7.00e-01, step: 7.00e+01\n", + "2023-08-01 13:26:58 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 9.05e-01, forcesx_mae: 8.92e-02, forcesy_mae: 1.32e-01, forcesz_mae: 9.59e-02, forces_mae: 1.06e-01, forces_cosine_similarity: 8.72e-02, forces_magnitude_error: 1.08e-01, loss: 1.26e+01, lr: 5.00e-04, epoch: 7.50e-01, step: 7.50e+01\n", + "2023-08-01 13:26:59 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 1.60e+00, forcesx_mae: 1.41e-01, forcesy_mae: 1.93e-01, forcesz_mae: 1.76e-01, forces_mae: 1.70e-01, forces_cosine_similarity: 2.28e-01, forces_magnitude_error: 2.31e-01, loss: 2.23e+01, lr: 5.00e-04, epoch: 8.00e-01, step: 8.00e+01\n", + "2023-08-01 13:27:00 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 1.50e+00, forcesx_mae: 2.21e-01, forcesy_mae: 8.65e-01, forcesz_mae: 3.35e-01, forces_mae: 4.74e-01, forces_cosine_similarity: 3.66e-01, forces_magnitude_error: 9.49e-01, loss: 5.46e+01, lr: 5.00e-04, epoch: 8.50e-01, step: 8.50e+01\n", + "2023-08-01 13:27:01 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 4.14e+00, forcesx_mae: 5.57e-02, forcesy_mae: 9.36e-02, forcesz_mae: 7.68e-02, forces_mae: 7.53e-02, forces_cosine_similarity: 2.33e-01, forces_magnitude_error: 8.21e-02, loss: 1.16e+01, lr: 5.00e-04, epoch: 9.00e-01, step: 9.00e+01\n", + "2023-08-01 13:27:01 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 9.06e-01, forcesx_mae: 3.69e-02, forcesy_mae: 4.61e-02, forcesz_mae: 6.08e-02, forces_mae: 4.79e-02, forces_cosine_similarity: 2.71e-01, forces_magnitude_error: 5.92e-02, loss: 6.84e+00, lr: 5.00e-04, epoch: 9.50e-01, step: 9.50e+01\n", + "2023-08-01 13:27:02 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 4.97e+00, forcesx_mae: 6.32e-02, forcesy_mae: 1.09e-01, forcesz_mae: 7.56e-02, forces_mae: 8.27e-02, forces_cosine_similarity: 1.50e-01, forces_magnitude_error: 9.81e-02, loss: 1.31e+01, lr: 5.00e-04, epoch: 1.00e+00, step: 1.00e+02\n", + "2023-08-01 13:27:02 (INFO): Evaluating on val.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "device 0: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 20/20 [00:01<00:00, 15.09it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2023-08-01 13:27:04 (INFO): energy_forces_within_threshold: 0.0000, energy_mae: 9.0515, forcesx_mae: 0.3079, forcesy_mae: 0.2660, forcesz_mae: 0.4767, forces_mae: 0.3502, forces_cosine_similarity: 0.0152, forces_magnitude_error: 0.5005, loss: 53.7886, epoch: 1.0000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "trainer.train()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZHkrkULBQ1Xy" + }, + "source": [ + "### Validate the model" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "paYx3_FBQ8OE" + }, + "source": [ + "#### Load the best checkpoint\n", + "\n", + "The `checkpoints` directory contains two checkpoint files:\n", + "\n", + "\n", + "\n", + "* `best_checkpoint.pt` - Model parameters corresponding to the best val performance during training. Used for predictions.\n", + "* `checkpoint.pt` - Model parameters and optimizer settings for the latest checkpoint. Used to continue training.\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "UW4ihgBdQ0Yt", + "outputId": "8226c4d2-041d-46d3-c0d9-02ce85f8fc93" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'./checkpoints/2023-08-01-13-26-40-S2EF-example/best_checkpoint.pt'" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# The `best_checpoint.pt` file contains the checkpoint with the best val performance\n", + "checkpoint_path = os.path.join(trainer.config[\"cmd\"][\"checkpoint_dir\"], \"best_checkpoint.pt\")\n", + "checkpoint_path" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6jppgncMTivj", + "outputId": "a15e13a5-4c1d-4fd4-c2c3-ef9fa210a9dd" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'src': 'data/s2ef/train_100',\n", + " 'normalize_labels': True,\n", + " 'target_mean': 0.45158625849998374,\n", + " 'target_std': 1.5156444102461508,\n", + " 'grad_target_mean': 0.0,\n", + " 'grad_target_std': 1.5156444102461508,\n", + " 'normalizer': {'energy': {'mean': 0.45158625849998374,\n", + " 'stdev': 1.5156444102461508},\n", + " 'forces': {'mean': 0.0, 'stdev': 1.5156444102461508}},\n", + " 'key_mapping': {'y': 'energy', 'force': 'forces'}},\n", + " {'src': 'data/s2ef/val_20'},\n", + " {'src': 'data/s2ef/val_20'}]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Append the dataset with the test set. We use the same val set for demonstration.\n", + "\n", + "# Dataset\n", + "dataset.append(\n", + " {'src': val_src}, # test set (optional)\n", + ")\n", + "dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "MaVROfxzRLaj", + "outputId": "0f143c63-1e1d-44c4-c641-34bac1706c2c" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "amp: true\n", + "cmd:\n", + " checkpoint_dir: ./checkpoints/2023-08-01-13-26-40-S2EF-val-example\n", + " commit: 0bd8935\n", + " identifier: S2EF-val-example\n", + " logs_dir: ./logs/tensorboard/2023-08-01-13-26-40-S2EF-val-example\n", + " print_every: 5\n", + " results_dir: ./results/2023-08-01-13-26-40-S2EF-val-example\n", + " seed: 0\n", + " timestamp_id: 2023-08-01-13-26-40-S2EF-val-example\n", + "dataset:\n", + " grad_target_mean: 0.0\n", + " grad_target_std: !!python/object/apply:numpy.core.multiarray.scalar\n", + " - &id001 !!python/object/apply:numpy.dtype\n", + " args:\n", + " - f8\n", + " - false\n", + " - true\n", + " state: !!python/tuple\n", + " - 3\n", + " - <\n", + " - null\n", + " - null\n", + " - null\n", + " - -1\n", + " - -1\n", + " - 0\n", + " - !!binary |\n", + " dPVlWhRA+D8=\n", + " key_mapping:\n", + " force: forces\n", + " y: energy\n", + " normalize_labels: true\n", + " normalizer:\n", + " energy:\n", + " mean: !!python/object/apply:numpy.core.multiarray.scalar\n", + " - *id001\n", + " - !!binary |\n", + " zSXlDMrm3D8=\n", + " stdev: !!python/object/apply:numpy.core.multiarray.scalar\n", + " - *id001\n", + " - !!binary |\n", + " dPVlWhRA+D8=\n", + " forces:\n", + " mean: 0.0\n", + " stdev: !!python/object/apply:numpy.core.multiarray.scalar\n", + " - *id001\n", + " - !!binary |\n", + " dPVlWhRA+D8=\n", + " src: data/s2ef/train_100\n", + " target_mean: !!python/object/apply:numpy.core.multiarray.scalar\n", + " - *id001\n", + " - !!binary |\n", + " zSXlDMrm3D8=\n", + " target_std: !!python/object/apply:numpy.core.multiarray.scalar\n", + " - *id001\n", + " - !!binary |\n", + " dPVlWhRA+D8=\n", + "eval_metrics: {}\n", + "gpus: 1\n", + "logger: tensorboard\n", + "loss_fns: {}\n", + "model: gemnet_oc\n", + "model_attributes:\n", + " activation: silu\n", + " atom_edge_interaction: true\n", + " atom_interaction: true\n", + " cbf:\n", + " name: spherical_harmonics\n", + " cutoff: 12.0\n", + " cutoff_aeaint: 12.0\n", + " cutoff_aint: 12.0\n", + " cutoff_qint: 12.0\n", + " direct_forces: true\n", + " edge_atom_interaction: true\n", + " emb_size_aint_in: 64\n", + " emb_size_aint_out: 64\n", + " emb_size_atom: 64\n", + " emb_size_cbf: 16\n", + " emb_size_edge: 64\n", + " emb_size_quad_in: 32\n", + " emb_size_quad_out: 32\n", + " emb_size_rbf: 16\n", + " emb_size_sbf: 32\n", + " emb_size_trip_in: 64\n", + " emb_size_trip_out: 64\n", + " envelope:\n", + " exponent: 5\n", + " name: polynomial\n", + " extensive: true\n", + " forces_coupled: false\n", + " max_neighbors: 30\n", + " max_neighbors_aeaint: 20\n", + " max_neighbors_aint: 1000\n", + " max_neighbors_qint: 8\n", + " num_after_skip: 2\n", + " num_atom: 3\n", + " num_atom_emb_layers: 2\n", + " num_before_skip: 2\n", + " num_blocks: 4\n", + " num_concat: 1\n", + " num_global_out_layers: 2\n", + " num_output_afteratom: 3\n", + " num_radial: 128\n", + " num_spherical: 7\n", + " output_init: HeOrthogonal\n", + " qint_tags:\n", + " - 1\n", + " - 2\n", + " quad_interaction: true\n", + " rbf:\n", + " name: gaussian\n", + " regress_forces: true\n", + " sbf:\n", + " name: legendre_outer\n", + " scale_file: configs/s2ef/all/gemnet/scaling_factors/gemnet-oc.pt\n", + "noddp: false\n", + "optim:\n", + " batch_size: 1\n", + " clip_grad_norm: 10\n", + " ema_decay: 0.999\n", + " eval_batch_size: 1\n", + " factor: 0.8\n", + " force_coefficient: 100\n", + " loss_energy: mae\n", + " loss_force: l2mae\n", + " lr_initial: 0.0005\n", + " max_epochs: 1\n", + " mode: min\n", + " num_workers: 2\n", + " optimizer: AdamW\n", + " optimizer_params:\n", + " amsgrad: true\n", + " patience: 3\n", + " scheduler: ReduceLROnPlateau\n", + "outputs: {}\n", + "slurm: {}\n", + "task:\n", + " dataset: trajectory_lmdb\n", + " description: Regressing to energies and forces for DFT trajectories from OCP\n", + " eval_on_free_atoms: true\n", + " grad_input: atomic forces\n", + " labels:\n", + " - potential energy\n", + " metric: mae\n", + " train_on_free_atoms: true\n", + " type: regression\n", + "test_dataset:\n", + " src: data/s2ef/val_20\n", + "trainer: s2ef\n", + "val_dataset:\n", + " src: data/s2ef/val_20\n", + "\n", + "2023-08-01 13:27:14 (INFO): Loading dataset: lmdb\n", + "2023-08-01 13:27:14 (INFO): Batch balancing is disabled for single GPU training.\n", + "2023-08-01 13:27:14 (INFO): Batch balancing is disabled for single GPU training.\n", + "2023-08-01 13:27:14 (INFO): Batch balancing is disabled for single GPU training.\n", + "2023-08-01 13:27:14 (INFO): Loading model: gemnet_oc\n", + "2023-08-01 13:27:15 (INFO): Loaded GemNetOC with 2596214 parameters.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-08-01 13:27:15 (WARNING): Model gradient logging to tensorboard not yet supported.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2023-08-01 13:27:15 (INFO): Loading checkpoint from: ./checkpoints/2023-08-01-13-26-40-S2EF-example/best_checkpoint.pt\n" + ] + } + ], + "source": [ + "pretrained_trainer = OCPTrainer(\n", + " task=task,\n", + " model=copy.deepcopy(model), # copied for later use, not necessary in practice.\n", + " dataset=dataset,\n", + " optimizer=optimizer,\n", + " outputs={},\n", + " loss_fns={},\n", + " eval_metrics={},\n", + " name=\"s2ef\",\n", + " identifier=\"S2EF-val-example\",\n", + " run_dir=\"./\", # directory to save results if is_debug=False. Prediction files are saved here so be careful not to override!\n", + " is_debug=False, # if True, do not save checkpoint, logs, or results\n", + " print_every=5,\n", + " seed=0, # random seed to use\n", + " logger=\"tensorboard\", # logger of choice (tensorboard and wandb supported)\n", + " local_rank=0,\n", + " amp=True, # use PyTorch Automatic Mixed Precision (faster training and less memory usage),\n", + ")\n", + "\n", + "pretrained_trainer.load_checkpoint(checkpoint_path=checkpoint_path)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kWetMgsmRBZS" + }, + "source": [ + "#### Run on the test set" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" }, + "id": "jbiPZNeJQ0WK", + "outputId": "dd346bcd-f30a-4333-a1ca-e18c057cb238" + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": { - "id": "erpOSowgCeuS" - }, - "source": [ - "#### Force\n", - "\n", - "Forces are another important property of the OC20 dataset. Unlike datasets like QM9 which contain only ground state properties, the OC20 dataset contains per-atom forces necessary to carry out atomistic simulations. Physically, forces are the negative gradient of energy w.r.t atomic positions: $F = -\\frac{dE}{dx}$. Although not mandatory (depending on the application), maintaining this energy-force consistency is important for models that seek to make predictions on both properties.\n", - "\n", - "The \"apply_constraint\" argument controls whether to apply system constraints to the forces. In the OC20 dataset, this controls whether to return forces for fixed atoms (apply_constraint=False) or return 0s (apply_constraint=True)." - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "2023-08-01 13:27:20 (INFO): Predicting on test.\n" + ] }, { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "NtgLDiT2Cmff", - "outputId": "61a720bd-4117-4403-eb07-4d49fd5ddc22" - }, - "source": [ - "# Returning forces for all atoms - regardless of whether \"fixed\" or \"free\"\n", - "i_structure.get_forces(apply_constraint=False)" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "array([[-1.07900000e-05, -3.80000000e-06, 1.13560540e-01],\n", - " [-0.00000000e+00, -4.29200000e-05, 1.13302410e-01],\n", - " [ 1.07900000e-05, -3.80000000e-06, 1.13560540e-01],\n", - " [-1.84600000e-05, 0.00000000e+00, 1.13543430e-01],\n", - " [ 0.00000000e+00, -0.00000000e+00, 1.13047800e-01],\n", - " [ 1.84600000e-05, 0.00000000e+00, 1.13543430e-01],\n", - " [-1.07900000e-05, 3.80000000e-06, 1.13560540e-01],\n", - " [-0.00000000e+00, 4.29200000e-05, 1.13302410e-01],\n", - " [ 1.07900000e-05, 3.80000000e-06, 1.13560540e-01],\n", - " [-1.10430500e-02, -2.53094000e-03, -4.84573700e-02],\n", - " [ 1.10430500e-02, -2.53094000e-03, -4.84573700e-02],\n", - " [ 0.00000000e+00, -2.20890000e-04, -2.07827000e-03],\n", - " [-1.10430500e-02, 2.53094000e-03, -4.84573700e-02],\n", - " [ 1.10430500e-02, 2.53094000e-03, -4.84573700e-02],\n", - " [-0.00000000e+00, 2.20890000e-04, -2.07827000e-03],\n", - " [-3.49808000e-03, -0.00000000e+00, -7.85544000e-03],\n", - " [ 3.49808000e-03, -0.00000000e+00, -7.85544000e-03],\n", - " [-0.00000000e+00, -0.00000000e+00, -5.97640000e-04],\n", - " [-3.18144370e-01, -2.36420450e-01, -3.97089230e-01],\n", - " [ 0.00000000e+00, -2.18895316e+00, -2.74768262e+00],\n", - " [ 3.18144370e-01, -2.36420450e-01, -3.97089230e-01],\n", - " [-5.65980520e-01, 0.00000000e+00, -6.16046990e-01],\n", - " [ 0.00000000e+00, 0.00000000e+00, -4.47152822e+00],\n", - " [ 5.65980520e-01, -0.00000000e+00, -6.16046990e-01],\n", - " [-3.18144370e-01, 2.36420450e-01, -3.97089230e-01],\n", - " [ 0.00000000e+00, 2.18895316e+00, -2.74768262e+00],\n", - " [ 3.18144370e-01, 2.36420450e-01, -3.97089230e-01],\n", - " [-0.00000000e+00, 0.00000000e+00, -3.96835355e+00],\n", - " [-0.00000000e+00, -3.64190926e+00, 5.71458646e+00],\n", - " [-0.00000000e+00, 3.64190926e+00, 5.71458646e+00],\n", - " [-2.18178516e+00, -0.00000000e+00, 1.67589182e+00],\n", - " [ 2.18178516e+00, 0.00000000e+00, 1.67589182e+00],\n", - " [-0.00000000e+00, 2.46333681e+00, 1.78299828e+00],\n", - " [-0.00000000e+00, -2.46333681e+00, 1.78299828e+00],\n", - " [ 6.18714050e+00, 2.26336330e-01, -5.99485570e-01],\n", - " [-6.18714050e+00, 2.26336330e-01, -5.99485570e-01],\n", - " [-6.18714050e+00, -2.26336330e-01, -5.99485570e-01],\n", - " [ 6.18714050e+00, -2.26336330e-01, -5.99485570e-01]])" - ] - }, - "metadata": {}, - "execution_count": 18 - } - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "device 0: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 20/20 [00:01<00:00, 15.15it/s]" + ] }, { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "QVgvU-OgCqzx", - "outputId": "1a4bed0b-3554-4b42-b41e-7ca84741d66e" - }, - "source": [ - "# Applying the fixed atoms constraint to the forces\n", - "i_structure.get_forces(apply_constraint=True)" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "array([[ 0. , 0. , 0. ],\n", - " [ 0. , 0. , 0. ],\n", - " [ 0. , 0. , 0. ],\n", - " [ 0. , 0. , 0. ],\n", - " [ 0. , 0. , 0. ],\n", - " [ 0. , 0. , 0. ],\n", - " [ 0. , 0. , 0. ],\n", - " [ 0. , 0. , 0. ],\n", - " [ 0. , 0. , 0. ],\n", - " [ 0. , 0. , 0. ],\n", - " [ 0. , 0. , 0. ],\n", - " [ 0. , 0. , 0. ],\n", - " [ 0. , 0. , 0. ],\n", - " [ 0. , 0. , 0. ],\n", - " [ 0. , 0. , 0. ],\n", - " [ 0. , 0. , 0. ],\n", - " [ 0. , 0. , 0. ],\n", - " [ 0. , 0. , 0. ],\n", - " [-0.31814437, -0.23642045, -0.39708923],\n", - " [ 0. , -2.18895316, -2.74768262],\n", - " [ 0.31814437, -0.23642045, -0.39708923],\n", - " [-0.56598052, 0. , -0.61604699],\n", - " [ 0. , 0. , -4.47152822],\n", - " [ 0.56598052, -0. , -0.61604699],\n", - " [-0.31814437, 0.23642045, -0.39708923],\n", - " [ 0. , 2.18895316, -2.74768262],\n", - " [ 0.31814437, 0.23642045, -0.39708923],\n", - " [-0. , 0. , -3.96835355],\n", - " [-0. , -3.64190926, 5.71458646],\n", - " [-0. , 3.64190926, 5.71458646],\n", - " [-2.18178516, -0. , 1.67589182],\n", - " [ 2.18178516, 0. , 1.67589182],\n", - " [-0. , 2.46333681, 1.78299828],\n", - " [-0. , -2.46333681, 1.78299828],\n", - " [ 6.1871405 , 0.22633633, -0.59948557],\n", - " [-6.1871405 , 0.22633633, -0.59948557],\n", - " [-6.1871405 , -0.22633633, -0.59948557],\n", - " [ 6.1871405 , -0.22633633, -0.59948557]])" - ] - }, - "metadata": {}, - "execution_count": 19 - } - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "2023-08-01 13:27:21 (INFO): Writing results to ./results/2023-08-01-13-26-40-S2EF-val-example/s2ef_s2ef_results.npz\n" + ] }, { - "cell_type": "markdown", - "metadata": { - "id": "uzDp10XsoHdo" - }, - "source": [ - "### Interacting with the OC20 datasets\n", - "\n", - "The OC20 datasets are stored in LMDBs. Here we show how to interact with the datasets directly in order to better understand the data. We use two seperate classes to read in the approriate datasets:\n", - "\n", - "*S2EF* - We use the [TrajectoryLmdbDataset](https://github.com/Open-Catalyst-Project/ocp/blob/master/ocpmodels/datasets/trajectory_lmdb.py) object to read in a **directory** of LMDB files containing the dataset.\n", - "\n", - "*IS2RE/IS2RS* - We use the [SinglePointLmdbDataset](https://github.com/Open-Catalyst-Project/ocp/blob/master/ocpmodels/datasets/single_point_lmdb.py) class to read in a **single LMDB file** containing the dataset.\n", - "\n" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "7F7BjxNQoGLn", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "36fcd255-facc-43dd-efda-c238cac9c5d9" - }, - "source": [ - "from ocpmodels.datasets import TrajectoryLmdbDataset, SinglePointLmdbDataset\n", - "\n", - "# TrajectoryLmdbDataset is our custom Dataset method to read the lmdbs as Data objects. Note that we need to give the path to the folder containing lmdbs for S2EF\n", - "dataset = TrajectoryLmdbDataset({\"src\": \"data/s2ef/train_100/\"})\n", - "\n", - "print(\"Size of the dataset created:\", len(dataset))\n", - "print(dataset[0])" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Size of the dataset created: 100\n", - "Data(atomic_numbers=[86], cell=[1, 3, 3], cell_offsets=[2964, 3], edge_index=[2, 2964], fid=[1], fixed=[86], force=[86, 3], id=\"0_0\", natoms=86, pos=[86, 3], sid=[1], tags=[86], total_frames=74, y=6.282500615000004)\n" - ] - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "pD5B_TymoJ8S", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "72b21c2a-9472-4b08-afe9-c1bd28a5b399" - }, - "source": [ - "data = dataset[0]\n", - "data" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "Data(atomic_numbers=[86], cell=[1, 3, 3], cell_offsets=[2964, 3], edge_index=[2, 2964], fid=[1], fixed=[86], force=[86, 3], id=\"0_0\", natoms=86, pos=[86, 3], sid=[1], tags=[86], total_frames=74, y=6.282500615000004)" - ] - }, - "metadata": {}, - "execution_count": 23 - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "rL4u0glIoL8h", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "a29c8dfc-617f-48fa-9195-e851b23033e1" - }, - "source": [ - "energies = torch.tensor([data.y for data in dataset])\n", - "energies" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "tensor([ 6.2825e+00, 4.1290e+00, 3.1451e+00, 3.0260e+00, 1.7921e+00,\n", - " 1.6451e+00, 1.2257e+00, 1.2161e+00, 1.0712e+00, 7.4727e-01,\n", - " 5.9575e-01, 5.7016e-01, 4.2819e-01, 3.1616e-01, 2.5283e-01,\n", - " 2.2425e-01, 2.2346e-01, 2.0530e-01, 1.6090e-01, 1.1807e-01,\n", - " 1.1691e-01, 9.1254e-02, 7.4997e-02, 6.3274e-02, 5.2782e-02,\n", - " 4.8892e-02, 3.9609e-02, 3.1746e-02, 2.7179e-02, 2.7007e-02,\n", - " 2.3709e-02, 1.8005e-02, 1.7676e-02, 1.4129e-02, 1.3162e-02,\n", - " 1.1374e-02, 7.4124e-03, 7.7525e-03, 6.1224e-03, 5.2787e-03,\n", - " 2.8587e-03, 1.1835e-04, -1.1200e-03, -1.3011e-03, -2.6812e-03,\n", - " -5.9202e-03, -6.1644e-03, -6.9261e-03, -9.1364e-03, -9.2114e-03,\n", - " -1.0665e-02, -1.3760e-02, -1.3588e-02, -1.4895e-02, -1.6190e-02,\n", - " -1.8660e-02, -1.4980e-02, -1.8880e-02, -2.0218e-02, -2.0559e-02,\n", - " -2.1013e-02, -2.2129e-02, -2.2748e-02, -2.3322e-02, -2.3382e-02,\n", - " -2.3865e-02, -2.3973e-02, -2.4196e-02, -2.4755e-02, -2.4951e-02,\n", - " -2.5078e-02, -2.5148e-02, -2.5257e-02, -2.5550e-02, 5.9721e+00,\n", - " 9.5081e+00, 2.6373e+00, 4.0946e+00, 1.4385e+00, 1.2700e+00,\n", - " 1.0081e+00, 5.3797e-01, 5.1462e-01, 2.8812e-01, 1.2429e-01,\n", - " -1.1352e-02, -2.2293e-01, -3.9102e-01, -4.3574e-01, -5.3142e-01,\n", - " -5.4777e-01, -6.3948e-01, -7.3816e-01, -8.2163e-01, -8.2526e-01,\n", - " -8.8313e-01, -8.8615e-01, -9.3446e-01, -9.5100e-01, -9.5168e-01])" - ] - }, - "metadata": {}, - "execution_count": 24 - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "mkOm2roAoNY2", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 737 - }, - "outputId": "aed9b4de-99de-49ab-a21c-3a372166747a" - }, - "source": [ - "plt.hist(energies, bins = 50)\n", - "plt.yscale(\"log\")\n", - "plt.xlabel(\"Energies\")\n", - "plt.show()" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "RtECvWIPCu0b" - }, - "source": [ - "### Additional Resources\n", - "\n", - "More helpful resources, tutorials, and documentation can be found at ASE's webpage: https://wiki.fysik.dtu.dk/ase/index.html. We point to specific pages that may be of interest:\n", - "\n", - "* Interacting with Atoms Object: https://wiki.fysik.dtu.dk/ase/ase/atoms.html\n", - "* Visualization: https://wiki.fysik.dtu.dk/ase/ase/visualize/visualize.html\n", - "* Structure optimization: https://wiki.fysik.dtu.dk/ase/ase/optimize.html\n", - "* More ASE Tutorials: https://wiki.fysik.dtu.dk/ase/tutorials/tutorials.html" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "qa9Iuu2GU52Z" - }, - "source": [ - "\n", - "# Tasks\n", - "\n", - "In this section, we cover the different types of tasks the OC20 dataset presents and how to train and predict their corresponding models.\n", - "\n", - "1. Structure to Energy and Forces (S2EF)\n", - "2. Initial Structure to Relaxed Energy (IS2RE)\n", - "3. Initial Structure to Relaxed Structure (IS2RS)\n", - "\n", - "Tasks can be interrelated. The figure below illustrates several approaches to solving the IS2RE task:\n", - "\n", - "(a) the traditional approach uses DFT along with an optimizer,\n", - "such as BFGS or conjugate gradient, to iteratively update\n", - "the atom positions until the relaxed structure and energy are found.\n", - "\n", - "(b) using ML models trained to predict the energy and forces of a\n", - "structure, S2EF can be used as a direct replacement for DFT. \n", - "\n", - "(c) the relaxed structure could potentially be directly regressed from\n", - "the initial structure and S2EF used to find the energy.\n", - "\n", - "(d) directly compute the relaxed energy from the initial state.\n", - "\n", - "\n", - "**NOTE** The following sections are intended to demonstrate the inner workings of our codebase and what goes into running the various tasks. We do not recommend training to completion within a notebook setting. Please see the [running on command line](#cmd) section for the preferred way to train/evaluate models." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "W7aZpLzmuNra" - }, - "source": [ - "![tasks.png](data:image/png;base64,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)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "yWXsiZ5freTG" - }, - "source": [ - "## Structure to Energy and Forces (S2EF) \n", - "\n", - "The S2EF task takes an atomic system as input and predicts the energy of the entire system and forces on each atom. This is our most general task, ultimately serving as a surrogate to DFT. A model that can perform well on this task can accelerate other applications like molecular dynamics and transitions tate calculations.\n", - "\n", - "### Steps for training an S2EF model\n", - "1) Define or load a configuration (config), which includes the following\n", - "* task\n", - "* model\n", - "* optimizer\n", - "* dataset\n", - "* trainer\n", - "\n", - "2) Create a ForcesTrainer object\n", - "\n", - "3) Train the model\n", - "\n", - "4) Validate the model\n", - "\n", - "**For storage and compute reasons we use a very small subset of the OC20 S2EF dataset for this tutorial. Results will be considerably worse than presented in our paper.**" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "2snWOAxnPPyd" - }, - "source": [ - "### Imports" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "l-1rNyuk_1Mo" - }, - "source": [ - "from ocpmodels.trainers import ForcesTrainer\n", - "from ocpmodels.datasets import TrajectoryLmdbDataset\n", - "from ocpmodels import models\n", - "from ocpmodels.common import logger\n", - "from ocpmodels.common.utils import setup_logging\n", - "setup_logging()\n", - "\n", - "import numpy as np\n", - "import copy\n", - "import os" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "OmkUDMQgP5he" - }, - "source": [ - "### Dataset" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "1SHl_1eQP4mW" - }, - "source": [ - "train_src = \"data/s2ef/train_100\"\n", - "val_src = \"data/s2ef/val_20\"" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "ZUpFFV2OWyYJ" - }, - "source": [ - "### Normalize data\n", - "\n", - "If you wish to normalize the targets we must compute the mean and standard deviation for our energy values. Because forces are physically related by the negative gradient of energy, we use the same multiplicative energy factor for forces." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "HAJ3x4SnXE1o" - }, - "source": [ - "train_dataset = TrajectoryLmdbDataset({\"src\": train_src})\n", - "\n", - "energies = []\n", - "for data in train_dataset:\n", - " energies.append(data.y)\n", - "\n", - "mean = np.mean(energies)\n", - "stdev = np.std(energies)" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "ruspSf6CQIk4" - }, - "source": [ - "### Define the Config" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "6R6IkYLCQPpH" - }, - "source": [ - "For this example, we will explicitly define the config; however, a set of default configs can be found [here](https://github.com/Open-Catalyst-Project/ocp/tree/master/configs). Default config yaml files can easily be loaded with the following [utility](https://github.com/Open-Catalyst-Project/ocp/blob/aa8e44d50229fce887b3a94a5661c4f85cd73eed/ocpmodels/common/utils.py#L361-L400). Loading a yaml config is preferrable when launching jobs from the command line. We have included our best models' config files here for reference. \n", - "\n", - "**Note** - we only train for a single epoch with a reduced batch size (GPU memory constraints) for demonstration purposes, modify accordingly for full convergence." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "j6Z_XbkiPGR9" - }, - "source": [ - "# Task\n", - "task = {\n", - " 'dataset': 'trajectory_lmdb', # dataset used for the S2EF task\n", - " 'description': 'Regressing to energies and forces for DFT trajectories from OCP',\n", - " 'type': 'regression',\n", - " 'metric': 'mae',\n", - " 'labels': ['potential energy'],\n", - " 'grad_input': 'atomic forces',\n", - " 'train_on_free_atoms': True,\n", - " 'eval_on_free_atoms': True\n", - "}\n", - "# Model\n", - "model = {\n", - " 'name': 'gemnet_t',\n", - " \"num_spherical\": 7,\n", - " \"num_radial\": 128,\n", - " \"num_blocks\": 3,\n", - " \"emb_size_atom\": 512,\n", - " \"emb_size_edge\": 512,\n", - " \"emb_size_trip\": 64,\n", - " \"emb_size_rbf\": 16,\n", - " \"emb_size_cbf\": 16,\n", - " \"emb_size_bil_trip\": 64,\n", - " \"num_before_skip\": 1,\n", - " \"num_after_skip\": 2,\n", - " \"num_concat\": 1,\n", - " \"num_atom\": 3,\n", - " \"cutoff\": 6.0,\n", - " \"max_neighbors\": 50,\n", - " \"rbf\": {\"name\": \"gaussian\"},\n", - " \"envelope\": {\n", - " \"name\": \"polynomial\",\n", - " \"exponent\": 5,\n", - " },\n", - " \"cbf\": {\"name\": \"spherical_harmonics\"},\n", - " \"extensive\": True,\n", - " \"otf_graph\": False,\n", - " \"output_init\": \"HeOrthogonal\",\n", - " \"activation\": \"silu\",\n", - " \"scale_file\": \"configs/s2ef/all/gemnet/scaling_factors/gemnet-dT.json\",\n", - " \"regress_forces\": True,\n", - " \"direct_forces\": True,\n", - "}\n", - "# Optimizer\n", - "optimizer = {\n", - " 'batch_size': 1, # originally 32\n", - " 'eval_batch_size': 1, # originally 32\n", - " 'num_workers': 2,\n", - " 'lr_initial': 5.e-4,\n", - " 'optimizer': 'AdamW',\n", - " 'optimizer_params': {\"amsgrad\": True},\n", - " 'scheduler': \"ReduceLROnPlateau\",\n", - " 'mode': \"min\",\n", - " 'factor': 0.8,\n", - " 'patience': 3,\n", - " 'max_epochs': 1, # used for demonstration purposes\n", - " 'force_coefficient': 100,\n", - " 'ema_decay': 0.999,\n", - " 'clip_grad_norm': 10,\n", - " 'loss_energy': 'mae',\n", - " 'loss_force': 'l2mae',\n", - "}\n", - "# Dataset\n", - "dataset = [\n", - " {'src': train_src,\n", - " 'normalize_labels': True,\n", - " \"target_mean\": mean,\n", - " \"target_std\": stdev,\n", - " \"grad_target_mean\": 0.0,\n", - " \"grad_target_std\": stdev\n", - " }, # train set \n", - " {'src': val_src}, # val set (optional)\n", - "]" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "8AsZpLjIQg-W" - }, - "source": [ - "### Create the trainer" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "0it4gs6gPGGz", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "e7a98c1d-6d4f-425b-878f-4a3a7b42b2ed" - }, - "source": [ - "trainer = ForcesTrainer(\n", - " task=task,\n", - " model=copy.deepcopy(model), # copied for later use, not necessary in practice.\n", - " dataset=dataset,\n", - " optimizer=optimizer,\n", - " identifier=\"S2EF-example\",\n", - " run_dir=\"./\", # directory to save results if is_debug=False. Prediction files are saved here so be careful not to override!\n", - " is_debug=False, # if True, do not save checkpoint, logs, or results\n", - " is_vis=False,\n", - " print_every=5,\n", - " seed=0, # random seed to use\n", - " logger=\"tensorboard\", # logger of choice (tensorboard and wandb supported)\n", - " local_rank=0,\n", - " amp=True, # use PyTorch Automatic Mixed Precision (faster training and less memory usage),\n", - ")" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "amp: true\n", - "cmd:\n", - " checkpoint_dir: ./checkpoints/2021-11-22-17-14-40-S2EF-example\n", - " commit: bc04a90\n", - " identifier: S2EF-example\n", - " logs_dir: ./logs/tensorboard/2021-11-22-17-14-40-S2EF-example\n", - " print_every: 5\n", - " results_dir: ./results/2021-11-22-17-14-40-S2EF-example\n", - " seed: 0\n", - " timestamp_id: 2021-11-22-17-14-40-S2EF-example\n", - "dataset:\n", - " grad_target_mean: 0.0\n", - " grad_target_std: !!python/object/apply:numpy.core.multiarray.scalar\n", - " - &id001 !!python/object/apply:numpy.dtype\n", - " args:\n", - " - f8\n", - " - false\n", - " - true\n", - " state: !!python/tuple\n", - " - 3\n", - " - <\n", - " - null\n", - " - null\n", - " - null\n", - " - -1\n", - " - -1\n", - " - 0\n", - " - !!binary |\n", - " dPVlWhRA+D8=\n", - " normalize_labels: true\n", - " src: data/s2ef/train_100\n", - " target_mean: !!python/object/apply:numpy.core.multiarray.scalar\n", - " - *id001\n", - " - !!binary |\n", - " zSXlDMrm3D8=\n", - " target_std: !!python/object/apply:numpy.core.multiarray.scalar\n", - " - *id001\n", - " - !!binary |\n", - " dPVlWhRA+D8=\n", - "gpus: 1\n", - "logger: tensorboard\n", - "model: gemnet_t\n", - "model_attributes:\n", - " activation: silu\n", - " cbf:\n", - " name: spherical_harmonics\n", - " cutoff: 6.0\n", - " direct_forces: true\n", - " emb_size_atom: 512\n", - " emb_size_bil_trip: 64\n", - " emb_size_cbf: 16\n", - " emb_size_edge: 512\n", - " emb_size_rbf: 16\n", - " emb_size_trip: 64\n", - " envelope:\n", - " exponent: 5\n", - " name: polynomial\n", - " extensive: true\n", - " max_neighbors: 50\n", - " num_after_skip: 2\n", - " num_atom: 3\n", - " num_before_skip: 1\n", - " num_blocks: 3\n", - " num_concat: 1\n", - " num_radial: 128\n", - " num_spherical: 7\n", - " otf_graph: false\n", - " output_init: HeOrthogonal\n", - " rbf:\n", - " name: gaussian\n", - " regress_forces: true\n", - " scale_file: configs/s2ef/all/gemnet/scaling_factors/gemnet-dT.json\n", - "optim:\n", - " batch_size: 1\n", - " clip_grad_norm: 10\n", - " ema_decay: 0.999\n", - " eval_batch_size: 1\n", - " factor: 0.8\n", - " force_coefficient: 100\n", - " loss_energy: mae\n", - " loss_force: l2mae\n", - " lr_initial: 0.0005\n", - " max_epochs: 1\n", - " mode: min\n", - " num_workers: 2\n", - " optimizer: AdamW\n", - " optimizer_params:\n", - " amsgrad: true\n", - " patience: 3\n", - " scheduler: ReduceLROnPlateau\n", - "slurm: {}\n", - "task:\n", - " dataset: trajectory_lmdb\n", - " description: Regressing to energies and forces for DFT trajectories from OCP\n", - " eval_on_free_atoms: true\n", - " grad_input: atomic forces\n", - " labels:\n", - " - potential energy\n", - " metric: mae\n", - " train_on_free_atoms: true\n", - " type: regression\n", - "val_dataset:\n", - " src: data/s2ef/val_20\n", - "\n", - "2021-11-22 17:15:16 (INFO): Loading dataset: trajectory_lmdb\n", - "2021-11-22 17:15:16 (INFO): Loading model: gemnet_t\n", - "2021-11-22 17:15:20 (INFO): Loaded GemNetT with 31671825 parameters.\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "2021-11-22 17:15:20 (WARNING): Model gradient logging to tensorboard not yet supported.\n" - ] - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "4yGWsRq3PF8R" - }, - "source": [ - "trainer.model" - ], - "execution_count": 3, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "vA8nDKt4QqkO" - }, - "source": [ - "### Train the model" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "WFmssq5oPFd_", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "a80e93f3-637a-4394-9ec8-4c38bac27461" - }, - "source": [ - "trainer.train()" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "2021-11-22 17:15:33 (INFO): forcesx_mae: 2.37e+00, forcesy_mae: 3.27e+00, forcesz_mae: 3.07e+00, forces_mae: 2.90e+00, forces_cos: -4.09e-02, forces_magnitude: 5.73e+00, energy_mae: 4.82e+01, energy_force_within_threshold: 0.00e+00, loss: 8.53e+02, lr: 5.00e-04, epoch: 5.00e-02, step: 5.00e+00\n", - "2021-11-22 17:15:39 (INFO): forcesx_mae: 2.42e+00, forcesy_mae: 3.28e+00, forcesz_mae: 3.03e+00, forces_mae: 2.91e+00, forces_cos: -1.82e-02, forces_magnitude: 5.77e+00, energy_mae: 4.96e+01, energy_force_within_threshold: 0.00e+00, loss: 7.71e+02, lr: 5.00e-04, epoch: 1.00e-01, step: 1.00e+01\n", - "2021-11-22 17:15:46 (INFO): forcesx_mae: 1.78e+01, forcesy_mae: 8.20e+01, forcesz_mae: 2.61e+01, forces_mae: 4.20e+01, forces_cos: -1.39e-02, forces_magnitude: 9.52e+01, energy_mae: 2.10e+03, energy_force_within_threshold: 0.00e+00, loss: 1.45e+04, lr: 5.00e-04, epoch: 1.50e-01, step: 1.50e+01\n", - "2021-11-22 17:15:53 (INFO): forcesx_mae: 1.17e+01, forcesy_mae: 4.24e+01, forcesz_mae: 1.78e+01, forces_mae: 2.40e+01, forces_cos: -2.96e-02, forces_magnitude: 5.36e+01, energy_mae: 1.12e+03, energy_force_within_threshold: 0.00e+00, loss: 3.92e+03, lr: 5.00e-04, epoch: 2.00e-01, step: 2.00e+01\n", - "2021-11-22 17:15:59 (INFO): forcesx_mae: 1.40e+01, forcesy_mae: 3.46e+01, forcesz_mae: 1.56e+01, forces_mae: 2.14e+01, forces_cos: 9.12e-03, forces_magnitude: 4.50e+01, energy_mae: 4.24e+02, energy_force_within_threshold: 0.00e+00, loss: 4.87e+03, lr: 5.00e-04, epoch: 2.50e-01, step: 2.50e+01\n", - "2021-11-22 17:16:06 (INFO): forcesx_mae: 9.72e+01, forcesy_mae: 2.24e+02, forcesz_mae: 1.05e+02, forces_mae: 1.42e+02, forces_cos: -4.17e-02, forces_magnitude: 3.00e+02, energy_mae: 4.30e+03, energy_force_within_threshold: 0.00e+00, loss: 3.78e+04, lr: 5.00e-04, epoch: 3.00e-01, step: 3.00e+01\n", - "2021-11-22 17:16:12 (INFO): forcesx_mae: 1.33e+00, forcesy_mae: 1.43e+00, forcesz_mae: 1.35e+00, forces_mae: 1.37e+00, forces_cos: 6.92e-03, forces_magnitude: 2.72e+00, energy_mae: 2.62e+01, energy_force_within_threshold: 0.00e+00, loss: 2.00e+02, lr: 5.00e-04, epoch: 3.50e-01, step: 3.50e+01\n", - "2021-11-22 17:16:19 (INFO): forcesx_mae: 1.05e+02, forcesy_mae: 2.08e+02, forcesz_mae: 1.16e+02, forces_mae: 1.43e+02, forces_cos: -2.02e-02, forces_magnitude: 2.95e+02, energy_mae: 3.29e+03, energy_force_within_threshold: 0.00e+00, loss: 3.36e+04, lr: 5.00e-04, epoch: 4.00e-01, step: 4.00e+01\n", - "2021-11-22 17:16:25 (INFO): forcesx_mae: 2.25e+02, forcesy_mae: 5.61e+02, forcesz_mae: 2.86e+02, forces_mae: 3.57e+02, forces_cos: 7.29e-02, forces_magnitude: 7.71e+02, energy_mae: 7.83e+03, energy_force_within_threshold: 0.00e+00, loss: 7.47e+04, lr: 5.00e-04, epoch: 4.50e-01, step: 4.50e+01\n", - "2021-11-22 17:16:32 (INFO): forcesx_mae: 6.88e-01, forcesy_mae: 7.65e-01, forcesz_mae: 6.54e-01, forces_mae: 7.03e-01, forces_cos: -7.49e-02, forces_magnitude: 1.25e+00, energy_mae: 1.88e+01, energy_force_within_threshold: 0.00e+00, loss: 1.05e+02, lr: 5.00e-04, epoch: 5.00e-01, step: 5.00e+01\n", - "2021-11-22 17:16:38 (INFO): forcesx_mae: 5.71e-01, forcesy_mae: 6.43e-01, forcesz_mae: 6.73e-01, forces_mae: 6.29e-01, forces_cos: 1.62e-01, forces_magnitude: 9.06e-01, energy_mae: 2.06e+01, energy_force_within_threshold: 0.00e+00, loss: 9.64e+01, lr: 5.00e-04, epoch: 5.50e-01, step: 5.50e+01\n", - "2021-11-22 17:16:45 (INFO): forcesx_mae: 4.86e-01, forcesy_mae: 4.93e-01, forcesz_mae: 5.01e-01, forces_mae: 4.93e-01, forces_cos: -2.05e-02, forces_magnitude: 9.57e-01, energy_mae: 1.11e+01, energy_force_within_threshold: 0.00e+00, loss: 7.26e+01, lr: 5.00e-04, epoch: 6.00e-01, step: 6.00e+01\n", - "2021-11-22 17:16:51 (INFO): forcesx_mae: 9.37e-01, forcesy_mae: 2.66e+00, forcesz_mae: 1.30e+00, forces_mae: 1.63e+00, forces_cos: 2.07e-01, forces_magnitude: 2.77e+00, energy_mae: 8.03e+00, energy_force_within_threshold: 0.00e+00, loss: 2.04e+02, lr: 5.00e-04, epoch: 6.50e-01, step: 6.50e+01\n", - "2021-11-22 17:16:58 (INFO): forcesx_mae: 4.89e-01, forcesy_mae: 4.57e-01, forcesz_mae: 4.84e-01, forces_mae: 4.77e-01, forces_cos: 1.22e-01, forces_magnitude: 6.81e-01, energy_mae: 6.36e+00, energy_force_within_threshold: 0.00e+00, loss: 6.72e+01, lr: 5.00e-04, epoch: 7.00e-01, step: 7.00e+01\n", - "2021-11-22 17:17:04 (INFO): forcesx_mae: 1.61e+00, forcesy_mae: 1.96e+00, forcesz_mae: 1.58e+00, forces_mae: 1.72e+00, forces_cos: 5.39e-02, forces_magnitude: 3.33e+00, energy_mae: 1.70e+01, energy_force_within_threshold: 0.00e+00, loss: 1.97e+02, lr: 5.00e-04, epoch: 7.50e-01, step: 7.50e+01\n", - "2021-11-22 17:17:11 (INFO): forcesx_mae: 9.00e-01, forcesy_mae: 1.00e+00, forcesz_mae: 1.10e+00, forces_mae: 1.00e+00, forces_cos: 2.08e-02, forces_magnitude: 1.65e+00, energy_mae: 1.93e+01, energy_force_within_threshold: 0.00e+00, loss: 1.34e+02, lr: 5.00e-04, epoch: 8.00e-01, step: 8.00e+01\n", - "2021-11-22 17:17:17 (INFO): forcesx_mae: 6.05e-01, forcesy_mae: 1.65e+00, forcesz_mae: 8.28e-01, forces_mae: 1.03e+00, forces_cos: 5.95e-02, forces_magnitude: 1.87e+00, energy_mae: 1.63e+01, energy_force_within_threshold: 0.00e+00, loss: 1.30e+02, lr: 5.00e-04, epoch: 8.50e-01, step: 8.50e+01\n", - "2021-11-22 17:17:24 (INFO): forcesx_mae: 5.26e-01, forcesy_mae: 7.32e-01, forcesz_mae: 5.05e-01, forces_mae: 5.88e-01, forces_cos: 5.29e-04, forces_magnitude: 1.07e+00, energy_mae: 4.13e+00, energy_force_within_threshold: 0.00e+00, loss: 7.10e+01, lr: 5.00e-04, epoch: 9.00e-01, step: 9.00e+01\n", - "2021-11-22 17:17:30 (INFO): forcesx_mae: 4.01e-01, forcesy_mae: 4.67e-01, forcesz_mae: 3.45e-01, forces_mae: 4.04e-01, forces_cos: 6.19e-02, forces_magnitude: 7.39e-01, energy_mae: 3.07e+00, energy_force_within_threshold: 0.00e+00, loss: 5.64e+01, lr: 5.00e-04, epoch: 9.50e-01, step: 9.50e+01\n", - "2021-11-22 17:17:37 (INFO): forcesx_mae: 4.27e-01, forcesy_mae: 7.22e-01, forcesz_mae: 4.27e-01, forces_mae: 5.25e-01, forces_cos: 4.71e-02, forces_magnitude: 9.01e-01, energy_mae: 8.72e+00, energy_force_within_threshold: 0.00e+00, loss: 6.92e+01, lr: 5.00e-04, epoch: 1.00e+00, step: 1.00e+02\n", - "2021-11-22 17:17:39 (INFO): Evaluating on val.\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "device 0: 100%|██████████| 20/20 [00:02<00:00, 7.13it/s]" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "2021-11-22 17:17:42 (INFO): forcesx_mae: 1.4760, forcesy_mae: 1.1875, forcesz_mae: 1.6235, forces_mae: 1.4290, forces_cos: -0.2961, forces_magnitude: 2.5544, energy_mae: 7.8576, energy_force_within_threshold: 0.0000, loss: 193.1406, epoch: 1.0000\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "ZHkrkULBQ1Xy" - }, - "source": [ - "### Validate the model" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "paYx3_FBQ8OE" - }, - "source": [ - "#### Load the best checkpoint\n", - "\n", - "The `checkpoints` directory contains two checkpoint files:\n", - "\n", - "\n", - "\n", - "* `best_checkpoint.pt` - Model parameters corresponding to the best val performance during training. Used for predictions.\n", - "* `checkpoint.pt` - Model parameters and optimizer settings for the latest checkpoint. Used to continue training.\n", - "\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "UW4ihgBdQ0Yt", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 35 - }, - "outputId": "8226c4d2-041d-46d3-c0d9-02ce85f8fc93" - }, - "source": [ - "# The `best_checpoint.pt` file contains the checkpoint with the best val performance\n", - "checkpoint_path = os.path.join(trainer.config[\"cmd\"][\"checkpoint_dir\"], \"best_checkpoint.pt\")\n", - "checkpoint_path" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "application/vnd.google.colaboratory.intrinsic+json": { - "type": "string" - }, - "text/plain": [ - "'./checkpoints/2021-11-22-17-14-40-S2EF-example/best_checkpoint.pt'" - ] - }, - "metadata": {}, - "execution_count": 12 - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "6jppgncMTivj", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "a15e13a5-4c1d-4fd4-c2c3-ef9fa210a9dd" - }, - "source": [ - "# Append the dataset with the test set. We use the same val set for demonstration.\n", - "\n", - "# Dataset\n", - "dataset.append(\n", - " {'src': val_src}, # test set (optional)\n", - ")\n", - "dataset" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "[{'grad_target_mean': 0.0,\n", - " 'grad_target_std': 1.5156444102461508,\n", - " 'normalize_labels': True,\n", - " 'src': 'data/s2ef/train_100',\n", - " 'target_mean': 0.45158625849998374,\n", - " 'target_std': 1.5156444102461508},\n", - " {'src': 'data/s2ef/val_20'},\n", - " {'src': 'data/s2ef/val_20'}]" - ] - }, - "metadata": {}, - "execution_count": 13 - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "MaVROfxzRLaj", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "0f143c63-1e1d-44c4-c641-34bac1706c2c" - }, - "source": [ - "pretrained_trainer = ForcesTrainer(\n", - " task=task,\n", - " model=model,\n", - " dataset=dataset,\n", - " optimizer=optimizer,\n", - " identifier=\"S2EF-val-example\",\n", - " run_dir=\"./\", # directory to save results if is_debug=False. Prediction files are saved here so be careful not to override!\n", - " is_debug=False, # if True, do not save checkpoint, logs, or results\n", - " is_vis=False,\n", - " print_every=10,\n", - " seed=0, # random seed to use\n", - " logger=\"tensorboard\", # logger of choice (tensorboard and wandb supported)\n", - " local_rank=0,\n", - " amp=True, # use PyTorch Automatic Mixed Precision (faster training and less memory usage)\n", - ")\n", - "\n", - "pretrained_trainer.load_checkpoint(checkpoint_path=checkpoint_path)" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "amp: true\n", - "cmd:\n", - " checkpoint_dir: ./checkpoints/2021-11-22-17-16-48-S2EF-val-example\n", - " commit: bc04a90\n", - " identifier: S2EF-val-example\n", - " logs_dir: ./logs/tensorboard/2021-11-22-17-16-48-S2EF-val-example\n", - " print_every: 10\n", - " results_dir: ./results/2021-11-22-17-16-48-S2EF-val-example\n", - " seed: 0\n", - " timestamp_id: 2021-11-22-17-16-48-S2EF-val-example\n", - "dataset:\n", - " grad_target_mean: 0.0\n", - " grad_target_std: !!python/object/apply:numpy.core.multiarray.scalar\n", - " - &id001 !!python/object/apply:numpy.dtype\n", - " args:\n", - " - f8\n", - " - false\n", - " - true\n", - " state: !!python/tuple\n", - " - 3\n", - " - <\n", - " - null\n", - " - null\n", - " - null\n", - " - -1\n", - " - -1\n", - " - 0\n", - " - !!binary |\n", - " dPVlWhRA+D8=\n", - " normalize_labels: true\n", - " src: data/s2ef/train_100\n", - " target_mean: !!python/object/apply:numpy.core.multiarray.scalar\n", - " - *id001\n", - " - !!binary |\n", - " zSXlDMrm3D8=\n", - " target_std: !!python/object/apply:numpy.core.multiarray.scalar\n", - " - *id001\n", - " - !!binary |\n", - " dPVlWhRA+D8=\n", - "gpus: 1\n", - "logger: tensorboard\n", - "model: gemnet_t\n", - "model_attributes:\n", - " activation: silu\n", - " cbf:\n", - " name: spherical_harmonics\n", - " cutoff: 6.0\n", - " direct_forces: true\n", - " emb_size_atom: 512\n", - " emb_size_bil_trip: 64\n", - " emb_size_cbf: 16\n", - " emb_size_edge: 512\n", - " emb_size_rbf: 16\n", - " emb_size_trip: 64\n", - " envelope:\n", - " exponent: 5\n", - " name: polynomial\n", - " extensive: true\n", - " max_neighbors: 50\n", - " num_after_skip: 2\n", - " num_atom: 3\n", - " num_before_skip: 1\n", - " num_blocks: 3\n", - " num_concat: 1\n", - " num_radial: 128\n", - " num_spherical: 7\n", - " otf_graph: false\n", - " output_init: HeOrthogonal\n", - " rbf:\n", - " name: gaussian\n", - " regress_forces: true\n", - " scale_file: configs/s2ef/all/gemnet/scaling_factors/gemnet-dT.json\n", - "optim:\n", - " batch_size: 1\n", - " clip_grad_norm: 10\n", - " ema_decay: 0.999\n", - " eval_batch_size: 1\n", - " factor: 0.8\n", - " force_coefficient: 100\n", - " loss_energy: mae\n", - " loss_force: l2mae\n", - " lr_initial: 0.0005\n", - " max_epochs: 1\n", - " mode: min\n", - " num_workers: 2\n", - " optimizer: AdamW\n", - " optimizer_params:\n", - " amsgrad: true\n", - " patience: 3\n", - " scheduler: ReduceLROnPlateau\n", - "slurm: {}\n", - "task:\n", - " dataset: trajectory_lmdb\n", - " description: Regressing to energies and forces for DFT trajectories from OCP\n", - " eval_on_free_atoms: true\n", - " grad_input: atomic forces\n", - " labels:\n", - " - potential energy\n", - " metric: mae\n", - " train_on_free_atoms: true\n", - " type: regression\n", - "test_dataset:\n", - " src: data/s2ef/val_20\n", - "val_dataset:\n", - " src: data/s2ef/val_20\n", - "\n", - "2021-11-22 17:17:43 (INFO): Loading dataset: trajectory_lmdb\n", - "2021-11-22 17:17:43 (INFO): Loading model: gemnet_t\n", - "2021-11-22 17:17:46 (INFO): Loaded GemNetT with 31671825 parameters.\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "2021-11-22 17:17:46 (WARNING): Model gradient logging to tensorboard not yet supported.\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "2021-11-22 17:17:46 (INFO): Loading checkpoint from: ./checkpoints/2021-11-22-17-14-40-S2EF-example/best_checkpoint.pt\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "kWetMgsmRBZS" - }, - "source": [ - "#### Run on the test set" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "jbiPZNeJQ0WK", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "dd346bcd-f30a-4333-a1ca-e18c057cb238" - }, - "source": [ - "# make predictions on the existing test_loader\n", - "predictions = pretrained_trainer.predict(pretrained_trainer.test_loader, results_file=\"s2ef_results\", disable_tqdm=False)" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "2021-11-22 17:17:46 (INFO): Predicting on test.\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "device 0: 100%|██████████| 20/20 [00:02<00:00, 7.47it/s]" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "2021-11-22 17:17:49 (INFO): Writing results to ./results/2021-11-22-17-16-48-S2EF-val-example/s2ef_s2ef_results.npz\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "\n" - ] - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "zaZGqeyqNCXz" - }, - "source": [ - "energies = predictions[\"energy\"]\n", - "forces = predictions[\"forces\"]" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "o8L28axZ4NVj" - }, - "source": [ - "## Initial Structure to Relaxed Energy (IS2RE) \n", - "The IS2RE task predicts the relaxed energy (energy of the relaxed state) given the initial state of a system. One approach to this is by training a regression model mapping the initial structure to the relaxed energy. We call this the *direct* approach to the IS2RE task. \n", - "\n", - "An alternative is to perform a structure relaxation using an S2EF model to obtain the relaxed state and compute the energy of that state (see the IS2RS task below for details about relaxation).\n", - "\n", - "### Steps for training an IS2RE model\n", - "1) Define or load a configuration (config), which includes the following\n", - "* task\n", - "* model\n", - "* optimizer\n", - "* dataset\n", - "* trainer\n", - "\n", - "2) Create an EnergyTrainer object\n", - "\n", - "3) Train the model\n", - "\n", - "4) Validate the model" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "kEPPcr0YYHpH" - }, - "source": [ - "### Imports" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "d-0GsaGDW16G" - }, - "source": [ - "from ocpmodels.trainers import EnergyTrainer\n", - "from ocpmodels.datasets import SinglePointLmdbDataset\n", - "from ocpmodels import models\n", - "from ocpmodels.common import logger\n", - "from ocpmodels.common.utils import setup_logging\n", - "setup_logging()\n", - "\n", - "import numpy as np\n", - "import copy\n", - "import os" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "w20BJZ_GYWat" - }, - "source": [ - "### Dataset" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "BlL5gGPQW1te" - }, - "source": [ - "train_src = \"data/is2re/train_100/data.lmdb\"\n", - "val_src = \"data/is2re/val_20/data.lmdb\"" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "yT5qHT2wamPh" - }, - "source": [ - "### Normalize data\n", - "\n", - "If you wish to normalize the targets we must compute the mean and standard deviation for our energy values." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "vaY-ZUMaamPh" - }, - "source": [ - "train_dataset = SinglePointLmdbDataset({\"src\": train_src})\n", - "\n", - "energies = []\n", - "for data in train_dataset:\n", - " energies.append(data.y_relaxed)\n", - "\n", - "mean = np.mean(energies)\n", - "stdev = np.std(energies)" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "K4SSW0UGYeYM" - }, - "source": [ - "### Define the Config\n", - "\n", - "For this example, we will explicitly define the config; however, a set of default configs can be found [here](https://github.com/Open-Catalyst-Project/ocp/tree/master/configs). Default config yaml files can easily be loaded with the following [utility](https://github.com/Open-Catalyst-Project/ocp/blob/aa8e44d50229fce887b3a94a5661c4f85cd73eed/ocpmodels/common/utils.py#L361-L400). Loading a yaml config is preferrable when launching jobs from the command line. We have included our best models' config files here for reference. \n", - "\n", - "**Note** - we only train for a single epoch with a reduced batch size (GPU memory constraints) for demonstration purposes, modify accordingly for full convergence." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "TiHmkTm6W1do" - }, - "source": [ - "# Task\n", - "task = {\n", - " \"dataset\": \"single_point_lmdb\",\n", - " \"description\": \"Relaxed state energy prediction from initial structure.\",\n", - " \"type\": \"regression\",\n", - " \"metric\": \"mae\",\n", - " \"labels\": [\"relaxed energy\"],\n", - "}\n", - "# Model\n", - "model = {\n", - " 'name': 'gemnet_t',\n", - " \"num_spherical\": 7,\n", - " \"num_radial\": 64,\n", - " \"num_blocks\": 5,\n", - " \"emb_size_atom\": 256,\n", - " \"emb_size_edge\": 512,\n", - " \"emb_size_trip\": 64,\n", - " \"emb_size_rbf\": 16,\n", - " \"emb_size_cbf\": 16,\n", - " \"emb_size_bil_trip\": 64,\n", - " \"num_before_skip\": 1,\n", - " \"num_after_skip\": 2,\n", - " \"num_concat\": 1,\n", - " \"num_atom\": 3,\n", - " \"cutoff\": 6.0,\n", - " \"max_neighbors\": 50,\n", - " \"rbf\": {\"name\": \"gaussian\"},\n", - " \"envelope\": {\n", - " \"name\": \"polynomial\",\n", - " \"exponent\": 5,\n", - " },\n", - " \"cbf\": {\"name\": \"spherical_harmonics\"},\n", - " \"extensive\": True,\n", - " \"otf_graph\": False,\n", - " \"output_init\": \"HeOrthogonal\",\n", - " \"activation\": \"silu\",\n", - " \"scale_file\": \"configs/s2ef/all/gemnet/scaling_factors/gemnet-dT.json\",\n", - " \"regress_forces\": False,\n", - " \"direct_forces\": False,\n", - "}\n", - "# Optimizer\n", - "optimizer = {\n", - " 'batch_size': 1, # originally 32\n", - " 'eval_batch_size': 1, # originally 32\n", - " 'num_workers': 2,\n", - " 'lr_initial': 1.e-4,\n", - " 'optimizer': 'AdamW',\n", - " 'optimizer_params': {\"amsgrad\": True},\n", - " 'scheduler': \"ReduceLROnPlateau\",\n", - " 'mode': \"min\",\n", - " 'factor': 0.8,\n", - " 'patience': 3,\n", - " 'max_epochs': 1, # used for demonstration purposes\n", - " 'ema_decay': 0.999,\n", - " 'clip_grad_norm': 10,\n", - " 'loss_energy': 'mae',\n", - "}\n", - "# Dataset\n", - "dataset = [\n", - " {'src': train_src,\n", - " 'normalize_labels': True,\n", - " 'target_mean': mean,\n", - " 'target_std': stdev,\n", - " }, # train set \n", - " {'src': val_src}, # val set (optional)\n", - "]" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "oG5w1sk-v1LI" - }, - "source": [ - "###Create EnergyTrainer" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "ExmkV2K1W07H", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "4e875ed0-258b-43eb-e191-d00274400128" - }, - "source": [ - "energy_trainer = EnergyTrainer(\n", - " task=task,\n", - " model=copy.deepcopy(model), # copied for later use, not necessary in practice.\n", - " dataset=dataset,\n", - " optimizer=optimizer,\n", - " identifier=\"IS2RE-example\",\n", - " run_dir=\"./\", # directory to save results if is_debug=False. Prediction files are saved here so be careful not to override!\n", - " is_debug=False, # if True, do not save checkpoint, logs, or results\n", - " is_vis=False,\n", - " print_every=5,\n", - " seed=0, # random seed to use\n", - " logger=\"tensorboard\", # logger of choice (tensorboard and wandb supported)\n", - " local_rank=0,\n", - " amp=True, # use PyTorch Automatic Mixed Precision (faster training and less memory usage) \n", - ")" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "amp: true\n", - "cmd:\n", - " checkpoint_dir: ./checkpoints/2021-11-22-17-21-04-IS2RE-example\n", - " commit: bc04a90\n", - " identifier: IS2RE-example\n", - " logs_dir: ./logs/tensorboard/2021-11-22-17-21-04-IS2RE-example\n", - " print_every: 5\n", - " results_dir: ./results/2021-11-22-17-21-04-IS2RE-example\n", - " seed: 0\n", - " timestamp_id: 2021-11-22-17-21-04-IS2RE-example\n", - "dataset:\n", - " normalize_labels: true\n", - " src: data/is2re/train_100/data.lmdb\n", - " target_mean: !!python/object/apply:numpy.core.multiarray.scalar\n", - " - &id001 !!python/object/apply:numpy.dtype\n", - " args:\n", - " - f8\n", - " - false\n", - " - true\n", - " state: !!python/tuple\n", - " - 3\n", - " - <\n", - " - null\n", - " - null\n", - " - null\n", - " - -1\n", - " - -1\n", - " - 0\n", - " - !!binary |\n", - " MjyJzgpQ978=\n", - " target_std: !!python/object/apply:numpy.core.multiarray.scalar\n", - " - *id001\n", - " - !!binary |\n", - " PnyyzMtk/T8=\n", - "gpus: 1\n", - "logger: tensorboard\n", - "model: gemnet_t\n", - "model_attributes:\n", - " activation: silu\n", - " cbf:\n", - " name: spherical_harmonics\n", - " cutoff: 6.0\n", - " direct_forces: false\n", - " emb_size_atom: 256\n", - " emb_size_bil_trip: 64\n", - " emb_size_cbf: 16\n", - " emb_size_edge: 512\n", - " emb_size_rbf: 16\n", - " emb_size_trip: 64\n", - " envelope:\n", - " exponent: 5\n", - " name: polynomial\n", - " extensive: true\n", - " max_neighbors: 50\n", - " num_after_skip: 2\n", - " num_atom: 3\n", - " num_before_skip: 1\n", - " num_blocks: 5\n", - " num_concat: 1\n", - " num_radial: 64\n", - " num_spherical: 7\n", - " otf_graph: false\n", - " output_init: HeOrthogonal\n", - " rbf:\n", - " name: gaussian\n", - " regress_forces: false\n", - " scale_file: configs/s2ef/all/gemnet/scaling_factors/gemnet-dT.json\n", - "optim:\n", - " batch_size: 1\n", - " clip_grad_norm: 10\n", - " ema_decay: 0.999\n", - " eval_batch_size: 1\n", - " factor: 0.8\n", - " loss_energy: mae\n", - " lr_initial: 0.0001\n", - " max_epochs: 1\n", - " mode: min\n", - " num_workers: 2\n", - " optimizer: AdamW\n", - " optimizer_params:\n", - " amsgrad: true\n", - " patience: 3\n", - " scheduler: ReduceLROnPlateau\n", - "slurm: {}\n", - "task:\n", - " dataset: single_point_lmdb\n", - " description: Relaxed state energy prediction from initial structure.\n", - " labels:\n", - " - relaxed energy\n", - " metric: mae\n", - " type: regression\n", - "val_dataset:\n", - " src: data/is2re/val_20/data.lmdb\n", - "\n", - "2021-11-22 17:20:24 (INFO): Loading dataset: single_point_lmdb\n", - "2021-11-22 17:20:24 (INFO): Loading model: gemnet_t\n", - "2021-11-22 17:20:26 (INFO): Loaded GemNetT with 22774037 parameters.\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "2021-11-22 17:20:26 (WARNING): Model gradient logging to tensorboard not yet supported.\n" - ] - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "tnJer5rGwjwi" - }, - "source": [ - "energy_trainer.model" - ], - "execution_count": 4, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "pto2SpJPwlz1" - }, - "source": [ - "### Train the Model" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "iHMRkFplwsky", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "df58e36a-6bb9-411a-ce4a-b9258fc06a55" - }, - "source": [ - "energy_trainer.train()" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "energy_mae: 6.21e+01, energy_mse: 3.86e+03, energy_within_threshold: 0.00e+00, loss: 6.76e+01, lr: 1.00e-04, epoch: 5.00e-02, step: 5.00e+00\n", - "energy_mae: 1.86e+02, energy_mse: 3.46e+04, energy_within_threshold: 0.00e+00, loss: 2.03e+02, lr: 1.00e-04, epoch: 1.00e-01, step: 1.00e+01\n", - "energy_mae: 2.88e+03, energy_mse: 8.31e+06, energy_within_threshold: 0.00e+00, loss: 3.14e+03, lr: 1.00e-04, epoch: 1.50e-01, step: 1.50e+01\n", - "energy_mae: 5.92e+02, energy_mse: 3.51e+05, energy_within_threshold: 0.00e+00, loss: 3.22e+02, lr: 1.00e-04, epoch: 2.00e-01, step: 2.00e+01\n", - "energy_mae: 4.49e+03, energy_mse: 2.02e+07, energy_within_threshold: 0.00e+00, loss: 2.45e+03, lr: 1.00e-04, epoch: 2.50e-01, step: 2.50e+01\n", - "energy_mae: 4.48e+01, energy_mse: 2.01e+03, energy_within_threshold: 0.00e+00, loss: 2.44e+01, lr: 1.00e-04, epoch: 3.00e-01, step: 3.00e+01\n", - "energy_mae: 1.29e+02, energy_mse: 1.68e+04, energy_within_threshold: 0.00e+00, loss: 7.05e+01, lr: 1.00e-04, epoch: 3.50e-01, step: 3.50e+01\n", - "energy_mae: 2.21e+02, energy_mse: 4.90e+04, energy_within_threshold: 0.00e+00, loss: 1.21e+02, lr: 1.00e-04, epoch: 4.00e-01, step: 4.00e+01\n", - "energy_mae: 2.20e+02, energy_mse: 4.84e+04, energy_within_threshold: 0.00e+00, loss: 1.20e+02, lr: 1.00e-04, epoch: 4.50e-01, step: 4.50e+01\n", - "energy_mae: 1.82e+01, energy_mse: 3.32e+02, energy_within_threshold: 0.00e+00, loss: 9.91e+00, lr: 1.00e-04, epoch: 5.00e-01, step: 5.00e+01\n", - "energy_mae: 2.80e+03, energy_mse: 7.84e+06, energy_within_threshold: 0.00e+00, loss: 1.52e+03, lr: 1.00e-04, epoch: 5.50e-01, step: 5.50e+01\n", - "energy_mae: 5.37e+01, energy_mse: 2.88e+03, energy_within_threshold: 0.00e+00, loss: 2.92e+01, lr: 1.00e-04, epoch: 6.00e-01, step: 6.00e+01\n", - "energy_mae: 4.53e+00, energy_mse: 2.05e+01, energy_within_threshold: 0.00e+00, loss: 2.46e+00, lr: 1.00e-04, epoch: 6.50e-01, step: 6.50e+01\n", - "energy_mae: 2.54e+03, energy_mse: 6.47e+06, energy_within_threshold: 0.00e+00, loss: 1.38e+03, lr: 1.00e-04, epoch: 7.00e-01, step: 7.00e+01\n", - "energy_mae: 5.55e+02, energy_mse: 3.08e+05, energy_within_threshold: 0.00e+00, loss: 3.02e+02, lr: 1.00e-04, epoch: 7.50e-01, step: 7.50e+01\n", - "energy_mae: 1.72e+02, energy_mse: 2.95e+04, energy_within_threshold: 0.00e+00, loss: 9.35e+01, lr: 1.00e-04, epoch: 8.00e-01, step: 8.00e+01\n", - "energy_mae: 1.04e+02, energy_mse: 1.08e+04, energy_within_threshold: 0.00e+00, loss: 5.67e+01, lr: 1.00e-04, epoch: 8.50e-01, step: 8.50e+01\n", - "energy_mae: 1.68e+02, energy_mse: 2.81e+04, energy_within_threshold: 0.00e+00, loss: 9.13e+01, lr: 1.00e-04, epoch: 9.00e-01, step: 9.00e+01\n", - "energy_mae: 4.73e+02, energy_mse: 2.24e+05, energy_within_threshold: 0.00e+00, loss: 2.58e+02, lr: 1.00e-04, epoch: 9.50e-01, step: 9.50e+01\n", - "energy_mae: 2.12e+01, energy_mse: 4.49e+02, energy_within_threshold: 0.00e+00, loss: 1.15e+01, lr: 1.00e-04, epoch: 1.00e+00, step: 1.00e+02\n", - "2021-11-22 17:23:24 (INFO): Evaluating on val.\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "device 0: 100%|██████████| 20/20 [00:10<00:00, 1.86it/s]" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "2021-11-22 17:23:35 (INFO): energy_mae: 1028.9198, energy_mse: 3489562.4455, energy_within_threshold: 0.0000, loss: 560.1051, epoch: 1.0000\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "MkAd2MBmw8wO" - }, - "source": [ - "### Validate the Model" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "gaauxWdNw_-4" - }, - "source": [ - "#### Load the best checkpoint" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "xkj0Bslqws_N", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 35 - }, - "outputId": "2680bf59-c13e-4113-b3bd-15aa62c9007e" - }, - "source": [ - "# The `best_checpoint.pt` file contains the checkpoint with the best val performance\n", - "checkpoint_path = os.path.join(energy_trainer.config[\"cmd\"][\"checkpoint_dir\"], \"best_checkpoint.pt\")\n", - "checkpoint_path" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "application/vnd.google.colaboratory.intrinsic+json": { - "type": "string" - }, - "text/plain": [ - "'./checkpoints/2021-11-22-17-21-04-IS2RE-example/best_checkpoint.pt'" - ] - }, - "metadata": {}, - "execution_count": 29 - } - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "BqmCqaFlbMZC", - "outputId": "fd9f2409-1b51-4b6a-90ca-0a00a40d2dfe" - }, - "source": [ - "# Append the dataset with the test set. We use the same val set for demonstration.\n", - "\n", - "# Dataset\n", - "dataset.append(\n", - " {'src': val_src}, # test set (optional)\n", - ")\n", - "dataset" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "[{'normalize_labels': True,\n", - " 'src': 'data/is2re/train_100/data.lmdb',\n", - " 'target_mean': -1.4570415561499996,\n", - " 'target_std': 1.8371084209427546},\n", - " {'src': 'data/is2re/val_20/data.lmdb'},\n", - " {'src': 'data/is2re/val_20/data.lmdb'}]" - ] - }, - "metadata": {}, - "execution_count": 30 - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "IkcqadZIxXP-", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "5a07d5c7-cbdf-4901-80db-1fcf19c1c42b" - }, - "source": [ - "pretrained_energy_trainer = EnergyTrainer(\n", - " task=task,\n", - " model=model,\n", - " dataset=dataset,\n", - " optimizer=optimizer,\n", - " identifier=\"IS2RE-val-example\",\n", - " run_dir=\"./\", # directory to save results if is_debug=False. Prediction files are saved here so be careful not to override!\n", - " is_debug=False, # if True, do not save checkpoint, logs, or results\n", - " is_vis=False,\n", - " print_every=10,\n", - " seed=0, # random seed to use\n", - " logger=\"tensorboard\", # logger of choice (tensorboard and wandb supported)\n", - " local_rank=0,\n", - " amp=True, # use PyTorch Automatic Mixed Precision (faster training and less memory usage)\n", - ")\n", - "\n", - "pretrained_energy_trainer.load_checkpoint(checkpoint_path=checkpoint_path)" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "amp: true\n", - "cmd:\n", - " checkpoint_dir: ./checkpoints/2021-11-22-17-23-12-IS2RE-val-example\n", - " commit: bc04a90\n", - " identifier: IS2RE-val-example\n", - " logs_dir: ./logs/tensorboard/2021-11-22-17-23-12-IS2RE-val-example\n", - " print_every: 10\n", - " results_dir: ./results/2021-11-22-17-23-12-IS2RE-val-example\n", - " seed: 0\n", - " timestamp_id: 2021-11-22-17-23-12-IS2RE-val-example\n", - "dataset:\n", - " normalize_labels: true\n", - " src: data/is2re/train_100/data.lmdb\n", - " target_mean: !!python/object/apply:numpy.core.multiarray.scalar\n", - " - &id001 !!python/object/apply:numpy.dtype\n", - " args:\n", - " - f8\n", - " - false\n", - " - true\n", - " state: !!python/tuple\n", - " - 3\n", - " - <\n", - " - null\n", - " - null\n", - " - null\n", - " - -1\n", - " - -1\n", - " - 0\n", - " - !!binary |\n", - " MjyJzgpQ978=\n", - " target_std: !!python/object/apply:numpy.core.multiarray.scalar\n", - " - *id001\n", - " - !!binary |\n", - " PnyyzMtk/T8=\n", - "gpus: 1\n", - "logger: tensorboard\n", - "model: gemnet_t\n", - "model_attributes:\n", - " activation: silu\n", - " cbf:\n", - " name: spherical_harmonics\n", - " cutoff: 6.0\n", - " direct_forces: false\n", - " emb_size_atom: 256\n", - " emb_size_bil_trip: 64\n", - " emb_size_cbf: 16\n", - " emb_size_edge: 512\n", - " emb_size_rbf: 16\n", - " emb_size_trip: 64\n", - " envelope:\n", - " exponent: 5\n", - " name: polynomial\n", - " extensive: true\n", - " max_neighbors: 50\n", - " num_after_skip: 2\n", - " num_atom: 3\n", - " num_before_skip: 1\n", - " num_blocks: 5\n", - " num_concat: 1\n", - " num_radial: 64\n", - " num_spherical: 7\n", - " otf_graph: false\n", - " output_init: HeOrthogonal\n", - " rbf:\n", - " name: gaussian\n", - " regress_forces: false\n", - " scale_file: configs/s2ef/all/gemnet/scaling_factors/gemnet-dT.json\n", - "optim:\n", - " batch_size: 1\n", - " clip_grad_norm: 10\n", - " ema_decay: 0.999\n", - " eval_batch_size: 1\n", - " factor: 0.8\n", - " loss_energy: mae\n", - " lr_initial: 0.0001\n", - " max_epochs: 1\n", - " mode: min\n", - " num_workers: 2\n", - " optimizer: AdamW\n", - " optimizer_params:\n", - " amsgrad: true\n", - " patience: 3\n", - " scheduler: ReduceLROnPlateau\n", - "slurm: {}\n", - "task:\n", - " dataset: single_point_lmdb\n", - " description: Relaxed state energy prediction from initial structure.\n", - " labels:\n", - " - relaxed energy\n", - " metric: mae\n", - " type: regression\n", - "test_dataset:\n", - " src: data/is2re/val_20/data.lmdb\n", - "val_dataset:\n", - " src: data/is2re/val_20/data.lmdb\n", - "\n", - "2021-11-22 17:23:36 (INFO): Loading dataset: single_point_lmdb\n", - "2021-11-22 17:23:36 (INFO): Loading model: gemnet_t\n", - "2021-11-22 17:23:38 (INFO): Loaded GemNetT with 22774037 parameters.\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "2021-11-22 17:23:38 (WARNING): Model gradient logging to tensorboard not yet supported.\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "2021-11-22 17:23:38 (INFO): Loading checkpoint from: ./checkpoints/2021-11-22-17-21-04-IS2RE-example/best_checkpoint.pt\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "TcUvAI81xoSt" - }, - "source": [ - "#### Test the model" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "VtCEFtXxxr3u", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "eadd2568-ac65-4d3a-b234-cafe99cee575" - }, - "source": [ - "# make predictions on the existing test_loader\n", - "predictions = pretrained_energy_trainer.predict(pretrained_trainer.test_loader, results_file=\"is2re_results\", disable_tqdm=False)" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "2021-11-22 17:23:38 (INFO): Predicting on test.\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "device 0: 100%|██████████| 20/20 [00:03<00:00, 5.80it/s]" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "2021-11-22 17:23:42 (INFO): Writing results to ./results/2021-11-22-17-23-12-IS2RE-val-example/is2re_is2re_results.npz\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "\n" - ] - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "1UcfxFi4x4aD" - }, - "source": [ - "energies = predictions[\"energy\"]" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "gM9Wqk0GIxyU" - }, - "source": [ - "## Initial Structure to Relaxed Structure (IS2RS) \n", - "\n", - "We approach the IS2RS task by using a pre-trained S2EF model to iteratively run a structure optimization to arrive at a relaxed structure. While the majority of approaches for this task do this iteratively, we note it's possible to train a model to directly predict relaxed structures.\n", - "\n", - "## Steps for making IS2RS predictions\n", - "1) Define or load a configuration (config), which includes the following\n", - "* task with relaxation dataset information\n", - "* model\n", - "* optimizer\n", - "* dataset\n", - "* trainer\n", - "\n", - "2) Create a ForcesTrainer object\n", - "\n", - "3) Train a S2EF model or load an existing S2EF checkpoint\n", - "\n", - "4) Run relaxations\n", - "\n", - "**Note** For this task we'll be using a publicly released pre-trained checkpoint of our best model to perform relaxations." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "tNSI3hUAJAWc" - }, - "source": [ - "#### Imports" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "Z-WZXuRiI6Vo" - }, - "source": [ - "from ocpmodels.trainers import ForcesTrainer\n", - "from ocpmodels.datasets import TrajectoryLmdbDataset\n", - "from ocpmodels import models\n", - "from ocpmodels.common import logger\n", - "from ocpmodels.common.utils import setup_logging\n", - "setup_logging()\n", - "\n", - "import numpy as np" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "XFLZTpRvldZE" - }, - "source": [ - "### Dataset\n", - "\n", - "The IS2RS task requires an additional realxation dataset to be defined - `relax_dataset`. This dataset is read in similar to the IS2RE dataset - requiring an LMDB file. The same datasets are used for the IS2RE and IS2RS tasks." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "irrPcbs4ldZF" - }, - "source": [ - "train_src = \"data/s2ef/train_100\"\n", - "val_src = \"data/s2ef/val_20\"\n", - "relax_dataset = \"data/is2re/val_20/data.lmdb\"" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "7gJ01gabd6BR" - }, - "source": [ - "### Download pretrained checkpoint" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "MiOeqFN-d-7K" - }, - "source": [ - "!wget -q https://dl.fbaipublicfiles.com/opencatalystproject/models/2021_08/s2ef/gemnet_t_direct_h512_all.pt\n", - "checkpoint_path = \"/content/ocp/gemnet_t_direct_h512_all.pt\"" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "fp1Ab8TGltP6" - }, - "source": [ - "### Define the Config" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "JLOydGsmltP7" - }, - "source": [ - "Running an iterative S2EF model for the IS2RS task can be run from any S2EF config given the following additions to the `task` portion of the config:\n", - "\n", - "* relax_dataset - IS2RE LMDB dataset\n", - "* *write_pos* - Whether to save out relaxed positions\n", - "* *relaxation_steps* - Number of optimization steps to run\n", - "* *relax_opt* - Dictionary of optimizer settings. Currently only LBFGS supported\n", - " * *maxstep* - Maximum distance an optimization is allowed to make\n", - " * *memory* - Memory history to use for LBFGS\n", - " * *damping* - Calculated step is multiplied by this factor before updating positions\n", - " * *alpha* - Initial guess for the Hessian\n", - " * *traj_dir* - If specified, directory to save out the full ML relaxation as an ASE trajectory. Useful for debugging or visualizing results.\n", - "* *num_relaxation_batches* - If specified, relaxations will only be run for a subset of the relaxation dataset. Useful for debugging or wanting to visualize a few systems.\n", - "\n", - "A sample relaxation config can be found [here](https://github.com/Open-Catalyst-Project/ocp/blob/1044e311182c1120c6e6d137ce6db3f445148973/configs/s2ef/2M/dimenet_plus_plus/dpp_relax.yml#L24-L33).\n", - " " - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "XU9DisuyltP8" - }, - "source": [ - "# Task\n", - "task = {\n", - " 'dataset': 'trajectory_lmdb', # dataset used for the S2EF task\n", - " 'description': 'Regressing to energies and forces for DFT trajectories from OCP',\n", - " 'type': 'regression',\n", - " 'metric': 'mae',\n", - " 'labels': ['potential energy'],\n", - " 'grad_input': 'atomic forces',\n", - " 'train_on_free_atoms': True,\n", - " 'eval_on_free_atoms': True,\n", - " 'relax_dataset': {\"src\": relax_dataset},\n", - " 'write_pos': True,\n", - " 'relaxation_steps': 200,\n", - " 'num_relaxation_batches': 1,\n", - " 'relax_opt': {\n", - " 'maxstep': 0.04,\n", - " 'memory': 50,\n", - " 'damping': 1.0,\n", - " 'alpha': 70.0,\n", - " 'traj_dir': \"ml-relaxations/is2rs-test\", \n", - " }\n", - "}\n", - "# Model\n", - "model = {\n", - " 'name': 'gemnet_t',\n", - " \"num_spherical\": 7,\n", - " \"num_radial\": 128,\n", - " \"num_blocks\": 3,\n", - " \"emb_size_atom\": 512,\n", - " \"emb_size_edge\": 512,\n", - " \"emb_size_trip\": 64,\n", - " \"emb_size_rbf\": 16,\n", - " \"emb_size_cbf\": 16,\n", - " \"emb_size_bil_trip\": 64,\n", - " \"num_before_skip\": 1,\n", - " \"num_after_skip\": 2,\n", - " \"num_concat\": 1,\n", - " \"num_atom\": 3,\n", - " \"cutoff\": 6.0,\n", - " \"max_neighbors\": 50,\n", - " \"rbf\": {\"name\": \"gaussian\"},\n", - " \"envelope\": {\n", - " \"name\": \"polynomial\",\n", - " \"exponent\": 5,\n", - " },\n", - " \"cbf\": {\"name\": \"spherical_harmonics\"},\n", - " \"extensive\": True,\n", - " \"otf_graph\": False,\n", - " \"output_init\": \"HeOrthogonal\",\n", - " \"activation\": \"silu\",\n", - " \"scale_file\": \"configs/s2ef/all/gemnet/scaling_factors/gemnet-dT.json\",\n", - " \"regress_forces\": True,\n", - " \"direct_forces\": True,\n", - "}\n", - "# Optimizer\n", - "optimizer = {\n", - " 'batch_size': 1, # originally 32\n", - " 'eval_batch_size': 1, # originally 32\n", - " 'num_workers': 2,\n", - " 'lr_initial': 5.e-4,\n", - " 'optimizer': 'AdamW',\n", - " 'optimizer_params': {\"amsgrad\": True},\n", - " 'scheduler': \"ReduceLROnPlateau\",\n", - " 'mode': \"min\",\n", - " 'factor': 0.8,\n", - " 'ema_decay': 0.999,\n", - " 'clip_grad_norm': 10,\n", - " 'patience': 3,\n", - " 'max_epochs': 1, # used for demonstration purposes\n", - " 'force_coefficient': 100,\n", - "}\n", - "# Dataset\n", - "dataset = [\n", - " {'src': train_src, 'normalize_labels': False}, # train set \n", - " {'src': val_src}, # val set (optional)\n", - "]" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "IsOqQIjnogkQ" - }, - "source": [ - "### Create the trainer" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "5KZvPu4hogkR", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "fdbbfa5c-0d7c-449f-8be5-ef2e5d17860d" - }, - "source": [ - "trainer = ForcesTrainer(\n", - " task=task,\n", - " model=model,\n", - " dataset=dataset,\n", - " optimizer=optimizer,\n", - " identifier=\"is2rs-example\",\n", - " run_dir=\"./\", # directory to save results if is_debug=False. Prediction files are saved here so be careful not to override!\n", - " is_debug=False, # if True, do not save checkpoint, logs, or results\n", - " is_vis=False,\n", - " print_every=5,\n", - " seed=0, # random seed to use\n", - " logger=\"tensorboard\", # logger of choice (tensorboard and wandb supported)\n", - " local_rank=0,\n", - " amp=True, # use PyTorch Automatic Mixed Precision (faster training and less memory usage)\n", - ")" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "amp: true\n", - "cmd:\n", - " checkpoint_dir: ./checkpoints/2021-11-22-17-42-24-is2rs-example\n", - " commit: bc04a90\n", - " identifier: is2rs-example\n", - " logs_dir: ./logs/tensorboard/2021-11-22-17-42-24-is2rs-example\n", - " print_every: 5\n", - " results_dir: ./results/2021-11-22-17-42-24-is2rs-example\n", - " seed: 0\n", - " timestamp_id: 2021-11-22-17-42-24-is2rs-example\n", - "dataset:\n", - " normalize_labels: false\n", - " src: data/s2ef/train_100\n", - "gpus: 1\n", - "logger: tensorboard\n", - "model: gemnet_t\n", - "model_attributes:\n", - " activation: silu\n", - " cbf:\n", - " name: spherical_harmonics\n", - " cutoff: 6.0\n", - " direct_forces: true\n", - " emb_size_atom: 512\n", - " emb_size_bil_trip: 64\n", - " emb_size_cbf: 16\n", - " emb_size_edge: 512\n", - " emb_size_rbf: 16\n", - " emb_size_trip: 64\n", - " envelope:\n", - " exponent: 5\n", - " name: polynomial\n", - " extensive: true\n", - " max_neighbors: 50\n", - " num_after_skip: 2\n", - " num_atom: 3\n", - " num_before_skip: 1\n", - " num_blocks: 3\n", - " num_concat: 1\n", - " num_radial: 128\n", - " num_spherical: 7\n", - " otf_graph: false\n", - " output_init: HeOrthogonal\n", - " rbf:\n", - " name: gaussian\n", - " regress_forces: true\n", - " scale_file: configs/s2ef/all/gemnet/scaling_factors/gemnet-dT.json\n", - "optim:\n", - " batch_size: 1\n", - " clip_grad_norm: 10\n", - " ema_decay: 0.999\n", - " eval_batch_size: 1\n", - " factor: 0.8\n", - " force_coefficient: 100\n", - " lr_initial: 0.0005\n", - " max_epochs: 1\n", - " mode: min\n", - " num_workers: 2\n", - " optimizer: AdamW\n", - " optimizer_params:\n", - " amsgrad: true\n", - " patience: 3\n", - " scheduler: ReduceLROnPlateau\n", - "slurm: {}\n", - "task:\n", - " dataset: trajectory_lmdb\n", - " description: Regressing to energies and forces for DFT trajectories from OCP\n", - " eval_on_free_atoms: true\n", - " grad_input: atomic forces\n", - " labels:\n", - " - potential energy\n", - " metric: mae\n", - " num_relaxation_batches: 1\n", - " relax_dataset:\n", - " src: data/is2re/val_20/data.lmdb\n", - " relax_opt:\n", - " alpha: 70.0\n", - " damping: 1.0\n", - " maxstep: 0.04\n", - " memory: 50\n", - " traj_dir: ml-relaxations/is2rs-test\n", - " relaxation_steps: 200\n", - " train_on_free_atoms: true\n", - " type: regression\n", - " write_pos: true\n", - "val_dataset:\n", - " src: data/s2ef/val_20\n", - "\n", - "2021-11-22 17:42:56 (INFO): Loading dataset: trajectory_lmdb\n", - "2021-11-22 17:42:56 (INFO): Loading model: gemnet_t\n", - "2021-11-22 17:43:00 (INFO): Loaded GemNetT with 31671825 parameters.\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "2021-11-22 17:43:00 (WARNING): Model gradient logging to tensorboard not yet supported.\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "wtMn792WpC4X" - }, - "source": [ - "### Load the best checkpoint\n" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "jFXQJBYxpC4Y", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "f35be368-a350-465d-fb32-5a5795317bac" - }, - "source": [ - "trainer.load_checkpoint(checkpoint_path=checkpoint_path)" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "2021-11-22 17:43:00 (INFO): Loading checkpoint from: /content/ocp/gemnet_t_direct_h512_all.pt\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "2rtga4JPot6i" - }, - "source": [ - "### Run relaxations\n", - "\n", - "We run a full relaxation for a single batch of our relaxation dataset (`num_relaxation_batches=1`)." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "aQG-HEpuot6k", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "f91a9a2a-4ea8-4b60-c6a1-a1255e482119" - }, - "source": [ - "trainer.run_relaxations()" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "2021-11-22 17:43:19 (INFO): Running ML-relaxations\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "\r 0%| | 0/20 [00:00" - ] - }, - "metadata": { - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "CN9RC25hxLlp" - }, - "source": [ - "Qualitatively, the ML relaxation is behaving as expected - decreasing energies over the course of the relaxation." - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 198 - }, - "id": "6kxJBkV1wZUw", - "outputId": "f1f39a5f-feac-42bc-c208-c6c14aff88ef" - }, - "source": [ - "fig, ax = plt.subplots(1, 3)\n", - "labels = ['ml-initial', 'ml-middle', 'ml-final']\n", - "for i in range(3):\n", - " ax[i].axis('off')\n", - " ax[i].set_title(labels[i])\n", - "\n", - "ase.visualize.plot.plot_atoms(\n", - " ml_trajectory[0], \n", - " ax[0], \n", - " radii=0.8,\n", - " # rotation=(\"-75x, 45y, 10z\")) # uncomment to visualize at different angles\n", - ")\n", - "ase.visualize.plot.plot_atoms(\n", - " ml_trajectory[100], \n", - " ax[1], \n", - " radii=0.8, \n", - " # rotation=(\"-75x, 45y, 10z\") # uncomment to visualize at different angles\n", - ")\n", - "ase.visualize.plot.plot_atoms(\n", - " ml_trajectory[-1], \n", - " ax[2], \n", - " radii=0.8,\n", - " # rotation=(\"-75x, 45y, 10z\"), # uncomment to visualize at different angles\n", - ")\n" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "" - ] - }, - "metadata": {}, - "execution_count": 99 - }, - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "8LE2lrJwyblQ" - }, - "source": [ - "Qualitatively, the generated structures seem reasonable with no obvious issues we had previously mentioned to look out for." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "MymFuumcRd8r" - }, - "source": [ - "# Model development \n", - "\n", - "In this section, we will walk through how to develop a simple Graph Neural Network model on the S2EF-200k dataset.\n", - "\n", - "Let's begin by setting up some imports and boilerplate config parameters." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "mk71_j2i96X4" - }, - "source": [ - "## Imports" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "vK49MKgd9ufL" - }, - "source": [ - "import torch\n", - "\n", - "from typing import Optional\n", - "\n", - "from ocpmodels.trainers import ForcesTrainer\n", - "from ocpmodels import models\n", - "from ocpmodels.common import logger\n", - "from ocpmodels.common.utils import setup_logging, get_pbc_distances\n", - "from ocpmodels.common.registry import registry\n", - "\n", - "from ocpmodels.models.gemnet.layers.radial_basis import PolynomialEnvelope\n", - "\n", - "from torch_geometric.nn.models.schnet import GaussianSmearing\n", - "from torch_scatter import scatter" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "Xj9QvWby-AI6" - }, - "source": [ - "setup_logging()\n", - "\n", - "# Dataset paths\n", - "train_src = \"data/s2ef/train_200k\"\n", - "val_src = \"data/s2ef/val\"\n", - "\n", - "# Configs\n", - "task = {\n", - " 'dataset': 'trajectory_lmdb', # dataset used for the S2EF task\n", - " 'description': 'Regressing to energies and forces for DFT trajectories from OCP',\n", - " 'type': 'regression',\n", - " 'metric': 'mae',\n", - " 'labels': ['potential energy'],\n", - " 'grad_input': 'atomic forces',\n", - " 'train_on_free_atoms': True,\n", - " 'eval_on_free_atoms': True\n", - "}\n", - "\n", - "# Optimizer\n", - "optimizer = {\n", - " 'batch_size': 16, # if hitting GPU memory issues, lower this\n", - " 'eval_batch_size': 8,\n", - " 'num_workers': 8,\n", - " 'lr_initial': 0.0001,\n", - " 'scheduler': \"ReduceLROnPlateau\",\n", - " 'mode': \"min\",\n", - " 'factor': 0.8,\n", - " 'patience': 3,\n", - " 'max_epochs': 80,\n", - " 'max_epochs': 5,\n", - " 'force_coefficient': 100,\n", - "}\n", - "\n", - "# Dataset\n", - "dataset = [\n", - " {'src': train_src, 'normalize_labels': True, 'target_mean': -0.7554450631141663, 'target_std': 2.887317180633545, 'grad_target_mean': 0.0, 'grad_target_std': 2.887317180633545}, # train set\n", - " {'src': val_src},\n", - "]" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "bzp-Cyrm-JOE" - }, - "source": [ - "## Atom and Edge Embeddings\n", - "\n", - "Each atom is represented as a node with its features computed using a simple `torch.nn.Embedding` layer on the atomic number.\n", - "\n", - "All pairs of atoms with a defined cutoff radius (=6A) are assumed to have edges between them, with their features computed as the concatenation of 1) a Gaussian expansion of the distance between the atoms, and the 2) source and 3) target\n", - "node features.\n", - "\n", - "We will use the `GaussianSmearing` layer (reproduced below) from the PyTorch Geometric library for computing distance features:\n", - "\n", - "```\n", - "class GaussianSmearing(torch.nn.Module):\n", - " def __init__(self, start=0.0, stop=5.0, num_gaussians=50):\n", - " super(GaussianSmearing, self).__init__()\n", - " offset = torch.linspace(start, stop, num_gaussians)\n", - " self.coeff = -0.5 / (offset[1] - offset[0]).item()**2\n", - " self.register_buffer('offset', offset)\n", - "\n", - " def forward(self, dist):\n", - " dist = dist.view(-1, 1) - self.offset.view(1, -1)\n", - " return torch.exp(self.coeff * torch.pow(dist, 2))\n", - "```" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "dfMCS-pL-2X5" - }, - "source": [ - "class AtomEmbedding(torch.nn.Module):\n", - " def __init__(self, emb_size):\n", - " super().__init__()\n", - " self.embeddings = torch.nn.Embedding(83, emb_size) # We go up to Bi (83).\n", - "\n", - " def forward(self, Z):\n", - " h = self.embeddings(Z - 1) # -1 because Z.min()=1 (==Hydrogen)\n", - " return h\n", - "\n", - "class EdgeEmbedding(torch.nn.Module):\n", - " def __init__(self, atom_emb_size, edge_emb_size, out_size):\n", - " super().__init__()\n", - " in_features = 2 * atom_emb_size + edge_emb_size\n", - " self.dense = torch.nn.Sequential(\n", - " torch.nn.Linear(in_features, out_size, bias=False),\n", - " torch.nn.SiLU()\n", - " )\n", - "\n", - " def forward(self, h, m_rbf, idx_s, idx_t,\n", - " ):\n", - " h_s = h[idx_s] # indexing source node, shape=(num_edges, emb_size)\n", - " h_t = h[idx_t] # indexing target node, shape=(num_edges, emb_size)\n", - "\n", - " m_st = torch.cat([h_s, h_t, m_rbf], dim=-1) # (num_edges, 2 * atom_emb_size + edge_emb_size)\n", - " m_st = self.dense(m_st) # (num_edges, out_size)\n", - " return m_st\n", - "\n", - "class RadialBasis(torch.nn.Module):\n", - " def __init__(self, num_radial: int, cutoff: float, env_exponent: int = 5):\n", - " super().__init__()\n", - " self.inv_cutoff = 1 / cutoff\n", - " self.envelope = PolynomialEnvelope(env_exponent)\n", - " self.rbf = GaussianSmearing(start=0, stop=1, num_gaussians=num_radial)\n", - "\n", - " def forward(self, d):\n", - " d_scaled = d * self.inv_cutoff\n", - " env = self.envelope(d_scaled)\n", - " return env[:, None] * self.rbf(d_scaled) # (num_edges, num_radial)" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "nhvCP4wzAE_K" - }, - "source": [ - "## Message passing \n", - "\n", - "We start by implementing a very simple message-passing scheme to predict system energy and forces.\n", - "\n", - "Given the node and edge features, we sum up edge features for all edges $e_{ij}$ connecting node $i$ to its neighbors $j$, and pass the resultant vector through a fully-connected layer to project it down to a scalar. This gives us a scalar energy contribution for each node $i$ in the structure. We then sum up all node energy contributions to predict the overall system energy.\n", - "\n", - "Similarly, to predict forces, we pass edge features through a fully-connected layer to project it down to a scalar representing the force magnitude per edge $e_{ij}$. We can then sum up these force magnitudes based on the original edge directions to predict the resultant force vector per node $i$." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "QMjBCLcSAQSp" - }, - "source": [ - "@registry.register_model(\"simple\")\n", - "class SimpleAtomEdgeModel(torch.nn.Module):\n", - " def __init__(self, num_atoms, bond_feat_dim, num_targets, emb_size=64, num_radial=64, cutoff=6.0, env_exponent=5):\n", - " super().__init__()\n", - "\n", - " self.radial_basis = RadialBasis(\n", - " num_radial=num_radial,\n", - " cutoff=cutoff,\n", - " env_exponent=env_exponent,\n", - " )\n", - "\n", - " self.atom_emb = AtomEmbedding(emb_size)\n", - " self.edge_emb = EdgeEmbedding(emb_size, num_radial, emb_size)\n", - "\n", - " self.out_energy = torch.nn.Linear(emb_size, 1)\n", - " self.out_forces = torch.nn.Linear(emb_size, 1)\n", - "\n", - " def forward(self, data):\n", - " batch = data.batch\n", - " atomic_numbers = data.atomic_numbers.long()\n", - " edge_index = data.edge_index\n", - " cell_offsets = data.cell_offsets\n", - " neighbors = data.neighbors\n", - "\n", - " # computing edges and distances taking periodic boundary conditions into account\n", - " out = get_pbc_distances(\n", - " data.pos,\n", - " edge_index,\n", - " data.cell,\n", - " cell_offsets,\n", - " neighbors,\n", - " return_offsets=True,\n", - " return_distance_vec=True,\n", - " )\n", - "\n", - " edge_index = out[\"edge_index\"]\n", - " D_st = out[\"distances\"]\n", - " V_st = -out[\"distance_vec\"] / D_st[:, None]\n", - "\n", - " idx_s, idx_t = edge_index\n", - "\n", - " # embed atoms\n", - " h_atom = self.atom_emb(atomic_numbers)\n", - "\n", - " # gaussian expansion of distances D_st\n", - " m_rbf = self.radial_basis(D_st)\n", - " # embed edges\n", - " m = self.edge_emb(h_atom, m_rbf, idx_s, idx_t)\n", - "\n", - " # read out energy\n", - " # \n", - " # x_E_i = \\sum_j m_ji -- summing up edge features m_ji for all neighbors j\n", - " # of node i to predict node i's energy contribution.\n", - " x_E = scatter(m, idx_t, dim=0, dim_size=h_atom.shape[0], reduce=\"sum\")\n", - " x_E = self.out_energy(x_E)\n", - "\n", - " # E = \\sum_i x_E_i\n", - " num_systems = torch.max(batch)+1\n", - " E = scatter(x_E, batch, dim=0, dim_size=num_systems, reduce=\"add\")\n", - " # (num_systems, 1)\n", - "\n", - " # read out forces\n", - " # \n", - " # x_F is the force magnitude per edge, we multiply that by the direction of each edge ji,\n", - " # and sum up all the vectors to predict the resultant force on node i\n", - " x_F = self.out_forces(m)\n", - " F_st_vec = x_F[:, :, None] * V_st[:, None, :]\n", - " F = scatter(F_st_vec, idx_t, dim=0, dim_size=atomic_numbers.size(0), reduce=\"add\")\n", - " # (num_atoms, num_targets, 3)\n", - " F = F.squeeze(1)\n", - "\n", - " return E, F\n", - "\n", - " @property\n", - " def num_params(self):\n", - " return sum(p.numel() for p in self.parameters())" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "-Vl3WEqVAith" - }, - "source": [ - "## Training the model" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "u7E7pLiqAmnL" - }, - "source": [ - "model_params = {\n", - " 'name': 'simple',\n", - " 'emb_size': 256,\n", - " 'num_radial': 128,\n", - " 'cutoff': 6.0,\n", - " 'env_exponent': 5,\n", - "}\n", - "\n", - "trainer = ForcesTrainer(\n", - " task=task,\n", - " model=model_params,\n", - " dataset=dataset,\n", - " optimizer=optimizer,\n", - " identifier=\"S2EF-simple\",\n", - " run_dir=\"./\", # directory to save results if is_debug=False. Prediction files are saved here so be careful not to override!\n", - " is_debug=False, # if True, do not save checkpoint, logs, or results\n", - " is_vis=False,\n", - " print_every=20,\n", - " seed=0, # random seed to use\n", - " logger=\"tensorboard\", # logger of choice (tensorboard and wandb supported)\n", - " local_rank=0,\n", - ")\n", - "\n", - "trainer.train()" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "thF9lWK9Ay90" - }, - "source": [ - "If you've wired everything up correctly, this model should be relatively small (~185k params) and achieve a force MAE of 0.0815, force cosine of 0.0321, energy MAE of 2.2772 in 2 epochs.\n", - "\n", - "We encourage the reader to try playing with the embedding size, cutoff radius, number of gaussian basis functions, and polynomial envelope exponent to see how it affects performance." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "PSqVJXsxArvu" - }, - "source": [ - "## Incorporating triplets and training GemNet-T\n", - "\n", - "Recall how this model computes edge embeddings based only on a Gaussian expansion of edge distances.\n", - "\n", - "To better capture 3D geometry, we should also embed angles formed by triplets or quadruplets of atoms. A model that incorporates this idea and works quite well is GemNet (Klicpera et al., NeurIPS 2021); see the following figure.\n", - "\n", - "![Screen Shot 2021-11-22 at 3.58.24 PM.png](data:image/png;base64,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)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Twh6yIC5GTrW" - }, - "source": [ - "You can train a GemNet-T (T = triplets) on S2EF-200k using the following config.\n", - "\n", - "Note that this is a significantly bulkier model (~3.4M params) than the one we developed above and will take longer to train." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "LVbM_S0sGlOr" - }, - "source": [ - "model_params = {\n", - " 'name': 'gemnet_t',\n", - " 'num_spherical': 7,\n", - " 'num_radial': 128,\n", - " 'num_blocks': 1,\n", - " 'emb_size_atom': 256,\n", - " 'emb_size_edge': 256,\n", - " 'emb_size_trip': 64,\n", - " 'emb_size_rbf': 16,\n", - " 'emb_size_cbf': 16,\n", - " 'emb_size_bil_trip': 64,\n", - " 'num_before_skip': 1,\n", - " 'num_after_skip': 1,\n", - " 'num_concat': 1,\n", - " 'num_atom': 3,\n", - " 'cutoff': 6.0,\n", - " 'max_neighbors': 50,\n", - " 'rbf': {'name': 'gaussian'},\n", - " 'envelope': {'name': 'polynomial', 'exponent': 5},\n", - " 'cbf': {'name': 'spherical_harmonics'},\n", - " 'extensive': True,\n", - " 'otf_graph': False,\n", - " 'output_init': 'HeOrthogonal',\n", - " 'activation': 'silu',\n", - " 'scale_file': 'configs/s2ef/all/gemnet/scaling_factors/gemnet-dT.json',\n", - " 'regress_forces': True,\n", - " 'direct_forces': True,\n", - "}\n", - "\n", - "trainer = ForcesTrainer(\n", - " task=task,\n", - " model=model_params,\n", - " dataset=dataset,\n", - " optimizer=optimizer,\n", - " identifier=\"S2EF-gemnet-t\",\n", - " run_dir=\"./\", # directory to save results if is_debug=False. Prediction files are saved here so be careful not to override!\n", - " is_debug=False, # if True, do not save checkpoint, logs, or results\n", - " is_vis=False,\n", - " print_every=20,\n", - " seed=0, # random seed to use\n", - " logger=\"tensorboard\", # logger of choice (tensorboard and wandb supported)\n", - " local_rank=0,\n", - ")\n", - "\n", - "trainer.train()" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "F-Pw3GCVHAwA" - }, - "source": [ - "This model should achieve a force MAE of 0.0668, a force cosine of 0.1180, and an energy MAE of 0.8106 in 2 epochs, significantly better than our simple model.\n", - "\n", - "Again, we encourage the reader to try playing with no. of blocks, choice of basis functions, the various embedding sizes to develop intuition for the interplay between these hyperparameters." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Rzx0lArZJ6r0" - }, - "source": [ - "# (Optional) OCP Calculator \n", - "\n", - "For those interested in using our pretrained models for other applications, we provide an [ASE](https://wiki.fysik.dtu.dk/ase/#:~:text=The%20Atomic%20Simulation%20Environment%20(ASE,under%20the%20GNU%20LGPL%20license.)-compatible Calculator to interface with ASE's functionality." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "QGaXyeS_8yHp" - }, - "source": [ - "## Download pretrained checkpoint\n", - "\n", - "We have released checkpoints of all the models on the leaderboard [here](https://github.com/Open-Catalyst-Project/ocp/blob/master/MODELS.md). These trained models can be used as an ASE calculator for various calculations.\n", - "\n", - "For this tutorial we download our current best model checkpoint: GemNet-T" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "MBCRi69284Ve" - }, - "source": [ - "!wget -q https://dl.fbaipublicfiles.com/opencatalystproject/models/2021_08/s2ef/gemnet_t_direct_h512_all.pt\n", - "checkpoint_path = \"/content/ocp/gemnet_t_direct_h512_all.pt\"" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "TNQ1dNVG93kH" - }, - "source": [ - "## Using the OCP Calculator\n" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "o_MHpzbhPKN_", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "fa4336cf-ba85-43b6-e608-551ffcf3763a" - }, - "source": [ - "from ocpmodels.common.relaxation.ase_utils import OCPCalculator\n", - "import ase.io\n", - "from ase.optimize import BFGS\n", - "from ase.build import fcc100, add_adsorbate, molecule\n", - "import os\n", - "from ase.constraints import FixAtoms\n", - "\n", - "# Construct a sample structure\n", - "adslab = fcc100(\"Cu\", size=(3, 3, 3))\n", - "adsorbate = molecule(\"C3H8\")\n", - "add_adsorbate(adslab, adsorbate, 3, offset=(1, 1))\n", - "tags = np.zeros(len(adslab))\n", - "tags[18:27] = 1\n", - "tags[27:] = 2\n", - "adslab.set_tags(tags)\n", - "cons= FixAtoms(indices=[atom.index for atom in adslab if (atom.tag == 0)])\n", - "adslab.set_constraint(cons)\n", - "adslab.center(vacuum=13.0, axis=2)\n", - "adslab.set_pbc(True)\n", - "\n", - "config_yml_path = \"configs/s2ef/all/gemnet/gemnet-dT.yml\"\n", - "\n", - "# Define the calculator\n", - "calc = OCPCalculator(config_yml=config_yml_path, checkpoint=checkpoint_path)\n", - "\n", - "# Set up the calculator\n", - "adslab.calc = calc\n", - "\n", - "os.makedirs(\"data/sample_ml_relax\", exist_ok=True)\n", - "opt = BFGS(adslab, trajectory=\"data/sample_ml_relax/toy_c3h8_relax.traj\")\n", - "\n", - "opt.run(fmax=0.05, steps=100)" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "amp: false\n", - "cmd:\n", - " checkpoint_dir: /content/ocp/checkpoints/2021-11-22-18-03-44\n", - " commit: bc04a90\n", - " identifier: ''\n", - " logs_dir: /content/ocp/logs/tensorboard/2021-11-22-18-03-44\n", - " print_every: 100\n", - " results_dir: /content/ocp/results/2021-11-22-18-03-44\n", - " seed: null\n", - " timestamp_id: 2021-11-22-18-03-44\n", - "dataset: null\n", - "gpus: 0\n", - "logger: tensorboard\n", - "model: gemnet_t\n", - "model_attributes:\n", - " activation: silu\n", - " cbf:\n", - " name: spherical_harmonics\n", - " cutoff: 6.0\n", - " direct_forces: true\n", - " emb_size_atom: 512\n", - " emb_size_bil_trip: 64\n", - " emb_size_cbf: 16\n", - " emb_size_edge: 512\n", - " emb_size_rbf: 16\n", - " emb_size_trip: 64\n", - " envelope:\n", - " exponent: 5\n", - " name: polynomial\n", - " extensive: true\n", - " max_neighbors: 50\n", - " num_after_skip: 2\n", - " num_atom: 3\n", - " num_before_skip: 1\n", - " num_blocks: 3\n", - " num_concat: 1\n", - " num_radial: 128\n", - " num_spherical: 7\n", - " otf_graph: true\n", - " output_init: HeOrthogonal\n", - " rbf:\n", - " name: gaussian\n", - " regress_forces: true\n", - " scale_file: configs/s2ef/all/gemnet/scaling_factors/gemnet-dT.json\n", - "optim:\n", - " batch_size: 32\n", - " clip_grad_norm: 10\n", - " ema_decay: 0.999\n", - " energy_coefficient: 1\n", - " eval_batch_size: 32\n", - " eval_every: 5000\n", - " factor: 0.8\n", - " force_coefficient: 100\n", - " loss_energy: mae\n", - " loss_force: l2mae\n", - " lr_initial: 0.0005\n", - " max_epochs: 80\n", - " mode: min\n", - " num_workers: 2\n", - " optimizer: AdamW\n", - " optimizer_params:\n", - " amsgrad: true\n", - " patience: 3\n", - " scheduler: ReduceLROnPlateau\n", - "slurm: {}\n", - "task:\n", - " dataset: trajectory_lmdb\n", - " description: Regressing to energies and forces for DFT trajectories from OCP\n", - " eval_on_free_atoms: true\n", - " grad_input: atomic forces\n", - " labels:\n", - " - potential energy\n", - " metric: mae\n", - " train_on_free_atoms: true\n", - " type: regression\n", - "\n", - "2021-11-22 18:03:35 (INFO): Loading dataset: trajectory_lmdb\n", - "2021-11-22 18:03:35 (INFO): Loading model: gemnet_t\n", - "2021-11-22 18:03:38 (INFO): Loaded GemNetT with 31671825 parameters.\n", - "2021-11-22 18:03:38 (INFO): Loading checkpoint from: /content/ocp/gemnet_t_direct_h512_all.pt\n", - " Step Time Energy fmax\n", - "BFGS: 0 18:03:41 -4.099784 1.5675\n", - "BFGS: 1 18:03:43 -4.244461 1.1370\n", - "BFGS: 2 18:03:44 -4.403120 0.7635\n", - "BFGS: 3 18:03:46 -4.503653 0.8364\n", - "BFGS: 4 18:03:48 -4.558208 0.7339\n", - "BFGS: 5 18:03:49 -4.592069 0.4095\n", - "BFGS: 6 18:03:51 -4.619362 0.7312\n", - "BFGS: 7 18:03:53 -4.671468 0.9712\n", - "BFGS: 8 18:03:54 -4.796430 0.9211\n", - "BFGS: 9 18:03:56 -4.957961 0.9762\n", - "BFGS: 10 18:03:57 -5.109433 1.0384\n", - "BFGS: 11 18:03:59 -5.295604 1.2247\n", - "BFGS: 12 18:04:00 -5.498977 1.1271\n", - "BFGS: 13 18:04:02 -5.618095 1.0669\n", - "BFGS: 14 18:04:04 -5.737120 0.9509\n", - "BFGS: 15 18:04:05 -5.901926 0.9260\n", - "BFGS: 16 18:04:07 -6.076125 1.2738\n", - "BFGS: 17 18:04:08 -6.198373 1.2029\n", - "BFGS: 18 18:04:10 -6.250323 0.6851\n", - "BFGS: 19 18:04:11 -6.254094 0.2008\n", - "BFGS: 20 18:04:13 -6.293966 0.1779\n", - "BFGS: 21 18:04:14 -6.326333 0.2294\n", - "BFGS: 22 18:04:16 -6.324431 0.1700\n", - "BFGS: 23 18:04:17 -6.321288 0.1016\n", - "BFGS: 24 18:04:19 -6.328468 0.0847\n", - "BFGS: 25 18:04:20 -6.331809 0.0587\n", - "BFGS: 26 18:04:22 -6.332153 0.0444\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "True" - ] - }, - "metadata": {}, - "execution_count": 106 - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "TUH5BaaXo-ca" - }, - "source": [ - "\n", - "# (Optional) Creating your own LMDBs for use in the OCP repository \n", - "\n", - "In order to interface with our repository, the data mustbe structured and organized in a specific format. Below we walk you through on how to create such datasets with your own non-OC20 data that may help with your research.\n", - "\n", - "For this tutorial we use the toy C3H8 trajectory we previously generated [here](#data-description)." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "o7cG3WhLnuqg" - }, - "source": [ - "\n", - "\n", - "#### Initial Structure to Relaxed Energy (IS2RE) LMDBs\n", - "IS2RE/IS2RS LMDBs utilize the SinglePointLmdb dataset. This dataset expects the data to be contained in a **single** LMDB file. In addition to the attributes defined by AtomsToGraph, the following attributes must be added for the IS2RE/IS2RS tasks:\n", - "\n", - "- pos_relaxed: Relaxed adslab positions\n", - "- sid: Unique system identifier, arbitrary\n", - "- y_init: Initial adslab energy, formerly Data.y\n", - "- y_relaxed: Relaxed adslab energy\n", - "- tags (optional): 0 - subsurface, 1 - surface, 2 - adsorbate\n", - "\n", - "\n", - "As a demo, we will use the above generated data to create an IS2R* LMDB file.\n" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "nweCG0y5nxlw" - }, - "source": [ - "from ocpmodels.preprocessing import AtomsToGraphs\n", - "\n", - "\"\"\"\n", - "args description:\n", - "\n", - "max neigh (int): maximum number of neighors to be considered while constructing a graph\n", - "radius (int): Neighbors are considered only within this radius cutoff in Angstrom\n", - "r_energy (bool): Stored energy value in the Data object; False for test data\n", - "r_forces (bool): Stores forces value in the Data object; False for test data\n", - "r_distances (bool): pre-calculates distances taking into account PBC and max neigh/radius\n", - " If you set it to False, make sure to add \"otf_graph = True\" under models in config for runs\n", - "r_fixed (bools): True if you want to fix the subsurface atoms\n", - "\"\"\"\n", - "\n", - "a2g = AtomsToGraphs(\n", - " max_neigh=50,\n", - " radius=6,\n", - " r_energy=True, \n", - " r_forces=True,\n", - " r_distances=False, \n", - " r_fixed=True,\n", - ")" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "K16pPnQdnzro" - }, - "source": [ - "import lmdb\n", - "\n", - "\"\"\"\n", - "For most cases one just needs to change the name of the lmdb as they require.\n", - "Make sure to give the entire path in the config (with .lmdb) for IS2RE tasks\n", - "\"\"\"\n", - "\n", - "db = lmdb.open(\n", - " \"data/toy_C3H8.lmdb\",\n", - " map_size=1099511627776 * 2,\n", - " subdir=False,\n", - " meminit=False,\n", - " map_async=True,\n", - ")" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "t_8oaE5qn1Za" - }, - "source": [ - "\"\"\"\n", - "This method converts extracts all features from trajectory file and convert to Data Object\n", - "\"\"\"\n", - "\n", - "def read_trajectory_extract_features(a2g, traj_path):\n", - " # Read the traj file\n", - " traj = ase.io.read(traj_path, \":\")\n", - "\n", - " # Get tags if you had defined those in the atoms object, if not skip this line\n", - " tags = traj[0].get_tags()\n", - "\n", - " # Collect only initial and final image as this is IS2RS task\n", - " images = [traj[0], traj[-1]]\n", - "\n", - " # Converts a list of atoms object to a list of Data object using a2g defined above\n", - " data_objects = a2g.convert_all(images, disable_tqdm=True)\n", - "\n", - " # Add tags to the data objects if you have them (we would suggest to do so), if not skip this\n", - " data_objects[0].tags = torch.LongTensor(tags)\n", - " data_objects[1].tags = torch.LongTensor(tags)\n", - "\n", - " return data_objects" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "qSfOagphn7yy" - }, - "source": [ - "import torch\n", - "import pickle\n", - "system_paths = [\"data/toy_c3h8_relax.traj\"] # specify list of trajectory files you wish to write to LMDBs\n", - "idx = 0\n", - "\n", - "for system in system_paths:\n", - " # Extract Data object\n", - " data_objects = read_trajectory_extract_features(a2g, system)\n", - " initial_struc = data_objects[0]\n", - " relaxed_struc = data_objects[1]\n", - " \n", - " initial_struc.y_init = initial_struc.y # subtract off reference energy, if applicable\n", - " del initial_struc.y\n", - " initial_struc.y_relaxed = relaxed_struc.y # subtract off reference energy, if applicable\n", - " initial_struc.pos_relaxed = relaxed_struc.pos\n", - " \n", - " # Filter data if necessary\n", - " # OCP filters adsorption energies > |10| eV\n", - " \n", - " initial_struc.sid = idx # arbitrary unique identifier \n", - " \n", - " # no neighbor edge case check\n", - " if initial_struc.edge_index.shape[1] == 0:\n", - " print(\"no neighbors\", traj_path)\n", - " continue\n", - " \n", - " # Write to LMDB\n", - " txn = db.begin(write=True)\n", - " txn.put(f\"{idx}\".encode(\"ascii\"), pickle.dumps(initial_struc, protocol=-1))\n", - " txn.commit()\n", - " db.sync()\n", - " idx += 1\n", - "\n", - "db.close()" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "p8ftTehrn9pG", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "74c95b8a-e260-4b6f-92c4-3544f28deda5" - }, - "source": [ - "from ocpmodels.datasets import SinglePointLmdbDataset\n", - "\n", - "# SinglePointLmdbDataset is out custom Dataset method to read the lmdbs as Data objects. Note that we need to give the entire path (including lmdb) for IS2RE\n", - "dataset = SinglePointLmdbDataset({\"src\": \"data/toy_C3H8.lmdb\"})\n", - "\n", - "print(\"Size of the dataset created:\", len(dataset))\n", - "print(dataset[0])" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Size of the dataset created: 1\n", - "Data(atomic_numbers=[38], cell=[1, 3, 3], cell_offsets=[1733, 3], edge_index=[2, 1733], fixed=[38], force=[38, 3], natoms=38, pos=[38, 3], pos_relaxed=[38, 3], sid=0, tags=[38], y_init=15.80469962027714, y_relaxed=8.358921451420816)\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "UWYBEis2n_ye" - }, - "source": [ - "#### Structure to Energy and Forces (S2EF) LMDBs\n", - "\n", - "S2EF LMDBs utilize the TrajectoryLmdb dataset. This dataset expects a directory of LMDB files. In addition to the attributes defined by AtomsToGraph, the following attributes must be added for the S2EF task:\n", - "\n", - "- tags (optional): 0 - subsurface, 1 - surface, 2 - adsorbate\n", - "- fid: Frame index along the trajcetory\n", - "- sid- sid: Unique system identifier, arbitrary\n", - "\n", - "Additionally, a \"length\" key must be added to each LMDB file.\n", - "\n", - "As a demo, we will use the above generated data to create an S2EF LMDB dataset" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "k74bbQJuoBwy" - }, - "source": [ - "os.makedirs(\"data/s2ef\", exist_ok=True)\n", - "db = lmdb.open(\n", - " \"data/s2ef/toy_C3H8.lmdb\",\n", - " map_size=1099511627776 * 2,\n", - " subdir=False,\n", - " meminit=False,\n", - " map_async=True,\n", - ")" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "-6VuR1lBoDfY", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "0c3e104b-d22f-4376-85f3-0cd505c8914d" - }, - "source": [ - "from tqdm import tqdm\n", - "tags = traj[0].get_tags()\n", - "data_objects = a2g.convert_all(traj, disable_tqdm=True)\n", - "\n", - "\n", - "for fid, data in tqdm(enumerate(data_objects), total=len(data_objects)):\n", - " #assign sid\n", - " data.sid = torch.LongTensor([0])\n", - " \n", - " #assign fid\n", - " data.fid = torch.LongTensor([fid])\n", - " \n", - " #assign tags, if available\n", - " data.tags = torch.LongTensor(tags)\n", - " \n", - " # Filter data if necessary\n", - " # OCP filters adsorption energies > |10| eV and forces > |50| eV/A\n", - "\n", - " # no neighbor edge case check\n", - " if data.edge_index.shape[1] == 0:\n", - " print(\"no neighbors\", traj_path)\n", - " continue\n", - "\n", - " txn = db.begin(write=True)\n", - " txn.put(f\"{fid}\".encode(\"ascii\"), pickle.dumps(data, protocol=-1))\n", - " txn.commit()\n", - " \n", - "txn = db.begin(write=True)\n", - "txn.put(f\"length\".encode(\"ascii\"), pickle.dumps(len(data_objects), protocol=-1))\n", - "txn.commit()\n", - "\n", - "\n", - "db.sync()\n", - "db.close()" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "100%|██████████| 101/101 [00:00<00:00, 129.56it/s]\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "rJ2ZXuBMH8xt" - }, - "source": [ - "# Running on command line [Preferred way to train models] " - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "aj8HsmxjISED" - }, - "source": [ - "The previous sections of this notebook are intended to demonstrate the inner workings of our codebase. For regular training, we suggest that you train and evaluate on command line.\n", - "\n", - "1. Clone our repo at https://github.com/Open-Catalyst-Project/ocp and set up the environment according to the readme.\n", - "2. Download relevant data ([see above for info](https://colab.research.google.com/drive/1oGZcrakB4Pbj8Xq74lSvcRDUHw9L-Dh5#scrollTo=jXoiLncsU3pe)).\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "lAdwlMNOKwYj" - }, - "source": [ - "3. In the config file, modify the path of the data [train](https://github.com/Open-Catalyst-Project/ocp/blob/master/configs/is2re/10k/base.yml#L4) [val](https://github.com/Open-Catalyst-Project/ocp/blob/master/configs/is2re/10k/base.yml#L8), [normalization parameters](https://github.com/Open-Catalyst-Project/ocp/blob/master/configs/is2re/10k/base.yml#L5-L7) as well as any other [model](https://github.com/Open-Catalyst-Project/ocp/blob/master/configs/is2re/10k/dimenet_plus_plus/dpp.yml#L4-L16) or [training](https://github.com/Open-Catalyst-Project/ocp/blob/master/configs/is2re/10k/dimenet_plus_plus/dpp.yml#L23-L35) args. \n", - "\n", - "For a simple example, we'll train DimeNet++ on IS2RE demo data: \\\n", - "a. Modify the train data path in `/contents/ocp/configs/is2re/10k/base.yml` in \n", - "Line 4 to `/contents/ocp/data/is2re/train_10k/data.lmdb` and val data path in Line 8 to `/contents/ocp/data/is2re/val_2k/data.lmdb`. \\\n", - "b. Calculate the mean and std for train data and modify Lines 6-7 respectively \\\n", - "c. We can change the model parameters in `/contents/ocp/configs/is2re/10k/dimenet_plus_plus/dpp.yml` and we suggest you to change the lr_milestones and warmup_steps as the data here is smaller (these need to be tuned for every dataset).\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "HjWsAaojKzpH" - }, - "source": [ - "4. Train: `python main.py --mode train --config-yml configs/is2re/10k/dimenet_plus_plus/dpp.yml --identifier dpp_is2re_sample`\n" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "mCgs4eGSO-HM" - }, - "source": [ - "# Optional block to try command line training \n", - "# Note that config args can be added in the command line. For example, --optim.batch_size=1" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "q1xRtYWTO8Xb" - }, - "source": [ - "5. Add a data path as a test set to `configs/is2re/10k/base.yml`\n", - "6. Run predictions with the trained model: \n", - "`python main.py --mode predict --config-yml configs/is2re/10k/dimenet_plus_plus/dpp.yml --checkpoint checkpoints/[datetime]-dpp_is2re_sample/checkpoint.pt`\n", - "7. View energy predictions at `results/[datetime]/is2re_predictions.npz`\n", - "\n", - "For more information on how to train and evaluate, see [this readme](https://github.com/Open-Catalyst-Project/ocp/blob/master/TRAIN.md). For checkpoints of publicly available trained models, see [MODELS.md](https://github.com/Open-Catalyst-Project/ocp/blob/master/MODELS.md)." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "oHIjM6eMwlXY" - }, - "source": [ - "# Limitations \n", - "The OpenCatalyst project is motivated by the problems we face due to climate change, many of which require innovative solutions to reduce energy usage and replace traditional chemical feedstocks with renewable alternatives. For example, one of the most energy intensive chemical processes is the development of new electrochemical catalysts for ammonia fertilizer production that helped to feed the world’s growing population during the 20th century. This is also an illustrative example of possible unintended consequences as advancements in chemistry and materials may be used for numerous purposes. As ammonia fertilization increased in use, its overuse in today’s farming has led to ocean “dead zones” and its production is very carbon intensive. Knowledge and techniques used to create ammonia were also transferred to the creation of explosives during wartime. We hope to steer the use of ML for atomic simulations to societally-beneficial uses by training and testing our approaches on datasets, such as OC20, that were specifically designed to address chemical reactions useful for addressing climate change." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "CLLCQpv14Gsx" - }, - "source": [ - "# Next Steps \n", - "\n", - "While progress has been well underway - https://opencatalystproject.org/leaderboard.html, a considerable gap still exists between state-of-the-art models and our target goals. We offer some some general thoughts as to next steps for the readers to ponder on or explore:\n", - "\n", - "* GNN depth has consistenly improved model performance. What limitations to depth are there? How far can we push deeper models for OC20? \n", - "* Our best performing models have little to no physical biases encoded. Can we incorporate such biases to improve our models? Experiments with physically inspired embeddings have had no advantage vs. random initializations, are there better ways to incorporate this information into the models?\n", - "* Uncertainty estimation will play an important role in later stages of the project when it comes to large scale screening. How can we get reliable uncertainty estimates from large scale GNNs?\n", - "* Are we limited to message-passing GNNs? Can we leverage alternative architectures for similiar or better performance?\n", - "* Trajectories are nothing more than sequential data points. How can we use sequential modeling techniques to model the full trajectory?\n", - "\n", - "OC20 is a large and diverse dataset with many splits. For those with limited resources but unsure where to start, we provide some general recommendations:\n", - "\n", - "* The IS2RE-direct task is a great place to start. With the largest training set containing ~460k data points, this task is easily accesible for those with even just a single GPU.\n", - "* Those interested in the more general S2EF task don't need to train on the All set to get meaningful performance.\n", - " * Results on the 2M dataset are often sufficient to highlight model improvements.\n", - " * For a fixed compute budget (e.g. fixed number of steps), training on the All set often leads to better performance.\n", - "* The S2EF 200k dataset is fairly noisy, trying to find meaningful trends using this dataset can be difficult.\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "PkKqewK_-ZLD" - }, - "source": [ - "\n", - "# References\n", - "\n", - "* Open Catalyst codebase: https://github.com/Open-Catalyst-Project/ocp/\n", - "* Open Catalyst webpage: https://opencatalystproject.org/\n", - "* [Electrocatalysis white paper](https://arxiv.org/pdf/2010.09435.pdf): C. Lawrence Zitnick, Lowik Chanussot, Abhishek Das, Siddharth Goyal, Javier Heras-Domingo, Caleb Ho, Weihua Hu, Thibaut Lavril, Aini Palizhati, Morgane Riviere, Muhammed Shuaibi, Anuroop Sriram, Kevin Tran, Brandon Wood, Junwoong Yoon, Devi Parikh, Zachary Ulissi: “An Introduction to Electrocatalyst Design using Machine Learning for Renewable Energy Storage”, 2020; arXiv:2010.09435.\n", - "* [OC20 dataset paper](https://arxiv.org/pdf/2010.09990.pdf): L. Chanussot, A. Das, S. Goyal, T. Lavril, M. Shuaibi, M. Riviere, K. Tran, J. Heras-Domingo, C. Ho, W. Hu, A. Palizhati, A. Sriram, B. Wood, J. Yoon, D. Parikh, C. L. Zitnick, and Z. Ulissi. The Open Catalyst 2020 (oc20) dataset and community challenges. ACS Catalysis, 2021.\n", - "* [Gemnet model:](https://arxiv.org/abs/2106.08903) Johannes Klicpera, Florian Becker, and Stephan Günnemann. Gemnet: Universal directional graph neural networks for molecules, 2021.\n", - "\n", - "\n" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] } - ] -} \ No newline at end of file + ], + "source": [ + "# make predictions on the existing test_loader\n", + "predictions = pretrained_trainer.predict(pretrained_trainer.test_loader, results_file=\"s2ef_results\", disable_tqdm=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "id": "zaZGqeyqNCXz" + }, + "outputs": [], + "source": [ + "energies = predictions[\"energy\"]\n", + "forces = predictions[\"forces\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "o8L28axZ4NVj" + }, + "source": [ + "## Initial Structure to Relaxed Energy (IS2RE) \n", + "The IS2RE task predicts the relaxed energy (energy of the relaxed state) given the initial state of a system. One approach to this is by training a regression model mapping the initial structure to the relaxed energy. We call this the *direct* approach to the IS2RE task. \n", + "\n", + "An alternative is to perform a structure relaxation using an S2EF model to obtain the relaxed state and compute the energy of that state (see the IS2RS task below for details about relaxation).\n", + "\n", + "### Steps for training an IS2RE model\n", + "1) Define or load a configuration (config), which includes the following\n", + "* task\n", + "* model\n", + "* optimizer\n", + "* dataset\n", + "* trainer\n", + "\n", + "2) Create an EnergyTrainer object\n", + "\n", + "3) Train the model\n", + "\n", + "4) Validate the model" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kEPPcr0YYHpH" + }, + "source": [ + "### Imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "d-0GsaGDW16G" + }, + "outputs": [], + "source": [ + "from ocpmodels.trainers import EnergyTrainer\n", + "from ocpmodels.datasets import SinglePointLmdbDataset\n", + "from ocpmodels import models\n", + "from ocpmodels.common import logger\n", + "from ocpmodels.common.utils import setup_logging\n", + "setup_logging()\n", + "\n", + "import numpy as np\n", + "import copy\n", + "import os" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "w20BJZ_GYWat" + }, + "source": [ + "### Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "BlL5gGPQW1te" + }, + "outputs": [], + "source": [ + "train_src = \"data/is2re/train_100/data.lmdb\"\n", + "val_src = \"data/is2re/val_20/data.lmdb\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "yT5qHT2wamPh" + }, + "source": [ + "### Normalize data\n", + "\n", + "If you wish to normalize the targets we must compute the mean and standard deviation for our energy values." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "vaY-ZUMaamPh" + }, + "outputs": [], + "source": [ + "train_dataset = SinglePointLmdbDataset({\"src\": train_src})\n", + "\n", + "energies = []\n", + "for data in train_dataset:\n", + " energies.append(data.y_relaxed)\n", + "\n", + "mean = np.mean(energies)\n", + "stdev = np.std(energies)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "K4SSW0UGYeYM" + }, + "source": [ + "### Define the Config\n", + "\n", + "For this example, we will explicitly define the config; however, a set of default configs can be found [here](https://github.com/Open-Catalyst-Project/ocp/tree/master/configs). Default config yaml files can easily be loaded with the following [utility](https://github.com/Open-Catalyst-Project/ocp/blob/aa8e44d50229fce887b3a94a5661c4f85cd73eed/ocpmodels/common/utils.py#L361-L400). Loading a yaml config is preferrable when launching jobs from the command line. We have included our best models' config files here for reference. \n", + "\n", + "**Note** - we only train for a single epoch with a reduced batch size (GPU memory constraints) for demonstration purposes, modify accordingly for full convergence." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "TiHmkTm6W1do" + }, + "outputs": [], + "source": [ + "# Task\n", + "task = {\n", + " \"dataset\": \"single_point_lmdb\",\n", + " \"description\": \"Relaxed state energy prediction from initial structure.\",\n", + " \"type\": \"regression\",\n", + " \"metric\": \"mae\",\n", + " \"labels\": [\"relaxed energy\"],\n", + "}\n", + "# Model\n", + "model = {\n", + " 'name': 'gemnet_t',\n", + " \"num_spherical\": 7,\n", + " \"num_radial\": 64,\n", + " \"num_blocks\": 5,\n", + " \"emb_size_atom\": 256,\n", + " \"emb_size_edge\": 512,\n", + " \"emb_size_trip\": 64,\n", + " \"emb_size_rbf\": 16,\n", + " \"emb_size_cbf\": 16,\n", + " \"emb_size_bil_trip\": 64,\n", + " \"num_before_skip\": 1,\n", + " \"num_after_skip\": 2,\n", + " \"num_concat\": 1,\n", + " \"num_atom\": 3,\n", + " \"cutoff\": 6.0,\n", + " \"max_neighbors\": 50,\n", + " \"rbf\": {\"name\": \"gaussian\"},\n", + " \"envelope\": {\n", + " \"name\": \"polynomial\",\n", + " \"exponent\": 5,\n", + " },\n", + " \"cbf\": {\"name\": \"spherical_harmonics\"},\n", + " \"extensive\": True,\n", + " \"otf_graph\": False,\n", + " \"output_init\": \"HeOrthogonal\",\n", + " \"activation\": \"silu\",\n", + " \"scale_file\": \"configs/s2ef/all/gemnet/scaling_factors/gemnet-dT.json\",\n", + " \"regress_forces\": False,\n", + " \"direct_forces\": False,\n", + "}\n", + "# Optimizer\n", + "optimizer = {\n", + " 'batch_size': 1, # originally 32\n", + " 'eval_batch_size': 1, # originally 32\n", + " 'num_workers': 2,\n", + " 'lr_initial': 1.e-4,\n", + " 'optimizer': 'AdamW',\n", + " 'optimizer_params': {\"amsgrad\": True},\n", + " 'scheduler': \"ReduceLROnPlateau\",\n", + " 'mode': \"min\",\n", + " 'factor': 0.8,\n", + " 'patience': 3,\n", + " 'max_epochs': 1, # used for demonstration purposes\n", + " 'ema_decay': 0.999,\n", + " 'clip_grad_norm': 10,\n", + " 'loss_energy': 'mae',\n", + "}\n", + "# Dataset\n", + "dataset = [\n", + " {'src': train_src,\n", + " 'normalize_labels': True,\n", + " 'target_mean': mean,\n", + " 'target_std': stdev,\n", + " }, # train set \n", + " {'src': val_src}, # val set (optional)\n", + "]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "oG5w1sk-v1LI" + }, + "source": [ + "###Create EnergyTrainer" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ExmkV2K1W07H", + "outputId": "4e875ed0-258b-43eb-e191-d00274400128" + }, + "outputs": [], + "source": [ + "energy_trainer = EnergyTrainer(\n", + " task=task,\n", + " model=copy.deepcopy(model), # copied for later use, not necessary in practice.\n", + " dataset=dataset,\n", + " optimizer=optimizer,\n", + " identifier=\"IS2RE-example\",\n", + " run_dir=\"./\", # directory to save results if is_debug=False. Prediction files are saved here so be careful not to override!\n", + " is_debug=False, # if True, do not save checkpoint, logs, or results\n", + " is_vis=False,\n", + " print_every=5,\n", + " seed=0, # random seed to use\n", + " logger=\"tensorboard\", # logger of choice (tensorboard and wandb supported)\n", + " local_rank=0,\n", + " amp=True, # use PyTorch Automatic Mixed Precision (faster training and less memory usage) \n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "tnJer5rGwjwi" + }, + "outputs": [], + "source": [ + "energy_trainer.model" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "pto2SpJPwlz1" + }, + "source": [ + "### Train the Model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "iHMRkFplwsky", + "outputId": "df58e36a-6bb9-411a-ce4a-b9258fc06a55" + }, + "outputs": [], + "source": [ + "energy_trainer.train()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MkAd2MBmw8wO" + }, + "source": [ + "### Validate the Model" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gaauxWdNw_-4" + }, + "source": [ + "#### Load the best checkpoint" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "xkj0Bslqws_N", + "outputId": "2680bf59-c13e-4113-b3bd-15aa62c9007e" + }, + "outputs": [], + "source": [ + "# The `best_checpoint.pt` file contains the checkpoint with the best val performance\n", + "checkpoint_path = os.path.join(energy_trainer.config[\"cmd\"][\"checkpoint_dir\"], \"best_checkpoint.pt\")\n", + "checkpoint_path" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "BqmCqaFlbMZC", + "outputId": "fd9f2409-1b51-4b6a-90ca-0a00a40d2dfe" + }, + "outputs": [], + "source": [ + "# Append the dataset with the test set. We use the same val set for demonstration.\n", + "\n", + "# Dataset\n", + "dataset.append(\n", + " {'src': val_src}, # test set (optional)\n", + ")\n", + "dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "IkcqadZIxXP-", + "outputId": "5a07d5c7-cbdf-4901-80db-1fcf19c1c42b" + }, + "outputs": [], + "source": [ + "pretrained_energy_trainer = EnergyTrainer(\n", + " task=task,\n", + " model=model,\n", + " dataset=dataset,\n", + " optimizer=optimizer,\n", + " identifier=\"IS2RE-val-example\",\n", + " run_dir=\"./\", # directory to save results if is_debug=False. Prediction files are saved here so be careful not to override!\n", + " is_debug=False, # if True, do not save checkpoint, logs, or results\n", + " is_vis=False,\n", + " print_every=10,\n", + " seed=0, # random seed to use\n", + " logger=\"tensorboard\", # logger of choice (tensorboard and wandb supported)\n", + " local_rank=0,\n", + " amp=True, # use PyTorch Automatic Mixed Precision (faster training and less memory usage)\n", + ")\n", + "\n", + "pretrained_energy_trainer.load_checkpoint(checkpoint_path=checkpoint_path)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TcUvAI81xoSt" + }, + "source": [ + "#### Test the model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "VtCEFtXxxr3u", + "outputId": "eadd2568-ac65-4d3a-b234-cafe99cee575" + }, + "outputs": [], + "source": [ + "# make predictions on the existing test_loader\n", + "predictions = pretrained_energy_trainer.predict(pretrained_trainer.test_loader, results_file=\"is2re_results\", disable_tqdm=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "1UcfxFi4x4aD" + }, + "outputs": [], + "source": [ + "energies = predictions[\"energy\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gM9Wqk0GIxyU" + }, + "source": [ + "## Initial Structure to Relaxed Structure (IS2RS) \n", + "\n", + "We approach the IS2RS task by using a pre-trained S2EF model to iteratively run a structure optimization to arrive at a relaxed structure. While the majority of approaches for this task do this iteratively, we note it's possible to train a model to directly predict relaxed structures.\n", + "\n", + "## Steps for making IS2RS predictions\n", + "1) Define or load a configuration (config), which includes the following\n", + "* task with relaxation dataset information\n", + "* model\n", + "* optimizer\n", + "* dataset\n", + "* trainer\n", + "\n", + "2) Create a ForcesTrainer object\n", + "\n", + "3) Train a S2EF model or load an existing S2EF checkpoint\n", + "\n", + "4) Run relaxations\n", + "\n", + "**Note** For this task we'll be using a publicly released pre-trained checkpoint of our best model to perform relaxations." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tNSI3hUAJAWc" + }, + "source": [ + "#### Imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Z-WZXuRiI6Vo" + }, + "outputs": [], + "source": [ + "from ocpmodels.trainers import ForcesTrainer\n", + "from ocpmodels.datasets import TrajectoryLmdbDataset\n", + "from ocpmodels import models\n", + "from ocpmodels.common import logger\n", + "from ocpmodels.common.utils import setup_logging\n", + "setup_logging()\n", + "\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XFLZTpRvldZE" + }, + "source": [ + "### Dataset\n", + "\n", + "The IS2RS task requires an additional realxation dataset to be defined - `relax_dataset`. This dataset is read in similar to the IS2RE dataset - requiring an LMDB file. The same datasets are used for the IS2RE and IS2RS tasks." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "irrPcbs4ldZF" + }, + "outputs": [], + "source": [ + "train_src = \"data/s2ef/train_100\"\n", + "val_src = \"data/s2ef/val_20\"\n", + "relax_dataset = \"data/is2re/val_20/data.lmdb\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7gJ01gabd6BR" + }, + "source": [ + "### Download pretrained checkpoint" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "MiOeqFN-d-7K" + }, + "outputs": [], + "source": [ + "!wget -q https://dl.fbaipublicfiles.com/opencatalystproject/models/2021_08/s2ef/gemnet_t_direct_h512_all.pt\n", + "checkpoint_path = \"/content/ocp/gemnet_t_direct_h512_all.pt\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fp1Ab8TGltP6" + }, + "source": [ + "### Define the Config" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "JLOydGsmltP7" + }, + "source": [ + "Running an iterative S2EF model for the IS2RS task can be run from any S2EF config given the following additions to the `task` portion of the config:\n", + "\n", + "* relax_dataset - IS2RE LMDB dataset\n", + "* *write_pos* - Whether to save out relaxed positions\n", + "* *relaxation_steps* - Number of optimization steps to run\n", + "* *relax_opt* - Dictionary of optimizer settings. Currently only LBFGS supported\n", + " * *maxstep* - Maximum distance an optimization is allowed to make\n", + " * *memory* - Memory history to use for LBFGS\n", + " * *damping* - Calculated step is multiplied by this factor before updating positions\n", + " * *alpha* - Initial guess for the Hessian\n", + " * *traj_dir* - If specified, directory to save out the full ML relaxation as an ASE trajectory. Useful for debugging or visualizing results.\n", + "* *num_relaxation_batches* - If specified, relaxations will only be run for a subset of the relaxation dataset. Useful for debugging or wanting to visualize a few systems.\n", + "\n", + "A sample relaxation config can be found [here](https://github.com/Open-Catalyst-Project/ocp/blob/1044e311182c1120c6e6d137ce6db3f445148973/configs/s2ef/2M/dimenet_plus_plus/dpp_relax.yml#L24-L33).\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "XU9DisuyltP8" + }, + "outputs": [], + "source": [ + "# Task\n", + "task = {\n", + " 'dataset': 'trajectory_lmdb', # dataset used for the S2EF task\n", + " 'description': 'Regressing to energies and forces for DFT trajectories from OCP',\n", + " 'type': 'regression',\n", + " 'metric': 'mae',\n", + " 'labels': ['potential energy'],\n", + " 'grad_input': 'atomic forces',\n", + " 'train_on_free_atoms': True,\n", + " 'eval_on_free_atoms': True,\n", + " 'relax_dataset': {\"src\": relax_dataset},\n", + " 'write_pos': True,\n", + " 'relaxation_steps': 200,\n", + " 'num_relaxation_batches': 1,\n", + " 'relax_opt': {\n", + " 'maxstep': 0.04,\n", + " 'memory': 50,\n", + " 'damping': 1.0,\n", + " 'alpha': 70.0,\n", + " 'traj_dir': \"ml-relaxations/is2rs-test\", \n", + " }\n", + "}\n", + "# Model\n", + "model = {\n", + " 'name': 'gemnet_t',\n", + " \"num_spherical\": 7,\n", + " \"num_radial\": 128,\n", + " \"num_blocks\": 3,\n", + " \"emb_size_atom\": 512,\n", + " \"emb_size_edge\": 512,\n", + " \"emb_size_trip\": 64,\n", + " \"emb_size_rbf\": 16,\n", + " \"emb_size_cbf\": 16,\n", + " \"emb_size_bil_trip\": 64,\n", + " \"num_before_skip\": 1,\n", + " \"num_after_skip\": 2,\n", + " \"num_concat\": 1,\n", + " \"num_atom\": 3,\n", + " \"cutoff\": 6.0,\n", + " \"max_neighbors\": 50,\n", + " \"rbf\": {\"name\": \"gaussian\"},\n", + " \"envelope\": {\n", + " \"name\": \"polynomial\",\n", + " \"exponent\": 5,\n", + " },\n", + " \"cbf\": {\"name\": \"spherical_harmonics\"},\n", + " \"extensive\": True,\n", + " \"otf_graph\": False,\n", + " \"output_init\": \"HeOrthogonal\",\n", + " \"activation\": \"silu\",\n", + " \"scale_file\": \"configs/s2ef/all/gemnet/scaling_factors/gemnet-dT.json\",\n", + " \"regress_forces\": True,\n", + " \"direct_forces\": True,\n", + "}\n", + "# Optimizer\n", + "optimizer = {\n", + " 'batch_size': 1, # originally 32\n", + " 'eval_batch_size': 1, # originally 32\n", + " 'num_workers': 2,\n", + " 'lr_initial': 5.e-4,\n", + " 'optimizer': 'AdamW',\n", + " 'optimizer_params': {\"amsgrad\": True},\n", + " 'scheduler': \"ReduceLROnPlateau\",\n", + " 'mode': \"min\",\n", + " 'factor': 0.8,\n", + " 'ema_decay': 0.999,\n", + " 'clip_grad_norm': 10,\n", + " 'patience': 3,\n", + " 'max_epochs': 1, # used for demonstration purposes\n", + " 'force_coefficient': 100,\n", + "}\n", + "# Dataset\n", + "dataset = [\n", + " {'src': train_src, 'normalize_labels': False}, # train set \n", + " {'src': val_src}, # val set (optional)\n", + "]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "IsOqQIjnogkQ" + }, + "source": [ + "### Create the trainer" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "5KZvPu4hogkR", + "outputId": "fdbbfa5c-0d7c-449f-8be5-ef2e5d17860d" + }, + "outputs": [], + "source": [ + "trainer = ForcesTrainer(\n", + " task=task,\n", + " model=model,\n", + " dataset=dataset,\n", + " optimizer=optimizer,\n", + " identifier=\"is2rs-example\",\n", + " run_dir=\"./\", # directory to save results if is_debug=False. Prediction files are saved here so be careful not to override!\n", + " is_debug=False, # if True, do not save checkpoint, logs, or results\n", + " is_vis=False,\n", + " print_every=5,\n", + " seed=0, # random seed to use\n", + " logger=\"tensorboard\", # logger of choice (tensorboard and wandb supported)\n", + " local_rank=0,\n", + " amp=True, # use PyTorch Automatic Mixed Precision (faster training and less memory usage)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "wtMn792WpC4X" + }, + "source": [ + "### Load the best checkpoint\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "jFXQJBYxpC4Y", + "outputId": "f35be368-a350-465d-fb32-5a5795317bac" + }, + "outputs": [], + "source": [ + "trainer.load_checkpoint(checkpoint_path=checkpoint_path)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2rtga4JPot6i" + }, + "source": [ + "### Run relaxations\n", + "\n", + "We run a full relaxation for a single batch of our relaxation dataset (`num_relaxation_batches=1`)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "aQG-HEpuot6k", + "outputId": "f91a9a2a-4ea8-4b60-c6a1-a1255e482119" + }, + "outputs": [], + "source": [ + "trainer.run_relaxations()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "j0JBID-2oB7S" + }, + "source": [ + "### Visualize ML-driven relaxations\n", + "\n", + "Following our earlier [visualization steps](#data-description), we can plot our ML-generated relaxations." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "k3z_fey3syg_" + }, + "outputs": [], + "source": [ + "import glob\n", + "import ase.io\n", + "from ase.visualize.plot import plot_atoms\n", + "import matplotlib.pyplot as plt\n", + "import random\n", + "import matplotlib\n", + "\n", + "params = {\n", + " 'axes.labelsize': 14,\n", + " 'font.size': 14,\n", + " 'font.family': ' DejaVu Sans',\n", + " 'legend.fontsize': 20,\n", + " 'xtick.labelsize': 20,\n", + " 'ytick.labelsize': 20,\n", + " 'axes.labelsize': 25,\n", + " 'axes.titlesize': 25,\n", + " 'text.usetex': False,\n", + " 'figure.figsize': [12, 12]\n", + "}\n", + "matplotlib.rcParams.update(params)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 375 + }, + "id": "3yArIY59sskv", + "outputId": "102ace01-5029-4261-cc18-c2f8634157c5" + }, + "outputs": [], + "source": [ + "system = glob.glob(\"ml-relaxations/is2rs-test/*.traj\")[0]\n", + "ml_trajectory = ase.io.read(system, \":\")\n", + "\n", + "energies = [atom.get_potential_energy() for atom in ml_trajectory]\n", + "\n", + "plt.figure(figsize=(7, 5))\n", + "plt.plot(range(len(energies)), energies)\n", + "plt.xlabel(\"step\")\n", + "plt.ylabel(\"energy, eV\")\n", + "system" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CN9RC25hxLlp" + }, + "source": [ + "Qualitatively, the ML relaxation is behaving as expected - decreasing energies over the course of the relaxation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 198 + }, + "id": "6kxJBkV1wZUw", + "outputId": "f1f39a5f-feac-42bc-c208-c6c14aff88ef" + }, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(1, 3)\n", + "labels = ['ml-initial', 'ml-middle', 'ml-final']\n", + "for i in range(3):\n", + " ax[i].axis('off')\n", + " ax[i].set_title(labels[i])\n", + "\n", + "ase.visualize.plot.plot_atoms(\n", + " ml_trajectory[0], \n", + " ax[0], \n", + " radii=0.8,\n", + " # rotation=(\"-75x, 45y, 10z\")) # uncomment to visualize at different angles\n", + ")\n", + "ase.visualize.plot.plot_atoms(\n", + " ml_trajectory[100], \n", + " ax[1], \n", + " radii=0.8, \n", + " # rotation=(\"-75x, 45y, 10z\") # uncomment to visualize at different angles\n", + ")\n", + "ase.visualize.plot.plot_atoms(\n", + " ml_trajectory[-1], \n", + " ax[2], \n", + " radii=0.8,\n", + " # rotation=(\"-75x, 45y, 10z\"), # uncomment to visualize at different angles\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8LE2lrJwyblQ" + }, + "source": [ + "Qualitatively, the generated structures seem reasonable with no obvious issues we had previously mentioned to look out for." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MymFuumcRd8r" + }, + "source": [ + "# Model development \n", + "\n", + "In this section, we will walk through how to develop a simple Graph Neural Network model on the S2EF-200k dataset.\n", + "\n", + "Let's begin by setting up some imports and boilerplate config parameters." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mk71_j2i96X4" + }, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "vK49MKgd9ufL" + }, + "outputs": [], + "source": [ + "import torch\n", + "\n", + "from typing import Optional\n", + "\n", + "from ocpmodels.trainers import ForcesTrainer\n", + "from ocpmodels import models\n", + "from ocpmodels.common import logger\n", + "from ocpmodels.common.utils import setup_logging, get_pbc_distances\n", + "from ocpmodels.common.registry import registry\n", + "\n", + "from ocpmodels.models.gemnet.layers.radial_basis import PolynomialEnvelope\n", + "\n", + "from torch_geometric.nn.models.schnet import GaussianSmearing\n", + "from torch_scatter import scatter" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Xj9QvWby-AI6" + }, + "outputs": [], + "source": [ + "setup_logging()\n", + "\n", + "# Dataset paths\n", + "train_src = \"data/s2ef/train_200k\"\n", + "val_src = \"data/s2ef/val\"\n", + "\n", + "# Configs\n", + "task = {\n", + " 'dataset': 'trajectory_lmdb', # dataset used for the S2EF task\n", + " 'description': 'Regressing to energies and forces for DFT trajectories from OCP',\n", + " 'type': 'regression',\n", + " 'metric': 'mae',\n", + " 'labels': ['potential energy'],\n", + " 'grad_input': 'atomic forces',\n", + " 'train_on_free_atoms': True,\n", + " 'eval_on_free_atoms': True\n", + "}\n", + "\n", + "# Optimizer\n", + "optimizer = {\n", + " 'batch_size': 16, # if hitting GPU memory issues, lower this\n", + " 'eval_batch_size': 8,\n", + " 'num_workers': 8,\n", + " 'lr_initial': 0.0001,\n", + " 'scheduler': \"ReduceLROnPlateau\",\n", + " 'mode': \"min\",\n", + " 'factor': 0.8,\n", + " 'patience': 3,\n", + " 'max_epochs': 80,\n", + " 'max_epochs': 5,\n", + " 'force_coefficient': 100,\n", + "}\n", + "\n", + "# Dataset\n", + "dataset = [\n", + " {'src': train_src, 'normalize_labels': True, 'target_mean': -0.7554450631141663, 'target_std': 2.887317180633545, 'grad_target_mean': 0.0, 'grad_target_std': 2.887317180633545}, # train set\n", + " {'src': val_src},\n", + "]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bzp-Cyrm-JOE" + }, + "source": [ + "## Atom and Edge Embeddings\n", + "\n", + "Each atom is represented as a node with its features computed using a simple `torch.nn.Embedding` layer on the atomic number.\n", + "\n", + "All pairs of atoms with a defined cutoff radius (=6A) are assumed to have edges between them, with their features computed as the concatenation of 1) a Gaussian expansion of the distance between the atoms, and the 2) source and 3) target\n", + "node features.\n", + "\n", + "We will use the `GaussianSmearing` layer (reproduced below) from the PyTorch Geometric library for computing distance features:\n", + "\n", + "```\n", + "class GaussianSmearing(torch.nn.Module):\n", + " def __init__(self, start=0.0, stop=5.0, num_gaussians=50):\n", + " super(GaussianSmearing, self).__init__()\n", + " offset = torch.linspace(start, stop, num_gaussians)\n", + " self.coeff = -0.5 / (offset[1] - offset[0]).item()**2\n", + " self.register_buffer('offset', offset)\n", + "\n", + " def forward(self, dist):\n", + " dist = dist.view(-1, 1) - self.offset.view(1, -1)\n", + " return torch.exp(self.coeff * torch.pow(dist, 2))\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "dfMCS-pL-2X5" + }, + "outputs": [], + "source": [ + "class AtomEmbedding(torch.nn.Module):\n", + " def __init__(self, emb_size):\n", + " super().__init__()\n", + " self.embeddings = torch.nn.Embedding(83, emb_size) # We go up to Bi (83).\n", + "\n", + " def forward(self, Z):\n", + " h = self.embeddings(Z - 1) # -1 because Z.min()=1 (==Hydrogen)\n", + " return h\n", + "\n", + "class EdgeEmbedding(torch.nn.Module):\n", + " def __init__(self, atom_emb_size, edge_emb_size, out_size):\n", + " super().__init__()\n", + " in_features = 2 * atom_emb_size + edge_emb_size\n", + " self.dense = torch.nn.Sequential(\n", + " torch.nn.Linear(in_features, out_size, bias=False),\n", + " torch.nn.SiLU()\n", + " )\n", + "\n", + " def forward(self, h, m_rbf, idx_s, idx_t,\n", + " ):\n", + " h_s = h[idx_s] # indexing source node, shape=(num_edges, emb_size)\n", + " h_t = h[idx_t] # indexing target node, shape=(num_edges, emb_size)\n", + "\n", + " m_st = torch.cat([h_s, h_t, m_rbf], dim=-1) # (num_edges, 2 * atom_emb_size + edge_emb_size)\n", + " m_st = self.dense(m_st) # (num_edges, out_size)\n", + " return m_st\n", + "\n", + "class RadialBasis(torch.nn.Module):\n", + " def __init__(self, num_radial: int, cutoff: float, env_exponent: int = 5):\n", + " super().__init__()\n", + " self.inv_cutoff = 1 / cutoff\n", + " self.envelope = PolynomialEnvelope(env_exponent)\n", + " self.rbf = GaussianSmearing(start=0, stop=1, num_gaussians=num_radial)\n", + "\n", + " def forward(self, d):\n", + " d_scaled = d * self.inv_cutoff\n", + " env = self.envelope(d_scaled)\n", + " return env[:, None] * self.rbf(d_scaled) # (num_edges, num_radial)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "nhvCP4wzAE_K" + }, + "source": [ + "## Message passing \n", + "\n", + "We start by implementing a very simple message-passing scheme to predict system energy and forces.\n", + "\n", + "Given the node and edge features, we sum up edge features for all edges $e_{ij}$ connecting node $i$ to its neighbors $j$, and pass the resultant vector through a fully-connected layer to project it down to a scalar. This gives us a scalar energy contribution for each node $i$ in the structure. We then sum up all node energy contributions to predict the overall system energy.\n", + "\n", + "Similarly, to predict forces, we pass edge features through a fully-connected layer to project it down to a scalar representing the force magnitude per edge $e_{ij}$. We can then sum up these force magnitudes based on the original edge directions to predict the resultant force vector per node $i$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "QMjBCLcSAQSp" + }, + "outputs": [], + "source": [ + "@registry.register_model(\"simple\")\n", + "class SimpleAtomEdgeModel(torch.nn.Module):\n", + " def __init__(self, num_atoms, bond_feat_dim, num_targets, emb_size=64, num_radial=64, cutoff=6.0, env_exponent=5):\n", + " super().__init__()\n", + "\n", + " self.radial_basis = RadialBasis(\n", + " num_radial=num_radial,\n", + " cutoff=cutoff,\n", + " env_exponent=env_exponent,\n", + " )\n", + "\n", + " self.atom_emb = AtomEmbedding(emb_size)\n", + " self.edge_emb = EdgeEmbedding(emb_size, num_radial, emb_size)\n", + "\n", + " self.out_energy = torch.nn.Linear(emb_size, 1)\n", + " self.out_forces = torch.nn.Linear(emb_size, 1)\n", + "\n", + " def forward(self, data):\n", + " batch = data.batch\n", + " atomic_numbers = data.atomic_numbers.long()\n", + " edge_index = data.edge_index\n", + " cell_offsets = data.cell_offsets\n", + " neighbors = data.neighbors\n", + "\n", + " # computing edges and distances taking periodic boundary conditions into account\n", + " out = get_pbc_distances(\n", + " data.pos,\n", + " edge_index,\n", + " data.cell,\n", + " cell_offsets,\n", + " neighbors,\n", + " return_offsets=True,\n", + " return_distance_vec=True,\n", + " )\n", + "\n", + " edge_index = out[\"edge_index\"]\n", + " D_st = out[\"distances\"]\n", + " V_st = -out[\"distance_vec\"] / D_st[:, None]\n", + "\n", + " idx_s, idx_t = edge_index\n", + "\n", + " # embed atoms\n", + " h_atom = self.atom_emb(atomic_numbers)\n", + "\n", + " # gaussian expansion of distances D_st\n", + " m_rbf = self.radial_basis(D_st)\n", + " # embed edges\n", + " m = self.edge_emb(h_atom, m_rbf, idx_s, idx_t)\n", + "\n", + " # read out energy\n", + " # \n", + " # x_E_i = \\sum_j m_ji -- summing up edge features m_ji for all neighbors j\n", + " # of node i to predict node i's energy contribution.\n", + " x_E = scatter(m, idx_t, dim=0, dim_size=h_atom.shape[0], reduce=\"sum\")\n", + " x_E = self.out_energy(x_E)\n", + "\n", + " # E = \\sum_i x_E_i\n", + " num_systems = torch.max(batch)+1\n", + " E = scatter(x_E, batch, dim=0, dim_size=num_systems, reduce=\"add\")\n", + " # (num_systems, 1)\n", + "\n", + " # read out forces\n", + " # \n", + " # x_F is the force magnitude per edge, we multiply that by the direction of each edge ji,\n", + " # and sum up all the vectors to predict the resultant force on node i\n", + " x_F = self.out_forces(m)\n", + " F_st_vec = x_F[:, :, None] * V_st[:, None, :]\n", + " F = scatter(F_st_vec, idx_t, dim=0, dim_size=atomic_numbers.size(0), reduce=\"add\")\n", + " # (num_atoms, num_targets, 3)\n", + " F = F.squeeze(1)\n", + "\n", + " return E, F\n", + "\n", + " @property\n", + " def num_params(self):\n", + " return sum(p.numel() for p in self.parameters())" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-Vl3WEqVAith" + }, + "source": [ + "## Training the model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "u7E7pLiqAmnL" + }, + "outputs": [], + "source": [ + "model_params = {\n", + " 'name': 'simple',\n", + " 'emb_size': 256,\n", + " 'num_radial': 128,\n", + " 'cutoff': 6.0,\n", + " 'env_exponent': 5,\n", + "}\n", + "\n", + "trainer = ForcesTrainer(\n", + " task=task,\n", + " model=model_params,\n", + " dataset=dataset,\n", + " optimizer=optimizer,\n", + " identifier=\"S2EF-simple\",\n", + " run_dir=\"./\", # directory to save results if is_debug=False. Prediction files are saved here so be careful not to override!\n", + " is_debug=False, # if True, do not save checkpoint, logs, or results\n", + " is_vis=False,\n", + " print_every=20,\n", + " seed=0, # random seed to use\n", + " logger=\"tensorboard\", # logger of choice (tensorboard and wandb supported)\n", + " local_rank=0,\n", + ")\n", + "\n", + "trainer.train()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "thF9lWK9Ay90" + }, + "source": [ + "If you've wired everything up correctly, this model should be relatively small (~185k params) and achieve a force MAE of 0.0815, force cosine of 0.0321, energy MAE of 2.2772 in 2 epochs.\n", + "\n", + "We encourage the reader to try playing with the embedding size, cutoff radius, number of gaussian basis functions, and polynomial envelope exponent to see how it affects performance." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PSqVJXsxArvu" + }, + "source": [ + "## Incorporating triplets and training GemNet-T\n", + "\n", + "Recall how this model computes edge embeddings based only on a Gaussian expansion of edge distances.\n", + "\n", + "To better capture 3D geometry, we should also embed angles formed by triplets or quadruplets of atoms. A model that incorporates this idea and works quite well is GemNet (Klicpera et al., NeurIPS 2021); see the following figure.\n", + "\n", + "![Screen Shot 2021-11-22 at 3.58.24 PM.png](data:image/png;base64,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)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Twh6yIC5GTrW" + }, + "source": [ + "You can train a GemNet-T (T = triplets) on S2EF-200k using the following config.\n", + "\n", + "Note that this is a significantly bulkier model (~3.4M params) than the one we developed above and will take longer to train." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "LVbM_S0sGlOr" + }, + "outputs": [], + "source": [ + "model_params = {\n", + " 'name': 'gemnet_t',\n", + " 'num_spherical': 7,\n", + " 'num_radial': 128,\n", + " 'num_blocks': 1,\n", + " 'emb_size_atom': 256,\n", + " 'emb_size_edge': 256,\n", + " 'emb_size_trip': 64,\n", + " 'emb_size_rbf': 16,\n", + " 'emb_size_cbf': 16,\n", + " 'emb_size_bil_trip': 64,\n", + " 'num_before_skip': 1,\n", + " 'num_after_skip': 1,\n", + " 'num_concat': 1,\n", + " 'num_atom': 3,\n", + " 'cutoff': 6.0,\n", + " 'max_neighbors': 50,\n", + " 'rbf': {'name': 'gaussian'},\n", + " 'envelope': {'name': 'polynomial', 'exponent': 5},\n", + " 'cbf': {'name': 'spherical_harmonics'},\n", + " 'extensive': True,\n", + " 'otf_graph': False,\n", + " 'output_init': 'HeOrthogonal',\n", + " 'activation': 'silu',\n", + " 'scale_file': 'configs/s2ef/all/gemnet/scaling_factors/gemnet-dT.json',\n", + " 'regress_forces': True,\n", + " 'direct_forces': True,\n", + "}\n", + "\n", + "trainer = ForcesTrainer(\n", + " task=task,\n", + " model=model_params,\n", + " dataset=dataset,\n", + " optimizer=optimizer,\n", + " identifier=\"S2EF-gemnet-t\",\n", + " run_dir=\"./\", # directory to save results if is_debug=False. Prediction files are saved here so be careful not to override!\n", + " is_debug=False, # if True, do not save checkpoint, logs, or results\n", + " is_vis=False,\n", + " print_every=20,\n", + " seed=0, # random seed to use\n", + " logger=\"tensorboard\", # logger of choice (tensorboard and wandb supported)\n", + " local_rank=0,\n", + ")\n", + "\n", + "trainer.train()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "F-Pw3GCVHAwA" + }, + "source": [ + "This model should achieve a force MAE of 0.0668, a force cosine of 0.1180, and an energy MAE of 0.8106 in 2 epochs, significantly better than our simple model.\n", + "\n", + "Again, we encourage the reader to try playing with no. of blocks, choice of basis functions, the various embedding sizes to develop intuition for the interplay between these hyperparameters." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Rzx0lArZJ6r0" + }, + "source": [ + "# (Optional) OCP Calculator \n", + "\n", + "For those interested in using our pretrained models for other applications, we provide an [ASE](https://wiki.fysik.dtu.dk/ase/#:~:text=The%20Atomic%20Simulation%20Environment%20(ASE,under%20the%20GNU%20LGPL%20license.)-compatible Calculator to interface with ASE's functionality." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QGaXyeS_8yHp" + }, + "source": [ + "## Download pretrained checkpoint\n", + "\n", + "We have released checkpoints of all the models on the leaderboard [here](https://github.com/Open-Catalyst-Project/ocp/blob/master/MODELS.md). These trained models can be used as an ASE calculator for various calculations.\n", + "\n", + "For this tutorial we download our current best model checkpoint: GemNet-T" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "MBCRi69284Ve" + }, + "outputs": [], + "source": [ + "!wget -q https://dl.fbaipublicfiles.com/opencatalystproject/models/2021_08/s2ef/gemnet_t_direct_h512_all.pt\n", + "checkpoint_path = \"/content/ocp/gemnet_t_direct_h512_all.pt\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TNQ1dNVG93kH" + }, + "source": [ + "## Using the OCP Calculator\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "o_MHpzbhPKN_", + "outputId": "fa4336cf-ba85-43b6-e608-551ffcf3763a" + }, + "outputs": [], + "source": [ + "from ocpmodels.common.relaxation.ase_utils import OCPCalculator\n", + "import ase.io\n", + "from ase.optimize import BFGS\n", + "from ase.build import fcc100, add_adsorbate, molecule\n", + "import os\n", + "from ase.constraints import FixAtoms\n", + "\n", + "# Construct a sample structure\n", + "adslab = fcc100(\"Cu\", size=(3, 3, 3))\n", + "adsorbate = molecule(\"C3H8\")\n", + "add_adsorbate(adslab, adsorbate, 3, offset=(1, 1))\n", + "tags = np.zeros(len(adslab))\n", + "tags[18:27] = 1\n", + "tags[27:] = 2\n", + "adslab.set_tags(tags)\n", + "cons= FixAtoms(indices=[atom.index for atom in adslab if (atom.tag == 0)])\n", + "adslab.set_constraint(cons)\n", + "adslab.center(vacuum=13.0, axis=2)\n", + "adslab.set_pbc(True)\n", + "\n", + "config_yml_path = \"configs/s2ef/all/gemnet/gemnet-dT.yml\"\n", + "\n", + "# Define the calculator\n", + "calc = OCPCalculator(config_yml=config_yml_path, checkpoint=checkpoint_path)\n", + "\n", + "# Set up the calculator\n", + "adslab.calc = calc\n", + "\n", + "os.makedirs(\"data/sample_ml_relax\", exist_ok=True)\n", + "opt = BFGS(adslab, trajectory=\"data/sample_ml_relax/toy_c3h8_relax.traj\")\n", + "\n", + "opt.run(fmax=0.05, steps=100)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TUH5BaaXo-ca" + }, + "source": [ + "\n", + "# (Optional) Creating your own LMDBs for use in the OCP repository \n", + "\n", + "In order to interface with our repository, the data mustbe structured and organized in a specific format. Below we walk you through on how to create such datasets with your own non-OC20 data that may help with your research.\n", + "\n", + "For this tutorial we use the toy C3H8 trajectory we previously generated [here](#data-description)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "o7cG3WhLnuqg" + }, + "source": [ + "\n", + "\n", + "#### Initial Structure to Relaxed Energy (IS2RE) LMDBs\n", + "IS2RE/IS2RS LMDBs utilize the SinglePointLmdb dataset. This dataset expects the data to be contained in a **single** LMDB file. In addition to the attributes defined by AtomsToGraph, the following attributes must be added for the IS2RE/IS2RS tasks:\n", + "\n", + "- pos_relaxed: Relaxed adslab positions\n", + "- sid: Unique system identifier, arbitrary\n", + "- y_init: Initial adslab energy, formerly Data.y\n", + "- y_relaxed: Relaxed adslab energy\n", + "- tags (optional): 0 - subsurface, 1 - surface, 2 - adsorbate\n", + "\n", + "\n", + "As a demo, we will use the above generated data to create an IS2R* LMDB file.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "nweCG0y5nxlw" + }, + "outputs": [], + "source": [ + "from ocpmodels.preprocessing import AtomsToGraphs\n", + "\n", + "\"\"\"\n", + "args description:\n", + "\n", + "max neigh (int): maximum number of neighors to be considered while constructing a graph\n", + "radius (int): Neighbors are considered only within this radius cutoff in Angstrom\n", + "r_energy (bool): Stored energy value in the Data object; False for test data\n", + "r_forces (bool): Stores forces value in the Data object; False for test data\n", + "r_distances (bool): pre-calculates distances taking into account PBC and max neigh/radius\n", + " If you set it to False, make sure to add \"otf_graph = True\" under models in config for runs\n", + "r_fixed (bools): True if you want to fix the subsurface atoms\n", + "\"\"\"\n", + "\n", + "a2g = AtomsToGraphs(\n", + " max_neigh=50,\n", + " radius=6,\n", + " r_energy=True, \n", + " r_forces=True,\n", + " r_distances=False, \n", + " r_fixed=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "K16pPnQdnzro" + }, + "outputs": [], + "source": [ + "import lmdb\n", + "\n", + "\"\"\"\n", + "For most cases one just needs to change the name of the lmdb as they require.\n", + "Make sure to give the entire path in the config (with .lmdb) for IS2RE tasks\n", + "\"\"\"\n", + "\n", + "db = lmdb.open(\n", + " \"data/toy_C3H8.lmdb\",\n", + " map_size=1099511627776 * 2,\n", + " subdir=False,\n", + " meminit=False,\n", + " map_async=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "t_8oaE5qn1Za" + }, + "outputs": [], + "source": [ + "\"\"\"\n", + "This method converts extracts all features from trajectory file and convert to Data Object\n", + "\"\"\"\n", + "\n", + "def read_trajectory_extract_features(a2g, traj_path):\n", + " # Read the traj file\n", + " traj = ase.io.read(traj_path, \":\")\n", + "\n", + " # Get tags if you had defined those in the atoms object, if not skip this line\n", + " tags = traj[0].get_tags()\n", + "\n", + " # Collect only initial and final image as this is IS2RS task\n", + " images = [traj[0], traj[-1]]\n", + "\n", + " # Converts a list of atoms object to a list of Data object using a2g defined above\n", + " data_objects = a2g.convert_all(images, disable_tqdm=True)\n", + "\n", + " # Add tags to the data objects if you have them (we would suggest to do so), if not skip this\n", + " data_objects[0].tags = torch.LongTensor(tags)\n", + " data_objects[1].tags = torch.LongTensor(tags)\n", + "\n", + " return data_objects" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "qSfOagphn7yy" + }, + "outputs": [], + "source": [ + "import torch\n", + "import pickle\n", + "system_paths = [\"data/toy_c3h8_relax.traj\"] # specify list of trajectory files you wish to write to LMDBs\n", + "idx = 0\n", + "\n", + "for system in system_paths:\n", + " # Extract Data object\n", + " data_objects = read_trajectory_extract_features(a2g, system)\n", + " initial_struc = data_objects[0]\n", + " relaxed_struc = data_objects[1]\n", + " \n", + " initial_struc.y_init = initial_struc.y # subtract off reference energy, if applicable\n", + " del initial_struc.y\n", + " initial_struc.y_relaxed = relaxed_struc.y # subtract off reference energy, if applicable\n", + " initial_struc.pos_relaxed = relaxed_struc.pos\n", + " \n", + " # Filter data if necessary\n", + " # OCP filters adsorption energies > |10| eV\n", + " \n", + " initial_struc.sid = idx # arbitrary unique identifier \n", + " \n", + " # no neighbor edge case check\n", + " if initial_struc.edge_index.shape[1] == 0:\n", + " print(\"no neighbors\", traj_path)\n", + " continue\n", + " \n", + " # Write to LMDB\n", + " txn = db.begin(write=True)\n", + " txn.put(f\"{idx}\".encode(\"ascii\"), pickle.dumps(initial_struc, protocol=-1))\n", + " txn.commit()\n", + " db.sync()\n", + " idx += 1\n", + "\n", + "db.close()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "p8ftTehrn9pG", + "outputId": "74c95b8a-e260-4b6f-92c4-3544f28deda5" + }, + "outputs": [], + "source": [ + "from ocpmodels.datasets import SinglePointLmdbDataset\n", + "\n", + "# SinglePointLmdbDataset is out custom Dataset method to read the lmdbs as Data objects. Note that we need to give the entire path (including lmdb) for IS2RE\n", + "dataset = SinglePointLmdbDataset({\"src\": \"data/toy_C3H8.lmdb\"})\n", + "\n", + "print(\"Size of the dataset created:\", len(dataset))\n", + "print(dataset[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UWYBEis2n_ye" + }, + "source": [ + "#### Structure to Energy and Forces (S2EF) LMDBs\n", + "\n", + "S2EF LMDBs utilize the TrajectoryLmdb dataset. This dataset expects a directory of LMDB files. In addition to the attributes defined by AtomsToGraph, the following attributes must be added for the S2EF task:\n", + "\n", + "- tags (optional): 0 - subsurface, 1 - surface, 2 - adsorbate\n", + "- fid: Frame index along the trajcetory\n", + "- sid- sid: Unique system identifier, arbitrary\n", + "\n", + "Additionally, a \"length\" key must be added to each LMDB file.\n", + "\n", + "As a demo, we will use the above generated data to create an S2EF LMDB dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "k74bbQJuoBwy" + }, + "outputs": [], + "source": [ + "os.makedirs(\"data/s2ef\", exist_ok=True)\n", + "db = lmdb.open(\n", + " \"data/s2ef/toy_C3H8.lmdb\",\n", + " map_size=1099511627776 * 2,\n", + " subdir=False,\n", + " meminit=False,\n", + " map_async=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "-6VuR1lBoDfY", + "outputId": "0c3e104b-d22f-4376-85f3-0cd505c8914d" + }, + "outputs": [], + "source": [ + "from tqdm import tqdm\n", + "tags = traj[0].get_tags()\n", + "data_objects = a2g.convert_all(traj, disable_tqdm=True)\n", + "\n", + "\n", + "for fid, data in tqdm(enumerate(data_objects), total=len(data_objects)):\n", + " #assign sid\n", + " data.sid = torch.LongTensor([0])\n", + " \n", + " #assign fid\n", + " data.fid = torch.LongTensor([fid])\n", + " \n", + " #assign tags, if available\n", + " data.tags = torch.LongTensor(tags)\n", + " \n", + " # Filter data if necessary\n", + " # OCP filters adsorption energies > |10| eV and forces > |50| eV/A\n", + "\n", + " # no neighbor edge case check\n", + " if data.edge_index.shape[1] == 0:\n", + " print(\"no neighbors\", traj_path)\n", + " continue\n", + "\n", + " txn = db.begin(write=True)\n", + " txn.put(f\"{fid}\".encode(\"ascii\"), pickle.dumps(data, protocol=-1))\n", + " txn.commit()\n", + " \n", + "txn = db.begin(write=True)\n", + "txn.put(f\"length\".encode(\"ascii\"), pickle.dumps(len(data_objects), protocol=-1))\n", + "txn.commit()\n", + "\n", + "\n", + "db.sync()\n", + "db.close()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rJ2ZXuBMH8xt" + }, + "source": [ + "# Running on command line [Preferred way to train models] " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aj8HsmxjISED" + }, + "source": [ + "The previous sections of this notebook are intended to demonstrate the inner workings of our codebase. For regular training, we suggest that you train and evaluate on command line.\n", + "\n", + "1. Clone our repo at https://github.com/Open-Catalyst-Project/ocp and set up the environment according to the readme.\n", + "2. Download relevant data ([see above for info](https://colab.research.google.com/drive/1oGZcrakB4Pbj8Xq74lSvcRDUHw9L-Dh5#scrollTo=jXoiLncsU3pe)).\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lAdwlMNOKwYj" + }, + "source": [ + "3. In the config file, modify the path of the data [train](https://github.com/Open-Catalyst-Project/ocp/blob/master/configs/is2re/10k/base.yml#L4) [val](https://github.com/Open-Catalyst-Project/ocp/blob/master/configs/is2re/10k/base.yml#L8), [normalization parameters](https://github.com/Open-Catalyst-Project/ocp/blob/master/configs/is2re/10k/base.yml#L5-L7) as well as any other [model](https://github.com/Open-Catalyst-Project/ocp/blob/master/configs/is2re/10k/dimenet_plus_plus/dpp.yml#L4-L16) or [training](https://github.com/Open-Catalyst-Project/ocp/blob/master/configs/is2re/10k/dimenet_plus_plus/dpp.yml#L23-L35) args. \n", + "\n", + "For a simple example, we'll train DimeNet++ on IS2RE demo data: \\\n", + "a. Modify the train data path in `/contents/ocp/configs/is2re/10k/base.yml` in \n", + "Line 4 to `/contents/ocp/data/is2re/train_10k/data.lmdb` and val data path in Line 8 to `/contents/ocp/data/is2re/val_2k/data.lmdb`. \\\n", + "b. Calculate the mean and std for train data and modify Lines 6-7 respectively \\\n", + "c. We can change the model parameters in `/contents/ocp/configs/is2re/10k/dimenet_plus_plus/dpp.yml` and we suggest you to change the lr_milestones and warmup_steps as the data here is smaller (these need to be tuned for every dataset).\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HjWsAaojKzpH" + }, + "source": [ + "4. Train: `python main.py --mode train --config-yml configs/is2re/10k/dimenet_plus_plus/dpp.yml --identifier dpp_is2re_sample`\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "mCgs4eGSO-HM" + }, + "outputs": [], + "source": [ + "# Optional block to try command line training \n", + "# Note that config args can be added in the command line. For example, --optim.batch_size=1" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "q1xRtYWTO8Xb" + }, + "source": [ + "5. Add a data path as a test set to `configs/is2re/10k/base.yml`\n", + "6. Run predictions with the trained model: \n", + "`python main.py --mode predict --config-yml configs/is2re/10k/dimenet_plus_plus/dpp.yml --checkpoint checkpoints/[datetime]-dpp_is2re_sample/checkpoint.pt`\n", + "7. View energy predictions at `results/[datetime]/is2re_predictions.npz`\n", + "\n", + "For more information on how to train and evaluate, see [this readme](https://github.com/Open-Catalyst-Project/ocp/blob/master/TRAIN.md). For checkpoints of publicly available trained models, see [MODELS.md](https://github.com/Open-Catalyst-Project/ocp/blob/master/MODELS.md)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "oHIjM6eMwlXY" + }, + "source": [ + "# Limitations \n", + "The OpenCatalyst project is motivated by the problems we face due to climate change, many of which require innovative solutions to reduce energy usage and replace traditional chemical feedstocks with renewable alternatives. For example, one of the most energy intensive chemical processes is the development of new electrochemical catalysts for ammonia fertilizer production that helped to feed the world’s growing population during the 20th century. This is also an illustrative example of possible unintended consequences as advancements in chemistry and materials may be used for numerous purposes. As ammonia fertilization increased in use, its overuse in today’s farming has led to ocean “dead zones” and its production is very carbon intensive. Knowledge and techniques used to create ammonia were also transferred to the creation of explosives during wartime. We hope to steer the use of ML for atomic simulations to societally-beneficial uses by training and testing our approaches on datasets, such as OC20, that were specifically designed to address chemical reactions useful for addressing climate change." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CLLCQpv14Gsx" + }, + "source": [ + "# Next Steps \n", + "\n", + "While progress has been well underway - https://opencatalystproject.org/leaderboard.html, a considerable gap still exists between state-of-the-art models and our target goals. We offer some some general thoughts as to next steps for the readers to ponder on or explore:\n", + "\n", + "* GNN depth has consistenly improved model performance. What limitations to depth are there? How far can we push deeper models for OC20? \n", + "* Our best performing models have little to no physical biases encoded. Can we incorporate such biases to improve our models? Experiments with physically inspired embeddings have had no advantage vs. random initializations, are there better ways to incorporate this information into the models?\n", + "* Uncertainty estimation will play an important role in later stages of the project when it comes to large scale screening. How can we get reliable uncertainty estimates from large scale GNNs?\n", + "* Are we limited to message-passing GNNs? Can we leverage alternative architectures for similiar or better performance?\n", + "* Trajectories are nothing more than sequential data points. How can we use sequential modeling techniques to model the full trajectory?\n", + "\n", + "OC20 is a large and diverse dataset with many splits. For those with limited resources but unsure where to start, we provide some general recommendations:\n", + "\n", + "* The IS2RE-direct task is a great place to start. With the largest training set containing ~460k data points, this task is easily accesible for those with even just a single GPU.\n", + "* Those interested in the more general S2EF task don't need to train on the All set to get meaningful performance.\n", + " * Results on the 2M dataset are often sufficient to highlight model improvements.\n", + " * For a fixed compute budget (e.g. fixed number of steps), training on the All set often leads to better performance.\n", + "* The S2EF 200k dataset is fairly noisy, trying to find meaningful trends using this dataset can be difficult.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PkKqewK_-ZLD" + }, + "source": [ + "\n", + "# References\n", + "\n", + "* Open Catalyst codebase: https://github.com/Open-Catalyst-Project/ocp/\n", + "* Open Catalyst webpage: https://opencatalystproject.org/\n", + "* [Electrocatalysis white paper](https://arxiv.org/pdf/2010.09435.pdf): C. Lawrence Zitnick, Lowik Chanussot, Abhishek Das, Siddharth Goyal, Javier Heras-Domingo, Caleb Ho, Weihua Hu, Thibaut Lavril, Aini Palizhati, Morgane Riviere, Muhammed Shuaibi, Anuroop Sriram, Kevin Tran, Brandon Wood, Junwoong Yoon, Devi Parikh, Zachary Ulissi: “An Introduction to Electrocatalyst Design using Machine Learning for Renewable Energy Storage”, 2020; arXiv:2010.09435.\n", + "* [OC20 dataset paper](https://arxiv.org/pdf/2010.09990.pdf): L. Chanussot, A. Das, S. Goyal, T. Lavril, M. Shuaibi, M. Riviere, K. Tran, J. Heras-Domingo, C. Ho, W. Hu, A. Palizhati, A. Sriram, B. Wood, J. Yoon, D. Parikh, C. L. Zitnick, and Z. Ulissi. The Open Catalyst 2020 (oc20) dataset and community challenges. ACS Catalysis, 2021.\n", + "* [Gemnet model:](https://arxiv.org/abs/2106.08903) Johannes Klicpera, Florian Becker, and Stephan Günnemann. Gemnet: Universal directional graph neural networks for molecules, 2021.\n", + "\n", + "\n" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "collapsed_sections": [ + "PoF-BxSM5Jkc", + "bSt6h_Q-oqjK", + "pto2SpJPwlz1", + "gaauxWdNw_-4", + "TcUvAI81xoSt", + "TUH5BaaXo-ca" + ], + "include_colab_link": true, + "name": "CCAI - OCP Tutorial", + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "display_name": "ocp-091622", + "language": "python", + "name": "ocp-091622" + }, + "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.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} From 929c2fb0996c5d4feeded906587cfe62cd0d6eb3 Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Tue, 8 Aug 2023 17:36:17 -0700 Subject: [PATCH 26/63] add type annotations --- configs/goc_stress_debug.yml | 1 + ocpmodels/modules/evaluator.py | 87 +++++++++++++++++++++++++++------ ocpmodels/modules/transforms.py | 5 +- 3 files changed, 75 insertions(+), 18 deletions(-) diff --git a/configs/goc_stress_debug.yml b/configs/goc_stress_debug.yml index b8d38dfc8..e936d8572 100644 --- a/configs/goc_stress_debug.yml +++ b/configs/goc_stress_debug.yml @@ -137,6 +137,7 @@ model: edge_atom_interaction: True atom_interaction: True + num_elements: 100 num_atom_emb_layers: 2 num_global_out_layers: 2 qint_tags: [1, 2] diff --git a/ocpmodels/modules/evaluator.py b/ocpmodels/modules/evaluator.py index 253f366d0..7eb5b4a01 100644 --- a/ocpmodels/modules/evaluator.py +++ b/ocpmodels/modules/evaluator.py @@ -81,7 +81,12 @@ def __init__(self, task: str = None, eval_metrics: dict = {}) -> None: eval_metrics if eval_metrics else self.task_metrics.get(task, {}) ) - def eval(self, prediction, target, prev_metrics={}): + def eval( + self, + prediction: Dict[str, torch.Tensor], + target: Dict[str, torch.Tensor], + prev_metrics={}, + ): metrics = prev_metrics @@ -125,32 +130,58 @@ def update(self, key, stat, metrics): return metrics -def forcesx_mae(prediction, target, key=None): +def forcesx_mae( + prediction: Dict[str, torch.Tensor], + target: Dict[str, torch.Tensor], + key=None, +): return mae(prediction["forces"][:, 0], target["forces"][:, 0]) -def forcesx_mse(prediction, target, key=None): +def forcesx_mse( + prediction: Dict[str, torch.Tensor], + target: Dict[str, torch.Tensor], + key=None, +): return mse(prediction["forces"][:, 0], target["forces"][:, 0]) -def forcesy_mae(prediction, target, key=None): +def forcesy_mae( + prediction: Dict[str, torch.Tensor], + target: Dict[str, torch.Tensor], + key=None, +): return mae(prediction["forces"][:, 1], target["forces"][:, 1]) -def forcesy_mse(prediction, target, key=None): +def forcesy_mse( + prediction: Dict[str, torch.Tensor], + target: Dict[str, torch.Tensor], + key=None, +): return mse(prediction["forces"][:, 1], target["forces"][:, 1]) -def forcesz_mae(prediction, target, key=None): +def forcesz_mae( + prediction: Dict[str, torch.Tensor], + target: Dict[str, torch.Tensor], + key=None, +): return mae(prediction["forces"][:, 2], target["forces"][:, 2]) -def forcesz_mse(prediction, target, key=None): +def forcesz_mse( + prediction: Dict[str, torch.Tensor], + target: Dict[str, torch.Tensor], + key=None, +): return mse(prediction["forces"][:, 2], target["forces"][:, 2]) def energy_forces_within_threshold( - prediction: dict, target: dict, key=None + prediction: Dict[str, torch.Tensor], + target: Dict[str, torch.Tensor], + key=None, ) -> Dict[str, Union[float, int]]: # Note that this natoms should be the count of free atoms we evaluate over. assert target["natoms"].sum() == prediction["forces"].size(0) @@ -185,7 +216,9 @@ def energy_forces_within_threshold( def energy_within_threshold( - prediction, target, key=None + prediction: Dict[str, torch.Tensor], + target: Dict[str, torch.Tensor], + key=None, ) -> Dict[str, Union[float, int]]: # compute absolute error on energy per system. # then count the no. of systems where max energy error is < 0.02. @@ -203,7 +236,9 @@ def energy_within_threshold( def average_distance_within_threshold( - prediction, target, key=None + prediction: Dict[str, torch.Tensor], + target: Dict[str, torch.Tensor], + key=None, ) -> Dict[str, Union[float, int]]: pred_pos = torch.split( prediction["positions"], prediction["natoms"].tolist() @@ -236,7 +271,11 @@ def average_distance_within_threshold( return {"metric": success / total, "total": success, "numel": total} -def stress_mae_from_decomposition(prediction, target, key=None): +def stress_mae_from_decomposition( + prediction: Dict[str, torch.Tensor], + target: Dict[str, torch.Tensor], + key=None, +): device = prediction["isotropic_stress"].device cg_matrix = cg_decomp_mat(2, device) @@ -261,7 +300,12 @@ def stress_mae_from_decomposition(prediction, target, key=None): return mae(prediction_stress, target_stress) -def min_diff(pred_pos, dft_pos, cell, pbc): +def min_diff( + pred_pos: torch.Tensor, + dft_pos: torch.Tensor, + cell: torch.Tensor, + pbc: torch.Tensor, +): pos_diff = pred_pos - dft_pos fractional = np.linalg.solve(cell.T, pos_diff.T).T @@ -276,7 +320,11 @@ def min_diff(pred_pos, dft_pos, cell, pbc): return np.matmul(fractional, cell) -def cosine_similarity(prediction: dict, target: dict, key=slice(None)): +def cosine_similarity( + prediction: Dict[str, torch.Tensor], + target: Dict[str, torch.Tensor], + key=slice(None), +): error = torch.cosine_similarity(prediction[key], target[key]) return { "metric": torch.mean(error).item(), @@ -286,7 +334,9 @@ def cosine_similarity(prediction: dict, target: dict, key=slice(None)): def mae( - prediction: dict, target: dict, key=slice(None) + prediction: Dict[str, torch.Tensor], + target: Dict[str, torch.Tensor], + key=slice(None), ) -> Dict[str, Union[float, int]]: error = torch.abs(target[key] - prediction[key]) return { @@ -297,7 +347,9 @@ def mae( def mse( - prediction: dict, target: dict, key=slice(None) + prediction: Dict[str, torch.Tensor], + target: Dict[str, torch.Tensor], + key=slice(None), ) -> Dict[str, Union[float, int]]: error = (target[key] - prediction[key]) ** 2 return { @@ -308,7 +360,10 @@ def mse( def magnitude_error( - prediction: dict, target: dict, key=slice(None), p: int = 2 + prediction: Dict[str, torch.Tensor], + target: Dict[str, torch.Tensor], + key=slice(None), + p: int = 2, ) -> Dict[str, Union[float, int]]: assert prediction[key].shape[1] > 1 error = torch.abs( diff --git a/ocpmodels/modules/transforms.py b/ocpmodels/modules/transforms.py index 0f37c1556..23371c938 100644 --- a/ocpmodels/modules/transforms.py +++ b/ocpmodels/modules/transforms.py @@ -1,10 +1,11 @@ import torch +from torch_geometric.data import Data from ocpmodels.common.utils import cg_decomp_mat, irreps_sum class DataTransforms: - def __init__(self, config): + def __init__(self, config) -> None: self.config = config def __call__(self, data_object): @@ -22,7 +23,7 @@ def __call__(self, data_object): return data_object -def decompose_tensor(data_object, config): +def decompose_tensor(data_object, config) -> Data: tensor_key = config["tensor"] rank = config["rank"] From f7b76ec3e060f4fe9ba562510f7f63c106d1f0db Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Tue, 8 Aug 2023 18:04:31 -0700 Subject: [PATCH 27/63] cleanup --- ocpmodels/common/utils.py | 15 +++++++++++---- ocpmodels/trainers/base_trainer.py | 9 ++++++--- 2 files changed, 17 insertions(+), 7 deletions(-) diff --git a/ocpmodels/common/utils.py b/ocpmodels/common/utils.py index fc0a99c4d..16e94c838 100644 --- a/ocpmodels/common/utils.py +++ b/ocpmodels/common/utils.py @@ -1195,8 +1195,16 @@ def irreps_sum(l): return total -def load_old_config(name, config): - if name == "is2re": +def update_old_config(config): + ### Read task based off config structure, similar to OCPCalculator. + if config["task"]["dataset"] == "trajectory_lmdb": + task = "s2ef" + elif config["task"]["dataset"] == "single_point_lmdb": + task = "is2re" + else: + raise NotImplementedError + + if task == "is2re": ### Define loss functions _loss_fns = [ { @@ -1216,7 +1224,7 @@ def load_old_config(name, config): _eval_metrics["primary_metric"] = config["task"]["primary_metric"] ### Define outputs _outputs = {"energy": {"shape": 1, "level": "system"}} - if name == "s2ef": + elif task == "s2ef": ### Define loss functions _loss_fns = [ { @@ -1284,7 +1292,6 @@ def load_old_config(name, config): config.update({"loss_fns": _loss_fns}) config.update({"eval_metrics": _eval_metrics}) config.update({"outputs": _outputs}) - return config def get_loss_module(loss_name): diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index 298124305..e9ef6ce0b 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -39,9 +39,9 @@ get_commit_hash, get_loss_module, irreps_sum, - load_old_config, load_state_dict, save_checkpoint, + update_old_config, ) from ocpmodels.modules.evaluator import Evaluator from ocpmodels.modules.exponential_moving_average import ( @@ -184,8 +184,11 @@ def __init__( print(yaml.dump(self.config, default_flow_style=False)) ### backwards compatability with OCP v<2.0 - if self.name in ["is2re", "s2ef"]: - self.config = load_old_config(self.name, self.config) + if self.name != "ocp": + logging.warning( + f"Detected old config, converting to new format. Consider updating to avoid potential incompatibilities." + ) + update_old_config(self.config) self.load() From 55e71b386d773d4445e3d827c17b0b9dd5a51f30 Mon Sep 17 00:00:00 2001 From: Richard Barnes Date: Tue, 8 Aug 2023 23:07:13 -0700 Subject: [PATCH 28/63] Type annotations --- .pre-commit-config.yaml | 1 - ocpmodels/trainers/base_trainer.py | 60 +++++++++++++++++++----------- 2 files changed, 38 insertions(+), 23 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index bf7ba03a4..d4495ca4d 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -3,7 +3,6 @@ repos: rev: 22.3.0 hooks: - id: black - language_version: python3.8 additional_dependencies: ['click==8.0.4'] - repo: https://github.com/pre-commit/pre-commit-hooks rev: v2.3.0 diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index e9ef6ce0b..b9486efa4 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -12,9 +12,10 @@ import subprocess from abc import ABC, abstractmethod from collections import defaultdict -from typing import Dict, Optional, cast +from typing import Any, DefaultDict, Dict, Optional, cast import numpy as np +import numpy.typing as npt import torch import torch.nn as nn import torch.optim as optim @@ -32,7 +33,8 @@ ParallelCollater, ) from ocpmodels.common.registry import registry -from ocpmodels.common.typing import assert_is_instance +from ocpmodels.common.typing import assert_is_instance as aii +from ocpmodels.common.typing import none_throws from ocpmodels.common.utils import ( cg_decomp_mat, check_traj_files, @@ -56,6 +58,16 @@ @registry.register_trainer("base") class BaseTrainer(ABC): + train_loader: DataLoader[Any] + val_loader: DataLoader[Any] + test_loader: DataLoader[Any] + device: torch.device + output_targets: Dict[str, Any] + normalizers: Dict[str, Any] + ema: Optional[ExponentialMovingAverage] + clip_grad_norm: bool + ema_decay: float + def __init__( self, task, @@ -65,12 +77,12 @@ def __init__( optimizer, loss_fns, eval_metrics, - identifier, + identifier: str, timestamp_id: Optional[str] = None, - run_dir=None, + run_dir: Optional[str] = None, is_debug: bool = False, print_every: int = 100, - seed=None, + seed: Optional[int] = None, logger: str = "tensorboard", local_rank: int = 0, amp: bool = False, @@ -100,14 +112,14 @@ def __init__( # create directories from master rank only distutils.broadcast(timestamp, 0) _timestamp_id = datetime.datetime.fromtimestamp( - timestamp.int() + float(timestamp.float().item()) ).strftime("%Y-%m-%d-%H-%M-%S") if identifier: timestamp_id = f"{_timestamp_id}-{identifier}" else: timestamp_id = _timestamp_id - self.timestamp_id = timestamp_id + self.timestamp_id = none_throws(timestamp_id) commit_hash = get_commit_hash() @@ -115,7 +127,7 @@ def __init__( self.config = { "task": task, "trainer": name, - "model": assert_is_instance(model.pop("name"), str), + "model": aii(model.pop("name"), str), "model_attributes": model, "outputs": outputs, "optim": optimizer, @@ -186,7 +198,7 @@ def __init__( ### backwards compatability with OCP v<2.0 if self.name != "ocp": logging.warning( - f"Detected old config, converting to new format. Consider updating to avoid potential incompatibilities." + "Detected old config, converting to new format. Consider updating to avoid potential incompatibilities." ) update_old_config(self.config) @@ -400,7 +412,7 @@ def load_task(self): "eval_on_free_atoms", True ) - ##TODO: Assert that all targets, loss fn, metrics defined and consistent + # TODO: Assert that all targets, loss fn, metrics defined and consistent self.evaluation_metrics = self.config.get("eval_metrics", {}) self.evaluator = Evaluator( task=self.name, @@ -582,8 +594,10 @@ def load_optimizer(self) -> None: def load_extras(self) -> None: self.scheduler = LRScheduler(self.optimizer, self.config["optim"]) - self.clip_grad_norm = self.config["optim"].get("clip_grad_norm") - self.ema_decay = self.config["optim"].get("ema_decay") + self.clip_grad_norm = aii( + self.config["optim"].get("clip_grad_norm"), bool + ) + self.ema_decay = aii(self.config["optim"].get("ema_decay"), float) if self.ema_decay: self.ema = ExponentialMovingAverage( self.model.parameters(), @@ -597,7 +611,7 @@ def save( metrics=None, checkpoint_file: str = "checkpoint.pt", training_state: bool = True, - ): + ) -> Optional[str]: if not self.is_debug and distutils.is_master(): if training_state: return save_checkpoint( @@ -629,7 +643,7 @@ def save( checkpoint_file=checkpoint_file, ) else: - if self.ema: + if self.ema is not None: self.ema.store() self.ema.copy_to() ckpt_path = save_checkpoint( @@ -657,8 +671,8 @@ def update_best( self, primary_metric, val_metrics, - disable_eval_tqdm=True, - ): + disable_eval_tqdm: bool = True, + ) -> None: if ( "mae" in primary_metric and val_metrics[primary_metric]["metric"] < self.best_val_metric @@ -679,7 +693,7 @@ def update_best( disable_tqdm=disable_eval_tqdm, ) - def train(self, disable_eval_tqdm=False): + def train(self, disable_eval_tqdm: bool = False) -> None: ensure_fitted(self._unwrapped_model, warn=True) eval_every = self.config["optim"].get( @@ -1041,9 +1055,9 @@ def _backward(self, loss) -> None: def predict( self, data_loader, - per_image=True, - results_file=None, - disable_tqdm=False, + per_image: bool = True, + results_file: Optional[str] = None, + disable_tqdm: bool = False, ): ensure_fitted(self._unwrapped_model, warn=True) @@ -1062,7 +1076,7 @@ def predict( data_loader = [[data_loader]] self.model.eval() - if self.ema: + if self.ema is not None: self.ema.store() self.ema.copy_to() @@ -1234,7 +1248,9 @@ def save_results( distutils.synchronize() if distutils.is_master(): - gather_results = defaultdict(list) + gather_results: DefaultDict[ + str, npt.NDArray[np.float_] + ] = defaultdict(list) full_path = os.path.join( self.config["cmd"]["results_dir"], f"{self.name}_{results_file}.npz", From 4b5e2a0f8c3aff66a6f04a89ea70b45b24ada447 Mon Sep 17 00:00:00 2001 From: Richard Barnes Date: Tue, 8 Aug 2023 23:16:01 -0700 Subject: [PATCH 29/63] Abstract out _get_timestamp --- ocpmodels/trainers/base_trainer.py | 26 ++++++++++++++------------ 1 file changed, 14 insertions(+), 12 deletions(-) diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index b9486efa4..09f61e639 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -106,18 +106,7 @@ def __init__( run_dir = os.getcwd() if timestamp_id is None: - timestamp = torch.tensor(datetime.datetime.now().timestamp()).to( - self.device - ) - # create directories from master rank only - distutils.broadcast(timestamp, 0) - _timestamp_id = datetime.datetime.fromtimestamp( - float(timestamp.float().item()) - ).strftime("%Y-%m-%d-%H-%M-%S") - if identifier: - timestamp_id = f"{_timestamp_id}-{identifier}" - else: - timestamp_id = _timestamp_id + timestamp_id = self._get_timestamp(self.device, identifier) self.timestamp_id = none_throws(timestamp_id) @@ -204,6 +193,19 @@ def __init__( self.load() + @staticmethod + def _get_timestamp(device: torch.device, suffix: Optional[str]) -> str: + now = datetime.datetime.now().timestamp() + timestamp_tensor = torch.tensor(now).to(device) + # create directories from master rank only + distutils.broadcast(timestamp_tensor, 0) + timestamp_str = datetime.datetime.fromtimestamp( + timestamp_tensor.float().item() + ).strftime("%Y-%m-%d-%H-%M-%S") + if suffix: + timestamp_str += "-" + suffix + return timestamp_str + def load(self) -> None: self.load_seed_from_config() self.load_logger() From 32ef93ca10474dc645767c9299d7b29632385871 Mon Sep 17 00:00:00 2001 From: Janice Lan Date: Thu, 31 Aug 2023 14:27:40 -0700 Subject: [PATCH 30/63] don't double ids when saving prediction results --- ocpmodels/modules/loss.py | 2 +- ocpmodels/trainers/base_trainer.py | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/ocpmodels/modules/loss.py b/ocpmodels/modules/loss.py index 114840cca..b5daa4950 100644 --- a/ocpmodels/modules/loss.py +++ b/ocpmodels/modules/loss.py @@ -70,7 +70,7 @@ def forward( batch_size: Optional[int] = None, ): # ensure torch doesn't do any unwanted broadcasting - assert input.shape == target.shape + assert input.shape == target.shape, f"Mismatched shapes: {input.shape} and {target.shape}" # zero out nans, if any found_nans_or_infs = not torch.all(input.isfinite()) diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index 09f61e639..bbfa4e6ac 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -1264,7 +1264,6 @@ def save_results( f"{self.name}_{results_file}_{i}.npz", ) rank_results = np.load(rank_path, allow_pickle=True) - gather_results["ids"].extend(rank_results["ids"]) for key in keys: gather_results[key].extend(rank_results[key]) os.remove(rank_path) From 18f77dcaf1fa0186711b96494b1884bd9f65b2fb Mon Sep 17 00:00:00 2001 From: Janice Lan Date: Wed, 6 Sep 2023 20:11:20 -0700 Subject: [PATCH 31/63] clip_grad_norm should be float --- ocpmodels/trainers/base_trainer.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index bbfa4e6ac..c8e47fbee 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -65,7 +65,7 @@ class BaseTrainer(ABC): output_targets: Dict[str, Any] normalizers: Dict[str, Any] ema: Optional[ExponentialMovingAverage] - clip_grad_norm: bool + clip_grad_norm: float ema_decay: float def __init__( @@ -597,7 +597,7 @@ def load_optimizer(self) -> None: def load_extras(self) -> None: self.scheduler = LRScheduler(self.optimizer, self.config["optim"]) self.clip_grad_norm = aii( - self.config["optim"].get("clip_grad_norm"), bool + self.config["optim"].get("clip_grad_norm"), (int, float) ) self.ema_decay = aii(self.config["optim"].get("ema_decay"), float) if self.ema_decay: From c1d06aa9123f1540b26bda583293c93c1fdbcfe6 Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Fri, 27 Oct 2023 12:15:25 -0700 Subject: [PATCH 32/63] model compatibility --- ocpmodels/common/typing.py | 2 +- ocpmodels/models/cgcnn.py | 230 --- ocpmodels/models/dimenet.py | 225 --- ocpmodels/models/dimenet_plus_plus.py | 7 +- .../equiformer_v2/equiformer_v2_oc20.py | 10 +- ocpmodels/models/escn/escn.py | 7 +- ocpmodels/models/forcenet.py | 518 ------- ocpmodels/models/gemnet/gemnet.py | 8 +- ocpmodels/models/gemnet_gp/gemnet.py | 7 +- ocpmodels/models/painn/painn.py | 8 +- ocpmodels/models/schnet.py | 7 +- ocpmodels/models/scn/scn.py | 8 +- ocpmodels/models/spinconv.py | 1269 ----------------- ocpmodels/trainers/base_trainer.py | 2 +- tests/models/test_cgcnn.py | 97 -- tests/models/test_dimenetpp.py | 7 +- tests/models/test_equiformer_v2.py | 3 +- tests/models/test_forcenet.py | 66 - tests/models/test_gemnet.py | 7 +- tests/models/test_gemnet_oc.py | 7 +- tests/models/test_schnet.py | 7 +- 21 files changed, 51 insertions(+), 2451 deletions(-) delete mode 100644 ocpmodels/models/cgcnn.py delete mode 100644 ocpmodels/models/dimenet.py delete mode 100644 ocpmodels/models/forcenet.py delete mode 100644 ocpmodels/models/spinconv.py delete mode 100644 tests/models/test_cgcnn.py delete mode 100644 tests/models/test_forcenet.py diff --git a/ocpmodels/common/typing.py b/ocpmodels/common/typing.py index c2520fc41..b177edd93 100644 --- a/ocpmodels/common/typing.py +++ b/ocpmodels/common/typing.py @@ -4,7 +4,7 @@ def assert_is_instance(obj: object, cls: Type[_T]) -> _T: - if not isinstance(obj, cls): + if obj and not isinstance(obj, cls): raise TypeError(f"obj is not an instance of cls: obj={obj}, cls={cls}") return obj diff --git a/ocpmodels/models/cgcnn.py b/ocpmodels/models/cgcnn.py deleted file mode 100644 index 96254bbd8..000000000 --- a/ocpmodels/models/cgcnn.py +++ /dev/null @@ -1,230 +0,0 @@ -""" -Copyright (c) Facebook, Inc. and its affiliates. - -This source code is licensed under the MIT license found in the -LICENSE file in the root directory of this source tree. -""" - -import torch -import torch.nn as nn -from torch_geometric.nn import MessagePassing, global_mean_pool -from torch_geometric.nn.models.schnet import GaussianSmearing - -from ocpmodels.common.registry import registry -from ocpmodels.common.utils import conditional_grad -from ocpmodels.datasets.embeddings import KHOT_EMBEDDINGS, QMOF_KHOT_EMBEDDINGS -from ocpmodels.models.base import BaseModel - - -@registry.register_model("cgcnn") -class CGCNN(BaseModel): - r"""Implementation of the Crystal Graph CNN model from the - `"Crystal Graph Convolutional Neural Networks for an Accurate - and Interpretable Prediction of Material Properties" - `_ paper. - - Args: - num_atoms (int): Number of atoms. - bond_feat_dim (int): Dimension of bond features. - num_targets (int): Number of targets to predict. - use_pbc (bool, optional): If set to :obj:`True`, account for periodic boundary conditions. - (default: :obj:`True`) - regress_forces (bool, optional): If set to :obj:`True`, predict forces by differentiating - energy with respect to positions. - (default: :obj:`True`) - atom_embedding_size (int, optional): Size of atom embeddings. - (default: :obj:`64`) - num_graph_conv_layers (int, optional): Number of graph convolutional layers. - (default: :obj:`6`) - fc_feat_size (int, optional): Size of fully connected layers. - (default: :obj:`128`) - num_fc_layers (int, optional): Number of fully connected layers. - (default: :obj:`4`) - otf_graph (bool, optional): If set to :obj:`True`, compute graph edges on the fly. - (default: :obj:`False`) - cutoff (float, optional): Cutoff distance for interatomic interactions. - (default: :obj:`10.0`) - num_gaussians (int, optional): Number of Gaussians used for smearing. - (default: :obj:`50.0`) - """ - - def __init__( - self, - num_atoms: int, - bond_feat_dim: int, - num_targets: int, - use_pbc: bool = True, - regress_forces: bool = True, - atom_embedding_size: int = 64, - num_graph_conv_layers: int = 6, - fc_feat_size: int = 128, - num_fc_layers: int = 4, - otf_graph: bool = False, - cutoff: float = 6.0, - num_gaussians: int = 50, - embeddings: str = "khot", - ) -> None: - super(CGCNN, self).__init__(num_atoms, bond_feat_dim, num_targets) - self.regress_forces = regress_forces - self.use_pbc = use_pbc - self.cutoff = cutoff - self.otf_graph = otf_graph - self.max_neighbors = 50 - # Get CGCNN atom embeddings - if embeddings == "khot": - embeddings = KHOT_EMBEDDINGS - elif embeddings == "qmof": - embeddings = QMOF_KHOT_EMBEDDINGS - else: - raise ValueError( - 'embedding mnust be either "khot" for original CGCNN K-hot elemental embeddings or "qmof" for QMOF K-hot elemental embeddings' - ) - self.embedding = torch.zeros(100, len(embeddings[1])) - for i in range(100): - self.embedding[i] = torch.tensor(embeddings[i + 1]) - self.embedding_fc = nn.Linear(len(embeddings[1]), atom_embedding_size) - - self.convs = nn.ModuleList( - [ - CGCNNConv( - node_dim=atom_embedding_size, - edge_dim=bond_feat_dim, - cutoff=cutoff, - ) - for _ in range(num_graph_conv_layers) - ] - ) - - self.conv_to_fc = nn.Sequential( - nn.Linear(atom_embedding_size, fc_feat_size), nn.Softplus() - ) - - if num_fc_layers > 1: - layers = [] - for _ in range(num_fc_layers - 1): - layers.append(nn.Linear(fc_feat_size, fc_feat_size)) - layers.append(nn.Softplus()) - self.fcs = nn.Sequential(*layers) - self.fc_out = nn.Linear(fc_feat_size, self.num_targets) - - self.cutoff = cutoff - self.distance_expansion = GaussianSmearing(0.0, cutoff, num_gaussians) - - @conditional_grad(torch.enable_grad()) - def _forward(self, data): - # Get node features - if self.embedding.device != data.atomic_numbers.device: - self.embedding = self.embedding.to(data.atomic_numbers.device) - data.x = self.embedding[data.atomic_numbers.long() - 1] - - ( - edge_index, - distances, - distance_vec, - cell_offsets, - _, # cell offset distances - neighbors, - ) = self.generate_graph(data) - - data.edge_index = edge_index - data.edge_attr = self.distance_expansion(distances) - # Forward pass through the network - mol_feats = self._convolve(data) - mol_feats = self.conv_to_fc(mol_feats) - if hasattr(self, "fcs"): - mol_feats = self.fcs(mol_feats) - - energy = self.fc_out(mol_feats) - return energy - - def forward(self, data): - if self.regress_forces: - data.pos.requires_grad_(True) - energy = self._forward(data) - - if self.regress_forces: - forces = -1 * ( - torch.autograd.grad( - energy, - data.pos, - grad_outputs=torch.ones_like(energy), - create_graph=True, - )[0] - ) - return energy, forces - else: - return energy - - def _convolve(self, data): - """ - Returns the output of the convolution layers before they are passed - into the dense layers. - """ - node_feats = self.embedding_fc(data.x) - for f in self.convs: - node_feats = f(node_feats, data.edge_index, data.edge_attr) - mol_feats = global_mean_pool(node_feats, data.batch) - return mol_feats - - -class CGCNNConv(MessagePassing): - """Implements the message passing layer from - `"Crystal Graph Convolutional Neural Networks for an - Accurate and Interpretable Prediction of Material Properties" - `. - """ - - def __init__( - self, node_dim, edge_dim, cutoff: float = 6.0, **kwargs - ) -> None: - super(CGCNNConv, self).__init__(aggr="add") - self.node_feat_size = node_dim - self.edge_feat_size = edge_dim - self.cutoff = cutoff - - self.lin1 = nn.Linear( - 2 * self.node_feat_size + self.edge_feat_size, - 2 * self.node_feat_size, - ) - self.bn1 = nn.BatchNorm1d(2 * self.node_feat_size) - self.ln1 = nn.LayerNorm(self.node_feat_size) - - self.reset_parameters() - - def reset_parameters(self) -> None: - torch.nn.init.xavier_uniform_(self.lin1.weight) - - self.lin1.bias.data.fill_(0) - - self.bn1.reset_parameters() - self.ln1.reset_parameters() - - def forward(self, x, edge_index, edge_attr): - """ - Arguments: - x has shape [num_nodes, node_feat_size] - edge_index has shape [2, num_edges] - edge_attr is [num_edges, edge_feat_size] - """ - out = self.propagate( - edge_index, x=x, edge_attr=edge_attr, size=(x.size(0), x.size(0)) - ) - out = nn.Softplus()(self.ln1(out) + x) - return out - - def message(self, x_i, x_j, edge_attr): - """ - Arguments: - x_i has shape [num_edges, node_feat_size] - x_j has shape [num_edges, node_feat_size] - edge_attr has shape [num_edges, edge_feat_size] - - Returns: - tensor of shape [num_edges, node_feat_size] - """ - z = self.lin1(torch.cat([x_i, x_j, edge_attr], dim=1)) - z = self.bn1(z) - z1, z2 = z.chunk(2, dim=1) - z1 = nn.Sigmoid()(z1) - z2 = nn.Softplus()(z2) - return z1 * z2 diff --git a/ocpmodels/models/dimenet.py b/ocpmodels/models/dimenet.py deleted file mode 100644 index efd335158..000000000 --- a/ocpmodels/models/dimenet.py +++ /dev/null @@ -1,225 +0,0 @@ -""" -Copyright (c) Facebook, Inc. and its affiliates. - -This source code is licensed under the MIT license found in the -LICENSE file in the root directory of this source tree. -""" - -import torch -from torch_geometric.nn import DimeNet -from torch_scatter import scatter -from torch_sparse import SparseTensor - -from ocpmodels.common.registry import registry -from ocpmodels.common.utils import conditional_grad -from ocpmodels.models.base import BaseModel - - -@registry.register_model("dimenet") -class DimeNetWrap(DimeNet, BaseModel): - r"""Wrapper around the directional message passing neural network (DimeNet) from the - `"Directional Message Passing for Molecular Graphs" - `_ paper. - - DimeNet transforms messages based on the angle between them in a - rotation-equivariant fashion. - - Args: - num_atoms (int): Unused argument - bond_feat_dim (int): Unused argument - num_targets (int): Number of targets to predict. - use_pbc (bool, optional): If set to :obj:`True`, account for periodic boundary conditions. - (default: :obj:`True`) - regress_forces (bool, optional): If set to :obj:`True`, predict forces by differentiating - energy with respect to positions. - (default: :obj:`True`) - hidden_channels (int, optional): Number of hidden channels. - (default: :obj:`128`) - num_blocks (int, optional): Number of building blocks. - (default: :obj:`6`) - num_bilinear (int, optional): Size of the bilinear layer tensor. - (default: :obj:`8`) - num_spherical (int, optional): Number of spherical harmonics. - (default: :obj:`7`) - num_radial (int, optional): Number of radial basis functions. - (default: :obj:`6`) - otf_graph (bool, optional): If set to :obj:`True`, compute graph edges on the fly. - (default: :obj:`False`) - cutoff (float, optional): Cutoff distance for interatomic interactions. - (default: :obj:`10.0`) - envelope_exponent (int, optional): Shape of the smooth cutoff. - (default: :obj:`5`) - num_before_skip: (int, optional): Number of residual layers in the - interaction blocks before the skip connection. (default: :obj:`1`) - num_after_skip: (int, optional): Number of residual layers in the - interaction blocks after the skip connection. (default: :obj:`2`) - num_output_layers: (int, optional): Number of linear layers for the - output blocks. (default: :obj:`3`) - max_angles_per_image (int, optional): The maximum number of angles used - per image. This can be used to reduce memory usage at the cost of - model performance. (default: :obj:`1e6`) - """ - - def __init__( - self, - num_atoms: int, - bond_feat_dim: int, # not used - num_targets: int, - use_pbc: bool = True, - regress_forces: bool = True, - hidden_channels: int = 128, - num_blocks: int = 6, - num_bilinear: int = 8, - num_spherical: int = 7, - num_radial: int = 6, - otf_graph: bool = False, - cutoff: float = 10.0, - envelope_exponent: int = 5, - num_before_skip: int = 1, - num_after_skip: int = 2, - num_output_layers: int = 3, - max_angles_per_image: int = int(1e6), - ) -> None: - self.num_targets = num_targets - self.regress_forces = regress_forces - self.use_pbc = use_pbc - self.cutoff = cutoff - self.otf_graph = otf_graph - self.max_angles_per_image = max_angles_per_image - self.max_neighbors = 50 - - super(DimeNetWrap, self).__init__( - hidden_channels=hidden_channels, - out_channels=num_targets, - num_blocks=num_blocks, - num_bilinear=num_bilinear, - num_spherical=num_spherical, - num_radial=num_radial, - cutoff=cutoff, - envelope_exponent=envelope_exponent, - num_before_skip=num_before_skip, - num_after_skip=num_after_skip, - num_output_layers=num_output_layers, - ) - - def triplets(self, edge_index, cell_offsets, num_nodes: int): - row, col = edge_index # j->i - - value = torch.arange(row.size(0), device=row.device) - adj_t = SparseTensor( - row=col, col=row, value=value, sparse_sizes=(num_nodes, num_nodes) - ) - adj_t_row = adj_t[row] - num_triplets = adj_t_row.set_value(None).sum(dim=1).to(torch.long) - - # Node indices (k->j->i) for triplets. - idx_i = col.repeat_interleave(num_triplets) - idx_j = row.repeat_interleave(num_triplets) - idx_k = adj_t_row.storage.col() - - # Edge indices (k->j, j->i) for triplets. - idx_kj = adj_t_row.storage.value() - idx_ji = adj_t_row.storage.row() - - # Remove self-loop triplets d->b->d - # Check atom as well as cell offset - cell_offset_kji = cell_offsets[idx_kj] + cell_offsets[idx_ji] - mask = (idx_i != idx_k) | torch.any(cell_offset_kji != 0, dim=-1) - - idx_i, idx_j, idx_k = idx_i[mask], idx_j[mask], idx_k[mask] - idx_kj, idx_ji = idx_kj[mask], idx_ji[mask] - - return col, row, idx_i, idx_j, idx_k, idx_kj, idx_ji - - @conditional_grad(torch.enable_grad()) - def _forward(self, data): - pos = data.pos - batch = data.batch - ( - edge_index, - dist, - _, - cell_offsets, - offsets, - neighbors, - ) = self.generate_graph(data) - - data.edge_index = edge_index - data.cell_offsets = cell_offsets - data.neighbors = neighbors - j, i = edge_index - - _, _, idx_i, idx_j, idx_k, idx_kj, idx_ji = self.triplets( - edge_index, - data.cell_offsets, - num_nodes=data.atomic_numbers.size(0), - ) - - # Cap no. of triplets during training. - if self.training: - sub_ix = torch.randperm(idx_i.size(0))[ - : self.max_angles_per_image * data.natoms.size(0) - ] - idx_i, idx_j, idx_k = ( - idx_i[sub_ix], - idx_j[sub_ix], - idx_k[sub_ix], - ) - idx_kj, idx_ji = idx_kj[sub_ix], idx_ji[sub_ix] - - # Calculate angles. - pos_i = pos[idx_i].detach() - pos_j = pos[idx_j].detach() - if self.use_pbc: - pos_ji, pos_kj = ( - pos[idx_j].detach() - pos_i + offsets[idx_ji], - pos[idx_k].detach() - pos_j + offsets[idx_kj], - ) - else: - pos_ji, pos_kj = ( - pos[idx_j].detach() - pos_i, - pos[idx_k].detach() - pos_j, - ) - - a = (pos_ji * pos_kj).sum(dim=-1) - b = torch.cross(pos_ji, pos_kj).norm(dim=-1) - angle = torch.atan2(b, a) - - rbf = self.rbf(dist) - sbf = self.sbf(dist, angle, idx_kj) - - # Embedding block. - x = self.emb(data.atomic_numbers.long(), rbf, i, j) - P = self.output_blocks[0](x, rbf, i, num_nodes=pos.size(0)) - - # Interaction blocks. - for interaction_block, output_block in zip( - self.interaction_blocks, self.output_blocks[1:] - ): - x = interaction_block(x, rbf, sbf, idx_kj, idx_ji) - P += output_block(x, rbf, i, num_nodes=pos.size(0)) - - energy = P.sum(dim=0) if batch is None else scatter(P, batch, dim=0) - return energy - - def forward(self, data): - if self.regress_forces: - data.pos.requires_grad_(True) - energy = self._forward(data) - - if self.regress_forces: - forces = -1 * ( - torch.autograd.grad( - energy, - data.pos, - grad_outputs=torch.ones_like(energy), - create_graph=True, - )[0] - ) - return energy, forces - else: - return energy - - @property - def num_params(self) -> int: - return sum(p.numel() for p in self.parameters()) diff --git a/ocpmodels/models/dimenet_plus_plus.py b/ocpmodels/models/dimenet_plus_plus.py index e2c9cade6..5d72b4369 100644 --- a/ocpmodels/models/dimenet_plus_plus.py +++ b/ocpmodels/models/dimenet_plus_plus.py @@ -446,6 +446,7 @@ def forward(self, data): if self.regress_forces: data.pos.requires_grad_(True) energy = self._forward(data) + outputs = {"energy": energy} if self.regress_forces: forces = -1 * ( @@ -456,9 +457,9 @@ def forward(self, data): create_graph=True, )[0] ) - return energy, forces - else: - return energy + outputs["forces"] = forces + + return outputs @property def num_params(self) -> int: diff --git a/ocpmodels/models/equiformer_v2/equiformer_v2_oc20.py b/ocpmodels/models/equiformer_v2/equiformer_v2_oc20.py index dea91f21f..79b1372c2 100644 --- a/ocpmodels/models/equiformer_v2/equiformer_v2_oc20.py +++ b/ocpmodels/models/equiformer_v2/equiformer_v2_oc20.py @@ -533,6 +533,7 @@ def forward(self, data): self.energy_lin_ref[atomic_numbers], ) + outputs = {"energy": energy} ############################################################### # Force estimation ############################################################### @@ -542,14 +543,9 @@ def forward(self, data): ) forces = forces.embedding.narrow(1, 1, 3) forces = forces.view(-1, 3) + outputs["forces"] = forces - if not self.regress_forces: - return {"energy": energy} - else: - return { - "energy": energy, - "forces": forces, - } + return outputs # Initialize the edge rotation matrics def _init_edge_rot_mat(self, data, edge_index, edge_distance_vec): diff --git a/ocpmodels/models/escn/escn.py b/ocpmodels/models/escn/escn.py index a6e56b423..4ca8c09e8 100644 --- a/ocpmodels/models/escn/escn.py +++ b/ocpmodels/models/escn/escn.py @@ -347,11 +347,13 @@ def forward(self, data): # Scale energy to help balance numerical precision w.r.t. forces energy = energy * 0.001 + outputs = {"energy": energy} ############################################################### # Force estimation ############################################################### if self.regress_forces: forces = self.force_block(x_pt, self.sphere_points) + outputs["forces"] = forces if self.show_timing_info is True: torch.cuda.synchronize() @@ -366,10 +368,7 @@ def forward(self, data): self.counter = self.counter + 1 - if not self.regress_forces: - return energy - else: - return energy, forces + return outputs # Initialize the edge rotation matrics def _init_edge_rot_mat(self, data, edge_index, edge_distance_vec): diff --git a/ocpmodels/models/forcenet.py b/ocpmodels/models/forcenet.py deleted file mode 100644 index cf909abd5..000000000 --- a/ocpmodels/models/forcenet.py +++ /dev/null @@ -1,518 +0,0 @@ -""" -Copyright (c) Facebook, Inc. and its affiliates. - -This source code is licensed under the MIT license found in the -LICENSE file in the root directory of this source tree. -""" - -from math import pi as PI -from typing import Optional - -import numpy as np -import torch -import torch.nn as nn -from torch_geometric.nn import MessagePassing -from torch_scatter import scatter - -from ocpmodels.common.registry import registry -from ocpmodels.datasets.embeddings import ATOMIC_RADII, CONTINUOUS_EMBEDDINGS -from ocpmodels.models.base import BaseModel -from ocpmodels.models.utils.activations import Act -from ocpmodels.models.utils.basis import Basis, SphericalSmearing - - -class FNDecoder(nn.Module): - def __init__( - self, decoder_type, decoder_activation_str, output_dim: int - ) -> None: - super(FNDecoder, self).__init__() - self.decoder_type = decoder_type - self.decoder_activation = Act(decoder_activation_str) - self.output_dim = output_dim - - self.decoder: nn.Sequential - if self.decoder_type == "linear": - self.decoder = nn.Sequential(nn.Linear(self.output_dim, 3)) - elif self.decoder_type == "mlp": - self.decoder = nn.Sequential( - nn.Linear(self.output_dim, self.output_dim), - nn.BatchNorm1d(self.output_dim), - self.decoder_activation, - nn.Linear(self.output_dim, 3), - ) - else: - raise ValueError(f"Undefined force decoder: {self.decoder_type}") - - self.reset_parameters() - - def reset_parameters(self) -> None: - for m in self.decoder: - if isinstance(m, nn.Linear): - nn.init.xavier_uniform_(m.weight) - m.bias.data.fill_(0) - - def forward(self, x): - return self.decoder(x) - - -class InteractionBlock(MessagePassing): - def __init__( - self, - hidden_channels: int, - mlp_basis_dim: int, - basis_type, - depth_mlp_edge: int = 2, - depth_mlp_trans: int = 1, - activation_str: str = "ssp", - ablation: str = "none", - ) -> None: - super(InteractionBlock, self).__init__(aggr="add") - - self.activation = Act(activation_str) - self.ablation = ablation - self.basis_type = basis_type - - # basis function assumes input is in the range of [-1,1] - if self.basis_type != "rawcat": - self.lin_basis = torch.nn.Linear(mlp_basis_dim, hidden_channels) - - if self.ablation == "nocond": - # the edge filter only depends on edge_attr - in_features = ( - mlp_basis_dim - if self.basis_type == "rawcat" - else hidden_channels - ) - else: - # edge filter depends on edge_attr and current node embedding - in_features = ( - mlp_basis_dim + 2 * hidden_channels - if self.basis_type == "rawcat" - else 3 * hidden_channels - ) - - if depth_mlp_edge > 0: - mlp_edge = [torch.nn.Linear(in_features, hidden_channels)] - for _ in range(depth_mlp_edge): - mlp_edge.append(self.activation) - mlp_edge.append( - torch.nn.Linear(hidden_channels, hidden_channels) - ) - else: - ## need batch normalization afterwards. Otherwise training is unstable. - mlp_edge = [ - torch.nn.Linear(in_features, hidden_channels), - torch.nn.BatchNorm1d(hidden_channels), - ] - self.mlp_edge = torch.nn.Sequential(*mlp_edge) - - if not self.ablation == "nofilter": - self.lin = torch.nn.Linear(hidden_channels, hidden_channels) - - if depth_mlp_trans > 0: - mlp_trans = [torch.nn.Linear(hidden_channels, hidden_channels)] - for _ in range(depth_mlp_trans): - mlp_trans.append(torch.nn.BatchNorm1d(hidden_channels)) - mlp_trans.append(self.activation) - mlp_trans.append( - torch.nn.Linear(hidden_channels, hidden_channels) - ) - else: - # need batch normalization afterwards. Otherwise, becomes NaN - mlp_trans = [ - torch.nn.Linear(hidden_channels, hidden_channels), - torch.nn.BatchNorm1d(hidden_channels), - ] - - self.mlp_trans = torch.nn.Sequential(*mlp_trans) - - if not self.ablation == "noself": - self.center_W = torch.nn.Parameter( - torch.Tensor(1, hidden_channels) - ) - - self.reset_parameters() - - def reset_parameters(self) -> None: - if self.basis_type != "rawcat": - torch.nn.init.xavier_uniform_(self.lin_basis.weight) - self.lin_basis.bias.data.fill_(0) - - for m in self.mlp_trans: - if isinstance(m, torch.nn.Linear): - torch.nn.init.xavier_uniform_(m.weight) - m.bias.data.fill_(0) - - for m in self.mlp_edge: - if isinstance(m, torch.nn.Linear): - torch.nn.init.xavier_uniform_(m.weight) - m.bias.data.fill_(0) - - if not self.ablation == "nofilter": - torch.nn.init.xavier_uniform_(self.lin.weight) - self.lin.bias.data.fill_(0) - - if not self.ablation == "noself": - torch.nn.init.xavier_uniform_(self.center_W) - - def forward(self, x, edge_index, edge_attr, edge_weight): - if self.basis_type != "rawcat": - edge_emb = self.lin_basis(edge_attr) - else: - # for rawcat, we directly use the raw feature - edge_emb = edge_attr - - if self.ablation == "nocond": - emb = edge_emb - else: - emb = torch.cat( - [edge_emb, x[edge_index[0]], x[edge_index[1]]], dim=1 - ) - - W = self.mlp_edge(emb) * edge_weight.view(-1, 1) - if self.ablation == "nofilter": - x = self.propagate(edge_index, x=x, W=W) + self.center_W - else: - x = self.lin(x) - if self.ablation == "noself": - x = self.propagate(edge_index, x=x, W=W) - else: - x = self.propagate(edge_index, x=x, W=W) + self.center_W * x - x = self.mlp_trans(x) - - return x - - def message(self, x_j, W): - if self.ablation == "nofilter": - return W - else: - return x_j * W - - -# flake8: noqa: C901 -@registry.register_model("forcenet") -class ForceNet(BaseModel): - r"""Implementation of ForceNet architecture. - - Args: - num_atoms (int): Unused argument - bond_feat_dim (int): Unused argument - num_targets (int): Unused argumebt - hidden_channels (int, optional): Number of hidden channels. - (default: :obj:`512`) - num_iteractions (int, optional): Number of interaction blocks. - (default: :obj:`5`) - cutoff (float, optional): Cutoff distance for interatomic interactions. - (default: :obj:`6.0`) - feat (str, optional): Input features to be used - (default: :obj:`full`) - num_freqs (int, optional): Number of frequencies for basis function. - (default: :obj:`50`) - max_n (int, optional): Maximum order of spherical harmonics. - (default: :obj:`6`) - basis (str, optional): Basis function to be used. - (default: :obj:`full`) - depth_mlp_edge (int, optional): Depth of MLP for edges in interaction blocks. - (default: :obj:`2`) - depth_mlp_node (int, optional): Depth of MLP for nodes in interaction blocks. - (default: :obj:`1`) - activation_str (str, optional): Activation function used post linear layer in all message passing MLPs. - (default: :obj:`swish`) - ablation (str, optional): Type of ablation to be performed. - (default: :obj:`none`) - decoder_hidden_channels (int, optional): Number of hidden channels in the decoder. - (default: :obj:`512`) - decoder_type (str, optional): Type of decoder: linear or MLP. - (default: :obj:`mlp`) - decoder_activation_str (str, optional): Activation function used post linear layer in decoder. - (default: :obj:`swish`) - training (bool, optional): If set to :obj:`True`, specify training phase. - (default: :obj:`True`) - otf_graph (bool, optional): If set to :obj:`True`, compute graph edges on the fly. - (default: :obj:`False`) - """ - - def __init__( - self, - num_atoms: int, # not used - bond_feat_dim: int, # not used - num_targets: int, # not used - hidden_channels: int = 512, - num_interactions: int = 5, - cutoff: float = 6.0, - feat: str = "full", - num_freqs: int = 50, - max_n: int = 3, - basis: str = "sphallmul", - depth_mlp_edge: int = 2, - depth_mlp_node: int = 1, - activation_str: str = "swish", - ablation: str = "none", - decoder_hidden_channels: int = 512, - decoder_type: str = "mlp", - decoder_activation_str: str = "swish", - training: bool = True, - otf_graph: bool = False, - use_pbc: bool = True, - ) -> None: - super(ForceNet, self).__init__() - self.training = training - self.ablation = ablation - if self.ablation not in [ - "none", - "nofilter", - "nocond", - "nodistlist", - "onlydist", - "nodelinear", - "edgelinear", - "noself", - ]: - raise ValueError(f"Unknown ablation called {ablation}.") - - """ - Descriptions of ablations: - - none: base ForceNet model - - nofilter: no element-wise filter parameterization in message modeling - - nocond: convolutional filter is only conditioned on edge features, not node embeddings - - nodistlist: no atomic radius information in edge features - - onlydist: edge features only contains distance information. Orientation information is ommited. - - nodelinear: node update MLP function is replaced with linear function followed by batch normalization - - edgelinear: edge MLP transformation function is replaced with linear function followed by batch normalization. - - noself: no self edge of m_t. - """ - - self.otf_graph = otf_graph - self.cutoff = cutoff - self.output_dim = decoder_hidden_channels - self.feat = feat - self.num_freqs = num_freqs - self.num_layers = num_interactions - self.max_n = max_n - self.activation_str = activation_str - self.use_pbc = use_pbc - self.max_neighbors = 50 - - if self.ablation == "edgelinear": - depth_mlp_edge = 0 - - if self.ablation == "nodelinear": - depth_mlp_node = 0 - - # read atom map and atom radii - atom_map = torch.zeros(101, 9) - for i in range(101): - atom_map[i] = torch.tensor(CONTINUOUS_EMBEDDINGS[i]) - - atom_radii = torch.zeros(101) - for i in range(101): - atom_radii[i] = ATOMIC_RADII[i] - atom_radii = atom_radii / 100 - - self.atom_radii = nn.Parameter(atom_radii, requires_grad=False) - self.basis_type = basis - - self.pbc_apply_sph_harm = "sph" in self.basis_type - self.pbc_sph_option = None - - # for spherical harmonics for PBC - if "sphall" in self.basis_type: - self.pbc_sph_option = "all" - elif "sphsine" in self.basis_type: - self.pbc_sph_option = "sine" - elif "sphcosine" in self.basis_type: - self.pbc_sph_option = "cosine" - - self.pbc_sph: Optional[SphericalSmearing] = None - if self.pbc_apply_sph_harm: - self.pbc_sph = SphericalSmearing( - max_n=self.max_n, option=self.pbc_sph_option - ) - - # self.feat can be "simple" or "full" - if self.feat == "simple": - self.embedding = nn.Embedding(100, hidden_channels) - - # set up dummy atom_map that only contains atomic_number information - atom_map = torch.linspace(0, 1, 101).view(-1, 1).repeat(1, 9) - self.atom_map = nn.Parameter(atom_map, requires_grad=False) - - elif self.feat == "full": - # Normalize along each dimaension - atom_map[0] = np.nan - atom_map_notnan = atom_map[atom_map[:, 0] == atom_map[:, 0]] - atom_map_min = torch.min(atom_map_notnan, dim=0)[0] - atom_map_max = torch.max(atom_map_notnan, dim=0)[0] - atom_map_gap = atom_map_max - atom_map_min - - ## squash to [0,1] - atom_map = ( - atom_map - atom_map_min.view(1, -1) - ) / atom_map_gap.view(1, -1) - - self.atom_map = torch.nn.Parameter(atom_map, requires_grad=False) - - in_features = 9 - # first apply basis function and then linear function - if "sph" in self.basis_type: - # spherical basis is only meaningful for edge feature, so use powersine instead - node_basis_type = "powersine" - else: - node_basis_type = self.basis_type - basis = Basis( - in_features, - num_freqs=num_freqs, - basis_type=node_basis_type, - act=self.activation_str, - ) - self.embedding = torch.nn.Sequential( - basis, torch.nn.Linear(basis.out_dim, hidden_channels) - ) - - else: - raise ValueError("Undefined feature type for atom") - - # process basis function for edge feature - if self.ablation == "nodistlist": - # do not consider additional distance edge features - # normalized (x,y,z) + distance - in_feature = 4 - elif self.ablation == "onlydist": - # only consider distance-based edge features - # ignore normalized (x,y,z) - in_feature = 4 - - # if basis_type is spherical harmonics, then reduce to powersine - if "sph" in self.basis_type: - logging.info( - "Under onlydist ablation, spherical basis is reduced to powersine basis." - ) - self.basis_type = "powersine" - self.pbc_sph = None - - else: - in_feature = 7 - self.basis_fun = Basis( - in_feature, - num_freqs, - self.basis_type, - self.activation_str, - sph=self.pbc_sph, - ) - - # process interaction blocks - self.interactions = torch.nn.ModuleList() - for _ in range(num_interactions): - block = InteractionBlock( - hidden_channels, - self.basis_fun.out_dim, - self.basis_type, - depth_mlp_edge=depth_mlp_edge, - depth_mlp_trans=depth_mlp_node, - activation_str=self.activation_str, - ablation=ablation, - ) - self.interactions.append(block) - - self.lin = torch.nn.Linear(hidden_channels, self.output_dim) - self.activation = Act(activation_str) - - # ForceNet decoder - self.decoder = FNDecoder( - decoder_type, decoder_activation_str, self.output_dim - ) - - # Projection layer for energy prediction - self.energy_mlp = nn.Linear(self.output_dim, 1) - - def forward(self, data): - z = data.atomic_numbers.long() - - pos = data.pos - batch = data.batch - - if self.feat == "simple": - h = self.embedding(z) - elif self.feat == "full": - h = self.embedding(self.atom_map[z]) - else: - raise RuntimeError("Undefined feature type for atom") - - ( - edge_index, - edge_dist, - edge_vec, - cell_offsets, - _, # cell offset distances - neighbors, - ) = self.generate_graph(data) - - data.edge_index = edge_index - data.cell_offsets = cell_offsets - data.neighbors = neighbors - - if self.pbc_apply_sph_harm: - edge_vec_normalized = edge_vec / edge_dist.view(-1, 1) - edge_attr_sph = self.pbc_sph(edge_vec_normalized) - - # calculate the edge weight according to the dist - edge_weight = torch.cos(0.5 * edge_dist * PI / self.cutoff) - - # normalized edge vectors - edge_vec_normalized = edge_vec / edge_dist.view(-1, 1) - - # edge distance, taking the atom_radii into account - # each element lies in [0,1] - edge_dist_list = ( - torch.stack( - [ - edge_dist, - edge_dist - self.atom_radii[z[edge_index[0]]], - edge_dist - self.atom_radii[z[edge_index[1]]], - edge_dist - - self.atom_radii[z[edge_index[0]]] - - self.atom_radii[z[edge_index[1]]], - ] - ).transpose(0, 1) - / self.cutoff - ) - - if self.ablation == "nodistlist": - edge_dist_list = edge_dist_list[:, 0].view(-1, 1) - - # make sure distance is positive - edge_dist_list[edge_dist_list < 1e-3] = 1e-3 - - # squash to [0,1] for gaussian basis - if self.basis_type == "gauss": - edge_vec_normalized = (edge_vec_normalized + 1) / 2.0 - - # process raw_edge_attributes to generate edge_attributes - if self.ablation == "onlydist": - raw_edge_attr = edge_dist_list - else: - raw_edge_attr = torch.cat( - [edge_vec_normalized, edge_dist_list], dim=1 - ) - - if "sph" in self.basis_type: - edge_attr = self.basis_fun(raw_edge_attr, edge_attr_sph) - else: - edge_attr = self.basis_fun(raw_edge_attr) - - # pass edge_attributes through interaction blocks - for _, interaction in enumerate(self.interactions): - h = h + interaction(h, edge_index, edge_attr, edge_weight) - - h = self.lin(h) - h = self.activation(h) - - out = scatter(h, batch, dim=0, reduce="add") - - force = self.decoder(h) - energy = self.energy_mlp(out) - return energy, force - - @property - def num_params(self) -> int: - return sum(p.numel() for p in self.parameters()) diff --git a/ocpmodels/models/gemnet/gemnet.py b/ocpmodels/models/gemnet/gemnet.py index c457b5108..dee6ef235 100644 --- a/ocpmodels/models/gemnet/gemnet.py +++ b/ocpmodels/models/gemnet/gemnet.py @@ -561,6 +561,8 @@ def forward(self, data): E_t, batch, dim=0, dim_size=nMolecules, reduce="mean" ) # (nMolecules, num_targets) + outputs = {"energy": E_t} + if self.regress_forces: if self.direct_forces: # map forces in edge directions @@ -592,9 +594,9 @@ def forward(self, data): )[0] # (nAtoms, 3) - return E_t, F_t # (nMolecules, num_targets), (nAtoms, 3) - else: - return E_t + outputs["forces"] = F_t + + return outputs @property def num_params(self): diff --git a/ocpmodels/models/gemnet_gp/gemnet.py b/ocpmodels/models/gemnet_gp/gemnet.py index 767f89cfa..94e1215fa 100644 --- a/ocpmodels/models/gemnet_gp/gemnet.py +++ b/ocpmodels/models/gemnet_gp/gemnet.py @@ -605,6 +605,7 @@ def forward(self, data): E_t, batch, dim=0, dim_size=nMolecules, reduce="mean" ) # (nMolecules, num_targets) + outputs = {"energy": E_t} if self.regress_forces: if self.direct_forces: # map forces in edge directions @@ -636,9 +637,9 @@ def forward(self, data): )[0] # (nAtoms, 3) - return E_t, F_t # (nMolecules, num_targets), (nAtoms, 3) - else: - return E_t + outputs["forces"] = F_t + + return outputs @property def num_params(self): diff --git a/ocpmodels/models/painn/painn.py b/ocpmodels/models/painn/painn.py index f2bf65600..3a9525897 100644 --- a/ocpmodels/models/painn/painn.py +++ b/ocpmodels/models/painn/painn.py @@ -412,11 +412,11 @@ def forward(self, data): per_atom_energy = self.out_energy(x).squeeze(1) energy = scatter(per_atom_energy, batch, dim=0) + outputs = {"energy": energy} if self.regress_forces: if self.direct_forces: forces = self.out_forces(x, vec) - return energy, forces else: forces = ( -1 @@ -427,9 +427,9 @@ def forward(self, data): create_graph=True, )[0] ) - return energy, forces - else: - return energy + outputs["forces"] = forces + + return outputs @property def num_params(self) -> int: diff --git a/ocpmodels/models/schnet.py b/ocpmodels/models/schnet.py index 5eb83db07..08fd93764 100644 --- a/ocpmodels/models/schnet.py +++ b/ocpmodels/models/schnet.py @@ -119,6 +119,7 @@ def forward(self, data): if self.regress_forces: data.pos.requires_grad_(True) energy = self._forward(data) + outputs = {"energy": energy} if self.regress_forces: forces = -1 * ( @@ -129,9 +130,9 @@ def forward(self, data): create_graph=True, )[0] ) - return energy, forces - else: - return energy + outputs["forces"] = forces + + return outputs @property def num_params(self) -> int: diff --git a/ocpmodels/models/scn/scn.py b/ocpmodels/models/scn/scn.py index dc94cbe2a..d9b79193f 100644 --- a/ocpmodels/models/scn/scn.py +++ b/ocpmodels/models/scn/scn.py @@ -404,6 +404,8 @@ def _forward_helper(self, data): energy = torch.zeros(len(data.natoms), device=pos.device) energy.index_add_(0, data.batch, node_energy.view(-1)) + outputs = {"energy": energy} + # Force estimation if self.regress_forces: forces = torch.einsum( @@ -416,11 +418,9 @@ def _forward_helper(self, data): forces = forces.view(-1, self.num_sphere_samples, 1) forces = forces * sphere_points.view(1, self.num_sphere_samples, 3) forces = torch.sum(forces, dim=1) / self.num_sphere_samples + outputs["forces"] = forces - if not self.regress_forces: - return energy - else: - return energy, forces + return outputs def _init_edge_rot_mat(self, data, edge_index, edge_distance_vec): edge_vec_0 = edge_distance_vec diff --git a/ocpmodels/models/spinconv.py b/ocpmodels/models/spinconv.py deleted file mode 100644 index bbf41c66a..000000000 --- a/ocpmodels/models/spinconv.py +++ /dev/null @@ -1,1269 +0,0 @@ -""" -Copyright (c) Facebook, Inc. and its affiliates. - -This source code is licensed under the MIT license found in the -LICENSE file in the root directory of this source tree. -""" -import logging -import math -import time -from math import pi as PI - -import torch -import torch.nn as nn -import torch.nn.functional as F -from torch.nn import ModuleList -from torch_scatter import scatter - -from ocpmodels.common.registry import registry -from ocpmodels.common.utils import conditional_grad -from ocpmodels.models.base import BaseModel - -try: - from e3nn import o3 - from e3nn.o3 import FromS2Grid -except Exception: - pass - - -@registry.register_model("spinconv") -class spinconv(BaseModel): - def __init__( - self, - num_atoms: int, # not used - bond_feat_dim: int, # not used - num_targets: int, - use_pbc: bool = True, - regress_forces: bool = True, - otf_graph: bool = False, - hidden_channels: int = 32, - mid_hidden_channels: int = 200, - num_interactions: int = 1, - num_basis_functions: int = 200, - basis_width_scalar: float = 1.0, - max_num_neighbors: int = 20, - sphere_size_lat: int = 15, - sphere_size_long: int = 9, - cutoff: float = 10.0, - distance_block_scalar_max: float = 2.0, - max_num_elements: int = 90, - embedding_size: int = 32, - show_timing_info: bool = False, - sphere_message: str = "fullconv", # message block sphere representation - output_message: str = "fullconv", # output block sphere representation - lmax: bool = False, - force_estimator: str = "random", - model_ref_number: int = 0, - readout: str = "add", - num_rand_rotations: int = 5, - scale_distances: bool = True, - ) -> None: - super(spinconv, self).__init__() - - self.num_targets = num_targets - self.num_random_rotations = num_rand_rotations - self.regress_forces = regress_forces - self.use_pbc = use_pbc - self.cutoff = cutoff - self.otf_graph = otf_graph - self.show_timing_info = show_timing_info - self.max_num_elements = max_num_elements - self.mid_hidden_channels = mid_hidden_channels - self.sphere_size_lat = sphere_size_lat - self.sphere_size_long = sphere_size_long - self.num_atoms = 0 - self.hidden_channels = hidden_channels - self.embedding_size = embedding_size - self.max_num_neighbors = self.max_neighbors = max_num_neighbors - self.sphere_message = sphere_message - self.output_message = output_message - self.force_estimator = force_estimator - self.num_basis_functions = num_basis_functions - self.distance_block_scalar_max = distance_block_scalar_max - self.grad_forces = False - self.num_embedding_basis = 8 - self.lmax = lmax - self.scale_distances = scale_distances - self.basis_width_scalar = basis_width_scalar - - if self.sphere_message in ["spharm", "rotspharmroll", "rotspharmwd"]: - assert self.lmax, "lmax must be defined for spherical harmonics" - if self.output_message in ["spharm", "rotspharmroll", "rotspharmwd"]: - assert self.lmax, "lmax must be defined for spherical harmonics" - - # variables used for display purposes - self.counter = 0 - self.start_time: float = time.time() - self.total_time: float = 0.0 - self.model_ref_number = model_ref_number - - if self.force_estimator == "grad": - self.grad_forces = True - - # self.act = ShiftedSoftplus() - self.act = Swish() - - self.distance_expansion_forces: GaussianSmearing = GaussianSmearing( - 0.0, - cutoff, - num_basis_functions, - basis_width_scalar, - ) - - # Weights for message initialization - self.embeddingblock2: EmbeddingBlock = EmbeddingBlock( - self.mid_hidden_channels, - self.hidden_channels, - self.mid_hidden_channels, - self.embedding_size, - self.num_embedding_basis, - self.max_num_elements, - self.act, - ) - self.distfc1: nn.Linear = nn.Linear( - self.mid_hidden_channels, self.mid_hidden_channels - ) - self.distfc2: nn.Linear = nn.Linear( - self.mid_hidden_channels, self.mid_hidden_channels - ) - - self.dist_block: DistanceBlock = DistanceBlock( - self.num_basis_functions, - self.mid_hidden_channels, - self.max_num_elements, - self.distance_block_scalar_max, - self.distance_expansion_forces, - self.scale_distances, - ) - - self.message_blocks = ModuleList() - for _ in range(num_interactions): - block = MessageBlock( - hidden_channels, - hidden_channels, - mid_hidden_channels, - embedding_size, - self.sphere_size_lat, - self.sphere_size_long, - self.max_num_elements, - self.sphere_message, - self.act, - self.lmax, - ) - self.message_blocks.append(block) - - self.energyembeddingblock = EmbeddingBlock( - hidden_channels, - 1, - mid_hidden_channels, - embedding_size, - 8, - self.max_num_elements, - self.act, - ) - - if force_estimator == "random": - self.force_output_block = ForceOutputBlock( - hidden_channels, - 2, - mid_hidden_channels, - embedding_size, - self.sphere_size_lat, - self.sphere_size_long, - self.max_num_elements, - self.output_message, - self.act, - self.lmax, - ) - - @conditional_grad(torch.enable_grad()) - def forward(self, data): - self.device = data.pos.device - self.num_atoms = len(data.batch) - self.batch_size = len(data.natoms) - - pos = data.pos - if self.regress_forces: - pos = pos.requires_grad_(True) - - ( - edge_index, - edge_distance, - edge_distance_vec, - cell_offsets, - _, # cell offset distances - neighbors, - ) = self.generate_graph(data) - - edge_index, edge_distance, edge_distance_vec = self._filter_edges( - edge_index, - edge_distance, - edge_distance_vec, - self.max_num_neighbors, - ) - - outputs = self._forward_helper( - data, edge_index, edge_distance, edge_distance_vec - ) - if self.show_timing_info is True: - torch.cuda.synchronize() - logging.info( - "Memory: {}\t{}\t{}".format( - len(edge_index[0]), - torch.cuda.memory_allocated() - / (1000 * len(edge_index[0])), - torch.cuda.max_memory_allocated() / 1000000, - ) - ) - - return outputs - - # restructure forward helper for conditional grad - def _forward_helper( - self, data, edge_index, edge_distance, edge_distance_vec - ): - ############################################################### - # Initialize messages - ############################################################### - - source_element = data.atomic_numbers[edge_index[0, :]].long() - target_element = data.atomic_numbers[edge_index[1, :]].long() - - x_dist = self.dist_block(edge_distance, source_element, target_element) - - x = x_dist - x = self.distfc1(x) - x = self.act(x) - x = self.distfc2(x) - x = self.act(x) - x = self.embeddingblock2(x, source_element, target_element) - - ############################################################### - # Update messages using block interactions - ############################################################### - - edge_rot_mat = self._init_edge_rot_mat( - data, edge_index, edge_distance_vec - ) - ( - proj_edges_index, - proj_edges_delta, - proj_edges_src_index, - ) = self._project2D_edges_init( - edge_rot_mat, edge_index, edge_distance_vec - ) - - for block_index, interaction in enumerate(self.message_blocks): - x_out = interaction( - x, - x_dist, - source_element, - target_element, - proj_edges_index, - proj_edges_delta, - proj_edges_src_index, - ) - - if block_index > 0: - x = x + x_out - else: - x = x_out - - ############################################################### - # Decoder - # Compute the forces and energies from the messages - ############################################################### - assert self.force_estimator in ["random", "grad"] - - energy = scatter(x, edge_index[1], dim=0, dim_size=data.num_nodes) / ( - self.max_num_neighbors / 2.0 + 1.0 - ) - atomic_numbers = data.atomic_numbers.long() - energy = self.energyembeddingblock( - energy, atomic_numbers, atomic_numbers - ) - energy = scatter(energy, data.batch, dim=0) - - if self.regress_forces: - if self.force_estimator == "grad": - forces = -1 * ( - torch.autograd.grad( - energy, - data.pos, - grad_outputs=torch.ones_like(energy), - create_graph=True, - )[0] - ) - if self.force_estimator == "random": - forces = self._compute_forces_random_rotations( - x, - self.num_random_rotations, - data.atomic_numbers.long(), - edge_index, - edge_distance_vec, - data.batch, - ) - - if not self.regress_forces: - return energy - else: - return energy, forces - - def _compute_forces_random_rotations( - self, - x, - num_random_rotations: int, - target_element, - edge_index, - edge_distance_vec, - batch, - ) -> torch.Tensor: - # Compute the forces and energy by randomly rotating the system and taking the average - - device = x.device - - rot_mat_x = torch.zeros(3, 3, device=device) - rot_mat_x[0][0] = 1.0 - rot_mat_x[1][1] = 1.0 - rot_mat_x[2][2] = 1.0 - - rot_mat_y = torch.zeros(3, 3, device=device) - rot_mat_y[0][1] = 1.0 - rot_mat_y[1][0] = -1.0 - rot_mat_y[2][2] = 1.0 - - rot_mat_z = torch.zeros(3, 3, device=device) - rot_mat_z[0][2] = 1.0 - rot_mat_z[1][1] = 1.0 - rot_mat_z[2][0] = -1.0 - - rot_mat_x = rot_mat_x.view(-1, 3, 3).repeat(self.num_atoms, 1, 1) - rot_mat_y = rot_mat_y.view(-1, 3, 3).repeat(self.num_atoms, 1, 1) - rot_mat_z = rot_mat_z.view(-1, 3, 3).repeat(self.num_atoms, 1, 1) - - # compute the random rotations - random_rot_mat = self._random_rot_mat( - self.num_atoms * num_random_rotations, device - ) - random_rot_mat = random_rot_mat.view( - num_random_rotations, self.num_atoms, 3, 3 - ) - - # the first matrix is the identity with the rest being random - # atom_rot_mat = torch.cat([torch.eye(3, device=device).view(1, 1, 3, 3).repeat(1, self.num_atoms, 1, 1), random_rot_mat], dim=0) - # or they are all random - atom_rot_mat = random_rot_mat - - forces = torch.zeros(self.num_atoms, 3, device=device) - - for rot_index in range(num_random_rotations): - rot_mat_x_perturb = torch.bmm(rot_mat_x, atom_rot_mat[rot_index]) - rot_mat_y_perturb = torch.bmm(rot_mat_y, atom_rot_mat[rot_index]) - rot_mat_z_perturb = torch.bmm(rot_mat_z, atom_rot_mat[rot_index]) - - # project neighbors using the random rotations - ( - proj_nodes_index_x, - proj_nodes_delta_x, - proj_nodes_src_index_x, - ) = self._project2D_nodes_init( - rot_mat_x_perturb, edge_index, edge_distance_vec - ) - ( - proj_nodes_index_y, - proj_nodes_delta_y, - proj_nodes_src_index_y, - ) = self._project2D_nodes_init( - rot_mat_y_perturb, edge_index, edge_distance_vec - ) - ( - proj_nodes_index_z, - proj_nodes_delta_z, - proj_nodes_src_index_z, - ) = self._project2D_nodes_init( - rot_mat_z_perturb, edge_index, edge_distance_vec - ) - - # estimate the force in each perpendicular direction - force_x = self.force_output_block( - x, - self.num_atoms, - target_element, - proj_nodes_index_x, - proj_nodes_delta_x, - proj_nodes_src_index_x, - ) - force_y = self.force_output_block( - x, - self.num_atoms, - target_element, - proj_nodes_index_y, - proj_nodes_delta_y, - proj_nodes_src_index_y, - ) - force_z = self.force_output_block( - x, - self.num_atoms, - target_element, - proj_nodes_index_z, - proj_nodes_delta_z, - proj_nodes_src_index_z, - ) - forces_perturb = torch.cat( - [force_x[:, 0:1], force_y[:, 0:1], force_z[:, 0:1]], dim=1 - ) - - # rotate the predicted forces back into the global reference frame - rot_mat_inv = torch.transpose(rot_mat_x_perturb, 1, 2) - forces_perturb = torch.bmm( - rot_mat_inv, forces_perturb.view(-1, 3, 1) - ).view(-1, 3) - - forces = forces + forces_perturb - - forces = forces / (num_random_rotations) - - return forces - - def _filter_edges( - self, - edge_index, - edge_distance, - edge_distance_vec, - max_num_neighbors: int, - ): - # Remove edges that aren't within the closest max_num_neighbors from either the target or source atom. - # This ensures all edges occur in pairs, i.e., if X -> Y exists then Y -> X is included. - # However, if both X -> Y and Y -> X don't both exist in the original list, this isn't guaranteed. - # Since some edges may have exactly the same distance, this function is not deterministic - device = edge_index.device - length = len(edge_distance) - - # Assuming the edges are consecutive based on the target index - target_node_index, neigh_count = torch.unique_consecutive( - edge_index[1], return_counts=True - ) - max_neighbors = torch.max(neigh_count) - - # handle special case where an atom doesn't have any neighbors - target_neigh_count = torch.zeros(self.num_atoms, device=device).long() - target_neigh_count.index_copy_( - 0, target_node_index.long(), neigh_count - ) - - # Create a list of edges for each atom - index_offset = ( - torch.cumsum(target_neigh_count, dim=0) - target_neigh_count - ) - neigh_index = torch.arange(length, device=device) - neigh_index = neigh_index - index_offset[edge_index[1]] - - edge_map_index = (edge_index[1] * max_neighbors + neigh_index).long() - target_lookup = ( - torch.zeros(self.num_atoms * max_neighbors, device=device) - 1 - ).long() - target_lookup.index_copy_( - 0, edge_map_index, torch.arange(length, device=device).long() - ) - - # Get the length of each edge - distance_lookup = ( - torch.zeros(self.num_atoms * max_neighbors, device=device) - + 1000000.0 - ) - distance_lookup.index_copy_(0, edge_map_index, edge_distance) - distance_lookup = distance_lookup.view(self.num_atoms, max_neighbors) - - # Sort the distances - distance_sorted_no_op, indices = torch.sort(distance_lookup, dim=1) - - # Create a hash that maps edges that go from X -> Y and Y -> X in the same bin - edge_index_min, no_op = torch.min(edge_index, dim=0) - edge_index_max, no_op = torch.max(edge_index, dim=0) - edge_index_hash = edge_index_min * self.num_atoms + edge_index_max - edge_count_start = torch.zeros( - self.num_atoms * self.num_atoms, device=device - ) - edge_count_start.index_add_( - 0, edge_index_hash, torch.ones(len(edge_index_hash), device=device) - ) - - # Find index into the original edge_index - indices = indices + ( - torch.arange(len(indices), device=device) * max_neighbors - ).view(-1, 1).repeat(1, max_neighbors) - indices = indices.view(-1) - target_lookup_sorted = ( - torch.zeros(self.num_atoms * max_neighbors, device=device) - 1 - ).long() - target_lookup_sorted = target_lookup[indices] - target_lookup_sorted = target_lookup_sorted.view( - self.num_atoms, max_neighbors - ) - - # Select the closest max_num_neighbors for each edge and remove the unused entries - target_lookup_below_thres = ( - target_lookup_sorted[:, 0:max_num_neighbors].contiguous().view(-1) - ) - target_lookup_below_thres = target_lookup_below_thres.view(-1) - mask_unused = target_lookup_below_thres.ge(0) - target_lookup_below_thres = torch.masked_select( - target_lookup_below_thres, mask_unused - ) - - # Find edges that are used at least once and create a mask to keep - edge_count = torch.zeros( - self.num_atoms * self.num_atoms, device=device - ) - edge_count.index_add_( - 0, - edge_index_hash[target_lookup_below_thres], - torch.ones(len(target_lookup_below_thres), device=device), - ) - edge_count_mask = edge_count.ne(0) - edge_keep = edge_count_mask[edge_index_hash] - - # Finally remove all edges that are too long in distance as indicated by the mask - edge_index_mask = edge_keep.view(1, -1).repeat(2, 1) - edge_index = torch.masked_select(edge_index, edge_index_mask).view( - 2, -1 - ) - edge_distance = torch.masked_select(edge_distance, edge_keep) - edge_distance_vec_mask = edge_keep.view(-1, 1).repeat(1, 3) - edge_distance_vec = torch.masked_select( - edge_distance_vec, edge_distance_vec_mask - ).view(-1, 3) - - return edge_index, edge_distance, edge_distance_vec - - def _random_rot_mat(self, num_matrices: int, device) -> torch.Tensor: - ang_a = 2.0 * math.pi * torch.rand(num_matrices, device=device) - ang_b = 2.0 * math.pi * torch.rand(num_matrices, device=device) - ang_c = 2.0 * math.pi * torch.rand(num_matrices, device=device) - - cos_a = torch.cos(ang_a) - cos_b = torch.cos(ang_b) - cos_c = torch.cos(ang_c) - sin_a = torch.sin(ang_a) - sin_b = torch.sin(ang_b) - sin_c = torch.sin(ang_c) - - rot_a = ( - torch.eye(3, device=device) - .view(1, 3, 3) - .repeat(num_matrices, 1, 1) - ) - rot_b = ( - torch.eye(3, device=device) - .view(1, 3, 3) - .repeat(num_matrices, 1, 1) - ) - rot_c = ( - torch.eye(3, device=device) - .view(1, 3, 3) - .repeat(num_matrices, 1, 1) - ) - - rot_a[:, 1, 1] = cos_a - rot_a[:, 1, 2] = sin_a - rot_a[:, 2, 1] = -sin_a - rot_a[:, 2, 2] = cos_a - - rot_b[:, 0, 0] = cos_b - rot_b[:, 0, 2] = -sin_b - rot_b[:, 2, 0] = sin_b - rot_b[:, 2, 2] = cos_b - - rot_c[:, 0, 0] = cos_c - rot_c[:, 0, 1] = sin_c - rot_c[:, 1, 0] = -sin_c - rot_c[:, 1, 1] = cos_c - - return torch.bmm(torch.bmm(rot_a, rot_b), rot_c) - - def _init_edge_rot_mat( - self, data, edge_index, edge_distance_vec - ) -> torch.Tensor: - device = data.pos.device - num_atoms = len(data.batch) - - edge_vec_0 = edge_distance_vec - edge_vec_0_distance = torch.sqrt(torch.sum(edge_vec_0**2, dim=1)) - - if torch.min(edge_vec_0_distance) < 0.0001: - logging.error( - "Error edge_vec_0_distance: {}".format( - torch.min(edge_vec_0_distance) - ) - ) - (minval, minidx) = torch.min(edge_vec_0_distance, 0) - logging.error( - "Error edge_vec_0_distance: {} {} {} {} {}".format( - minidx, - edge_index[0, minidx], - edge_index[1, minidx], - data.pos[edge_index[0, minidx]], - data.pos[edge_index[1, minidx]], - ) - ) - - avg_vector = torch.zeros(num_atoms, 3, device=device) - weight = 0.5 * ( - torch.cos(edge_vec_0_distance * PI / self.cutoff) + 1.0 - ) - avg_vector.index_add_( - 0, edge_index[1, :], edge_vec_0 * weight.view(-1, 1).expand(-1, 3) - ) - - edge_vec_2 = avg_vector[edge_index[1, :]] + 0.0001 - edge_vec_2_distance = torch.sqrt(torch.sum(edge_vec_2**2, dim=1)) - - if torch.min(edge_vec_2_distance) < 0.000001: - logging.error( - "Error edge_vec_2_distance: {}".format( - torch.min(edge_vec_2_distance) - ) - ) - - norm_x = edge_vec_0 / (edge_vec_0_distance.view(-1, 1)) - norm_0_2 = edge_vec_2 / (edge_vec_2_distance.view(-1, 1)) - norm_z = torch.cross(norm_x, norm_0_2, dim=1) - norm_z = norm_z / ( - torch.sqrt(torch.sum(norm_z**2, dim=1, keepdim=True)) + 0.0000001 - ) - norm_y = torch.cross(norm_x, norm_z, dim=1) - norm_y = norm_y / ( - torch.sqrt(torch.sum(norm_y**2, dim=1, keepdim=True)) + 0.0000001 - ) - - norm_x = norm_x.view(-1, 3, 1) - norm_y = norm_y.view(-1, 3, 1) - norm_z = norm_z.view(-1, 3, 1) - - edge_rot_mat_inv = torch.cat([norm_x, norm_y, norm_z], dim=2) - edge_rot_mat = torch.transpose(edge_rot_mat_inv, 1, 2) - - return edge_rot_mat - - def _project2D_edges_init(self, rot_mat, edge_index, edge_distance_vec): - torch.set_printoptions(sci_mode=False) - length = len(edge_distance_vec) - device = edge_distance_vec.device - - # Assuming the edges are consecutive based on the target index - target_node_index, neigh_count = torch.unique_consecutive( - edge_index[1], return_counts=True - ) - max_neighbors = torch.max(neigh_count) - target_neigh_count = torch.zeros(self.num_atoms, device=device).long() - target_neigh_count.index_copy_( - 0, target_node_index.long(), neigh_count - ) - - index_offset = ( - torch.cumsum(target_neigh_count, dim=0) - target_neigh_count - ) - neigh_index = torch.arange(length, device=device) - neigh_index = neigh_index - index_offset[edge_index[1]] - - edge_map_index = edge_index[1] * max_neighbors + neigh_index - target_lookup = ( - torch.zeros(self.num_atoms * max_neighbors, device=device) - 1 - ).long() - target_lookup.index_copy_( - 0, - edge_map_index.long(), - torch.arange(length, device=device).long(), - ) - target_lookup = target_lookup.view(self.num_atoms, max_neighbors) - - # target_lookup - For each target node, a list of edge indices - # target_neigh_count - number of neighbors for each target node - source_edge = target_lookup[edge_index[0]] - target_edge = ( - torch.arange(length, device=device) - .long() - .view(-1, 1) - .repeat(1, max_neighbors) - ) - - source_edge = source_edge.view(-1) - target_edge = target_edge.view(-1) - - mask_unused = source_edge.ge(0) - source_edge = torch.masked_select(source_edge, mask_unused) - target_edge = torch.masked_select(target_edge, mask_unused) - - return self._project2D_init( - source_edge, target_edge, rot_mat, edge_distance_vec - ) - - def _project2D_nodes_init(self, rot_mat, edge_index, edge_distance_vec): - torch.set_printoptions(sci_mode=False) - length = len(edge_distance_vec) - device = edge_distance_vec.device - - target_node = edge_index[1] - source_edge = torch.arange(length, device=device) - - return self._project2D_init( - source_edge, target_node, rot_mat, edge_distance_vec - ) - - def _project2D_init( - self, source_edge, target_edge, rot_mat, edge_distance_vec - ): - edge_distance_norm = F.normalize(edge_distance_vec) - source_edge_offset = edge_distance_norm[source_edge] - - source_edge_offset_rot = torch.bmm( - rot_mat[target_edge], source_edge_offset.view(-1, 3, 1) - ) - - source_edge_X = torch.atan2( - source_edge_offset_rot[:, 1], source_edge_offset_rot[:, 2] - ).view(-1) - - # source_edge_X ranges from -pi to pi - source_edge_X = (source_edge_X + math.pi) / (2.0 * math.pi) - - # source_edge_Y ranges from -1 to 1 - source_edge_Y = source_edge_offset_rot[:, 0].view(-1) - source_edge_Y = torch.clamp(source_edge_Y, min=-1.0, max=1.0) - source_edge_Y = (source_edge_Y.asin() + (math.pi / 2.0)) / ( - math.pi - ) # bin by angle - # source_edge_Y = (source_edge_Y + 1.0) / 2.0 # bin by sin - source_edge_Y = 0.99 * (source_edge_Y) + 0.005 - - source_edge_X = source_edge_X * self.sphere_size_long - source_edge_Y = source_edge_Y * ( - self.sphere_size_lat - 1.0 - ) # not circular so pad by one - - source_edge_X_0 = torch.floor(source_edge_X).long() - source_edge_X_del = source_edge_X - source_edge_X_0 - source_edge_X_0 = source_edge_X_0 % self.sphere_size_long - source_edge_X_1 = (source_edge_X_0 + 1) % self.sphere_size_long - - source_edge_Y_0 = torch.floor(source_edge_Y).long() - source_edge_Y_del = source_edge_Y - source_edge_Y_0 - source_edge_Y_0 = source_edge_Y_0 % self.sphere_size_lat - source_edge_Y_1 = (source_edge_Y_0 + 1) % self.sphere_size_lat - - # Compute the values needed to bilinearly splat the values onto the spheres - index_0_0 = ( - target_edge * self.sphere_size_lat * self.sphere_size_long - + source_edge_Y_0 * self.sphere_size_long - + source_edge_X_0 - ) - index_0_1 = ( - target_edge * self.sphere_size_lat * self.sphere_size_long - + source_edge_Y_0 * self.sphere_size_long - + source_edge_X_1 - ) - index_1_0 = ( - target_edge * self.sphere_size_lat * self.sphere_size_long - + source_edge_Y_1 * self.sphere_size_long - + source_edge_X_0 - ) - index_1_1 = ( - target_edge * self.sphere_size_lat * self.sphere_size_long - + source_edge_Y_1 * self.sphere_size_long - + source_edge_X_1 - ) - - delta_0_0 = (1.0 - source_edge_X_del) * (1.0 - source_edge_Y_del) - delta_0_1 = (source_edge_X_del) * (1.0 - source_edge_Y_del) - delta_1_0 = (1.0 - source_edge_X_del) * (source_edge_Y_del) - delta_1_1 = (source_edge_X_del) * (source_edge_Y_del) - - index_0_0 = index_0_0.view(1, -1) - index_0_1 = index_0_1.view(1, -1) - index_1_0 = index_1_0.view(1, -1) - index_1_1 = index_1_1.view(1, -1) - - # NaNs otherwise - if self.grad_forces: - with torch.no_grad(): - delta_0_0 = delta_0_0.view(1, -1) - delta_0_1 = delta_0_1.view(1, -1) - delta_1_0 = delta_1_0.view(1, -1) - delta_1_1 = delta_1_1.view(1, -1) - else: - delta_0_0 = delta_0_0.view(1, -1) - delta_0_1 = delta_0_1.view(1, -1) - delta_1_0 = delta_1_0.view(1, -1) - delta_1_1 = delta_1_1.view(1, -1) - - return ( - torch.cat([index_0_0, index_0_1, index_1_0, index_1_1]), - torch.cat([delta_0_0, delta_0_1, delta_1_0, delta_1_1]), - source_edge, - ) - - @property - def num_params(self) -> int: - return sum(p.numel() for p in self.parameters()) - - -class MessageBlock(torch.nn.Module): - def __init__( - self, - in_hidden_channels: int, - out_hidden_channels: int, - mid_hidden_channels: int, - embedding_size: int, - sphere_size_lat: int, - sphere_size_long: int, - max_num_elements: int, - sphere_message: str, - act, - lmax, - ) -> None: - super(MessageBlock, self).__init__() - self.in_hidden_channels = in_hidden_channels - self.out_hidden_channels = out_hidden_channels - self.act = act - self.lmax = lmax - self.embedding_size = embedding_size - self.mid_hidden_channels = mid_hidden_channels - self.sphere_size_lat = sphere_size_lat - self.sphere_size_long = sphere_size_long - self.sphere_message = sphere_message - self.max_num_elements = max_num_elements - self.num_embedding_basis = 8 - - self.spinconvblock = SpinConvBlock( - self.in_hidden_channels, - self.mid_hidden_channels, - self.sphere_size_lat, - self.sphere_size_long, - self.sphere_message, - self.act, - self.lmax, - ) - - self.embeddingblock1: EmbeddingBlock = EmbeddingBlock( - self.mid_hidden_channels, - self.mid_hidden_channels, - self.mid_hidden_channels, - self.embedding_size, - self.num_embedding_basis, - self.max_num_elements, - self.act, - ) - self.embeddingblock2: EmbeddingBlock = EmbeddingBlock( - self.mid_hidden_channels, - self.out_hidden_channels, - self.mid_hidden_channels, - self.embedding_size, - self.num_embedding_basis, - self.max_num_elements, - self.act, - ) - - self.distfc1 = nn.Linear( - self.mid_hidden_channels, self.mid_hidden_channels - ) - self.distfc2 = nn.Linear( - self.mid_hidden_channels, self.mid_hidden_channels - ) - - def forward( - self, - x, - x_dist, - source_element, - target_element, - proj_index, - proj_delta, - proj_src_index, - ): - out_size = len(x) - - x = self.spinconvblock( - x, out_size, proj_index, proj_delta, proj_src_index - ) - - x = self.embeddingblock1(x, source_element, target_element) - - x_dist = self.distfc1(x_dist) - x_dist = self.act(x_dist) - x_dist = self.distfc2(x_dist) - x = x + x_dist - - x = self.act(x) - x = self.embeddingblock2(x, source_element, target_element) - - return x - - -class ForceOutputBlock(torch.nn.Module): - def __init__( - self, - in_hidden_channels: int, - out_hidden_channels: int, - mid_hidden_channels: int, - embedding_size: int, - sphere_size_lat: int, - sphere_size_long: int, - max_num_elements: int, - sphere_message: str, - act, - lmax, - ) -> None: - super(ForceOutputBlock, self).__init__() - self.in_hidden_channels = in_hidden_channels - self.out_hidden_channels = out_hidden_channels - self.act = act - self.lmax = lmax - self.embedding_size = embedding_size - self.mid_hidden_channels = mid_hidden_channels - self.sphere_size_lat = sphere_size_lat - self.sphere_size_long = sphere_size_long - self.sphere_message = sphere_message - self.max_num_elements = max_num_elements - self.num_embedding_basis = 8 - - self.spinconvblock: SpinConvBlock = SpinConvBlock( - self.in_hidden_channels, - self.mid_hidden_channels, - self.sphere_size_lat, - self.sphere_size_long, - self.sphere_message, - self.act, - self.lmax, - ) - - self.block1: EmbeddingBlock = EmbeddingBlock( - self.mid_hidden_channels, - self.mid_hidden_channels, - self.mid_hidden_channels, - self.embedding_size, - self.num_embedding_basis, - self.max_num_elements, - self.act, - ) - self.block2: EmbeddingBlock = EmbeddingBlock( - self.mid_hidden_channels, - self.out_hidden_channels, - self.mid_hidden_channels, - self.embedding_size, - self.num_embedding_basis, - self.max_num_elements, - self.act, - ) - - def forward( - self, - x, - out_size, - target_element, - proj_index, - proj_delta, - proj_src_index, - ): - x = self.spinconvblock( - x, out_size, proj_index, proj_delta, proj_src_index - ) - - x = self.block1(x, target_element, target_element) - x = self.act(x) - x = self.block2(x, target_element, target_element) - - return x - - -class SpinConvBlock(torch.nn.Module): - def __init__( - self, - in_hidden_channels: int, - mid_hidden_channels: int, - sphere_size_lat: int, - sphere_size_long: int, - sphere_message: str, - act, - lmax, - ) -> None: - super(SpinConvBlock, self).__init__() - self.in_hidden_channels = in_hidden_channels - self.mid_hidden_channels = mid_hidden_channels - self.sphere_size_lat = sphere_size_lat - self.sphere_size_long = sphere_size_long - self.sphere_message = sphere_message - self.act = act - self.lmax = lmax - self.num_groups = self.in_hidden_channels // 8 - - self.ProjectLatLongSphere = ProjectLatLongSphere( - sphere_size_lat, sphere_size_long - ) - assert self.sphere_message in [ - "fullconv", - "rotspharmwd", - ] - if self.sphere_message in ["rotspharmwd"]: - self.sph_froms2grid = FromS2Grid( - (self.sphere_size_lat, self.sphere_size_long), self.lmax - ) - self.mlp = nn.Linear( - self.in_hidden_channels * (self.lmax + 1) ** 2, - self.mid_hidden_channels, - ) - self.sphlength = (self.lmax + 1) ** 2 - rotx = torch.zeros(self.sphere_size_long) + ( - 2 * math.pi / self.sphere_size_long - ) - roty = torch.zeros(self.sphere_size_long) - rotz = torch.zeros(self.sphere_size_long) - - self.wigner = [] - for xrot, yrot, zrot in zip(rotx, roty, rotz): - _blocks = [] - for l_degree in range(self.lmax + 1): - _blocks.append(o3.wigner_D(l_degree, xrot, yrot, zrot)) - self.wigner.append(torch.block_diag(*_blocks)) - - if self.sphere_message == "fullconv": - padding = self.sphere_size_long // 2 - self.conv1 = nn.Conv1d( - self.in_hidden_channels * self.sphere_size_lat, - self.mid_hidden_channels, - self.sphere_size_long, - groups=self.in_hidden_channels // 8, - padding=padding, - padding_mode="circular", - ) - self.pool = nn.AvgPool1d(sphere_size_long) - - self.GroupNorm = nn.GroupNorm( - self.num_groups, self.mid_hidden_channels - ) - - def forward(self, x, out_size, proj_index, proj_delta, proj_src_index): - x = self.ProjectLatLongSphere( - x, out_size, proj_index, proj_delta, proj_src_index - ) - if self.sphere_message == "rotspharmwd": - sph_harm_calc = torch.zeros( - ((x.shape[0], self.mid_hidden_channels)), - device=x.device, - ) - - sph_harm = self.sph_froms2grid(x) - sph_harm = sph_harm.view(-1, self.sphlength, 1) - for wD_diag in self.wigner: - wD_diag = wD_diag.to(x.device) - sph_harm_calc += self.act( - self.mlp(sph_harm.reshape(x.shape[0], -1)) - ) - wd = wD_diag.view(1, self.sphlength, self.sphlength).expand( - len(x) * self.in_hidden_channels, -1, -1 - ) - sph_harm = torch.bmm(wd, sph_harm) - x = sph_harm_calc - - if self.sphere_message in ["fullconv"]: - x = x.view( - -1, - self.in_hidden_channels * self.sphere_size_lat, - self.sphere_size_long, - ) - x = self.conv1(x) - x = self.act(x) - # Pool in the longitudal direction - x = self.pool(x[:, :, 0 : self.sphere_size_long]) - x = x.view(out_size, -1) - - x = self.GroupNorm(x) - - return x - - -class EmbeddingBlock(torch.nn.Module): - def __init__( - self, - in_hidden_channels: int, - out_hidden_channels: int, - mid_hidden_channels: int, - embedding_size: int, - num_embedding_basis: int, - max_num_elements: int, - act, - ) -> None: - super(EmbeddingBlock, self).__init__() - self.in_hidden_channels = in_hidden_channels - self.out_hidden_channels = out_hidden_channels - self.act = act - self.embedding_size = embedding_size - self.mid_hidden_channels = mid_hidden_channels - self.num_embedding_basis = num_embedding_basis - self.max_num_elements = max_num_elements - - self.fc1 = nn.Linear(self.in_hidden_channels, self.mid_hidden_channels) - self.fc2 = nn.Linear( - self.mid_hidden_channels, - self.num_embedding_basis * self.mid_hidden_channels, - ) - self.fc3 = nn.Linear( - self.mid_hidden_channels, self.out_hidden_channels - ) - - self.source_embedding = nn.Embedding( - max_num_elements, self.embedding_size - ) - self.target_embedding = nn.Embedding( - max_num_elements, self.embedding_size - ) - nn.init.uniform_(self.source_embedding.weight.data, -0.0001, 0.0001) - nn.init.uniform_(self.target_embedding.weight.data, -0.0001, 0.0001) - - self.embed_fc1 = nn.Linear( - 2 * self.embedding_size, self.num_embedding_basis - ) - - self.softmax = nn.Softmax(dim=1) - - def forward( - self, x: torch.Tensor, source_element, target_element - ) -> torch.Tensor: - source_embedding = self.source_embedding(source_element) - target_embedding = self.target_embedding(target_element) - embedding = torch.cat([source_embedding, target_embedding], dim=1) - embedding = self.embed_fc1(embedding) - embedding = self.softmax(embedding) - - x = self.fc1(x) - x = self.act(x) - x = self.fc2(x) - x = self.act(x) - x = ( - x.view(-1, self.num_embedding_basis, self.mid_hidden_channels) - ) * (embedding.view(-1, self.num_embedding_basis, 1)) - x = torch.sum(x, dim=1) - x = self.fc3(x) - - return x - - -class DistanceBlock(torch.nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - max_num_elements: int, - scalar_max, - distance_expansion, - scale_distances, - ) -> None: - super(DistanceBlock, self).__init__() - self.in_channels = in_channels - self.out_channels = out_channels - self.max_num_elements = max_num_elements - self.distance_expansion = distance_expansion - self.scalar_max = scalar_max - self.scale_distances = scale_distances - - if self.scale_distances: - self.dist_scalar = nn.Embedding( - self.max_num_elements * self.max_num_elements, 1 - ) - self.dist_offset = nn.Embedding( - self.max_num_elements * self.max_num_elements, 1 - ) - nn.init.uniform_(self.dist_scalar.weight.data, -0.0001, 0.0001) - nn.init.uniform_(self.dist_offset.weight.data, -0.0001, 0.0001) - - self.fc1 = nn.Linear(self.in_channels, self.out_channels) - - def forward(self, edge_distance, source_element, target_element): - if self.scale_distances: - embedding_index = ( - source_element * self.max_num_elements + target_element - ) - - # Restrict the scalar to range from 1 / self.scalar_max to self.scalar_max - scalar_max = math.log(self.scalar_max) - scalar = ( - 2.0 * torch.sigmoid(self.dist_scalar(embedding_index).view(-1)) - - 1.0 - ) - scalar = torch.exp(scalar_max * scalar) - offset = self.dist_offset(embedding_index).view(-1) - x = self.distance_expansion(scalar * edge_distance + offset) - else: - x = self.distance_expansion(edge_distance) - - x = self.fc1(x) - - return x - - -class ProjectLatLongSphere(torch.nn.Module): - def __init__(self, sphere_size_lat: int, sphere_size_long: int) -> None: - super(ProjectLatLongSphere, self).__init__() - self.sphere_size_lat = sphere_size_lat - self.sphere_size_long = sphere_size_long - - def forward( - self, x, length: int, index, delta, source_edge_index - ) -> torch.Tensor: - device = x.device - hidden_channels = len(x[0]) - - x_proj = torch.zeros( - length * self.sphere_size_lat * self.sphere_size_long, - hidden_channels, - device=device, - ) - splat_values = x[source_edge_index] - - # Perform bilinear splatting - x_proj.index_add_(0, index[0], splat_values * (delta[0].view(-1, 1))) - x_proj.index_add_(0, index[1], splat_values * (delta[1].view(-1, 1))) - x_proj.index_add_(0, index[2], splat_values * (delta[2].view(-1, 1))) - x_proj.index_add_(0, index[3], splat_values * (delta[3].view(-1, 1))) - - x_proj = x_proj.view( - length, - self.sphere_size_lat * self.sphere_size_long, - hidden_channels, - ) - x_proj = torch.transpose(x_proj, 1, 2).contiguous() - x_proj = x_proj.view( - length, - hidden_channels, - self.sphere_size_lat, - self.sphere_size_long, - ) - - return x_proj - - -class Swish(torch.nn.Module): - def __init__(self) -> None: - super(Swish, self).__init__() - - def forward(self, x): - return x * torch.sigmoid(x) - - -class GaussianSmearing(torch.nn.Module): - def __init__( - self, - start: float = -5.0, - stop: float = 5.0, - num_gaussians: int = 50, - basis_width_scalar: float = 1.0, - ) -> None: - super(GaussianSmearing, self).__init__() - offset = torch.linspace(start, stop, num_gaussians) - self.coeff = ( - -0.5 / (basis_width_scalar * (offset[1] - offset[0])).item() ** 2 - ) - self.register_buffer("offset", offset) - - def forward(self, dist) -> torch.Tensor: - dist = dist.view(-1, 1) - self.offset.view(1, -1) - return torch.exp(self.coeff * torch.pow(dist, 2)) diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index 7af24ffbb..afa5c0a9a 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -603,7 +603,7 @@ def load_optimizer(self) -> None: def load_extras(self) -> None: self.scheduler = LRScheduler(self.optimizer, self.config["optim"]) self.clip_grad_norm = aii( - self.config["optim"].get("clip_grad_norm"), (int, float) + self.config["optim"].get("clip_grad_norm", None), (int, float) ) self.ema_decay = aii(self.config["optim"].get("ema_decay"), float) if self.ema_decay: diff --git a/tests/models/test_cgcnn.py b/tests/models/test_cgcnn.py deleted file mode 100644 index 57873adf0..000000000 --- a/tests/models/test_cgcnn.py +++ /dev/null @@ -1,97 +0,0 @@ -""" -Copyright (c) Facebook, Inc. and its affiliates. - -This source code is licensed under the MIT license found in the -LICENSE file in the root directory of this source tree. -""" - -import os -import random - -import numpy as np -import pytest -import torch -from ase.io import read - -from ocpmodels.common.registry import registry -from ocpmodels.common.transforms import RandomRotate -from ocpmodels.common.utils import setup_imports -from ocpmodels.datasets import data_list_collater -from ocpmodels.preprocessing import AtomsToGraphs - - -@pytest.fixture(scope="class") -def load_data(request) -> None: - atoms = read( - os.path.join(os.path.dirname(os.path.abspath(__file__)), "atoms.json"), - index=0, - format="json", - ) - a2g = AtomsToGraphs( - max_neigh=200, - radius=6, - r_energy=True, - r_forces=True, - r_distances=True, - ) - data_list = a2g.convert_all([atoms]) - request.cls.data = data_list[0] - - -@pytest.fixture(scope="class") -def load_model(request) -> None: - torch.manual_seed(4) - setup_imports() - - num_gaussians = 50 - model = registry.get_model_class("cgcnn")( - None, - num_gaussians, - 1, - cutoff=6.0, - num_gaussians=num_gaussians, - regress_forces=True, - use_pbc=True, - ) - request.cls.model = model - - -@pytest.mark.usefixtures("load_data") -@pytest.mark.usefixtures("load_model") -class TestCGCNN: - def test_rotation_invariance(self) -> None: - random.seed(1) - data = self.data - - # Sampling a random rotation within [-180, 180] for all axes. - transform = RandomRotate([-180, 180], [0, 1, 2]) - data_rotated, rot, inv_rot = transform(data.clone()) - assert not np.array_equal(data.pos, data_rotated.pos) - - # Pass it through the model. - batch = data_list_collater([data, data_rotated]) - out = self.model(batch) - - # Compare predicted energies and forces (after inv-rotation). - energies = out[0].detach() - np.testing.assert_almost_equal(energies[0], energies[1], decimal=5) - - forces = out[1].detach() - np.testing.assert_array_almost_equal( - forces[: forces.shape[0] // 2], - torch.matmul(forces[forces.shape[0] // 2 :], inv_rot), - decimal=5, - ) - - def test_energy_force_shape(self, snapshot) -> None: - # Recreate the Data object to only keep the necessary features. - data = self.data - - # Pass it through the model. - energy, forces = self.model(data_list_collater([data])) - - assert snapshot == energy.shape - assert snapshot == pytest.approx(energy.detach()) - - assert snapshot == forces.shape - assert snapshot == pytest.approx(forces.detach()) diff --git a/tests/models/test_dimenetpp.py b/tests/models/test_dimenetpp.py index 77357cbb2..3eea80b43 100644 --- a/tests/models/test_dimenetpp.py +++ b/tests/models/test_dimenetpp.py @@ -72,10 +72,10 @@ def test_rotation_invariance(self) -> None: out = self.model(batch) # Compare predicted energies and forces (after inv-rotation). - energies = out[0].detach() + energies = out["energy"].detach() np.testing.assert_almost_equal(energies[0], energies[1], decimal=5) - forces = out[1].detach() + forces = out["forces"].detach() logging.info(forces) np.testing.assert_array_almost_equal( forces[: forces.shape[0] // 2], @@ -88,7 +88,8 @@ def test_energy_force_shape(self, snapshot) -> None: data = self.data # Pass it through the model. - energy, forces = self.model(data_list_collater([data])) + outputs = self.model(data_list_collater([data])) + energy, forces = outputs["energy"], outputs["forces"] assert snapshot == energy.shape assert snapshot == pytest.approx(energy.detach()) diff --git a/tests/models/test_equiformer_v2.py b/tests/models/test_equiformer_v2.py index f28e6ea9b..b3ced3e33 100644 --- a/tests/models/test_equiformer_v2.py +++ b/tests/models/test_equiformer_v2.py @@ -109,7 +109,8 @@ def test_energy_force_shape(self, snapshot): data = self.data # Pass it through the model. - energy, forces = self.model(data_list_collater([data])) + outputs = self.model(data_list_collater([data])) + energy, forces = outputs["energy"], outputs["forces"] assert snapshot == energy.shape assert snapshot == pytest.approx(energy.detach()) diff --git a/tests/models/test_forcenet.py b/tests/models/test_forcenet.py deleted file mode 100644 index dcd4d96de..000000000 --- a/tests/models/test_forcenet.py +++ /dev/null @@ -1,66 +0,0 @@ -""" -Copyright (c) Facebook, Inc. and its affiliates. - -This source code is licensed under the MIT license found in the -LICENSE file in the root directory of this source tree. -""" - -import os - -import pytest -import torch -from ase.io import read - -from ocpmodels.common.registry import registry -from ocpmodels.common.utils import setup_imports -from ocpmodels.datasets import data_list_collater -from ocpmodels.preprocessing import AtomsToGraphs - - -@pytest.fixture(scope="class") -def load_data(request) -> None: - atoms = read( - os.path.join(os.path.dirname(os.path.abspath(__file__)), "atoms.json"), - index=0, - format="json", - ) - a2g = AtomsToGraphs( - max_neigh=200, - radius=6, - r_energy=True, - r_forces=True, - r_distances=True, - ) - data_list = a2g.convert_all([atoms]) - request.cls.data = data_list[0] - - -@pytest.fixture(scope="class") -def load_model(request) -> None: - torch.manual_seed(4) - setup_imports() - - model = registry.get_model_class("forcenet")( - None, - 32, - 1, - cutoff=6.0, - ) - request.cls.model = model - - -@pytest.mark.usefixtures("load_data") -@pytest.mark.usefixtures("load_model") -class TestForceNet: - def test_energy_force_shape(self, snapshot) -> None: - # Recreate the Data object to only keep the necessary features. - data = self.data - - # Pass it through the model. - energy, forces = self.model(data_list_collater([data])) - - assert snapshot == energy.shape - assert snapshot == pytest.approx(energy.detach()) - - assert snapshot == forces.shape - assert snapshot == pytest.approx(forces.detach()) diff --git a/tests/models/test_gemnet.py b/tests/models/test_gemnet.py index df86f11b9..a82b8ffc3 100644 --- a/tests/models/test_gemnet.py +++ b/tests/models/test_gemnet.py @@ -88,10 +88,10 @@ def test_rotation_invariance(self) -> None: out = self.model(batch) # Compare predicted energies and forces (after inv-rotation). - energies = out[0].detach() + energies = out["energy"].detach() np.testing.assert_almost_equal(energies[0], energies[1], decimal=5) - forces = out[1].detach() + forces = out["forces"].detach() logging.info(forces) np.testing.assert_array_almost_equal( forces[: forces.shape[0] // 2], @@ -104,7 +104,8 @@ def test_energy_force_shape(self, snapshot) -> None: data = self.data # Pass it through the model. - energy, forces = self.model(data_list_collater([data])) + outputs = self.model(data_list_collater([data])) + energy, forces = outputs["energy"], outputs["forces"] assert snapshot == energy.shape assert snapshot == pytest.approx(energy.detach()) diff --git a/tests/models/test_gemnet_oc.py b/tests/models/test_gemnet_oc.py index 8d9095481..455ac01d8 100644 --- a/tests/models/test_gemnet_oc.py +++ b/tests/models/test_gemnet_oc.py @@ -134,10 +134,10 @@ def test_rotation_invariance(self) -> None: out = self.model(batch) # Compare predicted energies and forces (after inv-rotation). - energies = out[0].detach() + energies = out["energy"].detach() np.testing.assert_almost_equal(energies[0], energies[1], decimal=3) - forces = out[1].detach() + forces = out["forces"].detach() logging.info(forces) np.testing.assert_array_almost_equal( forces[: forces.shape[0] // 2], @@ -150,7 +150,8 @@ def test_energy_force_shape(self, snapshot) -> None: data = self.data # Pass it through the model. - energy, forces = self.model(data_list_collater([data])) + outputs = self.model(data_list_collater([data])) + energy, forces = outputs["energy"], outputs["forces"] assert snapshot == energy.shape assert snapshot == pytest.approx(energy.detach()) diff --git a/tests/models/test_schnet.py b/tests/models/test_schnet.py index 6e6282f83..f2fc4a522 100644 --- a/tests/models/test_schnet.py +++ b/tests/models/test_schnet.py @@ -66,10 +66,10 @@ def test_rotation_invariance(self) -> None: out = self.model(batch) # Compare predicted energies and forces (after inv-rotation). - energies = out[0].detach() + energies = out["energy"].detach() np.testing.assert_almost_equal(energies[0], energies[1], decimal=5) - forces = out[1].detach() + forces = out["forces"].detach() np.testing.assert_array_almost_equal( forces[: forces.shape[0] // 2], torch.matmul(forces[forces.shape[0] // 2 :], inv_rot), @@ -81,7 +81,8 @@ def test_energy_force_shape(self, snapshot) -> None: data = self.data # Pass it through the model. - energy, forces = self.model(data_list_collater([data])) + outputs = self.model(data_list_collater([data])) + energy, forces = outputs["energy"], outputs["forces"] assert snapshot == energy.shape assert snapshot == pytest.approx(energy.detach()) From 7fa38709d5af300a8e7b6a94a44477e1e8531f8d Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Fri, 27 Oct 2023 15:02:07 -0700 Subject: [PATCH 33/63] evaluator test fix --- ocpmodels/modules/evaluator.py | 46 ++++++++++++++----------------- tests/evaluator/test_evaluator.py | 6 ++-- 2 files changed, 23 insertions(+), 29 deletions(-) diff --git a/ocpmodels/modules/evaluator.py b/ocpmodels/modules/evaluator.py index 7eb5b4a01..dc19799cb 100644 --- a/ocpmodels/modules/evaluator.py +++ b/ocpmodels/modules/evaluator.py @@ -35,36 +35,30 @@ class Evaluator: task_metrics = { "s2ef": { - "metrics": { - "energy": ["mae"], - "forces": [ - "forcesx_mae", - "forcesy_mae", - "forcesz_mae", - "mae", - "cosine_similarity", - "magnitude_error", - "energy_forces_within_threshold", - ], - } + "energy": ["mae"], + "forces": [ + "forcesx_mae", + "forcesy_mae", + "forcesz_mae", + "mae", + "cosine_similarity", + "magnitude_error", + "energy_forces_within_threshold", + ], }, "is2rs": { - "metrics": { - "positions": [ - "average_distance_within_threshold", - "mae", - "mse", - ] - } + "positions": [ + "average_distance_within_threshold", + "mae", + "mse", + ] }, "is2re": { - "metrics": { - "energy": [ - "mae", - "mse", - "energy_within_threshold", - ] - }, + "energy": [ + "mae", + "mse", + "energy_within_threshold", + ] }, } diff --git a/tests/evaluator/test_evaluator.py b/tests/evaluator/test_evaluator.py index 448bc9831..7a7fcd300 100644 --- a/tests/evaluator/test_evaluator.py +++ b/tests/evaluator/test_evaluator.py @@ -89,14 +89,14 @@ class TestS2EFEval: def test_metrics_exist(self) -> None: assert "energy_mae" in self.metrics assert "forces_mae" in self.metrics - assert "forces_cos" in self.metrics - assert "energy_force_within_threshold" in self.metrics + assert "forces_cosine_similarity" in self.metrics + assert "energy_forces_within_threshold" in self.metrics @pytest.mark.usefixtures("load_evaluator_is2rs") class TestIS2RSEval: def test_metrics_exist(self) -> None: - assert "average_distance_within_threshold" in self.metrics + assert "positions_average_distance_within_threshold" in self.metrics @pytest.mark.usefixtures("load_evaluator_is2re") From 4371bfa98db61160b37c859908fa08868863eab5 Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Fri, 27 Oct 2023 16:09:13 -0700 Subject: [PATCH 34/63] lint --- ocpmodels/modules/loss.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/ocpmodels/modules/loss.py b/ocpmodels/modules/loss.py index b5daa4950..bf3888d8e 100644 --- a/ocpmodels/modules/loss.py +++ b/ocpmodels/modules/loss.py @@ -70,7 +70,9 @@ def forward( batch_size: Optional[int] = None, ): # ensure torch doesn't do any unwanted broadcasting - assert input.shape == target.shape, f"Mismatched shapes: {input.shape} and {target.shape}" + assert ( + input.shape == target.shape + ), f"Mismatched shapes: {input.shape} and {target.shape}" # zero out nans, if any found_nans_or_infs = not torch.all(input.isfinite()) From 1abf998e15a2d6c7facda5beec8edab7aef17350 Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Fri, 27 Oct 2023 16:47:37 -0700 Subject: [PATCH 35/63] remove old models --- ocpmodels/models/__init__.py | 15 --------------- 1 file changed, 15 deletions(-) diff --git a/ocpmodels/models/__init__.py b/ocpmodels/models/__init__.py index ef016b2e3..626423691 100644 --- a/ocpmodels/models/__init__.py +++ b/ocpmodels/models/__init__.py @@ -2,18 +2,3 @@ # # This source code is licensed under the MIT license found in the # LICENSE file in the root directory of this source tree. - -from .base import BaseModel -from .cgcnn import CGCNN -from .dimenet import DimeNetWrap as DimeNet -from .dimenet_plus_plus import DimeNetPlusPlusWrap as DimeNetPlusPlus -from .equiformer_v2 import EquiformerV2 -from .escn import eSCN -from .forcenet import ForceNet -from .gemnet.gemnet import GemNetT -from .gemnet_gp.gemnet import GraphParallelGemNetT as GraphParallelGemNetT -from .gemnet_oc.gemnet_oc import GemNetOC -from .painn.painn import PaiNN -from .schnet import SchNetWrap as SchNet -from .scn.scn import SphericalChannelNetwork -from .spinconv import spinconv From 8395a3a087b395a7503e1b0ca3ea7bc369447f04 Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Thu, 2 Nov 2023 15:15:25 -0700 Subject: [PATCH 36/63] pass calculator test --- ocpmodels/common/relaxation/ase_utils.py | 45 +++---- ocpmodels/common/utils.py | 6 +- ocpmodels/trainers/base_trainer.py | 124 ++++++++++-------- .../__snapshots__/test_ase_calculator.ambr | 2 +- tests/common/test_ase_calculator.py | 2 +- 5 files changed, 93 insertions(+), 86 deletions(-) diff --git a/ocpmodels/common/relaxation/ase_utils.py b/ocpmodels/common/relaxation/ase_utils.py index ac0614b53..838b3d023 100644 --- a/ocpmodels/common/relaxation/ase_utils.py +++ b/ocpmodels/common/relaxation/ase_utils.py @@ -20,7 +20,12 @@ from ase.constraints import FixAtoms from ocpmodels.common.registry import registry -from ocpmodels.common.utils import load_config, setup_imports, setup_logging +from ocpmodels.common.utils import ( + load_config, + setup_imports, + setup_logging, + update_old_config, +) from ocpmodels.datasets import data_list_collater from ocpmodels.preprocessing import AtomsToGraphs @@ -123,19 +128,8 @@ def __init__( checkpoint_path, map_location=torch.device("cpu") ) config = checkpoint["config"] - if trainer is not None: # passing the arg overrides everything else - config["trainer"] = trainer - else: - if "trainer" not in config: # older checkpoint - if config["task"]["dataset"] == "trajectory_lmdb": - config["trainer"] = "forces" - elif config["task"]["dataset"] == "single_point_lmdb": - config["trainer"] = "energy" - else: - logging.warning( - "Unable to identify OCP trainer, defaulting to `forces`. Specify the `trainer` argument into OCPCalculator if otherwise." - ) - config["trainer"] = "forces" + + config["trainer"] = "ocp" if "model_attributes" in config: config["model_attributes"]["name"] = config.pop("model") @@ -150,20 +144,20 @@ def __init__( config["model"]["otf_graph"] = True # Save config so obj can be transported over network (pkl) + update_old_config(config) self.config = copy.deepcopy(config) self.config["checkpoint"] = checkpoint_path - - if "normalizer" not in config: - del config["dataset"]["src"] - config["normalizer"] = config["dataset"] + del config["dataset"]["src"] self.trainer = registry.get_trainer_class( - config.get("trainer", "energy") + config.get("trainer", "ocp") )( task=config["task"], model=config["model"], - dataset=None, - normalizer=config["normalizer"], + dataset=[config["dataset"]], + outputs=config["outputs"], + loss_fns=config["loss_fns"], + eval_metrics=config["eval_metrics"], optimizer=config["optim"], identifier="", slurm=config.get("slurm", {}), @@ -211,9 +205,8 @@ def calculate(self, atoms: Atoms, properties, system_changes) -> None: predictions = self.trainer.predict( batch, per_image=False, disable_tqdm=True ) - if self.trainer.name == "s2ef": - self.results["energy"] = predictions["energy"].item() - self.results["forces"] = predictions["forces"].cpu().numpy() - elif self.trainer.name == "is2re": - self.results["energy"] = predictions["energy"].item() + for key in predictions: + _pred = predictions[key] + _pred = _pred.item() if _pred.numel() == 1 else _pred.cpu().numpy() + self.results[key] = _pred diff --git a/ocpmodels/common/utils.py b/ocpmodels/common/utils.py index 27364dc5d..3efa08351 100644 --- a/ocpmodels/common/utils.py +++ b/ocpmodels/common/utils.py @@ -1197,7 +1197,11 @@ def irreps_sum(l): def update_old_config(config): ### Read task based off config structure, similar to OCPCalculator. - if config["task"]["dataset"] == "trajectory_lmdb": + if config["task"]["dataset"] in [ + "trajectory_lmdb", + "lmdb", + "trajectory_lmdb_v2", + ]: task = "s2ef" elif config["task"]["dataset"] == "single_point_lmdb": task = "is2re" diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index afa5c0a9a..e30d15be1 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -60,7 +60,6 @@ class BaseTrainer(ABC): test_loader: DataLoader[Any] device: torch.device output_targets: Dict[str, Any] - normalizers: Dict[str, Any] ema: Optional[ExponentialMovingAverage] clip_grad_norm: float ema_decay: float @@ -281,9 +280,6 @@ def get_dataloader(self, dataset, sampler) -> DataLoader: return loader def load_datasets(self) -> None: - logging.info( - f"Loading dataset: {self.config['dataset'].get('format', 'lmdb')}" - ) self.parallel_collater = ParallelCollater( 0 if self.cpu else 1, self.config["model_attributes"].get("otf_graph", False), @@ -294,7 +290,11 @@ def load_datasets(self) -> None: self.test_loader = None # load train, val, test datasets - if self.config.get("dataset", None): + if self.config["dataset"].get("src", None): + logging.info( + f"Loading dataset: {self.config['dataset'].get('format', 'lmdb')}" + ) + self.train_dataset = registry.get_dataset_class( self.config["dataset"].get("format", "lmdb") )(self.config["dataset"]) @@ -1097,22 +1097,11 @@ def predict( desc="device {}".format(rank), disable=disable_tqdm, ): - batch_size = batch_list[0].natoms.numel() - - ### Get unique system identifiers - sids = batch_list[0].sid.tolist() - ## Support naming structure for OC20 S2EF - if "fid" in batch_list[0]: - fids = batch_list[0].fid.tolist() - systemids = [f"{sid}_{fid}" for sid, fid in zip(sids, fids)] - else: - systemids = [f"{sid}" for sid in sids] - - predictions["ids"].extend(systemids) with torch.cuda.amp.autocast(enabled=self.scaler is not None): out = self._forward(batch_list) + batch_size = batch_list[0].natoms.numel() for target_key in self.config["outputs"]: ### Target property is a direct output of the model if target_key in out: @@ -1180,50 +1169,71 @@ def predict( pred = pred.cpu().detach().to(dtype) - ### Split predictions into per-image predictions - if ( - self.config["outputs"][target_key].get("level", "system") - == "atom" - ): - batch_natoms = torch.cat( - [batch.natoms for batch in batch_list] - ) - batch_fixed = torch.cat( - [batch.fixed for batch in batch_list] - ) - per_image_pred = torch.split(pred, batch_natoms.tolist()) + if per_image: + ### Split predictions into per-image predictions + if ( + self.config["outputs"][target_key].get( + "level", "system" + ) + == "atom" + ): + batch_natoms = torch.cat( + [batch.natoms for batch in batch_list] + ) + batch_fixed = torch.cat( + [batch.fixed for batch in batch_list] + ) + per_image_pred = torch.split( + pred, batch_natoms.tolist() + ) - ### Save out only free atom, EvalAI does not need fixed atoms - _per_image_fixed = torch.split( - batch_fixed, batch_natoms.tolist() - ) - _per_image_free_preds = [ - _pred[(fixed == 0).tolist()].numpy() - for _pred, fixed in zip( - per_image_pred, _per_image_fixed + ### Save out only free atom, EvalAI does not need fixed atoms + _per_image_fixed = torch.split( + batch_fixed, batch_natoms.tolist() ) - ] - _chunk_idx = np.array( - [ - free_pred.shape[0] - for free_pred in _per_image_free_preds + _per_image_free_preds = [ + _pred[(fixed == 0).tolist()].numpy() + for _pred, fixed in zip( + per_image_pred, _per_image_fixed + ) ] - ) - per_image_pred = _per_image_free_preds - ### Assumes system level properties are of the same dimension - else: - per_image_pred = pred.numpy() - _chunk_idx = None - - predictions[f"{target_key}"].extend(per_image_pred) - ### Backwards compatibility, retain 'chunk_idx' for forces. - if _chunk_idx is not None: - if target_key == "forces": - predictions["chunk_idx"].extend(_chunk_idx) - else: - predictions[f"{target_key}_chunk_idx"].extend( - _chunk_idx + _chunk_idx = np.array( + [ + free_pred.shape[0] + for free_pred in _per_image_free_preds + ] ) + per_image_pred = _per_image_free_preds + ### Assumes system level properties are of the same dimension + else: + per_image_pred = pred.numpy() + _chunk_idx = None + + predictions[f"{target_key}"].extend(per_image_pred) + ### Backwards compatibility, retain 'chunk_idx' for forces. + if _chunk_idx is not None: + if target_key == "forces": + predictions["chunk_idx"].extend(_chunk_idx) + else: + predictions[f"{target_key}_chunk_idx"].extend( + _chunk_idx + ) + else: + predictions[f"{target_key}"] = pred.detach() + + if not per_image: + return predictions + + ### Get unique system identifiers + sids = batch_list[0].sid.tolist() + ## Support naming structure for OC20 S2EF + if "fid" in batch_list[0]: + fids = batch_list[0].fid.tolist() + systemids = [f"{sid}_{fid}" for sid, fid in zip(sids, fids)] + else: + systemids = [f"{sid}" for sid in sids] + + predictions["ids"].extend(systemids) for key in predictions: predictions[key] = np.array(predictions[key]) diff --git a/tests/common/__snapshots__/test_ase_calculator.ambr b/tests/common/__snapshots__/test_ase_calculator.ambr index 23fbb01b0..2277d3eb2 100644 --- a/tests/common/__snapshots__/test_ase_calculator.ambr +++ b/tests/common/__snapshots__/test_ase_calculator.ambr @@ -1,3 +1,3 @@ # name: TestCalculator.test_relaxation_final_energy - 0.92 + 0.74 # --- diff --git a/tests/common/test_ase_calculator.py b/tests/common/test_ase_calculator.py index ad0c08822..1be5e95db 100644 --- a/tests/common/test_ase_calculator.py +++ b/tests/common/test_ase_calculator.py @@ -43,7 +43,7 @@ def load_model_list(request) -> None: # eSCN "https://dl.fbaipublicfiles.com/opencatalystproject/models/2023_03/s2ef/escn_l6_m3_lay20_all_md_s2ef.pt", # EquiformerV2 - "https://dl.fbaipublicfiles.com/opencatalystproject/models/2023_06/oc20/s2ef/eq2_153M_ec4_allmd.pt", + # "https://dl.fbaipublicfiles.com/opencatalystproject/models/2023_06/oc20/s2ef/eq2_153M_ec4_allmd.pt", ] From a49bb4a6981d4f607393bfa0a49799d74f7b02d6 Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Fri, 3 Nov 2023 13:25:03 -0700 Subject: [PATCH 37/63] remove DP, cleanup --- ocpmodels/common/data_parallel.py | 99 ------- ocpmodels/common/relaxation/ase_utils.py | 4 +- ocpmodels/common/relaxation/ml_relaxation.py | 2 +- ocpmodels/common/utils.py | 18 +- ocpmodels/datasets/oc22_lmdb_dataset.py | 5 +- .../equiformer_v2/trainers/forces_trainer.py | 7 +- ocpmodels/modules/evaluator.py | 31 --- ocpmodels/modules/transforms.py | 4 +- ocpmodels/trainers/base_trainer.py | 244 ++++++++---------- ocpmodels/trainers/ocp_trainer.py | 6 +- 10 files changed, 134 insertions(+), 286 deletions(-) diff --git a/ocpmodels/common/data_parallel.py b/ocpmodels/common/data_parallel.py index 0b3beafdd..18509e039 100644 --- a/ocpmodels/common/data_parallel.py +++ b/ocpmodels/common/data_parallel.py @@ -7,7 +7,6 @@ import heapq import logging -from itertools import chain from pathlib import Path from typing import List, Literal, Protocol, Tuple, Union, runtime_checkable @@ -16,106 +15,8 @@ import numpy.typing as npt import torch from torch.utils.data import BatchSampler, DistributedSampler, Sampler -from torch_geometric.data.data import BaseData from ocpmodels.common import distutils, gp_utils -from ocpmodels.datasets import data_list_collater - - -class OCPDataParallel(torch.nn.DataParallel): - use_cpu: bool - - def __init__( - self, module, output_device: torch.device, num_gpus: int - ) -> None: - if num_gpus < 0: - raise ValueError("# GPUs must be positive.") - if num_gpus > torch.cuda.device_count(): - raise ValueError("# GPUs specified larger than available") - - self.src_device = torch.device(output_device) - - self.use_cpu = False - if num_gpus == 0: - self.use_cpu = True - elif num_gpus == 1: - device_ids = [self.src_device] - else: - if ( - self.src_device.type == "cuda" - and self.src_device.index >= num_gpus - ): - raise ValueError("Main device must be less than # of GPUs") - device_ids = list(range(num_gpus)) - - if self.use_cpu: - super(torch.nn.DataParallel, self).__init__() - self.module = module - - else: - super(OCPDataParallel, self).__init__( - module=module, - device_ids=device_ids, - output_device=self.src_device, - ) - - def forward(self, batch_list, **kwargs): - if self.use_cpu: - return self.module(batch_list[0]) - - if len(self.device_ids) == 1: - return self.module( - batch_list[0].to(f"cuda:{self.device_ids[0]}"), **kwargs - ) - - for t in chain(self.module.parameters(), self.module.buffers()): - if t.device != self.src_device: - raise RuntimeError( - ( - "Module must have its parameters and buffers on device " - "{} but found one of them on device {}." - ).format(self.src_device, t.device) - ) - - inputs = [ - batch.to(f"cuda:{self.device_ids[i]}") - for i, batch in enumerate(batch_list) - ] - replicas = self.replicate(self.module, self.device_ids[: len(inputs)]) - outputs = self.parallel_apply(replicas, inputs, kwargs) - return self.gather(outputs, self.output_device) - - -class ParallelCollater: - def __init__(self, num_gpus: int, otf_graph: bool = False) -> None: - self.num_gpus = num_gpus - self.otf_graph = otf_graph - - def __call__(self, data_list: List[BaseData]) -> List[BaseData]: - if self.num_gpus in [0, 1]: # adds cpu-only case - batch = data_list_collater(data_list, otf_graph=self.otf_graph) - return [batch] - - else: - num_devices = min(self.num_gpus, len(data_list)) - - count = torch.tensor([data.num_nodes for data in data_list]) - cumsum = count.cumsum(0) - cumsum = torch.cat([cumsum.new_zeros(1), cumsum], dim=0) - device_id = ( - num_devices * cumsum.to(torch.float) / cumsum[-1].item() - ) - device_id = (device_id[:-1] + device_id[1:]) / 2.0 - device_id = device_id.to(torch.long) - split = device_id.bincount().cumsum(0) - split = torch.cat([split.new_zeros(1), split], dim=0) - split = torch.unique(split, sorted=True) - split = split.tolist() - - return [ - data_list_collater(data_list[split[i] : split[i + 1]]) - for i in range(len(split) - 1) - ] @numba.njit diff --git a/ocpmodels/common/relaxation/ase_utils.py b/ocpmodels/common/relaxation/ase_utils.py index 838b3d023..2de31bf2d 100644 --- a/ocpmodels/common/relaxation/ase_utils.py +++ b/ocpmodels/common/relaxation/ase_utils.py @@ -24,7 +24,7 @@ load_config, setup_imports, setup_logging, - update_old_config, + update_config, ) from ocpmodels.datasets import data_list_collater from ocpmodels.preprocessing import AtomsToGraphs @@ -144,7 +144,7 @@ def __init__( config["model"]["otf_graph"] = True # Save config so obj can be transported over network (pkl) - update_old_config(config) + config = update_config(config) self.config = copy.deepcopy(config) self.config["checkpoint"] = checkpoint_path del config["dataset"]["src"] diff --git a/ocpmodels/common/relaxation/ml_relaxation.py b/ocpmodels/common/relaxation/ml_relaxation.py index 5305c34b5..655d3f017 100644 --- a/ocpmodels/common/relaxation/ml_relaxation.py +++ b/ocpmodels/common/relaxation/ml_relaxation.py @@ -45,7 +45,7 @@ def ml_relax( save_full_traj: bool Whether to save out the full ASE trajectory. If False, only save out initial and final frames. """ - batches = deque([batch[0]]) + batches = deque([batch]) relaxed_batches = [] while batches: batch = batches.popleft() diff --git a/ocpmodels/common/utils.py b/ocpmodels/common/utils.py index 3efa08351..8ea3addcb 100644 --- a/ocpmodels/common/utils.py +++ b/ocpmodels/common/utils.py @@ -1154,7 +1154,7 @@ def get_commit_hash(): return commit_hash -def cg_decomp_mat(l, device="cpu"): +def cg_change_mat(l, device="cpu"): if l not in [2]: raise NotImplementedError @@ -1188,6 +1188,9 @@ def cg_decomp_mat(l, device="cpu"): def irreps_sum(l): + """ + Returns the sum of the dimensions of the irreps up to the specified l. + """ total = 0 for i in range(l + 1): total += 2 * i + 1 @@ -1195,7 +1198,12 @@ def irreps_sum(l): return total -def update_old_config(config): +def update_config(base_config): + """ + Configs created prior to OCP 2.0 are organized a little different than they + are now. Update old configs to fit the new expected structure. + """ + config = copy.deepcopy(base_config) ### Read task based off config structure, similar to OCPCalculator. if config["task"]["dataset"] in [ "trajectory_lmdb", @@ -1238,13 +1246,15 @@ def update_old_config(config): "energy_coefficient", 1 ), }, + }, + { "forces": { "fn": config["optim"].get("loss_forces", "l2mae"), "coefficient": config["optim"].get( "force_coefficient", 30 ), }, - } + }, ] ### Define evaluation metrics _eval_metrics = { @@ -1297,6 +1307,8 @@ def update_old_config(config): config.update({"eval_metrics": _eval_metrics}) config.update({"outputs": _outputs}) + return config + def get_loss_module(loss_name): if loss_name in ["l1", "mae"]: diff --git a/ocpmodels/datasets/oc22_lmdb_dataset.py b/ocpmodels/datasets/oc22_lmdb_dataset.py index 86a5437cd..c04d614ed 100644 --- a/ocpmodels/datasets/oc22_lmdb_dataset.py +++ b/ocpmodels/datasets/oc22_lmdb_dataset.py @@ -17,6 +17,7 @@ from ocpmodels.common.registry import registry from ocpmodels.common.typing import assert_is_instance as aii from ocpmodels.common.utils import pyg2_data_transform +from ocpmodels.modules.transforms import DataTransforms @registry.register_dataset("oc22_lmdb") @@ -100,7 +101,9 @@ def __init__(self, config, transform=None) -> None: self._keys = list(range(num_entries)) self.num_samples = num_entries - self.transform = transform + self.key_mapping = self.config.get("key_mapping", None) + self.transforms = DataTransforms(self.config.get("transforms", {})) + self.lin_ref = self.oc20_ref = False # only needed for oc20 datasets, oc22 is total by default self.train_on_oc20_total_energies = self.config.get( diff --git a/ocpmodels/models/equiformer_v2/trainers/forces_trainer.py b/ocpmodels/models/equiformer_v2/trainers/forces_trainer.py index 406f2d3e1..b8a58d3ba 100755 --- a/ocpmodels/models/equiformer_v2/trainers/forces_trainer.py +++ b/ocpmodels/models/equiformer_v2/trainers/forces_trainer.py @@ -11,7 +11,6 @@ from torch.nn.parallel.distributed import DistributedDataParallel from ocpmodels.common import distutils -from ocpmodels.common.data_parallel import OCPDataParallel from ocpmodels.common.registry import registry from ocpmodels.modules.exponential_moving_average import ( ExponentialMovingAverage, @@ -93,11 +92,7 @@ def load_model(self) -> None: if self.logger is not None: self.logger.watch(self.model) - self.model = OCPDataParallel( - self.model, - output_device=self.device, - num_gpus=1 if not self.cpu else 0, - ) + self.model.to(self.device) if distutils.initialized() and not self.config["noddp"]: self.model = DistributedDataParallel( self.model, device_ids=[self.device] diff --git a/ocpmodels/modules/evaluator.py b/ocpmodels/modules/evaluator.py index dc19799cb..a963609b9 100644 --- a/ocpmodels/modules/evaluator.py +++ b/ocpmodels/modules/evaluator.py @@ -10,8 +10,6 @@ import numpy as np import torch -from ocpmodels.common.utils import cg_decomp_mat - """ An evaluation module for use with the OCP dataset and suite of tasks. It should be possible to import this independently of the rest of the codebase, e.g: @@ -265,35 +263,6 @@ def average_distance_within_threshold( return {"metric": success / total, "total": success, "numel": total} -def stress_mae_from_decomposition( - prediction: Dict[str, torch.Tensor], - target: Dict[str, torch.Tensor], - key=None, -): - device = prediction["isotropic_stress"].device - cg_matrix = cg_decomp_mat(2, device) - - zero_vectors = torch.zeros( - (prediction["isotropic_stress"].shape[0], 3), - device=device, - ) - prediction_irreps = torch.concat( - [ - prediction["isotropic_stress"].reshape(-1, 1), - zero_vectors, - prediction["anisotropic_stress"].reshape(-1, 5), - ], - dim=1, - ) - prediction_stress = torch.einsum( - "ba, cb->ca", cg_matrix, prediction_irreps - ).reshape(-1) - - target_stress = target["stress"].reshape(-1) - - return mae(prediction_stress, target_stress) - - def min_diff( pred_pos: torch.Tensor, dft_pos: torch.Tensor, diff --git a/ocpmodels/modules/transforms.py b/ocpmodels/modules/transforms.py index 23371c938..0a836daa5 100644 --- a/ocpmodels/modules/transforms.py +++ b/ocpmodels/modules/transforms.py @@ -1,7 +1,7 @@ import torch from torch_geometric.data import Data -from ocpmodels.common.utils import cg_decomp_mat, irreps_sum +from ocpmodels.common.utils import cg_change_mat, irreps_sum class DataTransforms: @@ -32,7 +32,7 @@ def decompose_tensor(data_object, config) -> Data: tensor_decomposition = torch.einsum( "ab, cb->ca", - cg_decomp_mat(rank), + cg_change_mat(rank), data_object[tensor_key].reshape(1, irreps_sum(rank)), ) diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index e30d15be1..dd8ee7904 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -25,23 +25,20 @@ from tqdm import tqdm from ocpmodels.common import distutils, gp_utils -from ocpmodels.common.data_parallel import ( - BalancedBatchSampler, - OCPDataParallel, - ParallelCollater, -) +from ocpmodels.common.data_parallel import BalancedBatchSampler from ocpmodels.common.registry import registry from ocpmodels.common.typing import assert_is_instance as aii from ocpmodels.common.typing import none_throws from ocpmodels.common.utils import ( - cg_decomp_mat, + cg_change_mat, get_commit_hash, get_loss_module, irreps_sum, load_state_dict, save_checkpoint, - update_old_config, + update_config, ) +from ocpmodels.datasets import data_list_collater from ocpmodels.modules.evaluator import Evaluator from ocpmodels.modules.exponential_moving_average import ( ExponentialMovingAverage, @@ -87,12 +84,13 @@ def __init__( slurm={}, noddp: bool = False, ) -> None: + self.name = name + self.is_debug = is_debug self.cpu = cpu self.epoch = 0 self.step = 0 - self.device: torch.device if torch.cuda.is_available() and not self.cpu: self.device = torch.device(f"cuda:{local_rank}") else: @@ -159,6 +157,7 @@ def __init__( "folder" ].replace("%j", self.config["slurm"]["job_id"]) + # Define datasets if isinstance(dataset, list): if len(dataset) > 0: self.config["dataset"] = dataset[0] @@ -178,17 +177,15 @@ def __init__( os.makedirs(self.config["cmd"]["results_dir"], exist_ok=True) os.makedirs(self.config["cmd"]["logs_dir"], exist_ok=True) - self.is_debug = is_debug - - if distutils.is_master(): - logging.info(yaml.dump(self.config, default_flow_style=False)) - ### backwards compatability with OCP v<2.0 if self.name != "ocp": logging.warning( "Detected old config, converting to new format. Consider updating to avoid potential incompatibilities." ) - update_old_config(self.config) + self.config = update_config(self.config) + + if distutils.is_master(): + logging.info(yaml.dump(self.config, default_flow_style=False)) self.load() @@ -272,7 +269,8 @@ def get_sampler( def get_dataloader(self, dataset, sampler) -> DataLoader: loader = DataLoader( dataset, - collate_fn=self.parallel_collater, + # collate_fn=self.parallel_collater, + collate_fn=data_list_collater, num_workers=self.config["optim"]["num_workers"], pin_memory=True, batch_sampler=sampler, @@ -280,10 +278,10 @@ def get_dataloader(self, dataset, sampler) -> DataLoader: return loader def load_datasets(self) -> None: - self.parallel_collater = ParallelCollater( - 0 if self.cpu else 1, - self.config["model_attributes"].get("otf_graph", False), - ) + # self.parallel_collater = ParallelCollater( + # 0 if self.cpu else 1, + # self.config["model_attributes"].get("otf_graph", False), + # ) self.train_loader = None self.val_loader = None @@ -455,11 +453,7 @@ def load_model(self) -> None: if self.logger is not None: self.logger.watch(self.model) - self.model = OCPDataParallel( - self.model, - output_device=self.device, - num_gpus=1 if not self.cpu else 0, - ) + self.model.to(self.device) if distutils.initialized() and not self.config["noddp"]: self.model = DistributedDataParallel( self.model, device_ids=[self.device] @@ -468,7 +462,7 @@ def load_model(self) -> None: @property def _unwrapped_model(self): module = self.model - while isinstance(module, (OCPDataParallel, DistributedDataParallel)): + while isinstance(module, DistributedDataParallel): module = module.module return module @@ -834,19 +828,60 @@ def train(self, disable_eval_tqdm: bool = False) -> None: if self.config.get("test_dataset", False): self.test_dataset.close_db() - def _forward(self, batch_list): - return self.model(batch_list) + def _forward(self, batch): + out = self.model(batch.to(self.device)) + + ### TOOD: Move into BaseModel in OCP 2.0 + outputs = {} + batch_size = batch.natoms.numel() + for target_key in self.config["outputs"]: + ### Target property is a direct output of the model + if target_key in out: + pred = out[target_key] + ## Target property is a derived output of the model. Construct the + ## parent property + else: + _max_rank = 0 + for subtarget_key in self.config["outputs"][target_key][ + "decomposition" + ]: + _max_rank = max( + _max_rank, + self.output_targets[subtarget_key]["irrep_dim"], + ) + + pred_irreps = torch.zeros( + (batch_size, irreps_sum(_max_rank)), device=self.device + ) - def _compute_loss(self, out, batch_list): - natoms = torch.cat( - [batch.natoms.to(self.device) for batch in batch_list], dim=0 - ) + for subtarget_key in self.config["outputs"][target_key][ + "decomposition" + ]: + irreps = self.output_targets[subtarget_key]["irrep_dim"] + _pred = out[subtarget_key] + + ## Fill in the corresponding irreps prediction + pred_irreps[ + :, + max(0, irreps_sum(irreps - 1)) : irreps_sum(irreps), + ] = _pred + + pred = torch.einsum( + "ba, cb->ca", + cg_change_mat(_max_rank, self.device), + pred_irreps, + ) + + outputs[target_key] = pred + + return outputs + + def _compute_loss(self, out, batch): + natoms = batch.natoms.to(self.device) batch_size = natoms.numel() natoms = torch.repeat_interleave(natoms, natoms) - fixed = torch.cat( - [batch.fixed.to(self.device) for batch in batch_list] - ) + fixed = batch.fixed.to(self.device) mask = fixed == 0 loss = [] @@ -854,10 +889,7 @@ def _compute_loss(self, out, batch_list): for loss_fn in self.loss_fns: target_name, loss_info = loss_fn - target = torch.cat( - [batch[target_name].to(self.device) for batch in batch_list], - dim=0, - ) + target = batch[target_name].to(self.device) pred = out[target_name] if self.output_targets[target_name].get( @@ -891,15 +923,11 @@ def _compute_loss(self, out, batch_list): loss = sum(loss) return loss - def _compute_metrics(self, out, batch_list, evaluator, metrics={}): - natoms = torch.cat( - [batch.natoms.to(self.device) for batch in batch_list], dim=0 - ) + def _compute_metrics(self, out, batch, evaluator, metrics={}): + natoms = batch.natoms.to(self.device) ### Retrieve free atoms - fixed = torch.cat( - [batch.fixed.to(self.device) for batch in batch_list] - ) + fixed = batch.fixed.to(self.device) mask = fixed == 0 s_idx = 0 @@ -911,22 +939,13 @@ def _compute_metrics(self, out, batch_list, evaluator, metrics={}): targets = {} for target_name in self.output_targets: - target = torch.cat( - [batch[target_name].to(self.device) for batch in batch_list], - dim=0, - ) + target = batch[target_name].to(self.device) # Add parent target to targets if "parent" in self.output_targets[target_name]: parent_target_name = self.output_targets[target_name]["parent"] if parent_target_name not in targets: - parent_target = torch.cat( - [ - batch[parent_target_name].to(self.device) - for batch in batch_list - ], - dim=0, - ) + parent_target = batch[parent_target_name].to(self.device) targets[parent_target_name] = parent_target if self.output_targets[target_name].get( @@ -982,6 +1001,7 @@ def validate(self, split: str = "val", disable_tqdm: bool = False): ): # Forward. with torch.cuda.amp.autocast(enabled=self.scaler is not None): + batch.to(self.device) out = self._forward(batch) loss = self._compute_loss(out, batch) @@ -1027,8 +1047,8 @@ def _backward(self, loss) -> None: self.optimizer.zero_grad() loss.backward() # Scale down the gradients of shared parameters - if hasattr(self.model.module, "shared_parameters"): - for p, factor in self.model.module.shared_parameters: + if hasattr(self.model, "shared_parameters"): + for p, factor in self.model.shared_parameters: if hasattr(p, "grad") and p.grad is not None: p.grad.detach().div_(factor) else: @@ -1081,7 +1101,7 @@ def predict( rank = distutils.get_rank() if isinstance(data_loader, torch_geometric.data.Batch): - data_loader = [[data_loader]] + data_loader = [data_loader] self.model.eval() if self.ema is not None: @@ -1090,7 +1110,7 @@ def predict( predictions = defaultdict(list) - for i, batch_list in tqdm( + for i, batch in tqdm( enumerate(data_loader), total=len(data_loader), position=rank, @@ -1099,77 +1119,33 @@ def predict( ): with torch.cuda.amp.autocast(enabled=self.scaler is not None): - out = self._forward(batch_list) + out = self._forward(batch) - batch_size = batch_list[0].natoms.numel() + batch_size = batch.natoms.numel() for target_key in self.config["outputs"]: - ### Target property is a direct output of the model - if target_key in out: - pred = out[target_key] - ### Denormalize predictions if needed - if self.normalizers.get(target_key, False): - pred = self.normalizers[target_key].denorm(pred) - ## Target property is a derived output of the model - else: - _max_rank = 0 - for subtarget_key in self.config["outputs"][target_key][ - "decomposition" - ]: - _max_rank = max( - _max_rank, - self.output_targets[subtarget_key]["irrep_dim"], - ) - - pred_irreps = torch.zeros( - (batch_size, irreps_sum(_max_rank)), device=self.device - ) - - for subtarget_key in self.config["outputs"][target_key][ - "decomposition" - ]: - irreps = self.output_targets[subtarget_key][ - "irrep_dim" - ] - _pred = out[subtarget_key] - - ### Denormalize predictions if needed - if self.normalizers.get(subtarget_key, False): - _pred = self.normalizers[subtarget_key].denorm( - _pred - ) - - ## Fill in the corresponding irreps prediction - pred_irreps[ - :, - max(0, irreps_sum(irreps - 1)) : irreps_sum( - irreps - ), - ] = _pred - - pred = torch.einsum( - "ba, cb->ca", - cg_decomp_mat(_max_rank, self.device), - pred_irreps, - ) - - ### Save outputs in desired precision, default float16 - if ( - self.config["outputs"][target_key].get( - "prediction_dtype", "float16" - ) - == "float32" - or self.config["task"].get("prediction_dtype", "float16") - == "float32" - or self.config["task"].get("dataset", "lmdb") - == "oc22_lmdb" - ): - dtype = torch.float32 - else: - dtype = torch.float16 - - pred = pred.cpu().detach().to(dtype) + pred = out[target_key] + if self.normalizers.get(target_key, False): + pred = self.normalizers[target_key].denorm(pred) if per_image: + ### Save outputs in desired precision, default float16 + if ( + self.config["outputs"][target_key].get( + "prediction_dtype", "float16" + ) + == "float32" + or self.config["task"].get( + "prediction_dtype", "float16" + ) + == "float32" + or self.config["task"].get("dataset", "lmdb") + == "oc22_lmdb" + ): + dtype = torch.float32 + else: + dtype = torch.float16 + + pred = pred.cpu().detach().to(dtype) ### Split predictions into per-image predictions if ( self.config["outputs"][target_key].get( @@ -1177,12 +1153,8 @@ def predict( ) == "atom" ): - batch_natoms = torch.cat( - [batch.natoms for batch in batch_list] - ) - batch_fixed = torch.cat( - [batch.fixed for batch in batch_list] - ) + batch_natoms = batch.natoms + batch_fixed = batch.fixed per_image_pred = torch.split( pred, batch_natoms.tolist() ) @@ -1225,10 +1197,10 @@ def predict( return predictions ### Get unique system identifiers - sids = batch_list[0].sid.tolist() + sids = batch.sid.tolist() ## Support naming structure for OC20 S2EF - if "fid" in batch_list[0]: - fids = batch_list[0].fid.tolist() + if "fid" in batch: + fids = batch.fid.tolist() systemids = [f"{sid}_{fid}" for sid, fid in zip(sids, fids)] else: systemids = [f"{sid}" for sid in sids] diff --git a/ocpmodels/trainers/ocp_trainer.py b/ocpmodels/trainers/ocp_trainer.py index 768ef9c1b..18947f409 100644 --- a/ocpmodels/trainers/ocp_trainer.py +++ b/ocpmodels/trainers/ocp_trainer.py @@ -7,21 +7,17 @@ import logging import os -import pathlib from collections import defaultdict -from pathlib import Path import numpy as np import torch -import torch_geometric from tqdm import tqdm from ocpmodels.common import distutils from ocpmodels.common.registry import registry from ocpmodels.common.relaxation.ml_relaxation import ml_relax -from ocpmodels.common.utils import cg_decomp_mat, check_traj_files, irreps_sum +from ocpmodels.common.utils import check_traj_files from ocpmodels.modules.evaluator import Evaluator -from ocpmodels.modules.normalizer import Normalizer from ocpmodels.modules.scaling.util import ensure_fitted from ocpmodels.trainers.base_trainer import BaseTrainer From 1f5a6bea135693181a40d8cc0100c4f71975e88a Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Fri, 3 Nov 2023 13:29:06 -0700 Subject: [PATCH 38/63] remove comments --- ocpmodels/trainers/base_trainer.py | 7 ------- 1 file changed, 7 deletions(-) diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index dd8ee7904..af2087f8f 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -269,7 +269,6 @@ def get_sampler( def get_dataloader(self, dataset, sampler) -> DataLoader: loader = DataLoader( dataset, - # collate_fn=self.parallel_collater, collate_fn=data_list_collater, num_workers=self.config["optim"]["num_workers"], pin_memory=True, @@ -278,11 +277,6 @@ def get_dataloader(self, dataset, sampler) -> DataLoader: return loader def load_datasets(self) -> None: - # self.parallel_collater = ParallelCollater( - # 0 if self.cpu else 1, - # self.config["model_attributes"].get("otf_graph", False), - # ) - self.train_loader = None self.val_loader = None self.test_loader = None @@ -1121,7 +1115,6 @@ def predict( with torch.cuda.amp.autocast(enabled=self.scaler is not None): out = self._forward(batch) - batch_size = batch.natoms.numel() for target_key in self.config["outputs"]: pred = out[target_key] if self.normalizers.get(target_key, False): From 72a90d79e81524767d600e6f1340afaac6bc96ef Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Fri, 3 Nov 2023 15:25:42 -0700 Subject: [PATCH 39/63] eqv2 support --- ocpmodels/common/relaxation/ase_utils.py | 9 +++++---- ocpmodels/trainers/base_trainer.py | 3 ++- tests/common/__snapshots__/test_ase_calculator.ambr | 2 +- tests/common/test_ase_calculator.py | 2 +- 4 files changed, 9 insertions(+), 7 deletions(-) diff --git a/ocpmodels/common/relaxation/ase_utils.py b/ocpmodels/common/relaxation/ase_utils.py index 2de31bf2d..7b7202823 100644 --- a/ocpmodels/common/relaxation/ase_utils.py +++ b/ocpmodels/common/relaxation/ase_utils.py @@ -129,7 +129,10 @@ def __init__( ) config = checkpoint["config"] - config["trainer"] = "ocp" + if trainer is not None: + config["trainer"] = trainer + else: + config["trainer"] = config.get("trainer", "ocp") if "model_attributes" in config: config["model_attributes"]["name"] = config.pop("model") @@ -149,9 +152,7 @@ def __init__( self.config["checkpoint"] = checkpoint_path del config["dataset"]["src"] - self.trainer = registry.get_trainer_class( - config.get("trainer", "ocp") - )( + self.trainer = registry.get_trainer_class(config["trainer"])( task=config["task"], model=config["model"], dataset=[config["dataset"]], diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index af2087f8f..f7da19992 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -178,7 +178,8 @@ def __init__( os.makedirs(self.config["cmd"]["logs_dir"], exist_ok=True) ### backwards compatability with OCP v<2.0 - if self.name != "ocp": + ### TODO: better format check for older configs + if not self.config.get("loss_fns"): logging.warning( "Detected old config, converting to new format. Consider updating to avoid potential incompatibilities." ) diff --git a/tests/common/__snapshots__/test_ase_calculator.ambr b/tests/common/__snapshots__/test_ase_calculator.ambr index 2277d3eb2..23fbb01b0 100644 --- a/tests/common/__snapshots__/test_ase_calculator.ambr +++ b/tests/common/__snapshots__/test_ase_calculator.ambr @@ -1,3 +1,3 @@ # name: TestCalculator.test_relaxation_final_energy - 0.74 + 0.92 # --- diff --git a/tests/common/test_ase_calculator.py b/tests/common/test_ase_calculator.py index 1be5e95db..ad0c08822 100644 --- a/tests/common/test_ase_calculator.py +++ b/tests/common/test_ase_calculator.py @@ -43,7 +43,7 @@ def load_model_list(request) -> None: # eSCN "https://dl.fbaipublicfiles.com/opencatalystproject/models/2023_03/s2ef/escn_l6_m3_lay20_all_md_s2ef.pt", # EquiformerV2 - # "https://dl.fbaipublicfiles.com/opencatalystproject/models/2023_06/oc20/s2ef/eq2_153M_ec4_allmd.pt", + "https://dl.fbaipublicfiles.com/opencatalystproject/models/2023_06/oc20/s2ef/eq2_153M_ec4_allmd.pt", ] From 2a82f56b024943495d11276fad5ef25d48e42dcd Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Fri, 3 Nov 2023 16:34:50 -0700 Subject: [PATCH 40/63] odac energy trainer merge fix --- .../models/equiformer_v2/trainers/energy_trainer.py | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) diff --git a/ocpmodels/models/equiformer_v2/trainers/energy_trainer.py b/ocpmodels/models/equiformer_v2/trainers/energy_trainer.py index 3fd88639b..a39e6fa83 100644 --- a/ocpmodels/models/equiformer_v2/trainers/energy_trainer.py +++ b/ocpmodels/models/equiformer_v2/trainers/energy_trainer.py @@ -11,12 +11,11 @@ from torch.nn.parallel.distributed import DistributedDataParallel from ocpmodels.common import distutils -from ocpmodels.common.data_parallel import OCPDataParallel from ocpmodels.common.registry import registry from ocpmodels.modules.exponential_moving_average import ( ExponentialMovingAverage, ) -from ocpmodels.trainers import EnergyTrainer +from ocpmodels.trainers import OCPTrainer from .lr_scheduler import LRScheduler @@ -49,7 +48,7 @@ def add_weight_decay(model, weight_decay, skip_list=()): @registry.register_trainer("equiformerv2_energy") -class EquiformerV2EnergyTrainer(EnergyTrainer): +class EquiformerV2EnergyTrainer(OCPTrainer): # This trainer does a few things differently from the parent energy trainer: # - When loading the model, it has a different way of setting up the params # with no weight decay. @@ -95,11 +94,7 @@ def load_model(self): if self.logger is not None: self.logger.watch(self.model) - self.model = OCPDataParallel( - self.model, - output_device=self.device, - num_gpus=1 if not self.cpu else 0, - ) + self.model.to(self.device) if distutils.initialized() and not self.config["noddp"]: self.model = DistributedDataParallel( self.model, device_ids=[self.device] From 843fbbded8a923a71de92aff7e3327263683221c Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Mon, 6 Nov 2023 09:50:55 -0800 Subject: [PATCH 41/63] is2re support --- ocpmodels/common/utils.py | 18 ++++++++++-------- ocpmodels/trainers/base_trainer.py | 4 ++++ 2 files changed, 14 insertions(+), 8 deletions(-) diff --git a/ocpmodels/common/utils.py b/ocpmodels/common/utils.py index 8ea3addcb..599748f79 100644 --- a/ocpmodels/common/utils.py +++ b/ocpmodels/common/utils.py @@ -1235,7 +1235,9 @@ def update_config(base_config): if "primary_metric" in config["task"]: _eval_metrics["primary_metric"] = config["task"]["primary_metric"] ### Define outputs - _outputs = {"energy": {"shape": 1, "level": "system"}} + _outputs = {"energy": {"level": "system"}} + ### Define key mapping + config["dataset"]["key_mapping"] = {"y_relaxed": "energy"} elif task == "s2ef": ### Define loss functions _loss_fns = [ @@ -1275,9 +1277,8 @@ def update_config(base_config): _eval_metrics["primary_metric"] = config["task"]["primary_metric"] ### Define outputs _outputs = { - "energy": {"shape": 1, "level": "system"}, + "energy": {"level": "system"}, "forces": { - "shape": 3, "level": "atom", "train_on_free_atoms": ( config["task"].get("train_on_free_atoms", False) @@ -1287,21 +1288,22 @@ def update_config(base_config): ), }, } + ### Define key mapping + config["dataset"]["key_mapping"] = {"y": "energy", "force": "forces"} if config["dataset"].get("normalize_labels", False): normalizer = { "energy": { - "mean": config["dataset"]["target_mean"], - "stdev": config["dataset"]["target_std"], + "mean": config["dataset"].get("target_mean", 0), + "stdev": config["dataset"].get("target_std", 1), }, "forces": { - "mean": config["dataset"]["grad_target_mean"], - "stdev": config["dataset"]["grad_target_std"], + "mean": config["dataset"].get("grad_target_mean", 0), + "stdev": config["dataset"].get("grad_target_std", 1), }, } config["dataset"]["normalizer"] = normalizer - config["dataset"]["key_mapping"] = {"y": "energy", "force": "forces"} ### Update config config.update({"loss_fns": _loss_fns}) config.update({"eval_metrics": _eval_metrics}) diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index f7da19992..625bcecd1 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -867,6 +867,10 @@ def _forward(self, batch): pred_irreps, ) + ### not all models are consistent with the output shape + if len(pred.shape) > 1: + pred = pred.squeeze(1) + outputs[target_key] = pred return outputs From 4566c231b7909b589a5acfb91d8a4be69b0c39aa Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Mon, 6 Nov 2023 15:28:06 -0800 Subject: [PATCH 42/63] cleanup --- .../2M/equiformer_v2/equiformer_refactor.yml | 131 ------------------ ocpmodels/common/utils.py | 4 +- ocpmodels/datasets/lmdb_dataset.py | 2 +- ocpmodels/trainers/base_trainer.py | 1 - 4 files changed, 3 insertions(+), 135 deletions(-) delete mode 100755 configs/s2ef/2M/equiformer_v2/equiformer_refactor.yml diff --git a/configs/s2ef/2M/equiformer_v2/equiformer_refactor.yml b/configs/s2ef/2M/equiformer_v2/equiformer_refactor.yml deleted file mode 100755 index 5ad262728..000000000 --- a/configs/s2ef/2M/equiformer_v2/equiformer_refactor.yml +++ /dev/null @@ -1,131 +0,0 @@ -trainer: equiformerv2_forces - -dataset: - train: - format: lmdb - src: /datasets01/open_catalyst/oc20/082422/struct_to_energy_forces/train/2M - key_mapping: - y: energy - force: forces - transforms: - normalizer: - energy: - mean: -0.7554450631141663 - stdev: 2.887317180633545 - forces: - mean: 0 - stdev: 2.887317180633545 - val: - src: /datasets01/open_catalyst/oc20/082422/struct_to_energy_forces/val/id_30k - # test: - # src: /datasets01/open_catalyst/oc20/082422/struct_to_energy_forces/val/id_30k - -logger: - name: wandb - project: is2dt_v4 - -loss_functions: - - energy: - fn: mae - coefficient: 1 - - forces: - fn: l2mae - coefficient: 100 - -evaluation_metrics: - metrics: - energy: - - mae - - mse - - energy_within_threshold - forces: - - mae - - cosine_similarity - misc: - - energy_forces_within_threshold - primary_metric: forces_mae - -outputs: - energy: - shape: 1 - level: system - forces: - shape: 3 - level: atom - train_on_free_atoms: True - eval_on_free_atoms: True - -slurm: - constraint: "volta32gb" - -model: - name: equiformer_v2 - - use_pbc: True - regress_forces: True - otf_graph: True - max_neighbors: 20 - max_radius: 12.0 - max_num_elements: 90 - - num_layers: 12 - sphere_channels: 128 - attn_hidden_channels: 64 # [64, 96] This determines the hidden size of message passing. Do not necessarily use 96. - num_heads: 8 - attn_alpha_channels: 64 # Not used when `use_s2_act_attn` is True. - attn_value_channels: 16 - ffn_hidden_channels: 128 - norm_type: 'layer_norm_sh' # ['rms_norm_sh', 'layer_norm', 'layer_norm_sh'] - - lmax_list: [6] - mmax_list: [2] - grid_resolution: 18 # [18, 16, 14, None] For `None`, simply comment this line. - - num_sphere_samples: 128 - - edge_channels: 128 - use_atom_edge_embedding: True - share_atom_edge_embedding: False # If `True`, `use_atom_edge_embedding` must be `True` and the atom edge embedding will be shared across all blocks. - distance_function: 'gaussian' - num_distance_basis: 512 # not used - - attn_activation: 'silu' - use_s2_act_attn: False # [False, True] Switch between attention after S2 activation or the original EquiformerV1 attention. - use_attn_renorm: True # Attention re-normalization. Used for ablation study. - ffn_activation: 'silu' # ['silu', 'swiglu'] - use_gate_act: False # [True, False] Switch between gate activation and S2 activation - use_grid_mlp: True # [False, True] If `True`, use projecting to grids and performing MLPs for FFNs. - use_sep_s2_act: True # Separable S2 activation. Used for ablation study. - - alpha_drop: 0.1 # [0.0, 0.1] - drop_path_rate: 0.05 # [0.0, 0.05] - proj_drop: 0.0 - - weight_init: 'uniform' # ['uniform', 'normal'] - -optim: - batch_size: 4 # 6 - eval_batch_size: 4 # 6 - load_balancing: atoms - num_workers: 8 - lr_initial: 0.0004 # [0.0002, 0.0004], eSCN uses 0.0008 for batch size 96 - - optimizer: AdamW - optimizer_params: - weight_decay: 0.001 - scheduler: LambdaLR - scheduler_params: - lambda_type: cosine - warmup_factor: 0.2 - warmup_epochs: 0.1 - lr_min_factor: 0.01 # - - max_epochs: 30 - force_coefficient: 100 - energy_coefficient: 2 - clip_grad_norm: 100 - ema_decay: 0.999 - loss_energy: mae - loss_force: l2mae - - eval_every: 5000 diff --git a/ocpmodels/common/utils.py b/ocpmodels/common/utils.py index 599748f79..4f0792385 100644 --- a/ocpmodels/common/utils.py +++ b/ocpmodels/common/utils.py @@ -1000,9 +1000,9 @@ class _TrainingContext: setup_imports(config) trainer_name = config.get("trainer", "ocp") # backwards compatibility for older configs - if trainer_name == "forces": + if trainer_name in ["forces", "equiformerv2_forces"]: task_name = "s2ef" - elif trainer_name == "energy": + elif trainer_name in ["energy", "equiformerv2_energy"]: task_name = "is2re" else: task_name = "ocp" diff --git a/ocpmodels/datasets/lmdb_dataset.py b/ocpmodels/datasets/lmdb_dataset.py index 3343628ab..93e13ed33 100644 --- a/ocpmodels/datasets/lmdb_dataset.py +++ b/ocpmodels/datasets/lmdb_dataset.py @@ -159,7 +159,7 @@ def __getitem__(self, idx: int) -> T_co: data_object[new_property] = data_object[_property] del data_object[_property] - self.transforms(data_object) + data_object = self.transforms(data_object) return data_object diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index 625bcecd1..06e63f317 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -1209,7 +1209,6 @@ def predict( predictions[key] = np.array(predictions[key]) self.save_results(predictions, results_file) - # TODO relaxation support if self.ema: self.ema.restore() From 92336ec7022ec7f57c9e9f2419b8457c093b85d4 Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Mon, 6 Nov 2023 15:31:44 -0800 Subject: [PATCH 43/63] config cleanup --- configs/is2re/100k/cgcnn/cgcnn.yml | 32 ----------- configs/is2re/10k/cgcnn/cgcnn.yml | 32 ----------- configs/is2re/all/base.yml | 2 +- configs/is2re/all/cgcnn/cgcnn.yml | 32 ----------- configs/s2ef/200k/cgcnn/cgcnn.yml | 31 ----------- configs/s2ef/200k/forcenet/fn_forceonly.yml | 55 ------------------- configs/s2ef/200k/spinconv/spinconv_force.yml | 37 ------------- configs/s2ef/20M/cgcnn/cgcnn.yml | 32 ----------- configs/s2ef/20M/spinconv/spinconv_force.yml | 37 ------------- configs/s2ef/2M/cgcnn/cgcnn.yml | 32 ----------- configs/s2ef/2M/spinconv/spinconv_force.yml | 37 ------------- configs/s2ef/all/cgcnn/cgcnn.yml | 32 ----------- configs/s2ef/all/spinconv/spinconv_force.yml | 37 ------------- 13 files changed, 1 insertion(+), 427 deletions(-) delete mode 100755 configs/is2re/100k/cgcnn/cgcnn.yml delete mode 100755 configs/is2re/10k/cgcnn/cgcnn.yml delete mode 100755 configs/is2re/all/cgcnn/cgcnn.yml delete mode 100755 configs/s2ef/200k/cgcnn/cgcnn.yml delete mode 100755 configs/s2ef/200k/forcenet/fn_forceonly.yml delete mode 100755 configs/s2ef/200k/spinconv/spinconv_force.yml delete mode 100755 configs/s2ef/20M/cgcnn/cgcnn.yml delete mode 100755 configs/s2ef/20M/spinconv/spinconv_force.yml delete mode 100755 configs/s2ef/2M/cgcnn/cgcnn.yml delete mode 100755 configs/s2ef/2M/spinconv/spinconv_force.yml delete mode 100755 configs/s2ef/all/cgcnn/cgcnn.yml delete mode 100755 configs/s2ef/all/spinconv/spinconv_force.yml diff --git a/configs/is2re/100k/cgcnn/cgcnn.yml b/configs/is2re/100k/cgcnn/cgcnn.yml deleted file mode 100755 index 324b38546..000000000 --- a/configs/is2re/100k/cgcnn/cgcnn.yml +++ /dev/null @@ -1,32 +0,0 @@ -includes: -- configs/is2re/100k/base.yml - -model: - name: cgcnn - atom_embedding_size: 384 - fc_feat_size: 128 - num_fc_layers: 4 - num_graph_conv_layers: 5 - num_gaussians: 100 - cutoff: 6.0 - regress_forces: False - use_pbc: True - -# *** Important note *** -# The total number of gpus used for this run was 1. -# If the global batch size (num_gpus * batch_size) is modified -# the lr_milestones and warmup_steps need to be adjusted accordingly. - -optim: - batch_size: 16 - eval_batch_size: 16 - num_workers: 16 - lr_initial: 0.01 - lr_gamma: 0.1 - lr_milestones: # steps at which lr_initial <- lr_initial * lr_gamma - - 31250 - - 56250 - - 75000 - warmup_steps: 18750 - warmup_factor: 0.2 - max_epochs: 30 diff --git a/configs/is2re/10k/cgcnn/cgcnn.yml b/configs/is2re/10k/cgcnn/cgcnn.yml deleted file mode 100755 index df4bf922e..000000000 --- a/configs/is2re/10k/cgcnn/cgcnn.yml +++ /dev/null @@ -1,32 +0,0 @@ -includes: -- configs/is2re/10k/base.yml - -model: - name: cgcnn - atom_embedding_size: 128 - fc_feat_size: 256 - num_fc_layers: 4 - num_graph_conv_layers: 5 - num_gaussians: 100 - cutoff: 6.0 - regress_forces: False - use_pbc: True - -# *** Important note *** -# The total number of gpus used for this run was 1. -# If the global batch size (num_gpus * batch_size) is modified -# the lr_milestones and warmup_steps need to be adjusted accordingly. - -optim: - batch_size: 64 - eval_batch_size: 64 - num_workers: 16 - lr_initial: 0.01 - lr_gamma: 0.1 - lr_milestones: # steps at which lr_initial <- lr_initial * lr_gamma - - 781 - - 1406 - - 2031 - warmup_steps: 468 - warmup_factor: 0.2 - max_epochs: 20 diff --git a/configs/is2re/all/base.yml b/configs/is2re/all/base.yml index cf61f8309..cfd817ffc 100755 --- a/configs/is2re/all/base.yml +++ b/configs/is2re/all/base.yml @@ -7,7 +7,7 @@ dataset: target_std: 2.279365062713623 - src: data/is2re/all/val_id/data.lmdb -logger: tensorboard +logger: wandb task: dataset: single_point_lmdb diff --git a/configs/is2re/all/cgcnn/cgcnn.yml b/configs/is2re/all/cgcnn/cgcnn.yml deleted file mode 100755 index 8caeda837..000000000 --- a/configs/is2re/all/cgcnn/cgcnn.yml +++ /dev/null @@ -1,32 +0,0 @@ -includes: -- configs/is2re/all/base.yml - -model: - name: cgcnn - atom_embedding_size: 384 - fc_feat_size: 512 - num_fc_layers: 4 - num_graph_conv_layers: 6 - num_gaussians: 100 - cutoff: 6.0 - regress_forces: False - use_pbc: True - -# *** Important note *** -# The total number of gpus used for this run was 4. -# If the global batch size (num_gpus * batch_size) is modified -# the lr_milestones and warmup_steps need to be adjusted accordingly. - -optim: - batch_size: 32 - eval_batch_size: 32 - num_workers: 16 - lr_initial: 0.01 - lr_gamma: 0.1 - lr_milestones: # steps at which lr_initial <- lr_initial * lr_gamma - - 17981 - - 32366 - - 46752 - warmup_steps: 10788 - warmup_factor: 0.2 - max_epochs: 20 diff --git a/configs/s2ef/200k/cgcnn/cgcnn.yml b/configs/s2ef/200k/cgcnn/cgcnn.yml deleted file mode 100755 index fd27082fb..000000000 --- a/configs/s2ef/200k/cgcnn/cgcnn.yml +++ /dev/null @@ -1,31 +0,0 @@ -includes: -- configs/s2ef/200k/base.yml - -model: - name: cgcnn - atom_embedding_size: 128 - fc_feat_size: 128 - num_fc_layers: 3 - num_graph_conv_layers: 2 - cutoff: 6.0 - num_gaussians: 100 - use_pbc: True - -# *** Important note *** -# The total number of gpus used for this run was 4. -# If the global batch size (num_gpus * batch_size) is modified -# the lr_milestones and warmup_steps need to be adjusted accordingly. - -optim: - batch_size: 32 - eval_batch_size: 32 - num_workers: 16 - lr_initial: 0.0005 - lr_gamma: 0.1 - lr_milestones: # steps at which lr_initial <- lr_initial * lr_gamma - - 23437 - - 31250 - warmup_steps: 3125 - warmup_factor: 0.2 - max_epochs: 50 - force_coefficient: 10 diff --git a/configs/s2ef/200k/forcenet/fn_forceonly.yml b/configs/s2ef/200k/forcenet/fn_forceonly.yml deleted file mode 100755 index e85592d89..000000000 --- a/configs/s2ef/200k/forcenet/fn_forceonly.yml +++ /dev/null @@ -1,55 +0,0 @@ -trainer: forces - -dataset: - - src: data/s2ef/200k/train/ - - src: data/s2ef/all/val_id/ - -model: - name: forcenet - num_interactions: 5 - cutoff: 6 - basis: "sphallmul" - ablation: "none" - depth_mlp_edge: 2 - depth_mlp_node: 1 - activation_str: "swish" - decoder_activation_str: "swish" - feat: "full" - hidden_channels: 512 - decoder_hidden_channels: 512 - max_n: 3 - -# *** Important note *** -# The total number of gpus used for this run was 8. -# If the global batch size (num_gpus * batch_size) is modified -# the lr_milestones and warmup_steps need to be adjusted accordingly. - -optim: - batch_size: 8 - eval_batch_size: 8 - eval_every: 10000 - num_workers: 8 - lr_initial: 0.0005 - max_epochs: 20 - energy_coefficient: 0 - lr_gamma: 0.1 - lr_milestones: # steps at which lr_initial <- lr_initial * lr_gamma - - 15625 - - 25000 - - 31250 - warmup_steps: 9375 - warmup_factor: 0.2 - -task: - dataset: trajectory_lmdb - description: "Regressing to energies and forces for DFT trajectories from OCP" - type: regression - metric: mae - primary_metric: forces_mae - labels: - - potential energy - grad_input: atomic forces - tag_specific_weights: - - 0.05 - - 1.0 - - 1.0 diff --git a/configs/s2ef/200k/spinconv/spinconv_force.yml b/configs/s2ef/200k/spinconv/spinconv_force.yml deleted file mode 100755 index c7c929340..000000000 --- a/configs/s2ef/200k/spinconv/spinconv_force.yml +++ /dev/null @@ -1,37 +0,0 @@ -includes: -- configs/s2ef/200k/base.yml - -model: - name: spinconv - model_ref_number: 0 - hidden_channels: 32 - mid_hidden_channels: 256 - num_interactions: 3 - num_basis_functions: 512 - sphere_size_lat: 16 - sphere_size_long: 12 - max_num_neighbors: 40 - cutoff: 6.0 - sphere_message: fullconv - output_message: fullconv - force_estimator: random - regress_forces: True - use_pbc: True - scale_distances: True - basis_width_scalar: 3.0 - -optim: - batch_size: 3 - eval_batch_size: 3 - num_workers: 8 - lr_initial: 0.0004 - optimizer: Adam - optimizer_params: {"amsgrad": True} - eval_every: 5000 - scheduler: ReduceLROnPlateau - mode: min - factor: 0.8 - patience: 3 - max_epochs: 80 - force_coefficient: 100 - energy_coefficient: 1 diff --git a/configs/s2ef/20M/cgcnn/cgcnn.yml b/configs/s2ef/20M/cgcnn/cgcnn.yml deleted file mode 100755 index 60aa4bee4..000000000 --- a/configs/s2ef/20M/cgcnn/cgcnn.yml +++ /dev/null @@ -1,32 +0,0 @@ -includes: -- configs/s2ef/20M/base.yml - -model: - name: cgcnn - atom_embedding_size: 512 - fc_feat_size: 128 - num_fc_layers: 3 - num_graph_conv_layers: 3 - cutoff: 6.0 - num_gaussians: 100 - use_pbc: True - -# *** Important note *** -# The total number of gpus used for this run was 48. -# If the global batch size (num_gpus * batch_size) is modified -# the lr_milestones and warmup_steps need to be adjusted accordingly. - -optim: - batch_size: 24 - eval_batch_size: 24 - num_workers: 16 - lr_initial: 0.0005 - lr_gamma: 0.1 - lr_milestones: # steps at which lr_initial <- lr_initial * lr_gamma - - 52083 - - 86805 - - 121527 - warmup_steps: 34722 - warmup_factor: 0.2 - max_epochs: 20 - force_coefficient: 100 diff --git a/configs/s2ef/20M/spinconv/spinconv_force.yml b/configs/s2ef/20M/spinconv/spinconv_force.yml deleted file mode 100755 index 51deaed0e..000000000 --- a/configs/s2ef/20M/spinconv/spinconv_force.yml +++ /dev/null @@ -1,37 +0,0 @@ -includes: -- configs/s2ef/20M/base.yml - -model: - name: spinconv - model_ref_number: 0 - hidden_channels: 32 - mid_hidden_channels: 256 - num_interactions: 3 - num_basis_functions: 512 - sphere_size_lat: 16 - sphere_size_long: 12 - max_num_neighbors: 40 - cutoff: 6.0 - sphere_message: fullconv - output_message: fullconv - force_estimator: random - regress_forces: True - use_pbc: True - scale_distances: True - basis_width_scalar: 3.0 - -optim: - batch_size: 3 - eval_batch_size: 3 - num_workers: 8 - lr_initial: 0.0004 - optimizer: Adam - optimizer_params: {"amsgrad": True} - eval_every: 5000 - scheduler: ReduceLROnPlateau - mode: min - factor: 0.8 - patience: 3 - max_epochs: 80 - force_coefficient: 100 - energy_coefficient: 1 diff --git a/configs/s2ef/2M/cgcnn/cgcnn.yml b/configs/s2ef/2M/cgcnn/cgcnn.yml deleted file mode 100755 index dfc5ba76f..000000000 --- a/configs/s2ef/2M/cgcnn/cgcnn.yml +++ /dev/null @@ -1,32 +0,0 @@ -includes: -- configs/s2ef/2M/base.yml - -model: - name: cgcnn - atom_embedding_size: 384 - fc_feat_size: 128 - num_fc_layers: 3 - num_graph_conv_layers: 3 - cutoff: 6.0 - num_gaussians: 100 - use_pbc: True - -# *** Important note *** -# The total number of gpus used for this run was 8. -# If the global batch size (num_gpus * batch_size) is modified -# the lr_milestones and warmup_steps need to be adjusted accordingly. - -optim: - batch_size: 8 - eval_batch_size: 8 - num_workers: 8 - lr_initial: 0.001 - lr_gamma: 0.1 - lr_milestones: # steps at which lr_initial <- lr_initial * lr_gamma - - 156250 - - 281250 - - 437500 - warmup_steps: 62500 - warmup_factor: 0.2 - max_epochs: 20 - force_coefficient: 10 diff --git a/configs/s2ef/2M/spinconv/spinconv_force.yml b/configs/s2ef/2M/spinconv/spinconv_force.yml deleted file mode 100755 index ac25afd57..000000000 --- a/configs/s2ef/2M/spinconv/spinconv_force.yml +++ /dev/null @@ -1,37 +0,0 @@ -includes: -- configs/s2ef/2M/base.yml - -model: - name: spinconv - model_ref_number: 0 - hidden_channels: 32 - mid_hidden_channels: 256 - num_interactions: 3 - num_basis_functions: 512 - sphere_size_lat: 16 - sphere_size_long: 12 - max_num_neighbors: 40 - cutoff: 6.0 - sphere_message: fullconv - output_message: fullconv - force_estimator: random - regress_forces: True - use_pbc: True - scale_distances: True - basis_width_scalar: 3.0 - -optim: - batch_size: 3 - eval_batch_size: 3 - num_workers: 8 - lr_initial: 0.0004 - optimizer: Adam - optimizer_params: {"amsgrad": True} - eval_every: 5000 - scheduler: ReduceLROnPlateau - mode: min - factor: 0.8 - patience: 3 - max_epochs: 80 - force_coefficient: 100 - energy_coefficient: 1 diff --git a/configs/s2ef/all/cgcnn/cgcnn.yml b/configs/s2ef/all/cgcnn/cgcnn.yml deleted file mode 100755 index 4b3b4e3bc..000000000 --- a/configs/s2ef/all/cgcnn/cgcnn.yml +++ /dev/null @@ -1,32 +0,0 @@ -includes: -- configs/s2ef/all/base.yml - -model: - name: cgcnn - atom_embedding_size: 512 - fc_feat_size: 128 - num_fc_layers: 3 - num_graph_conv_layers: 3 - cutoff: 6.0 - num_gaussians: 100 - use_pbc: True - -# *** Important note *** -# The total number of gpus used for this run was 32. -# If the global batch size (num_gpus * batch_size) is modified -# the lr_milestones and warmup_steps need to be adjusted accordingly. - -optim: - batch_size: 24 - eval_batch_size: 24 - num_workers: 16 - lr_initial: 0.0005 - lr_gamma: 0.1 - lr_milestones: # steps at which lr_initial <- lr_initial * lr_gamma - - 523179 - - 871966 - - 1220752 - warmup_steps: 348786 - warmup_factor: 0.2 - max_epochs: 20 - force_coefficient: 10 diff --git a/configs/s2ef/all/spinconv/spinconv_force.yml b/configs/s2ef/all/spinconv/spinconv_force.yml deleted file mode 100755 index da2a9348a..000000000 --- a/configs/s2ef/all/spinconv/spinconv_force.yml +++ /dev/null @@ -1,37 +0,0 @@ -includes: -- configs/s2ef/all/base.yml - -model: - name: spinconv - model_ref_number: 0 - hidden_channels: 32 - mid_hidden_channels: 256 - num_interactions: 3 - num_basis_functions: 512 - sphere_size_lat: 16 - sphere_size_long: 12 - max_num_neighbors: 40 - cutoff: 6.0 - sphere_message: fullconv - output_message: fullconv - force_estimator: random - regress_forces: True - use_pbc: True - scale_distances: True - basis_width_scalar: 3.0 - -optim: - batch_size: 3 - eval_batch_size: 3 - num_workers: 8 - lr_initial: 0.0004 - optimizer: Adam - optimizer_params: {"amsgrad": True} - eval_every: 5000 - scheduler: ReduceLROnPlateau - mode: min - factor: 0.8 - patience: 3 - max_epochs: 80 - force_coefficient: 100 - energy_coefficient: 1 From 371ad84f585e02992d134599e97121d9ffec47ba Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Mon, 6 Nov 2023 16:21:44 -0800 Subject: [PATCH 44/63] oc22 support --- ocpmodels/common/utils.py | 2 ++ ocpmodels/datasets/oc22_lmdb_dataset.py | 14 +++++++++++--- ocpmodels/modules/transforms.py | 5 ++++- 3 files changed, 17 insertions(+), 4 deletions(-) diff --git a/ocpmodels/common/utils.py b/ocpmodels/common/utils.py index 4f0792385..354dd86fd 100644 --- a/ocpmodels/common/utils.py +++ b/ocpmodels/common/utils.py @@ -1204,11 +1204,13 @@ def update_config(base_config): are now. Update old configs to fit the new expected structure. """ config = copy.deepcopy(base_config) + config["dataset"]["format"] = config["task"].get("dataset", "lmdb") ### Read task based off config structure, similar to OCPCalculator. if config["task"]["dataset"] in [ "trajectory_lmdb", "lmdb", "trajectory_lmdb_v2", + "oc22_lmdb", ]: task = "s2ef" elif config["task"]["dataset"] == "single_point_lmdb": diff --git a/ocpmodels/datasets/oc22_lmdb_dataset.py b/ocpmodels/datasets/oc22_lmdb_dataset.py index c04d614ed..aee0a2f81 100644 --- a/ocpmodels/datasets/oc22_lmdb_dataset.py +++ b/ocpmodels/datasets/oc22_lmdb_dataset.py @@ -149,8 +149,6 @@ def __getitem__(self, idx): ) data_object = pyg2_data_transform(pickle.loads(datapoint_pickled)) - if self.transform is not None: - data_object = self.transform(data_object) # make types consistent sid = data_object.sid if isinstance(sid, torch.Tensor): @@ -168,7 +166,7 @@ def __getitem__(self, idx): attr = "y" # if targets are not available, test data is being used else: - return data_object + return self.transforms(data_object) # convert s2ef energies to raw energies if attr == "y": @@ -199,6 +197,14 @@ def __getitem__(self, idx): lin_energy = sum(self.lin_ref[data_object.atomic_numbers.long()]) data_object[attr] -= lin_energy + if self.key_mapping is not None: + for _property in self.key_mapping: + if _property in data_object: + new_property = self.key_mapping[_property] + if new_property not in data_object: + data_object[new_property] = data_object[_property] + del data_object[_property] + # to jointly train on oc22+oc20, need to delete these oc20-only attributes # ensure otf_graph=1 in your model configuration if "edge_index" in data_object: @@ -208,6 +214,8 @@ def __getitem__(self, idx): if "distances" in data_object: del data_object.distances + data_object = self.transforms(data_object) + return data_object def connect_db(self, lmdb_path=None): diff --git a/ocpmodels/modules/transforms.py b/ocpmodels/modules/transforms.py index 0a836daa5..ffdbe2a3c 100644 --- a/ocpmodels/modules/transforms.py +++ b/ocpmodels/modules/transforms.py @@ -13,7 +13,8 @@ def __call__(self, data_object): return data_object for transform_fn in self.config: - # TODO move normalizer into dataset + # TODO: Normalization information used in the trainers. Ignore here + # for now. if transform_fn == "normalizer": continue data_object = eval(transform_fn)( @@ -27,6 +28,8 @@ def decompose_tensor(data_object, config) -> Data: tensor_key = config["tensor"] rank = config["rank"] + assert tensor_key in data_object + if rank != 2: raise NotImplementedError From de2a6adc75adb9040a24ab300383a4f1d7c759ed Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Mon, 6 Nov 2023 16:52:31 -0800 Subject: [PATCH 45/63] introduce collater to handle otf_graph arg --- ocpmodels/common/data_parallel.py | 11 +++++++++++ ocpmodels/trainers/base_trainer.py | 8 +++++--- 2 files changed, 16 insertions(+), 3 deletions(-) diff --git a/ocpmodels/common/data_parallel.py b/ocpmodels/common/data_parallel.py index 18509e039..123ee35b8 100644 --- a/ocpmodels/common/data_parallel.py +++ b/ocpmodels/common/data_parallel.py @@ -15,8 +15,19 @@ import numpy.typing as npt import torch from torch.utils.data import BatchSampler, DistributedSampler, Sampler +from torch_geometric.data import Batch, Data from ocpmodels.common import distutils, gp_utils +from ocpmodels.datasets import data_list_collater + + +class OCPCollater: + def __init__(self, otf_graph: bool = False) -> None: + self.otf_graph = otf_graph + + def __call__(self, data_list: List[Data]) -> Batch: + batch = data_list_collater(data_list, otf_graph=self.otf_graph) + return batch @numba.njit diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index 06e63f317..b0af991f9 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -25,7 +25,7 @@ from tqdm import tqdm from ocpmodels.common import distutils, gp_utils -from ocpmodels.common.data_parallel import BalancedBatchSampler +from ocpmodels.common.data_parallel import BalancedBatchSampler, OCPCollater from ocpmodels.common.registry import registry from ocpmodels.common.typing import assert_is_instance as aii from ocpmodels.common.typing import none_throws @@ -38,7 +38,6 @@ save_checkpoint, update_config, ) -from ocpmodels.datasets import data_list_collater from ocpmodels.modules.evaluator import Evaluator from ocpmodels.modules.exponential_moving_average import ( ExponentialMovingAverage, @@ -270,7 +269,7 @@ def get_sampler( def get_dataloader(self, dataset, sampler) -> DataLoader: loader = DataLoader( dataset, - collate_fn=data_list_collater, + collate_fn=self.ocp_collater, num_workers=self.config["optim"]["num_workers"], pin_memory=True, batch_sampler=sampler, @@ -278,6 +277,9 @@ def get_dataloader(self, dataset, sampler) -> DataLoader: return loader def load_datasets(self) -> None: + self.ocp_collater = OCPCollater( + self.config["model_attributes"].get("otf_graph", False) + ) self.train_loader = None self.val_loader = None self.test_loader = None From 5df5120fb6aa0940160f7899863dad433bf23f67 Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Mon, 6 Nov 2023 16:58:07 -0800 Subject: [PATCH 46/63] organize methods --- ocpmodels/trainers/base_trainer.py | 279 ----------------------------- ocpmodels/trainers/ocp_trainer.py | 279 ++++++++++++++++++++++++++++- 2 files changed, 278 insertions(+), 280 deletions(-) diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index b0af991f9..8ee19f398 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -30,10 +30,8 @@ from ocpmodels.common.typing import assert_is_instance as aii from ocpmodels.common.typing import none_throws from ocpmodels.common.utils import ( - cg_change_mat, get_commit_hash, get_loss_module, - irreps_sum, load_state_dict, save_checkpoint, update_config, @@ -692,283 +690,6 @@ def update_best( disable_tqdm=disable_eval_tqdm, ) - def train(self, disable_eval_tqdm: bool = False) -> None: - ensure_fitted(self._unwrapped_model, warn=True) - - eval_every = self.config["optim"].get( - "eval_every", len(self.train_loader) - ) - checkpoint_every = self.config["optim"].get( - "checkpoint_every", eval_every - ) - primary_metric = self.evaluation_metrics.get( - "primary_metric", self.evaluator.task_primary_metric[self.name] - ) - if ( - not hasattr(self, "primary_metric") - or self.primary_metric != primary_metric - ): - self.best_val_metric = 1e9 if "mae" in primary_metric else -1.0 - else: - primary_metric = self.primary_metric - self.metrics = {} - - # Calculate start_epoch from step instead of loading the epoch number - # to prevent inconsistencies due to different batch size in checkpoint. - start_epoch = self.step // len(self.train_loader) - - for epoch_int in range( - start_epoch, self.config["optim"]["max_epochs"] - ): - self.train_sampler.set_epoch(epoch_int) - skip_steps = self.step % len(self.train_loader) - train_loader_iter = iter(self.train_loader) - - for i in range(skip_steps, len(self.train_loader)): - self.epoch = epoch_int + (i + 1) / len(self.train_loader) - self.step = epoch_int * len(self.train_loader) + i + 1 - self.model.train() - - # Get a batch. - batch = next(train_loader_iter) - - # Forward, loss, backward. - with torch.cuda.amp.autocast(enabled=self.scaler is not None): - out = self._forward(batch) - loss = self._compute_loss(out, batch) - loss = self.scaler.scale(loss) if self.scaler else loss - self._backward(loss) - scale = self.scaler.get_scale() if self.scaler else 1.0 - - # Compute metrics. - self.metrics = self._compute_metrics( - out, - batch, - self.evaluator, - self.metrics, - ) - self.metrics = self.evaluator.update( - "loss", loss.item() / scale, self.metrics - ) - - # Log metrics. - log_dict = {k: self.metrics[k]["metric"] for k in self.metrics} - log_dict.update( - { - "lr": self.scheduler.get_lr(), - "epoch": self.epoch, - "step": self.step, - } - ) - if ( - self.step % self.config["cmd"]["print_every"] == 0 - and distutils.is_master() - ): - log_str = [ - "{}: {:.2e}".format(k, v) for k, v in log_dict.items() - ] - logging.info(", ".join(log_str)) - self.metrics = {} - - if self.logger is not None: - self.logger.log( - log_dict, - step=self.step, - split="train", - ) - - if ( - checkpoint_every != -1 - and self.step % checkpoint_every == 0 - ): - self.save( - checkpoint_file="checkpoint.pt", training_state=True - ) - - # Evaluate on val set every `eval_every` iterations. - if self.step % eval_every == 0: - if self.val_loader is not None: - val_metrics = self.validate( - split="val", - disable_tqdm=disable_eval_tqdm, - ) - self.update_best( - primary_metric, - val_metrics, - disable_eval_tqdm=disable_eval_tqdm, - ) - - if self.config["task"].get("eval_relaxations", False): - if "relax_dataset" not in self.config["task"]: - logging.warning( - "Cannot evaluate relaxations, relax_dataset not specified" - ) - else: - self.run_relaxations() - - if self.scheduler.scheduler_type == "ReduceLROnPlateau": - if self.step % eval_every == 0: - self.scheduler.step( - metrics=val_metrics[primary_metric]["metric"], - ) - else: - self.scheduler.step() - - torch.cuda.empty_cache() - - if checkpoint_every == -1: - self.save(checkpoint_file="checkpoint.pt", training_state=True) - - self.train_dataset.close_db() - if self.config.get("val_dataset", False): - self.val_dataset.close_db() - if self.config.get("test_dataset", False): - self.test_dataset.close_db() - - def _forward(self, batch): - out = self.model(batch.to(self.device)) - - ### TOOD: Move into BaseModel in OCP 2.0 - outputs = {} - batch_size = batch.natoms.numel() - for target_key in self.config["outputs"]: - ### Target property is a direct output of the model - if target_key in out: - pred = out[target_key] - ## Target property is a derived output of the model. Construct the - ## parent property - else: - _max_rank = 0 - for subtarget_key in self.config["outputs"][target_key][ - "decomposition" - ]: - _max_rank = max( - _max_rank, - self.output_targets[subtarget_key]["irrep_dim"], - ) - - pred_irreps = torch.zeros( - (batch_size, irreps_sum(_max_rank)), device=self.device - ) - - for subtarget_key in self.config["outputs"][target_key][ - "decomposition" - ]: - irreps = self.output_targets[subtarget_key]["irrep_dim"] - _pred = out[subtarget_key] - - ## Fill in the corresponding irreps prediction - pred_irreps[ - :, - max(0, irreps_sum(irreps - 1)) : irreps_sum(irreps), - ] = _pred - - pred = torch.einsum( - "ba, cb->ca", - cg_change_mat(_max_rank, self.device), - pred_irreps, - ) - - ### not all models are consistent with the output shape - if len(pred.shape) > 1: - pred = pred.squeeze(1) - - outputs[target_key] = pred - - return outputs - - def _compute_loss(self, out, batch): - natoms = batch.natoms.to(self.device) - batch_size = natoms.numel() - natoms = torch.repeat_interleave(natoms, natoms) - - fixed = batch.fixed.to(self.device) - mask = fixed == 0 - - loss = [] - - for loss_fn in self.loss_fns: - target_name, loss_info = loss_fn - - target = batch[target_name].to(self.device) - pred = out[target_name] - - if self.output_targets[target_name].get( - "level", "system" - ) == "atom" and self.output_targets[target_name].get( - "train_on_free_atoms", True - ): - target = target[mask] - pred = pred[mask] - natoms = natoms[mask] - - if self.normalizers.get(target_name, False): - target = self.normalizers[target_name].norm(target) - - mult = loss_info["coefficient"] - - loss.append( - mult - * loss_info["fn"]( - pred, - target, - natoms=natoms, - batch_size=batch_size, - ) - ) - - # Sanity check to make sure the compute graph is correct. - for lc in loss: - assert hasattr(lc, "grad_fn") - - loss = sum(loss) - return loss - - def _compute_metrics(self, out, batch, evaluator, metrics={}): - natoms = batch.natoms.to(self.device) - - ### Retrieve free atoms - fixed = batch.fixed.to(self.device) - mask = fixed == 0 - - s_idx = 0 - natoms_free = [] - for _natoms in natoms: - natoms_free.append(torch.sum(mask[s_idx : s_idx + _natoms]).item()) - s_idx += _natoms - natoms = torch.LongTensor(natoms_free).to(self.device) - - targets = {} - for target_name in self.output_targets: - target = batch[target_name].to(self.device) - # Add parent target to targets - if "parent" in self.output_targets[target_name]: - parent_target_name = self.output_targets[target_name]["parent"] - - if parent_target_name not in targets: - parent_target = batch[parent_target_name].to(self.device) - targets[parent_target_name] = parent_target - - if self.output_targets[target_name].get( - "level", "system" - ) == "atom" and self.output_targets[target_name].get( - "eval_on_free_atoms", True - ): - target = target[mask] - out[target_name] = out[target_name][mask] - - targets[target_name] = target - if self.normalizers.get(target_name, False): - out[target_name] = self.normalizers[target_name].denorm( - out[target_name] - ) - - targets["natoms"] = natoms - out["natoms"] = natoms - - metrics = evaluator.eval(out, targets, prev_metrics=metrics) - return metrics - @torch.no_grad() def validate(self, split: str = "val", disable_tqdm: bool = False): ensure_fitted(self._unwrapped_model, warn=True) diff --git a/ocpmodels/trainers/ocp_trainer.py b/ocpmodels/trainers/ocp_trainer.py index 18947f409..fc2514b7d 100644 --- a/ocpmodels/trainers/ocp_trainer.py +++ b/ocpmodels/trainers/ocp_trainer.py @@ -16,7 +16,7 @@ from ocpmodels.common import distutils from ocpmodels.common.registry import registry from ocpmodels.common.relaxation.ml_relaxation import ml_relax -from ocpmodels.common.utils import check_traj_files +from ocpmodels.common.utils import cg_change_mat, check_traj_files, irreps_sum from ocpmodels.modules.evaluator import Evaluator from ocpmodels.modules.scaling.util import ensure_fitted from ocpmodels.trainers.base_trainer import BaseTrainer @@ -106,6 +106,283 @@ def __init__( name=name, ) + def train(self, disable_eval_tqdm: bool = False) -> None: + ensure_fitted(self._unwrapped_model, warn=True) + + eval_every = self.config["optim"].get( + "eval_every", len(self.train_loader) + ) + checkpoint_every = self.config["optim"].get( + "checkpoint_every", eval_every + ) + primary_metric = self.evaluation_metrics.get( + "primary_metric", self.evaluator.task_primary_metric[self.name] + ) + if ( + not hasattr(self, "primary_metric") + or self.primary_metric != primary_metric + ): + self.best_val_metric = 1e9 if "mae" in primary_metric else -1.0 + else: + primary_metric = self.primary_metric + self.metrics = {} + + # Calculate start_epoch from step instead of loading the epoch number + # to prevent inconsistencies due to different batch size in checkpoint. + start_epoch = self.step // len(self.train_loader) + + for epoch_int in range( + start_epoch, self.config["optim"]["max_epochs"] + ): + self.train_sampler.set_epoch(epoch_int) + skip_steps = self.step % len(self.train_loader) + train_loader_iter = iter(self.train_loader) + + for i in range(skip_steps, len(self.train_loader)): + self.epoch = epoch_int + (i + 1) / len(self.train_loader) + self.step = epoch_int * len(self.train_loader) + i + 1 + self.model.train() + + # Get a batch. + batch = next(train_loader_iter) + + # Forward, loss, backward. + with torch.cuda.amp.autocast(enabled=self.scaler is not None): + out = self._forward(batch) + loss = self._compute_loss(out, batch) + loss = self.scaler.scale(loss) if self.scaler else loss + self._backward(loss) + scale = self.scaler.get_scale() if self.scaler else 1.0 + + # Compute metrics. + self.metrics = self._compute_metrics( + out, + batch, + self.evaluator, + self.metrics, + ) + self.metrics = self.evaluator.update( + "loss", loss.item() / scale, self.metrics + ) + + # Log metrics. + log_dict = {k: self.metrics[k]["metric"] for k in self.metrics} + log_dict.update( + { + "lr": self.scheduler.get_lr(), + "epoch": self.epoch, + "step": self.step, + } + ) + if ( + self.step % self.config["cmd"]["print_every"] == 0 + and distutils.is_master() + ): + log_str = [ + "{}: {:.2e}".format(k, v) for k, v in log_dict.items() + ] + logging.info(", ".join(log_str)) + self.metrics = {} + + if self.logger is not None: + self.logger.log( + log_dict, + step=self.step, + split="train", + ) + + if ( + checkpoint_every != -1 + and self.step % checkpoint_every == 0 + ): + self.save( + checkpoint_file="checkpoint.pt", training_state=True + ) + + # Evaluate on val set every `eval_every` iterations. + if self.step % eval_every == 0: + if self.val_loader is not None: + val_metrics = self.validate( + split="val", + disable_tqdm=disable_eval_tqdm, + ) + self.update_best( + primary_metric, + val_metrics, + disable_eval_tqdm=disable_eval_tqdm, + ) + + if self.config["task"].get("eval_relaxations", False): + if "relax_dataset" not in self.config["task"]: + logging.warning( + "Cannot evaluate relaxations, relax_dataset not specified" + ) + else: + self.run_relaxations() + + if self.scheduler.scheduler_type == "ReduceLROnPlateau": + if self.step % eval_every == 0: + self.scheduler.step( + metrics=val_metrics[primary_metric]["metric"], + ) + else: + self.scheduler.step() + + torch.cuda.empty_cache() + + if checkpoint_every == -1: + self.save(checkpoint_file="checkpoint.pt", training_state=True) + + self.train_dataset.close_db() + if self.config.get("val_dataset", False): + self.val_dataset.close_db() + if self.config.get("test_dataset", False): + self.test_dataset.close_db() + + def _forward(self, batch): + out = self.model(batch.to(self.device)) + + ### TOOD: Move into BaseModel in OCP 2.0 + outputs = {} + batch_size = batch.natoms.numel() + for target_key in self.config["outputs"]: + ### Target property is a direct output of the model + if target_key in out: + pred = out[target_key] + ## Target property is a derived output of the model. Construct the + ## parent property + else: + _max_rank = 0 + for subtarget_key in self.config["outputs"][target_key][ + "decomposition" + ]: + _max_rank = max( + _max_rank, + self.output_targets[subtarget_key]["irrep_dim"], + ) + + pred_irreps = torch.zeros( + (batch_size, irreps_sum(_max_rank)), device=self.device + ) + + for subtarget_key in self.config["outputs"][target_key][ + "decomposition" + ]: + irreps = self.output_targets[subtarget_key]["irrep_dim"] + _pred = out[subtarget_key] + + ## Fill in the corresponding irreps prediction + pred_irreps[ + :, + max(0, irreps_sum(irreps - 1)) : irreps_sum(irreps), + ] = _pred + + pred = torch.einsum( + "ba, cb->ca", + cg_change_mat(_max_rank, self.device), + pred_irreps, + ) + + ### not all models are consistent with the output shape + if len(pred.shape) > 1: + pred = pred.squeeze(1) + + outputs[target_key] = pred + + return outputs + + def _compute_loss(self, out, batch): + natoms = batch.natoms.to(self.device) + batch_size = natoms.numel() + natoms = torch.repeat_interleave(natoms, natoms) + + fixed = batch.fixed.to(self.device) + mask = fixed == 0 + + loss = [] + + for loss_fn in self.loss_fns: + target_name, loss_info = loss_fn + + target = batch[target_name].to(self.device) + pred = out[target_name] + + if self.output_targets[target_name].get( + "level", "system" + ) == "atom" and self.output_targets[target_name].get( + "train_on_free_atoms", True + ): + target = target[mask] + pred = pred[mask] + natoms = natoms[mask] + + if self.normalizers.get(target_name, False): + target = self.normalizers[target_name].norm(target) + + mult = loss_info["coefficient"] + + loss.append( + mult + * loss_info["fn"]( + pred, + target, + natoms=natoms, + batch_size=batch_size, + ) + ) + + # Sanity check to make sure the compute graph is correct. + for lc in loss: + assert hasattr(lc, "grad_fn") + + loss = sum(loss) + return loss + + def _compute_metrics(self, out, batch, evaluator, metrics={}): + natoms = batch.natoms.to(self.device) + + ### Retrieve free atoms + fixed = batch.fixed.to(self.device) + mask = fixed == 0 + + s_idx = 0 + natoms_free = [] + for _natoms in natoms: + natoms_free.append(torch.sum(mask[s_idx : s_idx + _natoms]).item()) + s_idx += _natoms + natoms = torch.LongTensor(natoms_free).to(self.device) + + targets = {} + for target_name in self.output_targets: + target = batch[target_name].to(self.device) + # Add parent target to targets + if "parent" in self.output_targets[target_name]: + parent_target_name = self.output_targets[target_name]["parent"] + + if parent_target_name not in targets: + parent_target = batch[parent_target_name].to(self.device) + targets[parent_target_name] = parent_target + + if self.output_targets[target_name].get( + "level", "system" + ) == "atom" and self.output_targets[target_name].get( + "eval_on_free_atoms", True + ): + target = target[mask] + out[target_name] = out[target_name][mask] + + targets[target_name] = target + if self.normalizers.get(target_name, False): + out[target_name] = self.normalizers[target_name].denorm( + out[target_name] + ) + + targets["natoms"] = natoms + out["natoms"] = natoms + + metrics = evaluator.eval(out, targets, prev_metrics=metrics) + return metrics + def run_relaxations(self, split="val"): ensure_fitted(self._unwrapped_model) From 2f793a8c85425e3e50b637fe0d1f58562938e479 Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Mon, 6 Nov 2023 17:14:46 -0800 Subject: [PATCH 47/63] include parent in targets --- ocpmodels/trainers/base_trainer.py | 11 +++++------ ocpmodels/trainers/ocp_trainer.py | 7 ++++--- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index 8ee19f398..46e04a8ba 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -371,11 +371,10 @@ def load_task(self): self.output_targets = {} for target_name in self.config["outputs"]: - if "decomposition" not in self.config["outputs"][target_name]: - self.output_targets[target_name] = self.config["outputs"][ - target_name - ] - else: + self.output_targets[target_name] = self.config["outputs"][ + target_name + ] + if "decomposition" in self.config["outputs"][target_name]: for subtarget in self.config["outputs"][target_name][ "decomposition" ]: @@ -407,7 +406,7 @@ def load_task(self): "eval_on_free_atoms", True ) - # TODO: Assert that all targets, loss fn, metrics defined and consistent + # TODO: Assert that all targets, loss fn, metrics defined are consistent self.evaluation_metrics = self.config.get("eval_metrics", {}) self.evaluator = Evaluator( task=self.name, diff --git a/ocpmodels/trainers/ocp_trainer.py b/ocpmodels/trainers/ocp_trainer.py index fc2514b7d..32d6e75bb 100644 --- a/ocpmodels/trainers/ocp_trainer.py +++ b/ocpmodels/trainers/ocp_trainer.py @@ -245,7 +245,7 @@ def _forward(self, batch): ### TOOD: Move into BaseModel in OCP 2.0 outputs = {} batch_size = batch.natoms.numel() - for target_key in self.config["outputs"]: + for target_key in self.output_targets: ### Target property is a direct output of the model if target_key in out: pred = out[target_key] @@ -253,7 +253,7 @@ def _forward(self, batch): ## parent property else: _max_rank = 0 - for subtarget_key in self.config["outputs"][target_key][ + for subtarget_key in self.output_targets[target_key][ "decomposition" ]: _max_rank = max( @@ -265,7 +265,7 @@ def _forward(self, batch): (batch_size, irreps_sum(_max_rank)), device=self.device ) - for subtarget_key in self.config["outputs"][target_key][ + for subtarget_key in self.output_targets[target_key][ "decomposition" ]: irreps = self.output_targets[subtarget_key]["irrep_dim"] @@ -284,6 +284,7 @@ def _forward(self, batch): ) ### not all models are consistent with the output shape + # TODO: Verify not an issue for high order predictions if len(pred.shape) > 1: pred = pred.squeeze(1) From 26179df3185a356eee4e01c8f9d9ba93e6fad3e6 Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Tue, 7 Nov 2023 13:30:18 -0800 Subject: [PATCH 48/63] shape flexibility --- ocpmodels/trainers/base_trainer.py | 139 ------------------- ocpmodels/trainers/ocp_trainer.py | 205 ++++++++++++++++++++++++----- 2 files changed, 174 insertions(+), 170 deletions(-) diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index 46e04a8ba..e69f46cce 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -18,7 +18,6 @@ import torch import torch.nn as nn import torch.optim as optim -import torch_geometric import yaml from torch.nn.parallel.distributed import DistributedDataParallel from torch.utils.data import DataLoader @@ -799,144 +798,6 @@ def _backward(self, loss) -> None: if self.ema: self.ema.update() - # Takes in a new data source and generates predictions on it. - @torch.no_grad() - def predict( - self, - data_loader, - per_image: bool = True, - results_file: Optional[str] = None, - disable_tqdm: bool = False, - ): - ensure_fitted(self._unwrapped_model, warn=True) - - if distutils.is_master() and not disable_tqdm: - logging.info("Predicting on test.") - assert isinstance( - data_loader, - ( - torch.utils.data.dataloader.DataLoader, - torch_geometric.data.Batch, - ), - ) - rank = distutils.get_rank() - - if isinstance(data_loader, torch_geometric.data.Batch): - data_loader = [data_loader] - - self.model.eval() - if self.ema is not None: - self.ema.store() - self.ema.copy_to() - - predictions = defaultdict(list) - - for i, batch in tqdm( - enumerate(data_loader), - total=len(data_loader), - position=rank, - desc="device {}".format(rank), - disable=disable_tqdm, - ): - - with torch.cuda.amp.autocast(enabled=self.scaler is not None): - out = self._forward(batch) - - for target_key in self.config["outputs"]: - pred = out[target_key] - if self.normalizers.get(target_key, False): - pred = self.normalizers[target_key].denorm(pred) - - if per_image: - ### Save outputs in desired precision, default float16 - if ( - self.config["outputs"][target_key].get( - "prediction_dtype", "float16" - ) - == "float32" - or self.config["task"].get( - "prediction_dtype", "float16" - ) - == "float32" - or self.config["task"].get("dataset", "lmdb") - == "oc22_lmdb" - ): - dtype = torch.float32 - else: - dtype = torch.float16 - - pred = pred.cpu().detach().to(dtype) - ### Split predictions into per-image predictions - if ( - self.config["outputs"][target_key].get( - "level", "system" - ) - == "atom" - ): - batch_natoms = batch.natoms - batch_fixed = batch.fixed - per_image_pred = torch.split( - pred, batch_natoms.tolist() - ) - - ### Save out only free atom, EvalAI does not need fixed atoms - _per_image_fixed = torch.split( - batch_fixed, batch_natoms.tolist() - ) - _per_image_free_preds = [ - _pred[(fixed == 0).tolist()].numpy() - for _pred, fixed in zip( - per_image_pred, _per_image_fixed - ) - ] - _chunk_idx = np.array( - [ - free_pred.shape[0] - for free_pred in _per_image_free_preds - ] - ) - per_image_pred = _per_image_free_preds - ### Assumes system level properties are of the same dimension - else: - per_image_pred = pred.numpy() - _chunk_idx = None - - predictions[f"{target_key}"].extend(per_image_pred) - ### Backwards compatibility, retain 'chunk_idx' for forces. - if _chunk_idx is not None: - if target_key == "forces": - predictions["chunk_idx"].extend(_chunk_idx) - else: - predictions[f"{target_key}_chunk_idx"].extend( - _chunk_idx - ) - else: - predictions[f"{target_key}"] = pred.detach() - - if not per_image: - return predictions - - ### Get unique system identifiers - sids = batch.sid.tolist() - ## Support naming structure for OC20 S2EF - if "fid" in batch: - fids = batch.fid.tolist() - systemids = [f"{sid}_{fid}" for sid, fid in zip(sids, fids)] - else: - systemids = [f"{sid}" for sid in sids] - - predictions["ids"].extend(systemids) - - for key in predictions: - predictions[key] = np.array(predictions[key]) - - self.save_results(predictions, results_file) - - if self.ema: - self.ema.restore() - - return predictions - def save_results( self, predictions, results_file: Optional[str], keys=None ) -> None: diff --git a/ocpmodels/trainers/ocp_trainer.py b/ocpmodels/trainers/ocp_trainer.py index 32d6e75bb..3ea5c3d95 100644 --- a/ocpmodels/trainers/ocp_trainer.py +++ b/ocpmodels/trainers/ocp_trainer.py @@ -8,9 +8,11 @@ import logging import os from collections import defaultdict +from typing import Optional import numpy as np import torch +import torch_geometric from tqdm import tqdm from ocpmodels.common import distutils @@ -245,6 +247,7 @@ def _forward(self, batch): ### TOOD: Move into BaseModel in OCP 2.0 outputs = {} batch_size = batch.natoms.numel() + num_atoms_in_batch = batch.natoms.sum() for target_key in self.output_targets: ### Target property is a direct output of the model if target_key in out: @@ -272,10 +275,11 @@ def _forward(self, batch): _pred = out[subtarget_key] ## Fill in the corresponding irreps prediction + ## Reshape irrep prediction to (batch_size, irrep_dim) pred_irreps[ :, max(0, irreps_sum(irreps - 1)) : irreps_sum(irreps), - ] = _pred + ] = _pred.view(batch_size, -1) pred = torch.einsum( "ba, cb->ca", @@ -284,44 +288,49 @@ def _forward(self, batch): ) ### not all models are consistent with the output shape - # TODO: Verify not an issue for high order predictions - if len(pred.shape) > 1: - pred = pred.squeeze(1) + ### reshape accordingly: num_atoms_in_batch, -1 or num_systems_in_batch, -1 + if self.output_targets[target_key]["level"] == "atom": + pred = pred.view(num_atoms_in_batch, -1) + else: + pred = pred.view(batch_size, -1) outputs[target_key] = pred return outputs def _compute_loss(self, out, batch): - natoms = batch.natoms.to(self.device) - batch_size = natoms.numel() - natoms = torch.repeat_interleave(natoms, natoms) - - fixed = batch.fixed.to(self.device) + batch_size = batch.natoms.numel() + fixed = batch.fixed mask = fixed == 0 loss = [] - for loss_fn in self.loss_fns: target_name, loss_info = loss_fn - target = batch[target_name].to(self.device) + target = batch[target_name] pred = out[target_name] + natoms = batch.natoms + natoms = torch.repeat_interleave(natoms, natoms) - if self.output_targets[target_name].get( - "level", "system" - ) == "atom" and self.output_targets[target_name].get( - "train_on_free_atoms", True + if ( + self.output_targets[target_name]["level"] == "atom" + and self.output_targets[target_name]["train_on_free_atoms"] ): target = target[mask] pred = pred[mask] natoms = natoms[mask] + num_atoms_in_batch = natoms.numel() if self.normalizers.get(target_name, False): target = self.normalizers[target_name].norm(target) - mult = loss_info["coefficient"] + ### reshape accordingly: num_atoms_in_batch, -1 or num_systems_in_batch, -1 + if self.output_targets[target_name]["level"] == "atom": + target = target.view(num_atoms_in_batch, -1) + else: + target = target.view(batch_size, -1) + mult = loss_info["coefficient"] loss.append( mult * loss_info["fn"]( @@ -340,10 +349,11 @@ def _compute_loss(self, out, batch): return loss def _compute_metrics(self, out, batch, evaluator, metrics={}): - natoms = batch.natoms.to(self.device) + natoms = batch.natoms + batch_size = natoms.numel() ### Retrieve free atoms - fixed = batch.fixed.to(self.device) + fixed = batch.fixed mask = fixed == 0 s_idx = 0 @@ -355,22 +365,22 @@ def _compute_metrics(self, out, batch, evaluator, metrics={}): targets = {} for target_name in self.output_targets: - target = batch[target_name].to(self.device) - # Add parent target to targets - if "parent" in self.output_targets[target_name]: - parent_target_name = self.output_targets[target_name]["parent"] - - if parent_target_name not in targets: - parent_target = batch[parent_target_name].to(self.device) - targets[parent_target_name] = parent_target - - if self.output_targets[target_name].get( - "level", "system" - ) == "atom" and self.output_targets[target_name].get( - "eval_on_free_atoms", True + target = batch[target_name] + num_atoms_in_batch = batch.natoms.sum() + + if ( + self.output_targets[target_name]["level"] == "atom" + and self.output_targets[target_name]["eval_on_free_atoms"] ): target = target[mask] out[target_name] = out[target_name][mask] + num_atoms_in_batch = natoms.sum() + + ### reshape accordingly: num_atoms_in_batch, -1 or num_systems_in_batch, -1 + if self.output_targets[target_name]["level"] == "atom": + target = target.view(num_atoms_in_batch, -1) + else: + target = target.view(batch_size, -1) targets[target_name] = target if self.normalizers.get(target_name, False): @@ -384,6 +394,139 @@ def _compute_metrics(self, out, batch, evaluator, metrics={}): metrics = evaluator.eval(out, targets, prev_metrics=metrics) return metrics + # Takes in a new data source and generates predictions on it. + @torch.no_grad() + def predict( + self, + data_loader, + per_image: bool = True, + results_file: Optional[str] = None, + disable_tqdm: bool = False, + ): + ensure_fitted(self._unwrapped_model, warn=True) + + if distutils.is_master() and not disable_tqdm: + logging.info("Predicting on test.") + assert isinstance( + data_loader, + ( + torch.utils.data.dataloader.DataLoader, + torch_geometric.data.Batch, + ), + ) + rank = distutils.get_rank() + + if isinstance(data_loader, torch_geometric.data.Batch): + data_loader = [data_loader] + + self.model.eval() + if self.ema is not None: + self.ema.store() + self.ema.copy_to() + + predictions = defaultdict(list) + + for i, batch in tqdm( + enumerate(data_loader), + total=len(data_loader), + position=rank, + desc="device {}".format(rank), + disable=disable_tqdm, + ): + + with torch.cuda.amp.autocast(enabled=self.scaler is not None): + out = self._forward(batch) + + for target_key in self.config["outputs"]: + pred = out[target_key] + if self.normalizers.get(target_key, False): + pred = self.normalizers[target_key].denorm(pred) + + if per_image: + ### Save outputs in desired precision, default float16 + if ( + self.config["outputs"][target_key].get( + "prediction_dtype", "float16" + ) + == "float32" + or self.config["task"].get( + "prediction_dtype", "float16" + ) + == "float32" + or self.config["task"].get("dataset", "lmdb") + == "oc22_lmdb" + ): + dtype = torch.float32 + else: + dtype = torch.float16 + + pred = pred.cpu().detach().to(dtype) + ### Split predictions into per-image predictions + if self.config["outputs"][target_key]["level"] == "atom": + batch_natoms = batch.natoms + batch_fixed = batch.fixed + per_image_pred = torch.split( + pred, batch_natoms.tolist() + ) + + ### Save out only free atom, EvalAI does not need fixed atoms + _per_image_fixed = torch.split( + batch_fixed, batch_natoms.tolist() + ) + _per_image_free_preds = [ + _pred[(fixed == 0).tolist()].numpy() + for _pred, fixed in zip( + per_image_pred, _per_image_fixed + ) + ] + _chunk_idx = np.array( + [ + free_pred.shape[0] + for free_pred in _per_image_free_preds + ] + ) + per_image_pred = _per_image_free_preds + ### Assumes system level properties are of the same dimension + else: + per_image_pred = pred.numpy() + _chunk_idx = None + + predictions[f"{target_key}"].extend(per_image_pred) + ### Backwards compatibility, retain 'chunk_idx' for forces. + if _chunk_idx is not None: + if target_key == "forces": + predictions["chunk_idx"].extend(_chunk_idx) + else: + predictions[f"{target_key}_chunk_idx"].extend( + _chunk_idx + ) + else: + predictions[f"{target_key}"] = pred.detach() + + if not per_image: + return predictions + + ### Get unique system identifiers + sids = batch.sid.tolist() + ## Support naming structure for OC20 S2EF + if "fid" in batch: + fids = batch.fid.tolist() + systemids = [f"{sid}_{fid}" for sid, fid in zip(sids, fids)] + else: + systemids = [f"{sid}" for sid in sids] + + predictions["ids"].extend(systemids) + + for key in predictions: + predictions[key] = np.array(predictions[key]) + + self.save_results(predictions, results_file) + + if self.ema: + self.ema.restore() + + return predictions + def run_relaxations(self, split="val"): ensure_fitted(self._unwrapped_model) From cc6c6c27110f401b74f71c52be6ed7e0f838d1e2 Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Tue, 7 Nov 2023 16:12:24 -0800 Subject: [PATCH 49/63] cleanup debug lines --- configs/is2re/all/base.yml | 2 +- ocpmodels/models/gemnet_oc/gemnet_oc.py | 17 +++-------------- 2 files changed, 4 insertions(+), 15 deletions(-) diff --git a/configs/is2re/all/base.yml b/configs/is2re/all/base.yml index cfd817ffc..cf61f8309 100755 --- a/configs/is2re/all/base.yml +++ b/configs/is2re/all/base.yml @@ -7,7 +7,7 @@ dataset: target_std: 2.279365062713623 - src: data/is2re/all/val_id/data.lmdb -logger: wandb +logger: tensorboard task: dataset: single_point_lmdb diff --git a/ocpmodels/models/gemnet_oc/gemnet_oc.py b/ocpmodels/models/gemnet_oc/gemnet_oc.py index a8486ad80..d6e0d8362 100644 --- a/ocpmodels/models/gemnet_oc/gemnet_oc.py +++ b/ocpmodels/models/gemnet_oc/gemnet_oc.py @@ -1323,6 +1323,8 @@ def forward(self, data): E_t, batch, dim=0, dim_size=nMolecules, reduce="mean" ) # (nMolecules, num_targets) + E_t = E_t.squeeze(1) # (num_molecules) + outputs = {"energy": E_t} if self.regress_forces: if self.direct_forces: if self.forces_coupled: # enforce F_st = F_ts @@ -1354,22 +1356,9 @@ def forward(self, data): else: F_t = self.force_scaler.calc_forces_and_update(E_t, pos) - E_t = E_t.squeeze(1) # (num_molecules) F_t = F_t.squeeze(1) # (num_atoms, 3) - outputs = { - "energy": E_t, - "forces": F_t, - "isotropic_stress": torch.rand( - (E_t.numel(), 1), device=E_t.device - ), - "anisotropic_stress": torch.rand( - (E_t.numel(), 5), device=E_t.device - ), - } - else: - E_t = E_t.squeeze(1) # (num_molecules) - outputs = {"y": E_t} + outputs["forces"] = F_t return outputs From d2bdc6e383ebcf65f5306e53355bee91fc952105 Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Tue, 7 Nov 2023 17:03:18 -0800 Subject: [PATCH 50/63] cleanup --- ocpmodels/trainers/base_trainer.py | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-) diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index e69f46cce..426ae8a57 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -11,7 +11,7 @@ import random from abc import ABC from collections import defaultdict -from typing import Any, DefaultDict, Dict, Optional +from typing import DefaultDict, Dict, Optional import numpy as np import numpy.typing as npt @@ -48,15 +48,6 @@ @registry.register_trainer("base") class BaseTrainer(ABC): - train_loader: DataLoader[Any] - val_loader: DataLoader[Any] - test_loader: DataLoader[Any] - device: torch.device - output_targets: Dict[str, Any] - ema: Optional[ExponentialMovingAverage] - clip_grad_norm: float - ema_decay: float - def __init__( self, task, From 9984ae7618ba87d4d6e08537f68545f23f36150f Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Tue, 14 Nov 2023 15:51:40 -0800 Subject: [PATCH 51/63] normalizer bugfix for new configs --- ocpmodels/trainers/base_trainer.py | 6 ++++-- ocpmodels/trainers/ocp_trainer.py | 5 ++++- 2 files changed, 8 insertions(+), 3 deletions(-) diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index 426ae8a57..62ece8107 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -350,9 +350,11 @@ def load_datasets(self) -> None: def load_task(self): # Normalizer for the dataset. + normalizer = ( + self.config["dataset"].get("transforms", {}).get("normalizer", {}) + ) self.normalizers = {} - if "normalizer" in self.config["dataset"]: - normalizer = self.config["dataset"]["normalizer"] + if normalizer: for target in normalizer: self.normalizers[target] = Normalizer( mean=normalizer[target].get("mean", 0), diff --git a/ocpmodels/trainers/ocp_trainer.py b/ocpmodels/trainers/ocp_trainer.py index 3ea5c3d95..812f68fa9 100644 --- a/ocpmodels/trainers/ocp_trainer.py +++ b/ocpmodels/trainers/ocp_trainer.py @@ -244,7 +244,7 @@ def train(self, disable_eval_tqdm: bool = False) -> None: def _forward(self, batch): out = self.model(batch.to(self.device)) - ### TOOD: Move into BaseModel in OCP 2.0 + ### TODO: Move into BaseModel in OCP 2.0 outputs = {} batch_size = batch.natoms.numel() num_atoms_in_batch = batch.natoms.sum() @@ -274,6 +274,9 @@ def _forward(self, batch): irreps = self.output_targets[subtarget_key]["irrep_dim"] _pred = out[subtarget_key] + if self.normalizers.get(subtarget_key, False): + _pred = self.normalizers[subtarget_key].denorm(_pred) + ## Fill in the corresponding irreps prediction ## Reshape irrep prediction to (batch_size, irrep_dim) pred_irreps[ From d278b6e81021f97e942bd837cb8613fdc387f9ba Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Fri, 17 Nov 2023 09:36:48 -0800 Subject: [PATCH 52/63] calculator normalization fix, backwards support for ckpt loads --- ocpmodels/common/utils.py | 5 ++++- ocpmodels/trainers/base_trainer.py | 17 +++++++++++++---- 2 files changed, 17 insertions(+), 5 deletions(-) diff --git a/ocpmodels/common/utils.py b/ocpmodels/common/utils.py index 354dd86fd..53b497e32 100644 --- a/ocpmodels/common/utils.py +++ b/ocpmodels/common/utils.py @@ -1304,7 +1304,10 @@ def update_config(base_config): "stdev": config["dataset"].get("grad_target_std", 1), }, } - config["dataset"]["normalizer"] = normalizer + + transforms = config["dataset"].get("transforms", {}) + transforms["normalizer"] = normalizer + config["dataset"]["transforms"] = transforms ### Update config config.update({"loss_fns": _loss_fns}) diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index 62ece8107..ea46c024a 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -515,12 +515,21 @@ def load_checkpoint( load_scales_compat(self._unwrapped_model, scale_dict) for key in checkpoint["normalizers"]: - if key in self.normalizers: - self.normalizers[key].load_state_dict( + ### Convert old normalizer keys to new target keys + if key == "target": + target_key = "energy" + elif key == "grad_target": + target_key = "forces" + else: + target_key = key + + if target_key in self.normalizers: + self.normalizers[target_key].load_state_dict( checkpoint["normalizers"][key] ) - if self.scaler and checkpoint["amp"]: - self.scaler.load_state_dict(checkpoint["amp"]) + + if self.scaler and checkpoint["amp"]: + self.scaler.load_state_dict(checkpoint["amp"]) def load_loss(self) -> None: self.loss_fns = [] From caf611f37017ddf1d17c274d5aca605496521b92 Mon Sep 17 00:00:00 2001 From: Abhishek Das Date: Mon, 11 Dec 2023 02:38:14 -0800 Subject: [PATCH 53/63] New weight_decay config -- defaults in BaseModel, extendable by others (e.g. EqV2) --- ocpmodels/models/base.py | 9 ++ .../equiformer_v2/equiformer_v2_oc20.py | 34 +++---- .../equiformer_v2/trainers/energy_trainer.py | 97 ------------------- .../equiformer_v2/trainers/forces_trainer.py | 93 ------------------ ocpmodels/trainers/base_trainer.py | 61 +++++++----- 5 files changed, 60 insertions(+), 234 deletions(-) diff --git a/ocpmodels/models/base.py b/ocpmodels/models/base.py index e87bd5a3f..4caad21c2 100644 --- a/ocpmodels/models/base.py +++ b/ocpmodels/models/base.py @@ -125,3 +125,12 @@ def generate_graph( @property def num_params(self) -> int: return sum(p.numel() for p in self.parameters()) + + @torch.jit.ignore + def no_weight_decay(self) -> list: + """Returns a list of parameters with no weight decay.""" + no_wd_list = [] + for name, _ in self.named_parameters(): + if "embedding" in name or "frequencies" in name or "bias" in name: + no_wd_list.append(name) + return no_wd_list diff --git a/ocpmodels/models/equiformer_v2/equiformer_v2_oc20.py b/ocpmodels/models/equiformer_v2/equiformer_v2_oc20.py index 79b1372c2..93598b6d7 100644 --- a/ocpmodels/models/equiformer_v2/equiformer_v2_oc20.py +++ b/ocpmodels/models/equiformer_v2/equiformer_v2_oc20.py @@ -579,33 +579,29 @@ def _uniform_init_linear_weights(self, m): torch.nn.init.uniform_(m.weight, -std, std) @torch.jit.ignore - def no_weight_decay(self): + def no_weight_decay(self) -> set: no_wd_list = [] named_parameters_list = [name for name, _ in self.named_parameters()] for module_name, module in self.named_modules(): - if ( - isinstance(module, torch.nn.Linear) - or isinstance(module, SO3_LinearV2) - or isinstance(module, torch.nn.LayerNorm) - or isinstance(module, EquivariantLayerNormArray) - or isinstance( - module, EquivariantLayerNormArraySphericalHarmonics - ) - or isinstance( - module, EquivariantRMSNormArraySphericalHarmonics - ) - or isinstance( - module, EquivariantRMSNormArraySphericalHarmonicsV2 - ) - or isinstance(module, GaussianRadialBasisLayer) + if isinstance( + module, + ( + torch.nn.Linear, + SO3_LinearV2, + torch.nn.LayerNorm, + EquivariantLayerNormArray, + EquivariantLayerNormArraySphericalHarmonics, + EquivariantRMSNormArraySphericalHarmonics, + EquivariantRMSNormArraySphericalHarmonicsV2, + GaussianRadialBasisLayer, + ), ): for parameter_name, _ in module.named_parameters(): - if isinstance(module, torch.nn.Linear) or isinstance( - module, SO3_LinearV2 - ): + if isinstance(module, (torch.nn.Linear, SO3_LinearV2)): if "weight" in parameter_name: continue global_parameter_name = module_name + "." + parameter_name assert global_parameter_name in named_parameters_list no_wd_list.append(global_parameter_name) + return set(no_wd_list) diff --git a/ocpmodels/models/equiformer_v2/trainers/energy_trainer.py b/ocpmodels/models/equiformer_v2/trainers/energy_trainer.py index a39e6fa83..f868dcfe6 100644 --- a/ocpmodels/models/equiformer_v2/trainers/energy_trainer.py +++ b/ocpmodels/models/equiformer_v2/trainers/energy_trainer.py @@ -5,12 +5,7 @@ LICENSE file in the root directory of this source tree. """ -import logging -import torch.optim as optim -from torch.nn.parallel.distributed import DistributedDataParallel - -from ocpmodels.common import distutils from ocpmodels.common.registry import registry from ocpmodels.modules.exponential_moving_average import ( ExponentialMovingAverage, @@ -20,104 +15,12 @@ from .lr_scheduler import LRScheduler -def add_weight_decay(model, weight_decay, skip_list=()): - decay = [] - no_decay = [] - name_no_wd = [] - for name, param in model.named_parameters(): - if not param.requires_grad: - continue # frozen weights - if ( - name.endswith(".bias") - or name.endswith(".affine_weight") - or name.endswith(".affine_bias") - or name.endswith(".mean_shift") - or "bias." in name - or any(name.endswith(skip_name) for skip_name in skip_list) - ): - no_decay.append(param) - name_no_wd.append(name) - else: - decay.append(param) - name_no_wd.sort() - params = [ - {"params": no_decay, "weight_decay": 0.0}, - {"params": decay, "weight_decay": weight_decay}, - ] - return params, name_no_wd - - @registry.register_trainer("equiformerv2_energy") class EquiformerV2EnergyTrainer(OCPTrainer): # This trainer does a few things differently from the parent energy trainer: - # - When loading the model, it has a different way of setting up the params - # with no weight decay. - # - Similar changes in the optimizer setup. # - When using the scheduler, it first converts the epochs into number of # steps and then passes it to the scheduler. That way in the config # everything can be specified in terms of epochs. - def load_model(self): - print("[EquiformerV2EnergyTrainer] Loading model") - # Build model - if distutils.is_master(): - logging.info(f"Loading model: {self.config['model']}") - - # TODO: depreicated, remove. - bond_feat_dim = None - bond_feat_dim = self.config["model_attributes"].get( - "num_gaussians", 50 - ) - - loader = self.train_loader or self.val_loader or self.test_loader - self.model = registry.get_model_class(self.config["model"])( - loader.dataset[0].x.shape[-1] - if loader - and hasattr(loader.dataset[0], "x") - and loader.dataset[0].x is not None - else None, - bond_feat_dim, - self.num_targets, - **self.config["model_attributes"], - ).to(self.device) - - # for no weight decay - self.model_params_no_wd = {} - if hasattr(self.model, "no_weight_decay"): - self.model_params_no_wd = self.model.no_weight_decay() - - if distutils.is_master(): - logging.info( - f"Loaded {self.model.__class__.__name__} with " - f"{self.model.num_params} parameters." - ) - - if self.logger is not None: - self.logger.watch(self.model) - - self.model.to(self.device) - if distutils.initialized() and not self.config["noddp"]: - self.model = DistributedDataParallel( - self.model, device_ids=[self.device] - ) - - def load_optimizer(self): - optimizer = self.config["optim"].get("optimizer", "AdamW") - optimizer = getattr(optim, optimizer) - optimizer_params = self.config["optim"]["optimizer_params"] - weight_decay = optimizer_params["weight_decay"] - - parameters, name_no_wd = add_weight_decay( - self.model, weight_decay, self.model_params_no_wd - ) - logging.info("Parameters without weight decay:") - logging.info(name_no_wd) - - self.optimizer = optimizer( - parameters, - lr=self.config["optim"]["lr_initial"], - **optimizer_params, - ) - def load_extras(self): def multiply(obj, num): if isinstance(obj, list): diff --git a/ocpmodels/models/equiformer_v2/trainers/forces_trainer.py b/ocpmodels/models/equiformer_v2/trainers/forces_trainer.py index b8a58d3ba..44dc9818e 100755 --- a/ocpmodels/models/equiformer_v2/trainers/forces_trainer.py +++ b/ocpmodels/models/equiformer_v2/trainers/forces_trainer.py @@ -7,10 +7,6 @@ import logging -import torch.optim as optim -from torch.nn.parallel.distributed import DistributedDataParallel - -from ocpmodels.common import distutils from ocpmodels.common.registry import registry from ocpmodels.modules.exponential_moving_average import ( ExponentialMovingAverage, @@ -20,102 +16,13 @@ from .lr_scheduler import LRScheduler -def add_weight_decay(model, weight_decay, skip_list=()): - decay = [] - no_decay = [] - name_no_wd = [] - for name, param in model.named_parameters(): - if not param.requires_grad: - continue # frozen weights - if ( - name.endswith(".bias") - or name.endswith(".affine_weight") - or name.endswith(".affine_bias") - or name.endswith(".mean_shift") - or "bias." in name - or any(name.endswith(skip_name) for skip_name in skip_list) - ): - no_decay.append(param) - name_no_wd.append(name) - else: - decay.append(param) - name_no_wd.sort() - params = [ - {"params": no_decay, "weight_decay": 0.0}, - {"params": decay, "weight_decay": weight_decay}, - ] - return params, name_no_wd - - @registry.register_trainer("equiformerv2_forces") class EquiformerV2ForcesTrainer(OCPTrainer): # This trainer does a few things differently from the parent forces trainer: - # - Different way of setting up model parameters with no weight decay. # - Support for cosine LR scheduler. # - When using the LR scheduler, it first converts the epochs into number of # steps and then passes it to the scheduler. That way in the config # everything can be specified in terms of epochs. - def load_model(self) -> None: - # Build model - if distutils.is_master(): - logging.info(f"Loading model: {self.config['model']}") - - # TODO: depreicated, remove. - bond_feat_dim = None - bond_feat_dim = self.config["model_attributes"].get( - "num_gaussians", 50 - ) - - loader = self.train_loader or self.val_loader or self.test_loader - self.model = registry.get_model_class(self.config["model"])( - loader.dataset[0].x.shape[-1] - if loader - and hasattr(loader.dataset[0], "x") - and loader.dataset[0].x is not None - else None, - bond_feat_dim, - 1, - **self.config["model_attributes"], - ).to(self.device) - - # for no weight decay - self.model_params_no_wd = {} - if hasattr(self.model, "no_weight_decay"): - self.model_params_no_wd = self.model.no_weight_decay() - - if distutils.is_master(): - logging.info( - f"Loaded {self.model.__class__.__name__} with " - f"{self.model.num_params} parameters." - ) - - if self.logger is not None: - self.logger.watch(self.model) - - self.model.to(self.device) - if distutils.initialized() and not self.config["noddp"]: - self.model = DistributedDataParallel( - self.model, device_ids=[self.device] - ) - - def load_optimizer(self) -> None: - optimizer = self.config["optim"].get("optimizer", "AdamW") - optimizer = getattr(optim, optimizer) - optimizer_params = self.config["optim"]["optimizer_params"] - weight_decay = optimizer_params["weight_decay"] - - parameters, name_no_wd = add_weight_decay( - self.model, weight_decay, self.model_params_no_wd - ) - logging.info("Parameters without weight decay:") - logging.info(name_no_wd) - - self.optimizer = optimizer( - parameters, - lr=self.config["optim"]["lr_initial"], - **optimizer_params, - ) - def load_extras(self) -> None: def multiply(obj, num): if isinstance(obj, list): diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index ea46c024a..a30e7382e 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -17,7 +17,6 @@ import numpy.typing as npt import torch import torch.nn as nn -import torch.optim as optim import yaml from torch.nn.parallel.distributed import DistributedDataParallel from torch.utils.data import DataLoader @@ -71,7 +70,6 @@ def __init__( slurm={}, noddp: bool = False, ) -> None: - self.name = name self.is_debug = is_debug self.cpu = cpu @@ -553,40 +551,54 @@ def load_loss(self) -> None: ) def load_optimizer(self) -> None: - optimizer = self.config["optim"].get("optimizer", "AdamW") - optimizer = getattr(optim, optimizer) + optimizer = getattr( + torch.optim, self.config["optim"].get("optimizer", "AdamW") + ) + optimizer_params = self.config["optim"].get("optimizer_params", {}) + + weight_decay = optimizer_params.get("weight_decay", 0) + assert ( + "weight_decay" not in self.config["optim"] + ), "`weight_decay` should be specified in `optim.optimizer_params`." + + if weight_decay > 0: + self.model_params_no_wd = {} + if hasattr(self._unwrapped_model, "no_weight_decay"): + self.model_params_no_wd = ( + self._unwrapped_model.no_weight_decay() + ) - if self.config["optim"].get("weight_decay", 0) > 0: - # Do not regularize bias etc. - params_decay = [] - params_no_decay = [] + params_decay, params_no_decay, name_no_decay = [], [], [] for name, param in self.model.named_parameters(): - if param.requires_grad: - if "embedding" in name: - params_no_decay += [param] - elif "frequencies" in name: - params_no_decay += [param] - elif "bias" in name: - params_no_decay += [param] - else: - params_decay += [param] + if not param.requires_grad: + continue + + if any( + name.endswith(skip_name) + for skip_name in self.model_params_no_wd + ): + params_no_decay.append(param) + name_no_decay.append(name) + else: + params_decay.append(param) + + if distutils.is_master(): + logging.info("Parameters without weight decay:") + logging.info(name_no_decay) self.optimizer = optimizer( - [ + params=[ {"params": params_no_decay, "weight_decay": 0}, - { - "params": params_decay, - "weight_decay": self.config["optim"]["weight_decay"], - }, + {"params": params_decay, "weight_decay": weight_decay}, ], lr=self.config["optim"]["lr_initial"], - **self.config["optim"].get("optimizer_params", {}), + **optimizer_params, ) else: self.optimizer = optimizer( params=self.model.parameters(), lr=self.config["optim"]["lr_initial"], - **self.config["optim"].get("optimizer_params", {}), + **optimizer_params, ) def load_extras(self) -> None: @@ -803,7 +815,6 @@ def _backward(self, loss) -> None: def save_results( self, predictions, results_file: Optional[str], keys=None ) -> None: - if results_file is None: return if keys is None: From e7e22828a1838b086b64e90deb07aa18dead0e03 Mon Sep 17 00:00:00 2001 From: Abhishek Das Date: Mon, 11 Dec 2023 02:54:38 -0800 Subject: [PATCH 54/63] Doc update --- DATASET.md | 12 ++++++------ MODELS.md | 14 +++++++------- README.md | 20 +++++++++++++------- 3 files changed, 26 insertions(+), 20 deletions(-) diff --git a/DATASET.md b/DATASET.md index 3026df613..7106492aa 100644 --- a/DATASET.md +++ b/DATASET.md @@ -340,7 +340,7 @@ Please consider citing the following paper in any research manuscript using the -``` +```bibtex @article{ocp_dataset, author = {Chanussot*, Lowik and Das*, Abhishek and Goyal*, Siddharth and Lavril*, Thibaut and Shuaibi*, Muhammed and Riviere, Morgane and Tran, Kevin and Heras-Domingo, Javier and Ho, Caleb and Hu, Weihua and Palizhati, Aini and Sriram, Anuroop and Wood, Brandon and Yoon, Junwoong and Parikh, Devi and Zitnick, C. Lawrence and Ulissi, Zachary}, title = {Open Catalyst 2020 (OC20) Dataset and Community Challenges}, @@ -462,12 +462,12 @@ The Open Catalyst 2022 (OC22) dataset is licensed under a [Creative Commons Attr Please consider citing the following paper in any research manuscript using the OC22 dataset: -``` +```bibtex @article{oc22_dataset, author = {Tran*, Richard and Lan*, Janice and Shuaibi*, Muhammed and Wood*, Brandon and Goyal*, Siddharth and Das, Abhishek and Heras-Domingo, Javier and Kolluru, Adeesh and Rizvi, Ammar and Shoghi, Nima and Sriram, Anuroop and Ulissi, Zachary and Zitnick, C. Lawrence}, - title = {The Open Catalyst 2022 (OC22) Dataset and Challenges for Oxide Electrocatalysis}, - year = {2022}, - journal={arXiv preprint arXiv:2206.08917}, + title = {The Open Catalyst 2022 (OC22) dataset and challenges for oxide electrocatalysts}, + journal = {ACS Catalysis}, + year={2023}, } ``` @@ -503,7 +503,7 @@ The OpenDAC 2023 (ODAC23) dataset is licensed under a [Creative Commons Attribut Please consider citing the following paper in any research manuscript using the ODAC23 dataset: -``` +```bibtex @article{odac23_dataset, author = {Anuroop Sriram and Sihoon Choi and Xiaohan Yu and Logan M. Brabson and Abhishek Das and Zachary Ulissi and Matt Uyttendaele and Andrew J. Medford and David S. Sholl}, title = {The Open DAC 2023 Dataset and Challenges for Sorbent Discovery in Direct Air Capture}, diff --git a/MODELS.md b/MODELS.md index d24b34dfe..4baaef070 100644 --- a/MODELS.md +++ b/MODELS.md @@ -93,7 +93,7 @@ The Open Catalyst 2020 (OC20) dataset is licensed under a [Creative Commons Attr Please consider citing the following paper in any research manuscript using the OC20 dataset or pretrained models, as well as the original paper for each model: -``` +```bibtex @article{ocp_dataset, author = {Chanussot*, Lowik and Das*, Abhishek and Goyal*, Siddharth and Lavril*, Thibaut and Shuaibi*, Muhammed and Riviere, Morgane and Tran, Kevin and Heras-Domingo, Javier and Ho, Caleb and Hu, Weihua and Palizhati, Aini and Sriram, Anuroop and Wood, Brandon and Yoon, Junwoong and Parikh, Devi and Zitnick, C. Lawrence and Ulissi, Zachary}, title = {Open Catalyst 2020 (OC20) Dataset and Community Challenges}, @@ -126,12 +126,12 @@ The Open Catalyst 2022 (OC22) dataset is licensed under a [Creative Commons Attr Please consider citing the following paper in any research manuscript using the OC22 dataset or pretrained models, as well as the original paper for each model: -``` +```bibtex @article{oc22_dataset, author = {Tran*, Richard and Lan*, Janice and Shuaibi*, Muhammed and Wood*, Brandon and Goyal*, Siddharth and Das, Abhishek and Heras-Domingo, Javier and Kolluru, Adeesh and Rizvi, Ammar and Shoghi, Nima and Sriram, Anuroop and Ulissi, Zachary and Zitnick, C. Lawrence}, - title = {The Open Catalyst 2022 (OC22) Dataset and Challenges for Oxide Electrocatalysis}, - year = {2022}, - journal = {arXiv preprint arXiv:2206.08917}, + title = {The Open Catalyst 2022 (OC22) dataset and challenges for oxide electrocatalysts}, + journal = {ACS Catalysis}, + year={2023}, } ``` @@ -150,7 +150,7 @@ OC22 dataset or pretrained models, as well as the original paper for each model: |eSCN | [checkpoint](https://dl.fbaipublicfiles.com/dac/checkpoints_20231018/eSCN.pt) | [config](https://github.com/Open-Catalyst-Project/ocp/tree/main/configs/odac/s2ef/eSCN.yml) | |EquiformerV2 | [checkpoint](https://dl.fbaipublicfiles.com/dac/checkpoints_20231018/Equiformer_V2.pt) | [config](https://github.com/Open-Catalyst-Project/ocp/tree/main/configs/odac/s2ef/eqv2_31M.yml) | |EquiformerV2 (Large) | [checkpoint](https://dl.fbaipublicfiles.com/dac/checkpoints_20231018/Equiformer_V2_Large.pt) | [config](https://github.com/Open-Catalyst-Project/ocp/tree/main/configs/odac/s2ef/eqv2_153M.yml) | - + ## IS2RE Direct models |Model |Checkpoint | Config | @@ -163,7 +163,7 @@ The Open DAC 2023 (ODAC23) dataset is licensed under a [Creative Commons Attribu Please consider citing the following paper in any research manuscript using the ODAC23 dataset: -``` +```bibtex @article{odac23_dataset, author = {Anuroop Sriram and Sihoon Choi and Xiaohan Yu and Logan M. Brabson and Abhishek Das and Zachary Ulissi and Matt Uyttendaele and Andrew J. Medford and David S. Sholl}, title = {The Open DAC 2023 Dataset and Challenges for Sorbent Discovery in Direct Air Capture}, diff --git a/README.md b/README.md index 94d238d72..d2271dc2a 100644 --- a/README.md +++ b/README.md @@ -11,28 +11,34 @@ library of state-of-the-art machine learning algorithms for catalysis. It provides training and evaluation code for tasks and models that take arbitrary -chemical structures as input to predict energies / forces / positions, and can -be used as a base scaffold for research projects. For an overview of tasks, data, and metrics, please read our papers: +chemical structures as input to predict energies / forces / positions / stresses, +and can be used as a base scaffold for research projects. For an overview of +tasks, data, and metrics, please read our papers: - [OC20](https://arxiv.org/abs/2010.09990) - [OC22](https://arxiv.org/abs/2206.08917) - [ODAC23](https://arxiv.org/abs/2311.00341) -Projects developed on `ocp`: +Projects and models built on `ocp`: -- CGCNN [[`arXiv`](https://arxiv.org/abs/1710.10324)] [[`code`](https://github.com/Open-Catalyst-Project/ocp/blob/main/ocpmodels/models/cgcnn.py)] - SchNet [[`arXiv`](https://arxiv.org/abs/1706.08566)] [[`code`](https://github.com/Open-Catalyst-Project/ocp/blob/main/ocpmodels/models/schnet.py)] -- DimeNet [[`arXiv`](https://arxiv.org/abs/2003.03123)] [[`code`](https://github.com/Open-Catalyst-Project/ocp/blob/main/ocpmodels/models/dimenet.py)] -- ForceNet [[`arXiv`](https://arxiv.org/abs/2103.01436)] [[`code`](https://github.com/Open-Catalyst-Project/ocp/blob/main/ocpmodels/models/forcenet.py)] - DimeNet++ [[`arXiv`](https://arxiv.org/abs/2011.14115)] [[`code`](https://github.com/Open-Catalyst-Project/ocp/blob/main/ocpmodels/models/dimenet_plus_plus.py)] -- SpinConv [[`arXiv`](https://arxiv.org/abs/2106.09575)] [[`code`](https://github.com/Open-Catalyst-Project/ocp/blob/main/ocpmodels/models/spinconv.py)] - GemNet-dT [[`arXiv`](https://arxiv.org/abs/2106.08903)] [[`code`](https://github.com/Open-Catalyst-Project/ocp/tree/main/ocpmodels/models/gemnet)] - PaiNN [[`arXiv`](https://arxiv.org/abs/2102.03150)] [[`code`](https://github.com/Open-Catalyst-Project/ocp/tree/main/ocpmodels/models/painn)] - Graph Parallelism [[`arXiv`](https://arxiv.org/abs/2203.09697)] [[`code`](https://github.com/Open-Catalyst-Project/ocp/tree/main/ocpmodels/models/gemnet_gp)] - GemNet-OC [[`arXiv`](https://arxiv.org/abs/2204.02782)] [[`code`](https://github.com/Open-Catalyst-Project/ocp/tree/main/ocpmodels/models/gemnet_oc)] - SCN [[`arXiv`](https://arxiv.org/abs/2206.14331)] [[`code`](https://github.com/Open-Catalyst-Project/ocp/tree/main/ocpmodels/models/scn)] +- AdsorbML [[`arXiv`](https://arxiv.org/abs/2211.16486)] [[`code`](https://github.com/open-catalyst-project/adsorbml)] - eSCN [[`arXiv`](https://arxiv.org/abs/2302.03655)] [[`code`](https://github.com/Open-Catalyst-Project/ocp/tree/main/ocpmodels/models/escn)] - EquiformerV2 [[`arXiv`](https://arxiv.org/abs/2306.12059)] [[`code`](https://github.com/Open-Catalyst-Project/ocp/tree/main/ocpmodels/models/equiformer_v2)] +Older model implementations that are no longer supported: + +- CGCNN [[`arXiv`](https://arxiv.org/abs/1710.10324)] [[`code`](https://github.com/Open-Catalyst-Project/ocp/blob/e7a8745eb307e8a681a1aa9d30c36e8c41e9457e/ocpmodels/models/cgcnn.py)] +- DimeNet [[`arXiv`](https://arxiv.org/abs/2003.03123)] [[`code`](https://github.com/Open-Catalyst-Project/ocp/blob/e7a8745eb307e8a681a1aa9d30c36e8c41e9457e/ocpmodels/models/dimenet.py)] +- SpinConv [[`arXiv`](https://arxiv.org/abs/2106.09575)] [[`code`](https://github.com/Open-Catalyst-Project/ocp/blob/e7a8745eb307e8a681a1aa9d30c36e8c41e9457e/ocpmodels/models/spinconv.py)] +- ForceNet [[`arXiv`](https://arxiv.org/abs/2103.01436)] [[`code`](https://github.com/Open-Catalyst-Project/ocp/blob/e7a8745eb307e8a681a1aa9d30c36e8c41e9457e/ocpmodels/models/forcenet.py)] + + ## Installation See [installation instructions](https://github.com/Open-Catalyst-Project/ocp/blob/main/INSTALL.md). From af0672377a07ac9341b84e2e6a2bf03fe5e617d1 Mon Sep 17 00:00:00 2001 From: Abhishek Das Date: Mon, 11 Dec 2023 03:06:13 -0800 Subject: [PATCH 55/63] Throw a warning instead of a hard error for optim.weight_decay --- ocpmodels/trainers/base_trainer.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/ocpmodels/trainers/base_trainer.py b/ocpmodels/trainers/base_trainer.py index a30e7382e..6f5d6c972 100644 --- a/ocpmodels/trainers/base_trainer.py +++ b/ocpmodels/trainers/base_trainer.py @@ -557,9 +557,13 @@ def load_optimizer(self) -> None: optimizer_params = self.config["optim"].get("optimizer_params", {}) weight_decay = optimizer_params.get("weight_decay", 0) - assert ( - "weight_decay" not in self.config["optim"] - ), "`weight_decay` should be specified in `optim.optimizer_params`." + if "weight_decay" in self.config["optim"]: + weight_decay = self.config["optim"]["weight_decay"] + logging.warning( + "Using `weight_decay` from `optim` instead of `optim.optimizer_params`." + "Please update your config to use `optim.optimizer_params.weight_decay`." + "`optim.weight_decay` will soon be deprecated." + ) if weight_decay > 0: self.model_params_no_wd = {} From ccda09f4af9f6c8ec1ec6a1c2bc42fb715c734ba Mon Sep 17 00:00:00 2001 From: Abhishek Das Date: Mon, 11 Dec 2023 03:08:52 -0800 Subject: [PATCH 56/63] EqV2 readme update --- ocpmodels/models/equiformer_v2/README.md | 1 - 1 file changed, 1 deletion(-) diff --git a/ocpmodels/models/equiformer_v2/README.md b/ocpmodels/models/equiformer_v2/README.md index 4768984c0..ea1386471 100644 --- a/ocpmodels/models/equiformer_v2/README.md +++ b/ocpmodels/models/equiformer_v2/README.md @@ -60,7 +60,6 @@ the training / validation scripts provided in the [official EquiformerV2 codebas might be easier to get started. * We provide a [slightly modified trainer](https://github.com/Open-Catalyst-Project/ocp/blob/main/ocpmodels/models/equiformer_v2/trainers/forces_trainer.py) and LR scheduler. The differences from the parent `forces` trainer are the following: - - Different way of setting up model parameters with no weight decay. - Support for cosine LR scheduler. - When using the LR scheduler, it first converts the epochs into number of steps and then passes it to the scheduler. That way in the config From e11dba6e6925b991d48c436db880f52b3ae6eb2f Mon Sep 17 00:00:00 2001 From: Abhishek Das Date: Mon, 11 Dec 2023 03:35:24 -0800 Subject: [PATCH 57/63] Config update --- configs/is2re/all/painn/painn_h1024_bs8x4.yml | 5 ++- configs/is2re/example.yml | 7 +-- configs/oc22/is2re/painn/painn.yml | 5 ++- configs/oc22/s2ef/gemnet-oc/gemnet_oc.yml | 5 ++- .../s2ef/gemnet-oc/gemnet_oc_finetune.yml | 5 ++- .../s2ef/gemnet-oc/gemnet_oc_oc20_oc22.yml | 5 ++- .../gemnet_oc_oc20_oc22_degen_edges.yml | 5 ++- configs/oc22/s2ef/painn/painn.yml | 5 ++- configs/oc22/s2ef/spinconv/spinconv.yml | 43 ------------------- .../oc22/s2ef/spinconv/spinconv_finetune.yml | 36 ---------------- configs/oc22/s2ef/spinconv/spinconv_joint.yml | 37 ---------------- configs/odac/is2re/eSCN.yml | 7 +-- configs/odac/is2re/gemnet-oc.yml | 5 ++- configs/odac/s2ef/eSCN.yml | 5 ++- configs/odac/s2ef/gemnet-oc.yml | 5 ++- configs/odac/s2ef/painn.yml | 5 ++- configs/odac/s2ef/schnet.yml | 3 +- configs/s2ef/200k/gemnet/gemnet-oc.yml | 5 ++- configs/s2ef/20M/gemnet/gemnet-oc.yml | 5 ++- configs/s2ef/2M/gemnet/gemnet-oc.yml | 7 ++- configs/s2ef/all/gemnet/gemnet-oc-large.yml | 5 ++- configs/s2ef/all/gemnet/gemnet-oc.yml | 5 ++- configs/s2ef/all/gp_gemnet/gp-gemnet-xl.yml | 5 ++- configs/s2ef/all/painn/painn_h512.yml | 5 ++- configs/s2ef/example.yml | 7 +-- 25 files changed, 68 insertions(+), 164 deletions(-) delete mode 100644 configs/oc22/s2ef/spinconv/spinconv.yml delete mode 100644 configs/oc22/s2ef/spinconv/spinconv_finetune.yml delete mode 100644 configs/oc22/s2ef/spinconv/spinconv_joint.yml diff --git a/configs/is2re/all/painn/painn_h1024_bs8x4.yml b/configs/is2re/all/painn/painn_h1024_bs8x4.yml index cbc4b92f2..558b10e2d 100644 --- a/configs/is2re/all/painn/painn_h1024_bs8x4.yml +++ b/configs/is2re/all/painn/painn_h1024_bs8x4.yml @@ -20,7 +20,9 @@ optim: load_balancing: atoms num_workers: 2 optimizer: AdamW - optimizer_params: {"amsgrad": True} + optimizer_params: + amsgrad: True + weight_decay: 0 # 2e-6 (TF weight decay) / 1e-4 (lr) = 2e-2 lr_initial: 1.e-4 scheduler: ReduceLROnPlateau mode: min @@ -31,4 +33,3 @@ optim: ema_decay: 0.999 clip_grad_norm: 10 loss_energy: mae - weight_decay: 0 # 2e-6 (TF weight decay) / 1e-4 (lr) = 2e-2 diff --git a/configs/is2re/example.yml b/configs/is2re/example.yml index 32a54bdb6..549bbe8c6 100644 --- a/configs/is2re/example.yml +++ b/configs/is2re/example.yml @@ -95,9 +95,10 @@ optim: # Learning rate. Passed as an `lr` argument when initializing the optimizer. lr_initial: 1.e-4 # Additional args needed to initialize the optimizer. - optimizer_params: {"amsgrad": True} - # Weight decay to use. Passed as an argument when initializing the optimizer. - weight_decay: 0 + optimizer_params: + amsgrad: True + # Weight decay to use. Passed as an argument when initializing the optimizer. + weight_decay: 0 # Learning rate scheduler. Should work for any scheduler specified in # in torch.optim.lr_scheduler: https://pytorch.org/docs/stable/optim.html # as long as the relevant args are specified here. diff --git a/configs/oc22/is2re/painn/painn.yml b/configs/oc22/is2re/painn/painn.yml index 7f941e59a..5fc50f782 100644 --- a/configs/oc22/is2re/painn/painn.yml +++ b/configs/oc22/is2re/painn/painn.yml @@ -20,7 +20,9 @@ optim: load_balancing: atoms num_workers: 2 optimizer: AdamW - optimizer_params: {"amsgrad": True} + optimizer_params: + amsgrad: True + weight_decay: 0 # 2e-6 (TF weight decay) / 1e-4 (lr) = 2e-2 lr_initial: 1.e-4 scheduler: ReduceLROnPlateau mode: min @@ -31,4 +33,3 @@ optim: ema_decay: 0.999 clip_grad_norm: 10 loss_energy: mae - weight_decay: 0 # 2e-6 (TF weight decay) / 1e-4 (lr) = 2e-2 diff --git a/configs/oc22/s2ef/gemnet-oc/gemnet_oc.yml b/configs/oc22/s2ef/gemnet-oc/gemnet_oc.yml index e0f999540..51abcdad6 100644 --- a/configs/oc22/s2ef/gemnet-oc/gemnet_oc.yml +++ b/configs/oc22/s2ef/gemnet-oc/gemnet_oc.yml @@ -65,7 +65,9 @@ optim: num_workers: 2 lr_initial: 5.e-4 optimizer: AdamW - optimizer_params: {"amsgrad": True} + optimizer_params: + amsgrad: True + weight_decay: 0 # 2e-6 (TF weight decay) / 1e-4 (lr) = 2e-2 warmup_steps: -1 # don't warm-up the learning rate # warmup_factor: 0.2 lr_gamma: 0.8 @@ -81,4 +83,3 @@ optim: max_epochs: 80 ema_decay: 0.999 clip_grad_norm: 10 - weight_decay: 0 # 2e-6 (TF weight decay) / 1e-4 (lr) = 2e-2 diff --git a/configs/oc22/s2ef/gemnet-oc/gemnet_oc_finetune.yml b/configs/oc22/s2ef/gemnet-oc/gemnet_oc_finetune.yml index d52902efd..3f6fc2525 100644 --- a/configs/oc22/s2ef/gemnet-oc/gemnet_oc_finetune.yml +++ b/configs/oc22/s2ef/gemnet-oc/gemnet_oc_finetune.yml @@ -65,7 +65,9 @@ optim: num_workers: 2 lr_initial: 1.e-4 optimizer: AdamW - optimizer_params: {"amsgrad": True} + optimizer_params: + amsgrad: True + weight_decay: 0 # 2e-6 (TF weight decay) / 1e-4 (lr) = 2e-2 warmup_steps: -1 # don't warm-up the learning rate # warmup_factor: 0.2 lr_gamma: 0.8 @@ -94,7 +96,6 @@ optim: max_epochs: 15 ema_decay: 0.999 clip_grad_norm: 10 - weight_decay: 0 # 2e-6 (TF weight decay) / 1e-4 (lr) = 2e-2 loss_energy: mae loss_force: l2mae force_coefficient: 100 diff --git a/configs/oc22/s2ef/gemnet-oc/gemnet_oc_oc20_oc22.yml b/configs/oc22/s2ef/gemnet-oc/gemnet_oc_oc20_oc22.yml index 82755527f..2fefc33cb 100644 --- a/configs/oc22/s2ef/gemnet-oc/gemnet_oc_oc20_oc22.yml +++ b/configs/oc22/s2ef/gemnet-oc/gemnet_oc_oc20_oc22.yml @@ -65,7 +65,9 @@ optim: num_workers: 2 lr_initial: 5.e-4 optimizer: AdamW - optimizer_params: {"amsgrad": True} + optimizer_params: + amsgrad: True + weight_decay: 0 # 2e-6 (TF weight decay) / 1e-4 (lr) = 2e-2 scheduler: ReduceLROnPlateau mode: min factor: 0.8 @@ -73,7 +75,6 @@ optim: max_epochs: 80 ema_decay: 0.999 clip_grad_norm: 10 - weight_decay: 0 # 2e-6 (TF weight decay) / 1e-4 (lr) = 2e-2 loss_energy: mae loss_force: atomwisel2 force_coefficient: 1 diff --git a/configs/oc22/s2ef/gemnet-oc/gemnet_oc_oc20_oc22_degen_edges.yml b/configs/oc22/s2ef/gemnet-oc/gemnet_oc_oc20_oc22_degen_edges.yml index ff1eb03a0..5cbb1997e 100644 --- a/configs/oc22/s2ef/gemnet-oc/gemnet_oc_oc20_oc22_degen_edges.yml +++ b/configs/oc22/s2ef/gemnet-oc/gemnet_oc_oc20_oc22_degen_edges.yml @@ -67,7 +67,9 @@ optim: num_workers: 2 lr_initial: 5.e-4 optimizer: AdamW - optimizer_params: {"amsgrad": True} + optimizer_params: + amsgrad: True + weight_decay: 0 # 2e-6 (TF weight decay) / 1e-4 (lr) = 2e-2 scheduler: ReduceLROnPlateau mode: min factor: 0.8 @@ -75,7 +77,6 @@ optim: max_epochs: 80 ema_decay: 0.999 clip_grad_norm: 10 - weight_decay: 0 # 2e-6 (TF weight decay) / 1e-4 (lr) = 2e-2 loss_energy: mae loss_force: atomwisel2 force_coefficient: 1 diff --git a/configs/oc22/s2ef/painn/painn.yml b/configs/oc22/s2ef/painn/painn.yml index a7fa9ba48..9acedc7fc 100644 --- a/configs/oc22/s2ef/painn/painn.yml +++ b/configs/oc22/s2ef/painn/painn.yml @@ -22,7 +22,9 @@ optim: eval_every: 5000 num_workers: 2 optimizer: AdamW - optimizer_params: {"amsgrad": True} + optimizer_params: + amsgrad: True + weight_decay: 0 # 2e-6 (TF weight decay) / 1e-4 (lr) = 2e-2 lr_initial: 1.e-4 warmup_steps: -1 # don't warm-up the learning rate # warmup_factor: 0.2 @@ -39,4 +41,3 @@ optim: max_epochs: 80 ema_decay: 0.999 clip_grad_norm: 10 - weight_decay: 0 # 2e-6 (TF weight decay) / 1e-4 (lr) = 2e-2 diff --git a/configs/oc22/s2ef/spinconv/spinconv.yml b/configs/oc22/s2ef/spinconv/spinconv.yml deleted file mode 100644 index 7a7d14d2f..000000000 --- a/configs/oc22/s2ef/spinconv/spinconv.yml +++ /dev/null @@ -1,43 +0,0 @@ -includes: - - configs/oc22/s2ef/base.yml - -model: - name: spinconv - model_ref_number: 0 - hidden_channels: 32 - mid_hidden_channels: 256 - num_interactions: 3 - num_basis_functions: 512 - sphere_size_lat: 16 - sphere_size_long: 12 - max_num_neighbors: 40 - cutoff: 6.0 - sphere_message: fullconv - output_message: fullconv - force_estimator: random - regress_forces: True - use_pbc: True - scale_distances: True - basis_width_scalar: 3.0 - otf_graph: True - -optim: - batch_size: 3 - eval_batch_size: 3 - num_workers: 8 - lr_initial: 0.0004 - optimizer: Adam - optimizer_params: {"amsgrad": True} - eval_every: 5000 - warmup_steps: -1 # don't warm-up the learning rate - # warmup_factor: 0.2 - lr_gamma: 0.8 - # Following calculation is for an effective batch size of 3 x 64 GPUs = 192 - # and a dataset size of 8225293 (1 epoch = 32130 steps). - lr_milestones: # steps at which lr_initial <- lr_initial * lr_gamma - - 86000 # ~2 epochs - - 129000 # ~3 epochs - - 171000 # ~4 epochs - - 214000 # ~5 epochs - - 257000 # ~6 epochs - max_epochs: 80 diff --git a/configs/oc22/s2ef/spinconv/spinconv_finetune.yml b/configs/oc22/s2ef/spinconv/spinconv_finetune.yml deleted file mode 100644 index b94f24145..000000000 --- a/configs/oc22/s2ef/spinconv/spinconv_finetune.yml +++ /dev/null @@ -1,36 +0,0 @@ -includes: - - configs/oc22/s2ef/base.yml - -model: - name: spinconv - model_ref_number: 0 - hidden_channels: 32 - mid_hidden_channels: 256 - num_interactions: 3 - num_basis_functions: 512 - sphere_size_lat: 16 - sphere_size_long: 12 - max_num_neighbors: 40 - cutoff: 6.0 - sphere_message: fullconv - output_message: fullconv - force_estimator: random - regress_forces: True - use_pbc: True - scale_distances: True - basis_width_scalar: 3.0 - otf_graph: True - -optim: - batch_size: 3 - eval_batch_size: 3 - num_workers: 3 - lr_initial: 0.0001 - optimizer: Adam - optimizer_params: {"amsgrad": True} - eval_every: 5000 - scheduler: ReduceLROnPlateau - mode: min - factor: 0.8 - patience: 3 - max_epochs: 80 diff --git a/configs/oc22/s2ef/spinconv/spinconv_joint.yml b/configs/oc22/s2ef/spinconv/spinconv_joint.yml deleted file mode 100644 index 8f1a1924d..000000000 --- a/configs/oc22/s2ef/spinconv/spinconv_joint.yml +++ /dev/null @@ -1,37 +0,0 @@ -includes: - - configs/oc22/s2ef/base.yml - -model: - name: spinconv - model_ref_number: 0 - hidden_channels: 32 - mid_hidden_channels: 256 - num_interactions: 3 - num_basis_functions: 512 - sphere_size_lat: 16 - sphere_size_long: 12 - max_num_neighbors: 40 - cutoff: 6.0 - sphere_message: fullconv - output_message: fullconv - force_estimator: random - regress_forces: True - use_pbc: True - scale_distances: True - basis_width_scalar: 3.0 - otf_graph: True - -optim: - batch_size: 3 - eval_batch_size: 3 - num_workers: 8 - lr_initial: 0.0004 - optimizer: Adam - optimizer_params: {"amsgrad": True} - eval_every: 5000 - warmup_steps: -1 # don't warm-up the learning rate - scheduler: ReduceLROnPlateau - mode: min - factor: 0.8 - patience: 3 - max_epochs: 80 diff --git a/configs/odac/is2re/eSCN.yml b/configs/odac/is2re/eSCN.yml index 9b9d319a9..e66133372 100755 --- a/configs/odac/is2re/eSCN.yml +++ b/configs/odac/is2re/eSCN.yml @@ -18,7 +18,7 @@ model: use_pbc: True basis_width_scalar: 2.0 otf_graph: True - + max_num_elements: 100 optim: @@ -27,7 +27,9 @@ optim: num_workers: 8 lr_initial: 0.0008 optimizer: AdamW - optimizer_params: {"amsgrad": True} + optimizer_params: + amsgrad: True + weight_decay: 0.2 eval_every: 5000 lr_gamma: 0.3 lr_milestones: # epochs at which lr_initial <- lr_initial * lr_gamma @@ -42,4 +44,3 @@ optim: ema_decay: 0.999 loss_energy: mae loss_force: l2mae - weight_decay: 0.2 diff --git a/configs/odac/is2re/gemnet-oc.yml b/configs/odac/is2re/gemnet-oc.yml index 7ed2655fa..623292efc 100644 --- a/configs/odac/is2re/gemnet-oc.yml +++ b/configs/odac/is2re/gemnet-oc.yml @@ -70,7 +70,9 @@ optim: num_workers: 8 lr_initial: 5.e-4 optimizer: AdamW - optimizer_params: {"amsgrad": True} + optimizer_params: + amsgrad: True + weight_decay: 0.2 scheduler: ReduceLROnPlateau mode: min factor: 0.8 @@ -80,4 +82,3 @@ optim: ema_decay: 0.999 clip_grad_norm: 10 loss_energy: mae - weight_decay: 0.2 diff --git a/configs/odac/s2ef/eSCN.yml b/configs/odac/s2ef/eSCN.yml index 3b6443b78..9517ff7c3 100755 --- a/configs/odac/s2ef/eSCN.yml +++ b/configs/odac/s2ef/eSCN.yml @@ -26,7 +26,9 @@ optim: num_workers: 8 lr_initial: 0.0008 optimizer: AdamW - optimizer_params: {"amsgrad": True} + optimizer_params: + amsgrad: True + weight_decay: 0.1 eval_every: 5000 max_epochs: 24 force_coefficient: 100 @@ -35,6 +37,5 @@ optim: ema_decay: 0.999 loss_energy: mae loss_force: l2mae - weight_decay: 0.1 scheduler: CosineAnnealingLR T_max: 2000000 diff --git a/configs/odac/s2ef/gemnet-oc.yml b/configs/odac/s2ef/gemnet-oc.yml index df6ae72d8..def88cf81 100644 --- a/configs/odac/s2ef/gemnet-oc.yml +++ b/configs/odac/s2ef/gemnet-oc.yml @@ -70,7 +70,9 @@ optim: num_workers: 8 lr_initial: 5.e-4 optimizer: AdamW - optimizer_params: {"amsgrad": True} + optimizer_params: + amsgrad: True + weight_decay: 0.1 mode: min max_epochs: 80 force_coefficient: 50 @@ -79,7 +81,6 @@ optim: clip_grad_norm: 10 loss_energy: mae loss_force: l2mae - weight_decay: 0.1 scheduler: CosineAnnealingLR T_max: 2000000 diff --git a/configs/odac/s2ef/painn.yml b/configs/odac/s2ef/painn.yml index b5aeadab5..80ac05775 100644 --- a/configs/odac/s2ef/painn.yml +++ b/configs/odac/s2ef/painn.yml @@ -24,7 +24,9 @@ optim: eval_every: 5000 num_workers: 2 optimizer: AdamW - optimizer_params: {"amsgrad": True} + optimizer_params: + amsgrad: True + weight_decay: 0.3 lr_initial: 1.e-4 lr_gamma: 0.8 mode: min @@ -37,7 +39,6 @@ optim: clip_grad_norm: 10 loss_energy: mae loss_force: l2mae - weight_decay: 0.3 scheduler: CosineAnnealingLR T_max: 1000000 diff --git a/configs/odac/s2ef/schnet.yml b/configs/odac/s2ef/schnet.yml index 8284a246a..95ff22d94 100755 --- a/configs/odac/s2ef/schnet.yml +++ b/configs/odac/s2ef/schnet.yml @@ -18,6 +18,8 @@ optim: eval_batch_size: 8 eval_every: 5000 num_workers: 8 + optimizer_params: + weight_decay: 0.2 lr_initial: 0.0001 lr_gamma: 0.1 lr_milestones: # steps at which lr_initial <- lr_initial * lr_gamma @@ -28,4 +30,3 @@ optim: warmup_factor: 0.2 max_epochs: 15 force_coefficient: 30 - weight_decay: 0.2 diff --git a/configs/s2ef/200k/gemnet/gemnet-oc.yml b/configs/s2ef/200k/gemnet/gemnet-oc.yml index 5207f85ad..1fa2bac3f 100644 --- a/configs/s2ef/200k/gemnet/gemnet-oc.yml +++ b/configs/s2ef/200k/gemnet/gemnet-oc.yml @@ -65,7 +65,9 @@ optim: num_workers: 2 lr_initial: 5.e-4 optimizer: AdamW - optimizer_params: {"amsgrad": True} + optimizer_params: + amsgrad: True + weight_decay: 0 scheduler: ReduceLROnPlateau mode: min factor: 0.8 @@ -77,4 +79,3 @@ optim: clip_grad_norm: 10 loss_energy: mae loss_force: l2mae - weight_decay: 0 diff --git a/configs/s2ef/20M/gemnet/gemnet-oc.yml b/configs/s2ef/20M/gemnet/gemnet-oc.yml index 06d5b5de8..04fd218de 100644 --- a/configs/s2ef/20M/gemnet/gemnet-oc.yml +++ b/configs/s2ef/20M/gemnet/gemnet-oc.yml @@ -65,7 +65,9 @@ optim: num_workers: 2 lr_initial: 5.e-4 optimizer: AdamW - optimizer_params: {"amsgrad": True} + optimizer_params: + amsgrad: True + weight_decay: 0. scheduler: ReduceLROnPlateau mode: min factor: 0.8 @@ -77,4 +79,3 @@ optim: clip_grad_norm: 10 loss_energy: mae loss_force: l2mae - weight_decay: 0 diff --git a/configs/s2ef/2M/gemnet/gemnet-oc.yml b/configs/s2ef/2M/gemnet/gemnet-oc.yml index 226ae9476..9cf409eba 100644 --- a/configs/s2ef/2M/gemnet/gemnet-oc.yml +++ b/configs/s2ef/2M/gemnet/gemnet-oc.yml @@ -65,16 +65,15 @@ optim: num_workers: 2 lr_initial: 5.e-4 optimizer: AdamW - optimizer_params: {"amsgrad": True} + optimizer_params: + amsgrad: True + weight_decay: 0. scheduler: ReduceLROnPlateau mode: min factor: 0.8 patience: 3 max_epochs: 80 - force_coefficient: 100 - energy_coefficient: 1 ema_decay: 0.999 clip_grad_norm: 10 loss_energy: mae loss_force: l2mae - weight_decay: 0 diff --git a/configs/s2ef/all/gemnet/gemnet-oc-large.yml b/configs/s2ef/all/gemnet/gemnet-oc-large.yml index 32648633e..2bf69b209 100644 --- a/configs/s2ef/all/gemnet/gemnet-oc-large.yml +++ b/configs/s2ef/all/gemnet/gemnet-oc-large.yml @@ -65,7 +65,9 @@ optim: num_workers: 2 lr_initial: 2.e-4 optimizer: AdamW - optimizer_params: {"amsgrad": True} + optimizer_params: + amsgrad: True + weight_decay: 0. scheduler: ReduceLROnPlateau mode: min factor: 0.8 @@ -77,4 +79,3 @@ optim: clip_grad_norm: 10 loss_energy: mae loss_force: l2mae - weight_decay: 0 diff --git a/configs/s2ef/all/gemnet/gemnet-oc.yml b/configs/s2ef/all/gemnet/gemnet-oc.yml index f720892a2..e113af76f 100644 --- a/configs/s2ef/all/gemnet/gemnet-oc.yml +++ b/configs/s2ef/all/gemnet/gemnet-oc.yml @@ -65,7 +65,9 @@ optim: num_workers: 2 lr_initial: 5.e-4 optimizer: AdamW - optimizer_params: {"amsgrad": True} + optimizer_params: + amsgrad: True + weight_decay: 0. scheduler: ReduceLROnPlateau mode: min factor: 0.8 @@ -77,4 +79,3 @@ optim: clip_grad_norm: 10 loss_energy: mae loss_force: l2mae - weight_decay: 0 diff --git a/configs/s2ef/all/gp_gemnet/gp-gemnet-xl.yml b/configs/s2ef/all/gp_gemnet/gp-gemnet-xl.yml index b80bac7af..cdedb27d8 100644 --- a/configs/s2ef/all/gp_gemnet/gp-gemnet-xl.yml +++ b/configs/s2ef/all/gp_gemnet/gp-gemnet-xl.yml @@ -43,7 +43,9 @@ optim: num_workers: 8 lr_initial: 2.e-4 optimizer: AdamW - optimizer_params: {"amsgrad": True} + optimizer_params: + amsgrad: True + weight_decay: 0. scheduler: ReduceLROnPlateau mode: min factor: 0.8 @@ -55,5 +57,4 @@ optim: clip_grad_norm: 10 loss_energy: mae loss_force: l2mae - weight_decay: 0 load_balancing: neighbors diff --git a/configs/s2ef/all/painn/painn_h512.yml b/configs/s2ef/all/painn/painn_h512.yml index a7fe4a7ab..da79efb5b 100644 --- a/configs/s2ef/all/painn/painn_h512.yml +++ b/configs/s2ef/all/painn/painn_h512.yml @@ -20,7 +20,9 @@ optim: eval_every: 5000 num_workers: 2 optimizer: AdamW - optimizer_params: {"amsgrad": True} + optimizer_params: + amsgrad: True + weight_decay: 0. # 2e-6 (TF weight decay) / 1e-4 (lr) = 2e-2 lr_initial: 1.e-4 lr_gamma: 0.8 scheduler: ReduceLROnPlateau @@ -34,4 +36,3 @@ optim: clip_grad_norm: 10 loss_energy: mae loss_force: l2mae - weight_decay: 0 # 2e-6 (TF weight decay) / 1e-4 (lr) = 2e-2 diff --git a/configs/s2ef/example.yml b/configs/s2ef/example.yml index 414a8001a..b792f2dfc 100644 --- a/configs/s2ef/example.yml +++ b/configs/s2ef/example.yml @@ -161,9 +161,10 @@ optim: # Learning rate. Passed as an `lr` argument when initializing the optimizer. lr_initial: 1.e-4 # Additional args needed to initialize the optimizer. - optimizer_params: {"amsgrad": True} - # Weight decay to use. Passed as an argument when initializing the optimizer. - weight_decay: 0 + optimizer_params: + amsgrad: True + # Weight decay to use. Passed as an argument when initializing the optimizer. + weight_decay: 0 # Learning rate scheduler. Should work for any scheduler specified in # in torch.optim.lr_scheduler: https://pytorch.org/docs/stable/optim.html # as long as the relevant args are specified here. From 9f86d2e3ba62bce634eb4dae30969bf41f336652 Mon Sep 17 00:00:00 2001 From: Janice Lan Date: Wed, 20 Dec 2023 17:35:15 +0000 Subject: [PATCH 58/63] don't need transform on inference lmdbs with no ground truth --- ocpmodels/modules/transforms.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ocpmodels/modules/transforms.py b/ocpmodels/modules/transforms.py index ffdbe2a3c..a9ecbc46f 100644 --- a/ocpmodels/modules/transforms.py +++ b/ocpmodels/modules/transforms.py @@ -28,7 +28,8 @@ def decompose_tensor(data_object, config) -> Data: tensor_key = config["tensor"] rank = config["rank"] - assert tensor_key in data_object + if tensor_key not in data_object: + return data_object if rank != 2: raise NotImplementedError From e8c1c6f1e0ad8e943a83f8d0f12cc628e9899547 Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Thu, 4 Jan 2024 18:45:52 +0000 Subject: [PATCH 59/63] remove debug configs --- configs/goc_oc20_debug.yml | 129 ---------------------------- configs/goc_stress_debug.yml | 162 ----------------------------------- 2 files changed, 291 deletions(-) delete mode 100644 configs/goc_oc20_debug.yml delete mode 100644 configs/goc_stress_debug.yml diff --git a/configs/goc_oc20_debug.yml b/configs/goc_oc20_debug.yml deleted file mode 100644 index 3065a22a0..000000000 --- a/configs/goc_oc20_debug.yml +++ /dev/null @@ -1,129 +0,0 @@ -trainer: ocp - -dataset: - train: - format: lmdb - src: /datasets01/open_catalyst/oc20/082422/struct_to_energy_forces/train/2M - key_mapping: - y: energy - force: forces - transforms: - normalizer: - energy: - mean: -0.7554450631141663 - stdev: 2.887317180633545 - forces: - mean: 0 - stdev: 2.887317180633545 - val: - src: /datasets01/open_catalyst/oc20/082422/struct_to_energy_forces/val/id_30k - test: - src: /datasets01/open_catalyst/oc20/082422/struct_to_energy_forces/val/id_30k - -logger: tensorboard - -loss_functions: - - energy: - fn: mae - coefficient: 1 - - forces: - fn: l2mae - coefficient: 100 - -evaluation_metrics: - metrics: - energy: - - mae - - mse - - energy_within_threshold - forces: - - mae - - cosine_similarity - misc: - - energy_forces_within_threshold - primary_metric: forces_mae - -outputs: - energy: - shape: 1 - level: system - forces: - shape: 3 - level: atom - train_on_free_atoms: True - eval_on_free_atoms: True - -model: - name: gemnet_oc - num_spherical: 7 - num_radial: 128 - num_blocks: 4 - emb_size_atom: 256 - emb_size_edge: 512 - emb_size_trip_in: 64 - emb_size_trip_out: 64 - emb_size_quad_in: 32 - emb_size_quad_out: 32 - emb_size_aint_in: 64 - emb_size_aint_out: 64 - emb_size_rbf: 16 - emb_size_cbf: 16 - emb_size_sbf: 32 - num_before_skip: 2 - num_after_skip: 2 - num_concat: 1 - num_atom: 3 - num_output_afteratom: 3 - cutoff: 12.0 - cutoff_qint: 12.0 - cutoff_aeaint: 12.0 - cutoff_aint: 12.0 - max_neighbors: 30 - max_neighbors_qint: 8 - max_neighbors_aeaint: 20 - max_neighbors_aint: 1000 - rbf: - name: gaussian - envelope: - name: polynomial - exponent: 5 - cbf: - name: spherical_harmonics - sbf: - name: legendre_outer - extensive: True - output_init: HeOrthogonal - activation: silu - scale_file: configs/s2ef/all/gemnet/scaling_factors/gemnet-oc.pt - - regress_forces: True - direct_forces: True - forces_coupled: False - - quad_interaction: True - atom_edge_interaction: True - edge_atom_interaction: True - atom_interaction: True - - num_atom_emb_layers: 2 - num_global_out_layers: 2 - qint_tags: [1, 2] - otf_graph: True - -optim: - batch_size: 4 - eval_batch_size: 4 - load_balancing: atoms - eval_every: 5000 - num_workers: 2 - lr_initial: 5.e-4 - optimizer: AdamW - optimizer_params: {"amsgrad": True} - scheduler: ReduceLROnPlateau - mode: min - factor: 0.8 - patience: 3 - max_epochs: 80 - ema_decay: 0.999 - clip_grad_norm: 10 - weight_decay: 0 diff --git a/configs/goc_stress_debug.yml b/configs/goc_stress_debug.yml deleted file mode 100644 index e936d8572..000000000 --- a/configs/goc_stress_debug.yml +++ /dev/null @@ -1,162 +0,0 @@ -trainer: ocp - -dataset: - train: - format: lmdb - src: /checkpoint/saro00/mpf_datasets/s2efs/0/train.lmdb - key_mapping: - y: energy - force: forces - stress: stress - transforms: - decompose_tensor: - tensor: stress - rank: 2 - decomposition: - isotropic_stress: - irrep_dim: 0 - anisotropic_stress: - irrep_dim: 2 - normalizer: - energy: - mean: -5.9749126 - stdev: 1.866159 - forces: - mean: 0 - stdev: 1.866159 - isotropic_stress: - mean: 43.27065 - stdev: 674.1657344451734 - anisotropic_stress: - stdev: 143.72764771869745 - val: - src: /checkpoint/saro00/mpf_datasets/s2efs/0/val.lmdb - test: - src: /checkpoint/saro00/mpf_datasets/s2efs/0/val.lmdb - -logger: tensorboard - -loss_functions: - - energy: - fn: mae - coefficient: 1 - - forces: - fn: l2mae - coefficient: 100 - - isotropic_stress: - fn: mae - - anisotropic_stress: - fn: mae - -evaluation_metrics: - metrics: - energy: - - mae - - mse - - energy_within_threshold - forces: - - mae - - cosine_similarity - isotropic_stress: - - mae - anisotropic_stress: - - mae - stress: - - stress_mae_from_decomposition - misc: - - energy_forces_within_threshold - primary_metric: forces_mae - -outputs: - energy: - shape: 1 - level: system - forces: - shape: 3 - level: atom - train_on_free_atoms: True - eval_on_free_atoms: True - - stress: - level: system - decomposition: - isotropic_stress: - irrep_dim: 0 - anisotropic_stress: - irrep_dim: 2 - -model: - name: gemnet_oc - num_spherical: 7 - num_radial: 128 - num_blocks: 4 - emb_size_atom: 256 - emb_size_edge: 512 - emb_size_trip_in: 64 - emb_size_trip_out: 64 - emb_size_quad_in: 32 - emb_size_quad_out: 32 - emb_size_aint_in: 64 - emb_size_aint_out: 64 - emb_size_rbf: 16 - emb_size_cbf: 16 - emb_size_sbf: 32 - num_before_skip: 2 - num_after_skip: 2 - num_concat: 1 - num_atom: 3 - num_output_afteratom: 3 - cutoff: 12.0 - cutoff_qint: 12.0 - cutoff_aeaint: 12.0 - cutoff_aint: 12.0 - max_neighbors: 30 - max_neighbors_qint: 8 - max_neighbors_aeaint: 20 - max_neighbors_aint: 1000 - rbf: - name: gaussian - envelope: - name: polynomial - exponent: 5 - cbf: - name: spherical_harmonics - sbf: - name: legendre_outer - extensive: True - output_init: HeOrthogonal - activation: silu - scale_file: configs/s2ef/all/gemnet/scaling_factors/gemnet-oc.pt - - regress_forces: True - direct_forces: True - forces_coupled: False - - quad_interaction: True - atom_edge_interaction: True - edge_atom_interaction: True - atom_interaction: True - - num_elements: 100 - num_atom_emb_layers: 2 - num_global_out_layers: 2 - qint_tags: [1, 2] - otf_graph: True - -optim: - batch_size: 4 - eval_batch_size: 4 - load_balancing: atoms - eval_every: 5000 - num_workers: 2 - lr_initial: 5.e-4 - optimizer: AdamW - optimizer_params: {"amsgrad": True} - scheduler: ReduceLROnPlateau - mode: min - factor: 0.8 - patience: 3 - max_epochs: 80 - ema_decay: 0.999 - clip_grad_norm: 10 - weight_decay: 0 From d3d7e1ce834ac1fd7b8e0f3d95c51db904fe80e5 Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Thu, 4 Jan 2024 22:50:54 +0000 Subject: [PATCH 60/63] ocp-2.0 example.yml --- configs/ocp_example.yml | 255 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 255 insertions(+) create mode 100644 configs/ocp_example.yml diff --git a/configs/ocp_example.yml b/configs/ocp_example.yml new file mode 100644 index 000000000..1065f7447 --- /dev/null +++ b/configs/ocp_example.yml @@ -0,0 +1,255 @@ +# Example config for training models for arbitrary outputs. + +trainer: ocp + +dataset: + train: + # The code currently supports 'lmdb' and 'oc22_lmdb'. + + # To train models on adsorption energy (as in OC20) or other properties directly contained in the lmdb, use `lmdb`. + # To train models on total DFT energy, use `oc22_lmdb`. + # + # Can use 'single_point_lmdb' or 'trajectory_lmdb' for backward compatibility. + # 'single_point_lmdb' was for training IS2RE models, and 'trajectory_lmdb' was + # for training S2EF models. + format: lmdb # 'lmdb' or 'oc22_lmdb' + # Directory containing training set LMDBs + src: data/s2ef/all/train/ + # If we want to rename a target value stored in the data object, specify the mapping here. + # e.g. data.energy = data.y + key_mapping: + y: energy + force: forces + stress: stress + # Transformations we want to apply to the dataset. If transforms are not specified for the val + # and test set, train transforms will be used by default. + transforms: + # If wanting to decompose rank-2 tensors into its irreps for training, specify the property and + # irrep forms here. Not relevant for energy+force only training. + decompose_tensor: + tensor: stress + rank: 2 + decomposition: + isotropic_stress: + irrep_dim: 0 + anisotropic_stress: + irrep_dim: 2 + # If we want to normalize targets, i.e. subtract the mean and + # divide by standard deviation, then specify the 'mean' and 'stdev' here. + # Statistics will by default be applied to the validation and test set. + normalizer: + energy: + mean: -0.7554450631141663 + stdev: 2.887317180633545 + forces: + mean: 0 + stdev: 2.887317180633545 + isotropic_stress: + mean: 43.27065 + stdev: 674.1657344451734 + anisotropic_stress: + stdev: 143.72764771869745 + # If we want to train OC20 on total energy, a path to OC20 reference + # energies `oc20_ref` must be specified to unreference existing OC20 data. + # download at https://dl.fbaipublicfiles.com/opencatalystproject/data/oc22/oc20_ref.pkl + # Also, train_on_oc20_total_energies must be set to True + # OC22 defaults to total energy, so these flags are not necessary. + train_on_oc20_total_energies: False # True or False + oc20_ref: None # path to oc20_ref + # If we want to train on total energies and use a linear reference + # normalization scheme, we must specify the path to the per-element + # coefficients in a `.npz` format. + lin_ref: False # True or False + val: + # Directory containing val set LMDBs + src: data/s2ef/all/val_id/ + # If we want to run validation with OC20 total energy val set, `oc20_ref` must be specified and + # train_on_oc20_total_energies set to True + # OC22 defaults to total energy, so these flags are not necessary. + train_on_oc20_total_energies: False # True or False + oc20_ref: None # path to oc20_ref + test: + # Directory containing test set LMDBs + src: data/s2ef/all/test_id/ + +task: + # This is an argument used for checkpoint loading. By default it is True and loads + # checkpoint as it is. If False, it could partially load the checkpoint without giving + # any errors + strict_load: True # True or False + # The following args in the 'task' tree are for running relaxations with an + # S2EF model during training (as additional validation) or testing. + # Totally optional if you're only looking to train an S2EF model. + # + # Whether to evaluate val relaxations when training S2EF models on the + # energy_mae and average_distance_within_threshold metrics. + eval_relaxations: False # True or False + # No. of batches to run relaxations on. Defaults to the full 'relax_dataset'. + num_relaxation_batches: 5 + # Max no. of steps to run relaxations for. + relaxation_steps: 300 + # Whether to save out the positions. + write_pos: True # True or False + # Path to initial structures to run relaxations on. Same as the IS2RE set. + relax_dataset: + src: data/is2re/all/test_id/data.lmdb + # To shard a dataset into smaller subsets, define the total_shards desired + # and the shard a particular process to see. + total_shards: 1 # int (optional) + shard: 0 # int (optional) + relax_opt: + name: lbfgs + maxstep: 0.04 + memory: 50 + damping: 1.0 + alpha: 70.0 + # Directory to save out trajectories (.traj files) in. + traj_dir: path/to/traj/directory + # Whether to save out the full trajectory or just the initial+final frames + save_full_traj: True # True or False + # When set to true, uses "deterministic" CUDA scatter ops if available, + # i.e. given the same input, leads to the same results. Default is false + # since this can be significantly slower. + set_deterministic_scatter: False # True or False + +logger: tensorboard # 'wandb' or 'tensorboard' + +loss_functions: +# Specify the different terms in the loss function. For each term, the target property must +# be specified, the loss function to be used (`fn`), and the coefficient to weigh that term by. + - energy: + fn: mae + coefficient: 1 + # Loss function to use for forces. + # + # 'l2mae' has been working well for us with a force to energy coefficient + # ratio of 100:1. + # + # When training on raw DFT energies, 'atomwisel2' might be a better default + # with a force to energy coefficient ratio of 1:1. 'atomwisel2' scales L2 loss + # for forces by the no. of atoms in the structure. + - forces: + fn: l2mae + coefficient: 100 + - isotropic_stress: + fn: mae + - anisotropic_stress: + fn: mae + +evaluation_metrics: + # Evaluation metrics to be reported are specified here. For each target property, + # specify the evaluation metrics to be reported for that property. A list of possible + # metrics can be found in modules/evaluator.py. + metrics: + energy: + - mae + - mse + - energy_within_threshold + forces: + - mae + - cosine_similarity + isotropic_stress: + - mae + anisotropic_stress: + - mae + stress: + - stress_mae_from_decomposition + misc: + - energy_forces_within_threshold + # Define the primary metric to be used for checkpointing and learning rate scheduler. + primary_metric: forces_mae + +outputs: + # Models in OCP return a dictionary with target properties as keys and predictions as their values. + # Here we must specify what our model will return. The target properties defined here must be consistent + # with the `loss_functions` and `evaluation_metrics`. + energy: + # Specify whether this is a system or atom level property. + level: system + # Specify the desired precision to be saved out. + prediction_dtype: float16 + forces: + level: atom + # Sometimes we only care to train and evaluate on free atoms. We can control those settings here for a desired property. + train_on_free_atoms: True # True or False + eval_on_free_atoms: True # True or False + stress: + level: system + # If our model is predicting a decomposition of a rank-2 tensor, we must specify that information here. + decomposition: + isotropic_stress: + irrep_dim: 0 + anisotropic_stress: + irrep_dim: 2 + +model: + name: gemnet_t + # Model attributes go here, e.g. no. of layers, no. of hidden channels, + # embedding functions, cutoff radius, no. of neighbors, etc. + # This list of params will look different depending on the model. + # + # 'otf_graph' specifies whether graph edges should be computed on the fly + # or they already exist in the preprocessed LMDBs. If unsure, set it to True. + otf_graph: True # True or False + # All models in OCP can be used to predict just energies, or both energies and + # forces. For S2EF, we need both, so 'regress_forces' is True. + regress_forces: True # True or False + # Whether forces are predicted directly via an independent network (when set + # to True), or as negative gradients of energy wrt positions (when False) + direct_forces: True + +optim: + # Batch size per GPU for training. + # Note that effective batch size will be 'batch_size' x no. of GPUs. + batch_size: 8 + # Batch size per GPU for evaluation. + # Note that effective batch size will be 'eval_batch_size' x no. of GPUs. + eval_batch_size: 8 + # Whether to load balance across GPUs based on no. of 'atoms' or 'neighbors'. + load_balancing: atoms # 'atoms' or 'neighbors' + # No. of subprocesses to use for dataloading, pass as an arg to + # https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader. + num_workers: 2 + # After how many updates to run evaluation on val during training. + # If unspecified, defaults to 1 epoch. + eval_every: 5000 + # Optimizer to use from torch.optim. + # Default is https://pytorch.org/docs/stable/generated/torch.optim.AdamW.html. + optimizer: AdamW + # Learning rate. Passed as an `lr` argument when initializing the optimizer. + lr_initial: 1.e-4 + # Additional args needed to initialize the optimizer. + optimizer_params: + amsgrad: True + # Weight decay to use. Passed as an argument when initializing the optimizer. + weight_decay: 0 + # Learning rate scheduler. Should work for any scheduler specified in + # in torch.optim.lr_scheduler: https://pytorch.org/docs/stable/optim.html + # as long as the relevant args are specified here. + # + # For example, for ReduceLROnPlateau, we specify `mode`, `factor`, `patience`. + # https://pytorch.org/docs/stable/generated/torch.optim.lr_scheduler.ReduceLROnPlateau.html + # + # Note that if task.primary_metric specified earlier in the config is a metric + # where higher is better (e.g. 'energy_force_within_threshold' or + # 'average_distance_within_threshold'), `mode` should be 'max' since we'd want + # to step LR when the metric has stopped increasing. Vice versa for energy_mae + # or forces_mae or loss. + # + # If you don't want to use a scheduler, set it to 'Null' (yes type that out). + # This is for legacy reasons. If scheduler is unspecified, it defaults to + # 'LambdaLR': warming up the learning rate to 'lr_initial' and then stepping + # it at pre-defined set of steps. See the DimeNet++ config for how to do this. + scheduler: ReduceLROnPlateau + mode: min + factor: 0.8 + patience: 3 + # No. of epochs to train for. + max_epochs: 100 + # Exponential moving average of parameters. 'ema_decay' is the decay factor. + ema_decay: 0.999 + # Max norm of gradients for clipping. Uses torch.nn.utils.clip_grad_norm_. + clip_grad_norm: 10 + +slurm: + constraint: "rtx_6000" From ddac40a194037bb5b2028a9a6153c78b8c3287ee Mon Sep 17 00:00:00 2001 From: Janice Lan Date: Thu, 4 Jan 2024 23:32:15 +0000 Subject: [PATCH 61/63] take out ocpdataparallel from fit.py --- ocpmodels/modules/scaling/fit.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/ocpmodels/modules/scaling/fit.py b/ocpmodels/modules/scaling/fit.py index 95c16f136..b3e1d4124 100644 --- a/ocpmodels/modules/scaling/fit.py +++ b/ocpmodels/modules/scaling/fit.py @@ -10,7 +10,6 @@ import torch.nn as nn from torch.nn.parallel.distributed import DistributedDataParallel -from ocpmodels.common.data_parallel import OCPDataParallel from ocpmodels.common.flags import flags from ocpmodels.common.utils import ( build_config, @@ -78,7 +77,7 @@ def main(*, num_batches: int = 16) -> None: # unwrap module from DP/DDP unwrapped_model = model while isinstance( - unwrapped_model, (DistributedDataParallel, OCPDataParallel) + unwrapped_model, DistributedDataParallel ): unwrapped_model = unwrapped_model.module assert isinstance( From 3ab12b485827556880f677db0e117cd201c882f2 Mon Sep 17 00:00:00 2001 From: Janice Lan Date: Fri, 5 Jan 2024 00:09:44 +0000 Subject: [PATCH 62/63] linter --- ocpmodels/modules/scaling/fit.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/ocpmodels/modules/scaling/fit.py b/ocpmodels/modules/scaling/fit.py index b3e1d4124..b8d816492 100644 --- a/ocpmodels/modules/scaling/fit.py +++ b/ocpmodels/modules/scaling/fit.py @@ -76,9 +76,7 @@ def main(*, num_batches: int = 16) -> None: # region reoad scale file contents if necessary # unwrap module from DP/DDP unwrapped_model = model - while isinstance( - unwrapped_model, DistributedDataParallel - ): + while isinstance(unwrapped_model, DistributedDataParallel): unwrapped_model = unwrapped_model.module assert isinstance( unwrapped_model, nn.Module From bc7b5cf3363e7118a3cf708faac8c0f24e50639c Mon Sep 17 00:00:00 2001 From: Muhammed Shuaibi Date: Fri, 5 Jan 2024 01:25:33 +0000 Subject: [PATCH 63/63] update tutorials --- tutorials/OCP_Tutorial.ipynb | 599 ++++---------------------- tutorials/train_s2ef_example.ipynb | 666 ----------------------------- 2 files changed, 79 insertions(+), 1186 deletions(-) delete mode 100644 tutorials/train_s2ef_example.ipynb diff --git a/tutorials/OCP_Tutorial.ipynb b/tutorials/OCP_Tutorial.ipynb index fcb84a8a9..12e3d9f8c 100644 --- a/tutorials/OCP_Tutorial.ipynb +++ b/tutorials/OCP_Tutorial.ipynb @@ -915,12 +915,7 @@ "source": [ "### Interacting with the OC20 datasets\n", "\n", - "The OC20 datasets are stored in LMDBs. Here we show how to interact with the datasets directly in order to better understand the data. We use two seperate classes to read in the approriate datasets:\n", - "\n", - "*S2EF* - We use the [TrajectoryLmdbDataset](https://github.com/Open-Catalyst-Project/ocp/blob/master/ocpmodels/datasets/trajectory_lmdb.py) object to read in a **directory** of LMDB files containing the dataset.\n", - "\n", - "*IS2RE/IS2RS* - We use the [SinglePointLmdbDataset](https://github.com/Open-Catalyst-Project/ocp/blob/master/ocpmodels/datasets/single_point_lmdb.py) class to read in a **single LMDB file** containing the dataset.\n", - "\n" + "The OC20 datasets are stored in LMDBs. Here we show how to interact with the datasets directly in order to better understand the data. We use [LmdbDataset](https://github.com/Open-Catalyst-Project/ocp/blob/main/ocpmodels/datasets/lmdb_dataset.py) to read in a directory of LMDB files or a single LMDB file." ] }, { @@ -935,10 +930,10 @@ }, "outputs": [], "source": [ - "from ocpmodels.datasets import TrajectoryLmdbDataset, SinglePointLmdbDataset\n", + "from ocpmodels.datasets import LmdbDataset\n", "\n", - "# TrajectoryLmdbDataset is our custom Dataset method to read the lmdbs as Data objects. Note that we need to give the path to the folder containing lmdbs for S2EF\n", - "dataset = TrajectoryLmdbDataset({\"src\": \"data/s2ef/train_100/\"})\n", + "# LmdbDataset is our custom Dataset method to read the lmdbs as Data objects. Note that we need to give the path to the folder containing lmdbs for S2EF\n", + "dataset = LmdbDataset({\"src\": \"data/s2ef/train_100/\"})\n", "\n", "print(\"Size of the dataset created:\", len(dataset))\n", "print(dataset[0])" @@ -1091,7 +1086,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": { "id": "l-1rNyuk_1Mo" }, @@ -1101,8 +1096,9 @@ "from ocpmodels.datasets import LmdbDataset\n", "from ocpmodels import models\n", "from ocpmodels.common import logger\n", - "from ocpmodels.common.utils import setup_logging\n", + "from ocpmodels.common.utils import setup_logging, setup_imports()\n", "setup_logging()\n", + "setup_imports()\n", "\n", "import numpy as np\n", "import copy\n", @@ -1120,7 +1116,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": { "id": "1SHl_1eQP4mW" }, @@ -1143,7 +1139,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": { "id": "HAJ3x4SnXE1o" }, @@ -1181,7 +1177,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": { "id": "j6Z_XbkiPGR9" }, @@ -1189,7 +1185,7 @@ "source": [ "# Task\n", "task = {\n", - " 'dataset': 'trajectory_lmdb', # dataset used for the S2EF task\n", + " 'dataset': 'lmdb', # dataset used for the S2EF task\n", " 'description': 'Regressing to energies and forces for DFT trajectories from OCP',\n", " 'type': 'regression',\n", " 'metric': 'mae',\n", @@ -1240,7 +1236,6 @@ " \"extensive\": True,\n", " \"output_init\": \"HeOrthogonal\",\n", " \"activation\": \"silu\",\n", - " \"scale_file\": \"configs/s2ef/all/gemnet/scaling_factors/gemnet-oc.pt\",\n", "\n", " \"regress_forces\": True,\n", " \"direct_forces\": True,\n", @@ -1254,6 +1249,8 @@ " \"num_atom_emb_layers\": 2,\n", " \"num_global_out_layers\": 2,\n", " \"qint_tags\": [1, 2],\n", + " \n", + " \"scale_file\": \"configs/s2ef/all/gemnet/scaling_factors/gemnet-oc.pt\",\n", "}\n", "\n", "# Optimizer\n", @@ -1299,7 +1296,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -1307,158 +1304,7 @@ "id": "0it4gs6gPGGz", "outputId": "e7a98c1d-6d4f-425b-878f-4a3a7b42b2ed" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "amp: true\n", - "cmd:\n", - " checkpoint_dir: ./checkpoints/2023-08-01-13-26-40-S2EF-example\n", - " commit: 0bd8935\n", - " identifier: S2EF-example\n", - " logs_dir: ./logs/tensorboard/2023-08-01-13-26-40-S2EF-example\n", - " print_every: 5\n", - " results_dir: ./results/2023-08-01-13-26-40-S2EF-example\n", - " seed: 0\n", - " timestamp_id: 2023-08-01-13-26-40-S2EF-example\n", - "dataset:\n", - " grad_target_mean: 0.0\n", - " grad_target_std: !!python/object/apply:numpy.core.multiarray.scalar\n", - " - &id001 !!python/object/apply:numpy.dtype\n", - " args:\n", - " - f8\n", - " - false\n", - " - true\n", - " state: !!python/tuple\n", - " - 3\n", - " - <\n", - " - null\n", - " - null\n", - " - null\n", - " - -1\n", - " - -1\n", - " - 0\n", - " - !!binary |\n", - " dPVlWhRA+D8=\n", - " normalize_labels: true\n", - " src: data/s2ef/train_100\n", - " target_mean: !!python/object/apply:numpy.core.multiarray.scalar\n", - " - *id001\n", - " - !!binary |\n", - " zSXlDMrm3D8=\n", - " target_std: !!python/object/apply:numpy.core.multiarray.scalar\n", - " - *id001\n", - " - !!binary |\n", - " dPVlWhRA+D8=\n", - "eval_metrics: {}\n", - "gpus: 1\n", - "logger: tensorboard\n", - "loss_fns: {}\n", - "model: gemnet_oc\n", - "model_attributes:\n", - " activation: silu\n", - " atom_edge_interaction: true\n", - " atom_interaction: true\n", - " cbf:\n", - " name: spherical_harmonics\n", - " cutoff: 12.0\n", - " cutoff_aeaint: 12.0\n", - " cutoff_aint: 12.0\n", - " cutoff_qint: 12.0\n", - " direct_forces: true\n", - " edge_atom_interaction: true\n", - " emb_size_aint_in: 64\n", - " emb_size_aint_out: 64\n", - " emb_size_atom: 64\n", - " emb_size_cbf: 16\n", - " emb_size_edge: 64\n", - " emb_size_quad_in: 32\n", - " emb_size_quad_out: 32\n", - " emb_size_rbf: 16\n", - " emb_size_sbf: 32\n", - " emb_size_trip_in: 64\n", - " emb_size_trip_out: 64\n", - " envelope:\n", - " exponent: 5\n", - " name: polynomial\n", - " extensive: true\n", - " forces_coupled: false\n", - " max_neighbors: 30\n", - " max_neighbors_aeaint: 20\n", - " max_neighbors_aint: 1000\n", - " max_neighbors_qint: 8\n", - " num_after_skip: 2\n", - " num_atom: 3\n", - " num_atom_emb_layers: 2\n", - " num_before_skip: 2\n", - " num_blocks: 4\n", - " num_concat: 1\n", - " num_global_out_layers: 2\n", - " num_output_afteratom: 3\n", - " num_radial: 128\n", - " num_spherical: 7\n", - " output_init: HeOrthogonal\n", - " qint_tags:\n", - " - 1\n", - " - 2\n", - " quad_interaction: true\n", - " rbf:\n", - " name: gaussian\n", - " regress_forces: true\n", - " sbf:\n", - " name: legendre_outer\n", - " scale_file: configs/s2ef/all/gemnet/scaling_factors/gemnet-oc.pt\n", - "noddp: false\n", - "optim:\n", - " batch_size: 1\n", - " clip_grad_norm: 10\n", - " ema_decay: 0.999\n", - " eval_batch_size: 1\n", - " factor: 0.8\n", - " force_coefficient: 100\n", - " loss_energy: mae\n", - " loss_force: l2mae\n", - " lr_initial: 0.0005\n", - " max_epochs: 1\n", - " mode: min\n", - " num_workers: 2\n", - " optimizer: AdamW\n", - " optimizer_params:\n", - " amsgrad: true\n", - " patience: 3\n", - " scheduler: ReduceLROnPlateau\n", - "outputs: {}\n", - "slurm: {}\n", - "task:\n", - " dataset: trajectory_lmdb\n", - " description: Regressing to energies and forces for DFT trajectories from OCP\n", - " eval_on_free_atoms: true\n", - " grad_input: atomic forces\n", - " labels:\n", - " - potential energy\n", - " metric: mae\n", - " train_on_free_atoms: true\n", - " type: regression\n", - "trainer: s2ef\n", - "val_dataset:\n", - " src: data/s2ef/val_20\n", - "\n", - "2023-08-01 13:26:43 (INFO): Loading dataset: lmdb\n", - "2023-08-01 13:26:43 (INFO): Batch balancing is disabled for single GPU training.\n", - "2023-08-01 13:26:43 (INFO): Batch balancing is disabled for single GPU training.\n", - "2023-08-01 13:26:43 (INFO): Loading model: gemnet_oc\n", - "2023-08-01 13:26:43 (INFO): Loaded GemNetOC with 2596214 parameters.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2023-08-01 13:26:43 (WARNING): Model gradient logging to tensorboard not yet supported.\n" - ] - } - ], + "outputs": [], "source": [ "trainer = OCPTrainer(\n", " task=task,\n", @@ -1491,7 +1337,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -1499,56 +1345,7 @@ "id": "WFmssq5oPFd_", "outputId": "a80e93f3-637a-4394-9ec8-4c38bac27461" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-08-01 13:26:47 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 1.11e+01, forcesx_mae: 4.63e-01, forcesy_mae: 7.30e-01, forcesz_mae: 5.88e-01, forces_mae: 5.94e-01, forces_cosine_similarity: -2.71e-02, forces_magnitude_error: 1.03e+00, loss: 1.71e+02, lr: 5.00e-04, epoch: 5.00e-02, step: 5.00e+00\n", - "2023-08-01 13:26:48 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 2.26e+01, forcesx_mae: 4.70e-01, forcesy_mae: 6.52e-01, forcesz_mae: 7.01e-01, forces_mae: 6.08e-01, forces_cosine_similarity: 1.11e-02, forces_magnitude_error: 1.12e+00, loss: 1.30e+02, lr: 5.00e-04, epoch: 1.00e-01, step: 1.00e+01\n", - "2023-08-01 13:26:49 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 2.47e+01, forcesx_mae: 4.45e-01, forcesy_mae: 6.03e-01, forcesz_mae: 6.59e-01, forces_mae: 5.69e-01, forces_cosine_similarity: 3.69e-03, forces_magnitude_error: 7.93e-01, loss: 9.21e+01, lr: 5.00e-04, epoch: 1.50e-01, step: 1.50e+01\n", - "2023-08-01 13:26:49 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 2.35e+01, forcesx_mae: 2.35e-01, forcesy_mae: 4.31e-01, forcesz_mae: 3.37e-01, forces_mae: 3.34e-01, forces_cosine_similarity: 8.77e-02, forces_magnitude_error: 4.51e-01, loss: 5.58e+01, lr: 5.00e-04, epoch: 2.00e-01, step: 2.00e+01\n", - "2023-08-01 13:26:50 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 1.33e+01, forcesx_mae: 1.33e-01, forcesy_mae: 1.48e-01, forcesz_mae: 1.77e-01, forces_mae: 1.53e-01, forces_cosine_similarity: -1.11e-02, forces_magnitude_error: 1.63e-01, loss: 2.86e+01, lr: 5.00e-04, epoch: 2.50e-01, step: 2.50e+01\n", - "2023-08-01 13:26:51 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 7.76e+00, forcesx_mae: 1.16e-01, forcesy_mae: 2.85e-01, forcesz_mae: 1.54e-01, forces_mae: 1.85e-01, forces_cosine_similarity: -1.37e-02, forces_magnitude_error: 2.51e-01, loss: 2.96e+01, lr: 5.00e-04, epoch: 3.00e-01, step: 3.00e+01\n", - "2023-08-01 13:26:52 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 7.79e+00, forcesx_mae: 5.18e-02, forcesy_mae: 5.56e-02, forcesz_mae: 5.98e-02, forces_mae: 5.57e-02, forces_cosine_similarity: 9.25e-02, forces_magnitude_error: 6.76e-02, loss: 1.25e+01, lr: 5.00e-04, epoch: 3.50e-01, step: 3.50e+01\n", - "2023-08-01 13:26:53 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 6.20e+00, forcesx_mae: 1.05e-01, forcesy_mae: 1.41e-01, forcesz_mae: 1.80e-01, forces_mae: 1.42e-01, forces_cosine_similarity: 1.38e-01, forces_magnitude_error: 1.89e-01, loss: 2.25e+01, lr: 5.00e-04, epoch: 4.00e-01, step: 4.00e+01\n", - "2023-08-01 13:26:53 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 2.79e+00, forcesx_mae: 1.42e-01, forcesy_mae: 2.08e-01, forcesz_mae: 2.35e-01, forces_mae: 1.95e-01, forces_cosine_similarity: 1.79e-01, forces_magnitude_error: 2.71e-01, loss: 2.65e+01, lr: 5.00e-04, epoch: 4.50e-01, step: 4.50e+01\n", - "2023-08-01 13:26:54 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 2.46e+00, forcesx_mae: 9.11e-02, forcesy_mae: 1.11e-01, forcesz_mae: 1.55e-01, forces_mae: 1.19e-01, forces_cosine_similarity: 1.48e-01, forces_magnitude_error: 1.79e-01, loss: 1.69e+01, lr: 5.00e-04, epoch: 5.00e-01, step: 5.00e+01\n", - "2023-08-01 13:26:55 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 1.65e+00, forcesx_mae: 1.61e-01, forcesy_mae: 1.62e-01, forcesz_mae: 2.43e-01, forces_mae: 1.89e-01, forces_cosine_similarity: 3.51e-01, forces_magnitude_error: 3.24e-01, loss: 2.62e+01, lr: 5.00e-04, epoch: 5.50e-01, step: 5.50e+01\n", - "2023-08-01 13:26:56 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 3.78e-01, forcesx_mae: 3.05e-02, forcesy_mae: 3.90e-02, forcesz_mae: 5.64e-02, forces_mae: 4.20e-02, forces_cosine_similarity: 1.70e-01, forces_magnitude_error: 5.91e-02, loss: 5.78e+00, lr: 5.00e-04, epoch: 6.00e-01, step: 6.00e+01\n", - "2023-08-01 13:26:57 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 8.06e+00, forcesx_mae: 3.03e-01, forcesy_mae: 5.27e-01, forcesz_mae: 4.00e-01, forces_mae: 4.10e-01, forces_cosine_similarity: 3.72e-01, forces_magnitude_error: 6.84e-01, loss: 5.42e+01, lr: 5.00e-04, epoch: 6.50e-01, step: 6.50e+01\n", - "2023-08-01 13:26:57 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 1.99e+00, forcesx_mae: 1.40e-01, forcesy_mae: 1.54e-01, forcesz_mae: 2.23e-01, forces_mae: 1.72e-01, forces_cosine_similarity: 4.15e-01, forces_magnitude_error: 2.86e-01, loss: 2.44e+01, lr: 5.00e-04, epoch: 7.00e-01, step: 7.00e+01\n", - "2023-08-01 13:26:58 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 9.05e-01, forcesx_mae: 8.92e-02, forcesy_mae: 1.32e-01, forcesz_mae: 9.59e-02, forces_mae: 1.06e-01, forces_cosine_similarity: 8.72e-02, forces_magnitude_error: 1.08e-01, loss: 1.26e+01, lr: 5.00e-04, epoch: 7.50e-01, step: 7.50e+01\n", - "2023-08-01 13:26:59 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 1.60e+00, forcesx_mae: 1.41e-01, forcesy_mae: 1.93e-01, forcesz_mae: 1.76e-01, forces_mae: 1.70e-01, forces_cosine_similarity: 2.28e-01, forces_magnitude_error: 2.31e-01, loss: 2.23e+01, lr: 5.00e-04, epoch: 8.00e-01, step: 8.00e+01\n", - "2023-08-01 13:27:00 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 1.50e+00, forcesx_mae: 2.21e-01, forcesy_mae: 8.65e-01, forcesz_mae: 3.35e-01, forces_mae: 4.74e-01, forces_cosine_similarity: 3.66e-01, forces_magnitude_error: 9.49e-01, loss: 5.46e+01, lr: 5.00e-04, epoch: 8.50e-01, step: 8.50e+01\n", - "2023-08-01 13:27:01 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 4.14e+00, forcesx_mae: 5.57e-02, forcesy_mae: 9.36e-02, forcesz_mae: 7.68e-02, forces_mae: 7.53e-02, forces_cosine_similarity: 2.33e-01, forces_magnitude_error: 8.21e-02, loss: 1.16e+01, lr: 5.00e-04, epoch: 9.00e-01, step: 9.00e+01\n", - "2023-08-01 13:27:01 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 9.06e-01, forcesx_mae: 3.69e-02, forcesy_mae: 4.61e-02, forcesz_mae: 6.08e-02, forces_mae: 4.79e-02, forces_cosine_similarity: 2.71e-01, forces_magnitude_error: 5.92e-02, loss: 6.84e+00, lr: 5.00e-04, epoch: 9.50e-01, step: 9.50e+01\n", - "2023-08-01 13:27:02 (INFO): energy_forces_within_threshold: 0.00e+00, energy_mae: 4.97e+00, forcesx_mae: 6.32e-02, forcesy_mae: 1.09e-01, forcesz_mae: 7.56e-02, forces_mae: 8.27e-02, forces_cosine_similarity: 1.50e-01, forces_magnitude_error: 9.81e-02, loss: 1.31e+01, lr: 5.00e-04, epoch: 1.00e+00, step: 1.00e+02\n", - "2023-08-01 13:27:02 (INFO): Evaluating on val.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "device 0: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 20/20 [00:01<00:00, 15.09it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-08-01 13:27:04 (INFO): energy_forces_within_threshold: 0.0000, energy_mae: 9.0515, forcesx_mae: 0.3079, forcesy_mae: 0.2660, forcesz_mae: 0.4767, forces_mae: 0.3502, forces_cosine_similarity: 0.0152, forces_magnitude_error: 0.5005, loss: 53.7886, epoch: 1.0000\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], + "outputs": [], "source": [ "trainer.train()" ] @@ -1583,7 +1380,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -1592,18 +1389,7 @@ "id": "UW4ihgBdQ0Yt", "outputId": "8226c4d2-041d-46d3-c0d9-02ce85f8fc93" }, - "outputs": [ - { - "data": { - "text/plain": [ - "'./checkpoints/2023-08-01-13-26-40-S2EF-example/best_checkpoint.pt'" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# The `best_checpoint.pt` file contains the checkpoint with the best val performance\n", "checkpoint_path = os.path.join(trainer.config[\"cmd\"][\"checkpoint_dir\"], \"best_checkpoint.pt\")\n", @@ -1612,7 +1398,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -1620,29 +1406,7 @@ "id": "6jppgncMTivj", "outputId": "a15e13a5-4c1d-4fd4-c2c3-ef9fa210a9dd" }, - "outputs": [ - { - "data": { - "text/plain": [ - "[{'src': 'data/s2ef/train_100',\n", - " 'normalize_labels': True,\n", - " 'target_mean': 0.45158625849998374,\n", - " 'target_std': 1.5156444102461508,\n", - " 'grad_target_mean': 0.0,\n", - " 'grad_target_std': 1.5156444102461508,\n", - " 'normalizer': {'energy': {'mean': 0.45158625849998374,\n", - " 'stdev': 1.5156444102461508},\n", - " 'forces': {'mean': 0.0, 'stdev': 1.5156444102461508}},\n", - " 'key_mapping': {'y': 'energy', 'force': 'forces'}},\n", - " {'src': 'data/s2ef/val_20'},\n", - " {'src': 'data/s2ef/val_20'}]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Append the dataset with the test set. We use the same val set for demonstration.\n", "\n", @@ -1655,7 +1419,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -1663,187 +1427,7 @@ "id": "MaVROfxzRLaj", "outputId": "0f143c63-1e1d-44c4-c641-34bac1706c2c" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "amp: true\n", - "cmd:\n", - " checkpoint_dir: ./checkpoints/2023-08-01-13-26-40-S2EF-val-example\n", - " commit: 0bd8935\n", - " identifier: S2EF-val-example\n", - " logs_dir: ./logs/tensorboard/2023-08-01-13-26-40-S2EF-val-example\n", - " print_every: 5\n", - " results_dir: ./results/2023-08-01-13-26-40-S2EF-val-example\n", - " seed: 0\n", - " timestamp_id: 2023-08-01-13-26-40-S2EF-val-example\n", - "dataset:\n", - " grad_target_mean: 0.0\n", - " grad_target_std: !!python/object/apply:numpy.core.multiarray.scalar\n", - " - &id001 !!python/object/apply:numpy.dtype\n", - " args:\n", - " - f8\n", - " - false\n", - " - true\n", - " state: !!python/tuple\n", - " - 3\n", - " - <\n", - " - null\n", - " - null\n", - " - null\n", - " - -1\n", - " - -1\n", - " - 0\n", - " - !!binary |\n", - " dPVlWhRA+D8=\n", - " key_mapping:\n", - " force: forces\n", - " y: energy\n", - " normalize_labels: true\n", - " normalizer:\n", - " energy:\n", - " mean: !!python/object/apply:numpy.core.multiarray.scalar\n", - " - *id001\n", - " - !!binary |\n", - " zSXlDMrm3D8=\n", - " stdev: !!python/object/apply:numpy.core.multiarray.scalar\n", - " - *id001\n", - " - !!binary |\n", - " dPVlWhRA+D8=\n", - " forces:\n", - " mean: 0.0\n", - " stdev: !!python/object/apply:numpy.core.multiarray.scalar\n", - " - *id001\n", - " - !!binary |\n", - " dPVlWhRA+D8=\n", - " src: data/s2ef/train_100\n", - " target_mean: !!python/object/apply:numpy.core.multiarray.scalar\n", - " - *id001\n", - " - !!binary |\n", - " zSXlDMrm3D8=\n", - " target_std: !!python/object/apply:numpy.core.multiarray.scalar\n", - " - *id001\n", - " - !!binary |\n", - " dPVlWhRA+D8=\n", - "eval_metrics: {}\n", - "gpus: 1\n", - "logger: tensorboard\n", - "loss_fns: {}\n", - "model: gemnet_oc\n", - "model_attributes:\n", - " activation: silu\n", - " atom_edge_interaction: true\n", - " atom_interaction: true\n", - " cbf:\n", - " name: spherical_harmonics\n", - " cutoff: 12.0\n", - " cutoff_aeaint: 12.0\n", - " cutoff_aint: 12.0\n", - " cutoff_qint: 12.0\n", - " direct_forces: true\n", - " edge_atom_interaction: true\n", - " emb_size_aint_in: 64\n", - " emb_size_aint_out: 64\n", - " emb_size_atom: 64\n", - " emb_size_cbf: 16\n", - " emb_size_edge: 64\n", - " emb_size_quad_in: 32\n", - " emb_size_quad_out: 32\n", - " emb_size_rbf: 16\n", - " emb_size_sbf: 32\n", - " emb_size_trip_in: 64\n", - " emb_size_trip_out: 64\n", - " envelope:\n", - " exponent: 5\n", - " name: polynomial\n", - " extensive: true\n", - " forces_coupled: false\n", - " max_neighbors: 30\n", - " max_neighbors_aeaint: 20\n", - " max_neighbors_aint: 1000\n", - " max_neighbors_qint: 8\n", - " num_after_skip: 2\n", - " num_atom: 3\n", - " num_atom_emb_layers: 2\n", - " num_before_skip: 2\n", - " num_blocks: 4\n", - " num_concat: 1\n", - " num_global_out_layers: 2\n", - " num_output_afteratom: 3\n", - " num_radial: 128\n", - " num_spherical: 7\n", - " output_init: HeOrthogonal\n", - " qint_tags:\n", - " - 1\n", - " - 2\n", - " quad_interaction: true\n", - " rbf:\n", - " name: gaussian\n", - " regress_forces: true\n", - " sbf:\n", - " name: legendre_outer\n", - " scale_file: configs/s2ef/all/gemnet/scaling_factors/gemnet-oc.pt\n", - "noddp: false\n", - "optim:\n", - " batch_size: 1\n", - " clip_grad_norm: 10\n", - " ema_decay: 0.999\n", - " eval_batch_size: 1\n", - " factor: 0.8\n", - " force_coefficient: 100\n", - " loss_energy: mae\n", - " loss_force: l2mae\n", - " lr_initial: 0.0005\n", - " max_epochs: 1\n", - " mode: min\n", - " num_workers: 2\n", - " optimizer: AdamW\n", - " optimizer_params:\n", - " amsgrad: true\n", - " patience: 3\n", - " scheduler: ReduceLROnPlateau\n", - "outputs: {}\n", - "slurm: {}\n", - "task:\n", - " dataset: trajectory_lmdb\n", - " description: Regressing to energies and forces for DFT trajectories from OCP\n", - " eval_on_free_atoms: true\n", - " grad_input: atomic forces\n", - " labels:\n", - " - potential energy\n", - " metric: mae\n", - " train_on_free_atoms: true\n", - " type: regression\n", - "test_dataset:\n", - " src: data/s2ef/val_20\n", - "trainer: s2ef\n", - "val_dataset:\n", - " src: data/s2ef/val_20\n", - "\n", - "2023-08-01 13:27:14 (INFO): Loading dataset: lmdb\n", - "2023-08-01 13:27:14 (INFO): Batch balancing is disabled for single GPU training.\n", - "2023-08-01 13:27:14 (INFO): Batch balancing is disabled for single GPU training.\n", - "2023-08-01 13:27:14 (INFO): Batch balancing is disabled for single GPU training.\n", - "2023-08-01 13:27:14 (INFO): Loading model: gemnet_oc\n", - "2023-08-01 13:27:15 (INFO): Loaded GemNetOC with 2596214 parameters.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2023-08-01 13:27:15 (WARNING): Model gradient logging to tensorboard not yet supported.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-08-01 13:27:15 (INFO): Loading checkpoint from: ./checkpoints/2023-08-01-13-26-40-S2EF-example/best_checkpoint.pt\n" - ] - } - ], + "outputs": [], "source": [ "pretrained_trainer = OCPTrainer(\n", " task=task,\n", @@ -1878,7 +1462,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -1886,36 +1470,7 @@ "id": "jbiPZNeJQ0WK", "outputId": "dd346bcd-f30a-4333-a1ca-e18c057cb238" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-08-01 13:27:20 (INFO): Predicting on test.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "device 0: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 20/20 [00:01<00:00, 15.15it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-08-01 13:27:21 (INFO): Writing results to ./results/2023-08-01-13-26-40-S2EF-val-example/s2ef_s2ef_results.npz\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], + "outputs": [], "source": [ "# make predictions on the existing test_loader\n", "predictions = pretrained_trainer.predict(pretrained_trainer.test_loader, results_file=\"s2ef_results\", disable_tqdm=False)" @@ -1923,7 +1478,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": { "id": "zaZGqeyqNCXz" }, @@ -1976,8 +1531,8 @@ }, "outputs": [], "source": [ - "from ocpmodels.trainers import EnergyTrainer\n", - "from ocpmodels.datasets import SinglePointLmdbDataset\n", + "from ocpmodels.trainers import OCPTrainer\n", + "from ocpmodels.datasets import LmdbDataset\n", "from ocpmodels import models\n", "from ocpmodels.common import logger\n", "from ocpmodels.common.utils import setup_logging\n", @@ -2028,11 +1583,11 @@ }, "outputs": [], "source": [ - "train_dataset = SinglePointLmdbDataset({\"src\": train_src})\n", + "train_dataset = LmdbDataset({\"src\": train_src})\n", "\n", "energies = []\n", "for data in train_dataset:\n", - " energies.append(data.y_relaxed)\n", + " energies.append(data.y_relaxed)\n", "\n", "mean = np.mean(energies)\n", "stdev = np.std(energies)" @@ -2148,34 +1703,26 @@ }, "outputs": [], "source": [ - "energy_trainer = EnergyTrainer(\n", + "energy_trainer = OCPTrainer(\n", " task=task,\n", " model=copy.deepcopy(model), # copied for later use, not necessary in practice.\n", " dataset=dataset,\n", " optimizer=optimizer,\n", + " outputs={},\n", + " loss_fns={},\n", + " eval_metrics={},\n", + " name=\"is2re\",\n", " identifier=\"IS2RE-example\",\n", " run_dir=\"./\", # directory to save results if is_debug=False. Prediction files are saved here so be careful not to override!\n", " is_debug=False, # if True, do not save checkpoint, logs, or results\n", - " is_vis=False,\n", " print_every=5,\n", " seed=0, # random seed to use\n", " logger=\"tensorboard\", # logger of choice (tensorboard and wandb supported)\n", " local_rank=0,\n", - " amp=True, # use PyTorch Automatic Mixed Precision (faster training and less memory usage) \n", + " amp=True, # use PyTorch Automatic Mixed Precision (faster training and less memory usage),\n", ")" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "tnJer5rGwjwi" - }, - "outputs": [], - "source": [ - "energy_trainer.model" - ] - }, { "cell_type": "markdown", "metadata": { @@ -2269,20 +1816,23 @@ }, "outputs": [], "source": [ - "pretrained_energy_trainer = EnergyTrainer(\n", + "pretrained_energy_trainer = OCPTrainer(\n", " task=task,\n", - " model=model,\n", + " model=copy.deepcopy(model), # copied for later use, not necessary in practice.\n", " dataset=dataset,\n", " optimizer=optimizer,\n", + " outputs={},\n", + " loss_fns={},\n", + " eval_metrics={},\n", + " name=\"is2re\",\n", " identifier=\"IS2RE-val-example\",\n", " run_dir=\"./\", # directory to save results if is_debug=False. Prediction files are saved here so be careful not to override!\n", " is_debug=False, # if True, do not save checkpoint, logs, or results\n", - " is_vis=False,\n", - " print_every=10,\n", + " print_every=5,\n", " seed=0, # random seed to use\n", " logger=\"tensorboard\", # logger of choice (tensorboard and wandb supported)\n", " local_rank=0,\n", - " amp=True, # use PyTorch Automatic Mixed Precision (faster training and less memory usage)\n", + " amp=True, # use PyTorch Automatic Mixed Precision (faster training and less memory usage),\n", ")\n", "\n", "pretrained_energy_trainer.load_checkpoint(checkpoint_path=checkpoint_path)" @@ -2368,8 +1918,8 @@ }, "outputs": [], "source": [ - "from ocpmodels.trainers import ForcesTrainer\n", - "from ocpmodels.datasets import TrajectoryLmdbDataset\n", + "from ocpmodels.trainers import OCPTrainer\n", + "from ocpmodels.datasets import LmdbDataset\n", "from ocpmodels import models\n", "from ocpmodels.common import logger\n", "from ocpmodels.common.utils import setup_logging\n", @@ -2465,7 +2015,7 @@ "source": [ "# Task\n", "task = {\n", - " 'dataset': 'trajectory_lmdb', # dataset used for the S2EF task\n", + " 'dataset': 'lmdb', # dataset used for the S2EF task\n", " 'description': 'Regressing to energies and forces for DFT trajectories from OCP',\n", " 'type': 'regression',\n", " 'metric': 'mae',\n", @@ -2562,20 +2112,23 @@ }, "outputs": [], "source": [ - "trainer = ForcesTrainer(\n", + "trainer = OCPTrainer(\n", " task=task,\n", - " model=model,\n", + " model=copy.deepcopy(model), # copied for later use, not necessary in practice.\n", " dataset=dataset,\n", " optimizer=optimizer,\n", + " outputs={},\n", + " loss_fns={},\n", + " eval_metrics={},\n", + " name=\"s2ef\",\n", " identifier=\"is2rs-example\",\n", " run_dir=\"./\", # directory to save results if is_debug=False. Prediction files are saved here so be careful not to override!\n", " is_debug=False, # if True, do not save checkpoint, logs, or results\n", - " is_vis=False,\n", " print_every=5,\n", " seed=0, # random seed to use\n", " logger=\"tensorboard\", # logger of choice (tensorboard and wandb supported)\n", " local_rank=0,\n", - " amp=True, # use PyTorch Automatic Mixed Precision (faster training and less memory usage)\n", + " amp=True, # use PyTorch Automatic Mixed Precision (faster training and less memory usage),\n", ")" ] }, @@ -2786,7 +2339,7 @@ "\n", "from typing import Optional\n", "\n", - "from ocpmodels.trainers import ForcesTrainer\n", + "from ocpmodels.trainers import OCPTrainer\n", "from ocpmodels import models\n", "from ocpmodels.common import logger\n", "from ocpmodels.common.utils import setup_logging, get_pbc_distances\n", @@ -2809,8 +2362,8 @@ "setup_logging()\n", "\n", "# Dataset paths\n", - "train_src = \"data/s2ef/train_200k\"\n", - "val_src = \"data/s2ef/val\"\n", + "train_src = \"data/s2ef/train_100\"\n", + "val_src = \"data/s2ef/val_20\"\n", "\n", "# Configs\n", "task = {\n", @@ -3016,8 +2569,8 @@ " F = scatter(F_st_vec, idx_t, dim=0, dim_size=atomic_numbers.size(0), reduce=\"add\")\n", " # (num_atoms, num_targets, 3)\n", " F = F.squeeze(1)\n", - "\n", - " return E, F\n", + " \n", + " return {\"energy\": E, \"forces\": F}\n", "\n", " @property\n", " def num_params(self):\n", @@ -3049,19 +2602,23 @@ " 'env_exponent': 5,\n", "}\n", "\n", - "trainer = ForcesTrainer(\n", + "trainer = OCPTrainer(\n", " task=task,\n", " model=model_params,\n", " dataset=dataset,\n", " optimizer=optimizer,\n", + " outputs={},\n", + " loss_fns={},\n", + " eval_metrics={},\n", + " name=\"s2ef\",\n", " identifier=\"S2EF-simple\",\n", " run_dir=\"./\", # directory to save results if is_debug=False. Prediction files are saved here so be careful not to override!\n", " is_debug=False, # if True, do not save checkpoint, logs, or results\n", - " is_vis=False,\n", - " print_every=20,\n", + " print_every=5,\n", " seed=0, # random seed to use\n", " logger=\"tensorboard\", # logger of choice (tensorboard and wandb supported)\n", " local_rank=0,\n", + " amp=True, # use PyTorch Automatic Mixed Precision (faster training and less memory usage),\n", ")\n", "\n", "trainer.train()" @@ -3141,19 +2698,23 @@ " 'direct_forces': True,\n", "}\n", "\n", - "trainer = ForcesTrainer(\n", + "trainer = OCPTrainer(\n", " task=task,\n", " model=model_params,\n", " dataset=dataset,\n", " optimizer=optimizer,\n", + " outputs={},\n", + " loss_fns={},\n", + " eval_metrics={},\n", + " name=\"s2ef\",\n", " identifier=\"S2EF-gemnet-t\",\n", " run_dir=\"./\", # directory to save results if is_debug=False. Prediction files are saved here so be careful not to override!\n", " is_debug=False, # if True, do not save checkpoint, logs, or results\n", - " is_vis=False,\n", - " print_every=20,\n", + " print_every=5,\n", " seed=0, # random seed to use\n", " logger=\"tensorboard\", # logger of choice (tensorboard and wandb supported)\n", " local_rank=0,\n", + " amp=True, # use PyTorch Automatic Mixed Precision (faster training and less memory usage),\n", ")\n", "\n", "trainer.train()" @@ -3247,10 +2808,8 @@ "adslab.center(vacuum=13.0, axis=2)\n", "adslab.set_pbc(True)\n", "\n", - "config_yml_path = \"configs/s2ef/all/gemnet/gemnet-dT.yml\"\n", - "\n", "# Define the calculator\n", - "calc = OCPCalculator(config_yml=config_yml_path, checkpoint=checkpoint_path)\n", + "calc = OCPCalculator(checkpoint_path=checkpoint_path)\n", "\n", "# Set up the calculator\n", "adslab.calc = calc\n", @@ -3284,7 +2843,7 @@ "\n", "\n", "#### Initial Structure to Relaxed Energy (IS2RE) LMDBs\n", - "IS2RE/IS2RS LMDBs utilize the SinglePointLmdb dataset. This dataset expects the data to be contained in a **single** LMDB file. In addition to the attributes defined by AtomsToGraph, the following attributes must be added for the IS2RE/IS2RS tasks:\n", + "IS2RE/IS2RS LMDBs utilize the LmdbDataset dataset. This dataset expects the data to be contained in a **single** LMDB file. In addition to the attributes defined by AtomsToGraph, the following attributes must be added for the IS2RE/IS2RS tasks:\n", "\n", "- pos_relaxed: Relaxed adslab positions\n", "- sid: Unique system identifier, arbitrary\n", @@ -3440,10 +2999,10 @@ }, "outputs": [], "source": [ - "from ocpmodels.datasets import SinglePointLmdbDataset\n", + "from ocpmodels.datasets import LmdbDataset\n", "\n", - "# SinglePointLmdbDataset is out custom Dataset method to read the lmdbs as Data objects. Note that we need to give the entire path (including lmdb) for IS2RE\n", - "dataset = SinglePointLmdbDataset({\"src\": \"data/toy_C3H8.lmdb\"})\n", + "# LmdbDataset is out custom Dataset method to read the lmdbs as Data objects. Note that we need to give the entire path (including lmdb) for IS2RE\n", + "dataset = LmdbDataset({\"src\": \"data/toy_C3H8.lmdb\"})\n", "\n", "print(\"Size of the dataset created:\", len(dataset))\n", "print(dataset[0])" @@ -3457,7 +3016,7 @@ "source": [ "#### Structure to Energy and Forces (S2EF) LMDBs\n", "\n", - "S2EF LMDBs utilize the TrajectoryLmdb dataset. This dataset expects a directory of LMDB files. In addition to the attributes defined by AtomsToGraph, the following attributes must be added for the S2EF task:\n", + "S2EF LMDBs utilize the LmdbDatset dataset. This dataset expects a directory of LMDB files. In addition to the attributes defined by AtomsToGraph, the following attributes must be added for the S2EF task:\n", "\n", "- tags (optional): 0 - subsurface, 1 - surface, 2 - adsorbate\n", "- fid: Frame index along the trajcetory\n", diff --git a/tutorials/train_s2ef_example.ipynb b/tutorials/train_s2ef_example.ipynb deleted file mode 100644 index 0e9c57159..000000000 --- a/tutorials/train_s2ef_example.ipynb +++ /dev/null @@ -1,666 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# SchNet S2EF training example" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The purpose of this notebook is to demonstrate some of the basics of the Open Catalyst Project's (OCP) codebase and data. In this example, we will train a schnet model for predicting the energy and forces of a given structure (S2EF task). First, ensure you have installed the OCP ocp repo and all the dependencies according to the [README](https://github.com/Open-Catalyst-Project/ocp/blob/master/README.md)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Disclaimer: This notebook is for tutorial purposes, it is unlikely it will be practical to train baseline models on our larger datasets using this format. As a next step, we recommend trying the command line examples. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Imports" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [], - "source": [ - "import torch\n", - "import os\n", - "from ocpmodels.trainers import ForcesTrainer\n", - "from ocpmodels import models\n", - "from ocpmodels.common import logger\n", - "from ocpmodels.common.utils import setup_logging\n", - "setup_logging()" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "True\n" - ] - } - ], - "source": [ - "# a simple sanity check that a GPU is available\n", - "if torch.cuda.is_available():\n", - " print(\"True\")\n", - "else:\n", - " print(\"False\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## The essential steps for training an OCP model\n", - "\n", - "1) Download data\n", - "\n", - "2) Preprocess data (if necessary)\n", - "\n", - "3) Define or load a configuration (config), which includes the following\n", - " \n", - " - task\n", - " - model\n", - " - optimizer\n", - " - dataset\n", - " - trainer\n", - "\n", - "4) Train\n", - "\n", - "5) Depending on the model/task there might be intermediate relaxation step\n", - "\n", - "6) Predict" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Dataset" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This examples uses the LMDB generated from the following [tutorial](http://laikapack.cheme.cmu.edu/notebook/open-catalyst-project/mshuaibi/notebooks/projects/ocp/docs/source/tutorials/lmdb_dataset_creation.ipynb). Please run that notebook before moving on. Alternatively, if you have other LMDBs available you may specify that instead." - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [], - "source": [ - "# set the path to your local lmdb directory\n", - "train_src = \"s2ef\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Define config" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For this example, we will explicitly define the config; however, a set of default config files exists in the config folder of this repository. Default config yaml files can easily be loaded with the `build_config` util (found in `ocp/ocpmodels/common/utils.py`). Loading a yaml config is preferrable when launching jobs from the command line. We have included our best models' config files [here](https://github.com/Open-Catalyst-Project/ocp/tree/master/configs/s2ef)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Task** " - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [], - "source": [ - "task = {\n", - " 'dataset': 'trajectory_lmdb', # dataset used for the S2EF task\n", - " 'description': 'Regressing to energies and forces for DFT trajectories from OCP',\n", - " 'type': 'regression',\n", - " 'metric': 'mae',\n", - " 'labels': ['potential energy'],\n", - " 'grad_input': 'atomic forces',\n", - " 'train_on_free_atoms': True,\n", - " 'eval_on_free_atoms': True\n", - "}" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Model** - SchNet for this example" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [], - "source": [ - "model = {\n", - " 'name': 'schnet',\n", - " 'hidden_channels': 1024, # if training is too slow for example purposes reduce the number of hidden channels\n", - " 'num_filters': 256,\n", - " 'num_interactions': 3,\n", - " 'num_gaussians': 200,\n", - " 'cutoff': 6.0\n", - "}" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Optimizer**" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [], - "source": [ - "optimizer = {\n", - " 'batch_size': 16, # if hitting GPU memory issues, lower this\n", - " 'eval_batch_size': 8,\n", - " 'num_workers': 8,\n", - " 'lr_initial': 0.0001,\n", - " 'scheduler': \"ReduceLROnPlateau\",\n", - " 'mode': \"min\",\n", - " 'factor': 0.8,\n", - " 'patience': 3,\n", - " 'max_epochs': 80,\n", - " 'max_epochs': 1, # used for demonstration purposes\n", - " 'force_coefficient': 100,\n", - "}" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Dataset**" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For simplicity, `train_src` is used for all the train/val/test sets. Feel free to update with the actual S2EF val and test sets, but it does require additional downloads and preprocessing. If you desire to normalize your targets, `normalize_labels` must be set to `True` and corresponding `mean` and `stds` need to be specified. These values have been precomputed for you and can be found in any of the [`base.yml`](https://github.com/Open-Catalyst-Project/ocp/blob/master/configs/s2ef/20M/base.yml#L5-L9) config files." - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [], - "source": [ - "dataset = [\n", - "{'src': train_src, 'normalize_labels': False}, # train set \n", - "{'src': train_src}, # val set (optional)\n", - "{'src': train_src} # test set (optional - writes predictions to disk)\n", - "]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Trainer**" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Use the `ForcesTrainer` for the S2EF and IS2RS tasks, and the `EnergyTrainer` for the IS2RE task " - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "amp: false\n", - "cmd:\n", - " checkpoint_dir: ./checkpoints/2021-09-04-08-51-28-SchNet-example\n", - " commit: 98a06d8\n", - " identifier: SchNet-example\n", - " logs_dir: ./logs/tensorboard/2021-09-04-08-51-28-SchNet-example\n", - " print_every: 5\n", - " results_dir: ./results/2021-09-04-08-51-28-SchNet-example\n", - " seed: 0\n", - " timestamp_id: 2021-09-04-08-51-28-SchNet-example\n", - "dataset:\n", - " normalize_labels: false\n", - " src: s2ef\n", - "gpus: 1\n", - "logger: tensorboard\n", - "model: schnet\n", - "model_attributes:\n", - " cutoff: 6.0\n", - " hidden_channels: 1024\n", - " num_filters: 256\n", - " num_gaussians: 200\n", - " num_interactions: 3\n", - "optim:\n", - " batch_size: 16\n", - " eval_batch_size: 8\n", - " factor: 0.8\n", - " force_coefficient: 100\n", - " lr_initial: 0.0001\n", - " max_epochs: 1\n", - " mode: min\n", - " num_workers: 8\n", - " patience: 3\n", - " scheduler: ReduceLROnPlateau\n", - "slurm: {}\n", - "task:\n", - " dataset: trajectory_lmdb\n", - " description: Regressing to energies and forces for DFT trajectories from OCP\n", - " eval_on_free_atoms: true\n", - " grad_input: atomic forces\n", - " labels:\n", - " - potential energy\n", - " metric: mae\n", - " train_on_free_atoms: true\n", - " type: regression\n", - "test_dataset:\n", - " src: s2ef\n", - "val_dataset:\n", - " src: s2ef\n", - "\n", - "2021-09-04 08:51:37 (INFO): Loading dataset: trajectory_lmdb\n", - "2021-09-04 08:51:37 (INFO): Loading model: schnet\n", - "2021-09-04 08:51:37 (INFO): Loaded SchNet with 5704193 parameters.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-04 08:51:37 (WARNING): Model gradient logging to tensorboard not yet supported.\n" - ] - } - ], - "source": [ - "trainer = ForcesTrainer(\n", - " task=task,\n", - " model=model,\n", - " dataset=dataset,\n", - " optimizer=optimizer,\n", - " identifier=\"SchNet-example\",\n", - " run_dir=\"./\", # directory to save results if is_debug=False. Prediction files are saved here so be careful not to override!\n", - " is_debug=False, # if True, do not save checkpoint, logs, or results\n", - " is_vis=False,\n", - " print_every=5,\n", - " seed=0, # random seed to use\n", - " logger=\"tensorboard\", # logger of choice (tensorboard and wandb supported)\n", - " local_rank=0,\n", - " amp=False, # use PyTorch Automatic Mixed Precision (faster training and less memory usage)\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Check the model" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "OCPDataParallel(\n", - " (module): SchNet(hidden_channels=1024, num_filters=256, num_interactions=3, num_gaussians=200, cutoff=6.0)\n", - ")\n" - ] - } - ], - "source": [ - "print(trainer.model)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Train" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2021-09-04 08:51:43 (INFO): forcesx_mae: 6.12e-01, forcesy_mae: 7.54e-01, forcesz_mae: 7.98e-01, forces_mae: 7.21e-01, forces_cos: -8.32e-03, forces_magnitude: 1.34e+00, energy_mae: 3.14e+01, energy_force_within_threshold: 0.00e+00, loss: 1.04e+02, lr: 1.00e-04, epoch: 1.25e-01, step: 5.00e+00\n", - "2021-09-04 08:51:43 (INFO): forcesx_mae: 4.95e-01, forcesy_mae: 5.85e-01, forcesz_mae: 6.06e-01, forces_mae: 5.62e-01, forces_cos: -1.64e-03, forces_magnitude: 9.97e-01, energy_mae: 2.38e+01, energy_force_within_threshold: 0.00e+00, loss: 8.02e+01, lr: 1.00e-04, epoch: 2.50e-01, step: 1.00e+01\n", - "2021-09-04 08:51:44 (INFO): forcesx_mae: 4.35e-01, forcesy_mae: 5.44e-01, forcesz_mae: 5.30e-01, forces_mae: 5.03e-01, forces_cos: 2.57e-02, forces_magnitude: 9.14e-01, energy_mae: 2.09e+01, energy_force_within_threshold: 0.00e+00, loss: 7.11e+01, lr: 1.00e-04, epoch: 3.75e-01, step: 1.50e+01\n", - "2021-09-04 08:51:44 (INFO): forcesx_mae: 3.70e-01, forcesy_mae: 4.50e-01, forcesz_mae: 4.22e-01, forces_mae: 4.14e-01, forces_cos: 3.03e-03, forces_magnitude: 7.05e-01, energy_mae: 1.66e+01, energy_force_within_threshold: 0.00e+00, loss: 5.83e+01, lr: 1.00e-04, epoch: 5.00e-01, step: 2.00e+01\n", - "2021-09-04 08:51:45 (INFO): forcesx_mae: 3.61e-01, forcesy_mae: 4.58e-01, forcesz_mae: 4.42e-01, forces_mae: 4.20e-01, forces_cos: 3.09e-02, forces_magnitude: 7.07e-01, energy_mae: 1.40e+01, energy_force_within_threshold: 0.00e+00, loss: 5.58e+01, lr: 1.00e-04, epoch: 6.25e-01, step: 2.50e+01\n", - "2021-09-04 08:51:45 (INFO): forcesx_mae: 3.51e-01, forcesy_mae: 3.96e-01, forcesz_mae: 3.91e-01, forces_mae: 3.79e-01, forces_cos: 2.94e-02, forces_magnitude: 6.65e-01, energy_mae: 1.39e+01, energy_force_within_threshold: 0.00e+00, loss: 5.19e+01, lr: 1.00e-04, epoch: 7.50e-01, step: 3.00e+01\n", - "2021-09-04 08:51:46 (INFO): forcesx_mae: 3.13e-01, forcesy_mae: 3.46e-01, forcesz_mae: 3.38e-01, forces_mae: 3.32e-01, forces_cos: 2.50e-02, forces_magnitude: 5.61e-01, energy_mae: 9.40e+00, energy_force_within_threshold: 0.00e+00, loss: 4.23e+01, lr: 1.00e-04, epoch: 8.75e-01, step: 3.50e+01\n", - "2021-09-04 08:51:46 (INFO): forcesx_mae: 3.06e-01, forcesy_mae: 3.59e-01, forcesz_mae: 3.59e-01, forces_mae: 3.41e-01, forces_cos: 1.31e-02, forces_magnitude: 5.62e-01, energy_mae: 1.02e+01, energy_force_within_threshold: 0.00e+00, loss: 4.91e+01, lr: 1.00e-04, epoch: 1.00e+00, step: 4.00e+01\n", - "2021-09-04 08:51:46 (INFO): Evaluating on val.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "device 0: 100%|██████████| 79/79 [00:01<00:00, 39.87it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2021-09-04 08:51:48 (INFO): forcesx_mae: 0.2778, forcesy_mae: 0.3467, forcesz_mae: 0.3606, forces_mae: 0.3284, forces_cos: 0.0278, forces_magnitude: 0.5615, energy_mae: 12.4560, energy_force_within_threshold: 0.0000, loss: 44.8795, epoch: 1.0000\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2021-09-04 08:51:49 (INFO): Predicting on test.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "device 0: 100%|██████████| 79/79 [00:01<00:00, 41.47it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2021-09-04 08:51:51 (INFO): Writing results to ./results/2021-09-04-08-51-28-SchNet-example/s2ef_predictions.npz\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "trainer.train()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Load Checkpoint\n", - "Once training has completed a `Trainer` class, by default, is loaded with the best checkpoint as determined by training or validation (if available) metrics. To load a `Trainer` class directly with a pretrained model, specify the `checkpoint_path` as defined by your previously trained model (`checkpoint_dir`):" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'./checkpoints/2021-09-04-08-51-28-SchNet-example/checkpoint.pt'" - ] - }, - "execution_count": 37, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "checkpoint_path = os.path.join(trainer.config[\"cmd\"][\"checkpoint_dir\"], \"checkpoint.pt\")\n", - "checkpoint_path" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "amp: false\n", - "cmd:\n", - " checkpoint_dir: ./checkpoints/2021-09-04-08-51-28-SchNet-example\n", - " commit: 98a06d8\n", - " identifier: SchNet-example\n", - " logs_dir: ./logs/tensorboard/2021-09-04-08-51-28-SchNet-example\n", - " print_every: 10\n", - " results_dir: ./results/2021-09-04-08-51-28-SchNet-example\n", - " seed: 0\n", - " timestamp_id: 2021-09-04-08-51-28-SchNet-example\n", - "dataset:\n", - " normalize_labels: false\n", - " src: s2ef\n", - "gpus: 1\n", - "logger: tensorboard\n", - "model: schnet\n", - "model_attributes:\n", - " cutoff: 6.0\n", - " hidden_channels: 1024\n", - " num_filters: 256\n", - " num_gaussians: 200\n", - " num_interactions: 3\n", - "optim:\n", - " batch_size: 16\n", - " eval_batch_size: 8\n", - " factor: 0.8\n", - " force_coefficient: 100\n", - " lr_initial: 0.0001\n", - " max_epochs: 1\n", - " mode: min\n", - " num_workers: 8\n", - " patience: 3\n", - " scheduler: ReduceLROnPlateau\n", - "slurm: {}\n", - "task:\n", - " dataset: trajectory_lmdb\n", - " description: Regressing to energies and forces for DFT trajectories from OCP\n", - " eval_on_free_atoms: true\n", - " grad_input: atomic forces\n", - " labels:\n", - " - potential energy\n", - " metric: mae\n", - " train_on_free_atoms: true\n", - " type: regression\n", - "test_dataset:\n", - " src: s2ef\n", - "val_dataset:\n", - " src: s2ef\n", - "\n", - "2021-09-04 08:51:51 (INFO): Loading dataset: trajectory_lmdb\n", - "2021-09-04 08:51:51 (INFO): Loading model: schnet\n", - "2021-09-04 08:51:51 (INFO): Loaded SchNet with 5704193 parameters.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-04 08:51:51 (WARNING): Model gradient logging to tensorboard not yet supported.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2021-09-04 08:51:51 (INFO): Loading checkpoint from: ./checkpoints/2021-09-04-08-51-28-SchNet-example/checkpoint.pt\n" - ] - } - ], - "source": [ - "model = {\n", - " 'name': 'schnet',\n", - " 'hidden_channels': 1024, # if training is too slow for example purposes reduce the number of hidden channels\n", - " 'num_filters': 256,\n", - " 'num_interactions': 3,\n", - " 'num_gaussians': 200,\n", - " 'cutoff': 6.0\n", - "}\n", - "\n", - "pretrained_trainer = ForcesTrainer(\n", - " task=task,\n", - " model=model,\n", - " dataset=dataset,\n", - " optimizer=optimizer,\n", - " identifier=\"SchNet-example\",\n", - " run_dir=\"./\", # directory to save results if is_debug=False. Prediction files are saved here so be careful not to override!\n", - " is_debug=False, # if True, do not save checkpoint, logs, or results\n", - " is_vis=False,\n", - " print_every=10,\n", - " seed=0, # random seed to use\n", - " logger=\"tensorboard\", # logger of choice (tensorboard and wandb supported)\n", - " local_rank=0,\n", - " amp=False, # use PyTorch Automatic Mixed Precision (faster training and less memory usage)\n", - ")\n", - "\n", - "pretrained_trainer.load_checkpoint(checkpoint_path=checkpoint_path)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Predict" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If a test has been provided in your config, predictions are generated and written to disk automatically upon training completion. Otherwise, to make predictions on unseen data a `torch.utils.data` DataLoader object must be constructed. Here we reference our test set to make predictions on. Predictions are saved in `{results_file}.npz` in your `results_dir`." - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2021-09-04 08:51:51 (INFO): Predicting on test.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "device 0: 100%|██████████| 79/79 [00:01<00:00, 44.68it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2021-09-04 08:51:53 (INFO): Writing results to ./results/2021-09-04-08-51-28-SchNet-example/s2ef_s2ef_results.npz\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "# make predictions on the existing test_loader\n", - "predictions = pretrained_trainer.predict(pretrained_trainer.test_loader, results_file=\"s2ef_results\", disable_tqdm=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [], - "source": [ - "energies = predictions[\"energy\"]\n", - "forces = predictions[\"forces\"]" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "ocp-models", - "language": "python", - "name": "ocp-models" - }, - "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.8.10" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -}