From 7c963c47899ddc154d8b577166f5ec63164dd9b0 Mon Sep 17 00:00:00 2001 From: wassname Date: Sat, 11 Apr 2020 12:50:35 +0800 Subject: [PATCH] refactoring --- anp-rnn_1d_regression.ipynb | 4 +- {src => neural_processes}/__init__.py | 0 {src => neural_processes}/data/__init__.py | 0 {src => neural_processes}/data/gp_curves.py | 0 {src => neural_processes}/data/smart_meter.py | 0 {src => neural_processes}/dict_logger.py | 0 neural_processes/lightning.py | 180 + neural_processes/logger.py | 4 + {src => neural_processes}/models/__init__.py | 0 neural_processes/models/lstm_seqseq.py | 147 + {src => neural_processes}/models/lstm_std.py | 8 +- .../models/neural_process/__init__.py | 2 + .../models/neural_process/lightning.py | 82 + .../models/neural_process}/model.py | 212 +- neural_processes/models/transformer.py | 165 + .../models/transformer_seq2seq.py | 148 +- neural_processes/modules/__init__.py | 2 + neural_processes/modules/attention.py | 124 + neural_processes/modules/modules.py | 107 + neural_processes/optuna.py | 0 {src => neural_processes}/plot.py | 0 {src => neural_processes}/train.py | 15 + {src => neural_processes}/utils.py | 26 + smartmeters-ANP-RNN-Copy1.ipynb | 10 +- smartmeters-ANP-RNN-mcdropout.ipynb | 22 +- smartmeters-ANP-RNN.ipynb | 4477 +---------------- smartmeters-lstm-deterministic.ipynb | 14 +- smartmeters-lstm-seq2seq.ipynb | 14 +- smartmeters-lstm_std.ipynb | 14 +- smartmeters-transformer-seq2seq.ipynb | 14 +- src/models/lightning_anp.py | 217 - src/models/lstm.py | 299 -- src/models/lstm_seqseq.py | 281 -- src/models/modules.py | 410 -- 34 files changed, 1325 insertions(+), 5673 deletions(-) rename {src => neural_processes}/__init__.py (100%) rename {src => neural_processes}/data/__init__.py (100%) rename {src => neural_processes}/data/gp_curves.py (100%) rename {src => neural_processes}/data/smart_meter.py (100%) rename {src => neural_processes}/dict_logger.py (100%) create mode 100644 neural_processes/lightning.py create mode 100644 neural_processes/logger.py rename {src => neural_processes}/models/__init__.py (100%) create mode 100644 neural_processes/models/lstm_seqseq.py rename {src => neural_processes}/models/lstm_std.py (97%) create mode 100644 neural_processes/models/neural_process/__init__.py create mode 100644 neural_processes/models/neural_process/lightning.py rename {src/models => neural_processes/models/neural_process}/model.py (51%) create mode 100644 neural_processes/models/transformer.py rename {src => neural_processes}/models/transformer_seq2seq.py (53%) create mode 100644 neural_processes/modules/__init__.py create mode 100644 neural_processes/modules/attention.py create mode 100644 neural_processes/modules/modules.py create mode 100644 neural_processes/optuna.py rename {src => neural_processes}/plot.py (100%) rename {src => neural_processes}/train.py (93%) rename {src => neural_processes}/utils.py (72%) delete mode 100644 src/models/lightning_anp.py delete mode 100644 src/models/lstm.py delete mode 100644 src/models/lstm_seqseq.py delete mode 100644 src/models/modules.py diff --git a/anp-rnn_1d_regression.ipynb b/anp-rnn_1d_regression.ipynb index c87d29b..62a35c4 100644 --- a/anp-rnn_1d_regression.ipynb +++ b/anp-rnn_1d_regression.ipynb @@ -99,8 +99,8 @@ }, "outputs": [], "source": [ - "from src.data.gp_curves import GPCurvesReader\n", - "from src.models.model import LatentModel" + "from neural_processes.data.gp_curves import GPCurvesReader\n", + "from neural_processes.models.model import LatentModel" ] }, { diff --git a/src/__init__.py b/neural_processes/__init__.py similarity index 100% rename from src/__init__.py rename to neural_processes/__init__.py diff --git a/src/data/__init__.py b/neural_processes/data/__init__.py similarity index 100% rename from src/data/__init__.py rename to neural_processes/data/__init__.py diff --git a/src/data/gp_curves.py b/neural_processes/data/gp_curves.py similarity index 100% rename from src/data/gp_curves.py rename to neural_processes/data/gp_curves.py diff --git a/src/data/smart_meter.py b/neural_processes/data/smart_meter.py similarity index 100% rename from src/data/smart_meter.py rename to neural_processes/data/smart_meter.py diff --git a/src/dict_logger.py b/neural_processes/dict_logger.py similarity index 100% rename from src/dict_logger.py rename to neural_processes/dict_logger.py diff --git a/neural_processes/lightning.py b/neural_processes/lightning.py new file mode 100644 index 0000000..299a431 --- /dev/null +++ b/neural_processes/lightning.py @@ -0,0 +1,180 @@ +import pytorch_lightning as pl +import torch +import optuna +import torch +from torch import nn +from pathlib import Path +from pytorch_lightning.callbacks import EarlyStopping +from optuna.integration.pytorch_lightning import _check_pytorch_lightning_availability +import torch.nn.functional as F +from .utils import ObjectDict +from .data.smart_meter import get_smartmeter_df +from .logger import logger + + +class PL_Seq2Seq(pl.LightningModule): + def __init__(self, hparams, loss_fn=F.mse_loss, num_workers=3, MODEL_CLS=None): + super().__init__() + self.hparams = ObjectDict() + self.hparams.update( + hparams.__dict__ if hasattr(hparams, "__dict__") else hparams + ) + self.num_workers = num_workers + self._model = MODEL_CLS(self.hparams) + self._datasets = None + self.loss_fn = loss_fn + self.train_logs = [] # HACK + self._dfs = None + # TODO make label name configurable + # TODO make data source configurable + + def forward(self, *args, **kwargs): + return self._model(*args, **kwargs) + + def training_step(self, batch, batch_idx): + # REQUIRED + assert all(torch.isfinite(d).all() for d in batch) + context_x, context_y, target_x, target_y = batch + y_dist, losses, extra = self.forward(context_x, context_y, target_x, target_y) + loss = losses['loss_p'] # + loss_mse + tensorboard_logs = { + "train/loss": loss, + 'train/loss_mse': losses['loss_mse'], + "train/loss_p": losses['loss_p'], + "train/sigma": torch.exp(extra['log_sigma']).mean()} + return {"loss": loss, "log": tensorboard_logs} + + def validation_step(self, batch, batch_idx): + context_x, context_y, target_x, target_y = batch + assert all(torch.isfinite(d).all() for d in batch) + y_dist, losses, extra = self.forward(context_x, context_y, target_x, target_y) + loss = losses['loss_p'] # + loss_mse + tensorboard_logs = { + "val_loss": loss, + 'val/loss_mse': losses['loss_mse'], + "val/loss_p": losses['loss_p'], + "val/sigma": torch.exp(extra['log_sigma']).mean()} + return {"val_loss": loss, "log": tensorboard_logs} + + def validation_end(self, outputs): + if int(self.hparams["vis_i"]) > 0: + self.show_image() + + avg_loss = torch.stack([x["val_loss"] for x in outputs]).mean() + keys = outputs[0]["log"].keys() + tensorboard_logs = { + k: torch.stack([x["log"][k] for x in outputs if k in x["log"]]).mean() + for k in keys + } + tensorboard_logs_str = {k: f"{v}" for k, v in tensorboard_logs.items()} + print(f"step {self.trainer.global_step}, {tensorboard_logs_str}") + assert torch.isfinite(avg_loss) + return {"avg_val_loss": avg_loss, "log": tensorboard_logs} + + def agg_logs(self, outputs): + if isinstance(outputs, dict): + outputs = [outputs] + aggs = {} + if len(outputs)>0: + for j in outputs[0]: + if isinstance(outputs[0][j], dict): + # Take mean of sub dicts + keys = outputs[0][j].keys() + aggs[j] = {k: torch.stack([x[j][k] for x in outputs if k in x[j]]).mean().item() for k in keys} + else: + # Take mean of numbers + aggs[j] = torch.stack([x[j] for x in outputs if j in x]).mean().item() + return aggs + + def show_image(self): + # https://github.com/PytorchLightning/pytorch-lightning/blob/f8d9f8f/pytorch_lightning/core/lightning.py#L293 + loader = self.val_dataloader() + vis_i = min(int(self.hparams["vis_i"]), len(loader.dataset)) + # print('vis_i', vis_i) + if isinstance(self.hparams["vis_i"], str): + image = plot_from_loader(loader, self, i=int(vis_i)) + plt.show() + else: + image = plot_from_loader_to_tensor(loader, self, i=vis_i) + self.logger.experiment.add_image('val/image', image, self.trainer.global_step) + + def test_step(self, batch, batch_idx): + pred, losses, extra = self.forward(*batch) + # For test use a diff loss, MSE over next 24 + # loss = losses["loss"] + loss = F.mse_loss(pred, batch[-1], reduction='none')[:, :24].mean() + tensorboard_logs = {"test_" + k: v for k, v in losses.items()} + return {"test_loss": loss, "log": tensorboard_logs} + + def test_end(self, outputs): + avg_loss = torch.stack([x["test_loss"] for x in outputs]).mean() + keys = outputs[0]["log"].keys() + tensorboard_logs = { + k: torch.stack([x["log"][k] for x in outputs if k in x["log"]]).mean() + for k in keys + } + tensorboard_logs_str = {k: f"{v}" for k, v in tensorboard_logs.items()} + + logger.info( + f"step {self.trainer.global_step}, {tensorboard_logs_str}" + ) + return {"avg_val_loss": avg_loss, "log": tensorboard_logs} + + def configure_optimizers(self): + optim = torch.optim.Adam(self.parameters(), lr=self.hparams["learning_rate"]) + scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( + optim, patience=self.hparams["patience"], verbose=True, min_lr=1e-7 + ) # note early stopping has patience 3 + return [optim], [scheduler] + + def _get_cache_dfs(self): + if self._dfs is None: + df_train, df_val, df_test = get_smartmeter_df() + self._dfs = dict(df_train=df_train, df_val=df_val, df_test=df_test) + return self._dfs + + @pl.data_loader + def train_dataloader(self): + df_train = self._get_cache_dfs()['df_train'] + data_train = SmartMeterDataSet( + df_train, self.hparams["num_context"], self.hparams["num_extra_target"] + ) + return torch.utils.data.DataLoader( + data_train, + batch_size=self.hparams["batch_size"], + shuffle=True, + collate_fn=collate_fns( + self.hparams["num_context"], self.hparams["num_extra_target"], sample=True, context_in_target=self.hparams["context_in_target"] + ), + num_workers=self.hparams["num_workers"], + ) + + @pl.data_loader + def val_dataloader(self): + df_test = self._get_cache_dfs()['df_val'] + data_test = SmartMeterDataSet( + df_test, self.hparams["num_context"], self.hparams["num_extra_target"] + ) + return torch.utils.data.DataLoader( + data_test, + batch_size=self.hparams["batch_size"], + shuffle=False, + collate_fn=collate_fns( + self.hparams["num_context"], self.hparams["num_extra_target"], sample=False, context_in_target=self.hparams["context_in_target"] + ), + ) + + @pl.data_loader + def test_dataloader(self): + df_test = self._get_cache_dfs()['df_test'] + data_test = SmartMeterDataSet( + df_test, self.hparams["num_context"], self.hparams["num_extra_target"] + ) + return torch.utils.data.DataLoader( + data_test, + batch_size=self.hparams["batch_size"], + shuffle=False, + collate_fn=collate_fns( + self.hparams["num_context"], self.hparams["num_extra_target"], sample=False, context_in_target=self.hparams["context_in_target"] + ), + ) diff --git a/neural_processes/logger.py b/neural_processes/logger.py new file mode 100644 index 0000000..1f17053 --- /dev/null +++ b/neural_processes/logger.py @@ -0,0 +1,4 @@ +import logging +import sys +logging.basicConfig(stream=sys.stdout, level=logging.INFO) +logger = logging.getLogger('predict_heading2') diff --git a/src/models/__init__.py b/neural_processes/models/__init__.py similarity index 100% rename from src/models/__init__.py rename to neural_processes/models/__init__.py diff --git a/neural_processes/models/lstm_seqseq.py b/neural_processes/models/lstm_seqseq.py new file mode 100644 index 0000000..6a72dc3 --- /dev/null +++ b/neural_processes/models/lstm_seqseq.py @@ -0,0 +1,147 @@ +import os +import numpy as np +import pandas as pd +import torch +from tqdm.auto import tqdm +from torch import nn +from torch.nn import functional as F +from torch.utils.data import DataLoader +from torchvision.datasets import MNIST +from test_tube import Experiment, HyperOptArgumentParser +from neural_processes.data.smart_meter import collate_fns, SmartMeterDataSet, get_smartmeter_df +import torchvision.transforms as transforms +from neural_processes.plot import plot_from_loader_to_tensor, plot_from_loader +from argparse import ArgumentParser +import json +import pytorch_lightning as pl +import math +from matplotlib import pyplot as plt +import torch +import io +import PIL +from torchvision.transforms import ToTensor +from neural_processes.modules import BatchNormSequence +from neural_processes.data.smart_meter import get_smartmeter_df + +from neural_processes.utils import ObjectDict +from neural_processes.lightning import PL_Seq2Seq + + +class Seq2SeqNet(nn.Module): + def __init__(self, hparams, _min_std = 0.05): + super().__init__() + self.hparams = hparams + self._min_std = _min_std + + + self.norm_input = BatchNormSequence(self.hparams.input_size) + self.encoder = nn.LSTM( + input_size=self.hparams.input_size, + hidden_size=self.hparams.hidden_size, + batch_first=True, + num_layers=self.hparams.lstm_layers, + bidirectional=self.hparams.bidirectional, + dropout=self.hparams.lstm_dropout, + ) + self.multihead_attn = nn.MultiheadAttention(self.hparams.hidden_size, num_heads=8) + + self.norm_target = BatchNormSequence(self.hparams.input_size_decoder) + self.decoder = nn.LSTM( + input_size=self.hparams.input_size_decoder, + hidden_size=self.hparams.hidden_size, + batch_first=True, + num_layers=self.hparams.lstm_layers, + bidirectional=self.hparams.bidirectional, + dropout=self.hparams.lstm_dropout, + ) + self.hidden_out_size = ( + self.hparams.hidden_size + * (self.hparams.bidirectional + 1) + ) + self.mean = nn.Linear(self.hidden_out_size, self.hparams.output_size) + self.std = nn.Linear(self.hidden_out_size, self.hparams.output_size) + self._use_lvar = False + + def forward(self, context_x, context_y, target_x, target_y=None): + x = torch.cat([context_x, context_y], -1) + + # Sometimes input normalisation can be important, an initial batch norm is a nice way to ensure this + x = self.norm_input(x) + target_x = self.norm_target(target_x) + + _, (h_out, cell) = self.encoder(x) + # hidden = [batch size, n layers * n directions, hid dim] + # cell = [batch size, n layers * n directions, hid dim] + + # context_x, d_encoded, target_x = k, v, q + + # query, key, value = target_x, context_x, d_encoded + attn_output, _ = self.multihead_attn(h_out.permute(1, 0, 2), h_out.permute(1, 0, 2), h_out.permute(1, 0, 2)) + h_out = attn_output.permute(1, 0, 2).contiguous() + attn_output, _ = self.multihead_attn(cell.permute(1, 0, 2), cell.permute(1, 0, 2), cell.permute(1, 0, 2)) + cell = attn_output.permute(1, 0, 2).contiguous() + + outputs, (_, _) = self.decoder(target_x, (h_out, cell)) + # output = [batch size, seq len, hid dim * n directions] + + # outputs: [B, T, num_direction * H] + mean = self.mean(outputs) + log_sigma = self.std(outputs) + if self._use_lvar: + log_sigma = torch.clamp(log_sigma, math.log(self._min_std), -math.log(self._min_std)) + sigma = torch.exp(log_sigma) + else: + sigma = self._min_std + (1 - self._min_std) * F.softplus(log_sigma) + y_dist=torch.distributions.Normal(mean, sigma) + + # Loss + loss_mse = loss_p = None + if target_y is not None: + loss_mse = F.mse_loss(mean, target_y, reduction='none') + if self._use_lvar: + loss_p = -log_prob_sigma(target_y, mean, log_sigma) + else: + loss_p = -y_dist.log_prob(target_y).mean(-1) + + if self.hparams["context_in_target"]: + loss_p[:context_x.size(1)] /= 100 + loss_mse[:context_x.size(1)] /= 100 + # # Don't catch loss on context window + # mean = mean[:, self.hparams.num_context:] + # log_sigma = log_sigma[:, self.hparams.num_context:] + + y_pred = y_dist.rsample if self.training else y_dist.loc + return y_pred, dict(loss_p=loss_p.mean(), loss_mse=loss_mse.mean()), dict(log_sigma=log_sigma, dist=y_dist) + + +class LSTMSeq2Seq_PL(PL_Seq2Seq): + def __init__(self, hparams, + MODEL_CLS=Seq2SeqNet, **kwargs): + super().__init__(hparams, + MODEL_CLS=MODEL_CLS, **kwargs) + + @staticmethod + def add_suggest(trial): + # TODO make label name configurable + # TODO make data source configurable + trial.suggest_loguniform("learning_rate", 1e-5, 1e-2) + trial.suggest_uniform("lstm_dropout", 0, 0.75) + trial.suggest_categorical("hidden_size", [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]) + trial.suggest_categorical("lstm_layers", [1, 2, 4, 8]) + trial.suggest_categorical("bidirectional", [False, True]) + + + trial._user_attrs = { + 'batch_size': 16, + 'grad_clip': 40, + 'max_nb_epochs': 200, + 'num_workers': 4, + 'num_extra_target': 24*4, + 'vis_i': '670', + 'num_context': 24*4, + 'input_size': 18, + 'input_size_decoder': 17, + 'context_in_target': True, + 'output_size': 1 + } + return trial diff --git a/src/models/lstm_std.py b/neural_processes/models/lstm_std.py similarity index 97% rename from src/models/lstm_std.py rename to neural_processes/models/lstm_std.py index 9100597..590f406 100644 --- a/src/models/lstm_std.py +++ b/neural_processes/models/lstm_std.py @@ -19,9 +19,9 @@ import io import PIL from torchvision.transforms import ToTensor -from src.data.smart_meter import get_smartmeter_df +from neural_processes.data.smart_meter import get_smartmeter_df -from src.utils import ObjectDict +from neural_processes.utils import ObjectDict from torch.utils.data._utils.collate import default_collate def collate_fn(batch, sample=None): @@ -112,7 +112,7 @@ class LSTMNet(nn.Module): return mean, log_sigma -class LSTM_PL(pl.LightningModule): +class LSTM_PL_STD(pl.LightningModule): def __init__(self, hparams): # TODO make label name configurable # TODO make data source configurable @@ -126,6 +126,8 @@ class LSTM_PL(pl.LightningModule): self._use_lvar = False self._min_std = 0.005 + self.default_args = {'bidirectional': False, 'hidden_size_power': 4, 'learning_rate': 0.0010825329363784934, 'lstm_dropout': 0.3905792111699782, 'lstm_layers': 4} + def forward(self, x): return self._model(x) diff --git a/neural_processes/models/neural_process/__init__.py b/neural_processes/models/neural_process/__init__.py new file mode 100644 index 0000000..8decd26 --- /dev/null +++ b/neural_processes/models/neural_process/__init__.py @@ -0,0 +1,2 @@ +from .lightning import PL_NeuralProcess +from .model import NeuralProcess diff --git a/neural_processes/models/neural_process/lightning.py b/neural_processes/models/neural_process/lightning.py new file mode 100644 index 0000000..c96466b --- /dev/null +++ b/neural_processes/models/neural_process/lightning.py @@ -0,0 +1,82 @@ +import pytorch_lightning as pl +import torch +import torch.nn.functional as F +from argparse import ArgumentParser +from test_tube import Experiment, HyperOptArgumentParser +from .model import NeuralProcess +from neural_processes.lightning import PL_Seq2Seq + + + +class PL_NeuralProcess(PL_Seq2Seq): + def __init__(self, hparams, + MODEL_CLS=NeuralProcess, **kwargs): + super().__init__(hparams, + MODEL_CLS=MODEL_CLS, **kwargs) + + DEFAULT_ARGS = { + 'attention_dropout': 0, + 'attention_layers': 2, + 'batchnorm': False, + 'det_enc_cross_attn_type': 'multihead', + 'det_enc_self_attn_type': 'uniform', + 'dropout': 0, + 'hidden_dim': 128, + 'latent_dim': 128, + 'latent_enc_self_attn_type': 'uniform', + 'learning_rate': 0.002, + 'n_decoder_layers': 4, + 'n_det_encoder_layers': 4, + 'n_latent_encoder_layers': 2, + 'num_heads': 8, + 'use_deterministic_path': True, + 'use_lvar': True, + 'use_self_attn': True, + 'use_rnn': False, + } + + @staticmethod + def add_suggest(trial): + trial.suggest_loguniform("learning_rate", 1e-5, 1e-2) + + trial.suggest_categorical("hidden_dim", [8*2**i for i in range(8)]) + trial.suggest_categorical("latent_dim", [8*2**i for i in range(8)]) + + trial.suggest_int("attention_layers", 1, 4) + trial.suggest_categorical("n_latent_encoder_layers", [1, 2, 4, 6, 8, 12]) + trial.suggest_categorical("n_det_encoder_layers", [1, 2, 4, 6, 8, 12]) + trial.suggest_categorical("n_decoder_layers", [1, 2, 4, 6, 8, 12]) + trial.suggest_int("num_heads", 8, 8) + + trial.suggest_uniform("dropout", 0, 0.9) + trial.suggest_uniform("attention_dropout", 0, 0.9) + + trial.suggest_categorical( + "latent_enc_self_attn_type", ['uniform', 'multihead', 'ptmultihead'] + ) + trial.suggest_categorical("det_enc_self_attn_type", ['uniform', 'multihead', 'ptmultihead']) + trial.suggest_categorical("det_enc_cross_attn_type", ['uniform', 'multihead', 'ptmultihead']) + + trial.suggest_categorical("batchnorm", [False, True]) + trial.suggest_categorical("use_self_attn", [False, True]) + trial.suggest_categorical("use_lvar", [False, True]) + trial.suggest_categorical("use_deterministic_path", [False, True]) + trial.suggest_categorical("use_rnn", [True, False]) + + trial._user_attrs = { + 'batch_size': 16, + 'grad_clip': 40, + 'max_nb_epochs': 200, + 'num_workers': 4, + 'num_context': 24* 4, + 'vis_i': '670', + 'num_extra_target': 24*4, + 'x_dim': 18, + 'context_in_target': True, + 'y_dim': 1, + 'patience': 3, + 'min_std': 0.005, + } + return trial + + diff --git a/src/models/model.py b/neural_processes/models/neural_process/model.py similarity index 51% rename from src/models/model.py rename to neural_processes/models/neural_process/model.py index 99cf3d0..052d4b5 100644 --- a/src/models/model.py +++ b/neural_processes/models/neural_process/model.py @@ -4,36 +4,194 @@ import torch.nn.functional as F from torch.utils.data import TensorDataset, DataLoader import math -from src.models.modules import LatentEncoder, DeterministicEncoder, Decoder -from src.models.modules import BatchNormSequence - -def log_prob_sigma(value, loc, log_scale): - """A slightly more stable (not confirmed yet) log prob taking in log_var instead of scale. - modified from https://github.com/pytorch/pytorch/blob/2431eac7c011afe42d4c22b8b3f46dedae65e7c0/torch/distributions/normal.py#L65 - """ - var = torch.exp(log_scale * 2) - return ( - -((value - loc) ** 2) / (2 * var) - log_scale - math.log(math.sqrt(2 * math.pi)) - ) +from neural_processes.modules import BatchNormSequence +from neural_processes.utils import kl_loss_var, log_prob_sigma -def kl_loss_var(prior_mu, log_var_prior, post_mu, log_var_post): - """ - Analytical KLD for two gaussians, taking in log_variance instead of scale ( given variance=scale**2) for more stable gradients - - For version using scale see https://github.com/pytorch/pytorch/blob/master/torch/distributions/kl.py#L398 - """ +class LatentEncoder(nn.Module): + def __init__( + self, + input_dim, + hidden_dim=32, + latent_dim=32, + self_attention_type="dot", + n_encoder_layers=3, + min_std=0.01, + batchnorm=False, + dropout=0, + attention_dropout=0, + use_lvar=False, + use_self_attn=False, + attention_layers=2, + use_lstm=False + ): + super().__init__() + # self._input_layer = nn.Linear(input_dim, hidden_dim) + if use_lstm: + self._encoder = LSTMBlock(input_dim, hidden_dim, batchnorm=batchnorm, dropout=dropout, num_layers=n_encoder_layers) + else: + self._encoder = BatchMLP(input_dim, hidden_dim, batchnorm=batchnorm, dropout=dropout, num_layers=n_encoder_layers) + if use_self_attn: + self._self_attention = Attention( + hidden_dim, + self_attention_type, + attention_layers, + rep="identity", + dropout=attention_dropout, + ) + self._penultimate_layer = nn.Linear(hidden_dim, hidden_dim) + self._mean = nn.Linear(hidden_dim, latent_dim) + self._log_var = nn.Linear(hidden_dim, latent_dim) + self._min_std = min_std + self._use_lvar = use_lvar + self._use_lstm = use_lstm + self._use_self_attn = use_self_attn - var_ratio_log = log_var_post - log_var_prior - kl_div = ( - (var_ratio_log.exp() + (post_mu - prior_mu) ** 2) / log_var_prior.exp() - - 1.0 - - var_ratio_log - ) - kl_div = 0.5 * kl_div - return kl_div + def forward(self, x, y): + encoder_input = torch.cat([x, y], dim=-1) -class LatentModel(nn.Module): + # Pass final axis through MLP + encoded = self._encoder(encoder_input) + + # Aggregator: take the mean over all points + if self._use_self_attn: + attention_output = self._self_attention(encoded, encoded, encoded) + mean_repr = attention_output.mean(dim=1) + else: + mean_repr = encoded.mean(dim=1) + + # Have further MLP layers that map to the parameters of the Gaussian latent + mean_repr = torch.relu(self._penultimate_layer(mean_repr)) + + # Then apply further linear layers to output latent mu and log sigma + mean = self._mean(mean_repr) + log_var = self._log_var(mean_repr) + + if self._use_lvar: + # Clip it in the log domain, so it can only approach self.min_std, this helps avoid mode collapase + # 2 ways, a better but untested way using the more stable log domain, and the way from the deepmind repo + log_var = F.logsigmoid(log_var) + log_var = torch.clamp(log_var, np.log(self._min_std), -np.log(self._min_std)) + sigma = torch.exp(0.5 * log_var) + else: + sigma = self._min_std + (1 - self._min_std) * torch.sigmoid(log_var * 0.5) + dist = torch.distributions.Normal(mean, sigma) + return dist, log_var + + +class DeterministicEncoder(nn.Module): + def __init__( + self, + input_dim, + x_dim, + hidden_dim=32, + n_d_encoder_layers=3, + self_attention_type="dot", + cross_attention_type="dot", + use_self_attn=False, + attention_layers=2, + batchnorm=False, + dropout=0, + attention_dropout=0, + use_lstm=False, + ): + super().__init__() + self._use_self_attn = use_self_attn + # self._input_layer = nn.Linear(input_dim, hidden_dim) + if use_lstm: + self._d_encoder = LSTMBlock(input_dim, hidden_dim, batchnorm=batchnorm, dropout=dropout, num_layers=n_d_encoder_layers) + else: + self._d_encoder = BatchMLP(input_dim, hidden_dim, batchnorm=batchnorm, dropout=dropout, num_layers=n_d_encoder_layers) + if use_self_attn: + self._self_attention = Attention( + hidden_dim, + self_attention_type, + attention_layers, + rep="identity", + dropout=attention_dropout, + ) + self._cross_attention = Attention( + hidden_dim, + cross_attention_type, + x_dim=x_dim, + attention_layers=attention_layers, + ) + + def forward(self, context_x, context_y, target_x): + # Concatenate x and y along the filter axes + d_encoder_input = torch.cat([context_x, context_y], dim=-1) + + # Pass final axis through MLP + d_encoded = self._d_encoder(d_encoder_input) + + if self._use_self_attn: + d_encoded = self._self_attention(d_encoded, d_encoded, d_encoded) + + # Apply attention as mean aggregation + h = self._cross_attention(context_x, d_encoded, target_x) + + return h + + +class Decoder(nn.Module): + def __init__( + self, + x_dim, + y_dim, + hidden_dim=32, + latent_dim=32, + n_decoder_layers=3, + use_deterministic_path=True, + min_std=0.01, + use_lvar=False, + batchnorm=False, + dropout=0, + use_lstm=False, + ): + super(Decoder, self).__init__() + self._target_transform = nn.Linear(x_dim, hidden_dim) + if use_deterministic_path: + hidden_dim_2 = 2 * hidden_dim + latent_dim + else: + hidden_dim_2 = hidden_dim + latent_dim + + if use_lstm: + self._decoder = LSTMBlock(hidden_dim_2, hidden_dim_2, batchnorm=batchnorm, dropout=dropout, num_layers=n_decoder_layers) + else: + self._decoder = BatchMLP(hidden_dim_2, hidden_dim_2, batchnorm=batchnorm, dropout=dropout, num_layers=n_decoder_layers) + self._mean = nn.Linear(hidden_dim_2, y_dim) + self._std = nn.Linear(hidden_dim_2, y_dim) + self._use_deterministic_path = use_deterministic_path + self._min_std = min_std + self._use_lvar = use_lvar + + def forward(self, r, z, target_x): + # concatenate target_x and representation + x = self._target_transform(target_x) + + if self._use_deterministic_path: + z = torch.cat([r, z], dim=-1) + + r = torch.cat([z, x], dim=-1) + + r = self._decoder(r) + + # Get the mean and the variance + mean = self._mean(r) + log_sigma = self._std(r) + + # Bound or clamp the variance + if self._use_lvar: + log_sigma = torch.clamp(log_sigma, math.log(self._min_std), -math.log(self._min_std)) + sigma = torch.exp(log_sigma) + else: + sigma = self._min_std + (1 - self._min_std) * F.softplus(log_sigma) + + dist = torch.distributions.Normal(mean, sigma) + return dist, log_sigma + + +class NeuralProcess(nn.Module): def __init__(self, x_dim, # features in input y_dim, # number of features in output @@ -61,7 +219,7 @@ class LatentModel(nn.Module): **kwargs, ): - super(LatentModel, self).__init__() + super(NeuralProcess, self).__init__() self._use_rnn = use_rnn self.context_in_target = context_in_target diff --git a/neural_processes/models/transformer.py b/neural_processes/models/transformer.py new file mode 100644 index 0000000..053fd46 --- /dev/null +++ b/neural_processes/models/transformer.py @@ -0,0 +1,165 @@ +import os +import numpy as np +import pandas as pd +import torch +import optuna +from tqdm.auto import tqdm +from torch import nn +from torch.nn import functional as F +from torch.utils.data import DataLoader + +from neural_processes.lightning import PL_Seq2Seq + +class NetTransformer(nn.Module): + def __init__(self, hparams): + super().__init__() + hparams["nlayers"] = int(2 ** hparams["nlayers_power"]) + hparams["hidden_size"] = int(2**hparams["hidden_size_power"]) + hparams["hidden_out_size"] = int(2 ** hparams["hidden_out_size_power"]) + hparams["nhead"] = int(2 ** hparams["nhead_power"]) + logger.debug(f"{type(self)} hparams {hparams}") + self.hparams = hparams + + hidden_out_size = self.hparams.hidden_out_size + enc_input_size = self.hparams.input_size + self.hparams.output_size + # self.enc_norm = BatchNormSequence(enc_input_size) + self.enc_emb = nn.Linear(enc_input_size, hidden_out_size) + encoder_norm = nn.LayerNorm(hidden_out_size) + layer_enc = nn.TransformerEncoderLayer( + d_model=hidden_out_size, + dim_feedforward=self.hparams.hidden_size, + dropout=self.hparams.attention_dropout, + nhead=self.hparams.nhead, + # activation + ) + self.encoder = nn.TransformerEncoder( + layer_enc, + num_layers=self.hparams.nlayers, + norm=encoder_norm + ) + + # self.dec_norm = BatchNormSequence(self.hparams.input_size) + # self.dec_emb = nn.Linear(self.hparams.input_size, hidden_out_size) + # layer_dec = nn.TransformerDecoderLayer( + # d_model=hidden_out_size, + # dim_feedforward=self.hparams.hidden_size, + # dropout=self.hparams.attention_dropout, + # nhead=self.hparams.nhead, + # ) + # decoder_norm = nn.LayerNorm(hidden_out_size) + # self.decoder = nn.TransformerDecoder( + # layer_dec, + # num_layers=self.hparams.nlayers, + # norm=decoder_norm + # ) + self.mean = nn.Linear(hidden_out_size, self.hparams.output_size) + + def forward(self, context_x, context_y, target_x, target_y=None): + device = next(self.parameters()).device + target_y_fake = torch.ones(context_y.shape).float().to(device) * self.hparams.nan_value + context = torch.cat([context_x, context_y], -1).detach() + target = torch.cat([target_x, target_y_fake], -1).detach() + x = torch.cat([context, target * 1], 1).detach() + + # Masks + x_mask = torch.isfinite(x) & (x!=self.hparams.nan_value) + x[~x_mask] = 0 + x = x.detach() + x_key_padding_mask = ~x_mask.any(-1) + # print('x_key_padding_mask', x_mask.float().mean()) + # print(x.shape, 'x1') + x = self.enc_emb(x).permute(1, 0, 2) + # print(x.shape, 'x2') + # Size([C, B, emb_dim]) + outputs = self.encoder(x, src_key_padding_mask=x_key_padding_mask).permute(1, 0, 2) + # print(outputs.shape, 'outputs') + + # Seems to help a little, especially with extrapolating out of bounds + steps = target_y.shape[1] + mean = softnorm(self.mean(outputs)) + mean_target = mean[:, -steps:, :] + mean_context = mean[:, :-steps, :] + + loss = None + if target_y is not None: + y = torch.cat([context_y, target_y], 1) + y_mask = torch.isfinite(y) & (y!=self.hparams.nan_value) + y[~y_mask] = 0 + y = y.detach() + + + loss_scale = 100 + # loss = F.mse_loss(mean * loss_scale, y * loss_scale, reduction='none') / loss_scale + + loss_target = F.mse_loss(mean_target * loss_scale, y[:, -steps:, :] * loss_scale, reduction='none') / loss_scale + loss_context = F.mse_loss(mean_context * loss_scale, y[:, :-steps, :] * loss_scale, reduction='none') / loss_scale + + y_mask_target = y_mask[:, -steps:, :].detach() + y_mask_context = y_mask[:, :-steps, :].detach() + # loss_target = loss[:, -steps:, :] + # loss_context = loss[:, :-steps, :] + # print(0, loss_context.sum(), loss_target.sum()) + + weight = (torch.arange(loss_target.shape[1]) + 0.5).float().to(device)[None,:, None] + # weight /= weight.sum() + # print(1.0, loss_context.sum(), loss_target.sum()) + loss_target = loss_target / torch.sqrt(weight) # We want to weight nearer stuff more + # print(1.5, loss_context.sum(), y_mask_context.sum(), loss_target.sum(), y_mask_target.sum(), (loss_context * y_mask_context).sum()) + loss_context = (loss_context * y_mask_context.float()).sum() / (y_mask_context.sum() + 1.) + loss_target = (loss_target * y_mask_target.float()).sum() / (y_mask_target.sum()+1.) # Mean over unmasked ones + # print(2, loss_context.sum(), loss_target.sum()) + + # Perhaps predicting the past, as a secondary loss will help + loss = loss_context /100. + loss_target + + assert torch.isfinite(loss) + + return mean_target, dict(loss=loss), dict() + +class PL_Transformer(PL_Seq2Seq): + def __init__(self, hparams, + MODEL_CLS=NetTransformer, **kwargs): + super().__init__(hparams, + MODEL_CLS=MODEL_CLS, **kwargs) + + self.default_args = {'attention_dropout': 0.4151003234623061, 'hidden_out_size_power': 2.0, 'hidden_size_power': 2.0, 'learning_rate': 0.0026738884132767185, 'nhead_power': 1.0, 'nlayers_power': 1.0} + + @staticmethod + def add_suggest(trial: optuna.Trial, user_attrs={}): + """ + Add hyperparam ranges to an optuna trial and typical user attrs. + + Usage: + trial = optuna.trial.FixedTrial( + params={ + 'hidden_size': 128, + } + ) + trial = add_suggest(trial) + trainer = pl.Trainer() + model = LSTM_PL(dict(**trial.params, **trial.user_attrs), dataset_train, + dataset_test, cache_base_path, norm) + trainer.fit(model) + """ + trial.suggest_loguniform("learning_rate", 1e-5, 1e-2) + trial.suggest_uniform("attention_dropout", 0, 0.9) + trial.suggest_discrete_uniform( + "hidden_size_power", 2, 10, 1 + ) + trial.suggest_discrete_uniform("hidden_out_size_power", 2, 9, 1) + trial.suggest_discrete_uniform("nhead_power", 1, 4, 1) + trial.suggest_discrete_uniform("nlayers_power", 1, 5, 1) + + user_attrs_default = { + "batch_size": 16, + "grad_clip": 40, + "max_nb_epochs": 200, + "num_workers": 4, + "vis_i": 670, + "input_size": 6, + "output_size": 1, + "label_steps": 24, + } + [trial.set_user_attr(k, v) for k, v in user_attrs_default.items()] + [trial.set_user_attr(k, v) for k, v in user_attrs.items()] + return trial diff --git a/src/models/transformer_seq2seq.py b/neural_processes/models/transformer_seq2seq.py similarity index 53% rename from src/models/transformer_seq2seq.py rename to neural_processes/models/transformer_seq2seq.py index 9248e38..03a21b1 100644 --- a/src/models/transformer_seq2seq.py +++ b/neural_processes/models/transformer_seq2seq.py @@ -8,9 +8,9 @@ from torch.nn import functional as F from torch.utils.data import DataLoader from torchvision.datasets import MNIST from test_tube import Experiment, HyperOptArgumentParser -from src.data.smart_meter import collate_fns, SmartMeterDataSet, get_smartmeter_df +from neural_processes.data.smart_meter import collate_fns, SmartMeterDataSet, get_smartmeter_df import torchvision.transforms as transforms -from src.plot import plot_from_loader_to_tensor, plot_from_loader +from neural_processes.plot import plot_from_loader_to_tensor, plot_from_loader from argparse import ArgumentParser import json import pytorch_lightning as pl @@ -22,10 +22,11 @@ import PIL import optuna from torchvision.transforms import ToTensor -from src.data.smart_meter import get_smartmeter_df -from src.models.modules import BatchNormSequence +from neural_processes.data.smart_meter import get_smartmeter_df +from neural_processes.modules import BatchNormSequence -from src.utils import ObjectDict +from neural_processes.utils import ObjectDict +from neural_processes.lightning import PL_Seq2Seq def log_prob_sigma(value, loc, log_scale): """A slightly more stable (not confirmed yet) log prob taking in log_var instead of scale. @@ -136,138 +137,13 @@ class TransformerSeq2SeqNet(nn.Module): return y_pred, dict(loss_p=loss_p.mean(), loss_mse=loss_mse.mean()), dict(log_sigma=log_sigma, dist=y_dist) -class TransformerSeq2Seq_PL(pl.LightningModule): - def __init__(self, hparams): - # TODO make label name configurable - # TODO make data source configurable - super().__init__() - self.hparams = ObjectDict() - self.hparams.update( - hparams.__dict__ if hasattr(hparams, "__dict__") else hparams - ) - self.model = TransformerSeq2SeqNet(self.hparams) - self._dfs = None +class TransformerSeq2Seq_PL(PL_Seq2Seq): - def forward(self, context_x, context_y, target_x, target_y): - return self.model(context_x, context_y, target_x, target_y) - - def training_step(self, batch, batch_idx): - # REQUIRED - assert all(torch.isfinite(d).all() for d in batch) - context_x, context_y, target_x, target_y = batch - y_dist, losses, extra = self.forward(context_x, context_y, target_x, target_y) - loss = losses['loss_p'] # + loss_mse - tensorboard_logs = { - "train/loss": loss, - 'train/loss_mse': losses['loss_mse'], - "train/loss_p": losses['loss_p'], - "train/sigma": torch.exp(extra['log_sigma']).mean()} - return {"loss": loss, "log": tensorboard_logs} - - def validation_step(self, batch, batch_idx): - context_x, context_y, target_x, target_y = batch - assert all(torch.isfinite(d).all() for d in batch) - y_dist, losses, extra = self.forward(context_x, context_y, target_x, target_y) - loss = losses['loss_p'] # + loss_mse - tensorboard_logs = { - "val_loss": loss, - 'val/loss_mse': losses['loss_mse'], - "val/loss_p": losses['loss_p'], - "val/sigma": torch.exp(extra['log_sigma']).mean()} - return {"val_loss": loss, "log": tensorboard_logs} - - def validation_end(self, outputs): - if int(self.hparams["vis_i"]) > 0: - self.show_image() - - avg_loss = torch.stack([x["val_loss"] for x in outputs]).mean() - keys = outputs[0]["log"].keys() - tensorboard_logs = { - k: torch.stack([x["log"][k] for x in outputs if k in x["log"]]).mean() - for k in keys - } - tensorboard_logs_str = {k: f"{v}" for k, v in tensorboard_logs.items()} - print(f"step {self.trainer.global_step}, {tensorboard_logs_str}") - assert torch.isfinite(avg_loss) - return {"avg_val_loss": avg_loss, "log": tensorboard_logs} - - - def show_image(self): - # https://github.com/PytorchLightning/pytorch-lightning/blob/f8d9f8f/pytorch_lightning/core/lightning.py#L293 - loader = self.val_dataloader() - vis_i = min(int(self.hparams["vis_i"]), len(loader.dataset)) - # print('vis_i', vis_i) - if isinstance(self.hparams["vis_i"], str): - image = plot_from_loader(loader, self, i=int(vis_i)) - plt.show() - else: - image = plot_from_loader_to_tensor(loader, self, i=vis_i) - self.logger.experiment.add_image('val/image', image, self.trainer.global_step) - - def test_step(self, *args, **kwargs): - return self.validation_step(*args, **kwargs) - - def test_end(self, *args, **kwargs): - return self.validation_end(*args, **kwargs) - - def configure_optimizers(self): - optim = torch.optim.Adam(self.parameters(), lr=self.hparams["learning_rate"]) - scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( - optim, patience=self.hparams["patience"], verbose=True, min_lr=1e-7 - ) # note early stopping has patience 3 - return [optim], [scheduler] - - def _get_cache_dfs(self): - if self._dfs is None: - df_train, df_val, df_test = get_smartmeter_df() - self._dfs = dict(df_train=df_train, df_val=df_val, df_test=df_test) - return self._dfs - - @pl.data_loader - def train_dataloader(self): - df_train = self._get_cache_dfs()['df_train'] - data_train = SmartMeterDataSet( - df_train, self.hparams["num_context"], self.hparams["num_extra_target"] - ) - return torch.utils.data.DataLoader( - data_train, - batch_size=self.hparams["batch_size"], - shuffle=True, - collate_fn=collate_fns( - self.hparams["num_context"], self.hparams["num_extra_target"], sample=True, context_in_target=self.hparams["context_in_target"] - ), - num_workers=self.hparams["num_workers"], - ) - - @pl.data_loader - def val_dataloader(self): - df_test = self._get_cache_dfs()['df_val'] - data_test = SmartMeterDataSet( - df_test, self.hparams["num_context"], self.hparams["num_extra_target"] - ) - return torch.utils.data.DataLoader( - data_test, - batch_size=self.hparams["batch_size"], - shuffle=False, - collate_fn=collate_fns( - self.hparams["num_context"], self.hparams["num_extra_target"], sample=False, context_in_target=self.hparams["context_in_target"] - ), - ) - - @pl.data_loader - def test_dataloader(self): - df_test = self._get_cache_dfs()['df_test'] - data_test = SmartMeterDataSet( - df_test, self.hparams["num_context"], self.hparams["num_extra_target"] - ) - return torch.utils.data.DataLoader( - data_test, - batch_size=self.hparams["batch_size"], - shuffle=False, - collate_fn=collate_fns( - self.hparams["num_context"], self.hparams["num_extra_target"], sample=False, context_in_target=self.hparams["context_in_target"] - ), - ) + def __init__(self, hparams, + MODEL_CLS=TransformerSeq2SeqNet, **kwargs): + super().__init__(hparams, + MODEL_CLS=MODEL_CLS, **kwargs) + self.default_args = {'agg': 'mean', 'attention_dropout': 0.12013231612195126, 'hidden_out_size_power': 4.0, 'hidden_size_power': 7.0, 'learning_rate': 0.0022924639229335475, 'nhead_power': 2.0, 'nlayers_power': 4.0} @staticmethod def add_suggest(trial: optuna.Trial): diff --git a/neural_processes/modules/__init__.py b/neural_processes/modules/__init__.py new file mode 100644 index 0000000..a0c6261 --- /dev/null +++ b/neural_processes/modules/__init__.py @@ -0,0 +1,2 @@ +from .modules import BatchMLP, BatchNormSequence, LSTMBlock +from .attention import Attention, AttnLinear diff --git a/neural_processes/modules/attention.py b/neural_processes/modules/attention.py new file mode 100644 index 0000000..2f51a68 --- /dev/null +++ b/neural_processes/modules/attention.py @@ -0,0 +1,124 @@ + +import torch +from torch import nn +import torch.nn.functional as F + +class AttnLinear(nn.Module): + def __init__(self, in_channels, out_channels): + super().__init__() + self.linear = nn.Linear(in_channels, out_channels, bias=False) + torch.nn.init.normal_(self.linear.weight, std=in_channels ** -0.5) + + def forward(self, x): + x = self.linear(x) + return x + + +class Attention(nn.Module): + def __init__( + self, + hidden_dim, + attention_type, + attention_layers=2, + n_heads=8, + x_dim=1, + rep="mlp", + dropout=0, + batchnorm=False, + ): + super().__init__() + self._rep = rep + + if self._rep == "mlp": + self.batch_mlp_k = BatchMLP( + x_dim, + hidden_dim, + attention_layers, + dropout=dropout, + batchnorm=batchnorm, + ) + self.batch_mlp_q = BatchMLP( + x_dim, + hidden_dim, + attention_layers, + dropout=dropout, + batchnorm=batchnorm, + ) + + if attention_type == "uniform": + self._attention_func = self._uniform_attention + elif attention_type == "laplace": + self._attention_func = self._laplace_attention + elif attention_type == "dot": + self._attention_func = self._dot_attention + elif attention_type == "multihead": + self._W_k = nn.ModuleList( + [AttnLinear(hidden_dim, hidden_dim) for _ in range(n_heads)] + ) + self._W_v = nn.ModuleList( + [AttnLinear(hidden_dim, hidden_dim) for _ in range(n_heads)] + ) + self._W_q = nn.ModuleList( + [AttnLinear(hidden_dim, hidden_dim) for _ in range(n_heads)] + ) + self._W = AttnLinear(n_heads * hidden_dim, hidden_dim) + self._attention_func = self._multihead_attention + self.n_heads = n_heads + elif attention_type == "ptmultihead": + self._W = torch.nn.MultiheadAttention( + hidden_dim, n_heads, bias=False, dropout=dropout + ) + self._attention_func = self._pytorch_multihead_attention + else: + raise NotImplementedError + + def forward(self, k, v, q): + if self._rep == "mlp": + k = self.batch_mlp_k(k) + q = self.batch_mlp_q(q) + rep = self._attention_func(k, v, q) + return rep + + def _uniform_attention(self, k, v, q): + total_points = q.shape[1] + rep = torch.mean(v, dim=1, keepdim=True) + rep = rep.repeat(1, total_points, 1) + return rep + + def _laplace_attention(self, k, v, q, scale=0.5): + k_ = k.unsqueeze(1) + v_ = v.unsqueeze(2) + unnorm_weights = torch.abs((k_ - v_) * scale) + unnorm_weights = unnorm_weights.sum(dim=-1) + weights = torch.softmax(unnorm_weights, dim=-1) + rep = torch.einsum("bik,bkj->bij", weights, v) + return rep + + def _dot_attention(self, k, v, q): + scale = q.shape[-1] ** 0.5 + unnorm_weights = torch.einsum("bjk,bik->bij", k, q) / scale + weights = torch.softmax(unnorm_weights, dim=-1) + + rep = torch.einsum("bik,bkj->bij", weights, v) + return rep + + def _multihead_attention(self, k, v, q): + outs = [] + for i in range(self.n_heads): + k_ = self._W_k[i](k) + v_ = self._W_v[i](v) + q_ = self._W_q[i](q) + out = self._dot_attention(k_, v_, q_) + outs.append(out) + outs = torch.stack(outs, dim=-1) + outs = outs.view(outs.shape[0], outs.shape[1], -1) + rep = self._W(outs) + return rep + + def _pytorch_multihead_attention(self, k, v, q): + # Pytorch multiheaded attention takes inputs if diff order and permutation + q = q.permute(1, 0, 2) + k = k.permute(1, 0, 2) + v = v.permute(1, 0, 2) + o = self._W(q, k, v)[0] + return o.permute(1, 0, 2) diff --git a/neural_processes/modules/modules.py b/neural_processes/modules/modules.py new file mode 100644 index 0000000..2d8f788 --- /dev/null +++ b/neural_processes/modules/modules.py @@ -0,0 +1,107 @@ +import torch +from torch import nn +import torch.nn.functional as F +import math +import numpy as np +# from .attention import Attention as PtAttention + + +class LSTMBlock(nn.Module): + def __init__( + self, in_channels, out_channels, dropout=0, batchnorm=False, bias=False, num_layers=1 + ): + super().__init__() + self._lstm = nn.LSTM( + input_size=in_channels, + hidden_size=out_channels, + num_layers=num_layers, + dropout=dropout, + batch_first=True, + bias=bias + ) + + def forward(self, x): + return self._lstm(x)[0] + + +class BatchNormSequence(nn.Module): + """Applies batch norm on features of a batch first sequence.""" + def __init__( + self, out_channels + ): + super().__init__() + self.norm = nn.BatchNorm1d(out_channels) + + def forward(self, x): + # x.shape is (Batch, Sequence, Channels) + # Now we want to apply batchnorm and dropout to the channels. So we put it in shape + # (Batch, Channels, Sequence) so we can use BatchNorm1d + x = x.permute(0, 2, 1) + x = self.norm(x) + return x.permute(0, 2, 1) + +class NPBlockRelu2d(nn.Module): + """Block for Neural Processes.""" + + def __init__( + self, in_channels, out_channels, dropout=0, batchnorm=False, bias=False + ): + super().__init__() + self.linear = nn.Linear(in_channels, out_channels, bias=bias) + self.act = nn.ReLU() + self.dropout = nn.Dropout2d(dropout) + self.norm = nn.BatchNorm2d(out_channels) if batchnorm else False + + def forward(self, x): + # x.shape is (Batch, Sequence, Channels) + # We pass a linear over it which operates on the Channels + x = self.act(self.linear(x)) + + # Now we want to apply batchnorm and dropout to the channels. So we put it in shape + # (Batch, Channels, Sequence, None) so we can use Dropout2d & BatchNorm2d + x = x.permute(0, 2, 1)[:, :, :, None] + + if self.norm: + x = self.norm(x) + + x = self.dropout(x) + return x[:, :, :, 0].permute(0, 2, 1) + + +class BatchMLP(nn.Module): + """Apply MLP to the final axis of a 3D tensor (reusing already defined MLPs). + + Args: + input: input tensor of shape [B,n,d_in]. + output_sizes: An iterable containing the output sizes of the MLP as defined + in `basic.Linear`. + Returns: + tensor of shape [B,n,d_out] where d_out=output_size + """ + + def __init__( + self, input_size, output_size, num_layers=2, dropout=0, batchnorm=False + ): + super().__init__() + self.input_size = input_size + self.output_size = output_size + self.num_layers = num_layers + + self.initial = NPBlockRelu2d( + input_size, output_size, dropout=dropout, batchnorm=batchnorm + ) + self.encoder = nn.Sequential( + *[ + NPBlockRelu2d( + output_size, output_size, dropout=dropout, batchnorm=batchnorm + ) + for _ in range(num_layers - 2) + ] + ) + self.final = nn.Linear(output_size, output_size) + + def forward(self, x): + x = self.initial(x) + x = self.encoder(x) + return self.final(x) + diff --git a/neural_processes/optuna.py b/neural_processes/optuna.py new file mode 100644 index 0000000..e69de29 diff --git a/src/plot.py b/neural_processes/plot.py similarity index 100% rename from src/plot.py rename to neural_processes/plot.py diff --git a/src/train.py b/neural_processes/train.py similarity index 93% rename from src/train.py rename to neural_processes/train.py index b19f64f..d817ff9 100644 --- a/src/train.py +++ b/neural_processes/train.py @@ -8,6 +8,7 @@ import torch from .dict_logger import DictLogger from .utils import PyTorchLightningPruningCallback from .plot import plot_from_loader +from .logger import logger def main( @@ -89,10 +90,24 @@ def run_trial( ): print(f"now run `tensorboard --logdir {MODEL_DIR}`") (MODEL_DIR / name).mkdir(parents=True, exist_ok=True) + + if getattr(PL_MODEL_CLS, 'default_args', None): + # add default args + params = {**PL_MODEL_CLS.default_args, **params} + else: + logger.warning(f"No default args on {PL_MODEL_CLS}") + + # Make trial trial = optuna.trial.FixedTrial(params=params) trial = PL_MODEL_CLS.add_suggest(trial) + + # Add auto number trial = add_number(trial, MODEL_DIR / name) + + # Add user attributes trial._user_attrs.update(user_attrs) + print(trial) + model, trainer = main( trial, PL_MODEL_CLS, name=name, MODEL_DIR=MODEL_DIR, train=False, prune=False ) diff --git a/src/utils.py b/neural_processes/utils.py similarity index 72% rename from src/utils.py rename to neural_processes/utils.py index 7ac6dab..a83348d 100644 --- a/src/utils.py +++ b/neural_processes/utils.py @@ -77,3 +77,29 @@ class ObjectDict(dict): def __dict__(self): return dict(self) + +def log_prob_sigma(value, loc, log_scale): + """A slightly more stable (not confirmed yet) log prob taking in log_var instead of scale. + modified from https://github.com/pytorch/pytorch/blob/2431eac7c011afe42d4c22b8b3f46dedae65e7c0/torch/distributions/normal.py#L65 + """ + var = torch.exp(log_scale * 2) + return ( + -((value - loc) ** 2) / (2 * var) - log_scale - math.log(math.sqrt(2 * math.pi)) + ) + + +def kl_loss_var(prior_mu, log_var_prior, post_mu, log_var_post): + """ + Analytical KLD for two gaussians, taking in log_variance instead of scale ( given variance=scale**2) for more stable gradients + + For version using scale see https://github.com/pytorch/pytorch/blob/master/torch/distributions/kl.py#L398 + """ + + var_ratio_log = log_var_post - log_var_prior + kl_div = ( + (var_ratio_log.exp() + (post_mu - prior_mu) ** 2) / log_var_prior.exp() + - 1.0 + - var_ratio_log + ) + kl_div = 0.5 * kl_div + return kl_div diff --git a/smartmeters-ANP-RNN-Copy1.ipynb b/smartmeters-ANP-RNN-Copy1.ipynb index 011dafe..d3f8f75 100644 --- a/smartmeters-ANP-RNN-Copy1.ipynb +++ b/smartmeters-ANP-RNN-Copy1.ipynb @@ -110,11 +110,11 @@ }, "outputs": [], "source": [ - "from src.models.model import LatentModel\n", - "from src.data.smart_meter import collate_fns, SmartMeterDataSet, get_smartmeter_df\n", - "from src.plot import plot_from_loader\n", - "from src.models.lightning_anp import LatentModelPL\n", - "from src.dict_logger import DictLogger" + "from neural_processes.models.model import LatentModel\n", + "from neural_processes.data.smart_meter import collate_fns, SmartMeterDataSet, get_smartmeter_df\n", + "from neural_processes.plot import plot_from_loader\n", + "from neural_processes.models.lightning_anp import LatentModelPL\n", + "from neural_processes.dict_logger import DictLogger" ] }, { diff --git a/smartmeters-ANP-RNN-mcdropout.ipynb b/smartmeters-ANP-RNN-mcdropout.ipynb index 979a74a..6368bd6 100644 --- a/smartmeters-ANP-RNN-mcdropout.ipynb +++ b/smartmeters-ANP-RNN-mcdropout.ipynb @@ -105,13 +105,13 @@ }, "outputs": [], "source": [ - "from src.models.model import LatentModel\n", - "from src.data.smart_meter import collate_fns, SmartMeterDataSet, get_smartmeter_df\n", - "from src.plot import plot_from_loader\n", - "from src.models.lightning_anp import LatentModelPL\n", - "from src.dict_logger import DictLogger\n", - "from src.train import main, objective, add_number, run_trial\n", - "from src.utils import init_random_seed" + "from neural_processes.models.model import LatentModel\n", + "from neural_processes.data.smart_meter import collate_fns, SmartMeterDataSet, get_smartmeter_df\n", + "from neural_processes.plot import plot_from_loader\n", + "from neural_processes.models.lightning_anp import LatentModelPL\n", + "from neural_processes.dict_logger import DictLogger\n", + "from neural_processes.train import main, objective, add_number, run_trial\n", + "from neural_processes.utils import init_random_seed" ] }, { @@ -289,7 +289,7 @@ }, "outputs": [], "source": [ - "from src.plot import plot_rows\n", + "from neural_processes.plot import plot_rows\n", "\n", "\n", "def eval_mc(model, loader, i):\n", @@ -392,7 +392,7 @@ " 'use_self_attn': True, \n", " 'use_rnn': False, \n", "}\n", - "default_attrs = {\n", + "default_user_attrs = {\n", " 'context_in_target': True,\n", " 'x_dim': 17,\n", " 'y_dim': 1,\n", @@ -2835,7 +2835,7 @@ " 'use_rnn': True,\n", " 'vis_i': 670\n", " },\n", - " user_attrs = default_attrs,\n", + " user_attrs = default_user_attrs,\n", " PL_MODEL_CLS=LatentModelPL\n", " )\n", " \n", @@ -3256,7 +3256,7 @@ }, "outputs": [], "source": [ - "from src.plot import plot_rows\n", + "from neural_processes.plot import plot_rows\n", "loader = model.val_dataloader()\n", "device = next(model.parameters()).device\n", "\n", diff --git a/smartmeters-ANP-RNN.ipynb b/smartmeters-ANP-RNN.ipynb index c0f5397..e3cdcd0 100644 --- a/smartmeters-ANP-RNN.ipynb +++ b/smartmeters-ANP-RNN.ipynb @@ -39,11 +39,11 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 10, "metadata": { "ExecuteTime": { - "end_time": "2020-03-15T14:02:05.965013Z", - "start_time": "2020-03-15T14:02:03.328951Z" + "end_time": "2020-04-11T04:49:21.604845Z", + "start_time": "2020-04-11T04:49:21.489780Z" } }, "outputs": [], @@ -69,11 +69,11 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 11, "metadata": { "ExecuteTime": { - "end_time": "2020-03-15T14:02:06.025267Z", - "start_time": "2020-03-15T14:02:05.967800Z" + "end_time": "2020-04-11T04:49:21.753642Z", + "start_time": "2020-04-11T04:49:21.657550Z" } }, "outputs": [], @@ -85,11 +85,11 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 12, "metadata": { "ExecuteTime": { - "end_time": "2020-03-15T14:02:06.078660Z", - "start_time": "2020-03-15T14:02:06.028512Z" + "end_time": "2020-04-11T04:49:22.002185Z", + "start_time": "2020-04-11T04:49:21.874963Z" } }, "outputs": [], @@ -101,31 +101,39 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 13, "metadata": { "ExecuteTime": { - "end_time": "2020-03-15T14:02:06.199223Z", - "start_time": "2020-03-15T14:02:06.081754Z" + "end_time": "2020-04-11T04:49:22.150671Z", + "start_time": "2020-04-11T04:49:22.036140Z" } }, "outputs": [], "source": [ - "from src.models.model import LatentModel\n", - "from src.data.smart_meter import collate_fns, SmartMeterDataSet, get_smartmeter_df\n", - "from src.plot import plot_from_loader\n", - "from src.models.lightning_anp import LatentModelPL\n", - "from src.dict_logger import DictLogger\n", - "from src.utils import PyTorchLightningPruningCallback\n", - "from src.train import main, objective, add_number, run_trial" + "\n", + "from neural_processes.data.smart_meter import collate_fns, SmartMeterDataSet, get_smartmeter_df\n", + "from neural_processes.plot import plot_from_loader\n", + "\n", + "from neural_processes.dict_logger import DictLogger\n", + "from neural_processes.utils import PyTorchLightningPruningCallback\n", + "from neural_processes.train import main, objective, add_number, run_trial\n", + "\n", + "from neural_processes.models.neural_process import PL_NeuralProcess\n", + "\n", + "from neural_processes.models.transformer import PL_Transformer\n", + "from neural_processes.models.transformer_seq2seq import TransformerSeq2Seq_PL\n", + "\n", + "from neural_processes.models.lstm_seqseq import LSTMSeq2Seq_PL\n", + "from neural_processes.models.lstm_std import LSTM_PL_STD" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 14, "metadata": { "ExecuteTime": { - "end_time": "2020-03-15T14:02:06.253385Z", - "start_time": "2020-03-15T14:02:06.202384Z" + "end_time": "2020-04-11T04:49:22.284717Z", + "start_time": "2020-04-11T04:49:22.177605Z" } }, "outputs": [], @@ -144,11 +152,11 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 15, "metadata": { "ExecuteTime": { - "end_time": "2020-03-15T14:02:16.324038Z", - "start_time": "2020-03-15T14:02:06.256352Z" + "end_time": "2020-04-11T04:49:31.807971Z", + "start_time": "2020-04-11T04:49:22.904020Z" } }, "outputs": [], @@ -158,21 +166,21 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 16, "metadata": { "ExecuteTime": { - "end_time": "2020-03-15T14:02:17.175648Z", - "start_time": "2020-03-15T14:02:16.328253Z" + "end_time": "2020-04-11T04:49:32.477716Z", + "start_time": "2020-04-11T04:49:31.811381Z" } }, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 7, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, @@ -198,32 +206,6 @@ "plt.legend()" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Train helpers" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "ExecuteTime": { - "end_time": "2020-02-16T04:12:04.687280Z", - "start_time": "2020-02-16T04:12:04.611238Z" - } - }, - "outputs": [], - "source": [] - }, { "cell_type": "markdown", "metadata": {}, @@ -233,39 +215,19 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 17, "metadata": { "ExecuteTime": { - "end_time": "2020-03-15T14:02:17.244830Z", - "start_time": "2020-03-15T14:02:17.179968Z" + "end_time": "2020-04-11T04:49:32.576672Z", + "start_time": "2020-04-11T04:49:32.481350Z" } }, "outputs": [], "source": [ - "default_params = {\n", - " 'attention_dropout': 0.1,\n", - " 'attention_layers': 2,\n", - " 'batchnorm': False,\n", - " 'det_enc_cross_attn_type': 'multihead',\n", - " 'det_enc_self_attn_type': 'uniform',\n", - " 'dropout': 0.2,\n", - " 'hidden_dim': 256,\n", - " 'latent_dim': 256,\n", - " 'latent_enc_self_attn_type': 'uniform',\n", - " 'learning_rate': 3e-4,\n", - " 'n_decoder_layers': 4,\n", - " 'n_det_encoder_layers': 4,\n", - " 'n_latent_encoder_layers': 2,\n", - " 'num_heads': 8,\n", - " 'use_deterministic_path': True,\n", - " 'use_lvar': True,\n", - " 'use_self_attn': True,\n", - " 'use_rnn': False,\n", - "}\n", - "default_attrs = {\n", + "default_user_attrs = {\n", " 'context_in_target': True,\n", " 'x_dim': 17,\n", - " 'y_dim': 1,\n", + " 'y_dim': 1,\n", " 'vis_i': '670',\n", " 'num_workers': 3,\n", " 'num_context': 24*4,\n", @@ -286,31 +248,31 @@ "source": [] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": { "ExecuteTime": { - "end_time": "2020-02-15T07:05:44.545917Z", - "start_time": "2020-02-15T07:05:44.487280Z" + "end_time": "2020-04-11T01:56:38.106876Z", + "start_time": "2020-04-11T01:56:38.100361Z" } }, - "outputs": [], - "source": [] + "source": [ + "# Models" + ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Train ANP-RNN" + "## ANP-RNN" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 18, "metadata": { "ExecuteTime": { - "end_time": "2020-03-15T15:08:40.995588Z", - "start_time": "2020-03-15T14:02:17.248737Z" + "end_time": "2020-04-11T04:49:32.718757Z", + "start_time": "2020-04-11T04:49:32.579382Z" } }, "outputs": [ @@ -319,624 +281,22 @@ "output_type": "stream", "text": [ "now run `tensorboard --logdir lightning_logs`\n", - "trial.number -5\n", - "INFO:root:GPU available: True, used: True\n", - "INFO:root:VISIBLE GPUS: 0\n", - "INFO:root:\n", - " | Name | Type | Params\n", - "---------------------------------------------------------------------------------------------------------------\n", - "0 | model | LatentModel | 7 M \n", - "1 | model.norm_x | BatchNormSequence | 34 \n", - "2 | model.norm_x.norm | BatchNorm1d | 34 \n", - "3 | model.norm_y | BatchNormSequence | 2 \n", - "4 | model.norm_y.norm | BatchNorm1d | 2 \n", - "5 | model._lstm_x | LSTM | 807 K \n", - "6 | model._lstm_y | LSTM | 791 K \n", - "7 | model._latent_encoder | LatentEncoder | 394 K \n", - "8 | model._latent_encoder._encoder | BatchMLP | 196 K \n", - "9 | model._latent_encoder._encoder.initial | NPBlockRelu2d | 131 K \n", - "10 | model._latent_encoder._encoder.initial.linear | Linear | 131 K \n", - "11 | model._latent_encoder._encoder.initial.act | ReLU | 0 \n", - "12 | model._latent_encoder._encoder.initial.dropout | Dropout2d | 0 \n", - "13 | model._latent_encoder._encoder.encoder | Sequential | 0 \n", - "14 | model._latent_encoder._encoder.final | Linear | 65 K \n", - "15 | model._latent_encoder._self_attention | Attention | 0 \n", - "16 | model._latent_encoder._penultimate_layer | Linear | 65 K \n", - "17 | model._latent_encoder._mean | Linear | 65 K \n", - "18 | model._latent_encoder._log_var | Linear | 65 K \n", - "19 | model._deterministic_encoder | DeterministicEncoder | 2 M \n", - "20 | model._deterministic_encoder._d_encoder | BatchMLP | 327 K \n", - "21 | model._deterministic_encoder._d_encoder.initial | NPBlockRelu2d | 131 K \n", - "22 | model._deterministic_encoder._d_encoder.initial.linear | Linear | 131 K \n", - "23 | model._deterministic_encoder._d_encoder.initial.act | ReLU | 0 \n", - "24 | model._deterministic_encoder._d_encoder.initial.dropout | Dropout2d | 0 \n", - "25 | model._deterministic_encoder._d_encoder.encoder | Sequential | 131 K \n", - "26 | model._deterministic_encoder._d_encoder.encoder.0 | NPBlockRelu2d | 65 K \n", - "27 | model._deterministic_encoder._d_encoder.encoder.0.linear | Linear | 65 K \n", - "28 | model._deterministic_encoder._d_encoder.encoder.0.act | ReLU | 0 \n", - "29 | model._deterministic_encoder._d_encoder.encoder.0.dropout | Dropout2d | 0 \n", - "30 | model._deterministic_encoder._d_encoder.encoder.1 | NPBlockRelu2d | 65 K \n", - "31 | model._deterministic_encoder._d_encoder.encoder.1.linear | Linear | 65 K \n", - "32 | model._deterministic_encoder._d_encoder.encoder.1.act | ReLU | 0 \n", - "33 | model._deterministic_encoder._d_encoder.encoder.1.dropout | Dropout2d | 0 \n", - "34 | model._deterministic_encoder._d_encoder.final | Linear | 65 K \n", - "35 | model._deterministic_encoder._self_attention | Attention | 0 \n", - "36 | model._deterministic_encoder._cross_attention | Attention | 2 M \n", - "37 | model._deterministic_encoder._cross_attention.batch_mlp_k | BatchMLP | 131 K \n", - "38 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial | NPBlockRelu2d | 65 K \n", - "39 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial.linear | Linear | 65 K \n", - "40 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial.act | ReLU | 0 \n", - "41 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial.dropout | Dropout2d | 0 \n", - "42 | model._deterministic_encoder._cross_attention.batch_mlp_k.encoder | Sequential | 0 \n", - "43 | model._deterministic_encoder._cross_attention.batch_mlp_k.final | Linear | 65 K \n", - "44 | model._deterministic_encoder._cross_attention.batch_mlp_q | BatchMLP | 131 K \n", - "45 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial | NPBlockRelu2d | 65 K \n", - "46 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial.linear | Linear | 65 K \n", - "47 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial.act | ReLU | 0 \n", - "48 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial.dropout | Dropout2d | 0 \n", - "49 | model._deterministic_encoder._cross_attention.batch_mlp_q.encoder | Sequential | 0 \n", - "50 | model._deterministic_encoder._cross_attention.batch_mlp_q.final | Linear | 65 K \n", - "51 | model._deterministic_encoder._cross_attention._W_k | ModuleList | 524 K \n", - "52 | model._deterministic_encoder._cross_attention._W_k.0 | AttnLinear | 65 K \n", - "53 | model._deterministic_encoder._cross_attention._W_k.0.linear | Linear | 65 K \n", - "54 | model._deterministic_encoder._cross_attention._W_k.1 | AttnLinear | 65 K \n", - "55 | model._deterministic_encoder._cross_attention._W_k.1.linear | Linear | 65 K \n", - "56 | model._deterministic_encoder._cross_attention._W_k.2 | AttnLinear | 65 K \n", - "57 | model._deterministic_encoder._cross_attention._W_k.2.linear | Linear | 65 K \n", - "58 | model._deterministic_encoder._cross_attention._W_k.3 | AttnLinear | 65 K \n", - "59 | model._deterministic_encoder._cross_attention._W_k.3.linear | Linear | 65 K \n", - "60 | model._deterministic_encoder._cross_attention._W_k.4 | AttnLinear | 65 K \n", - "61 | model._deterministic_encoder._cross_attention._W_k.4.linear | Linear | 65 K \n", - "62 | model._deterministic_encoder._cross_attention._W_k.5 | AttnLinear | 65 K \n", - "63 | model._deterministic_encoder._cross_attention._W_k.5.linear | Linear | 65 K \n", - "64 | model._deterministic_encoder._cross_attention._W_k.6 | AttnLinear | 65 K \n", - "65 | model._deterministic_encoder._cross_attention._W_k.6.linear | Linear | 65 K \n", - "66 | model._deterministic_encoder._cross_attention._W_k.7 | AttnLinear | 65 K \n", - "67 | model._deterministic_encoder._cross_attention._W_k.7.linear | Linear | 65 K \n", - "68 | model._deterministic_encoder._cross_attention._W_v | ModuleList | 524 K \n", - "69 | model._deterministic_encoder._cross_attention._W_v.0 | AttnLinear | 65 K \n", - "70 | model._deterministic_encoder._cross_attention._W_v.0.linear | Linear | 65 K \n", - "71 | model._deterministic_encoder._cross_attention._W_v.1 | AttnLinear | 65 K \n", - "72 | model._deterministic_encoder._cross_attention._W_v.1.linear | Linear | 65 K \n", - "73 | model._deterministic_encoder._cross_attention._W_v.2 | AttnLinear | 65 K \n", - "74 | model._deterministic_encoder._cross_attention._W_v.2.linear | Linear | 65 K \n", - "75 | model._deterministic_encoder._cross_attention._W_v.3 | AttnLinear | 65 K \n", - "76 | model._deterministic_encoder._cross_attention._W_v.3.linear | Linear | 65 K \n", - "77 | model._deterministic_encoder._cross_attention._W_v.4 | AttnLinear | 65 K \n", - "78 | model._deterministic_encoder._cross_attention._W_v.4.linear | Linear | 65 K \n", - "79 | model._deterministic_encoder._cross_attention._W_v.5 | AttnLinear | 65 K \n", - "80 | model._deterministic_encoder._cross_attention._W_v.5.linear | Linear | 65 K \n", - "81 | model._deterministic_encoder._cross_attention._W_v.6 | AttnLinear | 65 K \n", - "82 | model._deterministic_encoder._cross_attention._W_v.6.linear | Linear | 65 K \n", - "83 | model._deterministic_encoder._cross_attention._W_v.7 | AttnLinear | 65 K \n", - "84 | model._deterministic_encoder._cross_attention._W_v.7.linear | Linear | 65 K \n", - "85 | model._deterministic_encoder._cross_attention._W_q | ModuleList | 524 K \n", - "86 | model._deterministic_encoder._cross_attention._W_q.0 | AttnLinear | 65 K \n", - "87 | model._deterministic_encoder._cross_attention._W_q.0.linear | Linear | 65 K \n", - "88 | model._deterministic_encoder._cross_attention._W_q.1 | AttnLinear | 65 K \n", - "89 | model._deterministic_encoder._cross_attention._W_q.1.linear | Linear | 65 K \n", - "90 | model._deterministic_encoder._cross_attention._W_q.2 | AttnLinear | 65 K \n", - "91 | model._deterministic_encoder._cross_attention._W_q.2.linear | Linear | 65 K \n", - "92 | model._deterministic_encoder._cross_attention._W_q.3 | AttnLinear | 65 K \n", - "93 | model._deterministic_encoder._cross_attention._W_q.3.linear | Linear | 65 K \n", - "94 | model._deterministic_encoder._cross_attention._W_q.4 | AttnLinear | 65 K \n", - "95 | model._deterministic_encoder._cross_attention._W_q.4.linear | Linear | 65 K \n", - "96 | model._deterministic_encoder._cross_attention._W_q.5 | AttnLinear | 65 K \n", - "97 | model._deterministic_encoder._cross_attention._W_q.5.linear | Linear | 65 K \n", - "98 | model._deterministic_encoder._cross_attention._W_q.6 | AttnLinear | 65 K \n", - "99 | model._deterministic_encoder._cross_attention._W_q.6.linear | Linear | 65 K \n", - "100 | model._deterministic_encoder._cross_attention._W_q.7 | AttnLinear | 65 K \n", - "101 | model._deterministic_encoder._cross_attention._W_q.7.linear | Linear | 65 K \n", - "102 | model._deterministic_encoder._cross_attention._W | AttnLinear | 524 K \n", - "103 | model._deterministic_encoder._cross_attention._W.linear | Linear | 524 K \n", - "104 | model._decoder | Decoder | 2 M \n", - "105 | model._decoder._target_transform | Linear | 65 K \n", - "106 | model._decoder._decoder | BatchMLP | 2 M \n", - "107 | model._decoder._decoder.initial | NPBlockRelu2d | 589 K \n", - "108 | model._decoder._decoder.initial.linear | Linear | 589 K \n", - "109 | model._decoder._decoder.initial.act | ReLU | 0 \n", - "110 | model._decoder._decoder.initial.dropout | Dropout2d | 0 \n", - "111 | model._decoder._decoder.encoder | Sequential | 1 M \n", - "112 | model._decoder._decoder.encoder.0 | NPBlockRelu2d | 589 K \n", - "113 | model._decoder._decoder.encoder.0.linear | Linear | 589 K \n", - "114 | model._decoder._decoder.encoder.0.act | ReLU | 0 \n", - "115 | model._decoder._decoder.encoder.0.dropout | Dropout2d | 0 \n", - "116 | model._decoder._decoder.encoder.1 | NPBlockRelu2d | 589 K \n", - "117 | model._decoder._decoder.encoder.1.linear | Linear | 589 K \n", - "118 | model._decoder._decoder.encoder.1.act | ReLU | 0 \n", - "119 | model._decoder._decoder.encoder.1.dropout | Dropout2d | 0 \n", - "120 | model._decoder._decoder.final | Linear | 590 K \n", - "121 | model._decoder._mean | Linear | 769 \n", - "122 | model._decoder._std | Linear | 769 \n" + "WARNING:predict_heading2:No default args on \n" ] }, { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validation sanity check', layout=Layout(flex='2'), max=5.…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 0, {'val_loss': '0.42184552550315857', 'val/kl': '2.1713795206323994e-07', 'val/std': '0.6983310580253601', 'val/mse': '0.26364341378211975'} {}\n", - "\r" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "51a3da47db7845bb83ccd9ffdb06e783", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=1.0, bar_style='info', layout=Layout(flex='2'), max=1.0), HTML(value='')), …" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 1826, {'val_loss': '-0.6428284049034119', 'val/kl': '5.4591797379544005e-05', 'val/std': '0.07988817989826202', 'val/mse': '0.0059888968244194984'} {'train_loss': -0.4425143003463745, 'train/kl': 5.353632150217891e-05, 'train/std': 0.11668403446674347, 'train/mse': 0.014617819339036942}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 3653, {'val_loss': '-0.6794694662094116', 'val/kl': '0.00012594334839377552', 'val/std': '0.06845888495445251', 'val/mse': '0.0053461468778550625'} {'train_loss': -0.6174005270004272, 'train/kl': 6.462969031417742e-05, 'train/std': 0.08038288354873657, 'train/mse': 0.008405664935708046}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 5480, {'val_loss': '-0.6641156673431396', 'val/kl': '0.00010334183753002435', 'val/std': '0.06985745579004288', 'val/mse': '0.005731998011469841'} {'train_loss': -0.6783930659294128, 'train/kl': 6.751970067853108e-05, 'train/std': 0.07189679890871048, 'train/mse': 0.007116572465747595}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 7307, {'val_loss': '-0.64785236120224', 'val/kl': '6.461514567490667e-05', 'val/std': '0.06351888924837112', 'val/mse': '0.005672703497111797'} {'train_loss': -0.702958881855011, 'train/kl': 6.77721545798704e-05, 'train/std': 0.06865207850933075, 'train/mse': 0.006534663029015064}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 9134, {'val_loss': '-0.7176527976989746', 'val/kl': '4.687508044298738e-05', 'val/std': '0.05477931722998619', 'val/mse': '0.004916038364171982'} {'train_loss': -0.7147323489189148, 'train/kl': 6.48987406748347e-05, 'train/std': 0.06696134805679321, 'train/mse': 0.006167554296553135}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 10961, {'val_loss': '-0.7569440007209778', 'val/kl': '5.361469811759889e-05', 'val/std': '0.049641843885183334', 'val/mse': '0.004109958652406931'} {'train_loss': -0.7449450492858887, 'train/kl': 6.57353739370592e-05, 'train/std': 0.06346124410629272, 'train/mse': 0.005816280841827393}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 12788, {'val_loss': '-0.7574060559272766', 'val/kl': '3.885324258590117e-05', 'val/std': '0.04863661155104637', 'val/mse': '0.003958649933338165'} {'train_loss': -0.774450421333313, 'train/kl': 6.246966950129718e-05, 'train/std': 0.06125149503350258, 'train/mse': 0.005521796178072691}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 14615, {'val_loss': '-0.655064046382904', 'val/kl': '4.925979737890884e-05', 'val/std': '0.0435226671397686', 'val/mse': '0.004355155397206545'} {'train_loss': -0.7880685925483704, 'train/kl': 6.0735172155546024e-05, 'train/std': 0.05881268531084061, 'train/mse': 0.005228012800216675}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 16442, {'val_loss': '-0.7114515900611877', 'val/kl': '3.781724808504805e-05', 'val/std': '0.04664501175284386', 'val/mse': '0.0044994959607720375'} {'train_loss': -0.8029305934906006, 'train/kl': 5.973194492980838e-05, 'train/std': 0.0579378642141819, 'train/mse': 0.005083664786070585}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 18269, {'val_loss': '-0.5954879522323608', 'val/kl': '3.543590355548076e-05', 'val/std': '0.04523073881864548', 'val/mse': '0.005495685152709484'} {'train_loss': -0.814018964767456, 'train/kl': 5.570444045588374e-05, 'train/std': 0.05588681623339653, 'train/mse': 0.004857610445469618}\n", - "Epoch 9: reducing learning rate of group 0 to 3.0000e-05.\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 20096, {'val_loss': '-0.636482834815979', 'val/kl': '4.198354508844204e-05', 'val/std': '0.04087801277637482', 'val/mse': '0.004332580137997866'} {'train_loss': -0.8859013319015503, 'train/kl': 5.240697646513581e-05, 'train/std': 0.049901679158210754, 'train/mse': 0.004169043153524399}\n", - "INFO:root:Epoch 00011: early stopping\n", - "\n", - "Loading checkpoint lightning_logs/anp-rnn/version_-5/_ckpt_epoch_6.ckpt\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "8bb9384e8773495cad63879091f75533", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Testing', layout=Layout(flex='2'), max=356.0, style=Progr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 20097, {'val_loss': '5.675908088684082', 'val/kl': '5.951051934971474e-05', 'val/std': '0.11505361646413803', 'val/mse': '0.13731111586093903'} {}\n", - "----------------------------------------------------------------------------------------------------\n", - "TEST RESULTS\n", - "{}\n", - "----------------------------------------------------------------------------------------------------\n", - "\n" + "ename": "ValueError", + "evalue": "The value of the parameter 'learning_rate' is not found. Please set it at the construction of the FixedTrial object.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 10\u001b[0m },\n\u001b[1;32m 11\u001b[0m \u001b[0muser_attrs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdefault_user_attrs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m \u001b[0mPL_MODEL_CLS\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mPL_NeuralProcess\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 13\u001b[0m )\n", + "\u001b[0;32m/media/wassname/Storage5/projects2/3ST/attentive-neural-processes/neural_processes/train.py\u001b[0m in \u001b[0;36mrun_trial\u001b[0;34m(name, PL_MODEL_CLS, params, user_attrs, MODEL_DIR, plot_from_loader)\u001b[0m\n\u001b[1;32m 100\u001b[0m \u001b[0;31m# Make trial\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 101\u001b[0m \u001b[0mtrial\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0moptuna\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrial\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mFixedTrial\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 102\u001b[0;31m \u001b[0mtrial\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mPL_MODEL_CLS\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_suggest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrial\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 103\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 104\u001b[0m \u001b[0;31m# Add auto number\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/media/wassname/Storage5/projects2/3ST/attentive-neural-processes/neural_processes/models/neural_process/lightning.py\u001b[0m in \u001b[0;36madd_suggest\u001b[0;34m(trial)\u001b[0m\n\u001b[1;32m 38\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mstaticmethod\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0madd_suggest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrial\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 40\u001b[0;31m \u001b[0mtrial\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msuggest_loguniform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"learning_rate\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1e-5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1e-2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 41\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 42\u001b[0m \u001b[0mtrial\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msuggest_categorical\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"hidden_dim\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m8\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mi\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m8\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/optuna/trial.py\u001b[0m in \u001b[0;36msuggest_loguniform\u001b[0;34m(self, name, low, high)\u001b[0m\n\u001b[1;32m 674\u001b[0m \u001b[0;31m# type: (str, float, float) -> float\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 675\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 676\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_suggest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdistributions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mLogUniformDistribution\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlow\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlow\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhigh\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mhigh\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 677\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 678\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0msuggest_discrete_uniform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlow\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhigh\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mq\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/optuna/trial.py\u001b[0m in \u001b[0;36m_suggest\u001b[0;34m(self, name, distribution)\u001b[0m\n\u001b[1;32m 699\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mname\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_params\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 700\u001b[0m raise ValueError('The value of the parameter \\'{}\\' is not found. Please set it at '\n\u001b[0;32m--> 701\u001b[0;31m 'the construction of the FixedTrial object.'.format(name))\n\u001b[0m\u001b[1;32m 702\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 703\u001b[0m \u001b[0mvalue\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_params\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: The value of the parameter 'learning_rate' is not found. Please set it at the construction of the FixedTrial object." ] } ], @@ -944,7 +304,6 @@ "trial, trainer, model = run_trial(\n", " name=\"anp-rnn\",\n", " params={\n", - " **default_params, \n", " 'det_enc_cross_attn_type': 'multihead',\n", " 'det_enc_self_attn_type': 'uniform',\n", " 'latent_enc_self_attn_type': 'uniform',\n", @@ -952,9 +311,10 @@ " 'use_rnn': True,\n", " 'use_lvar': False,\n", " },\n", - " user_attrs = default_attrs,\n", - " PL_MODEL_CLS=LatentModelPL\n", - ")" + " user_attrs = default_user_attrs,\n", + " PL_MODEL_CLS=PL_NeuralProcess\n", + ")\n", + "trainer.logger.metrics" ] }, { @@ -962,8 +322,8 @@ "execution_count": null, "metadata": { "ExecuteTime": { - "end_time": "2020-03-15T07:42:06.297126Z", - "start_time": "2020-03-15T07:42:05.346541Z" + "end_time": "2020-04-11T03:48:24.104448Z", + "start_time": "2020-04-11T03:48:24.027269Z" } }, "outputs": [], @@ -978,1345 +338,31 @@ } }, "source": [ - "# ANP-RNN 2" + "## ANP-RNN 2" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": { "ExecuteTime": { - "end_time": "2020-03-15T15:59:03.628512Z", - "start_time": "2020-03-15T15:08:40.998784Z" + "end_time": "2020-04-11T04:38:49.863878Z", + "start_time": "2020-04-11T04:38:46.400Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "now run `tensorboard --logdir lightning_logs`\n", - "trial.number -4\n", - "INFO:root:GPU available: True, used: True\n", - "INFO:root:VISIBLE GPUS: 0\n", - "INFO:root:\n", - " | Name | Type | Params\n", - "---------------------------------------------------------------------------------------------------------------\n", - "0 | model | LatentModel | 9 M \n", - "1 | model.norm_x | BatchNormSequence | 34 \n", - "2 | model.norm_x.norm | BatchNorm1d | 34 \n", - "3 | model.norm_y | BatchNormSequence | 2 \n", - "4 | model.norm_y.norm | BatchNorm1d | 2 \n", - "5 | model._lstm_x | LSTM | 807 K \n", - "6 | model._lstm_y | LSTM | 791 K \n", - "7 | model._latent_encoder | LatentEncoder | 2 M \n", - "8 | model._latent_encoder._encoder | BatchMLP | 196 K \n", - "9 | model._latent_encoder._encoder.initial | NPBlockRelu2d | 131 K \n", - "10 | model._latent_encoder._encoder.initial.linear | Linear | 131 K \n", - "11 | model._latent_encoder._encoder.initial.act | ReLU | 0 \n", - "12 | model._latent_encoder._encoder.initial.dropout | Dropout2d | 0 \n", - "13 | model._latent_encoder._encoder.encoder | Sequential | 0 \n", - "14 | model._latent_encoder._encoder.final | Linear | 65 K \n", - "15 | model._latent_encoder._self_attention | Attention | 2 M \n", - "16 | model._latent_encoder._self_attention._W_k | ModuleList | 524 K \n", - "17 | model._latent_encoder._self_attention._W_k.0 | AttnLinear | 65 K \n", - "18 | model._latent_encoder._self_attention._W_k.0.linear | Linear | 65 K \n", - "19 | model._latent_encoder._self_attention._W_k.1 | AttnLinear | 65 K \n", - "20 | model._latent_encoder._self_attention._W_k.1.linear | Linear | 65 K \n", - "21 | model._latent_encoder._self_attention._W_k.2 | AttnLinear | 65 K \n", - "22 | model._latent_encoder._self_attention._W_k.2.linear | Linear | 65 K \n", - "23 | model._latent_encoder._self_attention._W_k.3 | AttnLinear | 65 K \n", - "24 | model._latent_encoder._self_attention._W_k.3.linear | Linear | 65 K \n", - "25 | model._latent_encoder._self_attention._W_k.4 | AttnLinear | 65 K \n", - "26 | model._latent_encoder._self_attention._W_k.4.linear | Linear | 65 K \n", - "27 | model._latent_encoder._self_attention._W_k.5 | AttnLinear | 65 K \n", - "28 | model._latent_encoder._self_attention._W_k.5.linear | Linear | 65 K \n", - "29 | model._latent_encoder._self_attention._W_k.6 | AttnLinear | 65 K \n", - "30 | model._latent_encoder._self_attention._W_k.6.linear | Linear | 65 K \n", - "31 | model._latent_encoder._self_attention._W_k.7 | AttnLinear | 65 K \n", - "32 | model._latent_encoder._self_attention._W_k.7.linear | Linear | 65 K \n", - "33 | model._latent_encoder._self_attention._W_v | ModuleList | 524 K \n", - "34 | model._latent_encoder._self_attention._W_v.0 | AttnLinear | 65 K \n", - "35 | model._latent_encoder._self_attention._W_v.0.linear | Linear | 65 K \n", - "36 | model._latent_encoder._self_attention._W_v.1 | AttnLinear | 65 K \n", - "37 | model._latent_encoder._self_attention._W_v.1.linear | Linear | 65 K \n", - "38 | model._latent_encoder._self_attention._W_v.2 | AttnLinear | 65 K \n", - "39 | model._latent_encoder._self_attention._W_v.2.linear | Linear | 65 K \n", - "40 | model._latent_encoder._self_attention._W_v.3 | AttnLinear | 65 K \n", - "41 | model._latent_encoder._self_attention._W_v.3.linear | Linear | 65 K \n", - "42 | model._latent_encoder._self_attention._W_v.4 | AttnLinear | 65 K \n", - "43 | model._latent_encoder._self_attention._W_v.4.linear | Linear | 65 K \n", - "44 | model._latent_encoder._self_attention._W_v.5 | AttnLinear | 65 K \n", - "45 | model._latent_encoder._self_attention._W_v.5.linear | Linear | 65 K \n", - "46 | model._latent_encoder._self_attention._W_v.6 | AttnLinear | 65 K \n", - "47 | model._latent_encoder._self_attention._W_v.6.linear | Linear | 65 K \n", - "48 | model._latent_encoder._self_attention._W_v.7 | AttnLinear | 65 K \n", - "49 | model._latent_encoder._self_attention._W_v.7.linear | Linear | 65 K \n", - "50 | model._latent_encoder._self_attention._W_q | ModuleList | 524 K \n", - "51 | model._latent_encoder._self_attention._W_q.0 | AttnLinear | 65 K \n", - "52 | model._latent_encoder._self_attention._W_q.0.linear | Linear | 65 K \n", - "53 | model._latent_encoder._self_attention._W_q.1 | AttnLinear | 65 K \n", - "54 | model._latent_encoder._self_attention._W_q.1.linear | Linear | 65 K \n", - "55 | model._latent_encoder._self_attention._W_q.2 | AttnLinear | 65 K \n", - "56 | model._latent_encoder._self_attention._W_q.2.linear | Linear | 65 K \n", - "57 | model._latent_encoder._self_attention._W_q.3 | AttnLinear | 65 K \n", - "58 | model._latent_encoder._self_attention._W_q.3.linear | Linear | 65 K \n", - "59 | model._latent_encoder._self_attention._W_q.4 | AttnLinear | 65 K \n", - "60 | model._latent_encoder._self_attention._W_q.4.linear | Linear | 65 K \n", - "61 | model._latent_encoder._self_attention._W_q.5 | AttnLinear | 65 K \n", - "62 | model._latent_encoder._self_attention._W_q.5.linear | Linear | 65 K \n", - "63 | model._latent_encoder._self_attention._W_q.6 | AttnLinear | 65 K \n", - "64 | model._latent_encoder._self_attention._W_q.6.linear | Linear | 65 K \n", - "65 | model._latent_encoder._self_attention._W_q.7 | AttnLinear | 65 K \n", - "66 | model._latent_encoder._self_attention._W_q.7.linear | Linear | 65 K \n", - "67 | model._latent_encoder._self_attention._W | AttnLinear | 524 K \n", - "68 | model._latent_encoder._self_attention._W.linear | Linear | 524 K \n", - "69 | model._latent_encoder._penultimate_layer | Linear | 65 K \n", - "70 | model._latent_encoder._mean | Linear | 65 K \n", - "71 | model._latent_encoder._log_var | Linear | 65 K \n", - "72 | model._deterministic_encoder | DeterministicEncoder | 4 M \n", - "73 | model._deterministic_encoder._d_encoder | BatchMLP | 327 K \n", - "74 | model._deterministic_encoder._d_encoder.initial | NPBlockRelu2d | 131 K \n", - "75 | model._deterministic_encoder._d_encoder.initial.linear | Linear | 131 K \n", - "76 | model._deterministic_encoder._d_encoder.initial.act | ReLU | 0 \n", - "77 | model._deterministic_encoder._d_encoder.initial.dropout | Dropout2d | 0 \n", - "78 | model._deterministic_encoder._d_encoder.encoder | Sequential | 131 K \n", - "79 | model._deterministic_encoder._d_encoder.encoder.0 | NPBlockRelu2d | 65 K \n", - "80 | model._deterministic_encoder._d_encoder.encoder.0.linear | Linear | 65 K \n", - "81 | model._deterministic_encoder._d_encoder.encoder.0.act | ReLU | 0 \n", - "82 | model._deterministic_encoder._d_encoder.encoder.0.dropout | Dropout2d | 0 \n", - "83 | model._deterministic_encoder._d_encoder.encoder.1 | NPBlockRelu2d | 65 K \n", - "84 | model._deterministic_encoder._d_encoder.encoder.1.linear | Linear | 65 K \n", - "85 | model._deterministic_encoder._d_encoder.encoder.1.act | ReLU | 0 \n", - "86 | model._deterministic_encoder._d_encoder.encoder.1.dropout | Dropout2d | 0 \n", - "87 | model._deterministic_encoder._d_encoder.final | Linear | 65 K \n", - "88 | model._deterministic_encoder._self_attention | Attention | 2 M \n", - "89 | model._deterministic_encoder._self_attention._W_k | ModuleList | 524 K \n", - "90 | model._deterministic_encoder._self_attention._W_k.0 | AttnLinear | 65 K \n", - "91 | model._deterministic_encoder._self_attention._W_k.0.linear | Linear | 65 K \n", - "92 | model._deterministic_encoder._self_attention._W_k.1 | AttnLinear | 65 K \n", - "93 | model._deterministic_encoder._self_attention._W_k.1.linear | Linear | 65 K \n", - "94 | model._deterministic_encoder._self_attention._W_k.2 | AttnLinear | 65 K \n", - "95 | model._deterministic_encoder._self_attention._W_k.2.linear | Linear | 65 K \n", - "96 | model._deterministic_encoder._self_attention._W_k.3 | AttnLinear | 65 K \n", - "97 | model._deterministic_encoder._self_attention._W_k.3.linear | Linear | 65 K \n", - "98 | model._deterministic_encoder._self_attention._W_k.4 | AttnLinear | 65 K \n", - "99 | model._deterministic_encoder._self_attention._W_k.4.linear | Linear | 65 K \n", - "100 | model._deterministic_encoder._self_attention._W_k.5 | AttnLinear | 65 K \n", - "101 | model._deterministic_encoder._self_attention._W_k.5.linear | Linear | 65 K \n", - "102 | model._deterministic_encoder._self_attention._W_k.6 | AttnLinear | 65 K \n", - "103 | model._deterministic_encoder._self_attention._W_k.6.linear | Linear | 65 K \n", - "104 | model._deterministic_encoder._self_attention._W_k.7 | AttnLinear | 65 K \n", - "105 | model._deterministic_encoder._self_attention._W_k.7.linear | Linear | 65 K \n", - "106 | model._deterministic_encoder._self_attention._W_v | ModuleList | 524 K \n", - "107 | model._deterministic_encoder._self_attention._W_v.0 | AttnLinear | 65 K \n", - "108 | model._deterministic_encoder._self_attention._W_v.0.linear | Linear | 65 K \n", - "109 | model._deterministic_encoder._self_attention._W_v.1 | AttnLinear | 65 K \n", - "110 | model._deterministic_encoder._self_attention._W_v.1.linear | Linear | 65 K \n", - "111 | model._deterministic_encoder._self_attention._W_v.2 | AttnLinear | 65 K \n", - "112 | model._deterministic_encoder._self_attention._W_v.2.linear | Linear | 65 K \n", - "113 | model._deterministic_encoder._self_attention._W_v.3 | AttnLinear | 65 K \n", - "114 | model._deterministic_encoder._self_attention._W_v.3.linear | Linear | 65 K \n", - "115 | model._deterministic_encoder._self_attention._W_v.4 | AttnLinear | 65 K \n", - "116 | model._deterministic_encoder._self_attention._W_v.4.linear | Linear | 65 K \n", - "117 | model._deterministic_encoder._self_attention._W_v.5 | AttnLinear | 65 K \n", - "118 | model._deterministic_encoder._self_attention._W_v.5.linear | Linear | 65 K \n", - "119 | model._deterministic_encoder._self_attention._W_v.6 | AttnLinear | 65 K \n", - "120 | model._deterministic_encoder._self_attention._W_v.6.linear | Linear | 65 K \n", - "121 | model._deterministic_encoder._self_attention._W_v.7 | AttnLinear | 65 K \n", - "122 | model._deterministic_encoder._self_attention._W_v.7.linear | Linear | 65 K \n", - "123 | model._deterministic_encoder._self_attention._W_q | ModuleList | 524 K \n", - "124 | model._deterministic_encoder._self_attention._W_q.0 | AttnLinear | 65 K \n", - "125 | model._deterministic_encoder._self_attention._W_q.0.linear | Linear | 65 K \n", - "126 | model._deterministic_encoder._self_attention._W_q.1 | AttnLinear | 65 K \n", - "127 | model._deterministic_encoder._self_attention._W_q.1.linear | Linear | 65 K \n", - "128 | model._deterministic_encoder._self_attention._W_q.2 | AttnLinear | 65 K \n", - "129 | model._deterministic_encoder._self_attention._W_q.2.linear | Linear | 65 K \n", - "130 | model._deterministic_encoder._self_attention._W_q.3 | AttnLinear | 65 K \n", - "131 | model._deterministic_encoder._self_attention._W_q.3.linear | Linear | 65 K \n", - "132 | model._deterministic_encoder._self_attention._W_q.4 | AttnLinear | 65 K \n", - "133 | model._deterministic_encoder._self_attention._W_q.4.linear | Linear | 65 K \n", - "134 | model._deterministic_encoder._self_attention._W_q.5 | AttnLinear | 65 K \n", - "135 | model._deterministic_encoder._self_attention._W_q.5.linear | Linear | 65 K \n", - "136 | model._deterministic_encoder._self_attention._W_q.6 | AttnLinear | 65 K \n", - "137 | model._deterministic_encoder._self_attention._W_q.6.linear | Linear | 65 K \n", - "138 | model._deterministic_encoder._self_attention._W_q.7 | AttnLinear | 65 K \n", - "139 | model._deterministic_encoder._self_attention._W_q.7.linear | Linear | 65 K \n", - "140 | model._deterministic_encoder._self_attention._W | AttnLinear | 524 K \n", - "141 | model._deterministic_encoder._self_attention._W.linear | Linear | 524 K \n", - "142 | model._deterministic_encoder._cross_attention | Attention | 2 M \n", - "143 | model._deterministic_encoder._cross_attention.batch_mlp_k | BatchMLP | 131 K \n", - "144 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial | NPBlockRelu2d | 65 K \n", - "145 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial.linear | Linear | 65 K \n", - "146 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial.act | ReLU | 0 \n", - "147 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial.dropout | Dropout2d | 0 \n", - "148 | model._deterministic_encoder._cross_attention.batch_mlp_k.encoder | Sequential | 0 \n", - "149 | model._deterministic_encoder._cross_attention.batch_mlp_k.final | Linear | 65 K \n", - "150 | model._deterministic_encoder._cross_attention.batch_mlp_q | BatchMLP | 131 K \n", - "151 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial | NPBlockRelu2d | 65 K \n", - "152 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial.linear | Linear | 65 K \n", - "153 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial.act | ReLU | 0 \n", - "154 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial.dropout | Dropout2d | 0 \n", - "155 | model._deterministic_encoder._cross_attention.batch_mlp_q.encoder | Sequential | 0 \n", - "156 | model._deterministic_encoder._cross_attention.batch_mlp_q.final | Linear | 65 K \n", - "157 | model._deterministic_encoder._cross_attention._W_k | ModuleList | 524 K \n", - "158 | model._deterministic_encoder._cross_attention._W_k.0 | AttnLinear | 65 K \n", - "159 | model._deterministic_encoder._cross_attention._W_k.0.linear | Linear | 65 K \n", - "160 | model._deterministic_encoder._cross_attention._W_k.1 | AttnLinear | 65 K \n", - "161 | model._deterministic_encoder._cross_attention._W_k.1.linear | Linear | 65 K \n", - "162 | model._deterministic_encoder._cross_attention._W_k.2 | AttnLinear | 65 K \n", - "163 | model._deterministic_encoder._cross_attention._W_k.2.linear | Linear | 65 K \n", - "164 | model._deterministic_encoder._cross_attention._W_k.3 | AttnLinear | 65 K \n", - "165 | model._deterministic_encoder._cross_attention._W_k.3.linear | Linear | 65 K \n", - "166 | model._deterministic_encoder._cross_attention._W_k.4 | AttnLinear | 65 K \n", - "167 | model._deterministic_encoder._cross_attention._W_k.4.linear | Linear | 65 K \n", - "168 | model._deterministic_encoder._cross_attention._W_k.5 | AttnLinear | 65 K \n", - "169 | model._deterministic_encoder._cross_attention._W_k.5.linear | Linear | 65 K \n", - "170 | model._deterministic_encoder._cross_attention._W_k.6 | AttnLinear | 65 K \n", - "171 | model._deterministic_encoder._cross_attention._W_k.6.linear | Linear | 65 K \n", - "172 | model._deterministic_encoder._cross_attention._W_k.7 | AttnLinear | 65 K \n", - "173 | model._deterministic_encoder._cross_attention._W_k.7.linear | Linear | 65 K \n", - "174 | model._deterministic_encoder._cross_attention._W_v | ModuleList | 524 K \n", - "175 | model._deterministic_encoder._cross_attention._W_v.0 | AttnLinear | 65 K \n", - "176 | model._deterministic_encoder._cross_attention._W_v.0.linear | Linear | 65 K \n", - "177 | model._deterministic_encoder._cross_attention._W_v.1 | AttnLinear | 65 K \n", - "178 | model._deterministic_encoder._cross_attention._W_v.1.linear | Linear | 65 K \n", - "179 | model._deterministic_encoder._cross_attention._W_v.2 | AttnLinear | 65 K \n", - "180 | model._deterministic_encoder._cross_attention._W_v.2.linear | Linear | 65 K \n", - "181 | model._deterministic_encoder._cross_attention._W_v.3 | AttnLinear | 65 K \n", - "182 | model._deterministic_encoder._cross_attention._W_v.3.linear | Linear | 65 K \n", - "183 | model._deterministic_encoder._cross_attention._W_v.4 | AttnLinear | 65 K \n", - "184 | model._deterministic_encoder._cross_attention._W_v.4.linear | Linear | 65 K \n", - "185 | model._deterministic_encoder._cross_attention._W_v.5 | AttnLinear | 65 K \n", - "186 | model._deterministic_encoder._cross_attention._W_v.5.linear | Linear | 65 K \n", - "187 | model._deterministic_encoder._cross_attention._W_v.6 | AttnLinear | 65 K \n", - "188 | model._deterministic_encoder._cross_attention._W_v.6.linear | Linear | 65 K \n", - "189 | model._deterministic_encoder._cross_attention._W_v.7 | AttnLinear | 65 K \n", - "190 | model._deterministic_encoder._cross_attention._W_v.7.linear | Linear | 65 K \n", - "191 | model._deterministic_encoder._cross_attention._W_q | ModuleList | 524 K \n", - "192 | model._deterministic_encoder._cross_attention._W_q.0 | AttnLinear | 65 K \n", - "193 | model._deterministic_encoder._cross_attention._W_q.0.linear | Linear | 65 K \n", - "194 | model._deterministic_encoder._cross_attention._W_q.1 | AttnLinear | 65 K \n", - "195 | model._deterministic_encoder._cross_attention._W_q.1.linear | Linear | 65 K \n", - "196 | model._deterministic_encoder._cross_attention._W_q.2 | AttnLinear | 65 K \n", - "197 | model._deterministic_encoder._cross_attention._W_q.2.linear | Linear | 65 K \n", - "198 | model._deterministic_encoder._cross_attention._W_q.3 | AttnLinear | 65 K \n", - "199 | model._deterministic_encoder._cross_attention._W_q.3.linear | Linear | 65 K \n", - "200 | model._deterministic_encoder._cross_attention._W_q.4 | AttnLinear | 65 K \n", - "201 | model._deterministic_encoder._cross_attention._W_q.4.linear | Linear | 65 K \n", - "202 | model._deterministic_encoder._cross_attention._W_q.5 | AttnLinear | 65 K \n", - "203 | model._deterministic_encoder._cross_attention._W_q.5.linear | Linear | 65 K \n", - "204 | model._deterministic_encoder._cross_attention._W_q.6 | AttnLinear | 65 K \n", - "205 | model._deterministic_encoder._cross_attention._W_q.6.linear | Linear | 65 K \n", - "206 | model._deterministic_encoder._cross_attention._W_q.7 | AttnLinear | 65 K \n", - "207 | model._deterministic_encoder._cross_attention._W_q.7.linear | Linear | 65 K \n", - "208 | model._deterministic_encoder._cross_attention._W | AttnLinear | 524 K \n", - "209 | model._deterministic_encoder._cross_attention._W.linear | Linear | 524 K \n", - "210 | model._decoder | Decoder | 1 M \n", - "211 | model._decoder._target_transform | Linear | 65 K \n", - "212 | model._decoder._decoder | BatchMLP | 1 M \n", - "213 | model._decoder._decoder.initial | NPBlockRelu2d | 262 K \n", - "214 | model._decoder._decoder.initial.linear | Linear | 262 K \n", - "215 | model._decoder._decoder.initial.act | ReLU | 0 \n", - "216 | model._decoder._decoder.initial.dropout | Dropout2d | 0 \n", - "217 | model._decoder._decoder.encoder | Sequential | 524 K \n", - "218 | model._decoder._decoder.encoder.0 | NPBlockRelu2d | 262 K \n", - "219 | model._decoder._decoder.encoder.0.linear | Linear | 262 K \n", - "220 | model._decoder._decoder.encoder.0.act | ReLU | 0 \n", - "221 | model._decoder._decoder.encoder.0.dropout | Dropout2d | 0 \n", - "222 | model._decoder._decoder.encoder.1 | NPBlockRelu2d | 262 K \n", - "223 | model._decoder._decoder.encoder.1.linear | Linear | 262 K \n", - "224 | model._decoder._decoder.encoder.1.act | ReLU | 0 \n", - "225 | model._decoder._decoder.encoder.1.dropout | Dropout2d | 0 \n", - "226 | model._decoder._decoder.final | Linear | 262 K \n", - "227 | model._decoder._mean | Linear | 513 \n", - "228 | model._decoder._std | Linear | 513 \n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validation sanity check', layout=Layout(flex='2'), max=5.…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 0, {'val_loss': '0.4272317886352539', 'val/kl': '2.016334832433131e-07', 'val/std': '0.708134114742279', 'val/mse': '0.26763391494750977'} {}\n", - "\r" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "87cac5e584db4c3b9650b74388af0cb1", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=1.0, bar_style='info', layout=Layout(flex='2'), max=1.0), HTML(value='')), …" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 1826, {'val_loss': '-0.6243447065353394', 'val/kl': '0.0001655164232943207', 'val/std': '0.09201371669769287', 'val/mse': '0.006292355712503195'} {'train_loss': -0.4238220751285553, 'train/kl': 0.00010450785339344293, 'train/std': 0.12079621851444244, 'train/mse': 0.014694823883473873}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 3653, {'val_loss': '-0.7118011713027954', 'val/kl': '0.00016593901091255248', 'val/std': '0.0826723650097847', 'val/mse': '0.004447834100574255'} {'train_loss': -0.6183847784996033, 'train/kl': 0.00015263594104908407, 'train/std': 0.08014649152755737, 'train/mse': 0.008464133366942406}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 5480, {'val_loss': '-0.658303439617157', 'val/kl': '0.00032418235787190497', 'val/std': '0.08431340754032135', 'val/mse': '0.005865172948688269'} {'train_loss': -0.6666434407234192, 'train/kl': 0.0001958497887244448, 'train/std': 0.07278729975223541, 'train/mse': 0.007329223677515984}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 7307, {'val_loss': '-0.7170640230178833', 'val/kl': '0.0001662165013840422', 'val/std': '0.05576356500387192', 'val/mse': '0.005448098294436932'} {'train_loss': -0.6996455788612366, 'train/kl': 0.00019197423534933478, 'train/std': 0.06931658089160919, 'train/mse': 0.0066827693954110146}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 9134, {'val_loss': '-0.7675071954727173', 'val/kl': '0.00015290360897779465', 'val/std': '0.05838920548558235', 'val/mse': '0.0046668751165270805'} {'train_loss': -0.716970682144165, 'train/kl': 0.00018089132208842784, 'train/std': 0.06721778213977814, 'train/mse': 0.006413701921701431}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 10961, {'val_loss': '-0.7645254731178284', 'val/kl': '0.0001615239161765203', 'val/std': '0.055786460638046265', 'val/mse': '0.0038805422373116016'} {'train_loss': -0.7421634793281555, 'train/kl': 0.00018077155982609838, 'train/std': 0.06484661996364594, 'train/mse': 0.006069732364267111}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 12788, {'val_loss': '-0.7474324107170105', 'val/kl': '0.00015343778068199754', 'val/std': '0.05599140375852585', 'val/mse': '0.004850178025662899'} {'train_loss': -0.765358567237854, 'train/kl': 0.00017713270790409297, 'train/std': 0.06183164194226265, 'train/mse': 0.00569744361564517}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 14615, {'val_loss': '-0.7448654174804688', 'val/kl': '8.592780795879662e-05', 'val/std': '0.04981078580021858', 'val/mse': '0.004216459579765797'} {'train_loss': -0.7900658845901489, 'train/kl': 0.00017211325757671148, 'train/std': 0.06001533195376396, 'train/mse': 0.005463994108140469}\n", - "Epoch 7: reducing learning rate of group 0 to 3.0000e-05.\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 16442, {'val_loss': '-0.6781318783760071', 'val/kl': '9.873737872112542e-05', 'val/std': '0.04399699345231056', 'val/mse': '0.004785820841789246'} {'train_loss': -0.8445413112640381, 'train/kl': 0.00017202386516146362, 'train/std': 0.05372248962521553, 'train/mse': 0.00473695108667016}\n", - "INFO:root:Epoch 00009: early stopping\n", - "\n", - "Loading checkpoint lightning_logs/anp-rnn2/version_-4/_ckpt_epoch_4.ckpt\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "1846666e41594f38b28d462a6ac9c603", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Testing', layout=Layout(flex='2'), max=356.0, style=Progr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 16443, {'val_loss': '2.689519166946411', 'val/kl': '0.0020408218260854483', 'val/std': '0.14355066418647766', 'val/mse': '0.27067017555236816'} {}\n", - "----------------------------------------------------------------------------------------------------\n", - "TEST RESULTS\n", - "{}\n", - "----------------------------------------------------------------------------------------------------\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "trial, trainer, model = run_trial(\n", " name=\"anp-rnn2\",\n", - " params={\n", - " **default_params, \n", + " params={ \n", " 'det_enc_self_attn_type': 'multihead',\n", " 'latent_enc_self_attn_type': 'multihead',\n", " 'use_deterministic_path': False,\n", " 'use_rnn': True,\n", " 'use_lvar': False,\n", " },\n", - " user_attrs=default_attrs,\n", - " PL_MODEL_CLS=LatentModelPL)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "ExecuteTime": { - "end_time": "2020-03-15T15:59:03.688697Z", - "start_time": "2020-03-15T15:59:03.631285Z" - } - }, - "outputs": [], - "source": [ - "# trial, trainer, model = run_trial(\n", - "# name=\"anp-rnn3b\",\n", - "# params={\n", - "# **default_params, \n", - "# 'det_enc_self_attn_type': 'ptmultihead',\n", - "# 'latent_enc_self_attn_type': 'ptmultihead',\n", - "# 'use_deterministic_path': False,\n", - "# 'use_rnn': True,\n", - "# 'use_lvar': False,\n", - "# },\n", - "# user_attrs=default_attrs,\n", - "# PL_MODEL_CLS=LatentModelPL)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "ExecuteTime": { - "end_time": "2020-03-16T00:02:56.437933Z", - "start_time": "2020-03-15T23:27:28.462054Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "now run `tensorboard --logdir lightning_logs`\n", - "trial.number -4\n", - "INFO:root:GPU available: True, used: True\n", - "INFO:root:VISIBLE GPUS: 0\n", - "INFO:root:\n", - " | Name | Type | Params\n", - "---------------------------------------------------------------------------------------------------------------\n", - "0 | model | LatentModel | 6 M \n", - "1 | model.norm_x | BatchNormSequence | 34 \n", - "2 | model.norm_x.norm | BatchNorm1d | 34 \n", - "3 | model.norm_y | BatchNormSequence | 2 \n", - "4 | model.norm_y.norm | BatchNorm1d | 2 \n", - "5 | model._lstm_x | LSTM | 807 K \n", - "6 | model._lstm_y | LSTM | 791 K \n", - "7 | model._latent_encoder | LatentEncoder | 656 K \n", - "8 | model._latent_encoder._encoder | BatchMLP | 196 K \n", - "9 | model._latent_encoder._encoder.initial | NPBlockRelu2d | 131 K \n", - "10 | model._latent_encoder._encoder.initial.linear | Linear | 131 K \n", - "11 | model._latent_encoder._encoder.initial.act | ReLU | 0 \n", - "12 | model._latent_encoder._encoder.initial.dropout | Dropout2d | 0 \n", - "13 | model._latent_encoder._encoder.encoder | Sequential | 0 \n", - "14 | model._latent_encoder._encoder.final | Linear | 65 K \n", - "15 | model._latent_encoder._self_attention | Attention | 262 K \n", - "16 | model._latent_encoder._self_attention._W | MultiheadAttention | 262 K \n", - "17 | model._latent_encoder._self_attention._W.out_proj | Linear | 65 K \n", - "18 | model._latent_encoder._penultimate_layer | Linear | 65 K \n", - "19 | model._latent_encoder._mean | Linear | 65 K \n", - "20 | model._latent_encoder._log_var | Linear | 65 K \n", - "21 | model._deterministic_encoder | DeterministicEncoder | 2 M \n", - "22 | model._deterministic_encoder._d_encoder | BatchMLP | 327 K \n", - "23 | model._deterministic_encoder._d_encoder.initial | NPBlockRelu2d | 131 K \n", - "24 | model._deterministic_encoder._d_encoder.initial.linear | Linear | 131 K \n", - "25 | model._deterministic_encoder._d_encoder.initial.act | ReLU | 0 \n", - "26 | model._deterministic_encoder._d_encoder.initial.dropout | Dropout2d | 0 \n", - "27 | model._deterministic_encoder._d_encoder.encoder | Sequential | 131 K \n", - "28 | model._deterministic_encoder._d_encoder.encoder.0 | NPBlockRelu2d | 65 K \n", - "29 | model._deterministic_encoder._d_encoder.encoder.0.linear | Linear | 65 K \n", - "30 | model._deterministic_encoder._d_encoder.encoder.0.act | ReLU | 0 \n", - "31 | model._deterministic_encoder._d_encoder.encoder.0.dropout | Dropout2d | 0 \n", - "32 | model._deterministic_encoder._d_encoder.encoder.1 | NPBlockRelu2d | 65 K \n", - "33 | model._deterministic_encoder._d_encoder.encoder.1.linear | Linear | 65 K \n", - "34 | model._deterministic_encoder._d_encoder.encoder.1.act | ReLU | 0 \n", - "35 | model._deterministic_encoder._d_encoder.encoder.1.dropout | Dropout2d | 0 \n", - "36 | model._deterministic_encoder._d_encoder.final | Linear | 65 K \n", - "37 | model._deterministic_encoder._self_attention | Attention | 262 K \n", - "38 | model._deterministic_encoder._self_attention._W | MultiheadAttention | 262 K \n", - "39 | model._deterministic_encoder._self_attention._W.out_proj | Linear | 65 K \n", - "40 | model._deterministic_encoder._cross_attention | Attention | 2 M \n", - "41 | model._deterministic_encoder._cross_attention.batch_mlp_k | BatchMLP | 131 K \n", - "42 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial | NPBlockRelu2d | 65 K \n", - "43 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial.linear | Linear | 65 K \n", - "44 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial.act | ReLU | 0 \n", - "45 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial.dropout | Dropout2d | 0 \n", - "46 | model._deterministic_encoder._cross_attention.batch_mlp_k.encoder | Sequential | 0 \n", - "47 | model._deterministic_encoder._cross_attention.batch_mlp_k.final | Linear | 65 K \n", - "48 | model._deterministic_encoder._cross_attention.batch_mlp_q | BatchMLP | 131 K \n", - "49 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial | NPBlockRelu2d | 65 K \n", - "50 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial.linear | Linear | 65 K \n", - "51 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial.act | ReLU | 0 \n", - "52 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial.dropout | Dropout2d | 0 \n", - "53 | model._deterministic_encoder._cross_attention.batch_mlp_q.encoder | Sequential | 0 \n", - "54 | model._deterministic_encoder._cross_attention.batch_mlp_q.final | Linear | 65 K \n", - "55 | model._deterministic_encoder._cross_attention._W_k | ModuleList | 524 K \n", - "56 | model._deterministic_encoder._cross_attention._W_k.0 | AttnLinear | 65 K \n", - "57 | model._deterministic_encoder._cross_attention._W_k.0.linear | Linear | 65 K \n", - "58 | model._deterministic_encoder._cross_attention._W_k.1 | AttnLinear | 65 K \n", - "59 | model._deterministic_encoder._cross_attention._W_k.1.linear | Linear | 65 K \n", - "60 | model._deterministic_encoder._cross_attention._W_k.2 | AttnLinear | 65 K \n", - "61 | model._deterministic_encoder._cross_attention._W_k.2.linear | Linear | 65 K \n", - "62 | model._deterministic_encoder._cross_attention._W_k.3 | AttnLinear | 65 K \n", - "63 | model._deterministic_encoder._cross_attention._W_k.3.linear | Linear | 65 K \n", - "64 | model._deterministic_encoder._cross_attention._W_k.4 | AttnLinear | 65 K \n", - "65 | model._deterministic_encoder._cross_attention._W_k.4.linear | Linear | 65 K \n", - "66 | model._deterministic_encoder._cross_attention._W_k.5 | AttnLinear | 65 K \n", - "67 | model._deterministic_encoder._cross_attention._W_k.5.linear | Linear | 65 K \n", - "68 | model._deterministic_encoder._cross_attention._W_k.6 | AttnLinear | 65 K \n", - "69 | model._deterministic_encoder._cross_attention._W_k.6.linear | Linear | 65 K \n", - "70 | model._deterministic_encoder._cross_attention._W_k.7 | AttnLinear | 65 K \n", - "71 | model._deterministic_encoder._cross_attention._W_k.7.linear | Linear | 65 K \n", - "72 | model._deterministic_encoder._cross_attention._W_v | ModuleList | 524 K \n", - "73 | model._deterministic_encoder._cross_attention._W_v.0 | AttnLinear | 65 K \n", - "74 | model._deterministic_encoder._cross_attention._W_v.0.linear | Linear | 65 K \n", - "75 | model._deterministic_encoder._cross_attention._W_v.1 | AttnLinear | 65 K \n", - "76 | model._deterministic_encoder._cross_attention._W_v.1.linear | Linear | 65 K \n", - "77 | model._deterministic_encoder._cross_attention._W_v.2 | AttnLinear | 65 K \n", - "78 | model._deterministic_encoder._cross_attention._W_v.2.linear | Linear | 65 K \n", - "79 | model._deterministic_encoder._cross_attention._W_v.3 | AttnLinear | 65 K \n", - "80 | model._deterministic_encoder._cross_attention._W_v.3.linear | Linear | 65 K \n", - "81 | model._deterministic_encoder._cross_attention._W_v.4 | AttnLinear | 65 K \n", - "82 | model._deterministic_encoder._cross_attention._W_v.4.linear | Linear | 65 K \n", - "83 | model._deterministic_encoder._cross_attention._W_v.5 | AttnLinear | 65 K \n", - "84 | model._deterministic_encoder._cross_attention._W_v.5.linear | Linear | 65 K \n", - "85 | model._deterministic_encoder._cross_attention._W_v.6 | AttnLinear | 65 K \n", - "86 | model._deterministic_encoder._cross_attention._W_v.6.linear | Linear | 65 K \n", - "87 | model._deterministic_encoder._cross_attention._W_v.7 | AttnLinear | 65 K \n", - "88 | model._deterministic_encoder._cross_attention._W_v.7.linear | Linear | 65 K \n", - "89 | model._deterministic_encoder._cross_attention._W_q | ModuleList | 524 K \n", - "90 | model._deterministic_encoder._cross_attention._W_q.0 | AttnLinear | 65 K \n", - "91 | model._deterministic_encoder._cross_attention._W_q.0.linear | Linear | 65 K \n", - "92 | model._deterministic_encoder._cross_attention._W_q.1 | AttnLinear | 65 K \n", - "93 | model._deterministic_encoder._cross_attention._W_q.1.linear | Linear | 65 K \n", - "94 | model._deterministic_encoder._cross_attention._W_q.2 | AttnLinear | 65 K \n", - "95 | model._deterministic_encoder._cross_attention._W_q.2.linear | Linear | 65 K \n", - "96 | model._deterministic_encoder._cross_attention._W_q.3 | AttnLinear | 65 K \n", - "97 | model._deterministic_encoder._cross_attention._W_q.3.linear | Linear | 65 K \n", - "98 | model._deterministic_encoder._cross_attention._W_q.4 | AttnLinear | 65 K \n", - "99 | model._deterministic_encoder._cross_attention._W_q.4.linear | Linear | 65 K \n", - "100 | model._deterministic_encoder._cross_attention._W_q.5 | AttnLinear | 65 K \n", - "101 | model._deterministic_encoder._cross_attention._W_q.5.linear | Linear | 65 K \n", - "102 | model._deterministic_encoder._cross_attention._W_q.6 | AttnLinear | 65 K \n", - "103 | model._deterministic_encoder._cross_attention._W_q.6.linear | Linear | 65 K \n", - "104 | model._deterministic_encoder._cross_attention._W_q.7 | AttnLinear | 65 K \n", - "105 | model._deterministic_encoder._cross_attention._W_q.7.linear | Linear | 65 K \n", - "106 | model._deterministic_encoder._cross_attention._W | AttnLinear | 524 K \n", - "107 | model._deterministic_encoder._cross_attention._W.linear | Linear | 524 K \n", - "108 | model._decoder | Decoder | 1 M \n", - "109 | model._decoder._target_transform | Linear | 65 K \n", - "110 | model._decoder._decoder | BatchMLP | 1 M \n", - "111 | model._decoder._decoder.initial | NPBlockRelu2d | 262 K \n", - "112 | model._decoder._decoder.initial.linear | Linear | 262 K \n", - "113 | model._decoder._decoder.initial.act | ReLU | 0 \n", - "114 | model._decoder._decoder.initial.dropout | Dropout2d | 0 \n", - "115 | model._decoder._decoder.encoder | Sequential | 524 K \n", - "116 | model._decoder._decoder.encoder.0 | NPBlockRelu2d | 262 K \n", - "117 | model._decoder._decoder.encoder.0.linear | Linear | 262 K \n", - "118 | model._decoder._decoder.encoder.0.act | ReLU | 0 \n", - "119 | model._decoder._decoder.encoder.0.dropout | Dropout2d | 0 \n", - "120 | model._decoder._decoder.encoder.1 | NPBlockRelu2d | 262 K \n", - "121 | model._decoder._decoder.encoder.1.linear | Linear | 262 K \n", - "122 | model._decoder._decoder.encoder.1.act | ReLU | 0 \n", - "123 | model._decoder._decoder.encoder.1.dropout | Dropout2d | 0 \n", - "124 | model._decoder._decoder.final | Linear | 262 K \n", - "125 | model._decoder._mean | Linear | 513 \n", - "126 | model._decoder._std | Linear | 513 \n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validation sanity check', layout=Layout(flex='2'), max=5.…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 0, {'val_loss': '1.026720404624939', 'val/kl': '0.5007113814353943', 'val/std': '0.9732889533042908', 'val/mse': '0.27839022874832153'} {}\n", - "\r" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "fd729dfae8d3424c908b7f8a0f24d7c3", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=1.0, bar_style='info', layout=Layout(flex='2'), max=1.0), HTML(value='')), …" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 1826, {'val_loss': '-0.5595438480377197', 'val/kl': '0.0010225089499726892', 'val/std': '0.10681277513504028', 'val/mse': '0.006353958044201136'} {'train_loss': -0.3397707939147949, 'train/kl': 0.018496964126825333, 'train/std': 0.14299923181533813, 'train/mse': 0.018082212656736374}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 3653, {'val_loss': '-0.6956742405891418', 'val/kl': '0.0003743761917576194', 'val/std': '0.07734071463346481', 'val/mse': '0.004305768292397261'} {'train_loss': -0.584082305431366, 'train/kl': 0.0011084909783676267, 'train/std': 0.08415291458368301, 'train/mse': 0.009035862050950527}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 5480, {'val_loss': '-0.660943865776062', 'val/kl': '0.00038441800279542804', 'val/std': '0.06794506311416626', 'val/mse': '0.0067007397301495075'} {'train_loss': -0.6457037329673767, 'train/kl': 0.000914797477889806, 'train/std': 0.07557971775531769, 'train/mse': 0.007583978585898876}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 7307, {'val_loss': '-0.6902258396148682', 'val/kl': '0.000548120413441211', 'val/std': '0.06256082653999329', 'val/mse': '0.00506548723205924'} {'train_loss': -0.6821491718292236, 'train/kl': 0.0006638779304921627, 'train/std': 0.07080988585948944, 'train/mse': 0.006849905010312796}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 9134, {'val_loss': '-0.6788279414176941', 'val/kl': '0.0004198125097900629', 'val/std': '0.07540367543697357', 'val/mse': '0.006317061837762594'} {'train_loss': -0.6997294425964355, 'train/kl': 0.0005116851534694433, 'train/std': 0.06830525398254395, 'train/mse': 0.006480811629444361}\n", - "Epoch 4: reducing learning rate of group 0 to 3.0000e-05.\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 10961, {'val_loss': '-0.7686061263084412', 'val/kl': '0.00026501118554733694', 'val/std': '0.053781475871801376', 'val/mse': '0.003572280751541257'} {'train_loss': -0.7661863565444946, 'train/kl': 0.00034162303199991584, 'train/std': 0.06142435222864151, 'train/mse': 0.005500624421983957}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 12788, {'val_loss': '-0.6987411379814148', 'val/kl': '0.0002520672569517046', 'val/std': '0.05158507451415062', 'val/mse': '0.0047387173399329185'} {'train_loss': -0.7794477939605713, 'train/kl': 0.00027729771682061255, 'train/std': 0.05976495146751404, 'train/mse': 0.005322746932506561}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 14615, {'val_loss': '-0.7118856906890869', 'val/kl': '0.00027958446298725903', 'val/std': '0.04966074973344803', 'val/mse': '0.004328195936977863'} {'train_loss': -0.7852046489715576, 'train/kl': 0.00026115216314792633, 'train/std': 0.059137631207704544, 'train/mse': 0.005295000970363617}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 16442, {'val_loss': '-0.693724513053894', 'val/kl': '0.00022185625857673585', 'val/std': '0.04828304052352905', 'val/mse': '0.004384470172226429'} {'train_loss': -0.7984015941619873, 'train/kl': 0.00024578155716881156, 'train/std': 0.05835358053445816, 'train/mse': 0.005178666207939386}\n", - "Epoch 8: reducing learning rate of group 0 to 3.0000e-06.\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 18269, {'val_loss': '-0.679880678653717', 'val/kl': '0.00024899686104618013', 'val/std': '0.04855526238679886', 'val/mse': '0.004621494561433792'} {'train_loss': -0.8050701022148132, 'train/kl': 0.00024039045092649758, 'train/std': 0.05741057172417641, 'train/mse': 0.0051253121346235275}\n", - "INFO:root:Epoch 00010: early stopping\n", - "\n", - "Loading checkpoint lightning_logs/anp-rnn3/version_-4/_ckpt_epoch_5.ckpt\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "8840504d68c8417a99e6382ad37c7f68", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Testing', layout=Layout(flex='2'), max=356.0, style=Progr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 18270, {'val_loss': '5.094888687133789', 'val/kl': '0.0008846893324516714', 'val/std': '0.09817715734243393', 'val/mse': '0.1575705111026764'} {}\n", - "----------------------------------------------------------------------------------------------------\n", - "TEST RESULTS\n", - "{}\n", - "----------------------------------------------------------------------------------------------------\n", - "\n" - ] - } - ], - "source": [ - "trial, trainer, model = run_trial(\n", - " name=\"anp-rnn3\",\n", - " params={\n", - " **default_params,\n", - " 'det_enc_self_attn_type': 'ptmultihead',\n", - " 'latent_enc_self_attn_type': 'ptmultihead',\n", - " 'use_deterministic_path': False,\n", - " 'use_rnn': True\n", - " },\n", - " user_attrs=default_attrs,\n", - " PL_MODEL_CLS=LatentModelPL)" + " user_attrs=default_user_attrs,\n", + " PL_MODEL_CLS=PL_NeuralProcess)" ] }, { @@ -2341,2227 +387,185 @@ "scrolled": true }, "source": [ - "# ANP" + "## ANP" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": { "ExecuteTime": { - "end_time": "2020-03-15T16:53:19.148385Z", - "start_time": "2020-03-15T16:34:45.848337Z" + "end_time": "2020-04-11T04:38:49.865814Z", + "start_time": "2020-04-11T04:38:46.400Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "now run `tensorboard --logdir lightning_logs`\n", - "trial.number -2\n", - "INFO:root:GPU available: True, used: True\n", - "INFO:root:VISIBLE GPUS: 0\n", - "INFO:root:\n", - " | Name | Type | Params\n", - "---------------------------------------------------------------------------------------------------------------\n", - "0 | model | LatentModel | 7 M \n", - "1 | model.norm_x | BatchNormSequence | 34 \n", - "2 | model.norm_x.norm | BatchNorm1d | 34 \n", - "3 | model.norm_y | BatchNormSequence | 2 \n", - "4 | model.norm_y.norm | BatchNorm1d | 2 \n", - "5 | model._latent_encoder | LatentEncoder | 2 M \n", - "6 | model._latent_encoder._encoder | BatchMLP | 70 K \n", - "7 | model._latent_encoder._encoder.initial | NPBlockRelu2d | 4 K \n", - "8 | model._latent_encoder._encoder.initial.linear | Linear | 4 K \n", - "9 | model._latent_encoder._encoder.initial.act | ReLU | 0 \n", - "10 | model._latent_encoder._encoder.initial.dropout | Dropout2d | 0 \n", - "11 | model._latent_encoder._encoder.encoder | Sequential | 0 \n", - "12 | model._latent_encoder._encoder.final | Linear | 65 K \n", - "13 | model._latent_encoder._self_attention | Attention | 2 M \n", - "14 | model._latent_encoder._self_attention._W_k | ModuleList | 524 K \n", - "15 | model._latent_encoder._self_attention._W_k.0 | AttnLinear | 65 K \n", - "16 | model._latent_encoder._self_attention._W_k.0.linear | Linear | 65 K \n", - "17 | model._latent_encoder._self_attention._W_k.1 | AttnLinear | 65 K \n", - "18 | model._latent_encoder._self_attention._W_k.1.linear | Linear | 65 K \n", - "19 | model._latent_encoder._self_attention._W_k.2 | AttnLinear | 65 K \n", - "20 | model._latent_encoder._self_attention._W_k.2.linear | Linear | 65 K \n", - "21 | model._latent_encoder._self_attention._W_k.3 | AttnLinear | 65 K \n", - "22 | model._latent_encoder._self_attention._W_k.3.linear | Linear | 65 K \n", - "23 | model._latent_encoder._self_attention._W_k.4 | AttnLinear | 65 K \n", - "24 | model._latent_encoder._self_attention._W_k.4.linear | Linear | 65 K \n", - "25 | model._latent_encoder._self_attention._W_k.5 | AttnLinear | 65 K \n", - "26 | model._latent_encoder._self_attention._W_k.5.linear | Linear | 65 K \n", - "27 | model._latent_encoder._self_attention._W_k.6 | AttnLinear | 65 K \n", - "28 | model._latent_encoder._self_attention._W_k.6.linear | Linear | 65 K \n", - "29 | model._latent_encoder._self_attention._W_k.7 | AttnLinear | 65 K \n", - "30 | model._latent_encoder._self_attention._W_k.7.linear | Linear | 65 K \n", - "31 | model._latent_encoder._self_attention._W_v | ModuleList | 524 K \n", - "32 | model._latent_encoder._self_attention._W_v.0 | AttnLinear | 65 K \n", - "33 | model._latent_encoder._self_attention._W_v.0.linear | Linear | 65 K \n", - "34 | model._latent_encoder._self_attention._W_v.1 | AttnLinear | 65 K \n", - "35 | model._latent_encoder._self_attention._W_v.1.linear | Linear | 65 K \n", - "36 | model._latent_encoder._self_attention._W_v.2 | AttnLinear | 65 K \n", - "37 | model._latent_encoder._self_attention._W_v.2.linear | Linear | 65 K \n", - "38 | model._latent_encoder._self_attention._W_v.3 | AttnLinear | 65 K \n", - "39 | model._latent_encoder._self_attention._W_v.3.linear | Linear | 65 K \n", - "40 | model._latent_encoder._self_attention._W_v.4 | AttnLinear | 65 K \n", - "41 | model._latent_encoder._self_attention._W_v.4.linear | Linear | 65 K \n", - "42 | model._latent_encoder._self_attention._W_v.5 | AttnLinear | 65 K \n", - "43 | model._latent_encoder._self_attention._W_v.5.linear | Linear | 65 K \n", - "44 | model._latent_encoder._self_attention._W_v.6 | AttnLinear | 65 K \n", - "45 | model._latent_encoder._self_attention._W_v.6.linear | Linear | 65 K \n", - "46 | model._latent_encoder._self_attention._W_v.7 | AttnLinear | 65 K \n", - "47 | model._latent_encoder._self_attention._W_v.7.linear | Linear | 65 K \n", - "48 | model._latent_encoder._self_attention._W_q | ModuleList | 524 K \n", - "49 | model._latent_encoder._self_attention._W_q.0 | AttnLinear | 65 K \n", - "50 | model._latent_encoder._self_attention._W_q.0.linear | Linear | 65 K \n", - "51 | model._latent_encoder._self_attention._W_q.1 | AttnLinear | 65 K \n", - "52 | model._latent_encoder._self_attention._W_q.1.linear | Linear | 65 K \n", - "53 | model._latent_encoder._self_attention._W_q.2 | AttnLinear | 65 K \n", - "54 | model._latent_encoder._self_attention._W_q.2.linear | Linear | 65 K \n", - "55 | model._latent_encoder._self_attention._W_q.3 | AttnLinear | 65 K \n", - "56 | model._latent_encoder._self_attention._W_q.3.linear | Linear | 65 K \n", - "57 | model._latent_encoder._self_attention._W_q.4 | AttnLinear | 65 K \n", - "58 | model._latent_encoder._self_attention._W_q.4.linear | Linear | 65 K \n", - "59 | model._latent_encoder._self_attention._W_q.5 | AttnLinear | 65 K \n", - "60 | model._latent_encoder._self_attention._W_q.5.linear | Linear | 65 K \n", - "61 | model._latent_encoder._self_attention._W_q.6 | AttnLinear | 65 K \n", - "62 | model._latent_encoder._self_attention._W_q.6.linear | Linear | 65 K \n", - "63 | model._latent_encoder._self_attention._W_q.7 | AttnLinear | 65 K \n", - "64 | model._latent_encoder._self_attention._W_q.7.linear | Linear | 65 K \n", - "65 | model._latent_encoder._self_attention._W | AttnLinear | 524 K \n", - "66 | model._latent_encoder._self_attention._W.linear | Linear | 524 K \n", - "67 | model._latent_encoder._penultimate_layer | Linear | 65 K \n", - "68 | model._latent_encoder._mean | Linear | 65 K \n", - "69 | model._latent_encoder._log_var | Linear | 65 K \n", - "70 | model._deterministic_encoder | DeterministicEncoder | 4 M \n", - "71 | model._deterministic_encoder._d_encoder | BatchMLP | 201 K \n", - "72 | model._deterministic_encoder._d_encoder.initial | NPBlockRelu2d | 4 K \n", - "73 | model._deterministic_encoder._d_encoder.initial.linear | Linear | 4 K \n", - "74 | model._deterministic_encoder._d_encoder.initial.act | ReLU | 0 \n", - "75 | model._deterministic_encoder._d_encoder.initial.dropout | Dropout2d | 0 \n", - "76 | model._deterministic_encoder._d_encoder.encoder | Sequential | 131 K \n", - "77 | model._deterministic_encoder._d_encoder.encoder.0 | NPBlockRelu2d | 65 K \n", - "78 | model._deterministic_encoder._d_encoder.encoder.0.linear | Linear | 65 K \n", - "79 | model._deterministic_encoder._d_encoder.encoder.0.act | ReLU | 0 \n", - "80 | model._deterministic_encoder._d_encoder.encoder.0.dropout | Dropout2d | 0 \n", - "81 | model._deterministic_encoder._d_encoder.encoder.1 | NPBlockRelu2d | 65 K \n", - "82 | model._deterministic_encoder._d_encoder.encoder.1.linear | Linear | 65 K \n", - "83 | model._deterministic_encoder._d_encoder.encoder.1.act | ReLU | 0 \n", - "84 | model._deterministic_encoder._d_encoder.encoder.1.dropout | Dropout2d | 0 \n", - "85 | model._deterministic_encoder._d_encoder.final | Linear | 65 K \n", - "86 | model._deterministic_encoder._self_attention | Attention | 2 M \n", - "87 | model._deterministic_encoder._self_attention._W_k | ModuleList | 524 K \n", - "88 | model._deterministic_encoder._self_attention._W_k.0 | AttnLinear | 65 K \n", - "89 | model._deterministic_encoder._self_attention._W_k.0.linear | Linear | 65 K \n", - "90 | model._deterministic_encoder._self_attention._W_k.1 | AttnLinear | 65 K \n", - "91 | model._deterministic_encoder._self_attention._W_k.1.linear | Linear | 65 K \n", - "92 | model._deterministic_encoder._self_attention._W_k.2 | AttnLinear | 65 K \n", - "93 | model._deterministic_encoder._self_attention._W_k.2.linear | Linear | 65 K \n", - "94 | model._deterministic_encoder._self_attention._W_k.3 | AttnLinear | 65 K \n", - "95 | model._deterministic_encoder._self_attention._W_k.3.linear | Linear | 65 K \n", - "96 | model._deterministic_encoder._self_attention._W_k.4 | AttnLinear | 65 K \n", - "97 | model._deterministic_encoder._self_attention._W_k.4.linear | Linear | 65 K \n", - "98 | model._deterministic_encoder._self_attention._W_k.5 | AttnLinear | 65 K \n", - "99 | model._deterministic_encoder._self_attention._W_k.5.linear | Linear | 65 K \n", - "100 | model._deterministic_encoder._self_attention._W_k.6 | AttnLinear | 65 K \n", - "101 | model._deterministic_encoder._self_attention._W_k.6.linear | Linear | 65 K \n", - "102 | model._deterministic_encoder._self_attention._W_k.7 | AttnLinear | 65 K \n", - "103 | model._deterministic_encoder._self_attention._W_k.7.linear | Linear | 65 K \n", - "104 | model._deterministic_encoder._self_attention._W_v | ModuleList | 524 K \n", - "105 | model._deterministic_encoder._self_attention._W_v.0 | AttnLinear | 65 K \n", - "106 | model._deterministic_encoder._self_attention._W_v.0.linear | Linear | 65 K \n", - "107 | model._deterministic_encoder._self_attention._W_v.1 | AttnLinear | 65 K \n", - "108 | model._deterministic_encoder._self_attention._W_v.1.linear | Linear | 65 K \n", - "109 | model._deterministic_encoder._self_attention._W_v.2 | AttnLinear | 65 K \n", - "110 | model._deterministic_encoder._self_attention._W_v.2.linear | Linear | 65 K \n", - "111 | model._deterministic_encoder._self_attention._W_v.3 | AttnLinear | 65 K \n", - "112 | model._deterministic_encoder._self_attention._W_v.3.linear | Linear | 65 K \n", - "113 | model._deterministic_encoder._self_attention._W_v.4 | AttnLinear | 65 K \n", - "114 | model._deterministic_encoder._self_attention._W_v.4.linear | Linear | 65 K \n", - "115 | model._deterministic_encoder._self_attention._W_v.5 | AttnLinear | 65 K \n", - "116 | model._deterministic_encoder._self_attention._W_v.5.linear | Linear | 65 K \n", - "117 | model._deterministic_encoder._self_attention._W_v.6 | AttnLinear | 65 K \n", - "118 | model._deterministic_encoder._self_attention._W_v.6.linear | Linear | 65 K \n", - "119 | model._deterministic_encoder._self_attention._W_v.7 | AttnLinear | 65 K \n", - "120 | model._deterministic_encoder._self_attention._W_v.7.linear | Linear | 65 K \n", - "121 | model._deterministic_encoder._self_attention._W_q | ModuleList | 524 K \n", - "122 | model._deterministic_encoder._self_attention._W_q.0 | AttnLinear | 65 K \n", - "123 | model._deterministic_encoder._self_attention._W_q.0.linear | Linear | 65 K \n", - "124 | model._deterministic_encoder._self_attention._W_q.1 | AttnLinear | 65 K \n", - "125 | model._deterministic_encoder._self_attention._W_q.1.linear | Linear | 65 K \n", - "126 | model._deterministic_encoder._self_attention._W_q.2 | AttnLinear | 65 K \n", - "127 | model._deterministic_encoder._self_attention._W_q.2.linear | Linear | 65 K \n", - "128 | model._deterministic_encoder._self_attention._W_q.3 | AttnLinear | 65 K \n", - "129 | model._deterministic_encoder._self_attention._W_q.3.linear | Linear | 65 K \n", - "130 | model._deterministic_encoder._self_attention._W_q.4 | AttnLinear | 65 K \n", - "131 | model._deterministic_encoder._self_attention._W_q.4.linear | Linear | 65 K \n", - "132 | model._deterministic_encoder._self_attention._W_q.5 | AttnLinear | 65 K \n", - "133 | model._deterministic_encoder._self_attention._W_q.5.linear | Linear | 65 K \n", - "134 | model._deterministic_encoder._self_attention._W_q.6 | AttnLinear | 65 K \n", - "135 | model._deterministic_encoder._self_attention._W_q.6.linear | Linear | 65 K \n", - "136 | model._deterministic_encoder._self_attention._W_q.7 | AttnLinear | 65 K \n", - "137 | model._deterministic_encoder._self_attention._W_q.7.linear | Linear | 65 K \n", - "138 | model._deterministic_encoder._self_attention._W | AttnLinear | 524 K \n", - "139 | model._deterministic_encoder._self_attention._W.linear | Linear | 524 K \n", - "140 | model._deterministic_encoder._cross_attention | Attention | 2 M \n", - "141 | model._deterministic_encoder._cross_attention.batch_mlp_k | BatchMLP | 70 K \n", - "142 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial | NPBlockRelu2d | 4 K \n", - "143 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial.linear | Linear | 4 K \n", - "144 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial.act | ReLU | 0 \n", - "145 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial.dropout | Dropout2d | 0 \n", - "146 | model._deterministic_encoder._cross_attention.batch_mlp_k.encoder | Sequential | 0 \n", - "147 | model._deterministic_encoder._cross_attention.batch_mlp_k.final | Linear | 65 K \n", - "148 | model._deterministic_encoder._cross_attention.batch_mlp_q | BatchMLP | 70 K \n", - "149 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial | NPBlockRelu2d | 4 K \n", - "150 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial.linear | Linear | 4 K \n", - "151 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial.act | ReLU | 0 \n", - "152 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial.dropout | Dropout2d | 0 \n", - "153 | model._deterministic_encoder._cross_attention.batch_mlp_q.encoder | Sequential | 0 \n", - "154 | model._deterministic_encoder._cross_attention.batch_mlp_q.final | Linear | 65 K \n", - "155 | model._deterministic_encoder._cross_attention._W_k | ModuleList | 524 K \n", - "156 | model._deterministic_encoder._cross_attention._W_k.0 | AttnLinear | 65 K \n", - "157 | model._deterministic_encoder._cross_attention._W_k.0.linear | Linear | 65 K \n", - "158 | model._deterministic_encoder._cross_attention._W_k.1 | AttnLinear | 65 K \n", - "159 | model._deterministic_encoder._cross_attention._W_k.1.linear | Linear | 65 K \n", - "160 | model._deterministic_encoder._cross_attention._W_k.2 | AttnLinear | 65 K \n", - "161 | model._deterministic_encoder._cross_attention._W_k.2.linear | Linear | 65 K \n", - "162 | model._deterministic_encoder._cross_attention._W_k.3 | AttnLinear | 65 K \n", - "163 | model._deterministic_encoder._cross_attention._W_k.3.linear | Linear | 65 K \n", - "164 | model._deterministic_encoder._cross_attention._W_k.4 | AttnLinear | 65 K \n", - "165 | model._deterministic_encoder._cross_attention._W_k.4.linear | Linear | 65 K \n", - "166 | model._deterministic_encoder._cross_attention._W_k.5 | AttnLinear | 65 K \n", - "167 | model._deterministic_encoder._cross_attention._W_k.5.linear | Linear | 65 K \n", - "168 | model._deterministic_encoder._cross_attention._W_k.6 | AttnLinear | 65 K \n", - "169 | model._deterministic_encoder._cross_attention._W_k.6.linear | Linear | 65 K \n", - "170 | model._deterministic_encoder._cross_attention._W_k.7 | AttnLinear | 65 K \n", - "171 | model._deterministic_encoder._cross_attention._W_k.7.linear | Linear | 65 K \n", - "172 | model._deterministic_encoder._cross_attention._W_v | ModuleList | 524 K \n", - "173 | model._deterministic_encoder._cross_attention._W_v.0 | AttnLinear | 65 K \n", - "174 | model._deterministic_encoder._cross_attention._W_v.0.linear | Linear | 65 K \n", - "175 | model._deterministic_encoder._cross_attention._W_v.1 | AttnLinear | 65 K \n", - "176 | model._deterministic_encoder._cross_attention._W_v.1.linear | Linear | 65 K \n", - "177 | model._deterministic_encoder._cross_attention._W_v.2 | AttnLinear | 65 K \n", - "178 | model._deterministic_encoder._cross_attention._W_v.2.linear | Linear | 65 K \n", - "179 | model._deterministic_encoder._cross_attention._W_v.3 | AttnLinear | 65 K \n", - "180 | model._deterministic_encoder._cross_attention._W_v.3.linear | Linear | 65 K \n", - "181 | model._deterministic_encoder._cross_attention._W_v.4 | AttnLinear | 65 K \n", - "182 | model._deterministic_encoder._cross_attention._W_v.4.linear | Linear | 65 K \n", - "183 | model._deterministic_encoder._cross_attention._W_v.5 | AttnLinear | 65 K \n", - "184 | model._deterministic_encoder._cross_attention._W_v.5.linear | Linear | 65 K \n", - "185 | model._deterministic_encoder._cross_attention._W_v.6 | AttnLinear | 65 K \n", - "186 | model._deterministic_encoder._cross_attention._W_v.6.linear | Linear | 65 K \n", - "187 | model._deterministic_encoder._cross_attention._W_v.7 | AttnLinear | 65 K \n", - "188 | model._deterministic_encoder._cross_attention._W_v.7.linear | Linear | 65 K \n", - "189 | model._deterministic_encoder._cross_attention._W_q | ModuleList | 524 K \n", - "190 | model._deterministic_encoder._cross_attention._W_q.0 | AttnLinear | 65 K \n", - "191 | model._deterministic_encoder._cross_attention._W_q.0.linear | Linear | 65 K \n", - "192 | model._deterministic_encoder._cross_attention._W_q.1 | AttnLinear | 65 K \n", - "193 | model._deterministic_encoder._cross_attention._W_q.1.linear | Linear | 65 K \n", - "194 | model._deterministic_encoder._cross_attention._W_q.2 | AttnLinear | 65 K \n", - "195 | model._deterministic_encoder._cross_attention._W_q.2.linear | Linear | 65 K \n", - "196 | model._deterministic_encoder._cross_attention._W_q.3 | AttnLinear | 65 K \n", - "197 | model._deterministic_encoder._cross_attention._W_q.3.linear | Linear | 65 K \n", - "198 | model._deterministic_encoder._cross_attention._W_q.4 | AttnLinear | 65 K \n", - "199 | model._deterministic_encoder._cross_attention._W_q.4.linear | Linear | 65 K \n", - "200 | model._deterministic_encoder._cross_attention._W_q.5 | AttnLinear | 65 K \n", - "201 | model._deterministic_encoder._cross_attention._W_q.5.linear | Linear | 65 K \n", - "202 | model._deterministic_encoder._cross_attention._W_q.6 | AttnLinear | 65 K \n", - "203 | model._deterministic_encoder._cross_attention._W_q.6.linear | Linear | 65 K \n", - "204 | model._deterministic_encoder._cross_attention._W_q.7 | AttnLinear | 65 K \n", - "205 | model._deterministic_encoder._cross_attention._W_q.7.linear | Linear | 65 K \n", - "206 | model._deterministic_encoder._cross_attention._W | AttnLinear | 524 K \n", - "207 | model._deterministic_encoder._cross_attention._W.linear | Linear | 524 K \n", - "208 | model._decoder | Decoder | 1 M \n", - "209 | model._decoder._target_transform | Linear | 4 K \n", - "210 | model._decoder._decoder | BatchMLP | 1 M \n", - "211 | model._decoder._decoder.initial | NPBlockRelu2d | 262 K \n", - "212 | model._decoder._decoder.initial.linear | Linear | 262 K \n", - "213 | model._decoder._decoder.initial.act | ReLU | 0 \n", - "214 | model._decoder._decoder.initial.dropout | Dropout2d | 0 \n", - "215 | model._decoder._decoder.encoder | Sequential | 524 K \n", - "216 | model._decoder._decoder.encoder.0 | NPBlockRelu2d | 262 K \n", - "217 | model._decoder._decoder.encoder.0.linear | Linear | 262 K \n", - "218 | model._decoder._decoder.encoder.0.act | ReLU | 0 \n", - "219 | model._decoder._decoder.encoder.0.dropout | Dropout2d | 0 \n", - "220 | model._decoder._decoder.encoder.1 | NPBlockRelu2d | 262 K \n", - "221 | model._decoder._decoder.encoder.1.linear | Linear | 262 K \n", - "222 | model._decoder._decoder.encoder.1.act | ReLU | 0 \n", - "223 | model._decoder._decoder.encoder.1.dropout | Dropout2d | 0 \n", - "224 | model._decoder._decoder.final | Linear | 262 K \n", - "225 | model._decoder._mean | Linear | 513 \n", - "226 | model._decoder._std | Linear | 513 \n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validation sanity check', layout=Layout(flex='2'), max=5.…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 0, {'val_loss': '0.4124463200569153', 'val/kl': '0.000867909868247807', 'val/std': '0.6997844576835632', 'val/mse': '0.24223445355892181'} {}\n", - "\r" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "e8d999e983e84f59bb2fa7a38f6d6be2", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=1.0, bar_style='info', layout=Layout(flex='2'), max=1.0), HTML(value='')), …" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 1826, {'val_loss': '-0.6180389523506165', 'val/kl': '0.0019512423314154148', 'val/std': '0.08328787237405777', 'val/mse': '0.005984470713883638'} {'train_loss': -0.4015297591686249, 'train/kl': 0.002748532220721245, 'train/std': 0.12619516253471375, 'train/mse': 0.015218577347695827}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 3653, {'val_loss': '-0.7278807163238525', 'val/kl': '0.0014059479581192136', 'val/std': '0.0711861178278923', 'val/mse': '0.004501875024288893'} {'train_loss': -0.6152340173721313, 'train/kl': 0.0023364636581391096, 'train/std': 0.07921499758958817, 'train/mse': 0.00786618236452341}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 5480, {'val_loss': '-0.6745252013206482', 'val/kl': '0.0015218108892440796', 'val/std': '0.07711585611104965', 'val/mse': '0.0046296496875584126'} {'train_loss': -0.6714304685592651, 'train/kl': 0.0019991567824035883, 'train/std': 0.07271461933851242, 'train/mse': 0.006999595556408167}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 7307, {'val_loss': '-0.724380612373352', 'val/kl': '0.0008795351022854447', 'val/std': '0.06039521470665932', 'val/mse': '0.004034927114844322'} {'train_loss': -0.7004716396331787, 'train/kl': 0.0017743543721735477, 'train/std': 0.06857810914516449, 'train/mse': 0.006414421368390322}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOydd3hUxfrHP5PeKQk1QEIVUCxUlVzkci0oFkS9yI0oKsRy4VrwKsq9VlBQ/KFysYCgolEUVEBFUFFAFBFQAek1oYSShIQkm2Szu/P7Y/Zkz+6eLQGSbJL9Ps8+yZ4zOztndma+85Z5XyGlJIgggggiiIaLkNpuQBBBBBFEELWLIBEEEUQQQTRwBIkgiCCCCKKBI0gEQQQRRBANHEEiCCKIIIJo4AgSQRBBBBFEA0eQCOohhBBSCNGpttsRRBBB1A0EiSCIGoMQ4m9CiB1CCJMQ4gchRIqXss8JIbYIISxCiKdd7j0hhCjWvUqFEDYhRJJBPZFCiDlCiCwhRJEQ4g8hxNX+tksI8XchxM/2eytdPpckhPhJCJEnhCgQQqwVQvT30QezhBA77e0d5XLvDiHERiHEKSHEISHEi0KIMC91+VVeCNFZCFEmhPjAR9seEkIctdc3VwgR6XL/ASHEfiFEiRBiuxCii4d6/mr/7QrsffO5ECJZdz/SXv8p+/c97KNd3n6fKtUVhDGCRBBEjcC+SH8G/BdoCmwAPvbykT3Ao8BXrjeklM9LKeO0FzAVWCmlzDWoJww4CFwGNAL+A3wihEj1s135wCvAFIO6i4G7gGZAE3s7vvC2eAObgPuB3wzuxQAPAklAP+BvwCNe6vK3/ExgvZd6EEJcBUyw15ECdACe0d0fDdwNDAHigGsBo/4G2AZcJaVsDLQGdgNv6O4/DXS2f89fgUeFEIM9tMvX7+N3XUF4gZQy+KpnL0ACnez/NwLmASeALNRCGGK/1wlYBRSiJvXH9usCmA4cB04BW4DzzrBNGcDPuvexQCnQ1cfnPgCe9nJfAPuAO6rQls3ATVVpFzAaRTae6gwBrrP3fXM/2rAGGOWjzMPAF1V4LrfywK3AJ6gF8wMvn/0QeF73/m/AUd2zHQT+dhq/eyTwArBNd+0IcKXu/XPA/NMZN1WpK/jy/ApKBPUfM1Bk0AG1K74duNN+7zngG9Ruto29LMCVwACgi/2zfwfyAIQQE+wiv+HLSzvORe2GAZBSlgB77dfPBH8BmgOf+lNYCNEC9Vxbz1a7hBCbgTJgCfC2lPK4v5/1gQG6dla5vBAiAXgWRRC+4NQP9v9bCCESUWOjDXCeEOKgXT30jBAixP497ey/fzvdd7ezj4dSlJTyov16E6CVwXedq/tsgRAizahd+t/Hn7qC8A/eRNgg6jiEEKGoHeGFUsoioEgI8TIwEpgDVKBE6tZSykOoXSr26/FAV+BXKeV2rU4p5RSM1SS+EIeSSvQotH/PmeAOYKGUsthXQSFEOJAJvCel3HG22iWlPF8IEQXcCET4+zkfbb0L6I2SRE63/HPAHCnlISGEryriUM+tQfs/HqXeAbVB6AE0Rm0gDgGzpZTZ9muV0K4JIZoCYwB9f+vr1/6P131WX5e338dnXUH4h6BEUL+RBISjVEIasgDNcPcoSrXyqxBiq30xQUr5PfA/lG75uN3AmeDvl9p3g5XGXPvlYsC1jgSgqKoPpfueGOAW4D0/yoYA7wNmYKzu1llpl5SyTEr5ETBBCHGB/Tv1Bu12PqrQt3UoSp1ytbTbPYQQ6bq6vvaj/IXA5SgVnz9w7Qft/yLUrh7gRSllgZTyAPAWcI2vSqWU+ajfZ7HddqKNB9fv8tTf3n6fqtYVhAcEiaB+IxfHrl9DO+AwgJTyqJRyjJSyNXAP8Lqwu51KKV+TUvYCuqNUKf8GQ4+dYtdFX0qZLZ2NuaBUFhdojRBCxAIdqZrqwxU3ooy5K70VEmo7PAdogbINVOhun+12haPUcOj7wL5D9gm7oXM2cJ2Ucot2XUqZqavral/lgYFAKpAthDiKUs/cJIQwMlKDSz/Y/z8mpcwDdqIIVB+quCphi8NQ6rsEKeVJIMfguzz1t8ff5zTqCsITattIEXyd/RfOxuIPgM9R4nIKSkQfbb93C9DG/v+5qJ1fB6APygslHGWcWwY8c4ZtaoYS228ColAeNr94KR9uL/chMMn+f6hLmW+AZ/347jeBX4C4qrYLCLVfvxdYbf8/3H7vYiANpQ6KBh5D7UZbe2lLhL2On1AqkygcxvtBKFvMAD/71GN5lEdRS91rGrAQaOahrsHAURTxNwa+B6bo7s8DvrSPozb2cXS3h7qGAeegNprNUMbq33T3p6CcFJqg1I85wODTGTdVqSv48jKWarsBwVc1/KjORNAERQYnUJ4fT+oWnhdR0kExygCXYb/+N5RnTTFKqsg0WkRPo12X2xeQUtQuPlV3703gTd37d+3PoX+N0t1PBizac3r5zhT7Z8vsz6O90v1s1yiDdrxrv3cZyjhZhJJMVhktyi7tWWlQ30D7vR/sz6Rv59de6vK7PD68huxlHgaOoTzF3gEidfcSgPn2Z9XGkbDfa2f/7nb29+OA/UAJilzmAym6uiKBufbvOQY87NKOYuAvfv4+XusKvvx7aT9kEEEEEUQQDRRBG0EQQQQRRANHkAiCCCKIIBo4gkQQRBBBBNHAESSCIIIIIogGjiARBBFEEEE0cNS5EBNJSUkyNTW1tptxxqioAG8OW2FhEBKk6SCCqHFICVpEjooKCA+v3facLWzcuDFXStnM6F6dI4LU1FQ2bNhQ2804Y+TkQHm55/tNmkCjRjXXniCCCEKhoAAaN1aEkJ0NbdvWj02ZECLL07168Hh1Ezab9/sWS820I4gggnBGqT2yksWiyMBqrd321ASCRFBLCBLB2UPwTGQQZxNms1r8tTnYEOZikAhqCUEiODuoqIBinwGogwjCP1itamNhNquxpV2r7wgSQS1ASt+72CAR+IeiIu+2liCCqAq0Rd9sblgSQZ0zFtcH+JIGwKGbDA2t/vbUVUippIH6YMgLonaheQppRFBR4fg/KBGcIYQQg4UQO4UQe4QQEwzupwghVgghNgshVgoh2lRnewIF/hABNIydyJmgoED1pcXSMCZrENUHTarU5pxeNdQQ5mG1EYE9TeJM4GpUjPMRQojuLsWmAfOklOejcqu+UF3tCST4a9xsCAPwdJGXB4W6BIVlZbXXlroGfzciDQkmk/prJBE0hHlYnRJBX2CPlHKflNKMikl+g0uZ7qgEGKBiq7ver5cISgRnBotF2Qb0CNoJ/MfJk0Hi1MNqdYwfbfHX2/Fcpc1Nmzaxbt06bPWIUauTCJJRCSw0HMKRK1fDJlQ2I1BpB+OFEInV2KaAQJAIzgxms/u10tKgeshfmExKogq63SpYrd7VQDab85x94YUXuPjiixk5ciQFBQU108hqRm2b2R4BLhNC/I7K9nQYcJvOQogMIcQGIcSGEydO1HQbzzpciUATS10RJAJjGBFBRQUcORLc6fqCRpgVFVBSUtutCQxYLGpO6tVBRmU0dOzYEYAPP/yQX375pQZaWP2oTq+hw0Bb3fs29muVkFIewS4RCCHiUInF3ShWSjkLmAXQu3fvOr+PcSWCw4ehTRuIjna+XlFBEAbwpAayWtVCFxVVs+2pS9BvOkwmiIurvbYECoxcRl2RlwctWyrPosmTJ1NaWspPP/1EWFj9cLyszqdYD3QWQrRHEcCtwD/0BYQQSUC+lNIGPI7KPVrv4UoEJSVw6BB07ux8PajqMIaRRKAhKEV5RmmpsxRQWuocYK2uwGazEXIWfYa1MVNe7lltW14OubnQzB6y7f/+7//O2vcHAqpNNSSltABjgeXAduATKeVWIcSzQojr7cUGAjuFELuAFsDk6mpPIEE/2Gw2pc7Iy3PEONHQUOKc+IOyMseOzVufBKUoYxQWwrFjzmNPyrqpSnvjjTe48MILWbRo0VmpTxtPnlS0GsrLITs7m+J6eJS9Wm0EUsqlUsouUsqOUsrJ9mtPSimX2P9fKKXsbC8zWkrZIHw/9JNRP/jy8tzLBne4ChUVytvFmzQAwf7yBE/qNF+LXyBi8eLFbNq0iVGjRrFt2zaf5ZcuXcqDDz5ImQfW8/cEsdUKV155JfHx8WzduhWg3ngO1baxuEFCP3b0UkBurnvZ4MKmYLGovtKfHTCCq4dHEAqeCNRVCq0L+OKLLwAoLCxk9+7dPsu//PLLvPrqq7zzzjuG9/2VuqWE6OhooqKiKC0tJTk5mZ49e/rd7kBG/bB01DF4kgjKylTIBL0BL0gECprKx5/zAhUVEBlZve2pS5DS8ziqi6rHyMhIFi9ezKFDh+jRo4fP8mPHjmXPnj0MGDDA8H5V5tj69b8TGirJy8vjyJEjHqWMuoYgEdQCPBEBKPVQkAjcUZV+sFiCRKCHN7uJdnCqrhiMpZQIIbj++ut9F7bjxhtv5MYbbzS8p0Ub9RdWK4SFCRITE8nKyqJVq1b+fziAEVQN1QI8qYZA6cH1CBKBQlWMwME+c4avvqsrqrQDBw7Qvn17Jk6c6LOs1WplwoQJrF27Fullpa+qRKSVF0LQrl07wutJHssgEdQCtIlnNrvrbsvKnCducFGr+q4t6DnkDF8G9rpCBEuXLiUrK4vdu3eTk5PD8uXL+e233wzLrl69mqlTp5Keng5ASUkJb731Fq+//rpTuarMr/nz36Z37/OYOXPmaT9DoCJIBLUAbVHLzze+r/dOCxJB1Rf2YJ85o75IBPfeey9r167l8ccfZ/ny5QwePJhXX33VsGy7du0YP34848aNQwhBeXk59957L0888YRTuarEqNq7dwfbt2+lyB7o6v333+fmm2/m66+/Pu1nChQEbQQ1DH0wK09EUFSkktdr5Rt6XoKqLuxBicAZ9YUIQkJCuPjiiwE4deoUV1xxBeeee65h2Y4dOzJt2rTK940aNWL06NE0bdq00s5gtcKpU/5//7hx/yU9/TY6dUoCYMuWLXz66af07NmTq6+++vQfLAAQJIIahl4t5GkQukbWtFgaNhFUdWHXokkGDcZqI1FfiECPyy67jMsuu8zv8qGhocyePdvp2qlTVVM5JiQ0omXLC2neXL2/9dZb6dWrF7169fK/kgBFUDVUw9AmndHhMQ3Fxc6Ts6GrOk7n+Y8fr5uukWcbvuwDUDeIYN++fYwePZrp06f7LFtQUMDSpUvZsWOHxzJSum+4/IG+r3r27Mnw4cPp1KlT1SsKMASJoIahDSRvg1BLwaihoRPB6ah6rFaVwayho74QwYEDB5gzZw5Llixxul5uoOT/448/GDJkCKNHj3a6npuby44dOygpKaGszL/n1o4JmM1mHntsNNOn188oOEEiqGFog8/X4q53K/VnMtdnnO7OPpisxr8+qAtE0KVLF2bNmsW//vUvQNkIoqKiaKZFgdMhKiqKK664gksuucTp+i233EK3bt1Yt26d36E1tJPsx44d5pNP5vDBB2/p7hWSmZnJRx99dHoPFUAI2ghqGP6mv9NP4HpyePG0cCaB94JGY7WJ2L59MxMmjObZZ2dywQV93MrUBSJo06YNY8aMqXwfFxeH2WxGSonVaiVUZ0S7+OKL+eabb9zqSE1NpbM9xK+30Bp6+1JhIbRoATExcTz11GvExMRWHsDLy8vjtttuIyUlhREjRpydB60lBImghqFNOl+Lm37xt1rVhI6IqL52BSr8UYt5OhmrhVaoJyHjqwzNULxo0Qds3ryeBx4YwcqVe9zK1QUicEVISAglJSVERUUh/DwWrcUaMptVEiNPOHlS5R4Ah0E5MbEZo0aNA7TTxdC8eXOGDx9OmzZtzuhZAgENdIrUHjQC+P77TObPn0hubjZJSe0YPnwyaWnpleVcRfqysiARGKGsTNlbDDQEgJr0DZUIzGa1iA0bdjvHjh1h0KAhhuXqAhFs2rSJ7OxsevToQWpqKqACwBmhtLTUK0H4CrSXn6+IoKJCjT+z2dkDTSOCuLg45s+ffzqPE3AI2ghqGDYbLFqUyaxZGeTmZgGS3NwsZs/OYM2azMpyRkTQEOGLCA4d8m4UbsjqIc22dM455/HKKx9w/fXG6ou6QARz587l+uuv9ysHwWWXXUZcXJzHU8e+7ANFRY5ot6DmYlbWXlav/obs7H310hstSAQ1DKsVXnppImaz82g0m018/LEjhorF4rwINlQi8DbpTCYVuruw0LM/eEM2tGubiQMH9nDixDGPsfPrAhF069aNIUOG0KVLl8prkyZNYvDgwfz6669OZQsLCzGZTCQmJjpdX7BgAV27duW55x73+D2aFGUy6T2GYOnSBdxxx1VkZr7ptLkwmUxkZ2dTWhfjeesQJIIahs0GOTnZhvfy8pyv66UCLbl2Q4MniaCoCDQ3cYvFcyL2hthnGjQSTU8fRN++LVm27DM2bvzZrVxdIIJ7772XL7/8kmuuuaby2u+//87y5cvJznaeNzt37qSwsJC2bds6XS8vL2fnzp0cOWI8/8CxcXAlglat2tK//9/o1Kmb00G0wYMHk5KSwrp16878IWsRDVR7Wnuw2aBly3bk5GS53UtMbOf0vqwMYmMd761WqCfBDv2GERFYLLBtm7MUUFhonIi9IROBtsA3bdqMI0cO8s9/3kK/fpcxY8ZKEhIceu+6QARGePTRRxk9erRhcpiEhAS3a0OGDGHNmm3ExDR3u1dRoeaWtvkqKXHOZTx0aDpDhyobntWqzvnEx0NycjKtW7emoo4PtGqVCIQQg4UQO4UQe4QQEwzutxNC/CCE+F0IsVkIcY1RPfUJViuMHTuZiIgYp+sRETEMH+58WMXVTtAQD5YZPXNxsbsqqKDAWD3kT4iF+gptgf/ii41s3HiC9u270KlTdw4dgp07HRKDPv5VoMJkMrmFk+7Xrx9XX301LVq08KuOxo2b0LZtN5o0SXS7p8X98iQRuEI7X/DRRx9x+PBhrrjiCr/aEKioNiIQQoQCM4Grge7ACCFEd5di/0Eltb8IuBV4nXoOmw2uuCKdMWNmkZDgcHUZM2aWk9cQqIG4aFEmaWmpdOgQQvfuqWRmZrpWWa9hZCMwyh1eVATbtxtP2oZOBABNmybx/fc7GT/+dcrL1UJ3/Lhx2UBE9+7dCQsL48CBA17Lfffdd1x++eWGUUlNJuPn1J9C90QEVpeBaLHUrxAm1SkR9AX2SCn3SSnNwHzgBpcyEtBkuEaAF+/eug+bzXFA6vzzr+Kee+ZW3ps5cyTjxqU6eQ4tW5bJE09kcPhwFlJKDh7MIiMjo8GQgac8BJ6C9Z065by4aWioBmOjRe/oUcf/+iRIgU4EFosFm83mpPLZtWsXb7zxBsuXL6+8tm3bNlasWMGuXbucPi8lHD5cwpQpjzF58iNO98rLHTYmTQrXS0lmM9x660C6do12srEEicA/JAMHde8P2a/p8TRwmxDiELAUGGdUkRAiQwixQQix4cSJE9XR1hqBPrzEypVzeeml63R33d1I3313IqWlzt5FJpPJrwxN9QF6tZDWd65xmFxh5LzRECUCbdPx3XdfMHBgJ6ZOfZx9++Do0SKefvovPPBARwoLZWUfBzoRHDp0CLPZTBMtPjvw66+/cv/99/Pee+9VXrvllltYtmwZGRkZTp8vKgKbLYS33nqRefP+53SvvNyRJMpshj17fuX998dz7Ng+QI2fkpIiysvLiI52qHQtFli2bBm9evXi0UcfrY7HrjHUtrF4BPCulPJlIcQlwPtCiPOklE7DUko5C5gF0Lt37wDXZnqGPrxEWJjx6TDNjTQtLZ3cXGPvBlcvifoKPRGcOqX6LyrK+6IVJAIFrY9ycg6SlbWXw4fzOX4coqLiOHRoKyUlJzl58ggFBckkJQU+EQBuaSE7derEqFGjnDyJWrVqZZhHuKgIIiOjeOyxKcTHN8JmsxESovbBegOx2Qxff/0KP//8EWFhEYwY8QIACxf+DpiIiHCcLLNYoKysjN9++43WrVuf5aetWVQnERwG9P5bbezX9LgbGAwgpVwrhIgCkgADAb/uQx9e4pprHuT99x9GacecobmRJia2sx86c0a7du3crtVH6BcnkwlyclTcF28IEoGC1nc33XQHl176Nw4ejAJUrt3HH19OYmJbGjVqwcmT1BkicMXFF19cmajGGywWNQaEENx772Nu9zUiKCpSRDBkyHhCQ8MZNGgMFksFYWHhbN8uSE6OrQw9odU7YMAA1q1bV+eJoDpVQ+uBzkKI9kKICJQxeIlLmWzgbwBCiG5AFFB3dT8+oE02bWFKSjJe0DU30r//fRIhIc4ZaWJiYpg8uX6GwnWF3j5QWqr67dAh359x9bZqiJ5D2liLiYmlY8dziI1NqbzXsWMfGjduiRCiMhx6IBPB7t27GTRoEA899JDXcmPHjuWf//ynm8Ts6zCmNl40z6EOHVSimYce6sTGjYsBNX5ycpw/Z7FA06ZN6du3b52PN1RtRCCltABjgeXAdpR30FYhxLNCiOvtxcYDY4QQm4CPgFHS1UesHkFTDWl/hwyZDDi7kYaGOtxIk5O7YrOpwkIIkpNTeOONWZUJues79ItTVU5WB6UC977zZNjU+iWQiSAnJ4cffviBDRs2uN0zmUysX7+eHTt2MHfuXLfk9OA8dnbs2MIPPywlL8+x39SIQF8uMlLNy+Lik5SVFTNlytW89tpdTvXWJ3fuarURSCmXoozA+mtP6v7fBvSvzjYEEvTG4jffvIsffywCZhEaOgGr9TDQjsaNHcHnzOYyWrZMITo6ku+/3wn4Vo3UJ+gXp6qc4C8thcaNna81VCL43/8mc+LEKfr1+xdNmypfjVOnclm0aDJms4nRo9/Cag1sD5gePXrw7bffGgaZmzBhAjNmzOCFF15g9erVbNiwwU11ql/gp0x5lFWrljFnzpeVQfg0IvjzzxWsXj2PK6+8n/T0aYwaNYPQ0DByc7PZtGkZTZu2ccofbrGAlJLJkyeTl5fHyy+/XGl3qGuom62uo9Abi/PzD2Oz9QTSue66g8ybZyMm5gB5eemVIXK7dk1j/PgPiImJ4+67r3WqoyFA775Xld2XUVCxhuZCqhHBwoXvMG/ei5SVOVytwsMj+frrV1i16l0slopKHXqgokmTJlx++eX07+++Z+zZsyfnnnsu8fHx9O7dm3vvvRdQz19Q4D52zj+/DwMGXEV8fCNAzSft/ooVs/jxx3ls3vwtUVGxhIaqfXJcXCL//veX3H23c5wh5ZklmDZtGq+88goFdTglXm17DTUo6CWCu+9+nZdfTuDgQejYUR1v790bVq+GtWvhpptU2UOH9rF162/s3Rtd+dmGAq2/qhpwz6h8Q+o3cPTdAw88zaZNB2na1KHDjo6O5447XqN58/YAAU8E3jBq1ChGjRrldr2kRBGB65mThx9+1um93p50663P07JlZy677A6nMlFRsfTsqaQHs1l5rmmwWGDixImEhIQQVofjndfdltdB2GwO/+5mzTqSm6uu//nnk0yf/gI2mwVIYeXKybRoAR98MJ7CwuNERUXTp88AoGFJBNpiVtXAjkblG1K/geN5b7zxNtq2dSfCwYPHOZVVag7jBD+1jdWrV/PHH3+QlpZmGFfol19+4dVXX2XkyJGVrqTaATFftg89EbRo0ZHhwycBkJubzbx5DxIdncB9971bWcZVsrRY4N///neVnynQEFQN1SCsVsfOa8cOtWAlJGSyYsWLdhIAyCI3907efPMuCguPAZKyslI2bPiRRYsyG9TOVpvE/uaX1WCxuJ8wDmRjaHVAe97yct/SkDYmA3VsLV68mAceeIAVK1YY3l++fDnz589n6VJljlT+/Z7rk1Jitq/omqeQK4QIYf36z9m8eTmHDm3j22/fZNeun90kp0Dts6oiSAQ1CJvNsVN7992VAJSW/huLxTXDeAVWq/PWo7TUxLRpExvUzlazERjt8NesyWTcuFRGjAhxC80BsH+/M4FoklhDgc0GJ04c46uvlpCdvcXtfnHxSdasyWTVqvcqx1SgqofS0tIYO3YsvXv3NrwfHR1NTEwMd955J+A5JDnAl19+zDnnRPLYY3dTXAx//rkPq9XCqlXv8c03r5Ofrwx0jRq14MEHF/DggwvZtm0lc+fex+rV8wyJ4ODBg6xatapOH/QMEkENwmZTA8dmg0OHugFQUZHj41MOHDmS3aCIQL+r1WPNmkxmz/ae4U3FljGuryHAZoM//ljH+PE38NFHboF/OXnyCDNn3sannz5dubgFKhHceOONzJgxg7/+9a+G9x966CEOHDhAr17K/9+bY0B0dCwVFRWUlBSxdOmPPPhgR2bPzuDrr1/hnXf+SW7uAQDCwsLp1+9mzjmnP61bd2XQoDF06zbArY/MZnj55ZcZOHAgCxcuPBuPWysI2ghqEFpymd27QcoWhIcfJSqqGUVF/p2ha9myTYMjAqMDYh9/7DnDmz6Cq2tMIr3rX32HzQYJCY3p02cIqanup29btepC37430bbteVgsEhABSwS+EB4eTjNd0mpvRDBgwFXs2FGKzRbFggVrAVi16h1GjZrB/v0badPmPLfPnHfeIM47b5Bh3WYzdO3alf79+zu1oa4hSAQ1BL3HkJZZ78orW5KaOp3ZszPcFjYj3HefSrHXUBY0KY0ntacYTEYZ3vR91dAkgn79BvDoowMM9dhhYeE89JDawWr3A5UI1q5dS/v27WnRooXHhPR6eNPbq3hF4Rw+DJ07X8ydd86kR48raNWqs1vZP/9cwYEDv3PRRdeSnNwVcO8jmw1Gj7630m21riJIBDUEfXgJLRTwOedAnz5qB/vOO2MxmYz9kENCQnnxxfe46SZHhqT6TgRaGGBXaQBUaA6jGEyxsU3drplMKpMUNCzPIZtNGUz9MWYGso0gPz+fSy+9lLi4OE55ij+uQ0WFf7agggJ1Wv/KK+/3WGbVqvdZsyYPkymEK69sTFxcIhUV7ikCzWaow56jQNBGUGPQE4EW32Xnzs8pLDxOWlo6zz77M/HxSQjh/JNERMRw333v8de/OlQe9cVTwRu8nSEYPnwyoaHuE7KsrIi5c+93MiJ/9jbzrkoAACAASURBVJnDbtBQJAKNRHNzS9yyeulhs1nJydnFrl2b7O8Dr48KCgro3bs3vXr18ksa8EVmUkr++c9bmTDhcr744iU+/PAx1q1byN696zGbnb0SoqMzgC/44osI7ruvFZs3LzckGk1qrcvRcYJEUEPQq4Y0Ivjqqwls27YSgOTkbsyadYL7759nDxAmiIxMqcxcVlBgw2avpCHsbLU5ZSQRpKWlEx3tnpPWYjHz7bdvOhmRX3ghg0WLFBk0hH4Dx1gbN+5aRo6MYPv21YblNm/+hocfPoe33nqg8lqg9VGHDh1Yv349K1eu9Ku8LyIQQrBmzTf8+ecKvvlmJl988SKvvHIL//lPX1avnseJE7BggdqAhIdfCkBcXH8SEpoTF9fU8Du2bNlGkyZNuOiii6r6eAGDOi7Q1B0YSQSRkWWV8V9AecN8/PFESkqygXYkJqq4Q2PGJFFcnMdTT73GqFHjAm6yVgc8eQxpKC724ADuEta7vFy53Q4dmh5wu93qgjY+TKYSrFZL5QLmitTUnoSGhnP8eDZ3330dF1zQlxde+G8NtvTswx/11sMPv0d5eSQFBUfJzz9EdvYWtm5dQe/eN7BwIaxYATExDq+z2NiLmDbtmNN3ROjSiURExFFQUEBsbOxZfpqaQ5AIagj6U7IlJeoE59y5WWgxqtasyWTWrDFUVGjiaRZHjmSwZo2jjkJ7xuyGTASqn0ZjlMfBE44cUUbkhtBv4Oi7//u/X8nLKyMszF2NBtC4cQuefvpHdu9ey7x5D2GzWQOuj6SUfqmENPgiAqsVuna9zkm9o/8OzX63fz+VMb/y8pxPXbt+R1JSMseOnSAxsQl1FUEiqCFok1OLSxUXB/pAhR9/PFFHAhpMzJ8/kZdf3kFERAy9e6vQuIE2WasD2kTV2wi08wMVFZ6OjQqMCKJlSxWNsqFIBHovoIiIKLf7WVnQrJna9Xbq1I+kpFT6929P27btA66PrrrqKnbu3MmCBQvo27ev2/3SUtAHJfVFBCdPuuv49USjZcLdtYvKEDBlZWrzFhfn+E59dNvQ0FAaN06q0w4cPolAKOvlBUBroBT4U0pZLzOIVSe0CaYdadc8WTR4c4lMSEgC1O44Lq5hEIFmuNRPbKPzAw6k0K3bNezZM5eKCocYoYztKr9DQ+g3cBgvjZwK1q6F115TC9n990OPHkoy6NnzBiIiAo8s9+7dS3Z2No1d44rboTkSRUc7Dmt6Q34+7Nq1lj///A4pJb1730BKygWA+mxenirnmho9N9dBBIcOQZMmzsHn6vrY8mgsFkJ0FELMAvYAU1D5he8HvhNC/CKEuFO4urgE4RFanCHNPnDkyI+MGBGCxT5bPWUrS0hwXNfUJHV90PkDm81dLeSJLBUOUFz8OrfdNqfS8yompjFjxsxi4MD0yjobAsxm2L17G//972VkZjqSqpeXQ6bdiaqgAF54QalAwD1pUqBgx44d7N69mw4dOrjdk1Lt1rU55SlukAYtNPXatR+zYMGTLFz4FO+8M7ayrvx8z8+vSQegyuze7Xx/0qRnuOGGG9i5c6e/jxZQ8LaQTwI+ADpKKa+SUt4mpbxZSnk+cD3QCBhZE42sD9DCS2iDVmXklJWha4cPn0xERIzLp2Lo0WMy77wzjvvua8306Q8DgTdZqwPaJNfDE1kqldB+Dh6ExYvTeemlAjIzrcyZc5K0tPTKmEMNod9AEcHBg9ns2LGarKw/Kq9/+aXa8aakQP/+qo9//lnd+/zzD3jzzamUlFQx1Gs1Izw8nE6dOhmGeC4tVc9QWgqFhb6DEx49quZht24D6NixD+HhkXTpcinvvQcZGUod5AmapKChpMRZWv3xx1UsWbKkzsYb8qgaklKO8HLvOPCKr8qFEIOBV4FQ4G0p5RSX+9MBLYBIDNBcSmksA9ZxaGoOjQjS0q5m2DDHyNNCI3z88UTy8rKJjm6HyTSZ2Nh0srNnUVCQw44dGwE1+G02ZxtDfYNGnBp27ICrr57MBx+MQUrHYhUREUPTpsm0bfsiubkz2b8/hA0b4rnhBsdntQVC868PxFDLZwuaeuTcc/sxceIKIiKUAn3dOvjsM1Xm9tvV359+gt9+g/R0mDHjCY4ePcgttwynTZvU2ml8FaEFI5RS6f69oaLC4QXUt+8w+vYdVnlv3DgVjuS779R7IRx2hNatldFYLxFoKC9XeUQAHn74CR58cCwXXHDBGTxR7cEvY7EQ4lIgVV9eSjnPx2dCgZnAFcAhYL0QYok9PaVWx0O68uOAuuuI6wOuRJCYGO12rD0tLb2SEDZsgJdfhmPH4JprHqZTp35cdNHAyrJWa8MhgmPH4NlnITY23X5oZyKQTVJSCsOHO1J7/vADzJoF8+d/xJYtc/jPf9TM1oeasFrr/ilQb9DsA7GxTSrj4+zcCTNmqD4dNgy6d1f9EBurFrmcHBgyZBQhIaWEh7sbl2sLa9eu5bXXXuMvf/kL99/vfgK4KuHJDx40lgjNZsduf8cO9bdzZ4d0cP753olAsxsMGHA5TY29dOsE/DEWvw90BP4AtK6UgFciAPoCe6SU++z1zAduALZ5KD8CeMqPNtdJuKqGXI3FrtByEx87Bn363ECfPjc4eSVYLI7dSH2ElI6Ju2ePeq+CyN1GdPR5XHjhVP71r4+cPpOaqv13EVu3rmDy5CuYOPFbwBFqor7bCYwMxatWqb7829/g5pvVtdBQuPBCh1Rw//3P0qqVs398bWP37t3Mnz+fsLAwNyIoLvZf1Sels2rHarVw4sQBhBBUVHSs3P1rf3v1ciaCZcvcVUPgbMOq62pHf/ZGvYHusurnp5OBg7r3h4B+RgWFEClAe+D7Kn5HnYGrRPD55w/x66/reeaZNYblW7RQIurx4+pz4eGOTFJhYfV/QdNLBFkuYYWuvfZChg1zkMDixVNZsmQKJlMh0BaYDMRw6NDWyjKlpYoI6vqE9QWNCL7+egE7d+bQs+d1bN+uUlIOHOisFuvZUxHBxo2OzwXSuPrLX/5CZmYmbdu2dbtnP1LjF1xJIzt7M088oUJW33jjetQS50BqKthTG6B9tSeJQMP+/fv46qvVpKSkeAyXHcjwhwj+BFoC/gfOrzpuBRZKKQ2nqRAiA8gAaNfOk8EwsOFKBCUlOzlw4HeP5SMiFBkcPQrr1v3Jn3/+H82apdKjx5OEhdX/BU2fxEcjgttuUzv7wYMd5dasyeSTTyZis2kdkg3cQ7du/+Daax2GAk2NEEgLXXVAW9AXL57DunXLiYnpztGj7YmM1EtMCt27q78HD8LJkyXYbEeIiYmhTZtkAgHt27enffv2btddDbW+4Eoa8fFJurqScEWzZkoSADUGhVDeRnv3QnKyw21U78zw888/8tBDd5Kenl4nicCb++gXQoglQBKwTQixXAixRHv5Ufdh1PZMQxv7NSPcCnzk4R5SyllSyt5Syt51Mea3ZqS0WBx+z/36DeLaa73nOk22z8eNG3exatU7LFv2WoNxIdWrhjQi6NMHzjtvNZs2fcKJE+rixx/rSUCDiezsb+nZ81rHFTsRBGKEzbMJrc8GDLiJK68cS0nJuQB06eJuG4mPV4tcSQksWDCTQYO6MGfOKwGfya2qOaxdiSApqR0ffSR5771SKirUxlJ/KC0x0fF/aCg0barG43/+A2+84binlwg6duzGyJEjGTBgQNUaFyDwJhFMO8O61wOdhRDtUQRwK/AP10JCiK5AE2DtGX5fwMIoztCIEY9U2gFSUtROLsdF5mrTRontQpxHixYdSU4+t3Lw1fedrc0G336bydy5EykszEaIduzcOZklS6Zw6NCf9O17Ew89tNDj2QIVr8kBbadcn4lA23AAXH31GHr2hHfeUe+7dnUvHxqqDMbFxRAV1YF27ToQFxePzRYYYc5/+eUX9u/fT9++fenYsWPldU/xp1xRXq6ew+Gy7YyIiKjK3Nb9+sHKleqgmKudpE8f+PZbRbIHDjjXr+H88/ty3XW+zKaBC2/uo6vOpGIppUUIMRZYjnIfnSul3CqEeBbYIKXUpIpbgfmnYYOoMzAiAr2xuGlTiIxUoqbeDU6TCKzWLrzyyh6g4Rwq+/TTTGbMyKC8XG3lpczi7bczaNYslfDwSFq0UAuDp9wE0JJJky5nwoSlhIVFBHw6xrMB/ZjQ/tc8Ybp1M/5MfLwigu7db2b8+JuJiQmcfBdz5szh7bff5q233qokAin9+w1PnYLt251DQRhBiy10+eWqry680L3MHXfA3/8Od93lCFGhuZiazYo46rprsj9eQ8OAqUBz1MkdAUgppXscYBdIKZcCS12uPeny/ukqtLdOQiOCkhK1kIeE2Pjww7F06tSHwYPvJDJS3U9MdCaCNm3UX33uXW1nW9+JYOrUiZUkoMFsNpGTs5P77nuv0mV0+PDJBhneYoAX2Lr1WU6cyKJVq85Yre5nE+obHKeDrezYsZnS0mYcPNiGsDDQbaidkJCgJNGiIqVyiYkJHGmzT58+FBUV0aVLl8pr3tJQ6nHihO/zBZrraGiosp9Mn+65bHS0sg24xh0qL3dIEGazlR07/iQuLs5JgqkL8McT/UXgeillIyllgpQy3h8SCMIBbWJpgzIsrJAVK95g0aLnnXYsTZo4nw1o3VrtMI4elRw+vJd9+zYEpHfH2YbF4ogY6gqbzeqUqF6F6Z5VGTgsLq4pnTrNAu4gMnIxUjr2OhUVzkbo+gbtuQoK8hk3ridPPjkOKdUi58ktVJNMNSKAwBlbGRkZzJ8/n4EDB1Ze80ctZLUau3u64pg9snSzZv5JQE3swUULdIkE9QbjF154ngsvvJDXX3/dd2UBBn+I4JiUcnu1t6Qew/UMQUyMhaSkFDp16usSxdBZlI2MVIPUahU88sj1TJzYp0FIBCYTtG7t2TtMS1SvIS0tncaNWwFw5ZX/5LHH0klMhPLy8/j99/a6z6m/9VU95AjdXUZKyvnEx18JgEGYnkpoRJCfX8HIkeeRlpYa0GPLH4kgP98/MtP0/S1b+vfdGhHopQw9MfXufTHt27cnIaHu7ZO9eQ0Ns6uFNgghPhZCjNCu2a8H4Sc0/3/NYyg5uRkzZhxg3LhMt4Nleo8F0NRDmcABAO65J4VFizKx2fzLzVoXYTLB+PFGsZcccDUST5myiZkzD3Py5FFWrJjCP+xuCZs2OcoEepL2M4W2gLdu3ZaXXtpEhw73AWDggVkJbfyZTGEcObKXw4ezKCoqqeaW+of8/HxMJpNTCkh/JAJ/zhiUlMD8+ep/zVXUF7RNml4i0HswDRx4Ofv27eOpp+reuVhvEsF19lcCYAKu1F271svn6iUslqrvwi0WyM5WOxSLxTFAtQHVqJG7SNq4savBKRN1hELpwHNzs3n8cZV+MZB3bqcLLerokCHpjBgxC+Vn4I7ExDZO7xMSkti7dz0//DCbhQuf4vDhGUASW7YIRowQjBmTxBdfKHVSfScCzfVWiyzqj0RQXCx46qlVbNp0kujowMi0demllxIbG8sOu8XbX0OxP6EnPvhAzcuOHeHKK/1rj5FEoPdIstnqqKUY78bib4HlUko/tG31G8XFSueYmOgwEvkDk8k5V/Hvv2cCE/npp2y2bWvN2LGT6Np1lNNnQkPV5NSkh927J6KRgIayMpV+8f7706lvMJkcC1nbtiruoRAZSOnog/DwSG699QW3z8bENKJZs/ZIKfnss3853SsuzmPSpLtISIARI+pfv4GDCCwWNWaPH1e2gWQv58M0Ijh1Cjp06EtUVOCoHSMjI4mOjibOPun8kQa0aKTecOqUCrsRGgr33ee/h5S2gdMTgdms2hUZGTi2ldOBN4mgLbBACPGjEOJpIUQ/UZWccfUEmueB5ipWFegH5BdfZLJuXQagEqufPHmY5567k//8xz2YVhNdxruiImOj6ZEj2QEzYc8m9O6xr7/+HJBOo0YTCAtT1s74+CQyMuZUeg1p2LdvA6++egtmcyme0lhWVJiZNm1ivZUItIVo3ryZjB+v+iclxftCp6mztZ2tP8ldagqbNm3CZDJVhpjwZ/5pGwlv2LhRlTnvPO8k6QojiQAcmzarFR544AGioqKYNWuW/xUHALydI5gKTBVCxAOXA3cBbwohtgPLUNLCMU+fry/QxympygJiszl7FMycORGbzV1m/fDDN+nduz9DhzoWtiZNHKdpPfnJt27drl4SgT5BSlFRIwBatuzPU0953w7GxiZSVKQFhPG8X6mvBAqOvsvJOcypU2rx9KYWAmevoby8QzzzzPNER4fw7rv/q8aWnh78JQJfWL9e/e3Tp2rfb+Q1BKrvmjXTG+vLMVUlNGoAwKfXkJSySEr5uZTyHinlRaiENc3wHX20zkNKZ8NTVYigrMx5Z3L8uPHOXkrJtGkTna5FRTnimQwfPpmQEGejaWRkDI88Mjlgdm5nE3r1xgUXqOxR/fqp6OQ//fQRDz7YiRkz3A6os2vXT0RFqVUtxEt87tat29VbI7vWd7ffPpGLLvoP4N1QDM6qoZCQUD755A0+++wDAvF8pz+qIV/rb2kpbNmi7HC9elXt+z1JBCoqrur/KVOmYDKZeOCBB6pWeS3D33wEyUCKrvx6KeXL1daqAEFJifMBJE1s9icPgH5ALlqUiRAheIipZ+gzHx+vyCQtLZ09e2D5chWDv2nTZO65ZwpDh6bXy52t9kxffZXJ77+rZ160qB1xcZPZsWMNx47tdcpJDCrw3Ntv31N5qMw99pBCWFgEjzwyuTqbX6vQNgY2W2ylNOrqheYKvWqoceOWPPzwa/Ts2R2LRRIeXnua4Pz8fK655hqSk5P59NNP3fJXe4IvIvjjDzWPzznH96ljV+htBPpTxCaTqtNigWh90KI6BH9OFk8FhqPyCOjzEayuxnYFBDTdnx4VFVSeBPYEm02RCCgSeOKJDI+LExj7zOsTY19/fTrLl6cTFaUSj2sJMOorESxalMnzz2dgtapZXViYxZtv3onVqlaC0tJC1qzJdMrqZpzUXqDZC0JDo7nvvtmVKri6HA7ACHp34pISx9j15dIeFaWC0ZWXQ0WF4MYbx9GmjfodajPfRWFhIevWrSMlJQXwrBbKz1c7df2i7A3r1qm/vXt7L2cE/elik0nFadJQVqb6sa6OK38kgqHAOVJKP0M91Q+YTMaDzx8iKClxTMpp0yZSWup5dEZHxxjuUvVE0LQpJCWpmOjHjjnE+fqmGrJaVb9Nm+YeXkIjAYDS0iJmz84A4Ior0snLM1a7CQF9+0rWrYMxY+DSSx0SXV2dsJ6gdx19++0nOHHicSDeZwIkIdR4OnlSSQXarttsthEVVXsp8Fq1asXatWux2Qe5JyLIyVHP0KSJKuNNaigpUUl4hIBLLjm9djVurOITnTzpTATa9y5fvoK5c99i4MCBhlnVAhX+/NL7gHqcC8sYnnYW2oD0pkLV+xZ7CpUAkJycwvPPz3IyFGuIcskYGBmpomPNn/92vT1drD2Ptz7TYDab+OSTiXTtCi1bGp9CTkxsh31DWWl8r28eQ1qwM63vSkth1aoPMJuVXckXEejLnDql1BurV39D//49OXas9nxBoqKiuPjii7n00ksBYyIwm9Vc05qpnZvwhF9/Vb9/9+6+VWYaXEN3ezIYayrkAweyWbBgAb/++qt/XxAg8HayeIYQ4jWUE/sfQoi3hBCvaa+aa2LtwNOCUVGhJozrQNBQXu48aD2FSkhOTmHNmgOGJADuRGCz7QRg+/ZDlbaK+koE3sJL6JGbm01kJDz66GQiI50N6hERMQwfPrmSCPbvV5X7Q+R1CeXlaizqAxsOGzYdCCUmRvqVn1lvJzCbJTNmPMuff27iDX3w/VqGERFoRtuCAnVw01cC+zX2ZIBpaf5/r6sdQVPLfvqpCmynQVsvLrlkIPPnz2fs2LH+f0kAwJtEsAHYCCwBngN+tr/XXvUanoigtFTpJT15MLjGPn/kkclERxt7/XhDaKhzoLAOHdQIbNHiysr21Tci0HZVjzwymbAwz+ElNGiEMXRoOhMmzCIpKQUhBElJKYwZM4u0tHTatFGV7thRSGlpceXvWltE8OqrrxIWFsa1115LseZucgYoK1OebdqZleJi6NbtJgASEox1X8nJKhCdpuLUu5BarYLXX/+UJ56YwpNPPmn4+ZrA1q1bef755/nqq68A46ix+sByR454r+/QIdi2Tdk9+vb1XrZRI8f/rkQwZIgizh07YMoUxzjSxlXr1u0ZPnw4vU/HCFGL8LZfKAR+llIer6nGBAr8OVRjtEOxWh1GYg1Dh6YjJTz++HjKy48TGdmWf/3reY+SgB5RUY7v6dOnBz/9BI0bK1FZO80YKLHjzwY0Yhs6NJ1PPoG1a5XXUFxcU8rKirBYHJ3ualsZOTKdfv3S3eLMNGsWBpwAmrF583q6daui8/hZxqpVq7BarXz11Vfs2bOHC40C4FcBmneQIwWq438jQ3HLlo48vFIqlZmeCCwWaNasBffe+5hf3nHVhY0bNzJx4kRGjhzJ4MFD3OZjaamxM4cRpHQk6LnsMhVq2xsSEx1u43pSAOWO+9JL8OCDinyKilQ/1/U4Vt5+6tuA34UQu4UQ7wkhMoQQ59VUw2oT/vyYRu5sRUXGO81rrknn+uuPAjauuiqLq67yL8SB3ijdvLn6q+lDNYKoT/H19RJOUVEP4ABXXbWX2bNzueeeuZU7/lat3G0roaEqC5fr4icEdOoUZS/Tp3LnXFsSwfTp0+nevTvXXnstMb5WJB+Q0l0yPXEij3nzFEG69kWjRlSqysCh79Z2vXl5jjGt5W+w1ZJHwrnnnsuECRMYMmSI4Xw8eND/un7+WUkD8fEwfLjv8lq/REQoCcLVOSQhwTEftQxn2nw8fjyP999/n0WLFvnfwACAt5PFNwMIIVKBS+2ve4QQ7VDnCK6piQbWBvxldbPZ4WJnNnveobgGnPNHbwvOdoLERDMQQU5OBVKGOxGBLy+mugI9qe3evRc4n+zs1UB7Bg1KZ+DAdEJCoGdP488LobyrXH+Hrl3j2bNH7X5rmwhSUlLYunXrWamrvNz5OWw2+Oqr/7F/v9KT6A3FkZHQqZOzp5R2cLF1a/X+8GFHbu2wMBgzJoNFiz5l/fr1dPB1RPkso1evXvSyn/hyVbcWFSn1rL/48kv1d8QI37HCIiPVnI6KcsyryEh3wm3RQo2n48dVv2pj98iRg9x+++1ccMEFDB061P9G1jL8OVl8APgN+B34AzgO+HVqQggxWAixUwixRwgxwUOZvwshtgkhtgohPvS/6dUHf2MKaeXKy5VLmafNU1ZWFr/8oo5dNG7sv3+2/mxKRIQZyMVqDScvz1LvJYLoaKX/T05WiZ0bNVLeHtpOzBOMvGTKyzOBVBYuDOGOO1JZtCjzLLW4dqEPYVJcXMSYMTdw5Mh22re/GnCWCNq0MR53TZo44u1omfC0MXXiRD75+fn89NNP1dB6/+G6MdMbaX0hP1/lHYiMhP79PZfT1GDa4h8b65h/Rkl9XCUCrc+aNm3Grbemc9111/nfyACAx72pEOIJ4BJUOImdwC/A/4AM6emIrPPnQ4GZwBXAIWC9EGKJlHKbrkxn4HGgv5TypBDCxzSvGfgrEZSXq8Xr+HHvNoWdO7dw6pRSNjZq5D8R6CWCqKg4hNiBlElkZxfTpYuS5+sDEVRUqD7Ru0A2b96LggLo338woBb4mBjf+t3oaLWb1fplzZpMvv/+LkAxZ25uFo8/nkGTJnDHHTUbhfSrr75i7dq13HDDDXTs2JGTJ0+eVkpDm01JmPqd8okTR/n++yU0b96enj3ns3+/Myl6OkXbpImyG4SEqAVW88WPioJx455l6tSpdOtW82kXs7KyKCoqom3btlRUOCvqPSWjN4KWj+Lccz1naQMlSR4/7phzsbEOyd1I4vakGmrZMpm33vrA50G+QIM3ieB2oDUqwFwm8KGU8nd/SMCOvsAeKeU+KaUZmA/c4FJmDDBTSnkSIFAM01VRDZ044d17x2KB+Pg2hIenAmpCehuQekRFOYvyF1+sPBGKihpXtrGuE4GUyu6hz/eQl+eI36Id2qlK+G/9AvjxxxOxWp1FvLIyE08+OZGaxueff87kyZOZNWsWiYmJp71rLCpSRKDffCQlteCllz4jPX2a26nihATPm4+YGLXgtWypfoucHMeY6ty5O02a1E7u3UmTJtGjRw8+/vhjtzAvvsJM6/HHH+qvN5t8RITDLqAnAk0i8EYEms1Of5ajLs5Jj0QgpeyK2s1vAAYCnwshfhVCzBZC3OlH3cmA3qRzyH5Njy5AFyHET0KIX4QQg6vU+mqAZiTTo7BQGZtc/ZRdI4y6oqQENmyAuLgLCQ1VrhpVUQ2FhDjvgFsoLQnHj8N332WSlpZKq1YhpKamkplZN9UdFRVq4hzXbQHy86GoSM2mmBgboaG+JQE99ETgmslMw8GDvg+tnW1cc801PPvss9xzzz3ExcVVKaWhXkdtdNgxPj6BtLQb6dt3WCURaP2gD2vuirAwtdnQ2wn0C5k/gd6qAy1atKB79+40b97CqT3+etzOmgVPPgmbN6v33oggOtrRV0aqIX8kAlBjWUpJfn4hR48e9a+hAQKvZkspZT7wpRBiGdALGADcgwpJ/c5Z+v7OKKJpA6wWQvSQUjod1xJCZKDSdNGunX+HjU4XrvYBKdWJxbIyNVi8TSpXaIOkrEy9wsPV4KpKDJfYWIdLqkYEW7Zk8uWXGZXxdbKyssjIUCEX0tPrVtIVjUi1fi8t1VwgrUAYOTnraN++avEA9ETgKYx3mzbVO46MMGzYMIYNU1leT506RVXSe+Tmqt9fCM+LsyYlurqPaoegPEFLXrNhgyIC/RyYOvVxjh3bzZw5b9O4qlHazgCTJk1i0qRJVFQ4bBfgn1ooKwt++MHxPjlZhYn2BE0qiolxJh/kpwAAIABJREFUSAR6hw4jImjWTP0WeXkO43pFBURESDp3Vv1ktVq9RsINJHg7WXy9EGKKEOJHlIF4GpAIjAf8Sfd8GJXcRkMb+zU9DgFLpJQVUsr9wC4UMThBSjlLStlbStm7mbdf9CzAlQhycx2LVVXO/9hsjgMve/eqhSguzowQVScCDZ9+ehcAe/Y86hZkzWQyMXFizas7Tgf6lIOui5rjsF4kUEqzZs2rrG+NjXWo34YPd899HBkZwzPP1G4U0qqQQFmZ40S7p9Anv/22li+/fI8jR3Y6qYb03i+eEB7ubDDW78CXL/+czz77lMOHXaduzcDIRdsXVq5Ufzt2VM91/fXey2vSptZfrjBS5YaFqfMGUqo1AlS/hYSEkJTUnBYtWlBeW+LUacAbXY1CncR5FGgppfyLlHKClHKxlNIfu/16oLMQor0QIgK4FXVKWY9FKGkAIUQSSlW0r2qPcHahH3hSOp9YdD0s5g1anmKAL79Uapuioq1+2wc06IkgNPQokImUxscos7NrXt1xOigudqjZystVtNG0tFQ6dAhh2LBUVq5U/dW4cTQtWnSskn0AlEpN83ZMS0tnzJhZhIS0BASxsW355z9nMXx4zUtOK1asYP369VX2zdfGXXGx5zG4ePGHvPjiKP74Y5kTEfjTd+HhDtXQkSPORDB+/CTeeWc+rbUCNQzX+ehrM2Y2O0JJ3H03TJsGAwZ4/4ymAmra1PhwZkiI6suuXZ2vu6qHtLauX3+MI0eO1qmQ1N5sBMPsOQca2429lRBC3OurYimlBRgLLAe2A59IKbcKIZ4VQmgcvRzIE0JsA34A/l3bOZL1EsGJE86GKYvFu01Aj+NOZu9WAERFFRtKAwkJ0KqV8c4tJsZhMO7QIQkY6fE7q1ttBmpHqnShMGdOJu3apRISUjU7hbazLSmBhQtVmO7Dh7OQUnL8eBYffpgBZFaS4OnMp8aNHRM1LS0dm+0BwMYll/xCv37pNX6OwGKxcPnll9OvXz8AZs6cSefOnXntNe9hu6R0LP7ebFIXXNCXgQNvo2XLi7Ba1ViKiHDeSHhCWJhDIsjJcZY6rrnmZq6/fjhNqqITPQtIS0ujY8eO7Nrl2BeWlPg+8b9xoyKL1FTfSXk0aOPLm+TZrZu7a7KrwVhPWnXNYOyPAuu/QohB2hshxKO4e/8YQkq5VErZRUrZUUo52X7tSSnlEvv/Ukr5sJSyu5Syh5Ry/uk8xNmCXmVhtRqfXvRHPVRc7Hyo6aKLlG29X7+/uBGBEMqlNDLSeNJqBuM1azJZu/YDPOXjjYmJYfLk6ld35OerXeOMGZmMG5fBwYNqAdfsFHPmGJPBvHkO0ujXT/ny5+UZh+muqDABE4mLU89/ugfmkpIc/ycmqqFeVBRVK+G7y8vLGTRoEAMGDCAkJASTycSePXs4cOCA18+Zzf6FGx82bCRjx75PcrLa/mqLmj9EEBGhVCKNG6sFzNXOWRuL2s6dO9m3bx9hYY5dgD9qIc1d1N/AcpGR/oVoEUKV05fViCAnR/2t70RwPfC8EOIvQojJQD/8JIK6BovFcVIzJ8fYjdQf9ZDrRNKfKnZVDUVHOwaXp0kbG6vcID2RAMCsWbOq3VBcWurooxdfdF/ATSYTTz3lbqfIzMzk3nsdpHH4cBZPPJHBZ59legk5nc3+/d+dljSgIS7OIU2NGvUoAGazspzWtEQQGxvLihUrWGlXYN9+++1s27adZ555xuvn/FUza5sYV9dRf4hA25xocXWOH3f0z+HD2SxY8FFlu2sKu3btYuvWbTRu3KLymj+bsL171d8uXfz7nqpG+dDP3852a6ZGPtri/9hjo0lL68P27durVnktwp+TxbkoMpiJOldws6uqqL5ArxZasiSTceNSGTEihHHjUlmzRtPzq0iG2i7AFeXlDuORBi1kdaNG7kSgFzdDQ413v/Hxnt0gAVq2bF0j3kL6iehpAT9yJNttNzRhgjtplJaamDZtopeQ0+2oqDh6RkQQEuLQkWueM1pogtqI3Cqlw4EgKakF8fFdCQ/3njDAXyLYt28/JtMpDh9WK3hiotrl+7PbdSWCwkKHCmr9+h8ZO/YfvPnmm/415CyhSZMmdO7cDSEcS5QviaCsTBm7Q0OdYyp5QmgoVFWbqp+/3bqp8XXkiPpebeO4Z882fv99Ayd9xcUOIHjzGioSQpwSQpwC9qAMubcA2rV6B40IFi3K5LXXMuxuh5Lc3Cxmz85gzZpMiosVEXj6jQ8dcr+mhZf4/fc5TgMpNNRd/220g4uPV26QnnDTTe7J3M82pHTWHXtawFu3buekx1buf55JwyhMd2hoNDCZc8+9wNCLoyrQiDYqSv1gubmKAWpaIpBSUl6uFjOTyeF2eOyY9wOM/hCB1Wrliis6Mnp0Y3bvVg/WubP/h/C8EUHHjl25+uqbufhiL/EZqgn6jZlrng8j7N+vftd27fw7tNm5c9XtT67z1x4OiV9/dWgLnnvuDZYuXUePHj2qVnktwpuxOF5KmaB7RUkp47TrNdnImoI2IV96yT1VotlssqtnFIqL3ReT0lLjOChms5phoaG5TgPJSCw1IoKoKPjHP9zdIAFSUjoxcmSG8QOdRWhpJDUYLeBaaGg9EeTneyeNoUPT6dbNcdonKSmFCy+cDaTTtWuPM5IIwEEEM2deDZRTUhKK2VzzEsHixYtp2jSG8ePvIDcX8vJMTJ06gaee+pfHJEdaQnRvKC6GAwdO0apVComJbdm7V03pTp38UwuBY3EzIoIePXrx+usLuPfecf5Vdhawbt067rzzTubNe6/ymj/2AU0t5E98vJiYqievB3eC0dIOrF+vfiuTCbp3v4Dzz+9LvD/p4QIE3iSCVG8fFAptznaDahMaEeTkGO9g9blx9QnqNWS5n1sCIC6uOwDXXnubTyIIDTX2ZR4yRLlBxsWlAILIyBTGjv2AH37YTYcObkcvzjpcF86hQ9N5/PFphNlP3ujTbupj5JeWGpNGVFR0ZT4Bm01V3rv35cyYcYAmTZSaS3+683Sh7YoTE1ujHWPJz6/5fM+nTp2itLQUm82GzQZhYeG8+eZU3n9/JqdOWSkvV/p9vfrNH2mgoAByc5swb95+Xnopi+xsNYbat/e/77xJBBpqMs7+5s2beffdd/nxx9WV14yI4MQJeOQRWLZMvdeIwJ/wTb4O2XmCKxGcf75S5+7fr7QEmo2mrhmLvZ0sfkkoBd1iVEayE0AU0An4K/A34CnUobB6AW2xa9GiHUePuq/qiYnOO9uiIsdCk51tnL5SSigqUjOtffvkyoEUEmK84INaAF0nYny8coNs3DidyZPVRO/fX4nLNaHmMFo4W7VKxmKxEBYWzpo1Byqva54n2jNoeQP++9/7KS5WM+Xaa2+tvP766wvZsmUjUqrzh1lZWUAKu3Z9SVTUtWfUbu0098MPf8Yzz6jMUnl5NU8EI0aMpFevYVjtgyw8PJwnnphGfHwjrFYrx46FYrNBZKRk+vRJpKWlcf75f/VZb36++v1PnIB9+xyqES2csj8IDVXj0RMRlJeXs3//Ubp3T64k/urEZZddxuzZs0lIcKzoRk4a332ndPMLFsDAger5wT+JQO9RVhW4EkFEhEr0s2eP+g1OnYKdO5exadN6Roy4mj596kamMm+qoVuA/wLnoAzFP6JIYTQqGukgKeW3NdHImoBKwqH+v/NOdzWMlgNXD233dviw51R5JSWKYKKj1cKvzaPoaOeAcnoYSQqalKk3em7cuITp059m/fq1vh7vjGGkSmnXriMDB15Nq1ZtmTv3Fad7rkQ2dGg6W7YU0rt3GlFR0Xz66bukpSk30lat2lBYeJL77uvDiBGCPXsuATLZvfurs5Ily9VgnJtbc0Rgtaqxcfy4IDY2joQERyTNMWPGc+uto4mIiKhsz48/ruHJJ59k0KBBPr1kli37kueeu5H585/g1VeHs22bEiE0b5aqnGAPD3cmAr00csUV3bjgglSfrq5nC126dGH06NH06+cgQtdAczYbaNGxTSb48EPl7RQRoUJue4M2F08HRrYHTcVUUKA2h999t4Tp059k7dp1p/cltQBfsYa2AXUjbsEZQr/Q9e+fzqlTMH/+4+TlHaJJk9b84x9TSUtz9szRPIiMDMQaNNfRiooDHDxYQN++Sh/uTWzX1EP6xTQ2Vu3a9ETw/vuPcOzYbvLzDzBkSNXi8VQVRkTQpcu53HXXQ9x++5W88MK/ueuuB73WsWhRJlu3/kZZmZrVmhvphg0/8dln7yGlWg2lzAEyaN78lrPSdo1YW9oDo3jLHXG2YTL5n98C4P/ZO+/4pqv9/z9PkqZt2tIJdFHKRhCVIYgWtwiiiLgtyHVQF+r1iot6XVdw4XVy+VoHolbFWRd4VdSf4AYBUbiyC7Ts0ZbuJJ/fH6enn09Wm7RJF7wejz7SJJ8kJyfnnPd+vXv27Edycgp9+w5s1NL7/vslLFtWwLJlshtW167/BI6md2/5fHMFgaZJZSUlpRt2ew1lgfA/NxNOp27pKrp3I/76S1p2QsjrvqxTSU8+ufFMqcTEpo/L25yqeTt4ULrQRowYQ2xsAoMHD236B7UwQm/ntRMYfXoVFdCjxxAiImIAjT59TvAQAkuX5rNgQS57924lKSmDSy+d6XEN6O4iu72Qykr9ZG/MwrZaXQWBEFJ4OJ06EV1q6klUVx8kPT0zwG8bOHwdnL17H4XNFk1cXMNO1xdeeJznnnvYaxppfv5cL6+oYNeub5s2WDdERcGGDT/z0UdzgVcpLm45QaBcGvPmPcuKFT8yefJNHH+8rHbasmUDGzaspXfvo8jMlKd3UlIXfvmluNFgdmkpnHjidcTGHoPZbGHJktfZvFmaAr16yQMrADojD0GgaVKAVVbC229/i80m6kkPQ42PPvoIp9NM376nEhUV7ZVfSVkDY8fK/0tK5Pee7Lvwvh7NoSuzWnXho2CcN4ARI8Zz7rnjW2y+goEjgqAOShAo7WPGjKHU1FQCgn37jmfxYsk8OmSIFAIvvqizf6r0UsBFGKjm4ABxcWZ69RpY/1xjgsCb5hEZKQ+WhAR5e/HF8xg+3JMDJRTwdjC9+upz1NbW8MUXf5KW5pkZVFCQz+zZuRQV+YiiN4L9+xvnTgoPlxuzIeqPqCgID4/G4ZCcxC0lCBwOfVy//PIdn3/+PqNHX1D//Pz5z/Hqq8+Sm/sk1177D5fXNYQDB6RGHB/fk6ws6RAfPvxSrrxSzkXnzv63Q1UIC5NFaEJIl6fdLuMplZUwfLho0SyrW2+9lcLCQr79doNXQXDggC4ITjlFZkh9/z1cdVXjaaNxcc1v7Wq1urrOlGtICQL1m7dSu+cm4YggqINa6OXlMufb4ZCS4aKLdvPee0n1GQkXXpjPhx9Oqc90UVDppUoQ2O3w2GPwxx/y+aysrHo+F2jcfPUmCJRfMylJ0l/s2ePZtzZU8HYQPPnkvRw6JOmUjQcZSCEwY0aOhwXgHQJvVdNJSb6JzlRwMzYWD6pid5jNkJnZh2uvnc5LL0nXUEtkdRgDnDk50zn77AsYPPiE+scGDhzMqaeOJTlZd2o//fQDfPrpAm655T7Gj7+8/vHduz0pDYw4cEAePKrfRSBuIZCHm8kkY1GlpfJPCZPqav+bKQUDY8eOZcOGLXTpIjm63OMDb70lD9shQ2RgPCMDRvrpGQ2Glu5LECjrf8+eA5SVbaVbt1gGDcps/ge2ABoNxQkhPhBCjBPGEr8OCHUwlJdLiuA33qjh6aeLWLxYphfITZhPQUGOhxBQMKaXfv21FAJRUXDeeXD++frmNJsbN9sbEgQpcn9QXAyVlU4qKvxkwmsGvGk33bv3Ijq6E8ceOxy73U6NwRnujUPIG8LDbZx11vVeaiTC6NlzoNfXmEySJE2Z5GFhjRdPJSRYOeOMK0hIkL91SxC1GmMDgwefwIQJ2S6W00UX/Y158xYyduyFfPbZu+zfv5fCwo1s3Pg/br31Cj75RFJvVVXJjJgDB+ShWFoKmzevoKBgFuvX/wTo1ewqG6ahg9tikQe+UTNWMSt3NwfAokUFjBt3PA888EBTpiFgzJ07l3ffXVSfcmy0CDZsgCVL5He48srA3jc8vGm1A+6w2VznzhgjAFi8+F3GjTuOJ554uPkf1kLw53D/D3AFsL6uP0G/EI+pVaA03k8+0aklcnNP5MCBfDIylO8xF4fD9+Gm0kslq6Z87OqrawgLu4+lS5+r35z+mO0qpc8ItVkVI/B33/3IRReZGT069BWMan7y8vIZMSKTHj0Ea9f+zqFDpVx22an06RPGCy88Xn/4+eYQ0pGW1p3rr8/j6qv/w9SpeXXzJ4DuQCIjR57p9XXR0Z4WVXx8w/OqAsZq7jZsaHR4zYa/VsfChe8ybdoldQVmz5CVdRagV2Qra2fbNp3p8vff/8uCBbn88IMUFoq6QgVCvSkSQkhBkZ4urzPWO6n58SYISkvL+f33Zfz111/+faEgQM2dprlaBIryaMyYwLX7Hj0Ci5s09D6DB+tr0H3OoqK60q/fILp2bR3q7qbAH66hrzRNywaGAFuAr4QQPwghrhJCBGiAtl3Y7dKd8cwzOrVEeXkhkENRURYDBgD4PtyM6aUffywzivr3h8zMQj744F/Mn39rvSDwh/8FPDezsgjUYVZZKf+pqQl9AwyHQ1JGP/lkDrt3S5+/sozU7dKl39UfsL45hCSSkrrz5ptbCA+P5733HqRz50wmTSoEnMTGLmHOnOVce+0dXl/rrWDTbJZZQb6Ewbff5vO3v0Xzxx8CyOSTT0Lf2tPoTnv//df49NMFLlYTSDek2SwH/eOPXxMXl8Ds2a+yZMlmrr7679jterV6RYVOaNijx1DOOecfDBki6yzcLQJf2S1Gy8mYuab6Y3sTBMceO5oPP/yZRx+dHdD3bwoqKio4cOAAdrt0FVZVubo+V6+Wtyec4OXFDSApKTiVxEao/egeZB8y5Hw++eR37rzzocA/sJXgV4xACJEITEKS4a9ANrPPAqZQ11imvcPhkNQS7p2/oAKH43siIzUslgzsds/Ap8lkZurUPLKysjl4EP77X/m45IFzEhPTGYvFGpBFoK4z+iLNZrkwlWuopiaDV14pZ+hQW32qXyigUvlmz/Y2Pzo2bVpHWZm8fvr0mT5jBFarjfPPv4fZs+9i0aJnsNur+eijR+jf/2UAamtzuemmraSmZnDHHTOZMCGbsDD5/TXNt//bYpEBT0Usp1BQkM9DD+UYaEMKWbgwh/z80Lb2NFoEM2bkUFNTzZo1+nzs3FnEySf3IDIyiiVLNtO1qwwiGTVJX5xWxxxzFsccc1b9/cYEgdWqH1gKiuSwulqunYgI74IgIqIzRx3VuX7dhRIFBQVkZ2dz/vmX8/TTb7q4hXbtkrGSqCj/ew0oNFZbYITVqrv1bDbf6b8REdL6j4iQQrWyUgprVRDaoYLFQogPkUVlrwPnaTLJG2CBEGJZKAfXUlDFZL6oJUCgaRrHHTeTZctyAH11Wq02TjllCgsW5DJnzmQiIjKorp7JkCHZdfnc/cjL2113rXyNv4LAV5wgNlalkAqqq21UV8vx+2tpBAolCHbvbtjds2/f1vouUqpqWGUNmUxmnE4HSUndGT/+bl5+2bW3kd1ezR9/XAUIKirkzisulnUGAFOmZBMf37i7xWbzFASzZ+dSVeUqkBwO2dozVILAmAfvcDi44ILJHDpURlFRBL17U6fpJ9KpUzyZmb1JS5N0mbm51xMXl8jtt/8Lk8lEaamT779/m6FDzyciwjd5UGMxgvh474pCZKSubERGehcEKgumJTKHKisr6dSpE4mJMjJuFAQq8WLgQE+3aUMItIAsKko//CMjvTMGgGecoLJSXqsEQWsw3DYV/hxJz2qa9o23JzRNax/1041AHS5dumSwa5enxp+UlIHJZGLcuGyWLQNZY7eVyMhuDBkyim++eQW7Xe6mqirpTpJ8J/oho9IcoemuIZALs7RUuofWr5cB40GDQps55HDIjZGY6L0RvIKKkZSWSs18woRsRo3KZv16z2tfeeUGL+/gSWij6Kqvv17OZWNC1GJx1ejAd7wilK09jQLLbDbz6KMvsn8/rFsnXRQHDkB5eQSDBo2mT58UhBCUlpbw5psvAFBZWU5VVSV799r58stXuPDCB7joovsBqKmpZN26H0lJ6UNioqTlaChGoGg2vMFm0w86m827ICgvr+X55x8HDjF79iPNmZZGcc0113DVVdewZYuz7rP155QgOProwN4zUF6hqCj5+wgh963J5F27NwqX2FjptispAYdjNbfeOo5+/frx3Xftg3zBH7kaL4SY6PZ3hhCiS8hH10JQknvKlIapJfr1g0mTssnK2gI4SUxcxfff59cLAR0VfPONLMi22+04nU4X7aE5FoHa0MpMnz37Ti65pHfIBYHd7r0RvBF79xZy882ZfPSR9L/v2bOfadMuYv7825r1+cXFWwPK/Xan6PAVrzCZTH631wwU3iwXZals3Kgf3Ndd9zrZ2Y8zf/7z3HzzpVx+eQ533/048+Y9wzvvvMzIkZNJSEgjJUXvtFJUtJaZM8/g0UfHAq4N1L25hhpqwWi8LiJCL7Yytlo1mcw89dR9PPnko9S2APucwyF/G9ADxU5n0wVBILGBsDC5P5VCAb73q1EQGGsJhBDs3r2NnTt98M60QfhzJF0DjET2FAYZE1gO9BBCPKRp2uu+XiiEGAM8A5iBlzRNe9Tt+b8BT6BoIeF5TdNeCuQLBAPKND7xROnjz8uTGn9iYgYZGYNYuPApNE1j1KhJjBsHkyYlATsoKor1+Z4qlfTDDx/igw/+RWJiKsuWya8ZiEXgXsXoGTBOoapqc0gFgdMpc/WzsrJxOOy899797N2ru3uM2Lu3kGefzSEhAZzO7vz00/uYTGamTHmq/hrZ5Md77YA3pKVlBBT/cDfnfcUrHA4HOTnS9RRsF5HRLVBdXUVJSQm7d8dhMoV7/FY7dsBPPy3lu+/+yyOPvMZll00mIiKSoqId9OlzIk8/vZGwMF0SOp0O+vXLqhcOFRXywAwP14PB6oA3NufxBiF0jddmc6XhUDCZTOTk3E9qqg2Hw0FYoEUKAUIJUbtd35uFhdLlmJSkj7EhqMB3ebn35AJ3KCtSfTVVVwFSEHiLE/hKIT3++L68/PJmjjsuOqSxu2DCH4sgDDhK07QLNU27EBiA3MEjgLt8vUgIYUaS1Y2te83lQogBXi5doGnacXV/LS4EQNc6qqth48YaYAtxcbt4/vktbNq0jM2bl/Of/0yu71TmcOwDfkLTBDEx3rVN5SbZuPFXAPbtK64nWfPXIlCmqRFKS1GCoHPnsUyd+ljILQKlCL7xxj84eHAn06a9SX6+naQkz1ZQNTUV/PvfuZjN0aSnH03Pnq4exIbbbro6tyMjbdx/f2C9mMPDXedtwoRsZs3Kw2TylMAVFTJWEGyow8zhgI8+WsKIEcnMmnWOz+uPP/56brnlbTIyTgXg9NPH8eKLs7jrrmOxWFznpFev43nggSVcd93LLF4M778vH09KkmvGGB8wuiR9Qa3HiAgZSwgPl1lvRtK7KVPu48YbpxPR3E5BjeCSSy7h7LNPo7Bwo0t8QGULDRrk38GakCCz9vyxHlQhHbgKgsYsAuPcGl1qFouV2NhMEhKS2k2cwB9BkK5p2i7D/d1AN03T9uPNqatjOLBB07RNda0t36YN9jp2OqW0r62V/69apb7qirqOZPvqr1VUElde+Qynny7TFkymcUjtVodyJy1dms/atTqnuiJZC8Qd4e7bVQecEgRC9Oeii6aHNENBuYaWLHmDQ4f2Y7dX88Ybt7N0ab7PFpp79xayffufPPHEav71r5/cnvPtm+/f/xWSkrojhKjvcXDllYFr6+pQVJgwIbue1M4doYgVqANg/37Yv99OTEwSnTr5JrkZMOBUMjOH8Pvvf7Bp02a2bdtCYmIaGRnHAFBc/Bc//fQumkHib90KL70EixbJ+97iA/5UBCsLVVGjq/x8o1Wg9keo8dNPP7FkybeYzRavgWJ/3ULqO/jjUgwP1y1tNXfh4f4ld6j3d68urq2Vlnx7yRzyRxB8K4T4VAgxRQgxBUlF/a0QIgrwEU8HIA3YZri/ve4xd1wohPhdCPGeEKKbtzcSQuQIIZYJIZbt8dYCrBlQecpVVdJlcfDgc4CJysopzJ9/Kw6Hq6yrqalg4cJ/c+qp6UA+JSXzcdVuBaecMoWsrGwWLPBMt6ysDEwDdVfAzGb517mzPOj27tUXXajgdMLChfm89NJ19Y8dPLiDF1/MITradyROtfd0h++2m90ZNCib557bwtdfO1m6dAsXXJAdMF0CuJKoKaSkeP/cjEAb1/oBZRHs3QvHHTeWvLw93HLL2w2+5uef3+Wxx87hlVdeIC3tNJ57bhtTp74IwP33n8Qzz1zC/v3bsduln+Krr1xfr2IBxjXjjyAwHnRWq3f30PbthSxd+h07jQ+GAIsWLeKDD76iS5eU+kBxTY3kPQKZMdQYwsMbjou4w2rVYwNGi0D935AgUHOtBIE6nj744GGmTbuM3bv3eX9hG4M/guAmYB5wXN3fa8BNmqaVa5rWeOeMhvEJkKlp2jHAl8B8bxdpmpanadowTdOGdW4OdaAXKLdQQYEkkrPbiwGN6uqdLtaAEfv2baVnTzCbczGmktaNlhUrFgK+Nd9ANFCjr1JBaSvx8fKQvv/+m0K6Qd95J59Zs6Z4CDV131cAuaamgjfemM6hQ675nN6CziaTDZhZr8mpzWexNN3H6t6q8Y47PD/XZrMxc2Zgrid/YLfD44/fy48//j+/rq+pqaqni4iPP5odO2TQ0WbrhBCCY48dw5Ah51JdXcHtt/fnuut6smSJVDezsyXz5ml1u9HoE/dHIzbGrMLCdEFQXAzz58MaOeqfAAAgAElEQVT/+3/w8sv/ZOLEU/hctQMLEQYOHEhW1hlYrdb6vblunVR2unf3FO7eEOgRoeYoIsKVBkbNS0OKiBIEmZnyujVr5N8vv7zHwoUL2Lx5c2CDaSU0KAjq/Pxfa5r2vqZpt9X9vadpfumfRYBRw09HDwoDoGnaPk3TVMrNS0CLE3irHOk5cxouljJCCBOzZp2Ow+HLLSIf96X5BqKBeosTqPtqwS9btpa1a9f4/Z6BID8/n+nTffMrlZfvZ+rUPJ+vLynZyaxZo10ey8qSbTdlfEFgtXYnKioPyK4XBEqTbQ7ZmSpCU5gwIZsbb8xDGp6Czp1TyMvLC0ktwfLlvzB37kwef3wc5eUNGc4KGr/99glms4WRIy/3eHbatDe4445P6Nq1FyUluygtHU9VlYl+/eDcc+Hhh6mrftcFgcnkX4aaL4vg669lG8i33oL09AEMHXoiccEg62kEyq2mBEGgbiF/hIURaj+pnh/uUPPj7X2VspGQIPnEAF55Bc49914efvi1+vqQto4GBYGmaQ7AKYQIcGoB+BXoI4ToIYSwApcBHxsvEEIYaxXHA2ub8DnNggqCNlYspWCxWHE6HWzc+LPPgz4xUZYxunc0Axn8DFQDdXcPqcNRsVEmJIwiNraJTVgbQW5uw+Rx4eEZrFiRTUKC7wUfG+tJCpOVlc0zz2whMdFJTc0WysrkYexuETSX9dI9xnL22dkI8Q3gZPToG0MiBBwOmZF0zTWPcN11LxMV1fjhabVGcvLJUxg9eho1NZ4kgkr1MpstTJlShskks7DOPtv1OrNZT5/1N+XW3SJQqcmqlqCkBM4++27ef/97JkyY4N+bNgHr16/nn//8Jx999B52uy4QFMXRAG+pJm5oLEvKHUbN31ethRDyPb3JwKQkfZ7Hj5dCtKgIwsIuYsyYySQkBNeDESr4k79yCFgthPgSqC/v0DTtloZepGmaXQgxDfgvMn30FU3T/hRCPAQs0zTtY+AWIcR4wA7sB/7WtK/RNKiFVlCQjxAmpNxzRWRkJyorywCNpKTunHXWTezevZGoqHi6dTvapS8BSDfJZZfJopusrGzWrfuBpUtfp6rqEKmpGfzrXzMDPnx8WQRKEJx22oMMChHvXMNuLBtVVTP54Qfo1WsmpaU52O2uc6GoNxScTnjhBRlEPe88PZ8e5AGmNrESBM3NVIyIcM1+iYgAq1VQVQVxcaEphamthSFDRhIZOdKlMKsx3HDDq14fX7YM5s2DCy90Ehm5l7w8Oe4LLvDk3ImO1l1p/gpRXxaBEdu368HPYLQP9YbVq1fz8MMPM3r0+YwadREgP091yPSnKX1MTGCuRH+ToBITXVNtFYSQiRubN8u1Ony45Brbtg0XYdbW4Y8g+KDuL2BomrYQWOj22H2G/+8B7mnKewcDimhuxgzvrg+r1cbVV/+HU0/NRtN8/6gLFuSyb5+sO3DvVHb11XO444459X1k07yFyxuBSlNTWqHa4Mo1tGtX6ILF3bplsHWrt2piM1265DFiRDZffAEbN2bXbUBZg+HetU0dIp98At/VJVKpDX7KKTLI1qePvomNQbvmwF3Li4yElJSebN4MU6bkNO/NfUDlnFcHgQuwsBCef16+14svVgOlQBcmTIBLLvG83hgk9XfujBaB4iRyb5VaVKS6lmlERIQmMb5fv37cf/8DxMf3qZ+7nTvlOBIS/HP5BBIkDg/3v22lWpfeago6d5aCsrZWt6a2batm8eKFrFsXxuTJ5/o/qFZCo4JA07T5QohIIEPTtJbjoW0BOBzw0EO3enV9GInk+vSRC2zjRr2CUyErK7v+sCsoeIxXXrmJOXMmkZTUnUsvnck552S7kHU1hQ9I5YarzaEsAuVGKSwso7i4jLi44NPePvTQTG64wbUYy2q1cdVVeZx6qvzenTpBfj5IktpsTKZ95OYeJDlZqnCbNsFTT8nUOqMwVZr62LEyEGiExeK/j7shKKI+I3eMEjKB9BIOBLW18Ndff/D77wdJSTmKmBh52jgc8jd0r3z2BacTnn5aviY6Gg4digR6k5RUywUXeDeVjIFif+fOZNI1XdWKMSVFark2myxYW716C4MHD2Ho0GEsXvyFf28cIAYOHEj//gPZtk3PWFKxVl8kc50765k64F/xGMjvm5wceCKCN0FgMsl1ZRQE27fXkps7kUGDhrQLQeBPY5rzgJXA53X3jxNCfNzwq9o+8vPz6dYtiQMHvGcGaZqTrKxsYmKkJqJpTpKSnCxf/jFvvHE7v/32qcv1S5fm8+67uVRWSl/A3r2FvPDCVdx++7F8+eUbgL7hmgKje0j9v2VLPpDJtm2xDB/eLyR0CZdems099zyPELJXQKdO3Zk6VRcCILnhTz0Vxo0D2IHTmcjPP6/mhhtSmDz5dB58sJa9e6UFpmkyqHbSSfK1aWmyw5QRMTFN67LlC8a5i4jQD8iystBIgpoaePLJf3L//aNYu1bPGvq//4MbbpBZMP/7n9T0G+qsVlQkD8S4ONntLiZGStGrrgrzqe0bM6UCEaLuGTLjxskOYOedJ++XlERTUnKAYKdvu0MpCkrp2bRJ3voSBOnpOpeQsTCsMdhsTctG86XIqXlTgmD/fhvDh48jK2t0i3QQbC78WSoPIIvDvgXQNG2lEKJnCMcUcuTn55OTk0OFt67YdVCVwenpMGBAVF2T9cX897/Psnr1Ytav/6meCx6ke8jdvWS31/K///1OQcEbXHDBpGZptxERkswNpNb2/ff5vPWWzoRaXn4oJHQJDgf88MMqNK0Qk+kA//d/8R4byGKB6+pKDH79dTu7d6dQXT2MkpIoNO0dIIyRI2VPWUWYV1oqhcKoUZ4bUsU+giUIjIem1QolJVuBDC666AoOHXovOB9iQE0NZGT0o2/fE+sD5QcPwg8/SK37+ecl9UFFhQyE/utf3gOR69bJ26OOkofdgw+a2bMHjjnG++e6Z0kFYn1aLFKjVZbYSSfJP5Wxc+hQAt98s5u+feP9f9MAsXLlSiorNWJj+1JdLSWach96EwSq/3Bysow5BdJ4xj212F/42sNqjcXEKGZgEzff/ClZWXIPNdeyDTX80U9rNU1zD3m1k3o578jNzW1QCIDM+ElPV9aAFOk7dmynf/9BxMenedAmNFQtu2rVrwFRS3iDe8DYW7FaKOgSHA44eFCeKGbz/kY32rhxxwOwZUs6XbuuBJIYNKiWadPkJklL03lgbr4ZjjvO9fVms67hBYtW233uIiLkD1FTE3xftyrumzbtUR588Hv69ZOmz5IlepBxzx4pBMLCpKtx9mzvbirF2tq3jm8uJcW3EADXwGegc+eeOaSg3I+7dpmIiemMpoXuRLvllls48cQhrFr1Sz21ekOuIaUwdOok40v+1g+YzYHRUru/1hvUnCm3GujtUFuiP3Zz4Y8g+FMIcQVgFkL0EUI8B/wQ4nGFFI0VdEVHJ3LBBdn1zSy+/HItq1eXceGFV/Lww0/x2WfbuemmZ1xe47taFkpK9jNjRg4FBU133ZjNrlpFMIrV/IHDAZMmPQlAz56N50QfdZS8XbECdu6MJjkZbr01zG+XWGKivtmCJQiU31shOVmebq+9tiA4H2CASkdWro3Vq+GLL/QWixdfLN0SvXrBE0/I9MONG+E//5Fpmsa2jMoiUIkGjcF4uAWqdBivNwrOxET53MGD0opT7r1QoE+fPgwceAxdu6ZRUyOTICorpeYf72aIREe7PuZv0Bea7haCxi0C0AVBYaGT3bt3sHdvAKljrQR/tufNwECgGngLmbbw91AOKtRoqKArLMzGlCnP1NP5AqSndye6Lq9RdQhz73jUGEVzZWUFDz/cPG3duNi6dGkZugSHQ0/xjItr/HSJiNhOeLjMMu7VC2bMCMwMN/p4g9lox3i42WzyjWtrg58HqTT7mhqp9T/xhEz9LC6Wmuv48dI19NBDUtu+804ZaPz5Z7j+ehlD2LFDHro7dsjf3D2Q7gvNsQjc+xcomEy6VfDoo7PJybmAnTvdMiaChJdffpnvvltFZmZfamt1t1BPN0e0EHJtNfUw9zeO4A2BCIJFi75gxIhU3n03+ApHsOFPz+IKTdNyNU07vo7mIVfTNM+Kl3aEmTNn+mBRTOSqq2SmkK/Da9euYg4dOkRsrOuiyMrK5q678rBYfDu2t29vnrZu3KC33toydAkOh54p5U/63iefPEJ1dRIg2LhRcMstop611R8YM2qC6Vd1DxhDcNI73aEEwd/+diw33HATtbVSew0Lk4FXi0Ue/MpC6tYNbrtNujVUZthHH+luoZ49/Z+H5lgE7nEUI5Qg+O23rXzxRQHFxbsJFZzOxgPFKSm+i78ag6wjafr4fAlY43sqQkiHowfx8UmUl/vHWNCa8CdrqK8QIk8I8YUQ4mv11xKDCxWys7O5+Wa9Hi4+vjvwBgkJeznttGyXzBKARx65kxNOSOO++27izDOPYtCgGObNe8bFNE1Kgquvzua003xTDXfr1jxt3SgILrssm5ycPMLCuiDZTxNCQpfgcMAbb0h28NLSPxu8dunSfL79dh7gqico1lZ/hIFxg4fOIpC3f//7Hfz444/B+xB0f3Bp6X5qaiTnwOWXw2uvSSoIbxg0CJ59VmYGCQFLl0pqB9DjA/6gOXNn5HRyD9IrQTB48HXMnfs+nTs3oRjGT6gUW9DjA5mZrtcYrfVAESj9hDuE8D63RkGgF+T14/vv93DNNW3fgeKPbfwusmH9vcAdhr92jRtvvJmcnDu46KIZ5ORsAbLrf0D3EvV16/5g165iVq36BVG3W5KSutT7JSMidK3l6aff5N//fh2z2VUli4y0MWtW87R142ITAsaNy2bixDWAk9NP/19I6BKcTigpkd/ZYmnY17lgQS61tZVen6upqajrQ+Abqi2gQjAFgXHulOZcXl7L77//HrwPQRcEDz/8F0KchdmsMXy4f69NToYTT5SH4R9/yAN55Ej/P7s5FoEQvmk9VEZTTMxAxoyZSGRkM09TL1i3bh0xMTGMHz+K6moZh/DmGoqI8L8Owx3h4U23JIzwti5NJv1xJTj37JEWYnsIFvuzXOyaps0N+UhaGMnJ6dx99+P8/LOufSlB4O4WmjTpRnr27M/Ikady5pnjcdalfwgh+U+MZe02m40LLpiEEILZs3MpLt5KamoGd90VOLWEO9w1tdhY6Nw5se650HCaOByQmXkWmzZBv34NRy0bypwCvWubLxg3uMkU3M5OKi3S6dStgzPOGMfo0b2D9hlOp54Z9PPPNjRNZkUFwn1zwQXw22/yt731Vk9t2BeCIUStVhnsdveaKp+64tqvqAg+1cTBgwc5dOgQVVVV1NTIVpnl5XIejJZ3oP2HFYRoniVhRESEHMfu3a50E1arDG5HRMjfo7paJgDExoaWmiMY8EcQfCKEuBH4EBkwBqCuMU27hWrIDnoVoy9BcMYZ53LGGbpdbzL8ou4l7QUF+S4C4N//fp0JE7KbrMUYIYQUBiozRVEBgCufTrDgdErNLCxM1VQ0LGySkvxrbu8LoXILKVitkq5ACtR8li3LpVevrWRkZDBzZvMFtSqGMgY6G0r39Ia0NOkmstn8OziUsHRPkW3K/ClFw11rVu6UHTvKeP/9D+jTZyDx8cMConNoDMOGDaOkpIT166s4eNA1bdSoELhnD/mL+Pjg1aUoYeReZawEAcg5270bpk69mJSUQyxatCgo1kio4I+MmoJ0Bf2A7FW8HFgWykG1BD7++CPuvvtqlix5o1FB4C8Ub1FRUSGaptV3JCsoyA/aIjS+jww6ypW3YsVvwfkAAxwO5RqS971lW1ituibfUOaU6trWEFpCEABs3JgP5FBSIn+nwsJCcnIC6xznDcoFUFZWy2+/rQSapoVGR/uvPaamSmHj/jlNCbSr+TGb9XUWEaErOzt3HmL69L/x+efvB13xMJlMREV1IjGxC9XV3usHrNamZfwo9tBgw31PG11qSniuW1fMH38sD4miFkz4kzXUw8tfu64sBnj99XkUFMzjs89m1wuClBR5qLkfQjt2bGfGjOu59NKT6dnTRI8eor7/sBGzZ3tSNldWVjB7dm6zydMU3OMEsbFyx1dUaNiD7Ix0OKCoaCd79shVHBsr5ygzU9JCHHUUDB6s57lnZUm+f9XHWPUITkrq7sFC6g0tJQh++MGzoVAwivHU9B84UElJiTwlAslvDxTh4dKCiIzUi6ug6W41dyUDXF0zDkcc558/mQEDjqOmJvhZV8qiqqnxLgiaag0Ys7SCCXdh600QXHPNS7zzzlIqKto2E6lPvUEIcaemaY/X/X+xpmnvGp6bpWnajJYYYKgwaNAQVq1aTZ8+p/D113LjdOniXeMoLt7GW2+94PKY0vZBNjyR13n3gRcXbw2aIHDXQpKS5AMREclUVdUQHR28nEunE37/fQ0Ox+lALQkJYWRkeB4ykZEyQFZTA1ddlc2IEf67WISQgqWwsOUEQWlpaIrxlCCoqQknLEzmwjfVp+0PevVquJFKoAgL01luFaVJdLQuZCorI3nwwdfqD7lDh/zvedAYPvjgA9599wNOOWUiiYkT2VbX5NYYI2nqXAbDLesN7nvReF9vG3oUPXvKOS0vD4wdtSXRkJy8zPC/O1X0mBCMpUVx66338cYbGznnnGdwOqXmZrV6/6G6d++F2cvJpLR9hdRU7z7w1NSMoOXEewsYA9hsaUREBHfFO53gcMi4gNlc2iCXS3o69O7tHx98RobuhktKkkLk6KObzpPjL9RBFxsbmmI8pfGVlIRTWyuJ4YLlknCf0549fR8qzVlr6rUq9mSzyawhFUjebSghKC8PXpXx8uXLefvtfP7660/Ky2Vg2mLRLSqLpWmHqBAtJwhUL4cuXfSxGtmK27J7qCFBIHz87+1+u4PdLjXY4mJ5Xx1M3iyCpKQu9ZlC7jBaAdOnzyQy0nXVRUbauPvumUHLgHHf5MpcrqwMfpqa0wmdOsmON+npiQ2a5orwTAjPORRCVscefbTMmU9NlYVUyrUBnps1FIJABdvHjJkJBL8Yz26Xc6a0WdXMpDkQQgrYoUP1OerWzdUV5I6m8uiAvr4iI/VD1Bgn2LSplJ07JWWq00l9g/nm4tJLL2Xu3Nc4+eTx7NolH+vSRbd44uMDm0urVWcmDVW2jre9mJkpY4xKQVuzZh0zZ97J5s3r23QqaUNTpPn439v9dgWnE/73vz8pLNzIqlVSjevd23fV4ddf57tkChlhtAImTMhm1qw80tK6I4QgLa07s2blcemlwcvvd6eyVjnelZXwxx/BbRfhdOpc74G0qjVqbmFhUgCkpEjtWAXizWaZeuvr0AqFIAD5+w4fng3kYbPJ36l79+5BKcaz2+XBuG2bjK6Hh7tSnFssrrxB/gQ+o6Kk1WSxQL9+0h3UWHOj5mSnqHlX+fpCuAqC668fzcSJelu0YGm5xxxzDBdfPJmePY+ttzq6GjqcBhofiImRc9YcOonGYDa77kUlqCIjdUGwbdtuXnrpCdavlz3FgyU4g42GBMGxQohSIUQZcEzd/+q+X40RhRBjhBB/CSE2CCHubuC6C4UQmhBimK9rggm7HS65ZBTXXdeb77+XK3noUO+L5tNP87n55hwcXiI9kZE2pk931SInTMhm6dItbNrkZOnSLWRnZwfdT2zURKSWKFfXa6+9E9TPWbAgnwcfTAdMrF2b4TdpnprHsDB52PvKwmrIvxwqQRAWpoR9NiNHruLLL79ky5YtQSnGczhkjn1hofQH7Nv3k8vzycnSSujSRWqOAwY07u4wrsnw8MYZNo0ZP02B0TWkfjejIAgL647Npvu7ghkwVindyiIwCoJADvRA+xY3B97ccJGR+nzZbH258cZH6NWrPyDXR1uET2+ipmnN2opCCDMwBzgL2A78KoT4WNO0NW7XxQC3Aj835/MCgd1OHSfQYCoqYomL8+1zffxx75TVZrOZWbPy6gPF7khM9J6BFAwY85cjIsBsrsLhiCIy0rNJfFORn5/PbbfpnclqarZ5BMd9ITpabtzevZseTAwVf7suCGDx4m9ZvHhCPc14c6BYOQ8dgspKqQ6mpsqTNDJS1i8od44x1tK7N6xZ49oW0ohAD7Tm5qqreRcCl8p5peFeddUCpk3Tr9c0tZ+a97mffPIJO3ZU0a3bmezaJdV/JQhstsCEm7Fvc6gRFuZJIR4WZswW68LFF99dH/Surg7OfAUboax1Gw5s0DRtk6ZpNcDbwPlervsX8BjuBDUhhN0OS5fuYuJEmXs/dKjUIoyaq8kkf0xfRHFOp9PngRgbKw/CUGm1xkVksejVxeedF7wevLm5vlNhG4Ny+zRVCIQq3Q9cBQFEEBYWRk0QelYqg7GyEmpqZFL/qFGn0qmTzPM/6ij9c42HlNUqXWe+XB+BujaaEx8A17WlWwG6ICgp8dRqVYFjczBjxgyuu+4Stm/fWp/Obew3EAhCFRz2Bl8CSgkxd2px8C30WxOhFARpwDbD/e11j9VDCDEE6KZp2mchHIcH7HYpmZcvl/eHDZOb06hNJSTITegrkyQ93fvjUVGB+dObAndtQi38kiDSnvtKpfSVIuuO5mhkoUyxs1j0A3nUqLOpqanBGoTcXhUErKrSabsTE6UrR4iGv5Py/w8Z4kqKFh4eOFNmcwWBUXkx/oZKwy0r84wLBKP389ixYxk79kKio7t6xAgCWQ8mU/PnIBCotqruUIHu8nJYtuwn1qxZWf9cWwwYtxr7hRDCBPwbuN2Pa3OEEMuEEMuC0TPVbpdajcruUEFL48JXi2nmzJnYbJ4ZJo88MtPlQDaZZDaM2vihhG9B4AxaOp8vAegrRTZYCAsLDjGYL6jgJwTXv223S6vAbod9+2SGWVxcbUDxIavV1W0UqFvIZGq+y8HX65UgWLFiGddccxzLl+vxj2BYBI888jj/+c97REQks3evXtcDgVlFLWkNgBScKSme1n9UlC7A7rtvIrNn31v/3OEmCIqAbob76XWPKcQARwPfCiG2ACcAH3sLGGuallfXC2FYZ3/70TWA/ftLOeWU/jid0iQ30iSAazew7Oxs8vLy6N7dM8PEqKkkJDSP5zwQuG/W3btXAzB9+k1BW2TnnONJp+0tOB5stESQT/3WwRYEVVXSZ75nj/QTffXVPwJ2D0ZEyIMlPDzwquRgrD9fNMtq25WXWygsXMXGjcX1zwVDECjXWlER9XU9SiloKD7QqZOr4tUafD4mk+fc22y6IEhPP4OUFJ1P/HATBL8CfYQQPYQQVmSB2sfqSU3TSjRNS9I0LVPTtEzgJ2C8pmkh5zHavn0btbWye4TSOowLyN23nZ2dzZYtW3A6nS4ZJiooGhvbclkK4K2iUe7EykpzUBZZfn4+8+fPd3tUMHHilEYDxc1FsCpVG4ISBH/9tZ7w8HCuuOIKMjMzMZlMZGZmNolzSPHol5eD3R4GlJGQ0LTtlZEhqTsCzTYL1tx5swqUIIiO7sesWb/Ro8eZ9c811zXkcDjYuXMP1dU1FNWpiv5YAyaTdMOq39PdvduScBeexgD7pEmvM3nyv+ufO6wEgaZpdmAa8F9gLfCOpml/CiEeEkKMD9XnNganE1JTezBmzKOAvsCNFoG/G0oFlJvKgdJUuGttgwYNAOCMM0bQr1/zDjSQgWLPTCmNb79d6HM8wUJLCAKVFGC3m6ipqeHdd9+lsLB5BHTKIlAFihkZMdxzzzMNvyjICJZF2pAgqKyMpEePwTgcneqDoCpzqKnYunUr3bt34fTT+3qkjjakYClyPnXgJia2HtWzN94hZRGUlMhKaSUw2yLnUEinTdO0hZqm9dU0rZemaTPrHrtP07SPvVx7aktYA3a79PFHRcluIf5YBG0RxoUXHx8B5PPRR9ezbVvzGTUbChQLoRe1Wa2y2ClYPO/uTeZDBSX04+NT6dy5swdZX1MI6FQCgmox2bt3y7kKFYL1eQ25hkpLdVqJHTv055tjFVRUVJCQkEhsbKKHIPBVg2IMwCtqh5a0yt3hTXgqBVHOmcaePXLimis4Q4E23CohNFA0ACpFTQV3VQBRiPYhCGJj9UNTbpZc7PbgMGo2FChOSZGui4wMGRxX1cJWqxQOzbGOWurgVIeLyRTJXiMZjAGBENCphjRVVa0nCBR9RjBgPNTUd4iJkb+1wwGvvfY033//Jnv36vGB0lLXJi2BYODAgaxbt5dXX13mIgga4glKTHQdZ0tmCnlDQ1bURx+9yeTJVv76S5ecRwRBK6O2FgoK3mH5chlg7dJF51WBltNKmwubTdfE16/PA7w3hGkKo6a3TKnISBv33z/T5+EWFyc3Z3O0spYSwOrQqKnxLfQCIaBTpr7RIvjqqytZvPiD5gwzIART6LgLAlWtrPonf/75chYvzsPp1KuAq6qkhdCUrDVNU/UXwkUQREV534tRUa2r/XuDNytK0YnU1g5C0zR27CiuT/E+IghaGW+9lc+9915NVdWxQCZbtuS7mJ9tuYuQO2w22Qzn++99N8duCqNmdnY2I0aMBBIAQXR0dx55JI9rr/UdKLbZ5AY1Zlz5ghDeN3hLadBKEFRU1GKxWOr7UCsESkCnqoqLi2H/frBYKti06Q327dvd+IubCdmuNLicOkbLwmKR9y0WWRQH0K3bzZx99s1UVJQyefJxPPzwPwCpZDUlE+vQITmHlZW41BD4cgs1twF9KOBtzQ8YINe5w3E0L71UQa9ew+oF3RFB0IrIz8/nH//IobKyHMmbV8iCBTn8/LPuR29PgkAI2QzHbvfeML55jJom4A3AyW23beHCC7P9tpTczXTlz01KkodWt266CyksTE+XbClBoD6ntlawceNGYmJiiKk7STMyMgImoFNMtsoa6NULHnnka04//VyPa4NpbSYlyXkMtoZssejjtFj0+4PqGMZqa4czYsSFrFv3A/UZmAYAACAASURBVFu2rOLll5+qZ+cNtGpW02DevDe48MITyc9/nZoaKdRsNu/fqSXXSSDwlnabkCDdp3a7oKhIDnr/fp1moi3hsBIE3mgTamoqmDNH+tFNpvYRHzCioUrf5jBqPv74cyQkjATkYg4kH94oCCIjdTpgFU8wmaRgiIyUgiE8XAqDlnLJqYPE6bRw5plncdNNN1FWVgbAkiVLAp4z90Dx0UfbOP74U0lJSXe5TtKB6Pf9mVOzWR747gpKdHTo3CNC6BpuWJhuIfTtK8exc6c80I47bgxz5+7gv/8tqmfnDdQiOHQINm/eyG+//UhhoYw4NxQoDiWbaHOhfk/j3PXuLf/fsEG/rqREj620lQyiw0oQ+PKX79ghH2/tgFNTkJbm3fXTvXv3ZjFq9uzZj/JyyZWRnh6YIFDCNC5Obmpfr+3SpXW0O2MFbl7eq1itVhITE+nfvz+1TaiOUoJg0yZ5v1cv1+9l5NRXhUbx8f4J2PBweeB37SqFqcUiD+NQdj4D/fBXFoEai4oTLFq0gg0bfiEuLpnIyNT616miOn+wb98+hgw5ivj4JBYsWEJKynmALgjchZ87H1hbg8Uix2hk3+3VS/7/2WdLePxxaSGq3iG7drk2rmlNHFaCoFu3hmkT2pNbSOH++2cSHu6ZWnHPPc3rJLp3rzzcVIeqQARBWJjczI1xLrVmUF4ddO+99zEPPvggVVVVrF27ll5q5wYAh0NublVDsHNnAe+++yTFxdsID5cHfkyMfoglJEg/t9L2G4LRQu3USQrlrl1Dny+vurkZaa2tVj1O8Omnv/Hll/8BJP9QWVkpIIWAv6mkS5f+woYN/2PPnp0ce2wWlZUyl7trV0/KF/AdPG4rsFjkflG/mdEi2Ls3mZUrF1JTU0llpb5mAhGcocRhJQjuv997BzFFm9AeLYIrrsjm73/PA7oDgvDwSI49djjnn39Js973uuukIImJKa9PDQ0EbV2oysMtn/vuk1RXtbW1TS7Ak/xC0uS3WuGnn57kueems337FqKjXVsuuiMyUjaa8eXmaS1XpdElZHR1DBmirriY7757jwUL7iU3dyyDBydQXCzJu/xxD0kq5jjOPHM8YWFhVFfj0pnMW9poW3YLgRSaRspsq1XGw+T9Ptx556+YzWEubKSa1jbYSA8rQXDhhdk89FAe0AUQ2Gyp9T0FTKbg5WG3JMLCYPz4bGAL8fFOvvmmgoKCn4mIaB4F6g8/yG5nVusBwsNDR6ndWnA684EcqqpUv4Uarr32Wp599tmA3qe2Vh5qGzfK+ykpcNJJl3PllbeRmtrNLxK0sDC9d7M7+2drCgIlAEwmPRusWzflHuoEXEJJyU4slnCcTicrVkgiuoMHYft2nYW1pkZmA2manl21fTsMHDiSF1/8iFtuuc9FECQneyoSVmvbDBIbYbXKcZvNuiVlscDAgfL5nTuHYjZbqK52rbnwRxA0tUbDXxxWgqC2Fs46K5uUlF2Ak8cfL6rnzmnri8wXLBZdm6yq0rnim6tlHH209Gd26RJV1/ymee/X1lBZmQu4Jg5UVVVx990+G+l5haJk3rxZ3qakwOjRN3Lvvf+mb9/MgOZNBc8VWrOmxSgI1H21R04/Xd526/Yc55zzD6655v/48ssyxo27mI0b/8fGjeupqXFSViYP9zVr9jJ//jx27bKzd69315FREHTt6ikI2ro1AK7uLFV/YTLBySfLx777Tr/WaBWo/3251GT70+DSzLvjsBIEDoesgFS5ykZ3cHsVBMZS+6oqWLLkS+bMeYRffvm1yb7HmhoYOfIqANLS4gkPbz0Ol1DB4fCeOFDp3kWkEZSXy/lS8YHUVOqty6a4GiMi9NhKa2awuWfQqXoCgBEj5EG9bVsU1dUDiItLZs+eKDZvhqeeup/TT+/L++9L0sLKSpg0aTR33nk1c+Y859Kz99Chsnp6j9275VyGh8v4ibsgaGl66abAveEQyDkbOhQiI51s3gzvvCPbyRqXmWrPWVws4y0gs7LKyqQlsH9/YLGXpqCDbe/GsX69HYdDmuLuTUDaKyIj5cLTNPjPf6Yze/YMXnttTpMXTmmp3rReBTM7mkVgsfjOtvIXVVWeZHOpqbB79xo2bVqHEE3LDYyLky6Y1i6cMh7GxuyhiAg44wz5/3vv6dfs2gU2WwKdOycTF5dY3+f73HMvA/Do+33TTRfTt6+VRYu+YLUs9Cc11ZNFtD1apMY4gexCJ9ODvvxSWqHuFrsSDPv3S6FYWipdazt2tEyK6WEnCFSD95KSpS6Lrb1aBOCan56UdAadOiXQtWtak9xDDgfs2VPBihXrAJ2Ur71txMaQnDwT8Gw4FEgB3rx5+WRlZXLccSaWL88E8klJgXvuOYkzzuhHRUVpk8en/MytCaMVaMweAjjvPHlAr1wJf/0Fb711NzNmDGPixOlER3ciJ+d8tm/fAsD119/J5s0aOTnTXd6/tlZqKqWlCfX006mpeFig7cEacIfRIgA45xxptldWTmL/fs/2lQqa5toKNBi9HvzBYScItm+X9pvFsqXedG+vgWIF1SMYYOTIf/PBB/u4446ZTRIE5eWwbt2frF8vCbJUTndrH0rBRteu2UAenTt7NhzyB6++ms/tt+dQVCTZXh2OQiCHLVvy6datF5mZvYmKaodpaD5gNrsqS506gepd9P77sHXrajZvXs6KFStITc0gKakre/fuavA933zza774ooZu3QbXC4K0tPbpFnKHOk/Ubf/+EQwfDg6HhbffloKgogIOHGi9MRpxWAmCqiro0eNyAMaMGVPvDmrPbiGQm/Too+X/69dLsxJ010UgkK+xI0QKIIOfHS0+AOpQy+a552TDoQULFnDDDTfQRZlAjeDeez2r1KGCDz/MpaBgGd9+u57o6DaeQxsAzGbPLKaxY+Xjf/4JZ5/9AHfdtZD+/c9m7txP+fXXnQwdeiLXXXcB//znTezfv5fKygoXyu/aWti/34LJZK53raWluR78Vmvz22+2BhRdu1F4XnGF/C5Llkgr6vffYcuWVhuiCzrgFveNigqdQ33gwKT64E5bz3lvDCaTzgOzYYPMwDh4sApN04WCv6iuhqFDR2KzyRLSQOkl2gvUgaYKeqKioigrK/NJS61QVASFhb6pPfbt21qfMdKRoL6PsR4iOloWmDmdUFZ2PP/v/73KtGnd+OqrxQCUlBzgq68+5r335nHLLZczcGA0q1cvq09i2LVLT4v0JQjaY22PgsWCSzvb2NhDHH205L///Xf5WHW1nnnWmjisBEFlpS4IevSQt0K07bJ1f2AyQb9+0gzdsQMuvzyBk0+WZf9lZf4Hm1QDdtVy0WxumCKiPUMJAvVd+/bty5w5c/j00099vsZul1qspunV6O7o3Fk+3h612IbgTRCAzIgBWL4c9u3bRkVFCU5nOitWwP798Xz66UpuuWUmYWGdMZvNbN++jVWrYOHCzVxzzUm8/PKN1NTI5AS13prSLbAtwmyWaa/KKvjjj8WsXCmb2Ku6E9DrLXxB0XSHEiEVBEKIMUKIv4QQG4QQHgnaQojrhRCrhRArhRBLhRADQjmefftkVB5qKC//EWifGQnuMJnk9+jZUz0ynJoaWd6pabLAxx+omILKGIqNpUNqt6AfMLW1kk6josLKjTfeyDnK8W1Afn4+mZmZWK0msrIyuffeGykv91TjLBYbU6bcyYkndmPChFGh/gotCuXqiIpy1dKVIFi1Cv75zx+YM6eIhIQezJhxCldc0Qc4muOPv40rrniOgoJyeve+mKoq2L27iHXrfqCwcCXFxXKddu2qN6xXaO+CAPR04O7djyUtTebPGgWBYiQtKtItJIdDY9euYux2O0VFcn5VrUooEDJBIIQwA3OAscAA4HIvB/2bmqYN0jTtOOBx4N+EEJJCIBOI4IEHLqCgIL/NNbhoChSJmqqLGDfuPebNK6uPD5SV+adR5OfLLJhRowSQSWnp7Pr372hQWppKsZ0/P5/u3T37Pefn55OTk1Pf07ioqJD8/LkcPOiuxiUyYUIeY8eeh9Pp5ODB/S33ZVoI3qyCzp1lt7qqKvjsM4iLSyUiIprt2/9g584NbN68A7sdYmISKSuz1hdFZWQcw/33f8ekSbNdMoZsNj0f35/eFm0Zar4UQWDnzpk89thbhIfrKaIghcCKFbJobPNmqZwsW1bGCSekMWhQJxYt+hJov3UEw4ENmqZt0jStBngbON94gaZpRg92FLJJQEiQn59Pfn4OspOXxv79u5gxI4cPP2wav0xbgqpgVMyQGzdGI4TJxRIwthX0hvz8fG67TWbBSBRit99LQUF+h7YIystlc5977slh61a93/OkSZOIjo7myiuvpKLCPSjsDdGcd142PXp04513lvDgg4+EdPytAbUO3InyTjtN3i5YAI8/DiC4665FPP/8VuLjU7y+l83Wif79R9G374lskxRFHvGB9mwNgD5fimBQPabc0karQGHPHqn97959AIvFyrhxd5Ka2j/kYw2lIEgDthnub697zAVCiJuEEBuRFsEtoRpMbq5nT9/KygruvTfwnr5tDcoiGDRI3v71lyxHNwoCh0MG5HyVqd9zj7csmGpmz87tkIJAWQSHDsnmPp7fHcrLy+sbrjSOrURHS99aRkZPzjtvfJBG2nag1kFkpGsQ9Oyz4dZbpdto1Sq5/nr3Hk5iYjeX7m/z5k3jttv6UFoqA/IOB8ybBx9/LJ/v0aNjCQJlzQjhShuekSHdths26GtL0zTy8qaycuXn2O3QuXN3Xn+9mosueoDExG4hH2urG/2aps3RNK0XcBdwr7drhBA5QohlQohle5QDO0D46kXQlJ6+bRFhYXITpabmo2mZXH+94JJLUnn/fd3i0TSZt7xjhzwAS0ulWVpbC9u3e5+H4uKt7brGwhf0dpUNN/fxH4m8+OKN9S6h9uzS8AWjQmDkRBICTjgBzjpL3v/2W++v3779T3bu3MBffy3l118LePbZL/jiC6nInHsuHH+8a+JGexcE3uZL0zRWrLgfgM8/r2LGDJny/ccfi/nmm5d4/vkrqKgIIamQD4RSEBQBRlGWXveYL7wNTPD2hKZpeZqmDdM0bVhn4woMAOnpzW9S3pYRFgZLl+ZTVKTcX3DgwA5yc3MoKHB1f1VXS1fR/v1SKBQX+86CiY1NaNdV175gdA35+u6BoZzPP5/HqFE9Oqw7zfidEhM9hd0pp8jbn37yHpO69NJZzJy5jH79zmXJknf45Zd+ANxwA2RnS4HgXkPQnmGcr06d5JoTQnD22ccDUFFhY/NmePNNSE3tz1VXzeGqq57HZtO5RcrK9vHll3P5/PPnQjrWUAqCX4E+QogeQggrcBnwsfECIUQfw91xwPpQDebKKz0pBSIjm9PTt23BYoEFC3JxOFxdHNXVFTzxhHf3V0GBDA736GGivPwQJpPn6VVeXsZbb7X/OIo71CFTWQnTp3v2qQgc8uQ7dKiUGTNyePvtjjdnxoPNZJI+fSOSk6F/f6loTJ8ODz4o21p+9BH8/e9QVTWS9euHcv31FtaseQnoTteuVYyUHVEJD3ftfdDekxTclQEVWxk79gJuvllj8mQp+P73Pzh4MJ3Ro2/kpJOucHnN/v1FvPLKG3z7bRWVlaHrYBOyqdY0zQ5MA/4LrAXe0TTtTyHEQ0II5UCdJoT4UwixEvgHMCVU44mNlZQCQiQBgrS07syd2/Sevm0NZrMsZvIG1YrTiIKCfGbM0CkSDh7ch9PpWXBQW1tDbm77j6O4w1hQdu652cyalUdcnI/uMQGisrKiQ86Z+8GWnOxZgzN6tLzdv18ecDNmwNtvy+KxJ5+E+fOli7K8XAreSy+NqD/wjVTT7d0aAM+G9snJikfJxIknCsaO1ejVawUAL7zg5M47YdEiee3KlbJwEQYB31BYeAcTJ0KollVIPZmapi0EFro9dp/h/1tD+flGLFsGkM3UqdncdJOM5HcQrxAgtacuXTLYtavQ4zlN0zj22CQefPCZ+v4LvgKk3tBR4ihGGOsI1q6F0aOzmTAhm4KCfG67bVKz378jzpm7IBBC1q4o5lCQsYKUukSh11+HNWvkdf36ScEAkJpawLBhA4iP78uIEfprjancHUEQgJwzVdAZFiY5wf74Q647IQR79kwHPmfbNhmIe+01GXBftUru6bg4AViJjdUoKRH1FPrBRjs3vvxHYqL869VLZj1YLG27/2mgMJmki8Nq9e7iKC3dxx13XM0HH0iXRSAB0o4SRzEiPl7eHjwo4wRr10pNdcKEbNLSvFNRK9eZftsd8G5FdMQ58xb3iIpyrSsQAjIz5d+dd8LEifI2N1cGhLt3/4zi4onExi5kzBhX94/RImjvgWIF9zkLD9eJHAEmTryKuLgHgOfJyPgckELAbNZ7ESQnw9NPC15+GQLsm+Q3DgtBkJ+fzwcfJLNvn+Cxx7rx2Wf5HUbjUDCZ4KKLspk2Lc+rrx/Abq/hkUdy2b4dkpP9O6gCpWZuL1AVsRs2yNvaWj219u9/94wZRETYuOmm+bz1lkZ+vp2bb9ZwOrfQqdMzHsK3o86ZL599Nx/ZjeHhcPHFcNxxUvHKzoZbbulNnz4nkJLS1+O9O1KgWMGb8FRKCMCoUZO48cbTOOWU5Vx8cTUTJ8rYy4wZcPvtMGyYjK9ERMg6IWMzrWBCaE1tY9VKGDZsmLZM+nn8gqoMNRYFRUbaeOaZPKZO7RjxAZCH2IEDskw9K8uEr9o8IQRvvulk6dJ8Xnwxh5oa3+6htLTuPPbYzA4TRzGiqkq6B2tqIC9PaqOJidCnjxQOP/6Yzwsv5FJcvJXExAwmTZrJiBFyHjQN7rlH+nCvvRbCw/P54INcdu7cSlpaBo8+2jHnDGTw1xu9+fbt8q+p6NRJp1K3WCA9venv1ZZw8KB3ipcVK2RQPRCkp0NWVtPHIoRYrmnaMG/PdcBsZ1fk5uZ6VIZWVlbwr3/ldihBYKz6TErKYO9ez1gBQGKitASysuR3nzt3itcgcdeu3Vm2bAvJyaEZb2sjPFxqWH/8IQ/+wYOlGV5aKlNrjzsumyVLslm+3JPKe/VqKQRiY2HUKIiMzOb227PrC4eMxVYdDfHxOnGjEenpcu2tWdM0KoSOFihWiIqSSpq7vh0fL4VqW0GHdw35Ctr5KqBqr1Bme3g4XH31TMxm71VgZWV7mTo1icsvFwYh4BossVptXH/9zA5ZSKYghKRQBt09pGmyKhZk3KCoyFUIaBps2qS3ZxwzRh5a0dF6vKk90yb7g/Bw341iIiIC1+RTUqQQNiocHWkOw8JchZxCQoLOCNAW0OEFga+gXUcL5hn9t5dfns31188jOtozkFldXc6hQ5IwTbcENJQwiIrqztSpeZx7bnabWaShwsCB8lYJAnCl7HZ3dcyfL4Oe69fLhANVSassAPdGJB0VDfVS7ty58f4eaq1aLNIfHh7u2iGwvfcHcUdcnGd8pVMnGD5c0sK0hXqJNjCE0GLmzJnYbB23kEzBuJhiY+GMM7J58cW9JCb624xdA7rz0ENbyMrK9ticHRGqq9uGDY13cqupge++k/+PGiUFgsqhV4LgcBACIA9uX99VpYoOGqSTq6lApxKUxx4rLYf0dE+N2GLpeOvOZMIny3F4uJ7G7ksgWK3SYgqlYtbBdT7qg3a5ubls3bqV1NQM7ruv4wXzjItICJnJsWGD7yIz79hKSorcoDExbcdsDRW6dpUa7J49cMcdkuqgr2syCz//LCk4unaVVci9esGNN+rPR0bqm7yjpDz6g5gY3w1VlGsnKkpvzhIeLquOzWb5vy8XUkezBhSionx3C0xOlspEZKSstSgpkfGW6mpJId+nj5zDUDbQ6uBbXSI7O5vs7Gx27ZKb2Z1GtyPAWzn77t0NB47dkZiYQXKyvkk7mmbmDrNZHuovvCADd3PmwFNPyYBnZKR0W8ydKzekOqBOOsn1Pbp10+MDh5MgiIqSwfXGkg6Ne82fIHpHFQTKwvZFBa+cFn37ynnt3FnObVmZ9xhDsNHhXUPe0BFNeCE8C+QyM+HSS30XmRlhtdq47LKZ9SyJqll5R4bZLLXUJ57QBed778HMmfDww/D113qKX2WlnA/FiwPSEjDSCx9OgkBWvQb3PYXoWIFid/ij0ZvNOlOpEC2XgXbYCQIhOq6m657NYbPJIrOpU/OIj/doBYEQ8udPSpIB4jPOyK53c3TUOTJCub4sFj3w++GH8raqSrJCgl7Ec+yxroefkXTNYumYLT0bQmxscN0VkZFtI3AaKsTGSsWhLa6Tw8I1ZISkgm3tUYQGiYlSgzUGPtPT4bTTZDzEvYAsLCyCqVPz6msKjNptR48PgGv2y2mnSWugtlZq+ocOyQwisxnuukvWDRgTzcLDXStEO6pLozEkJUkLu6RE77fbVLSEC6Q1oTT8sDBJwteW0IHlr3eEMuDS2jCZXHlfQB7o/fvDu+/melQR19RUsGCBTmdoPNgOB4sgOlp358TEwOmny816ww16RtHgwfK5o492NdPdC+06Qu/rpkAIKVDT0+X6CVSjV9ebzYePMI2M9F2L0Vo4DPQ+HUJ0bEEAcpFFRro2BomKgj17vGcP7du3FZNJNg43HnSHg0WgDjHF6Dh5MlxwgXysa1fpGrroIs/XhYe7dugKCzu84gPeYDLJeQsPl9puQ0Fkk0m3HtQ8NtRPuyMiIUGuG7tdFi+2Ng6D7a7DZuvYPkiF+HjPDlGpqRmGxvQ6unbNYPBgVwvAbO6YAXV3CCF9/koQmM26uygtTaaUuqN3b8+ss47u0ggEERGyWljTZO3Fvn1ybcXHS+oOs1laUyrjSFkBh4s1oGCx6BZ4ZKRMLTWbvXd2Cw+XFqfDkwkmaDgMjkUdbc0cCxWsVlc3D3jvwhUZaeOuu1ypJGJipJl/OLiGlEXgL2w2TyFgMnV8KzNQWK3y8IqJkfPVtaucu65doUsXeeAlJXm6MQ9XREdLi7xrV929lpQklRSLRc5ZTEzws7SMOKwsgsPBGlCIjZWLaM8eed/YkKa4WBbWTZ8+s/5xhU6dOm4w3R2qg9SAAbJozBtLJMhNWFbmyiOvEBfXNrNA2gqMsROj+8y9e9cRSMTGyjlTcxMb2zL78bASBIcboqKkqXnokLw/YUK2x8FvRETE4WEJKKgN1qmTPOxXrpRZVxaLnnmVkCC7cK1d62kNhId3bKbRI2gdGAVkSyllIdWRhRBjhBB/CSE2CCE8eusIIf4hhFgjhPhdCLFYCOEvMc4R+IlA8pYPt8wX4yYTQprnIDlyVFZQly5SMAwc6DmPoTTVj+AIWhIhEwRCCDMwBxgLDAAuF0IMcLtsBTBM07RjgPeAx0M1nsMVJpMM3iUn+46RCCGfO1xiKAru2lbnznKeEhNlsNhm02MI7m5Fi+XwC3AeQcdFKF1Dw4ENmqZtAhBCvA2cD6xRF2ia9o3h+p+A5ncNPwIPWCzyLzxcdjFT90tKZGDvcPVzux/uJpOk5QDpIuvf37dpfrhZT0fQsRFKQZAGbDPc3w6MaOD6a4BF3p4QQuQAOdDx+gi0JFQHLYXDzQJwh80m0xh9oSGq5SMpo0fQkdAmgsVCiEnAMOAUb89rmpYH5NVdu0cI4R+dZuiQBOxt5TF4w5FxBY62OrYj4woMbXVc0HbG5jMGG0pBUAR0M9xPr3vMBUKIM4Fc4BRN0xpt56xpWufGrgk1hBDLfDWBbk0cGVfgaKtjOzKuwNBWxwVte2wKocwa+hXoI4ToIYSwApcBHxsvEEIMBl4AxmuatjuEYzmCIziCIzgCHwiZINA0zQ5MA/4LrAXe0TTtTyHEQ0KI8XWXPQFEA+8KIVYKIT728XZHcARHcARHECKENEagadpCYKHbY/cZ/j8zlJ8fQuS19gB84Mi4AkdbHduRcQWGtjouaNtjA0BojfWaO4IjOIIjOIIOjcOIfecIjuAIjuAIvOGIIPACIYQXerHWhxAivvGrWh5CiDbLI3lkzgKDEKLVs/K8oa3uSWi7cxYIjggCA4QQ0UKIp4FFQogXhBATW3tMAEIImxBiDvC5EOLmumwrhGo63HrjihZCPAV8JoR4WAhxWmuOx4gjcxYYhBARQoi5wDf/v70zD5KjquP457u7uUwgmIQjECAuyUICxIgoiBSVIgTlUpCjSiiuBBCQyxDFCwGBGEVRJAgoKAaUw4oUXkAUAnKJCiYBNGqoxEJBCHeIBJLl5x/vTfIYdnaz2enpnpnfp6prevrY+eyv5817/fodsUHH3nF7EeJVuDQJxY3ZhlB3wlkhaSvgekDA/sC9FGfso+nAcOBYYCChyS1m1sdZYjccSWOBW4FOYCqwHPhiXj5d4DHrHVOBzQidOpcCP5Q0MOd4FTlNQgFjtqF4RrCOVcA1Znammf0XuAVYIGlCHjKSBsbXNqA/8FMzW2xmlwDLY6kyz9LHSuD7ZjbDzP5KaB32jKRROfl4zHqJpHTEJAEPmdkLZvYj4CFgZjwurxkqCpUmoS5itkE0bUYgaXtJV0kaBGBmLwD3JIdsDbQDf6+xV4eknwCXS9o19scYAnwoOexk4GhJo2pV+ojxWlsaM7OnefvYUO8CdjCzf9fCp8zNY9Y7rzGSbgGuk3SApNKUMZslh30WOETSdmZmtfhhK2qajG6FjFm1aMqMQNKehFvOkwhVCEiSmaXTSPcHlq3PsBdV9BpEqMJYCCwCPi1pGvB14GRJIwDM7CngBuDEGnkdAPwcmKE4r4SkNjN7LTlsGPkkUI9Z77xagO8AjxPSwEHAV4A5wP6SdgKImdNtxKory7ideVHTZPQoZMyqSVNmBMALhPq9DuB4Sdt2cdHeBzwJIOnEGt2ObgesNLNvmNnlwDXAIcAg4Ere3jHlH4QRXWtxG/oscBQhXudIGmJmayS1JJ89Hngi+hwpqSNjpxIes94xEngZuNjMbgMuuJagLQAACUZJREFUBKYAYwkZ6pe0roXOHUCtBngsapqE4sasajRlRmBmfyPMlbAE+C3wVXhH3fFkYLikucCRhPrKrL0eB0ZL2ituWgTcBXyOMDDfMEnnSToCOAF4PZ6XacnDzP4MLI7xugO4Ku5S8tl7AptKupXwA7g6S6fEzWPWA2mmZ2b/IYz0OyV5fyUwM2akK4ELJJ1AuKvqZqDuqnoVKk2mn1ukmGWGmTXsQrj13jh5r/J1YCNgCTC57NzbCaW1wzLwGgFsnroALXH9dOCGZN9E4Np4TgdwDDAPOKoWXl3Ea2NC6egDyb4BhB/gR4AjMrqWI4E9yrYVIWbv8CpCzKLXtLJtrfH1OOD+ZPsmhAexE4F3E6o+bsowXtMq7MstTca/vxXwTaB/kWJWiyV3gcz+MTiXMNjdTcD5cVtL2TGli3wW8Ku4/sn4wzwpI68vA4sJU3POSj3i+hhgLnBsfD+cMHDfFhnHqyuvSvE6F5gf1z8aXw/O2O8JQsl6l/g+zaRyiVlPXnnFLH7WI8D0CvtbgLuBs5Jtc4CdMo5Vt15l8apZmoyfcTLhGcBsQkOD8u9+LjGr1ZK7QAYXdDBhVNObgc0JJcJXgNFx/ztKuXH9pXjctcDADLwGArMIpYhNo9v/gGFxf0ty7L6EutBdgCOA+cA2GcWrW6+yY9N4rQFWAJcB/TK8ni0xYd5OuO3+DDA4z5ith1el71jmMSOUaFd09ffLXN5PaPt+MGGK2EeA8RnGq6JXN46Zpsn0OwRcXulHnXV3KjWNWS2X3AWqeEE3ia9twCSgLdn3A2BqhfOGEjKORcCHs/KK6yOT9UnAjcCOZceXvnSnAN+NX7bcvZL9I2I8/5KFV7lbsm02MCP+iO6Vd8zWx6tWMSu7luMI839vRCgETQV2Lzu+9OP3ceAC4PfAnnl7Jcdmmia7cGsBHiMUgnaMn30cSWGIdXcqmcYsryV3gSpc0OExMc4DzgDGJPtEaHI2H5hY4fwWYEINvHaI29sIpddlwLeAPxJufUtftLSU21oUr+T8tgwTZ+p2OjAubh8DXBfXpxNK4GcBo0rXuYYxW2+vrGPWxbUseZ1PePD8IHAeoRXLMcl3TNV2qYZXcn4mabLCtdw5bp8JfDtu/xShs9/MJH20ZOFTlKWuWw1J2p1wa/48cBHhYc8ZySEthC/em3QxTSaEIQfMbFENvE6Nn7cGeBRoN7OzCaWL6dEVSzo7mVlnUbwSpzVm9kA1vSq4jUrclgCvSmoFtgfOBHaz2BHLYkqN61nHbL29Eqeqx6zCtTwl7r6M0OpmHzO7gDBB1KmJj5ERffFK/KqeJiu4jQKmxd2lasWfmdnVwDnAFsQOY1aHw0b0hkJMXt8HXgYuNbObYO1Ik5Njr7/VZtYpqT2uL1cYsKp/6fgcvAYCb5jZ2omszezXkmYQEsyyJvXqzq0fob39zoSqgicJ9c0maayZ/dO91nrtE6/lK2Z2YelAM/ulpOmEH76s27gX1auS25S4715CT/RdottjsTNiQ2cAJeomI4i9DN9WkjGzxZKeSvatJlQNpT0PJwODJM0hlNrOydFrVXqOpHGEksm/gKebwWsD3FYDCyXdD9xnZvMkvYcwB3ZV25E3gNd2pWuZnDuecC2Xkd93rKZevXRrj/uWSJoNfF5hTKp2wt3w0mq7FZG6qBqS1C+9qGUdUVYm+0YTSmcpI4CdCG2AdzOzewrgNUDS0YSWTXeb2XFm9maje/XFzczONbN5cX2pmX3NwrAR7tWFl6Q2SYcQmk/fZWbHx8yrob364mZmCwhVVfcDvzCzAy10Hmt4Cp8RSDoN+J3CeN8HQajjTHv+JevtwMNx2yckDSUM+zvazKo6b2hfvAiDjd1JqE++ohm8+uomaYtq+zSyF6Hlzb3ABwv2HcvMq69ukrY0sxfNbK6ZXVtttyJT2IxA0jCF6pyPAF8gPOA5Nt5+r314I2mCrXuQMx7okHQ7cDjhecBiM3u9YF6tZvZcM3hVye1QMqirbWCvwwitXF4sr5JpRK8quR1K6OfRnFgBmi51tQCthJEIS23E24HriO3bCU/05wD3AVsC2wCvEoatzayXq3s1jpt7NYZX0d3qYcldILmQbYSOOVsn24Yk6y2EDilj4/spwKllf+N498rXq8hu7tUYXkV3q8cld4F4QXYmtGF/FrixwjHjgN9U2NffvfL3KrKbezWGV9Hd6nUpyjOC5wlDA+xAGFJ4XwBJrckT/5GEOV6RtJvipN+SZFVu2eJeDenmXo3hVXS3uqQQGYGZPQPcbGYvEer1SjP8dBKGiQB4L9Bf0iWEruClczPrJelejePmXo3hVXS3eqUQGQGArWupMgdYJemMuP2tmMvvBewNvGhme5jZfPcqnleR3dyrMbyK7laX5F031dVCaAL2cFyfEF8/RvJgyL2K71VkN/dqDK+iu9XLkrtANxf3DuANwiiAI/L2ca/Gc3OvxvAquls9LIWpGiqhMLn3RYSn/qeZ2f6WDIbmXvXhBcV1c6/G8IJiu9UTpc4XhULSfoSxbt7o8eAa4l69p6hu7tU7iuoFxXarFwqZETiO4zi1o3BVQ47jOE5t8YzAcRynyfGMwHEcp8nxjMBxHKfJ8YzAcRynyfGMwHF6QFKnpAWSnpC0UNLZSma8qnDOaElH1srRcfqCZwSO0zOvm9lEM9uRMK79fsB5PZwzGvCMwKkLvB+B4/SApNfMbEjyvh34EzAC2Ba4Hhgcd59mZg9K+gOht+tS4MeEYZNnAZOAAcAVZnZ1zf4Jx+kGzwgcpwfKM4K47WVge2AF8JaZrZI0ljBRyq6SJgEzzOzAePxJwGZmdpGkAcADwOFmtrSm/4zjdEFb3gKOU+f0A2ZLmgh0Ah0VjtsXmCDpsPh+KDCWcMfgOLniGYHj9JJYNdQJPEd4VvAsYSKUFmBVpdOA083szppIOk4v8IfFjtMLJG0KXAXMtlCvOhR4xszeAo4GWuOhK4CNklPvBE6R1C/+nQ5Jg3GcAuB3BI7TM4MkLSBUA60hPBy+NO77HjBX0jGEMfFXxu2LgE5JCwnTKV5GaEn0aJxBazlwcK3+AcfpDn9Y7DiO0+R41ZDjOE6T4xmB4zhOk+MZgeM4TpPjGYHjOE6T4xmB4zhOk+MZgeM4TpPjGYHjOE6T4xmB4zhOk/N/+iol5w0Wo9gAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 9134, {'val_loss': '-0.6695749163627625', 'val/kl': '0.000799733679741621', 'val/std': '0.0568060502409935', 'val/mse': '0.005037679336965084'} {'train_loss': -0.7123773097991943, 'train/kl': 0.0018125061178579926, 'train/std': 0.06797994673252106, 'train/mse': 0.006316928658634424}\n", - "Epoch 4: reducing learning rate of group 0 to 3.0000e-05.\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 10961, {'val_loss': '-0.6955886483192444', 'val/kl': '0.0007163399131968617', 'val/std': '0.04849543794989586', 'val/mse': '0.004054063931107521'} {'train_loss': -0.7836372256278992, 'train/kl': 0.001564738224260509, 'train/std': 0.059349723160266876, 'train/mse': 0.005054727662354708}\n", - "INFO:root:Epoch 00006: early stopping\n", - "\n", - "Loading checkpoint lightning_logs/anp_c/version_-2/_ckpt_epoch_1.ckpt\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "364c9e77175044a2ade92bf8ede76c9d", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Testing', layout=Layout(flex='2'), max=356.0, style=Progr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 10962, {'val_loss': '2.7513883113861084', 'val/kl': '0.022496435791254044', 'val/std': '0.17759346961975098', 'val/mse': '0.28182995319366455'} {}\n", - "----------------------------------------------------------------------------------------------------\n", - "TEST RESULTS\n", - "{}\n", - "----------------------------------------------------------------------------------------------------\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "trial, trainer, model = run_trial(name=\"anp_c\",\n", " params={\n", - " **default_params,\n", " 'det_enc_cross_attn_type': 'multihead',\n", " 'det_enc_self_attn_type': 'multihead',\n", " 'latent_enc_self_attn_type': 'multihead',\n", " 'use_deterministic_path': False,\n", " 'use_lvar': False,\n", " },\n", - " user_attrs=default_attrs,\n", - " PL_MODEL_CLS=LatentModelPL)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "ExecuteTime": { - "end_time": "2020-03-15T16:34:45.845722Z", - "start_time": "2020-03-15T15:59:03.750171Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "now run `tensorboard --logdir lightning_logs`\n", - "trial.number -2\n", - "INFO:root:GPU available: True, used: True\n", - "INFO:root:VISIBLE GPUS: 0\n", - "INFO:root:\n", - " | Name | Type | Params\n", - "---------------------------------------------------------------------------------------------------------------\n", - "0 | model | LatentModel | 9 M \n", - "1 | model.norm_x | BatchNormSequence | 34 \n", - "2 | model.norm_x.norm | BatchNorm1d | 34 \n", - "3 | model.norm_y | BatchNormSequence | 2 \n", - "4 | model.norm_y.norm | BatchNorm1d | 2 \n", - "5 | model._latent_encoder | LatentEncoder | 2 M \n", - "6 | model._latent_encoder._encoder | BatchMLP | 70 K \n", - "7 | model._latent_encoder._encoder.initial | NPBlockRelu2d | 4 K \n", - "8 | model._latent_encoder._encoder.initial.linear | Linear | 4 K \n", - "9 | model._latent_encoder._encoder.initial.act | ReLU | 0 \n", - "10 | model._latent_encoder._encoder.initial.dropout | Dropout2d | 0 \n", - "11 | model._latent_encoder._encoder.encoder | Sequential | 0 \n", - "12 | model._latent_encoder._encoder.final | Linear | 65 K \n", - "13 | model._latent_encoder._self_attention | Attention | 2 M \n", - "14 | model._latent_encoder._self_attention._W_k | ModuleList | 524 K \n", - "15 | model._latent_encoder._self_attention._W_k.0 | AttnLinear | 65 K \n", - "16 | model._latent_encoder._self_attention._W_k.0.linear | Linear | 65 K \n", - "17 | model._latent_encoder._self_attention._W_k.1 | AttnLinear | 65 K \n", - "18 | model._latent_encoder._self_attention._W_k.1.linear | Linear | 65 K \n", - "19 | model._latent_encoder._self_attention._W_k.2 | AttnLinear | 65 K \n", - "20 | model._latent_encoder._self_attention._W_k.2.linear | Linear | 65 K \n", - "21 | model._latent_encoder._self_attention._W_k.3 | AttnLinear | 65 K \n", - "22 | model._latent_encoder._self_attention._W_k.3.linear | Linear | 65 K \n", - "23 | model._latent_encoder._self_attention._W_k.4 | AttnLinear | 65 K \n", - "24 | model._latent_encoder._self_attention._W_k.4.linear | Linear | 65 K \n", - "25 | model._latent_encoder._self_attention._W_k.5 | AttnLinear | 65 K \n", - "26 | model._latent_encoder._self_attention._W_k.5.linear | Linear | 65 K \n", - "27 | model._latent_encoder._self_attention._W_k.6 | AttnLinear | 65 K \n", - "28 | model._latent_encoder._self_attention._W_k.6.linear | Linear | 65 K \n", - "29 | model._latent_encoder._self_attention._W_k.7 | AttnLinear | 65 K \n", - "30 | model._latent_encoder._self_attention._W_k.7.linear | Linear | 65 K \n", - "31 | model._latent_encoder._self_attention._W_v | ModuleList | 524 K \n", - "32 | model._latent_encoder._self_attention._W_v.0 | AttnLinear | 65 K \n", - "33 | model._latent_encoder._self_attention._W_v.0.linear | Linear | 65 K \n", - "34 | model._latent_encoder._self_attention._W_v.1 | AttnLinear | 65 K \n", - "35 | model._latent_encoder._self_attention._W_v.1.linear | Linear | 65 K \n", - "36 | model._latent_encoder._self_attention._W_v.2 | AttnLinear | 65 K \n", - "37 | model._latent_encoder._self_attention._W_v.2.linear | Linear | 65 K \n", - "38 | model._latent_encoder._self_attention._W_v.3 | AttnLinear | 65 K \n", - "39 | model._latent_encoder._self_attention._W_v.3.linear | Linear | 65 K \n", - "40 | model._latent_encoder._self_attention._W_v.4 | AttnLinear | 65 K \n", - "41 | model._latent_encoder._self_attention._W_v.4.linear | Linear | 65 K \n", - "42 | model._latent_encoder._self_attention._W_v.5 | AttnLinear | 65 K \n", - "43 | model._latent_encoder._self_attention._W_v.5.linear | Linear | 65 K \n", - "44 | model._latent_encoder._self_attention._W_v.6 | AttnLinear | 65 K \n", - "45 | model._latent_encoder._self_attention._W_v.6.linear | Linear | 65 K \n", - "46 | model._latent_encoder._self_attention._W_v.7 | AttnLinear | 65 K \n", - "47 | model._latent_encoder._self_attention._W_v.7.linear | Linear | 65 K \n", - "48 | model._latent_encoder._self_attention._W_q | ModuleList | 524 K \n", - "49 | model._latent_encoder._self_attention._W_q.0 | AttnLinear | 65 K \n", - "50 | model._latent_encoder._self_attention._W_q.0.linear | Linear | 65 K \n", - "51 | model._latent_encoder._self_attention._W_q.1 | AttnLinear | 65 K \n", - "52 | model._latent_encoder._self_attention._W_q.1.linear | Linear | 65 K \n", - "53 | model._latent_encoder._self_attention._W_q.2 | AttnLinear | 65 K \n", - "54 | model._latent_encoder._self_attention._W_q.2.linear | Linear | 65 K \n", - "55 | model._latent_encoder._self_attention._W_q.3 | AttnLinear | 65 K \n", - "56 | model._latent_encoder._self_attention._W_q.3.linear | Linear | 65 K \n", - "57 | model._latent_encoder._self_attention._W_q.4 | AttnLinear | 65 K \n", - "58 | model._latent_encoder._self_attention._W_q.4.linear | Linear | 65 K \n", - "59 | model._latent_encoder._self_attention._W_q.5 | AttnLinear | 65 K \n", - "60 | model._latent_encoder._self_attention._W_q.5.linear | Linear | 65 K \n", - "61 | model._latent_encoder._self_attention._W_q.6 | AttnLinear | 65 K \n", - "62 | model._latent_encoder._self_attention._W_q.6.linear | Linear | 65 K \n", - "63 | model._latent_encoder._self_attention._W_q.7 | AttnLinear | 65 K \n", - "64 | model._latent_encoder._self_attention._W_q.7.linear | Linear | 65 K \n", - "65 | model._latent_encoder._self_attention._W | AttnLinear | 524 K \n", - "66 | model._latent_encoder._self_attention._W.linear | Linear | 524 K \n", - "67 | model._latent_encoder._penultimate_layer | Linear | 65 K \n", - "68 | model._latent_encoder._mean | Linear | 65 K \n", - "69 | model._latent_encoder._log_var | Linear | 65 K \n", - "70 | model._deterministic_encoder | DeterministicEncoder | 4 M \n", - "71 | model._deterministic_encoder._d_encoder | BatchMLP | 201 K \n", - "72 | model._deterministic_encoder._d_encoder.initial | NPBlockRelu2d | 4 K \n", - "73 | model._deterministic_encoder._d_encoder.initial.linear | Linear | 4 K \n", - "74 | model._deterministic_encoder._d_encoder.initial.act | ReLU | 0 \n", - "75 | model._deterministic_encoder._d_encoder.initial.dropout | Dropout2d | 0 \n", - "76 | model._deterministic_encoder._d_encoder.encoder | Sequential | 131 K \n", - "77 | model._deterministic_encoder._d_encoder.encoder.0 | NPBlockRelu2d | 65 K \n", - "78 | model._deterministic_encoder._d_encoder.encoder.0.linear | Linear | 65 K \n", - "79 | model._deterministic_encoder._d_encoder.encoder.0.act | ReLU | 0 \n", - "80 | model._deterministic_encoder._d_encoder.encoder.0.dropout | Dropout2d | 0 \n", - "81 | model._deterministic_encoder._d_encoder.encoder.1 | NPBlockRelu2d | 65 K \n", - "82 | model._deterministic_encoder._d_encoder.encoder.1.linear | Linear | 65 K \n", - "83 | model._deterministic_encoder._d_encoder.encoder.1.act | ReLU | 0 \n", - "84 | model._deterministic_encoder._d_encoder.encoder.1.dropout | Dropout2d | 0 \n", - "85 | model._deterministic_encoder._d_encoder.final | Linear | 65 K \n", - "86 | model._deterministic_encoder._self_attention | Attention | 2 M \n", - "87 | model._deterministic_encoder._self_attention._W_k | ModuleList | 524 K \n", - "88 | model._deterministic_encoder._self_attention._W_k.0 | AttnLinear | 65 K \n", - "89 | model._deterministic_encoder._self_attention._W_k.0.linear | Linear | 65 K \n", - "90 | model._deterministic_encoder._self_attention._W_k.1 | AttnLinear | 65 K \n", - "91 | model._deterministic_encoder._self_attention._W_k.1.linear | Linear | 65 K \n", - "92 | model._deterministic_encoder._self_attention._W_k.2 | AttnLinear | 65 K \n", - "93 | model._deterministic_encoder._self_attention._W_k.2.linear | Linear | 65 K \n", - "94 | model._deterministic_encoder._self_attention._W_k.3 | AttnLinear | 65 K \n", - "95 | model._deterministic_encoder._self_attention._W_k.3.linear | Linear | 65 K \n", - "96 | model._deterministic_encoder._self_attention._W_k.4 | AttnLinear | 65 K \n", - "97 | model._deterministic_encoder._self_attention._W_k.4.linear | Linear | 65 K \n", - "98 | model._deterministic_encoder._self_attention._W_k.5 | AttnLinear | 65 K \n", - "99 | model._deterministic_encoder._self_attention._W_k.5.linear | Linear | 65 K \n", - "100 | model._deterministic_encoder._self_attention._W_k.6 | AttnLinear | 65 K \n", - "101 | model._deterministic_encoder._self_attention._W_k.6.linear | Linear | 65 K \n", - "102 | model._deterministic_encoder._self_attention._W_k.7 | AttnLinear | 65 K \n", - "103 | model._deterministic_encoder._self_attention._W_k.7.linear | Linear | 65 K \n", - "104 | model._deterministic_encoder._self_attention._W_v | ModuleList | 524 K \n", - "105 | model._deterministic_encoder._self_attention._W_v.0 | AttnLinear | 65 K \n", - "106 | model._deterministic_encoder._self_attention._W_v.0.linear | Linear | 65 K \n", - "107 | model._deterministic_encoder._self_attention._W_v.1 | AttnLinear | 65 K \n", - "108 | model._deterministic_encoder._self_attention._W_v.1.linear | Linear | 65 K \n", - "109 | model._deterministic_encoder._self_attention._W_v.2 | AttnLinear | 65 K \n", - "110 | model._deterministic_encoder._self_attention._W_v.2.linear | Linear | 65 K \n", - "111 | model._deterministic_encoder._self_attention._W_v.3 | AttnLinear | 65 K \n", - "112 | model._deterministic_encoder._self_attention._W_v.3.linear | Linear | 65 K \n", - "113 | model._deterministic_encoder._self_attention._W_v.4 | AttnLinear | 65 K \n", - "114 | model._deterministic_encoder._self_attention._W_v.4.linear | Linear | 65 K \n", - "115 | model._deterministic_encoder._self_attention._W_v.5 | AttnLinear | 65 K \n", - "116 | model._deterministic_encoder._self_attention._W_v.5.linear | Linear | 65 K \n", - "117 | model._deterministic_encoder._self_attention._W_v.6 | AttnLinear | 65 K \n", - "118 | model._deterministic_encoder._self_attention._W_v.6.linear | Linear | 65 K \n", - "119 | model._deterministic_encoder._self_attention._W_v.7 | AttnLinear | 65 K \n", - "120 | model._deterministic_encoder._self_attention._W_v.7.linear | Linear | 65 K \n", - "121 | model._deterministic_encoder._self_attention._W_q | ModuleList | 524 K \n", - "122 | model._deterministic_encoder._self_attention._W_q.0 | AttnLinear | 65 K \n", - "123 | model._deterministic_encoder._self_attention._W_q.0.linear | Linear | 65 K \n", - "124 | model._deterministic_encoder._self_attention._W_q.1 | AttnLinear | 65 K \n", - "125 | model._deterministic_encoder._self_attention._W_q.1.linear | Linear | 65 K \n", - "126 | model._deterministic_encoder._self_attention._W_q.2 | AttnLinear | 65 K \n", - "127 | model._deterministic_encoder._self_attention._W_q.2.linear | Linear | 65 K \n", - "128 | model._deterministic_encoder._self_attention._W_q.3 | AttnLinear | 65 K \n", - "129 | model._deterministic_encoder._self_attention._W_q.3.linear | Linear | 65 K \n", - "130 | model._deterministic_encoder._self_attention._W_q.4 | AttnLinear | 65 K \n", - "131 | model._deterministic_encoder._self_attention._W_q.4.linear | Linear | 65 K \n", - "132 | model._deterministic_encoder._self_attention._W_q.5 | AttnLinear | 65 K \n", - "133 | model._deterministic_encoder._self_attention._W_q.5.linear | Linear | 65 K \n", - "134 | model._deterministic_encoder._self_attention._W_q.6 | AttnLinear | 65 K \n", - "135 | model._deterministic_encoder._self_attention._W_q.6.linear | Linear | 65 K \n", - "136 | model._deterministic_encoder._self_attention._W_q.7 | AttnLinear | 65 K \n", - "137 | model._deterministic_encoder._self_attention._W_q.7.linear | Linear | 65 K \n", - "138 | model._deterministic_encoder._self_attention._W | AttnLinear | 524 K \n", - "139 | model._deterministic_encoder._self_attention._W.linear | Linear | 524 K \n", - "140 | model._deterministic_encoder._cross_attention | Attention | 2 M \n", - "141 | model._deterministic_encoder._cross_attention.batch_mlp_k | BatchMLP | 70 K \n", - "142 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial | NPBlockRelu2d | 4 K \n", - "143 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial.linear | Linear | 4 K \n", - "144 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial.act | ReLU | 0 \n", - "145 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial.dropout | Dropout2d | 0 \n", - "146 | model._deterministic_encoder._cross_attention.batch_mlp_k.encoder | Sequential | 0 \n", - "147 | model._deterministic_encoder._cross_attention.batch_mlp_k.final | Linear | 65 K \n", - "148 | model._deterministic_encoder._cross_attention.batch_mlp_q | BatchMLP | 70 K \n", - "149 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial | NPBlockRelu2d | 4 K \n", - "150 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial.linear | Linear | 4 K \n", - "151 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial.act | ReLU | 0 \n", - "152 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial.dropout | Dropout2d | 0 \n", - "153 | model._deterministic_encoder._cross_attention.batch_mlp_q.encoder | Sequential | 0 \n", - "154 | model._deterministic_encoder._cross_attention.batch_mlp_q.final | Linear | 65 K \n", - "155 | model._deterministic_encoder._cross_attention._W_k | ModuleList | 524 K \n", - "156 | model._deterministic_encoder._cross_attention._W_k.0 | AttnLinear | 65 K \n", - "157 | model._deterministic_encoder._cross_attention._W_k.0.linear | Linear | 65 K \n", - "158 | model._deterministic_encoder._cross_attention._W_k.1 | AttnLinear | 65 K \n", - "159 | model._deterministic_encoder._cross_attention._W_k.1.linear | Linear | 65 K \n", - "160 | model._deterministic_encoder._cross_attention._W_k.2 | AttnLinear | 65 K \n", - "161 | model._deterministic_encoder._cross_attention._W_k.2.linear | Linear | 65 K \n", - "162 | model._deterministic_encoder._cross_attention._W_k.3 | AttnLinear | 65 K \n", - "163 | model._deterministic_encoder._cross_attention._W_k.3.linear | Linear | 65 K \n", - "164 | model._deterministic_encoder._cross_attention._W_k.4 | AttnLinear | 65 K \n", - "165 | model._deterministic_encoder._cross_attention._W_k.4.linear | Linear | 65 K \n", - "166 | model._deterministic_encoder._cross_attention._W_k.5 | AttnLinear | 65 K \n", - "167 | model._deterministic_encoder._cross_attention._W_k.5.linear | Linear | 65 K \n", - "168 | model._deterministic_encoder._cross_attention._W_k.6 | AttnLinear | 65 K \n", - "169 | model._deterministic_encoder._cross_attention._W_k.6.linear | Linear | 65 K \n", - "170 | model._deterministic_encoder._cross_attention._W_k.7 | AttnLinear | 65 K \n", - "171 | model._deterministic_encoder._cross_attention._W_k.7.linear | Linear | 65 K \n", - "172 | model._deterministic_encoder._cross_attention._W_v | ModuleList | 524 K \n", - "173 | model._deterministic_encoder._cross_attention._W_v.0 | AttnLinear | 65 K \n", - "174 | model._deterministic_encoder._cross_attention._W_v.0.linear | Linear | 65 K \n", - "175 | model._deterministic_encoder._cross_attention._W_v.1 | AttnLinear | 65 K \n", - "176 | model._deterministic_encoder._cross_attention._W_v.1.linear | Linear | 65 K \n", - "177 | model._deterministic_encoder._cross_attention._W_v.2 | AttnLinear | 65 K \n", - "178 | model._deterministic_encoder._cross_attention._W_v.2.linear | Linear | 65 K \n", - "179 | model._deterministic_encoder._cross_attention._W_v.3 | AttnLinear | 65 K \n", - "180 | model._deterministic_encoder._cross_attention._W_v.3.linear | Linear | 65 K \n", - "181 | model._deterministic_encoder._cross_attention._W_v.4 | AttnLinear | 65 K \n", - "182 | model._deterministic_encoder._cross_attention._W_v.4.linear | Linear | 65 K \n", - "183 | model._deterministic_encoder._cross_attention._W_v.5 | AttnLinear | 65 K \n", - "184 | model._deterministic_encoder._cross_attention._W_v.5.linear | Linear | 65 K \n", - "185 | model._deterministic_encoder._cross_attention._W_v.6 | AttnLinear | 65 K \n", - "186 | model._deterministic_encoder._cross_attention._W_v.6.linear | Linear | 65 K \n", - "187 | model._deterministic_encoder._cross_attention._W_v.7 | AttnLinear | 65 K \n", - "188 | model._deterministic_encoder._cross_attention._W_v.7.linear | Linear | 65 K \n", - "189 | model._deterministic_encoder._cross_attention._W_q | ModuleList | 524 K \n", - "190 | model._deterministic_encoder._cross_attention._W_q.0 | AttnLinear | 65 K \n", - "191 | model._deterministic_encoder._cross_attention._W_q.0.linear | Linear | 65 K \n", - "192 | model._deterministic_encoder._cross_attention._W_q.1 | AttnLinear | 65 K \n", - "193 | model._deterministic_encoder._cross_attention._W_q.1.linear | Linear | 65 K \n", - "194 | model._deterministic_encoder._cross_attention._W_q.2 | AttnLinear | 65 K \n", - "195 | model._deterministic_encoder._cross_attention._W_q.2.linear | Linear | 65 K \n", - "196 | model._deterministic_encoder._cross_attention._W_q.3 | AttnLinear | 65 K \n", - "197 | model._deterministic_encoder._cross_attention._W_q.3.linear | Linear | 65 K \n", - "198 | model._deterministic_encoder._cross_attention._W_q.4 | AttnLinear | 65 K \n", - "199 | model._deterministic_encoder._cross_attention._W_q.4.linear | Linear | 65 K \n", - "200 | model._deterministic_encoder._cross_attention._W_q.5 | AttnLinear | 65 K \n", - "201 | model._deterministic_encoder._cross_attention._W_q.5.linear | Linear | 65 K \n", - "202 | model._deterministic_encoder._cross_attention._W_q.6 | AttnLinear | 65 K \n", - "203 | model._deterministic_encoder._cross_attention._W_q.6.linear | Linear | 65 K \n", - "204 | model._deterministic_encoder._cross_attention._W_q.7 | AttnLinear | 65 K \n", - "205 | model._deterministic_encoder._cross_attention._W_q.7.linear | Linear | 65 K \n", - "206 | model._deterministic_encoder._cross_attention._W | AttnLinear | 524 K \n", - "207 | model._deterministic_encoder._cross_attention._W.linear | Linear | 524 K \n", - "208 | model._decoder | Decoder | 2 M \n", - "209 | model._decoder._target_transform | Linear | 4 K \n", - "210 | model._decoder._decoder | BatchMLP | 2 M \n", - "211 | model._decoder._decoder.initial | NPBlockRelu2d | 589 K \n", - "212 | model._decoder._decoder.initial.linear | Linear | 589 K \n", - "213 | model._decoder._decoder.initial.act | ReLU | 0 \n", - "214 | model._decoder._decoder.initial.dropout | Dropout2d | 0 \n", - "215 | model._decoder._decoder.encoder | Sequential | 1 M \n", - "216 | model._decoder._decoder.encoder.0 | NPBlockRelu2d | 589 K \n", - "217 | model._decoder._decoder.encoder.0.linear | Linear | 589 K \n", - "218 | model._decoder._decoder.encoder.0.act | ReLU | 0 \n", - "219 | model._decoder._decoder.encoder.0.dropout | Dropout2d | 0 \n", - "220 | model._decoder._decoder.encoder.1 | NPBlockRelu2d | 589 K \n", - "221 | model._decoder._decoder.encoder.1.linear | Linear | 589 K \n", - "222 | model._decoder._decoder.encoder.1.act | ReLU | 0 \n", - "223 | model._decoder._decoder.encoder.1.dropout | Dropout2d | 0 \n", - "224 | model._decoder._decoder.final | Linear | 590 K \n", - "225 | model._decoder._mean | Linear | 769 \n", - "226 | model._decoder._std | Linear | 769 \n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validation sanity check', layout=Layout(flex='2'), max=5.…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 0, {'val_loss': '0.43982192873954773', 'val/kl': '0.0006571835256181657', 'val/std': '0.6844580769538879', 'val/mse': '0.29960399866104126'} {}\n", - "\r" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "d81595078f2d4663af55445552645c7e", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=1.0, bar_style='info', layout=Layout(flex='2'), max=1.0), HTML(value='')), …" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 1826, {'val_loss': '-0.5597448348999023', 'val/kl': '0.0010788586223497987', 'val/std': '0.09572924673557281', 'val/mse': '0.008218586444854736'} {'train_loss': -0.35748064517974854, 'train/kl': 0.0022839053999632597, 'train/std': 0.13907167315483093, 'train/mse': 0.017793959006667137}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 3653, {'val_loss': '-0.6659052968025208', 'val/kl': '0.001045938115566969', 'val/std': '0.06598107516765594', 'val/mse': '0.00438737403601408'} {'train_loss': -0.6084573864936829, 'train/kl': 0.0018979157321155071, 'train/std': 0.08042319118976593, 'train/mse': 0.008051631040871143}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 5480, {'val_loss': '-0.7188330888748169', 'val/kl': '0.0010508011328056455', 'val/std': '0.060397207736968994', 'val/mse': '0.004563245456665754'} {'train_loss': -0.6739754676818848, 'train/kl': 0.0018278189236298203, 'train/std': 0.07296169549226761, 'train/mse': 0.0070334551855921745}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 7307, {'val_loss': '-0.6969916820526123', 'val/kl': '0.0010379372397437692', 'val/std': '0.05430024862289429', 'val/mse': '0.005199989769607782'} {'train_loss': -0.7058612108230591, 'train/kl': 0.001559548545628786, 'train/std': 0.06874026358127594, 'train/mse': 0.006453181616961956}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOydd5hTVfrHPyfTCwNMoTsMDB1UQMQ2iqtY1t4Q2FlFVFBUXFx1dRfX9eeCZcVdlbUACqKMYFkFCyKoIIIgHaT3oZcZprdMJuf3x8lNbm5uMplhSjLk+zx5ktx77snJueee73nLeV8hpSSEEEIIIYQzF5bGbkAIIYQQQgiNixARhBBCCCGc4QgRQQghhBDCGY4QEYQQQgghnOEIEUEIIYQQwhmOEBGEEEIIIZzhCBFBE4QQQgohujR2O0IIIYTgQIgIQmgwCCGuFEJsF0KUCiEWCyE6+ii7XwhRJoQodrwW6s5FCSH+I4Q4IoTIE0K8JYSI8FJPKyHEbEfZAiHEciHEBYYyfxBCZAshSoQQc4UQibpzjwgh1gghKoQQ7xuu6+U4l+d4fS+E6OXjP0UKIT5z/DcphLjccP5JIcRmIUSREGKfEOJJb3XVpLwQYpDj9yb4qEsIIV4WQuQ6Xi8LIYTufJgQYoKjH4uEEOuFEC281DVMCLHD0d8nhBAzhRAJuvOJQogvHP2dLYT4QzX/09f9qVFdIZgjRAQhNAiEEMnA58DfgURgDfBxNZfdKKWMd7yu1h1/GhgA9AG6Af2BZ7zUEQ+sBs5z/O5M4BshRLyjXb2BKcBdQGugFHhLd/0RYAIw3aTuI8AdjnqTgS+BOdX8p2XAH4FjJucEcDfQErgWeEQIMcxHXdWWdxDk68Cv1bRrNHALcC5wDnAj8IDu/P8BFwMXAQmo/ir3Utdy4BIpZXOgMxCO6kMNbwJWVH9nAm877oPnH6z+/vhdVwg+IKUMvZrYC5BAF8fn5sAHwEkgGzVhWhznugA/AQVADvCx47gA/gOcAAqB34A+p9mm0cAvuu9xQBnQw0v5/cBgL+fWAEN03/8AHKxBWwqB8xyfXwA+0p1LR00szQzXTADe91FnOPAwUOpnGw4Bl1dT5g1gcg3+l0d5FGn+C3gfmODj2l+A0brv9wErHZ9bAsVAei3ue7xj/M3X3Xcr0E1X5kPgJS/Xe70/Na0r9PL+CkkETR+TUWTQGRiEWkGOdJz7J7AQ9aB3cJQFuBq4DLXabg7cCeQCCCGeFkLke3v5aEdvYKP2RUpZAuxxHPeGLCHESSHEQiHEuYZzwvC5gxCiuY+6cLS/LxAJ7PbSrj04Jpfq6tLVmY9aHU9GTVynDYda5lJgS23LO1Rv9wLP+1GFWz84Pmv35mzABtwhhDgmhNgphHhY9zsZxnvvOFYAFAG3A685TnUDbFLKnWa/JYRIdYylVLN2Ge6Pz7pC8B/hjd2AEOoPQogwYBjQV0pZBBQJIV5FidnvAZVAR6CdlPIQSm2B43gzoAewSkq5TatTSvkS8FItmhOPkkr0KHD8jhkygXWoSf5PwHdCiB5SynxgAfAnIcRiIAx41HFNrKNOUzj01B8C/yel1MrFm1zjq10ekFK2EELEASNQUldd4DmU6nbGaZR/A/i7lLJYp+73BmM/FADxDoLpgFoQdAM6AV2BH4QQO6WUi6SUywA3e4HjWHMhRHtgFErC036n0PDbzv6WUh4w1OXr/lT5qisE/xGSCJo2koEI3CenbKC94/NfUBPtKiHEFiHEvQBSyh+B/6L0ryeEEFP1xr7q4FjVaUbeYsfhYpRuWY8E1IrRA1LK5VLKMillqZTyRSAfteIFmAisBzagVBpzUeR13EebYoCvUOqOF3WnatQub3BIOO8AHwhloDbrA78ghHgEJbldL6WscBz7m66+d/wofyNKvVWdHUaDsR8SgGKp9C1ljmPPO+7JJpQt5LrqKpVSHkYRt2Y7qWl/+ypfJ/cuhBARNHXk4Fr1a0gFDgNIKY9JKUdJKduhDINvCYfbqZTyDSnleUAv1ErwSfCYkDxejmsPSJeRN97xu1tQhkgc9cSh9L1+qT5Qdg/hqL9MSvmIlLK9lLIzSm21VkppN7tQCBGFIotDuBtAzdrVGYgCdlJzWFBSSXsvfVAtHGT8NHClQ0oDQEr5gq6+B6srD1wJDHCoco4BQ4FxQoh5Xn7arR8cn7V7s0lrhu58TcIWh6PuNah+DRdCdPXyWz7bZbg/Na0rBG9obCNF6FX3L9yNxbOAL1DickdgO3C/49wQoIPjc2/Uyq8zcD5wAUqaiEOt6P7vNNuUghLbbweigZdxGCNNyqYCl6B0+dEoEjoJJDnOtwfaoYjhQuAgcLWXuiJQksBcINzkfG+UeuFSx3+dBczRnQ93tOFFlFopWqsHuAroh1JPJaBUMUeAaB/9EOWo4xDKFhMNCMe5TJQ3UU8/+9Rrecf9bqN7fYxyAEj0UteDwDZd324BHtSdX4ry3okCeqIcCa700a5Ux+eOKIeEz3Xn5wCzHf19iWNc9PZSV3X3x++6Qi8fY6mxGxB61cNNdSeClo6H56RjwnwWl9fQv1DSQTHKcDvacfxK1CqwGCVVZAHxddCuwSgiKgOWAGm6c+8A7zg+93b8fglqtf8DMEBX9jKUzrkU2AFk+vjNQY7+KHX8H+11qa7MH4ADjt+bp58sUbp3aXg95zg3xPF/ih39+w1wTjV9sN+kvjTHuX0oCU7fznd81OV3ear3GhKO8XDK8foXDoJynG+PWhAUA3uBB3TnLkWpkbTvE1FEV+J4n4qDxB3nE1HEXOLo9z/ozqU6fiPVz/vjta7Qy/+XthIJIYQQQgjhDEXIRhBCCCGEcIYjRAQhhBBCCGc4QkQQQgghhHCGI0QEIYQQQghnOEJEEEIIIYRwhiPoQkwkJyfLtLS0xm7GacFmA7vp1idPhIeD5QykaymhstL1vaLC/bsZhFD9ZSxnsUBsrOtzeNCNev9ht6vxpUdZGVRVmZePi1P9piGYxpuU6v96+2/1hbAw9Qo2rF27NkdKmWJ2LugeibS0NNasWdPYzTgtHDsG5d4C+BrQsiU0rzaUWtNDRQUcPer6vn075PsKaeeAEGqCMB67wJGBICoK2ratu3YGGoqLISfH9V1KWLXKs0809Oun+kRDMI237Gzv/+t0YLf7JsNmzSApqe5/t74hhPAaBytIuL9poSaD17i6O1NgXOVVJw1oMOtbKV31+SuJBSuM/6+w0Pd4q6hw/97Qq+vawm6vHxIARaa+4O9YDCaEiKARUJMBHCwPZl3DOKFZradXn0aoTb0/jf120hjv1QBjvwYLUdbnfSyqJmRdiAhCqBOEJILqoZ+QjPaC2kC7PlgmutpC//+qquDUKd/ljUQQLERZn89FdRJBVVXTG0chImgE1GQQhYigblZg+n5sag+xHvr/dupU9f81JBG4w2aD0tLqyzU1qSBEBI2AmkgEdnvwPJx1Cf2DfrpqIXB/cINl1Vsb6MdKXl715YNVIqivdlqt/o23EBHUAEKIa4UQO4QQu4UQT5uc7yiE+EEIsUkIsUQI0aE+2xMoqKmR60yUCkISQe2gH1tGQ7AZQkTgDqvVP1VkiAj8hCNN4pvA71HJTYYLIXoZik0CPpBSnoPKq/oiZwCMRFAdMQTLw1mX0E/WIYnAf9S034xlpKw/b5y6RH3dQ408qyPREBH4j4HAbinlXimlFZVA4mZDmV7Aj47Pi03ONzmYPWTVifBnokSgf9Dr4qHT19GUJQLtv/lrYLdaPfsjGIiyvp4JjRh9kejWrRv59ddfsTehgVSfRNAelQhFwyFcuXI1bARuc3y+FWgmhAjCrRr+w2zsVOfi19RWH/5A30/+qDiqg37iCIaJrrbQ/ltNpChj/wbD/FaX97CqyvUMan2h9Z8Z4bz99ovcdNOF3HXXXeT7s8sxCNDYxuIngEFCiPWoTFKHAY9bLIQYLYRYI4RYc7K6WTPAYSYRFBT4nuzqYiIMNoRsBLWD9t9OhwiCgSjrso2nTkFurvpslAj0u7Q1pKaq9MsfffQRK1eurLuGNCLqM8TEYeAs3fcOjmNOSCmP4JAIhBDxwO1SSg+KlVJORaW7Y8CAAUGgwfQOIxGUl6uHt6jIfau/HpoBSx8TpinD6Kdd1zaCpkoEtfW0CjaJoK53FZ88qZ4/u91dItD2YbRp417+yScnUlFRxoYNywlvIoGr6vNfrAa6CiE6oQhgGCr3qBNCiGTglJTSDvwVmF6P7QkIGAew5rNcUgLJyd6vsVq9E0VTg1ECqGsbQTCseGuD2kpRxrhXgd4/lZV26kqZUVGhwnCAksz1EkF+vndp/Jln/k1sLLRqVSfNaHTUm2pISmkDHgG+A7YBn0gptwghnhdC3OQodjmwQwixE2iNSnrdpKE9rNrDphFBdbsZzyT1kH4Sq4tdxeAuZQT6ire2OFMkgrfeepvrruvLwoVzT7uuI0dcn0+ccC3UKioUERj78fDhA5SUFDvLNBXUq41ASjlfStlNSpkupZzoOPaslPJLx+fPpJRdHWXul1I2oa41h/awapE19RJBTYKDNWXoJ/66UAsZ6w30FW9tUVt1WrBJBF9/PY9t2zbyxBP3sGvX1mrLL148n+efH0dFhfsfzc+H48dd3/Xee1ar+q4PWAhw991X06dPM3bu3EJVFVitAc6afqKxjcVnHLTJqLBQGaJKStR3u923VFCXE2KgQ2/YrQ8iCPQVb21RVxJBoBPB7NlfAVBUVMC+fbuqLf/uu68yY8brfPrpDOcxKWHPHu/XSOkah/qFSXR0DFFR0ZSXl3Hhhe0ZMKB/rf5DoKFpWDqCCNrgstvh4EH3hzAvT8U6N0NlZfVx0psK6lsiaKpEUFuJoKpK9U1EhOt7IMNiiWLq1HkcO3aIHj3Orrb83Xc/wv79uxk48DLnMX8SHWmwWiE6Wn3+5pv1SCnJy8vl+PEjWK1+JhYJcISIoIGhV08YV2K5uZCa6v1amw0iI+uvbYEAo02gLvdQNPX9GKfjaVVRERxEIKWkslJw1VU3VV/YgWuuuZVrrrnV7Zg/geU0GMeNEIKWLZNYtiybtLSmkeXoDFhfBhZ8rUorKlyqIjOcCTuMjf+xPiSCYAihUBtoE3hNUqFq0NsJApUI9u/fT6dOnZg4cXy1Zauqqnj55adZt24F0uSG14QIzJ47IQTt26ciRIT/FQUwQkTQgNBHEvX2sPkKNxGoD2hdwrj6qg8iaKrQxlZt/qdeOtVyAQca5s+fT3Z2Nvv27eLEiaP89NN3bN68zrTsqlVLeeedlxk3LhOA0tISPvpoCh9++Bag8jj7C60/58x5l2uu6cMHH7zpPNdUFmchImhA+OPL7osImsqg84UQEdQetQkvoSEYDMYPPvggixev4KGH/srSpd9xzz3XMmPG66Zl27VL5f77H2fEiLEIIbBaKxg//kFeeeVvQM0kAq0/9+zZzs6dWygpUSnMPv/8Qx544A6++ebb0/pfgYCQjaABoU3kviI8lpSohzAszPNcID6cdY2GIoKmuFP7dCQCMxfSiADTelgsFvr1u5C8PCgqKiQj4yq6du1tWrZjx3TGj5/k/N6sWXNuvvl+kpMTsdslZWX+33ytP8eO/Tu33vpHWrZUOz937PiNBQv+x8UX9+f6639f+z8WAAgRQQPCXz/2khJISPA8fiZIBA1hI2iq0MZVbRYMwSARgGs8XHjhIC68cJDf14WFhTF27DTCwz1JrzpoYzIhoTm9evV1Hr/xxmGcffZ5DBp0Xs0qDECEVEMNCH+JQNvybkSgPpx1CWOU0LrUVRslgqYEvV6/tjYCfZ8E2ljbu3cv999/P2+++Z9qyxYW5rN48Xz27NnudrygQMUV8uWQYQZvi5E+ffpzww1D6dixS80qDECEiKABod9D4AveNpY1dYlAv4kH6n4Tnc3W9AhAgzFpfW2g7+9AI4L9+/fz3nvv8d13X7odrzDZcr916wbuvfd6nn76fk6eVH1TWgo5OTlkZ29nz56aMUFlJVitVp588n7++1/PKDhN4bkMEUEDwl/R3RsRBKo3R13B+EDVhyqnqaqH9OOithOTfk4NtMmtW7duvP32VO6551FA2Qi6d49mwIAUj7JVVdFkZFzF2WdfxJ49cPiwkgZef30ITzzRk82bf63Rb9vtcOTIYT777D1mz57iPF5YWMDcuVl88sns0/tzAYCQjaABoa1Gq5vMbTbl3hYTY36uqW4qM04+9RFfqbJS9V9Tkwz0iwtjP2Znb2LatPsZOfJN0tPP91qHvr8DTSLo0KEDI0eOcsboiouLp7LSCkiqqqoI03lXJCZeyN/+thCbTamBDh9WO4NTUtJo06ZrrX6/oCCeESPeoHv3OOex/PxcHnvsj3To0JEHHxx+On+v0REiggaENvn485AVFpoTQaA9oHUJ4wRWH6vSM0EiMI6RZctmsWfPaiZPHs5rr+32WkegbyrTt8lisbB1awlRUdEIg/tXWZmnWrG8HB58cAa1RVlZCtdeO5Y+fVzHkpJaccMNQ2nbtkOt6w0UhIigAaHfTLZsWRYffzyenJwDJCenMnToRDIyMp1lCwqgdWvPOgJNZK9L1EceAm+/0ZQlAmO/XXbZ3eTlHaFfv+t91hHIEsHGjRvZseMA7dqdTYcOaYAKAGdEZSUUF5cREeFJEHWB8nKIj1ef4+LimTx5DhD8ccCCuOnBBf3EM39+FtOmjSYnJxuQ5ORkM23aaJYty3KWORM9h0I2gtpDv0HKOEbOOqsPjzwyi0su8a2+0BNBXWcBO11Mnz6doUNvqjYHQWkpPP/8IEaOjGffPvNdx7XB8eN72LRpIXv37jU9H+wLtBARNBD0D9Vbb43HanXf2mi1lvLxx64YKpp+04hgH3C+0JBEEEiT3OkiP989ZIKx344d201+/nHs1RinAjkvQc+ePbn66uvp1Kmb89jkyRMYMeJaNmxY5TxWWgqlpQVUVJQSH5/kVsfKlZ/y+OM9mD37rzX+/ZUrP+XFF6/hf/97x+14WVkphw8foKioBjErAhAhImgg6J/BEycOmJbJzXU/XlDgWSaQHs66Rl3ZCOx279c2NYnAZlNEoMFsJT9hwhWMGdOG1as/Z+fOX7zWpYU61xBIY+3BBx8kK+trfve765zHtm5dz9Kl33HkiOu5KS2Ff/97B++9V0BS0lludVRWVnDkyA6P58wfJCWdRZ8+V9K2bU+34yNGXEtGRkd+/bVmnkiBhpCNoIGgfzhbtUrl+PFsjzJJSe4xqAsKoF079zKB9HDWJcw2j9Vm0rbb4a+OBd8LL3iG6mhqCX6Mq3izPktISCE39yCvvTaEnj0H8eyzS7zWp4+9H2hjzdie0aP/wtCh99O7tys5jCZFx8Z6bs3v1+96Jk3aSkJCzRMNZ2RkkpGR6RF2o02b9rRu3Y7y8uBeYdSrRCCEuFYIsUMIsVsI8bTJ+VQhxGIhxHohxCYhxHVm9TQF6IngvvsmEhkZ63Y+MjKWoUPdN6sUFXnWE2gPZ13BzCbijQgWLIAvvzQ/l5cHBw6o1+bNnuf18Z6aAvxR57zwwlqmTDlJ27bdaN++l8/6AnVTWWlpKTab+03r1+8CLr/89yQltSYnx+V27Q3x8S1p374nzZoleS9UDSor3fvljTdms3LlYS699Kpa1xkIqDciEEKEAW8Cvwd6AcOFEMZR+AwqqX0/YBjwVn21p7Ghn3iuuCKTUaOmkpDg2gwzatRUN68hUKvbzz7LIiMjjc6dLWRkpPH551k0NVitnmowb+El8vJg5kyYPduV91kP/bFly5Sq4Ngx17GmphoyEoE3lVhCQjL//vcO7rvP9yMWqETQq1cvUlPDOXRov9txux127IDdu2HdOti06XsmThzMt9+aRyWtLex2V2eYkU0g9VVtUJ8SwUBgt5Ryr5TSCswBbjaUkYAmwzUHjtRjexoVRt3rOedcwwMPTHcee/PNuxg7Ns3Nc2jZsiz+/vfRHD6cjZSSw4ez+etfRzNrVtMig9xcz2PeJrR1OkeQtWs9z+uJYPVqGDcOnngCTp1SxyorfUd/DSZUVtbcrrJnD7zyCixebH4+UInAZrNht9uJj3epfObO3cnEiW+zdOl3gHrGDh/eyubNP3D06E6POsrLS/joo6eYNeuJGv/+889fzt13x7Bz5y+mQeuC3YmjPomgPXBQ9/2Q45gezwF/FEIcAuYDY80qEkKMFkKsEUKsOXnyZH20td5hDOi1ZMl0XnnlRn0JDzfSjz8eT3m5u3dRWVkp48dXn6EpWFBRYb6D2JsuvzoiOKJbSlRUKPVaVRUcOuQ63lSkArMJyTh5r137FY8+2p/nnvueN96AZ5+VrFsHU6fCp59KD0L0J2dGY+DAgUPs3GmlefOWgBofu3atYvr0h1i6dKaz3AUXDOHppxdw5ZWjPeqwWCx89dW/WLjwvz5/a/fuVXz44eMcP+5yFS0vL6KyspzIyFg3V92fflrAjTeex4QJfznNf9i4aGxj8XDgfSnlq0KIi4APhRB9pJRuSgEp5VRgKsCAAQOCci2nf+DsdggPN48TobmRZmRkkpNj7t1w8GDNvR4CFWZ2EDBfYVVUwG+/qc9hYUol8PPPyr5w7bXqmKYG6tcP1q93XatJBNC0icD433JzD3Ly5K2cPDnYcUQQFvYVVVXX8fnnYZx7LnRzeWQGrESg8iO4LLUVFdCmTRcGDbqHvn1dpsWWLdvSsqV5HuGIiGiGD3+JmJjm2O12LF52gH377Wv88stswsMjGT78RQBefHE9FRWlREREucUCq6goZ/PmdbRq1c5rHpFgQH0SwWFA77/VwXFMj/uAawGklCuEENFAMnCiHtvVKDCqhq67bhwffvhnlHbMHZp7W3JyqmPTmTs6dPCR4T6IYLd7DwlsNln/9ps6np4OsbHq+1sOlbeUcMMNLtXQ8OHq++rVyrhsJIKmoBryRyK47LIR/PijhexsuOUWuOgiqKxsw/z5FfzySyz79rkTQaBKBMa2WK3QteuFdO16od91CCG46aanqi13/fWPExYWwRVXjMJmqyQ8PAIhBNHRKs6QfswOHHgZX3zxK61bt8NmC14iqE/V0GqgqxCikxAiEmUMNvp6HACuBBBC9ASigeDU/VQDs1jvycnmE7rmRnrnnROwWNxHVkxMLM8+6xkKNxhRUuJ9QjYSwdatMG2a+nzeeXC+I3aatkj87DNFAidOqMxjbdpAr17Q1rE4bGoSgdF7RX/cHXEcOhSDxQI33gipqZCefj5pacprTW9Ih8AMM7Fr1y6uueYK/vnPx5zHzNSJM2Y8wvTpD3uVpP1F584q0cxjj3Vh7dp5HuerqlwG4xYtEunbdyBt23YImP6qDepNIpBS2oQQjwDfAWHAdCnlFiHE88AaKeWXwOPANCHEY6il8T1SNoW1mieMqiGAoUMnMm3aKKxWlxuC3o20ffseTm8FIQTt2qXyxBMTuf12d++iYIWvBCH6Ca2gAF5+Wa0C+/RRaqCoKBWUr2tX5UH066/w2muqn1u1chFEYqJ6b2oSgbcsW8bJaPt2dUyTojS0aaPejURgTN4TCDF0jh49ytKliyktdTVOI4KKilIOHdpCdHQzliyZjtVa5nPVf+DAb+TmHiQ9/Xw3rz0joqJUZxUX51FeXsxrrw2hRYu2PPjgdMdxz6CQwWwwrlcbgZRyPsoIrD/2rO7zVuCS+mxDoMCoGnrnnXtZvjyLdu16kpd3mKKiXI/gc1ZrOcnJHYmLi2LJkh1u1wc77HbfYab1D9XBg4oEOnVSm8W0iSkjQ73ffTds2qT2DoBLCgDvRBBsqKx0zyHsjQiM/23u3F+Ai+ncuQhoBkBhYQ6rVr0HPOVBBNqu7HDHzFBV1fhEcPbZZ/PFF4uw2VwzrzZ2Zs9+mu++m8ywYS/y7LNL2bt3jVdJG+Cjj/7Cxo0LePLJr+nf3z0I3+bNP7B06QdcffVDZGZO4p57JhMWFk5OzgE2blxAYqIrymhxMaSkgJSS//53Ivn5ufzrX68SrMEaGttYfMbAKBGcOnUYm81KZGQ0U6eaa8N69Mjg4YdnMWfOn7jvvht4772vgaZBBKWlvlfleqOl5ijWoYP5pJSYCMOGwQxHlGEzItC7qAYbEeTnq4mngy7asb8SwZ49amWblpaPRgQREVEsW/Z/wFOcPCmpqhJuuu3KSnciaOwk9i1btuTSSwe7ORZoRNCpU386dOhNTEwz0tMHkJ4+wGdd6ennI6UkNra5x7kffpjKypWf0KZNV7p0ucB5PD4+iSef/NqtrGYwFkIwbdokiooKeOqpv5OUlFi7P9nICBFBA8GYi+C++97iwIHNHvFQjDhxYi87dqwjO9u1GmoKWcpKS32f10sEOTnqPcW7JM/gwbB0qfKT10+YCQnKgFdcrMglMlK9B4tqyG53xRLSpAKr1ftiQN9vBQVQVXUOQlTRv79rgoqJacaIES/z+edlFBXFkJPjHvLcanWpPQJl0WEc8xoRDBp0D4MG3eN3PUOGPO/13LBhL2Cz3cq33w6hf39IS1PHo6PjPKSH0lKX2uzhh8c7PJCCdzoN3pYHGYxE0Lp1Oq1bpwMwe/bf+PrrV7DbbSQnd3TaCGbNepyCghNERsZw/vmXOesKlIeztrBafYcCAPdVuyYRJCd7L2+xwOOPK1vBpZe6H2/ZUpFJXp6a8AJFItCrYLxBf69LS6F5c+8hysH9vy1aBFJa6N8fWrSIcyt37bVjWb1aGeGPHfMkArPfbywsXbqUn37aQL9+GfTp098jON6uXSv59tvXufTSu+jXr/ZRatTzmE5xMSxdms/nn99LTEwCY8a871FWSrW4SEiABx54ElBOClKq92BDcCq0ghDawDWubJYty2L+/H9jt6ulXE5ONu+8M5IpU+6loOA4ILFay1iz5mfmzlUbzQLh4awt7HY1sftakVdVmROBL4kA1IR/7bWeqTyTHKFlNPVQIBiLpVQTcHUGRv14KS3VEq+Yl7XZXOWtVli4UH2+3ks+Gm3yN9oJ9EQQCNLnvHnzePbZP7F8+Q+Ap21p48bvWLFiDhs2zDe52hNSSmw28x2L2obE3NwIVq/+gk2bvsZnmIsAACAASURBVOPQoa0sWvSOR+RW4x4YKesnvWpDIEQEDQSjRDB9+sM888wFzJz5J2w299FTVVXpMVDLykqZNGm8s65AeEBrg8LC6lfkRm8iMyJYtiyLsWPTGD7c4hGaw4iWajOq02AcCERaXq4mbk3t5Q36tlZUuBu9jdD369KlaqJq3TqPuLjfPMoqbxi1484XEQRCX110UQZ33/0I55yj9P/GXeeRkTFERcUyaNDIautaseJj7roriilT7gPg+PG9VFXZ+OmnmSxY8A7Hj6sH9dSpGMaN+5Rx4z5j69YlTJ8+hqVLP3CrSyPkI0cOsnLlTxw+fCBoiSCkGmogGBPXr1v3dY3jouvjrgeCN0dt4E8YaP2K12ZTk58QrpX9smUqw5uW3EcLzQF4BO4DT8+hxpQGNL2y9h/Lyz09gvQwTsS+VGp6ItBCcRw/Po45c3J46qlv3Mrm5R1hxYp/Ap/7dCENBCK4/vpbGTDgVud342R73XWPcfnlI326g2qIioqjqqqS8vIitm//mf/7v8sYNGgk+/evJzu7BHgQgBMnLFxwwR2AymNwxRWj6NnzMre6tHv47ruvMmPG64wf/ypduvyZ5p526IBHiAgaCBoBaIP4ssvuZvfuVWRnr6ew0L89dG3auKyggeDNURv4o5/XSwS5uWriTkpy6dM//th7hjczIjCqhqDxyODoUWjRwt1YbrV6v5c1kfz0JHvCsTe/e/cEunbt6lG2bdtu9OmTxubNcOyYBFyK7UCTCIxjxuhoEB4e4RcJgAr2OHNmGZGR0ezcuQKAn36awT33TGb16iq2bFHlCgvV78TGQp8+V9CnzxWm7Sovh/T0HgwYcAmJiSkhiSAE39AmHm1Fd+ed/wTgww+zmD9/NFCNGw0wZowrxV4gPKA1hZT+bbrRSwRmhmJvO0e9SViaRJCX596WhobdriYPY9zEigqIizO/pib3WZ9rQVM5/eUvk902kmkID4/gySf/zciRcPy4oKJCbdKDwCOCX35ZQVJSJ5KTWyOE8Bqfyh+Eh0cAinW7dr2QkSPfpKLiNnbvbkOPHjiJAGD58lXs35/NFVecS3p6N9P6ioogM/NBMjOVJGG3u7zTgglBqFwITmgTj3E1k5ubCUzFYungcY0GiyWMhx+exR13jHEeC8ZdjDZb9ROwzeYu+pvZB7xtGIqLM/fh1ohAr49vDBuLN2nIl7qsJhOxVn9hoYtczEhAQ2QktG+v7slBXZxgvXttYxPBqVOn+P3vL+Z3v1NSjbYKrwsIIRgw4CE++6wNy5bBfIOt+fPPY/jxxyHMmpVLfv4xbDbPG2hGSsGYBS9EBA0EbeLRJIIlS2awcOHbbN5sBzKx2w8SG9sTIdxvSWRkLGPGzCQjIzMg48DUBDVVC4H5HoKhQycSFuapSykvL2L69Ic8jMitHJkJT+hCGTaGRFAbIqiNakgjz6SkKnxFbLHbq2jVSvmi7t/vfk5ra2M7JuTn53POOQPo0+c8hBBePab8hZSSN94YxsSJg/nqq1d4+eVfnf2mPZva/oH8/LMB2LWrkDFj2rJp03ce9enHq9bXwfhshoiggaA9UNpqZvr0McyYMY2SEtctuPHGrTz00AckJ3dECEFyckdn5jK73U5pqeuJDMbB5g8RGB90M4kgIyOTmBjPnLQ2m5VFi95xRGx15Xf47bcsoqLUQ6vVH0hEoKmMzFAbiUAjvLy85dx1VyTbti01Lb9p00LWrn0O8CSCQHEhTUvrzLx5q5kzZwng3XXWXwgh2LRpIZs3/8D8+d9z4MB5gA1wpcjr18/9mqioHiQktCI+3lPiLC2FnTu3cu65Lbn+enVhMD6bISJoIEjp7vHRsmV7wsPV5hdtkvv++yw+/ng8OTkHSEpyxR0aNSqZzMww5sx503l9MKqG/CECo1eMt81kxcXe/CjdZ3irtZRPPhnv4TMfSKoh8O5/XpN2avVrfWaxHKSqymY6gQGkpfXHYlGJnVes2M7nn//TeS5Q7ATGPjsd+4CGMWNmMnbsYqqq/geE07r1YiIj5wAQHQ09eriXt1g6MmXKcbp1u9ijLinBYomnsDCfvDwlvgaja3eICBoARkPxwYNw/vl7aN9+AgC33w4REVnk5o72WM3q/eMLdIl9g3HV4Q8RGG0o2sStRctctiyLu++OwSyPgzfk5h5wXn/8uHpvDInAlwrI39hBvmAkgltvzWTmzDLat+9pWr5Fi9Y89dQLAJSWprJz56+mbW1cInDdKG037+nivPNuZOHCyykqiqdrV3j55cG88MIDREQoEtDGiobiYt8bxeLj27N27UmWLVO5Q4Lx2Qx5DTUAjPaBefNg+XLX+XPPBYtlPEbPIc0l8tVXtxMZGUtiosvyF4yDrToiMEpN5eUqzk54uHIB1fYPVFZ6sxYKzAgiKSnVaSdoLCKozmOquFiNk+Rk1/4Qu71m7TTaCFJSIDIy2uc155wzgMTEKk6diuXKK1/1qAsad6zddNM17Nixgzff/JSePQfWyWo7P19lt4uOVvmso6IE7dvDq68qA3t0tAodYbMpt96CArUHRR/MUI+ysjDatHGJrMH4bFYrEQghLEKIfkKI64UQVwghWjVEw5oSjB5DmnibkqKCpbVoARUV3l0iExKSiY6OdVuVSBlcA84YH8YMxmBwmjTQurWaHM32D2hITu7IVVc9SERElNtxLb+DphrS9OcNTQT+SkN6IqyNWghc/7G6kBwaOnVSoUet1u7OY4FiI9i3bw9HjhwgIaFFnfnoL126HYBmzfaRl7fReTwlRXlZWSzw3HMwYYJr8tfvQTHCKMUG03OpwSsRCCHShRBTgd3AS6j8wg8B3wshVgohRgqji0sIptAmHU38LylRB06evJgRI9QyUctKZoT+uDEGT7AMOKvVM4yBGbyphbRJ3FfmqeTkjtx771uMHv2e0/MqNraF09iu1aFJBA09ufkb6K62nmFa/Xa7y9Pq3XevISur+qTqHTuqd6MLaW3aUdf45ZftLF68i9TUznXmlvnrr2ocnTw5hxkzHjEt07atemmbEX2F9igpgdde+z9GjbqZPXt2BM1zqYeviXwCMAtIl1JeI6X8o5TyDinlOcBNQHPgroZoZLBDm3S0AVJSos1C+YQ7tssOGzYRi8Xd6Vtbzc6YMZYxY9rx4Yd/dpsogsVgfOqUf5OJ0VBstA/4SjiyfbvyjMnIyOTdd/PIyqrivffynDuNG9tG4O9q9nSJID9fjYvY2Ap27lxIdvaGaq/V+mbduu3ObHmBQgRCRJCW1oXw8PDTihprt8NHH8HPP0NlZV8AwsLWmxqA9TDLZ2FW98qVP/H99186w8AEGxl4tRFIKYf7OHcCeK26yoUQ1wKvo1JVviulfMlw/j/A7xxfY4FWUsoWfrQ7qKBNOtrEXV6u+Pcf/3Alu8jIyCQ7G77+ejxwwC1b2Q8/TCU//yh7966lvBzi49U1wTLY/CWs6ohg6NCJTJ16v5uNQNlO2pOefj42m5Xw8EhiYz1dS5OSVF6CvDw12QYqEWjqMSFObw9Bq1ZhZGb+QGRkjPeLHND69+DBMgoKjpOSkhYwqiH9GD8diWDTJvjqK2VvCgtT2u033vjEOdF7g1mGOzPcc8/fuOeeR+jZ81xAtTuYEtn7ZSwWQlwMpOnLSyk/8HqBuiYMeBO4CjgErBZCfOlIT6nV8Ziu/Fign0dFTQDGgHMlJSquS1paZ7dyQ4ZksmiR2jj2/POuqJnXXfdnunS5gF69Lg86icDfsBLgnQg0PW1GRia//baIpUtnAjhzN+jjC7366q2sWTOP3r2v4Jlnvncet1iUDvjYMaVDb8jJTUr/JzEp1eo+MrJmRK+p1bQkNikp4abxccygEUFYWC/Cw1UcDn3KysZacKxYsYKXXnqDAQMu5a67HqoVEWgT8goVVgibTb0SE6mWBMA/1RBAv36D3XI6BJsLqT/G4g+BSUAGcL7j5TsfnMJAYLeUcq+U0grMAW72UX44MNuPeoMOdrvrYbLZ1INusbhiu2iIjIRevdTnjS4bFueffzOZmf+iX7/r3NwMg0EiqAlZGYlAU+PoH7DLLruH7t0zuOiiYUyevN8jyJwK4CfZsuUHJk68yu2c3k7QkBJBTfMfaGTv7/09flwFswPl4QLK68VfNGumvGWqqqIAl++kNvE21jjbuXMXX345h3Xr1Czur2pIm4Q3b4YHHlApTFevdi/ToUMxx4/vqbYufXiSX3919bMRRpIKhmdTD3+MvQOAS6SUD0kpxzpej/pxXXtAZ37ikOOYB4QQHYFOwI9+1Bs0qKpSk5t+Vayt3KTM47nnMjyu6avUl2zwotoNtjAT/hJBRYX7/ykrU6vbiAjXqgygd+/Lee65n3n0UdeaYd68l7nvvpYMH24hN/cAXbteBMChQ7oIYuB0Ic3JadgVW029XSoq1MRSXTpPUP20b5/ru5a9rKhoKwsWvMGJE/vMLzRAkwr0Rn2t3Y21ur344kt57bUshg8f7dYeX1i5EkaOVPaAt99WhtyFC1U/deoEFzhSEW/a9HfGjevC+vW+k9loY+/AAXjtNZgyxbzc/v17+eyz91mxYjEQHM+mHv6ohjajlgleuLBOMAz4TEpp2n1CiNHAaIDUVO8Gw0CDFmkyPl6vFlLvUp5i//71HtdoRPDbby6xdvfu1Xz//dukpKSRmfmss2wwqIb8WcVZrbBtm/sxbUJq1cp33oVly7L45JPx2O1q6OTmHqSw8CQDB97mkahE252ck9OwEkFNiaC0VI0Tf9poNGJqEsGhQ4tZtepPtGqVTqtWnaqtJyXFxp494ezZk0fPni2d7WjZ0hUepaHzX6SmduLmm11t90c19MsvqtxXX6nviYkutc5FF8GVV0LnzrnMnv02AHFxvk2SRslq/37zvli//mf+85+R3HxzJhdd9LugIwJf7qNfCSG+BJKBrUKI74QQX2ovP+o+DOgzs3dwHDPDMHyohaSUU6WUA6SUA1L8dY4OAGi+84WFrhWCtspr1iySG2540uOaVq2gXTtVbtcudWzTpu/46acZLFjwRsB4c/gLf8hqxw7PnbWaWsi4y3PbtqWsWPEJJ0+qXZwff+wiAQ2VleXs3buW/v1vcDuure6qywpW16gpEdRkI5lRd61JBD16dOfqqx+hbVvz8MlGFBevBGDlStfiRC+RNMZY048dfyLXSqnGEii1a0wMPPOM2rmflqZyWcfGwk03JTF7djkzZ5aRnj7QZ53GCd9blrg2bXpy6613MXCgSl4TDM+mHr4kgkmnWfdqoKsQohOKAIYBfzAWEkL0AFoCK07z9wIOZj7/mh78rLPOYsiQ50yv69tX5U5dv15teU9L60vr1um0b9/bzYhntzfOSq0mqI4ICgo8I46CttLNYsuW8Qwf7vKimjfvJQ4d2szAgbfz2GOfed1bYHZcn6CmIdQdlZXKS+l03B59obzcU32kSQSXXDKYXr0G+11XmzaCzZuhvNzFvPr70hiJkFauXMmWLfs499yBpKSkV1v+xAlFhAkJ8J//KMmgRQu44w71MqK6Xdcabr4Z1q5VRHP4MBw65Bn7KjV1IEOGfOBMXB9sROB1CpFS/uTrVV3FUkob8AjwHbAN+ERKuUUI8bwQ4iZd0WHAHOkrXm6Qwmz1rj1cvuLEn6s80JwG4/79b+C113bz5JPzPOoNdPVQdZOgN+Pbb79lAaMpL3ePvSSlnYiIKFq3VhODt70FYWHhTJgw2C33c0OrhoqK/NPz1xZmvu0aEdQ0XeKgQZcAynNIQ3m5a9w2xsQ2c+Z7/OlPf2D58h/8Ugtp0kC3bur5alFHjujDhsErr0BPR8gmLcG9EYHiclsb+OM1dJsQYpcQokAIUSiEKBJCFPpTuZRyvpSym5QyXUo50XHsWSnll7oyz0kpn679XwhcmEkE2sRw+PAKliyZYXpdz55KtM3ONhdD9fUGOhH4ap8WS8gM27aZx146enQHo0e/xx/+8DKg9hZERrqzqsUSRlVVJVu2/OBUIYHSdwuhJsu6Sm7iC/U9GegzrmnQVEP5+ZvIzT3oWcAL9Bvu9CSpjdfGmNj69j2fG24YSufO3XwuKDT33J071fdu/mnDaoz2DleXw14U3KWlVWzdupHs7D1NRyLQ4V/ATVLK5lLKBCllMyllDZzTzkzoXUbBUzV09Ogq5s59wfTaiAjo3Vt93rgR7HY7x4/vYe/eNUDwSARVVb5X3t4eKACr1VzlY7dXuUVlVWG6pyIcMnl8fCJjxsyka9eL6NLlQiwWl/YzLEwZD6X0L+TF6aI+pQ6r1TMSZ2WlmrgtFsmECX15+um+ftcXH69eFRXuBNOYRJCZOZrJk+dw4YWXe7Wz2GxKDXTvvcpQDPVHBB0cSQS9jdspU17g+uv78uGHbwUdEfjjNXRcSrmt+mIh6OHNr1h7sGJioEsX74aqvn1h3TrlRtqnz0HGjesCwOzZMmg2lVUXf9+Yu1cPiyUVuz3b9JwxUX1GRiYfffQX8vKOcPXVD5ORkWmaxB6Ueig317t4X5eoz8nTTJLSpIFmzapo3vxsYmP91w9ZreVYrduBvhw75vKf11SZjUEEvnYVf/yx2i0cGQnbVQw5ysqU7axT9U5StUK7dur90CHX7m89une/kLPO6kSzZgmNEub8dOCVCIQQtzk+rhFCfAzMBZxTkJTy83puW8ChJtvGjZOg0X309tv/xPXXe79ecyPdsgU2bXJtrxg7tiOjRr3A6NFqogtkIjAzAmvwNRErr5mJKI9hcyW70Rj80ksbsdmsfPbZc8yb9xI332yubdQmuIYggrqcDMrLVXhkDWYqQ80+0KJFOC+9tNGzgA9ERERRWbkF6MvBgxX06qV2O7r2vdSi0aeJ3NxThIdHEx0dg9XqmnXtdvjmG9czFhMDd98NP/0EXbvWX+L4li2V7aGkRPW10QZxzjmDWbp0r/O7GVkEKnxJBDfqPpcCV+u+S+CMIgItVr4W56c6GFcw2oStqYZ8GYtBhUNo2RLy8rKYOdMVITEn5wD//vdoWrWCW27JDFgisNu9JxEpLXXPH2xEYSFImUlUFFRWjvBwDwVISurg9j0hIZnVq+exePE0wsMjiYiI4dNP/055uYr5HR+fxIgRr5OcrAg0mCSCvXuVuqZ/fzWxVFW5Jn09NImgpoZiUCkcf/e7Qfz4I+Tmura8a9JnYxDBLbdczN69O1i0aCulpa7kOidPKhJo1kztCxgwANLT4fLL67c9Qig7wa5davwYiaC8XFBSogg7LEzd/2CJN+TLRrAIeEJKOdLkdW9DNTBQYLX65wZot6uBakypZ7erzU8rVqQBFrKyzmLJkvd91tWlC8B4KivdV8UVFaVMmjQeCFyJoKjIfPKw22H3bt8Ti+YN07r1HxgzZqaHMTgiIophw170uC42tjkpKZ1o0aIdH344zkkCAMXFuUyZci8FBcq2ECwSgdWqSFNzRQXvXk+19RjS0KuXIle9/UQLj9EYiXwiI6OIjo4hIiLebWGl6eg7doShQxUJNBQ0O4FmmNajqEhtBNX2qQSTesgXEZwFfCqE+FkI8ZwQ4gIhgkXQqXtYrf5NutquUCMWLVLZtaxW5Q5ZUnKIKVNGMn36Q17rUgPc3GiqhbutaRar+oJ+stA20Znh2LHqXSq1Ce/kyZ95++176NnzMsLDlbzfrFkyo0e/52ED2Lt3Da+/PsQRRtm8Q2w2Kxs2jHe2o75RnURw4ED1986YcMZqVdeZQSOCU6fWM3ZsR77+umZbgczCTGhtaGgbgd0O3367kW3bSmne/Cy3cxqJazr7hoSW2H7NGvPzM2f+icsui+ajj6YGxHPpL3yFoX4ZeFkI0QwYDNwLvCOE2AYsAL6TUh5vmGY2PvwlAm/+ztOnm2fXWrToHbp1u8TUuKkkglTA02jatq3Lf15LqdeYqKhQBJiU5Dv/gJlKwwhN/11ZuQ+73UbnzgN4+ulvfV4TF5dEUZG2Zdj7eqWwUM2ije01VFioJjSbDTp39l5OP57y85U05a1vNfKV8hg5OQecuQX8RVTUYaA9hw9bsdsjnRsVaxo0ry6gJx7jwkqTCDR3zobEOeco1+49e9TK37ixDMBqraC8vDSo9hJU6z4qpSySUn4hpXxAStkPlbAmBfAZhrqpoaLCP9WQNzc379m1JB9/PN70jJogJqJSNbgQGRnLuHETnd8DQT1UUaFE49xc3wnGfRmQNWiqoRtvHM5TT81n8OAxACxfPptx47owebLHBnV27lxOdHQzACw+tlonJioCbSyJQJustY10J0743tNgXFh4k7TARbIXXXQFr7++l8GDH/S/sUBcnAU4gd0eyalTrpm/MYhAT3aBRARRUa4Nn2ZSwfDhLzF3bikjR/4pqCQCv4ITCCHaCyEuFkJchoo9tFpKeU39Ni1woMWI10I6+IKZRDB3bha+snrm5pqTREwMdOiQCUwlNrY1IEhM7MCoUVO55hqXBBEoRACethE9ysv9a6tSDWWxaFE3Xn75ev7xj4tZtiyLbduWcvz4HrZv/9mt/LJlWbz77gNOm4CZcRkgPDySO++c6Nbe+oLZOJFSBdfbscPdV9+XlFST8BQaSSQnR9GqVScSEmoWl6tFizakpKgbdPSoOxE09Oo2J+cUt956IWPG3O5GBFK6VEONQQQAAx1e38bQ1gCRkTFYLDEIIYKKCKrdRyCEeBkYCmwFtCdMAkvrsV0BBf2KyGZT7mmlpZ6eP8bk66BI4G9/G+11cgLv+YpBqYcOHcrk9tszue461/GSEldkxMbavKJ3p/VnYvUlKeixZ48KL1FcrFRpOTnZvPPOSKqq1KxYVlbAsmVZTnWa96T2As1eEB4exQMPvMfFF2fyzjv1T55mk0BpqTpu3BFcUOCec0GPmhDW6RqLhRD06NGOkyfhxAnXwqUxJIL8/AI2bPiV9u07uvWBFpsqLq72//N00a+fiu+1bZvyAowxJIHT548OFvizoewWoLuUsp7XUIEHu11tudebyG02NfkVF7uIQAv8ZiYNTJo0nrIy79ZRLS+xN/ToAUuWqP0EeiLQT6qNtfIoLVWkGBbmHxn5SwTHjnmGl9BIAKCsrIhp01SM+oyMTK9qNyHgo488O0eI+g+tbDYJePv/vtQ9NcnKpRHMkiUvsnTpMW6++a+0aNHG90UGaAZjJRGogd8YRNCqVVs+/3wFRUXuHak3FDeW60psrNq0tmePstmcfbbr3ObNP/D991O47rrL+fOfvTuCBBr8eQz2Ao1simwcVFSol16HW1mpVgF6kT0/X02KZqs3zbvHDMnJHRk1aqrXXbCgjFMAmzbZ+Mc/rmTWLBW6Wj+pNNbKw2pVk5i/k5U/9oHycrDbvfeZ67dLnbYVb4HnvElamhRTX1FBwXzi9EYENpv3vvG3jdq9CAuD1avfZsGCN6isrPnaTUsL+uOPP5Kff9zZhoYeY5GR0fTrdyE9e7onl9fsA43hMaRH9+7qXQt0pyEn5wC//vopGzasCiqJwFc+gslCiDdQS7MNQogpQog3tFfDNbHxYGbEs9nUpK+Pj66FSzCmWgRo1858MkpO7miaatGIli2Vv7TNFs7OnYLVqz93/mZji6BabBt/Jngp/ZMIfvsNlKdU9dBsK2aB56Ki3CUtq9V1MzUiqE/1kNk98dVP3qQCf0lW87RKTITMzJf44x9fpXlzL/omH0hKUoO6rKwF33//trMNjeU1ZFxcbd6s3usrjIS/8EYEvXpdzqOPzmHo0EeajI1As4mvBfxJRNPkYLbCr6x0PRia26YmOptNLE88MZG//nU05eUuVYcQvtVBRpxzjopEmpg4iksu2ew8XlzsyiDVGND+tz9EcOSIf+1cuxZgImFho6mq8r3hQFvx620FubkHSElJ5fHHJ5KamklCgo0bb4zGbq9ixowioqPjG0UiqKpSpPntt68za9bjnHvutTz66Byio9VW9aNHlUeKPqG6lnvCH2ibmJKS4JJLPL2qQI3VmBi18zU/35xkUlKUviUqqie33aac5v1JClPX2Lp1C/PmzaNFi3NJT1exWKxWV2j2Af5kTa9HaIHtdu1y5QcBaNWqE61adaJ798DY3+MvfBFBAfCLlNJHMICmCynNicCoJgLfK/JbbsmkshKef/5RiovzgFQ6dZpYrSSgx7nnqtR7sbFDufPOoc7jGhE0hkRgjK7qCzk5cNCPiMh2u0rGA5nccQf88IOa2OPiEikvL3LLLRAd7U6m+kBznTop4+vRo9CqlWuIZ2dvpHv3S5x2gYaUCDSy3LbtJ+z2Ktav/4Zjx3aTlqaCSmlhlLt3V/cUakZUmsutPr+zHunpKmyJBilVsDajx1Lz5mpSq6iIxWpVpKG1oyFj56xfv5ZJk8ZzxRV3OYlg0yb1THbu7P1/NhRatFD2lGPH1CLNuLu5MdRppwNfRPBH4E0hRCnwC7AcRQybfVzTZOCPOOyvEe33v8/krLMymTkTFiyA88+vWVu6d1erxUOH1EpOi3GiuWo25MpDmwxqYsT0lnzGiD17lIokORliYwsZMOBmLrzwTrp3v4Rly7KcK/62bVN58smJpKVlUl6uJi79pN5MbSdw6rs/+GAdlZWdnatvbfXWkBKBdq/uuus/HDmyg9atOxMV5RlwKj/fRQQ18RjSiCAhoZR//etOBg8eQ//+agK1WNwlDVD3MCHBkwgsFjXJHj+u6mzb1k5lpcVpXG+o2DnduvVmzJiniY11hdJetUq91/T5qS90766IYMcOFxEUFeWyYcN89u1rRufOtzRuA2sAXzuL7wAQQqQBFzteDwghUlH7CK7zdm1TgD+JS/xlfa3M/v3qPS2tZm0JD4fUVDu7dln43//+x3333Q40Tqz4oiI10fo7iUrpf5auDRvUe//+8PXX/+Lkyf1UVlbQvfslzhV/fDz06aPKFRYqgrRYFInk56u+Mrr1wKMTfAAAIABJREFUnnvuOU7dMtAoEoE24aakdGTSpC1er9OHl64J2WqqoaNHF7NhwzcUF59yEkHLluYTuLcAihoRfPjha+zZ808mTFhNZWXnBl1w9OlzHt27n8eqVS7pc906dS5QiKB3bxXx9Oef4fe/V+Sam3uQt966m/T0cxk1KniIwJ+dxfuBdcB6YANwAojxdY0GIcS1QogdQojdQgjTuMBCiDuFEFuFEFuEEB/53/T6hT8PYWWlf6u2AweymTjxWnbtUuxSG0NXu3ZKD/P990uxOWYwm029GpIIKiuVmsNfIigv919i2b1bvffqBZ06nUdiYgfS0vo5z4eHu28iSkhQRBAR4VKpaNKAHosWZTF2bBrDh1sYOzaNysos53+pL+j/s93ue6OdHnovtZoQwcmTakyUl2/miitGcccdzznPmYVBAOWLbwZNhVRQEE1x8Sl27lze4C6kdrv7QuvECVcIk8baSGbEBReo8bZ/v8tonJCQwiWXZHLBBTc2DdWQEOJvwEWocBI7gJXAf4HRUspqtcNCiDDgTeAq4BCwWgjxpZRyq65MV+CvwCVSyjwhRKvT+TN1CX9Wi9VNJDab8iTaufM3Nm/eB0STmFi7jTBpaRH89BOEh/entDSfhAT1dFdU1F/8dTNUVbncFP2BP4ZkUJPMXkco986d4YILPnM7HxWl/LXDvYxYIVQseuOEO3duFk89NZJKx83KyclG5TkAm81/O01NoZ8EVFhtWLfuG3btWsGAATfTunU6JSV5ztzLehQUuOvm/cHJk1VAOCdOLOEf/3DFZYqI8J67Nzxc9atxMaPp39PTb2fcuKto3Tq9wRccBw5kc+JEEaWlZxEb25zjjqhmmrovEBAZCYMHwxdfwLffqj0/iYnteeSRWTRrFlzGYl8Swd1AO1SAuSzgIynlen9IwIGBwG4p5V4ppRWYA9xsKDMKeFNKmQcQSIZpf0NO+3o4iouVQS4urgOtWt0J1N7tTQt/27nzCCcJgOZ3X7s6awO7Xa1U/c35a+ZSa4acHNVfzZqZr2Dj472TgAaLxZNkJ00a7yQBF0pR4b39a1ttoJ8ENLXQmjVfMHfuRH74YSqjRiXxyis3ml6bl6f85X3lbDD+Vn6+Wg0MHeq+iSk11beB10w9pPW/1ZriJKqGdCGVEiZPnsBtt53NihUfA66+aNUAS8Wa2EEGD9b2bniq9YJJIvBKBFLKHqjV/BrgcuALIcQqIcQ0IcRIP+puD+h9RQ45junRDegmhFguhFgphLi2Rq2vJ1RV1c1NLC5WdTVv3pfzz/8ncPpEoKXJW7ZMqTvOP99CRkYaWVlZp99gP6B5Cvk7KfgrEeilASHg+PE9FBefwu64EcZt/P7C+4a+Aw1mI9CIoG/f6xgy5HmuvPIBoqPjiYkxT/2dn6+8rPz1yiopgYoKQUwMXHqpi1zi4909hcxgph7SiECfSrQhVUN2OyQnt6ZTp17OvRANSQTV9ZkeiYkqDIyUiryllJSWFnDy5LGgkgh8rrGklKeAr4UQC4DzgMuAB1AhqWfU0e93RRFNB2CpEOJsKaVbRlYhxGgc8nxqqn+bjU4HdbVS1Ksp9u1T77UlgubN1YNdXAwLFsxizpwHnPF1Dh/OZvRope7IzKw/dQfUnCD9lQj0RADw5z93x26v4rnnltG9+yW1JoJ27VI5fNgs93FqvUsExcVqQteM5QMH3sbAgSoD7PTphdRVeg/NYygx0X3178/uW18SQW4uzJ79V44d28Vzz72L3e5Fx1THsNvhiScmMGTIBLcorVD/RBAWplRjNYlO26qVshGcOAE9e0ruu0/104EDVfgZ17PR4Wtn8U1CiJeEED+jDMSTgCTgccCfACaHUcltNHRwHNPjEPCllLJSSrkP2IkiBjdIKadKKQdIKQek1ISua4m6Wilqq+Hjx/dw6JD6Utut8cplcy0As2c/6hFkrbS0lPHjzcNZ1yVqEuDOZvPfBdJIBNokqcXKqS0RPPHERGJi3N2IhIgFJta7RHDihPfIonWZ40kjAovlEEeOuLa6ejMG6xEX56k60mwEp07B6tXzWLXqfxw/frjBVrjaGNOPHc1GUN9E0KyZf/2mhzYlnTihQqAnJLSiefPWlJQET3g2XxLBPai9A38B1jr0/DXBaqCrEKITigCGAcYtj3OB4cAMIUQySlW0l0ZGXawU9SGXv/hiIoWFrwHmXi3+IiJiN1brdior80zPH/CWuqqOUNMop/66jS5enMWWLeOBA0yfnkp5+URmzXK/CbUlgltuURLSM8+MoaSkiKSks4iIeJFjxzLrXSIwSk+bN/9ATEwCnTqd5zNnQk1gs8Evv6jPBw/OZ+PGMtq1644Q/jkRhIUpY7I+ImpkpJJACwqge/csrrrqCC1btmtQ1RC4vKakdEkE3qK0ng60vqqoUM+nxaKM9f7awTRy0lRpU6Yo1qrOphVI8GUjuE1K+SrQwkgCQohqM15IKW3AI8B3wDbgEynlFiHE80KImxzFvgNyhRBbgcXAk1LK3Fr+lzqDtwnC34EB7mqhqKhEIAGwmSatT0vzLwpm69YLgbu8nq9vtZlxYps7N4uMjDQ6d1Z2irlz3e0U/hg7338/i6lTRyOlSuGZl5fNtGmjWbbMVVd09OntaL3llkxKS5VE9uc/zyUxUZFDfUsE+vqrqmxMnDiYv//9AgAWLnyTxx7ryoIFtQ/bZbfDxImwfDlYLFX06XOS1FQVpTAmxv8+M242A5d6aMmSfvz88/XExbVsMOOn3Q5DhmRw//3pHD++l6Ii9ezFxXnf+3A66NZNywboWqhpUoE/Cgi9RFBYCCtWKPJqrPDwtYE/nPV3IUSFlPJHACHEX4DfAe9Ud6GUcj4w33DsWd1nCfzZ8QoYmBFBRYUSlf1R7UjprhK49dZJLFwICQnhHg9nfLzaqh4WpjZFecOyZVns3TsDb/l4Y2JimTjR//hFtYF+YGt5FrQQ24cPZ/O3vyk7xS23qB2/2iYnwLkzOCfnAMnJqQwdOpEBAzJZuNAz5LQWWVQLGWFGnjXF2Wf3p6ysgoiIqAaLNaTvr8rKCnr3vgK7vQqLxUJFRSnHju3m5Mn9tf6N1auVV1rz5vDEE2F06eJSDdZEgkpMVKo5/Yr/6quVS+T+/WpneFVVwxqL9+7dwalTOURGxtSbfcBiUS7H2k7ulBQX0cTGqme4TRt3o7kZ9BLBBx8oYo6KUjHCGjIsx+nAHyK4CWUwfhK4FuiBpxtok4LZSrGw0D/DZ3GxMhzpJxkt6qbZakbzBkpJUSsKbxuPVMhl70/if/87tUENxWZ5FsrKSpk0aTy33JLpjBsPigSmTRvttGvk5KhV/8aNIKW5OisnJ5tHH+3MG2/srbVaSI9581YjpQpq11DRR/VEEB0dxzPP/OD8fumld9O//40kJtZud5SU8PXX6vOtt7pWtBpq0mdm6qHLLoNLL4URI+yUl1tYufJnBg68tFZtrSnsdli0aCeLFx+jefPWbHXsPKprIujVy/2Z7NTJJZnHxSmpyJ9+TExUfZif7wqK9957r3PxxVfTs2fPoCACf3YW56DI4E3UvoI7amEvCBpokRaNao8vvsjyS+edl+e50tSIwGgfSEx03+zjSwz1nvMYkpPbceed9UsC4D6xeXPLPHLkALm57qsoswxiVmspv/wyHl8hp/PyFJvUBRGAWpm1aNFw+Qh8qQZatGhN+/Y9iImpndFo5061EzsuDgYNghMn9lFaWoh0LNtr2mcJJp6sQkBMjFKpff31/xpUIoiLa0n79j2xWCz1IhHEx3suzPTq2dhY9TxaLGp17wsWi0uVpj3rp07Zyc/PCxoXUl9eQ0VCiEIhRCGwG2XIHQJox5okrFaX2uPw4WyklBw+nM2//z2ahQur99U3iys/ZYpKJnPqlCvgTVycZ8RCo/ufHt6SrwBceeUfGkR/q5/YvOVZSElJZdcudzWCNxKz2w/QooVnLoHIyBgGDbqHkSP/C9Tci8MM+fmnWLt2BTk5uxpEIjASgazjGeFbx+bhq66CyMgqxo1L5/77WzhTotaUCLyp31q0UAOydetLG8xGoOUI11AfHkPedltriIx0jbvo6OrrMy7ievceQefOZwfNpjJfxuJmUsoE3StaShmvHW/IRjYkrFZztUdFRSlz5ox3GozNJvyqKnPVTnGxmnnCw10XtW/vuYMxPNzccAfmyVcAWrfuwvXXj26QAaf/DTO3zMjIWIYM8bRTeCexVB59NNMZilmV7cioUdN48MEZXHHF/YSH141EcM89v+eOOy7m9dcfqXeJQErP/BRr1sxjxIhY3nprBKDG0+zZT/P++4/WuP7CQlizRi0aBg+G0tJCkpM7kpR0FmFhSttb0z7zNtm1aaOWzd27395gq9vVq39l/PiR/PTTTMDlWqypUesC1RGBHv4QgZGkrNZEYmKaNQmJIM3XhUKhDm9NYKCy0rvaIzf3gDMlpdmGE2/6/csvfwKAnj37OI95cy3zph7KyMhk1KipREd3BARxcR15+OFZvPbaLtq169ogA06/wr3llkwee2wS4Y4/4ivtpjmJxXLbbRPp2RPnKrZPn8EeWdvqykukTZv2WCxhREVF1Hv0UbNcDWVlhVitZUip2DQsLIIvv3yZhQvfdP5/b9ASsmjulMuWqfrPPVf5/MfHt+SNN/YxebLaOFcbL6uoKPPQCtqEeepUwxmLt2zZxJdfvs/27UspKlKb8iIiPCXomqJdO2UYDg+v2biqjURw6lTdRShoCPgyFr8ihLAA81BZyk4C0UAXlNfQlcA/UJvCmgysVu+7UZOSUiktVUZjfeiEo0fNY7trUFskICXFJUh58/Fu3tyV9cyIjIxMCgsz+fBDuPhiyMhQxxtqwBl/Iz6+PTabjfDwCCZP3u/1Om1if++9hykvLwRS6dLlboYMUcfHjfuMvXvXkpSk9h8uXz6bpUtn0rv3Ffw/e+cdHlWV/vHPmZlMkkkhkECAVEqk2hBdC/bOKou6P1mIiOIalWJldSW21Q2ufRVrVkVXR0UsyO7qsi5rAaxgAQUB6RApSQjpbeb8/jg5c6dnJpkJIeT7PHmS3Llz58y597zvedv3nT791oiM/dlnVYtPKeHKFoKUcNg9w4G/+MDJJ0/muOMudgl9iyWG/PyHsdl6tGQSmVveK3n33T8zZMgYRow4nY0b4ZlnFH3BmDEwbRp89JG65umn+//8UASXP9hsvpsZrQh27NhPY2MCoeWXtA+/+tWp/PGPf8NiGcRPP6ljeXlqXYQLTaonhMoAAqPvcagIxyKIj1fyobzcwerV33LkkQe4lVqICOYa+j/gTmAIKlC8FKUUfo9iIz1DSvlhRwyyo6B9k4HcHhMmFFFXp9IiGxqMHWV5OaxZY/SN9Ya/YHEwFs1g3Zf0A7d7N6xcuYgFC+5h9erPO9wiAEhJGcSRR55PWloW77//16DvHTMmn1//ugJ4BSGa+PnnPzNzZi7LltlJTc2kpmYfd9xxLBMnCoqLr2LVqsUsXfr3dhXg+YN7oVW0LAKHw3euhBDExSVisylWvKYmyM6+hVNO+T0Wi7ErWLduGQsW3MWf/3wGzc3w4IOG4Fq+HN58U/FNJSeDEP/ikUcu4o03ZvP44xOoq1NSvLXgZiD4cydpRfDf/y5k69YtbbtwmBgw4DDGjv09I0acztq16tiwYaG/Xz8zMTGqZ0BWltqxW63qJ9x+IHpeghXoHXaYmveTToKYmCqkNPP116sPGtdQa1xDa4Do8xZ0Eugdoq5GLSq6ndLSHfTs2Z9Jkx5gzJh8KiqMRV5ba/D/BMsSWbFiKXAydXWbAUU2FKzqsHfvwFwnurJyzx549dVZ7Nq1gYqKLUyefEJ4X7YN8P5+aWkjGDv2Ju6//xzs9j8wduyNQd+/ZIkdKEBKzzTS9euX88knL7vcJo2NdQhhonfvAVEpINKCMloxglDaeM6dq+oAjjwSbr7ZEDL9+g0hJaUfmZkjKC1V8YCUFNWj97//hYUL1XmXXAIbNnzKihULWbFCHezVK5PJkx9pMy25P0Wgc+wtllz27w+xqUI74R4s1opg6NDQ3z9okNqVm0xqXjMyPK3ZtrrNhgyB1av9n5OWBsXF6rzvv3eydy/07Dm6S7iGDjm4uwry8kYRG5sESPLyjne5N/QCX7bMzk03FbJ79zZSU1WBVKA+xFVValvgdJYCA1pdqAkJhonpDa0I9u6FUaOOpKamgrS03A7Zebg/1PX1ai4yMoYRF5dIQkKAKHcLXnnlBSoq7sNf8diHHz7jc76UTnbsWB1SxXUo+PbbL5k06XSs1ljOPlslzHekRfDvfz/B5583ERc3mREj+vD11+r499/D/ffXcNddCQgBPXr04ZlnVNqs7tiWkQG//a3qhNXQAGeeqbKF9uy5huzsIzCbLSxd+gonnjgRaLtF4C9zSFsE/fqdypAhbbtuuPj3v9+jpMRMWtppbN2aiNmsXEOhID5euXK83TnteY50r4uEhODUE3pdZ2X1YO9eSEg4vGtYBIca3BXBJZccQ0ODksR6p6oRqEAK8KsMEhIGU1MDubkqeyYUDpLUVOUC8IbVqnZp+/ZBRsYCxo1ThTHR3nk4nWqnVlmp3BKKBXUuzc2NPPTQj34zg4xq4q2AIFhBnD8Eq50IFwkJidTX19HQUB91i8Dh8FUya9Z8yvr1jwF9WLVKHcvJ+ZitW4/gp596sWmTbzBUW4V9+6rY0YwZisX2oouUcEpPH0h6umLpO+GECa73RdIi0IrA3RKONu655wZ27tzKNdfsRMpEBg0KXblpCybS0POQkNA61Ywew969B09zmoODI7WDoAWDlBKHQ63kxx/fxM03v+M6Z9kyO888M8VvgZSq/vVFTIzipcjMVNv5UBVBIOig18KF8MQTHdOuUl+/rEz91NTAm2/egd0+iy+/fMvnfK0slRKA4ErAv62eltZGqlY/yM3N4+GHX2b+/E9du8VoKgLv+zF69F1AFlarE5NJuRnOPXcraWmfAioTCOCtt+7hlluGsXz56678eX2/R4+G//u/1p+ftloEVqvvtVUsQgWRQyURbA+cTjjttPMZNeo8qqtVkkVWVvD3mM0G9Uu0FIFGKHQniYlqA7l5c8VB4xpqVREIId4RQvy6JYOoS0PveIQQvPVWI089tZM+fYwGAlq4BUr3Kyvz3cFKaWRiaH93KDu2+PjAueAXX6z6pVosatexb199hymCpibYtk19p/T0QcTHJzNo0HE0NzfT3GyYVP6qif3BarVx9tnX+q2RGDRoRMTGb7VaueSSyzn22DEdogi8LYLSUkUGN2aMieJiKCyE00+fwo03qgbnn3xSz759pezevZGSkp948slJrF2rXET+GDc3b/6WhQvnsGHDFz6vtad1qb9qW5tNCbZHHnm07RcOEU4n/PnPzzB79gfs3au+SN8ApPdZWUa/6uxsZRlHOrnAG6EUN+7b9yUA33yzpktZBE+j6KM3tPQn6CBPYcejuVlVFZ90Ui7jx5u4++4TPVgwWxNuqam+7pGqqnocDrBYmlwLNFR62kBWwciRcOONEBenfEezZ0+KKl0CGIrgP/+xU1CQy4UXCrZtW0VdXSX33XcakyfHsGjRg67zQ3Hr6NqDqVOf5uqri33cS2PGnBXR76Ch578jYwTffKN+H320EiY6FXLgQEhJqaSuLo5nnnmNKVMe5/DDzwagvFxpLH+CcNWqxcyfX8hnn73hcTw2tn0kZ/4EaXy8UgQbNpRHXbDp6zc1ebrGvGGzqdjJqFEGPYY/moxIIxSLoHdvtdAdjr4HDQNpKFxD/5VS5gOjgC3Af4UQnwkhrhRCtCGzt3PC6YR331XUEiUlihK5tHQrTz11GZdfru5+MOGm00u9sX27arHU3PyL61ioiiBQlbFGUpIi9GlszI4qXQKo+Vm40M6TTxruHm0Z6d9r137qOj8YJYZ6PYe5c7eQkNCTt976E7175zJ37lZOO+0qLrzwVp5+eifTpv0hYuNfuNDOiBGJDBggeP75DMDeYVlDFRWKWdZsdjB0qHfxgmTYMPVcrV5dwAcf9OKaa17iscc2U1ur/Bz+qBUGDDiGsWNvZtSoCzyOt8caAP+KoG9ftQ0+++ybom55VlfXUla2DymlSxH4a1ivx9nRhG5Wa+v1DMcffyIAFsvAruMaAhBCpKIa1fwe+BZ4HKUYukwdgcPhn1oCoKmpDillQOFmMpkDVtXW1Kgn1Ww2Uu9CXaw2W3CqgOOOOxyAM8/8q4ssL1pwOtX8NDQEtoh27Vrv+jsQJQYopfmb39zOa6/dxqOPXszbb9/Dn/98JsuW2Rkx4nQ+/3w+06dncvLJvj0O2gLNHaV7EtTWlgAFrFoVnT7P3q6hlSv18cVYrYaGKC/fyeTJsXz//bkcfXQNEMc778Dmzf0xmXJxOAS9evn3+R9xxNlMnvwIhx/uaTW1NT6g4S9dt3dvddGmptSobzjee28ho0f34oknLmfvXiXo/SnCaKQVh4rW3EM6TrFv38HTkyCUGMG7qGIyG3ChlHKclHK+lHImcABvR2ThcARrdC6QUvoVblarjTPPLGD+/EImTjS5iqQAvvgCvvsuF4ChQw1/dzidi4IFjbOy1IVKSqJfXex0BpsfBfcYyZgx+YwbVwzkALgqZ9PScrjsskd44YVr+cc/HqS5WbXza25u4Nlnr+S556ZSWmqQ/c2eXdBuZeBfwdeydGl0SmS878Xy5UpDDxq0lZgYI68xMTGVhISeZGbm8oc/2JgwQZ336qs/UVKiLpCeLlm+/DXq691K2YOgvRaByeQrZPXuu6IiukR9ALW1dSQmJmOxDENKlZ/vbwce7VhAMPizUNyhN291ddFluI0kQrEInpBSDpdS3i+l/MX9BSnlwVE/HQIcjsCMmmlp2ZhMJhffT1paDkII0tKyOfbYi/jooxdb3CXSlUq6eLGdJ54w6ADcd/bhlMoHo6bOaKGy14ogmrsPpxP69g3u7vGOkZjN+cAWzjhDYrc38/rrkrlzt3D22f4b3DkcTR4BZzB6HLQHgRRYVVXkW3vqe6AFZlkZrF0riImB2bOv8+hVbLXGccQR53DYYSchhOD446uARnbvzmPBAtW7oKJiKU8+mc8///mw632NjXX88MP/KCvb7vP57bUIwFfIxsaqL7V06cdR3+FOnnwVn366n1/96o+Af6EbE9N2Go1IoEeP4Otyx47VgKIT0KwCnR2hKIKeQoiLvX7OFEJEuY10x8LhCE4toTFmTD5z527htdecXHvtPJYvt7t2tRqNjbW89Vahh6vGne0wHEUQGxvYDG5qUmWOO3c20dAQfYtg5szA7h5Q9RTuFtF336ntUHn5S+367NYskdYQSMELYcJuj6x7SAtK/Xv5cvV71Cj/gcbp018hP/9BFi9+knnzLqVPn1WAmU2bVBOYYcMy6NUrg379DnO9Z+fOtRQVnclf/nK+z/XaaxGAr+vDZlPKa82aNdTVRXeLq1lbd+9WoslfoPhAuoU0cnICxyeUsldMw/v2HRy1BKEogquA54H8lp+/AbcBy4UQgRvoAkKI84QQ64QQPwsh/ujn9SuEEHuFEN+1/Py+Dd8hImhuVtQS993nvuPPYcSIM3j//cdYuvRV17mTJ8cxaZIZsznwqquuVsJr4MAvgfl8+eW5rtfCbWqtm154w2xuQsXvY9i2LfoWwVln5TN16tOkpXm6e9yhLaKPPrKzYYMZcPL9955BX6UoQo/yBRLkocKfggeQ0kFBQUFElYG+B3V18P77Rt+Ao46qoKmpIeD71q1bxqpVizn+eN0mLA6rtYazzsrmr3/dyEknTXSd63Q6GDJkDIMH/8rnOpGwCLzjUgkJSkwMHnwaDQ3RNQmcTuVO+aXF9+BPEbSWRNERsFgCu6f69TuMPn2UyVBZeXDECUJRBDHAMCnlJVLKS4DhqOqgX6EUgl8IIcwosrrzW94zUQgx3M+p86WUR7X8PB/2N4gQ9M3askVlskya9BBz525h06YVbN68kqefnsyUKbl89JGyAKR00rNnRlCufSEgLu4B4HdUVf2HmTNzWb7cHrYiCFQk07fvYHr3VsJl06boK4KmJnj11ZupqNjFjBmvYbc3u5SCOxoba3n99UKcThMxMT8yyKtkNljbTXcCNlC9mGfNal8v5vHj85kzpxizH57l2tpaCgsjFyvQVtm778Irryi/ep8+VTz3XDoPPDA24PvOOutarr/+Dc45Zyg33wwFBbtobOzJk08e4TMngwYdyz33LOWaa17wuU4kXCbeykQrht69h3vEOKKBK664lBkzTmfbNhXT8VYENlvgjVFHI5AisFisJCUps7+q6uCgog5FEWRKKXe7/b8HyJJSlgPB7MTjgJ+llJtaWlu+QSfudayFqGJZ/I7vv/83y5bZqa4uc53T2LiVF18s4PLLH+e++74gNTWLo4/+Nd67W7PZBhTRp4+dn39e7Dqud8vhBj9jY/0/dDZbMscco8o6tm6NvmvoX/96lerqcpqbG3j11VtYtsweMKW2qmorYOfyyw/nvvs8i56CpeFec82L9OmjLLKMjBzmzCl2kQC2B+PH5+MMMEHbtkUuVqCfI10VfMEFMHnyZyQlJZOcHNixPHz4aeTmjmL79h/IydlMnz5r6dWrD9nZqhCtpGQdX3yxIGins9jY9nHqaFgshtXq3hiopsYzWBwNl8eKFV/w7bcfU1bmv5gsmEumoxEsYK0V8sFiEYSyN/1YCPFPYEHL/5e0HEsAKoK8LwNwj2btQFkR3rhECHEKsB64SUrpEwETQhQABQDZ2e1zEwSCw6HSDHfuVO2Qtmz5li1bvsXh8NR1zc21vP/+o8ydu4Vly+wtXZTcV4TA4ZgC5FNVletTgNbQYDR4Dwe9evlvfNNDsRpHnQvmrbfsPPLINa7/Kyp+4W9/KyAxsZer0JvlAAAgAElEQVSHsvREQUs8xPO7pqVlu1FPuB/P4eST85k5Mz8iLg5vBOozEclnSt8Dfa8GD4bRo89l9Oi9gd/Ugi+/XMD8+YWMG3cbEyf+hSef3O6ilr777pOori7jySe30aNHuo+VAJENoMbGKqHfo4ehCEpLq9i1q4bMTCWd6+sj109a4/XXP+Czz3Zx553KenO3huPijOe9MyCwRQD79v0EDGXXriqczgOY4hQiQtk/TAfmAUe1/PwdmC6lrJFSBmiNETL+AeRKKY9A1SS87O8kKWWxlHK0lHJ072Dh+nbg7bdVrnlVlWoqUF1dFlDAlZZu46WX4PXX/VUaS0ym9zn9dKitDdzgPVwE8ouuXr2gZUy1UVMEdrudG2+c4lNDoL97TEygAHItr78+i+pqz0YNgdJwJ0woom/fyPi5/cFfrMBms1FU1D7Xkzt0DYHOFikt/T6k9zU21rvoIjIzVSc7IQQ2WzJCCI488jxGjbqAhoZabrllKNde29cnayiSikBfy2YzKnZLSnbzySf/xuFQBI0NgUMebcZhh41g0KAzaWoSPiyikehdHUmYzf7HlJgI+/dvAGD79lLXuuzMQeOgiqDFz/8/KeXbUsqbWn7ekqF14t4JuNNFZbYcc0FKWSal1I/T88AxYYw9YpASHnzQfzGZf/Rj8WIoLw/clL2gIHB1bVuCn7Gx/rNO1q5dBMCePVVRUQR2u52CggIcAS5eXV3O8OHFAd+/f/8u5sw5x+OYbxqu0eYymoFAHStISuoHCGJjsyguLiY/v/2uJw2dxlterp6l+fOvoaYmmOGsIfnmm39gNls8AsMaM2a8yh/+8A/S0wexf/9uKiv30qOHJwlRJHfnWgAnJBiKwGxOJTk5heZmZQ1EI0fe6VT8WeDbVzgUeoeORs+eqpey+9wnJ8OgQaqBQkxMmkcCQWdFa41pHEIIpxCih5QyQCPGgPgayBNCDEApgN+hOItcEEL0c6tNGAesDfMzIoLm5nB26TZAcerExGTT1OSvpaVq5TxhQhFPPXWZx2txcW0PfiYl+TJA9uuXTkkJNDbGRyVGUFhYSG0Q2kmLJZvNm/NR/Yt85wLwEViglIF3JXa4vWTbgvHj87n33sXA3+nT50fy8yNHbAdGUL2uTrk2LrtsNgkJrXdKt1rjOeWUKSQk9KSxsZ64OP/bX7PZwosvVlFRsctPYL3949fQVll8vOGOMZl6cs4543E4lFCL9A53w4YNPPXU39m16yzgVB9F0NksAlBKANR86GY4CQkwYEAeq1aBw5HkWpe1tZ1TmUForqFqYLUQ4gUhxBP6p7U3SSmbgRnAYpSAf1NK+aMQ4l4hxLiW064XQvwohPgeuB5FY9HhsNvtmAJG2XoBKk0hPj4HKEb7vE2mopbAsAGTycbvfnc/oITd2WdPIy4uCVA73/vvb3vw059PsqBAFRo5nclRsQiCB1JtNDcXtXTR8u/umT79VW677V8hfVaPHh0TCMxoqcSzWCLs4AaX26S+XknSU04Z18o7DFx33UtcfvljAZWA0+mkrGw7JpOJXr18Kboj7Roym406FrNZKbiGBs/fkcTq1at5/PE/83VL1x7veEBnFaJgzH1srPpxD7Drdene3razIZRg8TstP2FDSvk+8L7Xsbvc/r4duL0t144U7HY706YFcn3YOOmkJ5gxQwnu1athzhyj92l1dX5LJ7FCYBuQzbhxnp3Kpk59iqlTnwKUqRtOyz1v+M8cUr9raozmMZEUptnZ2Wzd6m+nbwaKESIfKeH885VbZ/78QsrKWu/a5g8dFQicPft+Jk2CzMyBEb+2w6ECxY2NysKJVLzD4WjmsstUSuK8edU+ysJkimxsxd0VqQVbdTVUV0sSEwVSGu1Z/WTltglDhgzhppvu4euvT2fTJt8izEgUy0ULWhFo2WAy1QAJbNiwBYcj19V+s7k5/DqijkAo7KMvA28CX0gpX9Y/0R9ax+CGG24IEBtQgu6yywxBNmIEnHceFBQo7nOAurp8YmO3cNddTk466SYWL57OxInCo8JWo700ubGxvouhqUlRNFZVaSbQ9n2GN4qKirDZfHf6QryMEPnMng0XXgjnnKMsoOzsw0lPH8wddywJSwlAxykCLbgivaPVwrGsJccgLq4xSEZVeDCbLeTlHQ/A/v27fV6PNOWC1Wq4YlTDGtWW69prp3jMWyTncMSIEcyYcTe9eqlQobsiiHR2UqShlbBO4W1qUh7vH39cg9NpdD/srBZBKKRzFwLfAf9u+f8oIcSiaA8s2rDb7aSlpVFWFmihOhk1Kt/1MKocdCcjRy5i8+ZbsNnWuM486igoK7Pz+ee3UFenQimlpVt59tkrufXWI11VyZEgynK/xrJldu68MxswsX//QBYutEfcPZSfn89jjz1J375ZqHqJHKQsRsp8Bg9WvREmTTIE0erV/2XXrg2sW7ec667rx5QpNr799v1gH8Hw4aq5SLSyhbyhKT4aGyOrNfXc60equno9a9d+ErHr33DDAu6993NXe0p3RFpQCmGkblqtEBen5qqszDNVKJKCzelU16toia27bww6Y3zAHe6uIYCMDOVOTk7OdbkL4SBWBMA9qOKwCgAp5XdA5G3qDoTOhAmsBACy+VVL1cOUKQnk55tZu/ZjPvjgCf71r0fZuPGvrjOPPVa5RLw7lzkcTWzfvoply5QiiMRi1YrA6JbWhKpj2Mbtt0eWLkFj2bKl7Nq1HZvNDmyhqUnt9A8/3Pfck0+ezEknTSIn5ygqK0tpbKzzS0Wh0aePspSi3WLQHf/5j2qt+d13qyJ6Xa0I9rWwRMTHN/sNlLcVqamZLqvAHYmJgbt4tQfago2JgeRkJenuvNPz+YqkRbBy5XesXv0t5eVKWrpbBJ1dESh3kGGx9+unBp+aOhyn00i17ayKIBRvVZOUcr/wdDwfBEXTgdFaJoxCEUNcvdhUekRZ2Q6ysg6npOQnhg1LpKxMLf6jj4YnnwwcVN248Ws++8zO8ce3P01RLwh/3dLq62u5++5Crrwyn8bGyPlUq10Uip41HP4UwdVXG6mkd975P3bv3kRe3gkBr60ZVDsSPXuqraaUke2+qt1yWhGMGHGU2zMUHfTu7dv0PlLQS95qBZtNzdX+/Z4iI5KK4Kabrmf58qWkp1cCSR6KwDuDqDMiLs6wCLQ1U9PCHq5TRw9mRfCjEGISYBZC5KGyez6L7rCii9YpBVJJTs53NcR4+OG1JCWlEheXyCmnXM6UKY8BcMYZyies+E/8V8sC1NSUU1xcwMCBtJsuQbvrA9E07NixjdpaJZQipQheeulNbrihmSuuEGzZomgT4uNpVcgNHXoyQ4ee7HM8Lg7y8pQS7Sh3kDtOOOEUAPLy/GiydkBbBNq1Ee1dbFwc5OZG9zNAWQT6uavwKoloaIA9e9Tz0F7X58CBeezZs59du5TprIVpSkrnDLB6w10RaAu3qqqZysoakpPVl+ms/QlC2RLNBEYADcDrKH7VG6M5qGgjGKWAxWIDHmfwYGNH1Lt3DnFxvgnuOTnGQgzWkQsMaon2wmxWD1ygYrWMjGyqqiJLN+F0ghAWysuVi+f88+Hii/1nJ5WV7WDhwvt55537Al4vN9ezUCmacBdiGgkJarU2N0c2V1UXk+1vqbiJdvOUQYNCz9iJi1PV6T17qr8tlvCyy7RSe+WVZykvL3UddzhUfnyrBnYIeOKJF3j55e+prrYghPF8BGvO1JkQH29svrQFs2dPKf/853zXOQ5H56wwDiVrqFZKWSilPLaF5qFQSlnfEYOLFoqKiojzk2aRmJjK0KGqTiAvz/97y8tLqK/37Tahq2XN5sDNBtrLq6+RkKAUT1ycp4SLibFx++1F1NVFNnvI6VTkWZWVSoAEM9Pfe+9+5s+fzYIFdzFxovDJoOrZM/pmflyc+hwhlOvEW+Ho3WWkd2e6mEy7AxYvvpfduzdG9kNa0LNn6IrGZDJiMT16qHhCZmZ4WVr6szZt2kRZ2R6f1xsa2i/gmptVoF1K9XlaWXVk/Kg9SE42lKsx5mSqqz21ZGd0D4WSNXSYEKJYCPEfIcT/9E9HDC5ayM/P5/rrr3f9n5GRw223vcrf/lZKdbVy3Rxm9AHBbr+VadMyePHF6cyaNYwrr0zigw8e97numDH5HHVUYKrh9vLqa8THq8+6775iEhKS0dk8v/lNMWPHqvFH0iI4/fRjmDRpDKB2Z4Fq75Yts/Pxx/N8jmvW1c8/tzNgQPvHExcXfJfYs6cScpmZOuPF002mFcHOnTv5/PPP2z+gFujsEB1SaWraGXRjEA689y1ZWf7P84eePf3fs3BcV7ri+4QTppKe7hvYcU+RbCuam5WbCQwllZx8cLiFwFMxG8WRNi691NOBEg2OpvYilCleADyL4gI6CAhVQ8PMmTNbKH1jmDatiB9+gNJS2LZNLZqBbnlR27f/wL59JWzc+BWacjo52X+DthkzXuPrr9/h2WevxOk0VH97qCW8kZCgFsdvf5vPiBFjuOWWJtauHewhZCOpCDZs+Im6OuXrD8YFP39+IU1N/glVGhtrWbCgkJtuan/APDlZuXu0cIuNVS6S6moljLSf1t1tkpRkzIkWNk6nmVWrVnHCCYGD2eHA4VCLXCuCgoKH6dWrfeWwQsCwYWr869YpH312duhVtoEozMEo0gpFgOtrJCcPdf3tXbxYX9/2mM/69esZNeoYeve+BnjYZTV2hm5kocJd2WqXZE2NchW6W8Glpcq67u9bHH7AEIoiaJZSPhP1kXQwMjMzefDBB6mshPJytRh+/lntbAYM8NyBnXPONDIyhjJ8+Gkcc8y4gLz2oAT+ySdfhhDCo8p21qyiiPDqg3rA9G4uLy+HgQNh7VrPQF4kXUNFRU/zyis9+Pbb4L1ag/UZANi1q/2uMXefv/eONpirRL9WX2/sMOPikjnnnHMCvylMaNeQVgS9eycFtJ4sFhVj2rEj+A7RPZaSl6euHapLx2LBlfAQ7PrhKIK6OjVes1kJOPeNQXt2uhUVFdTUVJOYqL6sFpydmVYiGFRTKqUI9u1T99odjY3qWQmnbW00EUqw+B9CiGlCiH5CiF76J+oj6yA0N6udTWMj/PSTOuadDTNq1AVMnvwoxxyjeGNMJlNAbqJly+zMnJnLU0+pLp7Tpr3C3LlbuPjiyDFcxsYaC8ViMQRFZaVxTiQtgosvnkJu7ngguEUQuFubQntdY/Hx7Q8cxsZqRWCnoWE4gwYNIjc3NyL1F96uIe/drMWiCvD69FG7/N69VQpusKpg92uYzeH59Xv1aj2YnJAQWsBZP2Pbt29l5coVlJYasRCN+nZEDkeNGs2qVfs544ybAeN7Hoj6gUhZIbGxSsPeddd1gO+abK8rLZIIRRFMAf6AShld2fKzIpqD6gi89957TJ06lTfeeNV1Q7QiGDasbdfURV4qjVS6fOPLl9sjrvm1QK6urubjj1W8IhqKQGc56I5bwRRBsMyp9racjI+H9PT2UykIAUuW2IECpNyKlJKtW7dGpHex9pNXV6uo6XvvefZq7t9fCZmBAw0BZ7EETwFtj1AKZa4sFjWu1lw62iLYvHkDixe/TWmpb6aQtojaAqfTRFJSMvX1ia7P0xly0YYQhovLZosc1Ym2ZjZvVpawptfW6EyxglCyhgb4+TmoK4sB5s2bx7x583jqqYddrIAbVC8JH2K4srIdPP/8tdxzzylMnGgKyCXkr8irsbG2pUdvcMTEhNdmUCsWq9XKL78otsbKSsMfpHlv2osdO3YxdeoF/Pijyn4J5hpy7zMARnP7/v3b33IykgLh0UcLAc/71N7exVL6uoa+/fYV1+tWa+Dq35SUwJlUbU1BDed5Mptb/xxtESQmDqB//6OoqfGfMtpWq0BvXNxTb6NtDeh7kpOjlKG2uGJiDPdhe8aQmKgW6VVXPQeo2IC7y7YzKYKAMQIhxK1Sygdb/v4/KeUCt9fmSClnd8QAo4VRo0axevVqjj32ZBobVfP3xkZV6eqdblhWtp0lS57zOKZ3+4CLXC2QjzzQcbNZme/aXbFvn7EQQoXVamXQoBw2boSqKukRwHM42p9x8cMPP/LRR/8C1PdvrUGcd5+BoUMjky4aycKznTv934/29C7WgkwFrAUmk4Pf//4x1+sZGcEFc16eCmLv3GmkF8bEtP17h/u+1s43sngGcdRRqpS5qcnXz93Q0Dbl9c4777BgwTts3foQ0I+kpOjGBywW6NfPWCsxMYYyAGWB1taqjCtvF1ioSExUF4+NzXR1raurM5TLweIa+p3b395U0edFYSwdirvuuouff97IPffMpaHBcAv5o4lOTx/kly/He7cfyEfet6//4wkJRgYQtN0NcOutyuVSX2/2MM0j4R5KSurJsGHHAf3CzulOTo6MEhAisoogK8v//WhP72JveomkJDNjxqhOY7GxrQdtzWYlmAYPNo61xy0U7nzFxAQvMNOKwNsK8O661dZd7jffrOS99+xUVKiHNtoWQVKS7/d1j5XoSmmLpe2bKX3/qqqMHtbu86Vjk50BwRSBCPC3v/8PSuidV0ODSs0D/4qgR48+SOk/DaeszNhF+vORx8fbXILaG94LPSambS4Q90Xq/mBFQhGMHDmKJ574EjC5FkaoiFRPeKs1sj0W5swpQnWaM9De3sW6V3F5S3tmdz9zVlbo409JUe4Ks7l9SrQtitMfJYm+39pKrquTlJcbHWe9d8tNTW3LWBs3bgKPPPJ3NJ9VNCwC94rq1qyWuDjjnLZStejxf/LJP/jxR+V39nadHQyKQAb429//Bx1+/PFH1q3bSGNjI42NUFKijnuneYEKAgvhf6pSUw1pN2ZMPjNmFJOernrxZmQE9o0HarTRFrN606ZPAaiqavKwCCKRQtrcrHybEJwSQgjPHVWvXpHLvoh0wDA/Px+LpRhQ9yknJ6fdvYubmtSi1gFBs3k7mzf/l+HDgwfY/SE3VzHapreRuNSdBTMc+HuPthRU1aykoUFwxx0nul6PVJwgL+8ILrxwsquzW1JSZO57YqIS/mazcmv27auUdGvxE5PJeJ7DVapaeeq1vGbNCn74QdHWe89NZ4kTBJuOI4UQlUKIKuCIlr/1/yGxdQkhzhNCrBNC/CyE+GOQ8y4RQkghxOgwx99mnHzyyRx++GBeeOFRamuNBextwi9fbuf55wt8KKZBNWiZMMFzFzllSj5ffLGFTZucLFu2JWCANJCQTEgIP7f4oYemAFBd7Yyoa8hut3PEEf2ZONEE5OJ0Bs6q6d8fRo9WzXsGDPCvUNuKaGSOxMZOArbw7rsfsWXLlnY3sNetG/VztHnz27z22h0dwqfkjbbuYP0JPLPZcI8kJ6v9X0yM4b/SnfHcEa5w0927qqvV9bTiaWvns/R0o6taWpp6Nvv0Mb5LuJaWnpdQrWFvBtK8vHH06aNcDd6utE5vEUgpzVLKZCllkpTS0vK3/r9VUSWEMANPAecDw4GJQojhfs5LAm4Avmz71wgfMS3SNjU1nV9+UUIzJcVzMSQmwrvvFtLQ4LvtMZvNXH11MWPG5Lt2FykpoROpBdtlhPugZmf3BRw4HLEuArB9+9qnCHTPht27f0EZgFvZtavAI1PKZjN6tGZkGCa3XoiRQFxcdLpTmc1Keo0f/9uIXK+hwdMiGDAglRNPjFyxWjhoqyLw9z6z2RDI2dnqQZ8yZYnr9dpa+P57z9Rlb2HXGpqa4MMP/8Hbb6t+VwkJ4d9z9yBvfLza+evEhva28dS9BtLTQ3Px6c/Sje0TE4+hf39VnHTQKYII4DjgZynlJillI/AG8Bs/590HPAB0KJHd7t272bVLctFFV/KL6irnY4pnZQUminM6nZx/vsFLdPjh4VECB9tdJCSEt5jfeedzkpLUSigthY0blWBqj2vIX88Gp9MzOJ6ZCUceqeIq4aS+hgohosc8GROjBmyxxNPYztXY3Kx+3BXBRRdN5oYb7m3vMNuEtioCfwFjvYsGXBQm3slVDQ241hCoeQiHWK2hAR5+eDZFRcppkJzcuuAWwvDBJyaqjYjVauzChYjcM6mVQKh9k40uZer3HjeOPvcmNWBYQwca0VQEGcB2t/93tBxzQQgxCsiSUv4riuMICL149Y1ydwtppsZA1bD9+2fTo4d6GFNSlPAO1YUhROtmZjixApPJEJjr1yvzurGxfRZBoFRKHRy3Wg0ys2j1k22LmyxUWCxK4m3cuA1rOxs36IXt7hrq3fvA0Qe09XPdqZ813H3lgRQBqLRn941HOCmXjY1w6qnnc8QRlwDq2W/tlthsar2mphpEiH37Rq8ATQv31q4vhDF2nSyxZ4+DzZu/c53TGa2CaCqCoBAq+voocEsI5xYIIVYIIVbs9S7Paweam9Ui1lWz7opAF//MmlVEfLxvJtCsWUWkpLSNOCoUX2NCQniZMloR6O6bTU3tUwSBUil7984mLk7NVSQzefwhmlWl+h5EghJYKwJ3iyAxsRI4MFu99ug17yYw7haB7oS2YsVGNmz4wuN9TqdnDUw4/QkaG+H22x/kwgtVD4vExNArnd3TQKNhlXqjtXGZTEbiREoKxMU10tRk5rXXHnads2GDZ5VxZwgYR3PqdgLuZLmZLcc0koCRwMdCiC3A8cAifwFjKWVxSy+E0b1bq2gKAZWVlcTHx3Pkkb1cHZbAcA0JYZiY48fnM2dOMRkZvplAiYltc12EsmMzmUJPnyssvI6VK58GDEXQ0NA+RTB2rC+dtsViY8aMIg4/vO0ZLeEgmt3LItmTQC/k0lL1t9XawMyZPbjjjuvaf/Ew0Vo9QGsQwjNG5asIHDQ15VBSUsr27Z7v1amzgKtavzW459Lr97dmEVgsHUM94Q+tPZPaetLVyb16qUlISjrWdY7Dody3+tnr6hbB10CeEGKAEMKKKlBbpF+UUu6XUqZJKXOllLnAF8A4KWXUeYy2b99OfX09lZUVNDYaFoEWbt4ZC+PH57Nsmf9MoLYsulCzD0JNv7RYLGgvnFYE2jXUljiB3W7n5Zdf9joqOPLIKVx8cT5mc/TdHtH+DH0PRo48ikmTJpGbm4vJZAqbgM5dkO3YoX4nJVURH5+IzdbxjGmRaE/qfg33YLHNBr17NwMWXn99LLfdhocy8G5jGUoaaVMTNDc7KC3dS2mpFpqBBa4SrqF/l0jDXTH6g7ZKLBb1d2am2s0dc8wNPudqC6pLKwIpZTMwA1gMrAXelFL+KIS4VwgxLlqfGwoGDBjAvHlvcP/9f/OwCLRrKNodkUIVcPHxwZWBfiBvuulPXHPNLYCd//wnl4kTTVx9dS4LF9rb5PrwFygGycaN70ctHuCNaPcy1vegubmcBQsWsHVr2wjo6usNTicdMB0wII133qni7rt9mxdFG5FQnu7XcBd8FgsMHKhuzP79JqSEH380znXvzgahZQ/t368SMo49tg///OeLQGBFYLWqBIUDTU2dkqKUkb9NoFaaOuVWy5Q9e2DJEqNeCQxFEImmPu1FVL1qUsr3pZSHSSkHSSmLWo7dJaVc5Ofc0zrCGgBVRfqb30xgwoSrKCtTD29srOEOirYiCKc6Ny0tcKm9zmJISelFZeVioIDGRoP59PbbC3j11fAZNQMFiisqtnWIHxairwj0PUhJaaTZS1uGQ0Cnd73u3bUOZKA4EhaBTmbQQs3d7+3dGe3nnz3/d48TtGYR1NertVdXV0tKSipmcz8gsGvoQCsAjcRE38wmvS70b036pxXBBx9Inn8eXnrJeI97ym21b/fbDsUBCxYfaGj/uZZ5Okc4Lq7jdqOhIlBdgdlsjPXDD30ZNevra7nnnvAZNYMFijsK0fYB63uwf79v/10InYBOCzvvjKFICOS2IFKfGxPj6R7VO9x+/X5GCCe5uSrcpxl7NdwVgcMRPAajYwKHHTaCxYtLycu7AAi8EessikBDP6Pu1DDuFgEYSSdVVcp82LTJsCAbGoznp7r6wDa1PyQVwZtvvskFF5zMX/4y22WqdZRbKJTUUW8E4iDSimDevCdaeiD4YseO8Bk1i4qKsPmsOhvXXBOZVpvBkJDQMYJU34NAyi0UAjr3+IC7Iti27T1uuOFU/v3vdyIx1JDRmv86HHjTWGtFYLP9jJQ24uIuJzZWWUHuO9uqKs+4VCD3UH29pztEtfhUwtJfAobFcuCUayDoNRkfb2ws3GMEoIgE3VFTY1C2gKd7qK0sp5HAIacI7HY7U6dO5csvl/H88w/x1VfKdaIDxZFgywyGti5Uf3UFZjO8+66dBx8MyN5BRkb4u/j8/PyWPr7aCZpDSkox48ZFrsuaP+gCsnBTZ9sCfR9MpjyE14eFSkDX0GDs4urqDEVQW/s93377KWVl/q2NaCGSlqy3RaCDxgMGjOKCC67nvPOmkZOjXGrFxc+7znM6Pd0cgdxDmo3T/Tx9zB83U0fFpsJBbKxR2KYVgZ4z/dtbEQBsdduzuSvR/fsPnFVwSCkCTZtQ06J6HY5mvvqqALCTnq60eVsbgYSK9jAZenOvWCxw552F1Nf733bFxtr4wx/atotXrTglGRnTgS307Zsf9cWYmNgxueBgLNxduwRJSUkktdz47OzskAno3AXevn2GIhg//jJeeOEjzjjjgkgPOyiirQgsFsXEm5//IL/61SX07KmszZUrd3n08fauJ9ACvrZWKUyHw7PO4N13X2XGjBMpL1d5uP4UQWdsYi+EUlCxsb6KAIwUcJ3lpOswtmwxznFXiE1NBo15R+OQUgSBaBOgkD59QmMlbC/a6ucUwjdobDYH92XPmqV28W3ZZTzxxFweeugVTjhhJqDmJhqKQAjlCrJYoq+E3aEX7siRxzF9+nSqWlbk0qVLW1UCUiqhrxWBlCp1tLFR3aMBAwZy0kmn0a9fZjS/gg86wiJwx0knqUaFAwbc6sHOu2ePZw1LWRns2qWO796t/jbB+TcAACAASURBVHZ/Jn/+eSPr139FY2Os354XmtOqMyIlRT3D3q4h/bfFAldfDVOmwPnnq+PuFkFjo2dBWWVl+FxNkcAhpQgCC81tpKdH3y2kdxBthfeuyGwO7Mvu0SOHU05RAq0tRVODBw/h3HMvIzFxSMv12s4G6Y2YGEPoJycr4am5YjoK2jV01VU3Y7VaSU1NZejQoTSFMFlVVZ7+3OpqJdzAIDrr6KyhSDfv8a7jcP+/srKUb799n9jYldhssHmzlffeM85tajLmQ8PdRaSneN++Ms46axixsWnccMPngHrOvONh0Y7btQf6mTWZPOk4wFCegweXs37971iy5FrA0yIAT/cQKIXprzI7mjGEQ0oRBA4AZpOWFv0daVxc+ywOq9W32KeoyJcCA2zs31/E2rXqv7bUEjgcareiH9JILkadh+3eKDzaMQFvaKH2xRdf8Kc//Yn6+nrWrl3LIG2/B4DT6Vs4tX+/Z8bQ55+/xgsvPEJJyXbfC0QJkW7eA77pkTqN9MsvF/Dgg79m+fK5TJ+ujr35pnQ9b6Dy5Vt77r7//is2bvyJX37ZRVycqrzt399TAUWTbyrS8A6wa4sgLi6Jr756m7Vrn8dqlZSWeroVvRWBtjjLyox2oHv3hkfbES4OKUUQKBsmKakIiyX6AalIXF+7h8xmtQDz8/N58sli+vfPQQV3c4BiIN+V2tcWi+CyyyZy9dWns22bqpJqbzVnTIxBzKeDwX36dFxMwN94wM4772irqSmkIjJvcjV9zF0RfPjh08yZM4sdO7ZEdMyBYLFEx4fuvbsF9TkDBhyD1RrPp5++zIYNd9C793ykFLzzjuHTcDg8KSf8ITk5hTPPHEdzc4wre69/f8/NTmcMEgeCDh5raAvBYolh5sw3uO++5a46jC/dSPe9A+eglEFVlephvXNn9DOKIpRsdnBA+36nTLkCh6MZm60ftbUPkZOjAqHR3pVGIg86IUEFlNwX6aRJ+ZxxRj7Ll8PixYqB9MsvjV1ZW6oW339/EbW1tS5SvbaQ67lDM7R2FpSU2IECmprUNquxsZHf//73lJWVcf311wd8n3fhT1OTWrDuimDgwEmceOJx9O+f5XuBCCI2VllqHcG7o5+35GQYPPg4Jkwo4pVXbmb//l3067edPXvG88MPcezda7jHysuD92oeNeoE7r33PbZtgxdeUMe8FcGB4hRqC7xdc2azoch+9SvFrDpmjOIZeuEF9T1PPlm5zRoaDmwc5JCyCEApg337mli+XHLppSVAPunp0S9WiY+PTI63xWIQWmnoXbXNBmPHwtFHq/+1r7EtiuCiiyYwYsQplJWplTzcp6VQ6LBaO5cSAFi92l8BXj1//GPgVFx/1N7aTeSuCCZMmMYddzxKZmZu5AbshdjY6NIue0M/Y9p9eu65M5kzZyVjx97Mtdc+wPHHmwHBwoVl/PLLBpxOJ/v3a8uglAUL5vlUcFdVGQWd2iLIzPSszo1UXURHwPte+COOPPdc+L//Uzv+F180YifecYOOxiGnCECZ9vX1nhxD0TZBIxl/iI/3b7bHxcGqVR+ybt2rgMrQqKtrW0PxJ554kRtu+ISGBjM9e7bNIoiLUy6lcHv2dgRqa/0nDtQFSdnw95JO93NXBNHYVLjvkmNiOoYG3B260Yt+js1mCwMGjCIzczgpKX05/3wlsT/9NIabbx7Op5++jJTKbXb55edw661Tefnlua7rORywenUVDodSDv56hh9MbiHwTaYwmYy4YFnZDv75z0dYsuQ5Lr4YhgxRMki7iPbtMwgjDwQOOUXQ3NxMU5Pq7evOOhps8ZpMSqBpn7bNFppwM5sNP2EkH+pgiuDFF6fx0Ue3AUrRad9iuFaBwwFrVL9tBg4MP2AnhJqj5OTOVxEKkJDgP3EgJ0izZe9gnQ4c6+AeqO9cUrKGTZvW4/DDA653uO4NTILBbFZKuH9/lVnVp4/6HakMrnCgs2D8xSPy8tQYm5uTSUgYT2JiKk6ng3374IILfgfgMR/bt8MDD/wfkydb+eqr/1FRoebDfcNxsCkCb7hb6hUVu7DbZ/Hvfz8BwKmnqtc+/tg4f8uWA9et7JBTBEVFRfTubeaKKwZ5WAT+FIF+MLOzlUCz2YzFmJDgG+jUAdB+/ZRAyMxUJF2R3r3FxfmazLova2bmCGy2BkymJiorPfsThIra2lqeeeavfPqpija3pgh07ndGhvqJi1Pz1ZnN+uOPLwJ8Gw4Fqij2bjEI8MYbdqZPz2XSJBNNTbnExtpJSID8/JM488whVFcb6SA2m3oeMjOVSycjwxDwwdw77oo0JubA8u3o5z052ddt88Ybf6SmRjn6pRzPI4/8hr17t7B3L5x99q18/71k7NhZ7NypYge7dkFzs9qd1NWp8tt+/Tz95J21diBUuNN3Z2WN4KyzruX8828E4Pjj1ff76Scj1bapScUPDgQ68VKNDra2VHNIGeu6Ad4PIKiHPD3dd+el/xdC7YwqK41Wee49TaP5QLv3a3UfV1wczJq1EIBbblHm9pYtcOyx4VkEq1b9yN133wSMAvIYOND/d9ApoJqZUqNv3wNLoBUKhg3LZ8kSSEoqpLp6G/37Z3PPPUU+xWROp8ra8H4O3n3Xzr33FtDQoM2ErTQ2FvDVV5CTM4iqqv3ExioJn5joaUG6C36rVc1XVZX6cb9PHVHpHg70HGRkqA3Otm0G9fa2bavZv/8/wFU0Np5HcnJf9u/fTXr6IPbu9ezIpXHnnf/D4Whm2TKlYdxTR7U1fTDD3SKwWuO56qpnXK/Fx8Nxx8HSpbBsGfz2t+p4RYUipsvK8t18tacHeatjjd6lOydefPFFvvnmFyZO/A9NTeqhTk313bGnprZuficmqp1wUlL4DefbC+9F4s5ECgZ30q5daicbjkVQWtpMQkJP4BhA9ap1X6Bms/rOetfvb546ui4gXKjvk8+kSarh0Ny587nppuvo06cPDoehyOrrjZoKDSnhL38pdFMC+ngtr75ayKJFK/joow2kpcXTv39obsSkJMNC6NnTeLY6kzB059Hx7mR20UV3cOutRaSmOmluTuWWW37hsMNO5JFHLuLFF6dTWVlKQ0OtKyZgXNPCL7/4KoKDpXYgGNwVAfi6uk48Uf1e4UW+v2cPfPedUrJSqrW7Y0d0rYVO9JhFHzppISmpL2Vlqvw/L8/3BlmtofknrVajIOpAQwemNNLS1JfVAePm5tAKy8rLYeTIE3j55XIggbQ0tfPXD3XPnmq30pYWnZ0J2q2hszbi4xOorq6itLSUykojHuCviGfnTtizx3+wee9e47jaCYY3Lv1MdUSBY7jwVkpJScaxww47gU8/fYn9+58F4LXXYMeOClauXMQnn8xj7tyJXHllIps2eUo9KeHbb9XfWVmebrCDHe6uobg4yM6u5qeflrJ+/WcAjBihjm/d6msxORzq+Ndfq/nZsaPbIogYKiqMjCHdUCMvz9dHm5zc8WNrL/RO/T//mcvEiYJPPrkTUIpAB4y9K2K9UV5uVDnq3UdmpueiPJjyuoNBCxxtKQ0ceBj33vsUCxf+0+WmAd9ModpapQjS0vwHm9PTjeNdQZi5w19WjPtaKSvbTnPzoyQkNLNuHRQVpXDHHauZMKGI5OTemExmyspUtfWePZu5++6TeOCBp9m2TVkXo0YZc9YZEwzChTsl9bBh8PXXS/jTn07h7bf/BKjveuSR6pyVK/1fI5rC3x1RjREIIc4DHgfMwPNSyr94vX4tMB1wANVAgZRyTbTG43DA8OEjqKqqpabmJyDWRxGYzZ0v5z0U6EXas6cqAXY6VaB3zx6VwpeRoRRCSor/IG5VlWepu3vDHr0oNSd9V4D+HloRWK1WJk+ehs2mhL3unuVwwMKFdh5+uJCSkm2kpWVz1FFjqa/3bSlltdq4+upbOfHELDIycvnqq6Ud+I2iD38uwJQUY4Nx772fUV5eQkNDPbNn76CiYig//zyMceOGU1VVxnXXvYTFoh6m8vKdrF//GXFxzwFwwQVKMHYl1xAoZeB0Krft8OFHMmTIaLKzj3C9fswxKoV0xQo47zzjfVJK9u37hR49+mA2R3/RRc0iEEKYgaeA84HhwEQhhHdZ0mtSysOllEcBDwKPRms8AG+/bWfdujWUlGxh//4hxMTYycjwdAN1BBd+NKB3H2eeeQnPPPMLc+a8CaiAsW4WIqVqilFZ6enzbmxU1sDChXbGjMllwADBU0/1QtNza0XQVawBcO9ZbAj7MWNy6dvXxJgxqt9zWZk6Pnt2ATt3qp7Ge/du5cMPn6G62jPpOy4ulYKCYs4990KcTieVleUH5XMUDP7iFT17eq6XXr3607dvAnAvAEuWOJASkpJSXUoAICvrCE47bTP19SNJTIQzz1THu6Ii0MjMzOX1178mP/8h17Gjj1bnrFkD//qXYQHU1VUxfXoGU6cms2rVh9EfZxSvfRzws5Ryk5SyEXgD+I37CVJKd7qlBCBquSZ2u51ZswrcjmylubmAzz6zewi4g9EaAGO3lpQUR0pKXzIyTMTHK8FfVma4OurrldAvKcGVzbFrl8qC0QJPYR9QQFmZ3bUoD/Z0Pnfoe97QAMXFdm6/3RD2O3du5aabLmPYsERuueVy6upaZ/tKSEjkrLPyycjI4s03l1JYeH+Uv0HHw59FEBtrUEpoCCH44x9vJDnZwZ49Ftat83y9qQnefDOZjz/ORQi44grPto/eLJ4HM7y/h3fcJzERxo1Tm7RXX4XiYnW8pmYfFouVCy+8lYyMoVEfZzRtjgzAnX5xB/Ar75OEENOBmwErcEa0BlNYWOizoKWsZf78QmbNUimDFsvBK+zcA1OgFlNeHqxaBevWwciRvoFtdyKrhx/2nR+oZfnyQmbPVvPTlSwCTTJaUgLffFNIfb2vsK+tDZ3pq6xsGxZLPRBHdvZARo4cGKGRdh4EEs4ZGWpD4Z4yPGTIcZx2GixaBI8/rlyMZWWrqa7eSmrqeezcacFshhkzVE49qOfLndu/K8DbilIuyUo++GAe5547E5PJxIQJMGiQ5LHHGvnkk1hGjoQxY3J45ZUwUv3aO84O+6QAkFI+JaUcBNwG3OHvHCFEgRBihRBixV5/CckhIFAvgrIy43hn7IIUKvQDt3SpncmTrUycKFi/Pguws25d64HikhL/81NRsQ2bzaiT6CoYOVL93rEDSkvD7+vsC8lTT02jokJRbnaVWIo7AqWyxsb6b8l45pnqtYoKtRkpLT2c+voL2LnTQnJyDWed9RpZWT+5ztfWeFd6zrznTErJvfeewd//fiPLlr3qOh4buwSnczoAxcWS++6Df/5TuS5LS+GTT+CRR2DevOiMM5qP607AnX4xs+VYILwBPOPvBSllMYpbmdGjR7fJfZSdne0qJnOHe/PyA1m12V6YzYY/u7lZ1anX1+8ACli5Empr86mrC5wW279/tptbyEBiYq9OXyXcFuTmqh1oRQX06pVNebnvdw8XH3wwj6VL3+a++57mmmui29/5QEAI9Rz4S0POzFQuSPd6lT594Omn1fGaGli//iccDit9+uTw+efTWLz47wwZ8obL9aHXX1dSBN5WlBCCq666npdeeo6MDCNk2r//UK64YhRffLGRn34axJo1Km6waJGTqipDmzQ3w5VXRn6c0bQIvgbyhBADhBBW4HfAIvcThBB5bv/+GtgQrcEUFRX5NCm3Wm1cd11Ry1gO7pQ1kymwe6e0tJC6Oti82fMVHSAdONBEdXU1Kr7vifr6KhYtsnc5RWA2GwRnp55ahNUamV1AdXUls2cXsGBB670NDkYEqm0wmQx3mzsUvQIMHQrjxg3loosGctJJZo4//hzOP/9GMjNHus7VFnlXetb8WVEXXXQZixYt46ijRruOpaZmcu6507jrrkE89hhcf72uODcBtfTo8TnXXispLIzOOIWMIheAEGIs8FdU+uiLUsoiIcS9wAop5SIhxOPAWUATKjo5Q0r5Y7Brjh49Wq7wLsULEcceex7ffPMRTmcTQmQzbVoRV12V7+J079u3TZftNDCZTPi/n4LZs50cfriqEk5Jgffft1NYWBBSIDQjI4dVq7a0uzlNZ4KUqofs4sUwdSrEx9t5+eUbfLKB2ors7By2bt0SkWt1Jjgcyp0WSGysWePbcStUHHOMsgb8Ub4crKitNViOfV+TPPLIs/zwwxJmznzNI6sKVDbf1q2SF144lYQEC88+u4STT257KpoQYqWUcrTf16KpCKKB9iiCjz+GTz+Fu+9WRGpFRaqgIz5eCcdo9yyONrKyctmxw7+LIyYmlYKCxxkzRrksZs7MpbQ0NHeIEIJ9+5ydpoo6Urj2WnjuOTj7bKUMANassXPffZe1+9pCCJwdVQ3UwQjUUxeUP1sXa/rD11+/y2efvcG5585g6NCTXcdjY40+GllZXSdryOlUTKuBxOwZZ4xk8+YfGT36N1x66Z/Jyhrpc47D0YzD0cTAgfGMGdP2sQRTBAc8WNzR0ERz6elq96EzYbrCDuSOO/z1L1ZoairjueemsmyZclmEEyDt3z+7S5nrGtqVsd0tt2348HzS0gJRUZs9fqel5ZCY6J9rI3B/7IMfPXsGFtS9egX38X/33Qd88cWbbNrkWUqr4wPeBIYHO7ypX7wxbdofycgYxooV7/HBB4/7PcdstmC1RpeT+5BQBHa7nb59+3L66YJ587LRhVIpKUYxTFdQBBMn5jNnTjHmACupubmR+fOVkzEQRYI34uNtzJpV1CUVwcCWDE9vV8eECb4xA6vVhsn0MkJIHnigmddfl8ydu4UpUx73OTcYnXVXgHbf+HsmTCZFHpeT459s79e/voW8vBPo1+8wj+M6Y6grPmfBeMt++9vLuOGGJzj11CsYNeqCjhuUF7q8IrDb7RQUFLC7pQtNff12oIDKSrvL562LWA52WK0wfnx+UJeETpf1J+y80bdvDnPmFDN+fH6XXKC6D0V1Nbz9tpHxMmZMPldfXUxaWg5CCNLSchg1qhinM58jj1T9KTTGjMln5sxiMjLUuRkZOTz3XLEPnXVXg8USmJOrXz/1k5XlW6Xfv/8Q7r33M44+eqzrWI8eRlFaV7IGNFrLRrzggrOYNm0eY8b8JviJUUQXXN6eKCwspNbHoVnLypWF9OihFmtXsAbAMMkDpYIC2GxKiulYwTPPTMHp9O2klZaWw5IlW/z2G+gqsFjgnHNg4UKlCEpKVLYGqPnRc1RRAXe0VLice67vdfLz85kxwyhKzMzsiNEfeCQmqhaLgfzfsbFK2ZaWql1xdQs9k8Wigs5Wq7Ic3JMQuuKGw2JR1lFzs/96Ht2bQEpYu7btwfZ2jbHjP7JjEaiQrLJym8sKOJjTRt2hm3nMmlXErbdeSZOfvnc1NaXk56fhdJYhhBkpHYDAnd3DarXxu98VuUzarrg4Qc3VhAmKDvgvf1HkXxUVnkkDzz8PS5aov/v1gyOO8LxGUpLymWt0perr1qDbttYEKcDOzlbC3mRSFpfDod6jlYe3xdBVnzWdGltVpebAH4SAwYNhwwblKtu/X7Hf6l4j0fRadNFpNxCokKyr0gVr9xDAn/50AxUV3umQNTidauUqJQBKCShlkJaWw4QJRZxzTr5rkXbVxakX1siRKnvsm2/g88+VSyMhQaXvLVmivv/w4TBxou9i9G5x3FWsy1CRlBRcEbhbku5zE4iQr6s+axoJCcF3/Far2piAyjgqK1MbDYslujxoXXzaVSFZQUGBh3vIZLJx441GMK8rKYKYGEUsN358PuPH53Piibn88ksoaaJKCcyduwXw9Gt21cXpvns/+WSlCN5+Wwk2s9moK7nwQrj0Ut/39+7tS0tyKFkEoL5vTEzkmq531WdNozVF4A6TyZfQL1roAiHS4MjPz6e4uJicHCPwN21aMZdeqnbNJlPXevi8ldquXaGnibrzLrnvPrpifAA8g52jRnm6ORwO1YAmLk4VnnkjNtbXGjCbu9amIlREkqOrK61Ff4iN7ZzfscsrAlDKYMuWLfzvf07mzt3i4fboags3IcFTcPfvH3o+e2qqOte7aXpXdXfExRnfzWqFM85Q3/2qq5SFAEoJ+KNVGDTId0F31XlqDZFSBJrLqKujM3ZAPASm3RfuD25XUwRmszIndeHcrFlFzJ7dOpWE1WrjssuKGDhQ9SM2+huE1r/5YEVystEvdtIkuOgiZRmccYbqGJWb6/ueQYP8L+ZDVRGYzbg6u7UHXSVpozUkJyvLs6HjWKZbxSFhEWjoB81dEXTFhy8uznDtjB+viszS0zN8zhNC3f60tBxuu62Y66/Pp08fQwlYLHQpfiFvCOEp0IXw7OcwcKBvcDgvL7Df9lCLD7ijd+/AhHSh4lCav7S0ziV7DimLIDtb5Yq7+7+7mkWgkZBg+Lt1FtHttxd4NGCxWuO45RYVL/HHI3Swtu0MFd6KoDX06KGspUDX6kwLu6MhhJobh0NZBppaIRwr4VBSBDExqgK7psawSCMZdA8Xh5RFEBOj2DfdXR1ddfHGx3vuZh9+2LcLV0NDLS+/XBiQTO5g7s8QCoRQ7pxQ0/K8g8PuiI3t2kozVOgexikpykqwWpWAT09XFqbZrBSq91wJcWgpAo2EBDUfsbFKMWirymo1LPOOaN15SFkE4Lmj8w6sdiUIoZSBtgoCdSALdFwXsXRlaGE0fLhizNy3z/95sbGqWjiQYhSia7vQwkFMjJoLLdDS05UgE0IJOlD/x8aq3tkxMapo6lBWpD17qpoB/RzFxKj5czpVqmlysnqtvj56YzikLAJvHOy0063BXXAFyh4KdLyrWwNgCB6zGQ47zP93TkqCo44Kns/dq1fXtSzbAvdYgdlszLPJZFipNptSrunpioaiKyckhAI9L9pdqWldNNOrruKO2udH79KdG4mJXTc+oGGzGQJq1ixfimrNLOqNaD90nQXuO1AhVDaQXogJCcqVMXhw8J1qz57tD5Ie6rDZ6HK9Lg42HHKuIY3OmMsbaQihdrIlJUbA+OGHCykp2Ub//tnMmlXkOh4bqxZjXFzXYGINBd4CPiFBFZbpDUJzc/C89pSUbgHWja6BQ0oR6EVttR46pnxMjKJKaG6Gyy/P56KL8l0VsE6nmpP4+MhWhx4s8LfTd7cSgykBq7VbCXSj6yCqikAIcR7wOKql0/NSyr94vX4z8HugGdgLTJVShtY/sQ1ISVHpbIeaKR8ba2THpKQcOjv+1tCe4GRq6qEb3OxG10PURIIQwgw8BZwPDAcmCiGGe532LTBaSnkE8BbwYLTGAyrokpoaXRa/zo5uJWCgLXUSMTEqwNnVM6q6cWghmmLhOOBnKeUmKWUj8Abg0YJHSvmRlFInt38BRL2lh83WLQy7oWA2h7cp0C0aD/UMl250PURTJGYAbm3B2dFyLBCuAj7w94IQokAIsUIIsWKvLsPrRjcigFCTBkwmlebYvYnoRldEpwgWCyEuA0YDp/p7XUpZDBS3nLtXCBG1OEKISANKD/AY/KF7XOGjs46te1zhobOOCzrP2ALWxkdTEewEstz+z2w55gEhxFlAIXCqlLJVPj4pZQe1aggMIcQKKeXoAz0Ob3SPK3x01rF1jys8dNZxQecem0Y0Dd2vgTwhxAAhhBX4HbDI/QQhxNHAc8A4KeWeKI6lG93oRje6EQBRUwRSymZgBrAYWAu8KaX8UQhxrxBiXMtpDwGJwAIhxHdCiEUBLteNbnSjG92IEqIaI5BSvg+873XsLre/z4rm50cRxQd6AAHQPa7w0VnH1j2u8NBZxwWde2wACCnlgR5DN7rRjW504wCiOxmuG93oRjcOcXQrAj8QQqQf6DH4gxCi54Eegz8IIQL07Trw6J6z8CCEOOBZef7QWdckdN45CwfdisANQohEIcRfgQ+EEM8JIS4+0GMCEELYhBBPAf8WQsxsybZC6KbDB25ciUKIx4B/CSH+LIQ4/UCOxx3dcxYehBBxQohngI9aEjrOaDneGear061J6Lxz1hYcdAOOFoQQGcArgADGAp8QZe6jMHAzkApMAeJQKbdIKZ0HakBCiDzgXcABTEWRBs4+UOPxg+45Cw9TgT6oos7NwItCiLgDPF+deU1CJ5yztqJbERioRzGk3iCl3AW8CXwnhDjiQAxGCBHX8tsCWIHXpJQ/SSkfAva27CoP5O6jBiiWUs6SUq5BZYf9IoSIOl9UIHTPWXgQQriTjwvgcyllmZRyHvA5MKflvAPFs9qp1iQcFHPWJhyyikAIMUQI8awQIh5ASlkGfOx2ShYwEFjXweM6TAhhB+YKIUa31GMkAie4nXYtMFkIkdlRu4+W+XLtxqSUJXhyQ9mAoVLKHR0xHq+xdc9ZeOMaLIR4E3hJCPFrIYTmUu3jdtofgIuEEIOklLIjBFtnXZMtY+uUcxYpHJKKQAgxBmVyFqBcCAghhJSyxu00K7AlFNqLCI4rHuXC+B5YBUwXQlwFPABcK4RIA5BSbgdeBa7uoHH9GngHmCWE+GPLMYuUstrttF4cmAXaPWfhjcsE/BX4AbUGLgTuAv4OjBVCjARoUU7v0eK6klHOM++sa7JlHJ1yziKJQ1IRAGUo/95hwJVCiBw/N+1oYCOAEOLqDjJHBwE1UsoHpZRzgeeBi4B44P/bO/dYKa4ygP++vZdHA5TKw0LFer0CLVCQ4IOmNoRIQWuqoqUkUktpMSoEECkRjRKKRSRR26DUtjEkFU1KY4jxyUNbrKWNVVuBSiSKAWO0oW0oLSJQuHz+8Z2F02X3Xq53Z+fs7vdLJjs7Z2b3t+fM7Dlz5jwe4I0dU/6Kjehai9vQw8CtWHytEJH+qnpGRArRd48F9gWfOSIyOmOnIh5n3WM4cBT4mqr+BLgHmA6MwjLUL8v5FjrbgFoN8JjqNQnpxlnVaMqMQFX/gs2VcAD4FfBVuKDueBowWES2AHOw+sqs6f8pyAAACQNJREFUvf4MtInIlLBpL/AY8AVsYL5BIrJKRGZjM7udCMdlWvJQ1T8C+0N8bQMeDEESfff1wFAR+TH2B3g6S6fIzeOsC+JMT1X/hY30Oz16/wCwNmSkx4HVIvIp7K7qSBZOZbySuibj700pzjJDVRt2wW69L43eS+k6MAA4AEwrOXYrVlqblYHXEODy2AUohPXFwA+jsInAxnDMaGAusAO4tRZeZeLrUqx09J4orA/2B/wsMDujtBwOXFeyLYU4u8ArhTgLXvNLtrWE13nArmj7ZdiD2InAm7Cqj80Zxtf8CmG5XZPh898CfBPonVKc1WLJXSCzHwYrscHuNgN3h22Fkn2KibwU+HlY/0T4Y56akddXgP3Y1JzrYo+wPhLYAtwe3g/GBu4blnF8lfOqFF8rgZ1h/YPhdWbGfvuwkvWk8D7OpHKJs6688oqz8F3PAssqhBeAx4Gl0bZNwDUZx1WnXiXxVbNrMnzHZ7FnABuwhgal534ucVarJXeBDBK0Hzaq6aPA5ViJ8FWgLYRfUMoN66+E/TYCfTPw6gusw0oRQ4Pbf4FBIbwQ7TsDqwudBMwGdgJXZhRfnXqV7BvH1xngGLAe6JVhehbChbkVu+3+PNAvzzi7CK9K51jmcYaVaI+V+/wSl3dhbd9nAp8Mf9BjM4yvil6dOGZ6TcbnEPCdSn/qnL9TqWmc1XLJXaCKCXpZeG0FpgKtUdj3gDsrHDcQyzj2Au/LyiusD4/WpwKPAONK9i+edAuAb4eTLXevKHxIiM8/ZeFV6hZt2wAsD3+iU/KOs4vxqlWclaTlGGz+7wFYIehO4NqS/Yt/fh8FVgO/Ba7P2yvaN9NrsoxbAXgeKwSNC989j6gwxPk7lUzjLK8ld4EqJOjgcDHuAJYAI6MwwZqc7QQmVji+AEyogdfVYXsrVno9BHwL+D1261s80eJSbksqXtHxrRlenLHbYmBM2D4SeDisL8NK4EuBEcV0rmGcXbRX1nFWJi2LXndjD56fBlZhrVjmRueYVNulGl7R8ZlckxXScnzYvha4L2z/DNbZb210fRSy8EllqetWQyJyLXZr/jKwBnvYsyTapYCdeK9TZppMsCEHVHVvDbwWhu87AzwHtKvqXVjpYllwRaPOTqrakYpX5HRGVZ+qplcFtxGR2wHgNRFpAa4CPgdM1tARS8OVGtazjrOL9oqcqh5nFdJyQQhej7W6uUFVV2MTRC2MfJSM6IlX5Ff1a7KC2whgfgguViv+SFUfAlYAwwgdxrQOh43oDklMXt8DjgL3qupmODfS5LTQ6++0qnaISHtYf0lswKrexf1z8OoLnFLVcxNZq+ovRGQ5dsEcalKvztx6Ye3tx2NVBX/H6ptVREap6t/c65zXDSEtX1XVe4o7qurPRGQZ9seXdRv3VL0quU0PYU9gPdEnBbfnQ2fEhs4AitRNRhB6Gb6hJKOq+0Xkn1HYaaxqKO55OA24REQ2YaW2FTl6nYyPEZExWMnkH8C/m8Hr/3A7DewRkV3Ak6q6Q0Tejs2BXdV25A3g9Y5iWkbHjsXS8hD5nWM19eqmW3sIOyAiG4Avio1J1Y7dDR+stluK1EXVkIj0ihO1pCPK8SisDSudxQwBrsHaAE9W1d8k4NVHRG7DWjY9rqrzVPX1RvfqiZuqrlTVHWH9oKp+XW3YCPcq4yUirSLyMaz59GOqekfIvBraqyduqrobq6raBfxUVW9S6zzW8CSfEYjIIuDXYuN9fxisjjPu+RettwPPhG0fF5GB2LC/bapa1XlDe+KFDTa2HatPvr8ZvHrqJiLDqu3TyF5Yy5sngPcmdo5l5tVTNxG5QlWPqOoWVd1YbbeUSTYjEJFBYtU5HwC+hD3guT3cfp97eCMiE/T8g5yxwGgR2Qrcgj0P2K+qJxLzalHVF5vBq0puN5NBXW0De83CWrkcKa2SaUSvKrndjPXzaE40gaZL5RagBRuJsNhGvB14mNC+HXuivwl4ErgCuBJ4DRu2NrNeru7VOG7u1RheqbvVw5K7QJSQrVjHnLdG2/pH6wWsQ8qo8H46sLDkM+5wr3y9UnZzr8bwSt2tHpfcBUKCjMfasB8GHqmwzxjglxXCertX/l4pu7lXY3il7lavSyrPCF7Ghga4GhtSeAaAiLRET/yHY3O8IiKTJUz6LSKiVW7Z4l4N6eZejeGVultdkkRGoKovAI+q6itYvV5xhp8ObJgIgHcCvUXkG1hX8OKxmfWSdK/GcXOvxvBK3a1eSSIjANDzLVU2ASdFZEnYfjbk8lOA9wNHVPU6Vd3pXul5pezmXo3hlbpbXZJ33VS5BWsC9kxYnxBeP0L0YMi90vdK2c29GsMrdbd6WXIX6CRxtwGnsFEAh+Tt416N5+ZejeGVuls9LMlUDRURm9x7DfbUf5GqfkijwdDcqz68IF0392oML0jbrZ4odr5IChG5ERvr5lSXO9cQ9+o+qbq5V/dI1QvSdqsXkswIHMdxnNqRXNWQ4ziOU1s8I3Acx2lyPCNwHMdpcjwjcBzHaXI8I3Acx2lyPCNwnC4QkQ4R2S0i+0Rkj4jcJdGMVxWOaRORObVydJye4BmB43TNCVWdqKrjsHHtbwRWdXFMG+AZgVMXeD8Cx+kCEfmPqvaP3rcDfwCGAG8DfgD0C8GLVPVpEfkd1tv1IPB9bNjkdcBUoA9wv6o+VLMf4Tid4BmB43RBaUYQth0FrgKOAWdV9aSIjMImSnm3iEwFlqvqTWH/TwNvVtU1ItIHeAq4RVUP1vTHOE4ZWvMWcJw6pxewQUQmAh3A6Ar7zQAmiMis8H4gMAq7Y3CcXPGMwHG6Saga6gBexJ4VHMYmQikAJysdBixW1e01kXScbuAPix2nG4jIUOBBYINavepA4AVVPQvcBrSEXY8BA6JDtwMLRKRX+JzRItIPx0kAvyNwnK65RER2Y9VAZ7CHw/eGsO8CW0RkLjYm/vGwfS/QISJ7sOkU12MtiZ4LM2i9BMys1Q9wnM7wh8WO4zhNjlcNOY7jNDmeETiO4zQ5nhE4juM0OZ4ROI7jNDmeETiO4zQ5nhE4juM0OZ4ROI7jNDmeETiO4zQ5/wPLwg0E0QF54gAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 9134, {'val_loss': '-0.6858823895454407', 'val/kl': '0.0008773907902650535', 'val/std': '0.07987513393163681', 'val/mse': '0.005739749874919653'} {'train_loss': -0.7223997712135315, 'train/kl': 0.0015210185665637255, 'train/std': 0.06705736368894577, 'train/mse': 0.006151153240352869}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 10961, {'val_loss': '-0.7021335959434509', 'val/kl': '0.0008041483233682811', 'val/std': '0.05238235741853714', 'val/mse': '0.004420850425958633'} {'train_loss': -0.7431835532188416, 'train/kl': 0.001334377215243876, 'train/std': 0.06409317255020142, 'train/mse': 0.005752872209995985}\n", - "Epoch 5: reducing learning rate of group 0 to 3.0000e-05.\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 12788, {'val_loss': '-0.7109814882278442', 'val/kl': '0.0006971193361096084', 'val/std': '0.046636518090963364', 'val/mse': '0.004250768572092056'} {'train_loss': -0.8182313442230225, 'train/kl': 0.001185458735562861, 'train/std': 0.05582946166396141, 'train/mse': 0.004642571788281202}\n", - "INFO:root:Epoch 00007: early stopping\n", - "\n", - "Loading checkpoint lightning_logs/anp_b/version_-2/_ckpt_epoch_2.ckpt\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOydeXgURfrHP5U7AUIIAYSEhFsOQQREFFAED5QVxWNRIz9xVbwX7wPWY13jseItiqCyiEFYVxcVUWA9uEQOOVTuMzEcgYSQO5nMTP3+qOlMT0/PpIcjmSTzfZ55Zqa7uqe6pqq+9R71vkJKSQghhBBCCI0XYXVdgRBCCCGEEOoWISIIIYQQQmjkCBFBCCGEEEIjR4gIQgghhBAaOUJEEEIIIYTQyBEighBCCCGERo4QEdQDCCGGCSFygqAe44UQK+q6HiGEEMLJRYgIGgiEEBOFEHuFEKVCiK1CiG6u45OEECW6V7kQwimESHKdjxZCfCiEKBJCHBJCPFi3TxI4hMJLQoh81+slIYTwUXaY6/n1bXKz61y0EOIDIUSWEKJYCLFRCHGZn98dJYRYIYQ45mq794UQzXTnfbatECJKCPEfIcQ+IYQUQgwz3PsBIcQe17UHhBCvCSEi/NTlQiHED0KIQiHEPsO51kKIT1z3KRRCrBRCnOPnXpbLu55PCiG6+LlfB1fdyoQQ24QQFxnOdxJCLHC1eZ4Q4p9+7vWxEOKgq112CCFuM5wf4fqNMtdvpvm5l9++H8i96j2klKFXkL+AYUCOn/O3Ab8CPQEBdAYSfZR9Bvhe9/0FYDnQAugBHAJG+rh2PLCirtvDpF53ANuBFCAZ2ALcGWhbAk1c7dMBtUj6E1AMdPBR/kZgJBDnar9vgGlW2haIAu4HhgAHgWGGe3cGElyfE4HvgQf9tMFAYBwwAdhnONcJeBBoC4S7yuQBTX3cy1J5V92XAhLo4qduq4BXgVjgGuAY0ErXDrtdv9cEiAH6+LlXLyDa9bm7q037u74nAYXAda77vAz87Ode/v6fgO5V3191XoHG8gIeA/5jOPYG8Kbr8y3AVtfEswe4Q1fO3+QVBvwBjLBQB+G69826YweAS3Tf/wHM9XH9eHREAJwHrHUNmLXAeYaye1zPsxdIdx3v4po8Cl2Ty7yT0LY/ARN032/1NWj9taWP8r8C11gsezXwW6BtC+RgIALD+ZbA/4B3LNThIgxE4KNckTaBWnw2j/JABLAB6IMfIgC6AZVAM92x5biIGkUyy4/zfz8dRaJ/1t3rJ935JkA50N3H9T7/n0DvVd9fIdVQ7WEucLmmOhBChAN/Bua4zh9GrUDjUaTwmhCin4X7prheZwgh/nCph/4uhDD7b4cCrYHPXHVogVr1bdKV2YRadfmFECIR+Bp4EzVRvQp8LYRoKYRo4jp+mZSyGYowNrou/QewGLUKSwHe0t3zV5eaxez1jp/q9ArwGVoLIXJdbfWaq75mz9gGNZFt9nMvPc7Xyp5I2+p+/0YhRBGKMM8E3rN6bQ337Ytaie86gfIPAMuklL/WcHkvYI+Uslh3TN8Og4B9QohvXGqhH4UQvXW//Y7xv3cdKwO2oYhgoe63qttbSlmKkjZ6ua57XAixwPW5pv/H770aGkJEUEuQUmYB64ExrkPDgTIp5c+u819LKXdLhaWoyXKohVunuN4vAXoDFwI3oFbFRtyMkkpKXN+but4LdWUKgWbUjFHATinlbCmlXUr5CWpgXuE670SRU6yU8qCUUptMq4A0oJ2UskJKWW18llL2kVIm+Hjd7acuTU2eoakQpnaCbUBf1CQwHOiPIjEPCCEigUxglpRyW02NIYS4GNW+T+nqpNVFXy8rbQuAlHKOlDIeRUbTgFyr1/qpZzwwG/i7lLLweMoLIdqj1HFP+bvWBeN/A57tkAJcj1o4tEMtLr4QQkQBSCnvNv73ru/NUOPjc5TEUeNvSSlflFL+SVcWfP8/NdW7QSFEBLWLOahJGpR+WZMGEEJcJoT4WQhxVAhxDLgcpaesCeWu939KKY9JKfehVo6X6wsJIeJQ+s5ZusMaIcTrjsWj1Dk1oR2QZTiWBSS7Vk9jgTuBg0KIr4UQ3V1lHkWpqNYIITYLIf5i4bf0z6E3fk/TPYfxGUqkS6bXQ0p5SEq5RUrplFLuddXnGsNvhKEmPxtwr4U6DUL9l9dKKXfo6qTVRV8vK21rrPNOlKTxjuv3zNqgRgghYoGvUGqzF3THN+vuN7Sm8sDrwLNWiATv/wY826EcpW78RkppA6agJMwe/m4qpXS4FhEpwF0Wf8tYL+28WdlA7lXvESKC2sWnwDAhRApKMpgDynsBpa6ZArSRUiagxF1TzxcDtqMmLP2kZxZSdgxwFPixupCUBSjR+kxduTOxpgo5gFrZ65EK7Hfde5GU8mLUynsbMMN1/JCU8nYpZTvUqvIdzePEMCEZX9Nc1z8vpWzqet3p+t3Nx/kMoNqqehy4pIgPgDYo20CVv4uFEGcBXwJ/kVJ+V33TE2tbM0SgDMi+2sAvXH1sPsoecYf+nJSyl+5+y2sqD4wAXnZ52hxyHVslhLjR5Kc3A52EzpsKz3b4FfP+ahXV7YKhH7hUfp0xaXML/4/lezUI1LWRorG9UJ4lS4ANumPNAAdwAWryvwwoA55znR+Gf6+hj4AFrvukoCbeWw1lFqNWccZrX0QZb1ugvDAOYsFrCLVqO4aSbCJQEsAxlBTTBrgSZWALA/4OLHVddx2Q4vrcC7Ui7HSCbXonytCejJJUNuPba+hCFIEJoD3wAzBTd34a8DM+PGoM9zoDpa4Z6+O837YFolEeKTko1V4MIFznbgNauz73dD3Tq37qEua6/jKUZBYDRLnORaJW9vOBCAvP5bc8ys50mu4lUbr+WB/3+xm1yIlBLUj0XkOnu/r6RSgPpQdQuvgoH797PUptEw5cCpQCo13nW6HUN9e4fusl/HsN+fx/Ar1XfX/VeQUa2wvl4ieBRwzH73FNKsdQaom5WCeCeFf5YpQH0VPahOI6nwzYMfHscE1GH6K8QnLx76I4Hk+voSHAL64B8wswxHW8LW7PoGMoKaSn69w/UVJDiWvAT/D1ewG0qXDd96jr9U/D85cAQ12fH3T9fpmrrd7E5dGCIggJVLiu0V7pPn53JsoWoi+72WrbAvtcv6d/ddDdO9c10e1DuS/G+GmDYSb3+tF17gLX9zJDXYf6uFeg5WtyH+3g6gPlKAn2IsP5q1GG6CJXuV66c9NwueSiJuelrj5VBPwG3G6410WohVC5614ddOcmAd8E8P/4vFdDe2mrjxBCCCGEEBopQjaCEEIIIYRGjhARhBBCCCE0coSIIIQQQgihkSNEBCGEEEIIjRwhIgghhBBCaOTwGdY2WJGUlCQ7dOhQ19U4Ydjt4HT6LxMZCebBlBsnbLbjvzYsDCLqXW8/fjidqo8FgqioU1OX+gKzMSmEGocNAb/88kuelLKV2bl6NzQ6dOjAunXr6roaJ4xDh6Ciwn+Z1q0hLq526hPscDjgjz+O//rYWGjT5uTVJ9hRWAgFBb7PFxdDVRUkJrqPtW0L0dGnvm7BCKcTcnLMF2ft20N4eO3X6WRDCGEMCVONkGqojmBl+8aJrIAbGmoizT/+UGQBaoIzDmjtXGOBr+etqoLDh2HrVkUGxnONFcXFviX0srLarUtdIEQEdYSa1ELQuAemEf4GY14e7N8PR4+q70eOeBNHiAjUsfXrYc8e1f+MbdpY+5vTCUVFvs+XltZeXeoKISKoI4SIwDqkhPJy83MlJWpiA0UAALm53uWttHdDghkRHDvmKYmGiEAhL8//QqGiouEvJEJEUEewohpqrAPTiPJy84m8shK2b3efKypSZFBZ6U0EUlpr84YCX0SgR1WVZx9rjP2trMya6qcm1WR9R4gI6ghWVqhSNs7BaYSvgZqb690+mnRgNnAb+qpODytEAJ6Eabc3LrIE35KmEZWVNZepzzilRCCEGCmE2C6E2CWEeNzkfJoQ4jtXisIfXXH6GzwCGWwhIvBtNC8p8T6mta3ZAG8s6iEpvZ9V8xIyQk+yZtc1dFid4EMSwXHClZN3Kio+ek/gBiFET0OxKcBHUso+wLPACzQCBDLYQkRgvrqV0tvrRQ8zImgsEoHZcxb6yCVmNIQ2JiIIROK22Rp225xKiWAgsEtKuUeqFHRzUclK9OgJfO/6/IPJ+QaJEBEEBrP2Ki31L1k5nd6rvYY8kPUwe04ztRA0bqN6ZWVg0rkmmW7atInVq1fjbECNdSqJIBmV+ENDjuuYHptQSSlAZS5qJoRoeQrrFBQIqYasw+k0by9/0oCGxupCanxOu91cjQYhIggEWn964YUXGDRoEOPGjeOYL4atZ6hrY/HDwAVCiA2orEj7USkbPSCEmCCEWCeEWHdE8xGsxzAONn+Dr7ETga/J2woRNNZJzthmvtRCWlm9DaaxtBEEvmFTI47OnVWK5Dlz5vDzzz+f5FrVDU5liIn9qJywGlJcx6ohpTyASyIQQjRFJQv3olgp5XRgOsCAAQPqvV+DcbBlZ0NKinksHKdTDdaGsMX9eOCLCHytcPU4dgxatXK3XWOZ5AIhAlArXS3OUGNpIwhcItDKZ2RkUF5ezsqVK4loIAGsTuVTrAW6CiE6ogjgelSi82oIIZKAo1JKJ/AEKn9og4dR1VFQoIJbpaWZl6+qarxEYDYx5eVZW80dOwYbNsAZZ0BMTONVDdVEBPoJsT4QgdPpJCzsxJQZ+fmBB+VzOlW/i4qCV1999YR+P9hwylRDUko7cC+wCNgK/FtKuVkI8awQYrSr2DBguxBiB9AGyDhV9Qkm6AebzaYG4qFDygd+61bv8o1ZPWSc1JzOwILP2e1uF8n6MMmdDOjbrLi45pWv3pZSH9ro3XffpW/fvsyfP/+4rj92zJpq0Qy7dmVTYkUcrWc4pTYCKeVCKWU3KWVnKWWG69hTUsovXZ//I6Xs6ipzm5SygW/bUNBLBFqHlFIFAyss9NZtN+bgc0YiyM09fpG+MUoE2dk1l9cTQX3YUPbFF1+wadMmxo8fz5YtW2osv3DhQu6//34qXA96vCQAcOWVl9CsWTM2b94M0GA8h+raWNwooe87Zp3SGD64oW9m8YdA1Rxm0IiggYzZGqG12dGjgXtX1Yc2+uqrrwAoLCxk586dNZZ/5ZVXeOONN5g5cybl5Se2IIiOjiUmJoby8nKSk5Pp16/f8d8siNAwLB31DPrBZiZlFhRAu3bu71pY5RNUi9ZLGCcmqyEB9GisRHD4sLXy9Y0IoqOj+eKLL8jJyaF37941lr/33nvZtWsX559//glHEl2wYAPt20sKCvI5cOBAtZRR3xEigjqAJn47HOZEoIUD0GdGqqxUyVUaG/SrN7NNYlagJwIpG3bWN32YCKsqRc2FNCoq+IlASokQgtGjR9dc2IUxY8YwZswYpDyx5EYaKisFLVu2JCsri7Zt2574DYMAjXCNWffQBps/NYfxXEMPeuULeiI43sVXffOKORHo2ysQJwOtbYO5ffbt20fHjh2ZPHlyjWUdDgePP/44q1atQrpWXqWl1p4vJ8f/eZsNhBCkpqYS2UDyWIaIoA6gdUZ/qQSNKpAQERyfWki7h3afhm4w1p4v0Mi19UF9tnDhQrKysti5cycHDx5k0aJFrF+/3rTssmXLeOmll0hPTwegtLSUd955j9mz3/H7Gw6HIgKzsTl37vtceukZTJs29YSfJdgQIoI6gBYb3x8RGEMvN0YiMEbDPF4igPox0Z0MaEQQqKdZfZAI7rzzTlatWsUTTzzBokWLGDlyJG+88YZp2dTUVB566CHuu+8+hBAUF1fy2GN38vLLk/z+hiaJZ2d7e1Dt3r2NHTs2U1ioLPCzZ8/m2muv5ZtvvjnhZ6trhGwEdQCnU9kB/G1oMQuPYLeb7z5uqDBOSidil6ushLi4xiMRBLr3ROtvwUwEYWFhDBo0CICioiIuvvhievXqZVq2c+fOTJkypfq7EM0ZO/Y2EhISq+0MZtCIoLxcbTpLSnKfu+++Jxkz5iYSE5OQEn777Tc+++wz+vXrx2WXXXZyHrKO0IimleCBlO78ur5QUeHtKVRV1biIwDhphySCmnGiRAD1w0Ptggsu4IILLrBU1maDiopwXnxxRo1l9THk9u/3JIL4+Ob07NkXUO17/fXX079/f/r37x9Q3YMRQf53N0xY9X4xTnyBbomv7zgVRNBYJILjUQ1pqpBg3FS2Z88ebrvtNl577bUayx47doyFCxeybds2QK3srTxTZaXnuCwv971gs9mgX79+jB07li5dulh5hKBGiAjqAFoguZpgtBM0ZiKorDyx1XxjI4KaJAKbDQ4edH+XMrjtBPv27eODDz7gyy+/9DheabKi2rhxI6NGjeK2226jpMT93x89msfu3dsoKzPfTKBvDw2HDql3m83GY4/dxttvqyg4DS3sS4gI6gBSWpuQjDrxxkYE+lVtUZH/sjURhXavxkIE/iSCw4dh0iR48EHYvdt9PJjtBN26dWP69On89a9/BZSNICYmhlatWnmVjYmJ4eKLL+acc871WNHfc891XHRRDzZuXO11TVWV+Qa8oiLVlrm5+/n3vz/gk0/eA9SxwsJCMjMz+eSTT07OQ9YhGpHGOTigDTIrk7pRImjok5gR+snMn01l1y54/nno3RsmToRXXlGb8e6/311GW8E19DY0I4KsrF+ZMeM2unb9jC1b2nP4sHuRsXUruMLrBzURpKSkcPvtt1d/b9q0KTabDSklDoeDcF143kGDBrF48WKOHPFMxZmS0oEOHbqa3v/QId/PffQoxMU15emn3yQurgmg+lNpaT433XQTaWlp3HDDDSf+kHWIEBHUMrTOZmWwNXbVkH4V7ysRVH6+mvjLy2HNGvj+e9Bcy4uKID5efW5sRKBXXaxY8TG7d29j9+421ccSElSb6oPSBbNqyIiwsDBKS0uJiYnx8gDSnDGM4SRefnmm6b0qKszVQhry86FXr1aMH39f9TG7HZKSWjN27FhSUlKO+zmCBSEiqGVoRqsff8xk7tzJ5OVlk5SUytixGQwZku5RtrLSMymN3d7wQyRo0OIrgXLpMzP2FRXBSy+pCS0sTJWfNct9fv9+NxFodpmG3Hb6tJ56Ijj//P9jx4727NgRRdeuSmrKz4enn/YkgmCWCDZt2kR2dja9e/emQ4cOAMT6iLly8GA5lZXeBGEGKZV6zN8za6G8o6M9j0dFNWXu3LlWHyGoEbIR1DKcTpg/P5Pp0yeQl5cFSPLyspgxYwIrVmR6lW+s6iG9asNs411ZGTz3nIod064d3OdarOmlpv37Pa/RiDQYJ7qTAf2uYn37tW9/BklJqoHOOQdatoTUVEWKOTnuNgtmIvjwww8ZPXq0pRwEo0ZdQK9eTfn9d/Ndx3rk5VmL0Lply26WLVtMdvae6mMNKTx8iAhqGU4nvPzyZGw2zxneZitj3jzvGCqN1YVUP8jMIkb++KObBJ58EgYOhNat1TnNB95IBNoquaG2oS+PoZycXaxfr2b3AQPUsZgYaNNGXXPggPt6vSQWTOjRowejRo2iW7du1ceee+45Ro4cyZo1a6qPOZ3KiFteXkZCQkuPe3z99aeMGNGdf/7ziepjVsOaf/31p9x886VkZk6rPlZVBWVlZWRnZ1N+Ir7NQYAQEdQynE44eNA8W0h+vvdx4yTYUCcxI/REYOaq58oLwujRSt8dFgbXXKM+X3mlOqdNcMb7NFSpyhcRPPvs01RUhNGyZSGFhT9VH09NVe969ZDDEZxEcOedd7JgwQIuv/zy6mMbNmxg0aJFZOseoLISvv9+O7/+Wki7du097mGzVbJnz3YOHHCXt5qkpmnT9gwePIIuXXro7gcjR44kLS2N1au9PZHqE0JEUMtwOOC001JNz7Vs6X28sRqMNSIwC57mdIJrrxA9e7qPn38+vPsuDB2qvpuphqDhE4G3ykIxY37+m8yd6461oxFBVpa7ZLBKBGZ49NFHWbhwIUO1Pxy3wbtZs3ivvMbDh49iyZItPP30m4D3BjJ/GDQonQ8++B/XXXdL9TGbDZKTk2nXrh1V9XxjwSk1FgshRgJvAOHA+1LKFw3nU4FZQIKrzONSyoWnsk51DacT7rsvg2eemeChHoqKimPsWO+UzY2RCPTRQs3G1759ql1atwYTN3Jat1ahOPLz1cQQE6OON/S9BGZt5nRCZOSfAUhK2kBysps5fUkEwdg+ZWVlxMbGehiAzznnHK9y/ib25s1b0Lx5i+rvgaasLCry7G9SwkcffUJDiER9yiQCIUQ4MBW4DOgJ3CCE6Gko9jdUUvuzgOsB/zFiGwAcDhg5Mp3bb59OfLzWqxIYO3a6l9cQwNKlmQwe3IFOncIYMqQD8+Z5G5QbGvQTmZlBTktT29PYm1wIDwctX4heKmiMEsHevcqVMjER3nzzc2691T3EzIjAbg/OxUbPnj2JiIhg3759PstICd999z9uuukiZs40j0qqRyBE4HQ6TDc1NhSD8alUDQ0Edkkp90gpbcBcNBnVDQm4HPxoDhi0ug0Pmhtjnz6XcscdHwLXAc2ZPXsc997bwcNzaMWKTGbMmMCBA1lIKdm/P4tHHplAZmbDJgOr9gFfRADuVJ96O0FjsRHo22/dOvU+YIC362yrVmrj3bFjbskzWCUCu92O0+kkXvMHBnbs2MG7777LokWLOHBAeUDt2LGFlSu/Y8+eHV73KCsr5cUXHyMj42EgMCJ49tlhXH55LL/88pPH8XquEarGqSSCZECfGC7HdUyPZ4CbhBA5wELgPkwghJgghFgnhFh35MiRU1HXWoM20H788UNefvkK4CtAuZHm52cxbdoE5s9XE/28ed7eReXlZUyaVHOGpvoM/eAyDrSiIrUbFvwTQbKrp82aBa+/rla5jYUI9G22fLlaxhYXvw9AeXkxzzwzlIkTOyOE9CJMzcU22KSCnJwcbDYbLVq4VTtr1qzh7rvv5oMPZmGzqecfNeo6/vWvb7nhhgle9wgLC+O99/7JRx+9zdGj3mpXDbt2rWH27IfIzXW7ilZUFGOzVRAREedRdtGib+nfvz+PPvroyXnQOkJdG4tvAP4lpUwBLgdmCyG86iSlnC6lHCClHGAWW6Q+QZMIIiKiAAF4BhRyOMr4z3/URJ+XZ+5d9Mcf5scbCvQrWqPo/dlnSg985pnKH94X+vVTOZ5LS2H1atizp/ERwZYtkJ8fDxQQE/MLADExTcnJ2czhw3soKDjgRQTaPYKNCAAiIyM9bARdunRh/PjxjBgxpvpY69ZtueCCS+nZ80yv66OjY3jssRd55JHX2b7dt0X8m29eZ+HCV/n+e3fY6hde2MDMmSWcdtoZHmXLyipYv349W7XVST3FqTQW7wf0/lsprmN63AqMBJBSrhJCxABJgEn4p4YBTSK4/PL7mT37QR9lssnNhaSkVNemM0+kpJh7HTUU+JIIDhyA775TKo50b3OKBzp3hvffh9deU+qRI0cavo1A8/bRPH8+/lh9HznSzuWXPw6oXLtPPLGIli3b07x5G1OJQP8ezBg0aBBnnjmI3Fxr5YUQ3HnnY/z+O5SU+C43atRDhIdHMnz47djtVUREKAKKiWnita/n7LPPZ/Xq1bTTGrKe4lRKBGuBrkKIjkKIKJQx+EtDmWxgBIAQogcQA9Rv3U8N0Iegjo31NaGnsno1/PnPz6Fs7m7ExsYxaZK3d1FDgd3u6b6oJ4IlS1TbDRsG7dt7XeqFsDA47TT1+fBh972CMd7+icLhcD+XzQarVilDcYsWcP31rWjVKq26bOfOZ5OQcBpCiGoVmmZU1wggmHTfO3fuZPjw4TzwwAMex6uqFMFreOqpe3nyyXvYv9+3xFxW5p8EADp1UolmHnigC7/88oXHOaNdoVmzRAYOHFjv4w2dMiKQUtqBe4FFwFaUd9BmIcSzQojRrmIPAbcLITYBnwDjpWyIw1RBiwWjEUFCQgbgqXNUOsgMfv4ZkpO7I6UqrAZtGs8/P50rr6xhOVyPYZyA9N81f/eBA63fT9MkHjni1n03xB6mVwtJqYgAYMwY7xg5etQHieDgwYP88MMPrNMs3y4cPgylpWVs2rSW3bu38emnH/Lxx/4dD3/++Tc2bFhIUZH/9WZ0tBqXJSUFVFSU8OKLlzFt2l8oLfWUKBtKyJJTuo/AtSdgoeHYU7rPW4DBp7IOwQStwzgcMHXqnRw8+AYgadr0AUpK8klKSuWaazKYNSudvXshN1eSlJRGZGQ0c+ZsxxVrK6hWaycbRpuAfmPZHy7XAyvSgAY9EUDDzftstA9oYbuzsmYyZ842Ro78K4mJavlfVJTH/PkZ2GxljBv3HkJAbq5qm2C0EfTu3ZslS5Z4BJnTwmG89NLjzJr1Fo8++gLz5i3jt9/WkZxsLmk7nfDWW4+yceO3PPLIAvr1G+Vx/vffv2PZso+45JK7SU+fwvjxbxEeHkFeXjabNn1LYqJa9ZeUQPPm6hopJf/4RwbHjuXzyiuveG1iqy9ogEMieKEfZNnZyUA00dF9mTHDc3WyYYMKqVxRcTb33PMxs2ZN5JFH/sSnny4AGm4ie6fTW/TWJrbCQjUAmzRRPvFWocUfystT7zab2mDW0KK4Gl1H8/PV+6ZNM8jLW8WwYX+pLhsZGc0337xOREQU48e/TVJSJEeOqBV2ExVuP6iIoEWLFlx00UUex7R+ccYZ/ejWrRdNmjSjT58B9OkzwOd98vOhU6ezcTolcXHNvc5/9910fv55Kzk5UTzySJPqjYhNm7bkkUcWVJcrLnYTgRCC116bQmFhIU8++SSJgXTOIEIDm0qCG/pcBElJ95OdDRdemOBVLi1NEUFODoSH72HfvvUcOBDrkVS8ISayz8/3nID09gJt01NKSmATuJZ8/MgRN4E2ROh1+3a7crMNC4Nrr72HgoIrqlezALGxzbj55jdp3bojoNRDR44o9ZC2yUyzOQQrWWqEd+2147n22vGWrjl4EK677lmf56+//nn27bOxd28PZs1yJzaKiWniIT0Y4389/PBkYmPDiKjHA7L+1rweQlu1lZXBli3NABg5MoVPPpnEggZsUM0AACAASURBVAUv43TaSUpK4+yzlTF48eLHsdv3ExkZS/fu51NRAXFxnvdqKLDZvAeYXgWWk6PeA1ELgdKPx8eribGgwNNgHKyT3PFA82ax2dxhuxMS4IILzO1JI0e6t+wkJ8OmTcpgrCfKqiqIijpVNbaOZcuWsXHjRoYMGUK/fv0ATxXihg0/M3PmG4wZM44LL7zc9B6Fhb73DWho0aJzddutXg3PPvs4rVod4q67/uVRznife+99hATv9Vy9Qv1UaNVTaKvbDRtUDJwOHWDnzkwWLnwVp1ONwLy8LBYtugX4C3Z7DiCpqipn27bl/Pe/7h3FDY0IjPmZwZMIjsc+oEFvJ2iI9hWHwx1jx2Zz2wd0e6/8wtdegmDpY1988QUTJ07ku+++qz6m/x+XLVvEV1/N5YcffIcp04cakVJit3vHhti61TNW0dato9i0aRE5OVtYsmQaO3aoXcWVlZ6/3xCkzBAR1CK0gbV2rXovKprGrFkTsds9I2U5nVWAZ0e12cp46y33juKG0Pn0MAsWpl/1GYlgxYpM7ruvAzfcEMZ993UwTeqjQbMTHDniaXxuKND7tldVuYmgWbMK1q37kuzs37yuKSkpYMWKTJYunRX0nkNDhgzh3nvvZcAAt/5fPxFHR8cSGxvnERlUjyNHqI4TtGrVPMaNi+a9924FIDd3Dw6HnaVLZ/HFF78CcOml0KyZBIZy2WXfs2XLj3z44V0sW/ZR9T31UkF29h8sXbrUIxx2fUOICGoRmvuoJn4ePbqQkpJ8y9cfPuzuaMGyWjtZMCMCTVXkdHqqhrQYTFYyvEHDlwj0k1JVlbt/CXGAV165kk8+edzrmoKCA0ydehOfffaMBxHow0sESx8bM2YMb731FhdeeCHgvdfk1lsfYPnyffTu3d/rWpvNM8x2dHQTHI4qKiqK2bZtOfff35kZMyawcOHrbN2q9K7nnQdXX630hsuW9aBNmx4MH347PXqcX30f/V6Ed955hWHDhvGf//znJD517SJkI6hFaLuKtYHbsWM38vNb1ejTrKFlS7fBL1gG6cmAw2G++tQG26FDiigSEqBpU/MYTFqGN7MIrnqDcUMjAik9JQK9aigxEc46axRdugzyuq5t224MHHgN7dufQbNmkiZNBKWlSpcejC6kehhdjCMjI2nZ0jz0zL59ns/Rp8+lzJpVTlRUDDt2qM0WS5fO5IorPiE7uwtNmzrp0iWMTp1g0SJFjnl5F3L77Rd63FdPvp06dWfw4MHU5/A3ISKoRWi7irVONGHCFHJyzmLGjAleE5sZrr7anWKvIRGBmTQgpZsINmxQ7z1cyaF8xWAyy/AGnqqhhra7uKLC81n0RHD66Z0YOnSB6XUREZE88IB7BduuHezc6WkwDpY+tmrVKjp27EibNm0QQlhOJpOf724LDRERkYBKINC16yBuuWUqvXtfzJw5XQEYOjSMsDDlcXXOOb/zxRdn8O235YwYEetxH71EcOONd/L443dST7cQACHVUK3CKBHExcGQISo3QVycb7eDsLBw7rnnY4YPv6t60AfLID0ZMBvYZWXuCU7bUHr22eo9Kcl8w1CTJuY+3Jprd0FBw4kfr0FvZNd2TWuTn7+gfEZooSYOHAguieDo0aOcd955dO2qJuqqKkzzAhhRUqJCbPiDEIJLLrmb8vKurFunPKRGj3afP3LkNaCInJxYduw4gt3uFicrKz3bp76PxxAR1CKMRLBmzYcUFh5myJB0nn32J5o1S8I7+Gocd945iyFD0pHS09hZ37e2FxQotY9ZcnptxVVUBNu3q2QzZ7oCSo4dm0F4uHdaqIqKYj788G4vI7Lm2nfsWMMLM2FUC4HbRhAXV4aviC0RERAV5eDgwR1kZW3ysBMEk0Rw7NgxBgwYQP/+/QFRHSrEH/LzVc4KMyKTUvLmm9eTkXERX331MpmZj/Heeypq3YgRVR5uoP36jSA5eTsATz/9Fr/+usjjXnr1kOpT9bdThYiglqBN3Dabe/BmZk5gy5YfAUhO7sH06Ue4++6PSEpKQwiBEGnAdLp3T8fpdOJ0Oj1Wz8GwYgsU+r0UhYVqRevPPrBhg2q7Xr3ceyiGDEknNjbe6xq73caSJdO8jMgbN2YSHq5+02ZrOHYCh8M7iY9eIpg162rGjYti69Zl1WXat1fZ23r3hj17FvPgg6cza9ZEDyLQ/iOns+4XG506dWLt2rX8+OOPVFVZk+hyc32ThRCCX39dzO+/f8fixVNZsKCA7Ow2QD4tWszxKDt48I2MG6fE0LCwm7wkTo0Idu7cQtu2LTjrrLMCfbygQchGUEvQJrvCQm0zUwnR0bHV8V9AecPMmzeZvLxskpJSiYvLIDs7nUcf/QsVFTO5+eY36dLlPrQkTcGwYgsU+flqMNc0wWihJtavV+8DDJEDSkoMyt9qeM4ANlsZ//73ZBIS0snPV1KBNmHWdxhDIttsqt3sdhUqoqrqKA6HnaZN1QQWH+9WAQGceWY/wsMjyc/PZuHCCcB0DhzwJEqHg6DRfVtZ+JiFKTHirrtmERkZTU5OEZ98cgV2O8TGPs7Qof/wKnvGGdqGxG7ExnbzOKdJsnFxTSksPEZeXhOrjxJ0CBFBLUGbtI8dU+8tWjRl6lR3j12xIpPp02+nqkqN7ry8LMLDJ7iu7QfMpKys0EMiqI9EUFlZc70dDrfuW/Ntd6mIXe10G8YJ3x/y87Pp1IlqImgodgLjJjyjx9Bzz61xZdVSajTNe0pDamobnnlmOTt2rGL27IcRYip5eZEehlC7nTpNzi6lrE5GY0WSKympmeT7978CUDYEux3695c8/PAM07Lh4dC3LyxbBr/+6g7BAW4iPu20ZLZsOUK3bhZ38AUhgoTrGz60ya+wUL3HejohMG/e5GoScF9TBkymY8c7mDmzlKuv/pvH4K9vRKCPbukPepuBpu9OTHTvH6iqMtmGDKiMb95o2TLVw07QUCQCf0Sg7SqOioohLEzltDDGQ4uOhtNPP4fzzruBhx76jObNVaNoAfqg7vvYpZdeSlpaGmvWrLEkEVgxJGvQcl8PHuw/1kjv3ur9N8O+PM2hITw8nObNkwgPD/e+uJ6gRiIQQoQJIc4SQowSQgwXQrSujYo1NOhVQ+DWd2vw5RIJ2WRlRRIVpS7QqwPqepAGCrMwEmbQiKCiQn2OjIRmzcz3D2hITk4jPf1OoqI8g+9HRcUxdmyGFxHUd5gF0NPvKjZO+gkJ5kEKmzSBhIQ2DBhwJc2bq8BC+bo9jnVth9q9ezfZ2dkkJCRY+t+sEMGOHav49NPn2bJF3dBf7mtQ6iGAbds8pUmn092n67qdThQ+iUAI0VkIMR3YBbyIyi98N/A/IcTPQohbzPILh2AOo2po585vuOGGMOyuHuTLJTIsLJXKSneslPJy6q0LqVX/b40INGmgRQsVIM43WSoieO65d3jppQ+qY8LHxSVw++3TGTIkvcFJBGZtqd9VHBFxhL///QIyM1VSdV+upPoFSTMVB5GjR4Onj23bto2dO3fSqVOnGidbh6Nm+wCoMBOff74IhyOSqKjd1SGlfSEhQamEbDa110IPra++9trfGT36SrZv315zBYIQ/iby54CPgc5SykullDdJKa+VUvYBRgPNgXG1UcmGAG1AuTtqISCrQ9eOHZtRverXEBUVR8eOKhLp008/wOzZDyKlexKob6uQQInAuLr1RZYAa9Yoz5irrkpn48YCtm938MEHBdU7jfVE0BBsBL5iM2mr+fDwXLZtW0ZW1kaE8J3DQcs/sHz5xxQWbgOUnl1ro7ruY5GRkXTp0oXw8AifdXE4lFPB2rXWCL5Hj/Np0eImAJKTD1qqhyYVGNVDmoS+evVSvvrqy3obb8insVhKeYOfc4eB12u6uRBiJPAGEA68L6V80XD+NUDbux0HtJZS1vOArubQOrFGBEOHXsmYMTuqz2sT1rx5k8nPz6Zly1TGjs2goCCd3buhvLwbe/bMBVTni4mp+9WaVeTmKn20lQnY4XAPLqO+e+zYDKZPv83DRhAbG0fr1sn07Xs2NpuNqKgomjVTblVRUe7fNBJBQ5QI9CGoTz89jQEDviMqKpYWLZTR0wyaRDBv3iTy8ycB3SkpUfePjg6ePuZPLXToUGDkPnDg1SxcqNrq6quHWLqmd29YuBB+/93zuNZX7757Evfddy9naptd6hkseQ0JIc4DOujLSyk/8nmBuiYcmApcDOQAa4UQX7rSU2r3eEBX/j6g/jri1gCjRJCQEEvbtsoVpl07tZIbMiTdK1bOFldrNW9+BaNHqwTkZWVqcgyWQVoTKiu9XR19QW8oNkoEQ4ak89tvS1i2bBag1EEPP5zBVVe52+yOO8awZMkXnHvucCZP/p8pETQEG4Fx4jPuIWjXrhlpacMBb28hPTSnhQsuGM+vv3Zl1y6qiQDqViJYtWoVb775JkOHDmX8+LtNy9jtbs8yq/jpJ7VJMSLCHbakJnTvrtxo9+5V408jUK2dhgy5iMREql276xusGItnA1OAIcDZrpfvfHBuDAR2SSn3SCltwFzgSj/lb0AlsG+Q0HKs6sNLaGjdWhmsEhO9jcgdOyr9eElJCr16qaQbmoFKyuAnA2OkyJqg361pZvg8//zxnH76EEaNup4VK/Z5kABAfv4RpJT89NN3PPXUxdXH9USgZd+qL9BHBAVz7ytjrmJNioqIwG/SlLAwJV1ed92znHPOCEARgdbHtIi5dYGdO3cyd+5cVq1aZUreUsKePYGNgb17Ydo09UBXXJFXrRqrCTEx0Lmzao8dbkHeK8RHfYUVY+8AYLCU8m4p5X2u118tXJcM/KH7nuM65gWhttB2BL63cN96B23isdvdE91XX/2Np58eQnS06mTR0dCtm9pBq9/AExurNgE5HO50jfrJMtiJIJDVd1WVEvM1mBFBr17DeP/95bz9tnvNMG3aS5x5Zgs6dgzjwIFs+vU7F4Ds7M307q2MoJpBUB9dsz7A6VT/e06OqntVlcotbITNpialsjLlZbV586d8++2bCLG3xg1h2uKjaVP1rpcIoO7aa+jQoWRmZjJhwgTTSXbPHu+gcjVh7lyoqhLADP7731Zs2OA7mY0RmvSwdav7mLbAy87ew+zZ/+KHH34IrEJBAitE8Dtw2imux/XAf6SUpl1OCDFBCLFOCLHuyBFrIZuDCdpA0ksEZWX72Ldvg5coGR7ubdhr1Uo982effQN4qlmCfRViVXfrdCpxXb/C0u8h0BAV5c6oBTB/fiYvvzyZoqJjgOTgwT/YvHkDI0dezQsvTKdJE0W0kZFqotN2ntYXiUAfF6mgQHmPmbWp3mOoRQv48ccPmDVrIseObfEubEBcHFRUlFJVpXQswUIEHTt25MYbb2To0KFez+xwqGiygeDgQbUpLDLSCagcDU2aWDdJmhEBqLZau3Y5999/C9OmfRBYpYIEPm0EQoivUNs3mwFbhBBrgOruIaUc7etaF/YD+sSCKa5jZrgeuMfXjaSU04HpAAMGDKgnQ9gNMyLo23conTp1MXVdS0ry3NQjxFrgcn7/XTlJO53BZ8zzBasSQWGhZ2hfME+5eOjQMhYuPETfvueQkpLGlCmTcTo9G6GysoLffvuFd9/9DFDtBEpFUlLiDj5XH2C1/crL3R5DiYkwcOA1nH56Vzp16ub/QpTUuXjx23zyyVfACi8isNvdbVgX0Adb1GAWqLAmLF6s3ocMCWPChHxstgrCw60HV+jWTalp9+xRC5aYGHW8ogI6d+7BmDHjOPPMIZSWYlnlFCzw1wpTTvDea4GuQoiOKAK4HrjRWEgI0R1oAaw6wd8LWmir9qoq92r+yivvoHt3TImgeXNPj5devZqxfj2Ehw+uLlNeXj+IwKpEYPT/djigoCATmMxf/6piL40dm8GiRS+ya9fvjBx5De+++x8OHDB319Mf1xNBTo4igroOpmYVViW+/HxPCWrEiNvp1cu9N8Af4uIgMTGFxMQ4jh5Vk6wWDyosrO762M8//8zevXs588yBxMV19jgXKBGUlcHSperzpZeq96iomIDuERcHnTrB7t3KTtCnjzpeUQF9+w6kb1/lPxPsUroZfKqGpJRL/b1qurGU0g7cCywCtgL/llJuFkI8K4TQSxPXA3NlfY7h6gMOh3Kd1FZqehtBbKxSVZjFcRHCkyAuuWQokZFQWZlSfX2w+HnXBKsrWuOO0CVLMoEJgGckUXASFRVNWpqaGNq1M99bEB4eQXr6RdhsNg8igIZHBMXFagVvtKlYXcXHxMDQoelkZCyuvh+4pYK6IoIPPviAG2+8kSVLvvM6FygRLF6sFk/du0Na2vHXqXt39a7fN2Z05Q32MWkGK15DVwshdgohCoUQRUKIYiGEpYgeUsqFUspuUsrOUsoM17GnpJRf6so8I6X0TqoahAj0Dy4q8o4XrzcWr1o10+e1+lhEERFuvfhB1/6Xuh6kNaG01PoOXofDWy00f/5kwDsd5d6923nppQ94/PGXAHj44QxiYz1drcLDw7Hbq/jpp+/Yvz8raImgvLzmeljpcxoBaO8JCU727dtAXt4fvi/SQQj3wgTUf6GpH6Hu+tjZZ5/N2LFjad/eW70VCBGUl8PXX6vPV199YnXSgh/qdxi728nBli2b2L1794n9SB3AirH4n8BoKWVzKWW8lLKZlLKeesseP8rLPb11aoJZOFy9RLBy5dt8/PHzPq/Xu5E6nU5atFAzpUYEwSwRVFUpQ57eA8gfzMICFBaaq3wcDgeTJk1g/nyVqP6qq9J5/vnp1REqExISmTJlFv36nctZZw0iIiKCqCg12RkT1NQF3M4CSlrMyfG/49rK/6tJnBoRxMUV88QT/Rg1qq/lesXFqQVHbKw7D3Jdx9GZMGECc+fOZcCAYR7H9ZsOrWDxYkVu3bq5dwj7gz8vK40Idu1yk7j2/02d+jyjRvXlww/fsV65IIEVIsiVUm6tuVjDRlGR9RAJoCY342pPc/EDaNUqkbPOGujzer1EkJ//Bxs3vgHUD4lAe0ardTMLFBYb6zucRHl5GVOmTK7+ftVV6bRu3RaAcePu4aqr0vnss5/4/PNVtG/fESGUzaWuJQKnU7l+HjnidgZwOtVnX8RU0yRcXOydmaxp0wo6duxD1669LNctLKyCRx45g8rKHMBzL0Fd9jGz3BWBLMgOHIDPP1efr7lGLQhqQpcuvs8lJipnjvJyd/yvykpVx7POGkT79h2Ji6t/62R/XkOaELVOCDEPmI+n19Dnp7huQQPNyBtIXHajqgPcSWliY+GLL/bQtq3v66Oj1QrNbofff/8eeAF4kgUL2tO27fOMGKE2UmlZpIIleQhYizLqcKhVVWWluUE5Pj6D8vIJGNVDGoxG4oULN1FVZeP115/h3Xdf5K67PLWNMTF1LxFo7WJUa1RVqVW9MUKolZSaWhBDcEsGHTu2Yfr0TX4nNCOaN48mN3c3TudhICUoiODo0aPY7TFIGVst8YF1tZDdDlOnqv41eLDbuOsPMTFqsj/tNN8Sbdeuirx37FAZ30D14yFDLmLZsj3WKhdk8Oc1dIXucxlwie67BBo8EUipxHdtoqqqsjbpVlWZG0m1QRsX53Y984e4OFi4MJN//etetAnRZstmxowJCAFnnaXIIJiySIF/IsjKUoNG2/zk6/q8PPVsYWE3e7mHArRtm+LxPTExicWLv2Du3BlERkYRHR3Lq68+SWmp0jvFx7dk1Kg3gPQ6kwj8qTNKStSrZUu3p08g9gGHQy00NBVYoO6ecXGCp55aypw5vdm6VdVFq6+2u9jKavpk4rzzzmP79u0sWbKFLl2UE7/d7paKa8J//6tcPZOS4JZbrF2jGdpTUtRkb/YfdO0Kq1YpO8EItRmbykqIjXU3kMPhO75TMMLf9LEEeFhKeYvJ6y+1VcG6REWFeuknDSvukGYrlqoqWL48E+hAfn4YI0em8Omn//J7n9hY8xj8NlsZc+dOriabYLATaDmZq6r8ryCPHlUvf+L9rl3qHh063Mhdd80yicoazSOPvOB1XXx8c1JSOtKmTTv+8Y/7q0kAoKgon3//+y9AZp1LBP6gSY1Q8/9aUeGerLVnat5cS0wfWN1iYqBLl4E0b67EXm0vgdW6nApER0cTGxtLXFzT6mN79lhT0e7YoYhACLjrLut+/frQHL68i7p1c/+GhvruOeSPCNoDnwohlgshnhFCnCNEba8J6hZmk5VGBP4mO7PrPv88k88/d7tDHj68n0cfvYW//c08mBYoicBXDP78/OygshNUVCidqZZ4x1cZK4N4m4qGTH7+J7z77nh69DifiAg1s7VokcRLL33gFWPo11/Xcffd11FRUY4vT2SHwwZMpqLCWtz6kwm73Zorrd3uXkjUNJloNgHwdB1dvHgqV12VxvTp1rcCmXkOQd3aojZt2sSOHWW0a6f0L+Xl1kJKrF8Pr76qSGzUqJoTz2iIivLcd9Gqlfk+jLQ0RRQHD7rHutZOf//7RE4/PYYZM6Zb+9Eggb99BC9JKYcDlwObgL8A64UQc4QQ/yeEaFNblawrmInyNpsaJL62t1dVmUsNr78+maoqb4aYM2datQeMEbGxvmPwt2yZaomUagsVFeZuoHr4Iwk9NB/tqqolOJ12OnUawLp1lezdK1m//ogXCQC0aNGSgoI88vIO+dxkpqDO5eZaq8vJQiBeLgUFyqhcE1np7QN6Ijh6dD+HDmVTURHAjwIlJTns2vWN67M6Vpd2AmMWNittuGoVvPyy6mu9esGf/2z998xsdikp3sciIty2AS3+l36BY7NVUlISgEU7CFCjZllKWSyl/K+U8g4p5VmohDWtAL9hqOs7bDbzFVlZmTLKVVR4n3c6fRNEbq755CSl9PCA0SMuzjxhTUSESr+oEUEw+MRbVXvUBLvd7aP94otTeeyxhVx66V3Ex8OXX37CsGFdmDjRa4M669atpEkTtXwL82MwiYhQxGoWuO1UIpBcug6H6mf+Jl8pPUlXH2foqqsm8/33e0hPvzOgOsbFhbNv3xIASkqUVFWXRGCUoKx4C2m7h//0J5g0ybqDR3Q0tDFZ2sbHm9+jQwf1vm+feteI4LHHXmTr1jImTJho7YeDBFbzESQDabrya6WUr5yyWgUBfK0+9JNuSYnqKLm5yjDkdJpLA/PnZyJEGD5i6vlcwUZEwCWXqNXvRx89QHFxHpDKGWdkMGRIenXnq+s92frNR2YoLVU6aCuT4b596l7Nm2fy3HOTycvLpnXrVMrLM1i7dgVZWbupNPzY/PmZTJ58B+XlaqZw+Ji1IiKiaN8+g717a1ci0DbXnUwYiUIfZ6hJkyZ07Ngx4HsmJ5/G4MGXsXKlWxrRh6OuTRw9epRLL72cpKTk6phRNS02qqrcAeEuvzwwB4r27c3LC6EM+EYPIs1+YCSCmBjl9x0Mi7NAUCMRCCFeAsYCWwCt60lg2SmsV51CSmuTlmZQ8zcJzp+fyaRJE0w9XzT4CpMAimi0hDWrVsGbb7q9ETTSqcvNURERNa8Wd+ywnhVM2QcyKS6egNOpJvbDh7N49NFbqHLNpsXFhcyfn1mtIpoyZXI1CeghhKi2F0RFRXP33R+weXM6e/fWrkRgVSUWCIxqI32cIX+G4thYNaE2aaImK/0qOy5OMHToxaxcCQUFyhxYV0RQWFjIunWrSU52W2xrkgi0fta+vWegwpqQkOA/eU9Skm8iyMpS70aPwmBQ1wYCKxLBVcDpUsoAtlPVbxQVWfsj7faaDXq+JikNsbFxPPxwhs/z8fHuTqiFmdAyMtU1EZSXu9Nm+oLdHthGPGUfmFxNAhqqdEvq0tJiJk2aAKjNZP5sAnv3uhtnyxb3JqDaIgK7/dTkSDYSgd5GMGfOJObPL+Xuu5+gVSt3BPmYGKX+0FxBi4o8J9fYWGUgBThyRAKizqTOtm3b8vXXqygvd1b/fk02Ai2fcO/e1n8nPFwlf/KHpk1V2+klklTX2i0nR/3HERGqn69f/x1z5rzH4MHDmDTJtyNIsMGK8LQHCGArVf2G03lyV3D+Jqnk5DSef366qfFTg5avYMWKTD788CLAyaFDnkbpuiICzU7iz0AcaFgOJRHUnABcv7vYl0RlPK7fXVxbRBAICQYCf0Twww+z+de/3vRSoWkulJrvn1FyCA93G0yPHHGQn59bZ3aomJgY+vQZRP/+5wGerqxmKCtTuQYgMCJo08bangujhBEXpzad2e2eO4wPHMhm4cJP2bBhjfVKBAH87Sx+C6UCKgM2CiG+w3NnsZUsZfUOxn0DJ4p27VLZvz/L63hychorVuyr8fqICNXpNm/+gR07viM8/A8cjjQOHVIisOa/X9vQ9gzUBH8kYcSBA6p8WFgqTqd3m3mXzyYmBl54IYM775xAmY51jJJWRUUFUVExtU4EVozoNcFmU5OM5spo3I2tz1WcmAh33fUSDschWrVyWz+F8PalN1MhxcZKIiLysNtbsWDBJ9x88/11ltpTL5X7kwZmz1aJ5SGwPMTgP42nHi1aeG9kS0tT0vq+fepzZSUMGjSMt96aS2pqZ9P7BCv8SQTrgF+AL4F/AD+5vmuvBomTLcY//HAGMTGeXj/R0f7VQUbEx0PfvpfRo8cFtGqlRoS2CrEa4fNkw+oEF4hEsH69eu/UydtTygzJyamcdhqMG5fO9OnTSU1NQwhBWloab76pJC273U6XLhH06BGLw1FSPfD1iX9OJYztNHPmG3TpEsGtt/6J0tKaWbKqSrXL5s0q325RkXeGrJISVS42Vqkw/vSnG7nttgeJjnbr7OLivI2hYWHeHjFRUYLUVBUDvV+/v1bXobYXG7/+upm3336e779XYUN9EcHOnfDNN4rokpLgyiut76oOD7eWrwFUOeNOYaOdoLIS2rfvyKhRY+nTZ0CdO3EEAn82gkLgJyllLTva1S1Otih/1VXpfzz7DwAAIABJREFUlJVBRsZEysqOIkR7Hnzweb/qICOaNoVzzrmGc865hjlz4Kuv3ERg1Qh7smG1naxKBF9/rfLJAlx6qWqbefMmk5+fTfPmiZSWFlNV5Wbp2Ng4nn3WTabp6emkp6dXG+zKytSqPyIiorp99u3bREKCSu5TGxlPtXy2eqxevRSHw8H3339NVtYuevb0HyFUPwHm5pp7OxnzEJit9Js29T6mldXXMTIS2raNYs8eyMtTzFEXfWzt2l+YMmUyY8aMY/jwUaZE4HTChx+quo0eDTfcENhvJCRYD5uhhe7QvLPAbSf4wxXtu7LS/f+0aaPqV1/CTPiTCG4CNrhyEcxy5Q22EMS1fuNU6HSHDUvnySfzACcpKVmMHGmdBMBzECcnq/e6IoKCAjUYrGzucTisSQ4HD8LHH6vnuP56FSCsvLyIAQOu5I03lrNhQx7//OeHJCerFX9ychovvjid8eO921Fb9epXugsWrOe334oZOHBwdVsG4td/vDDrS3/722t07dqT4cP/5CUpmsFK++k9hoqL85k48U/VK2lQbaGPZquHkTQiIqB1a/U5L0+FQDeLAHqq0b17L+6663GGDx8FmId0nzpVqWWSkmDMmMB/w6payFd5jQi0TWUFBfDrr/l89dVsFi+eX69cSH1KBFLKawGEEB2A81yvO4QQqah9BJfXRgVrEydbBK6oUMbPigr3LtCEBO9VQni4fy+lmBiQ0sbKlZ+yb184cL2H51BtdjibrWYSkFINUKsi+oYN6v2885RoD/DVV//kyJF9REdXcsUVg7nqqnQPKappU/+ruchIdV5K6NFDhZ3UvDu0z6caZkSQkpLG4sWbLd/DChHo9xAsWvQ2S5d+TXHx0epJ1J/6w0gEkZFuz6GVK39m8eJRzJy5ljZtOlmu88lA7979efTR/oBn+HYNM2bATz+psXHPPdaCOOphzAJoBcbySUmKYIuKlINJ8+YqZHxGxv/Ro8eZjB9/VWA/UIewsrN4H7Ae2ABsBA4DPtYXnhBCjBRCbBdC7BJCmGYhE0L8WQixRQixWQgxx3rVTz782QccjsBXkdnZqgMfOZLFxx+r/XcJCd562ZYta/ZeiIy0MXXqTXz7rXKbPHDAvYGtNiUCKwbi4mIlImfX7PwDwKZN6r2vTkvSsWN/EhNT6NnzLNNr4mpeTFe38/z5mQwZ0oFu3cKYOLEDkFkdvvtU4mT4kluRvDRvmV27ZnLw4Fauv/52Jk58BlATni+1EHj3Ob1EUFranJKSo2zYsLLWVUP6tjOOO5sNVq5Uz/a3v7nTRwaCDh0CD8wXFeUpWQnhDkGhqYfi41sxbFg6I0Zc0TAkAiHEJOBcVDiJ7cDPwNvABOlri6zn9eHAVOBiIAdYK4T4Ukq5RVemK/AEMFhKWSCEaH0iD3Oi8KcWys1Vk2C8xZwTxcVu3e0ff/zG/v3KOmmUCLRgX9p7VZVb7aNHq1ZNiYlpRnh4BJGRDo4dC+fIETVoa2uQSmltJa0PhlYTKivdxk99vPgHHvgPYJ5RKjzct6pDj8hI+Pe/Mz02o+XlZaFyIUNVVXrA4ZoDgZEIvv/+a1avXsXll19Jy5ad2bixgNTUznTp4pvYapIIjh2DX36BsDDJ/v2TsNtjycx0x8SPj/e/wzYszJ33AtRnTSIIC+vC66/volevzrU+qe3dm8WRI8W0bdueoiLPpfiePapt09Kg83E452gLr+NBfLwnOaemKoP1H3+ovpqYmMzEiR/Tt2/d7/gPBP4kgv8D2gHfApnAHCnlBisk4MJAYJeUco+U0gbMBa40lLkdmCqlLACoa8O0L4nA4VB67EAiVuon88TEFJo3V8tdY/KRmBhPFYcvfW6TJjBzZhHvv3+UlJTw6t+oTYnAqkdVIESwdasiv06dzEV1s4naqpEvNhZefXWyx2Y0hTJg8kkP+2CEkQi++ea/TJ+ewbvvTmfo0Ja8+OIVlJWpsNtm/6GUNRPBsmXqd/r0sfPgg+9w++3uiKNhYdbUH/qVcWSkmijDwqCoKJIWLTrXyX6VV155jpEje7NgwTwviUAL/6yljQwUqebbTizB2J5a8Lk/dOmhtX7VICQCKWV3IUQiyjYwDHhcCNEUFYn0Jyml78zrCsmAPnt2DnCOoUw3ACHESiAceEZK+W1AT3ASYTYx5Oaqlb2WbMZKYprKSs/IkB069KV7976sXu0tEZhN+s2aeasE9OL9aafB779n8s47k5kyJZt27VJ56aUM0tMDM0IHCn8TpzZJaElnzHDsmPL3bt5cGSLXrHE/55lnepbNzd1Ns2YtCA9PQL9eMYYK9oemTSEnx5d+KrvWieDssy9HiDTOPPMyli6dS2ysEi/LypRraFKSInx9CBF/k6+U8MMP6vPFF0fSr9+YarUOqHa2Em8nKsrt5hsZqX6/ZUvlWZWf7578atMLpmXLNnTt2pOEhDZe/UkLSqjlBQgErVoFnrRHD6NGwBiFVEpJcXERhw6V07LladQX+A0xIaU8CiwQQnwL9AfOB+5AhaSuiQis/n5XFNGkAMuEEL2llMf0hYQQE3DJ86knQud+4HR6D9ziYjVA9dACzfmDmY+6tlvZKBGYqQS0ROJ6NUxMjNuoXFr6MXAHpaVq9O7fn8WECUrdcSrJwN/EWVwMu3f7TwDy3/+qROJGCAHnGJYIDz54Ok6ng08/XcGAAYOrj1tVzWlITU0lK8tsc1rqKScC44qwT5+rSU1VGWA//LDII/3i4cPq1a6de8Vak31g9261oSkhwU2k+tW9VQOq/hqtb7ZurYhg7txZCPEV06e/j9OZUGtE8NBDz/Hgg8+Rn++e+EGRnyYRHA8RaGFajhcREaqPazkj9KEm1P8tufVW5V5UUODAWvCGuofPWgohRgshXhRCLEcZiKcALYGHACtUtx+V3EZDiuuYHjnAl1LKKinlXmAHihg8IKWcLqUcIKUc0EpTYJ5kmE0KZkkwiorUH+7PcGzctZqbu5uDB1XP0UsEUVGepKCHmaTwyCO9ueEGwbp1EzHm8i0rK2PyZPNw1icL/lRDBQVKGvCVOERKWLdOfT73XBg5Ep57TgXRe/tt72xQ2iSpj5UDga/mMjIyiI01sm0ckHFKicC4G9du9wxd4ivHkxY+BGpWC61apd4HDYLdu1exdOksDh3aXn3eV98ywqgaAvf/sXVrIatXf8aBA/trTTWkbzvjhsTcXDX24uPxkH6soGVLa7almqBXDzVtqnYdV1Yq4gwLCyM+vjUtW7ahvLz+hGfz11XGAyuBR4FfXHr+QLAW6CqE6IgigOsBYyD5+cANwEwhRBJKVVQn2Z8DIQItn+tZJg4t+fneRufPPnuRwsJpgINWrcKrB6i/1bN5HHXpqqv5bJtt1U3nOOFv4jx2zPc5UJLV0aNq0Nx7r6fKYsWKTObNUyGnk5JSGTs2g48/rvJYHYP5TtiakJ6ejt0O99xzF6WlxbRp057S0hcoKUk/pURglAYKCuC3374jNjaejh37+8yZ4HQqe1SbNv5tUk4n/Pyz+nzuubBy5RwWL36bZs1eZ8CA0xHCuhonIkK1rdNJ9XWdXN6irVpdyy23tKFFi3a1pvPWS+bGtK9a9rpu3QLLoSzEidkG9IiPdwd+BPVfFRQoImjTBt57L5fOnU9MBVXb8Jeh7GpXzoEEIwkIIWrMeCGltAP3AouArcC/pZSbhRDPCiFGu4otAvKFEFuAH4BHpJT55nc8tTBOClqIaSOKitSkp7cDlJa6v+/aZXb3DkA4kZG5REe7O7A/IjBzbeve/SzAd+8/VWozMPcY0twyO3UK47bbOrBihXmmNVCeLQD9+3uTwIwZE1zePJK8vCxmzJjAihWZXht4jndgjRuXTlmZmlFef30+TZsq9dmplgj0OHDATkbGRTz5pNKBLV48lQce6Mq3377pde2BA2pvRb6fkbBjhyLWpCRlNO3SZSBDhtxEz57K9cqqNKDBqB7SInIeO9aOc88dS2xsi1qVCK67bggXXNCZPXvc68LCQpg3T30OJLAcKLvayZqYmzXzJCF3xFb3sbra8X+8sNJdnhRCVEopvwcQQjwKXAhMq+lCKeVCYKHh2FO6zxJ40PWqUxgnBX+DUENuruoQ27b5/9PPO28yy5fD6ae3q17RRkf7H6xGIpg/P5NFizLRpAIj4uLiyMiwHr8oUBgntvnzM3niiQlUVCjZXZvAQeVP0LBrlzJorlmTCUzmf//LZuNGteofMiSdefMmY7N5yv82Wxnz5k3moYc87R3HO5DDwqB3735UVlbSpEl09Uq5toiguBgKCirp1Ws4TqeDsLAwKivLOHRoF0eO7Duu+69erd4HDVJ9cOjQcQwdOo6BA9Xx4yECTRUVGakmzthYRTbHjtVuvCG7Hfbs2c7Ro3kIoXQ5UsI776i6dO8OI0ZYv190tHnKyeOFFqNIUw9rRKC3DdZFfKYTgZXuMhplMH4EGAl0x9sNtN5DPylUVHgnojBDQYFapdTE/Nq9TjvNLa77kwZATV76Hccq5LLvH5o6dfopNRQbO/WUKZOrSUCDNoHriWDOHNi6NRNl6/cmjbw8c3VWXl4W55/fieXL3SvCE1nRffPN2ur0o7VNBIcOQUxME/72t++qjw0d+n/063cFiYnJx3V/bRPZgAHuY5GRbmkrUCLQq9w0VVGHDsq99+uvl+J0Sv6fvfMOj6pK//jnTEsmhYQktIQ0elFUxIJixYaisq4r4ogoalxFXHXR3TV2De4qa8Oyxl1dfzqLYAERXewNFARWRBABgVBCDyWE1Jk5vz9OTuZOSybJTEhCvs+TJ8mde+/cOXPOefv37d//zCY9a2PhdsPnn69l48YdlJerhP9du9Rnttth8uTw3V5CKDdSY4LcCQkNc2R16uQVBLqpjbYICgtvoLj4R/75z/+jS5dGUKEeRoRTWbwHJQyeR9UVXN6EeEGrhr/bY8MG+OYbJ5Mn5zBunInJk0O7PcKR+kYiKr1Aw/F1G62C+voapKamM3ZsdFNH/T9nqOcpKfEed7m0qywf/+C2FhppaaHdWbt2bfP5vzmCQI+3xeL9DlpCELjdwa3L5ORuZGQMwG4PMxfWgL17lfsoNtZbULVr10ZcrtK6jmzNcQ3psdLuoXnzPuOdd/7RojGCpKTOdOs2sC6WorP3+vf3kuuFg5ychpUuI3TqbEMZV8bsNX/X0NatP7N27VL2729EQc1hRn2VxQfxVUFtQC/gciGElFI2MpGv9cLl8mr1Bw/Chx8qv7V2WYRye4SLr79eCJzKzz//C5vteiC8/G6r1ZtCGKqvAcDIkVdF3R/p7xrq3j2L7dsDnyc11buxFxXpzTa00Ljlltd9xhrAZrMzevRYTjjBmzZq1HabgtLSvSxfvoaUlDQsFpWY1hKCQGuNUsqQmUKNxapaqqIBA9SG7/G4uf12JRHWrq3GYrE0yyLQf+uAcXLyxRx11KIWDxYbM4Z0b2DdND4cNKWCOC5OWREpKb4BYX/oOIGUXotAu4auv/5FhKiif/+2YQ1A/cHiRCllJ8NPrJQyQR9vyYeMNowbQlkZ9fqtm4KqKtX2yWbbWqd5hVvoozFlSrA0SEFMzG+48MK8qAsC/00gLy+wZ4DNFsfYsd44xZraTMaYmOBaf2pqFiNGOMjJ8ZIMpaVlc+utL/P3v7/KlVfeUHe8uWl/Y8eO4vLLT+GBB26t2+haImtIp4wuXfoeEybE8cILEwCoqipnxow/8+9/N76/08qV6rem3ygvLyUtLZuuXTOx1EqAxgoC7Yo0Xqs3XZvtBC65ZHKLBT+XLFnMXXddx/vvv1Z3rLGCIC2t4RaUwaDremy2+quyhfCem5qq/t+7V1NfHEN29onExTXe2jtcqK+OIKe+C4VCBEMwhw9Gt9DBg6H91ka3R7hQ2o2akVdcMbHJgmDMGAdTpxbSrZuiYk5KygZeJyvrXdLT+7YYgVp5ubJSTj7ZgcMxDbNZ7RppadnceGOhj8WkC39OOSWY0LDXCQ2PR938qKPOYfr0Ii69NNDqCodkrj5kZGRgMpmxWq0tIgj0eGlBUFFRSnV1BVKqL8pstjJ37t/4+OPn6z5/MFRXK4G6cKGyLqQMFAQJCZ159tmNzJ7ttdAaKwjAawno36mp6ve+ferztJRFsGrVCt5++9+sWPF13bHGCIKsLOjTp/Fj4M9hlZxcPzGdnpNWqzrX41FxjBkzVBZhewkWPyGEMAHvoTqS7QZigT6orKGRwAOoorA2DaMgKCuDtLSs2nRGXxjdHuGipATcbkFKCqSnZ9ZNrHCCV9odoifUmDEOzjjDwZo16r633qqCaC3RSlA/w/btXl9oamoGbrcLs9nK9OlFPudL6bUIRo92MGgQvPLKLVRUKF/J8OFX1gmN229/mw0blpGaquoPv/12Bvfd9xrDh5/N739/NyZT81P/3nnnXbbWztQrrlC/oy0IjJTdKqPnsrpN32Kx4nBMIy4uqTaTSE0IKSWzZz9K//4jGDjwLO65x8tblZKiqLr37lWuicxM3/fUY9SYGgIjrFaVKKHnaGyst2n7r79uZsiQdMLLL2keTjzxDAoKXqaiQrm7dFKG3e71x9cHLcAaC38LQAhV9xKsGRCooLJeC2lp6jmffVYnm8wmMTGTrKxhwS9uZajPNfQ74D6gPypQ/A1KKNyAYiM9W0r5SUs8ZLShtTfdC3bs2IbdHuFC9zntXlsg2xhftxCBQSutsSjiNcmBA5IVKxa1mCAw+m27du3NMceMIjU1kw8/fLru+MyZMGWKWryJiaoh+ogRDl555QD9+4/AZrPz1Vf/rgvCp6b25NChfdx77wmMGyd46KHr+frrj5g9+//qPnNz3etms/ceWuONdFtSI/xpy4UQxMYmEBfn3W1Gj/4jZ599AxaLV+1cs2YBb711P48+eja7dyshEBOjNv29e2HePHXeBRfA8uXz+Pvff8Obb97DM8+MpaZGVaA1xRoAfFKbNXQtx6RJ57NpU1HTbtwISAk5Of249NIbGDz4LMDbCjI7u+G1Y7c3TWmwWoNzWNntoYWq0UrVAkqn4H7//RJ++GFx4x/kMKHeYZVS/iylzJdSniml7C+lPE5KeZWU8g0pZQTacrcOaItAV3KOGOHgxhsLazVUQefOGdxwQyEnnRR+oNjjgZdegieeUP9v3vwuRUXLsdkaF/T0d4nogjS1se0CBO+9N6tFgsVS+vLfZGYO5sIL72DXrg04nXcBSit67z1voO2YY7wb8IIFTjZu/B/V1RUYi8deeeUWXn11Up3bpLKyAiFM9OypXGrNdQuBr5asNd5oWQQejxqrcNt0GtGjR3+Sk3tw1FHn1DFa9usHU6fChRfC4MGKg/+yy+CXX75h6dI5vPfeYyxaNIuXXnoQaLog0ONidIdoQdCp09EcbAz9bhOhlTKjkG6MW6hz56a9r/bzB0Oofg7GbCQdMNbIzb2EAQOObzPuoejbeW0AWhAYF25u7lBiYxMBSd++J/PDDw5eeQUef1xJ/2C0CEb/+Kefwpdf6sm1kLKyhzhw4PFmCwJtJVRUgN1eyqFD3bDbB0d9wnk8Stvxf5+MjIHExiYQH69y+r79Vm2CQ4ao9oF68c6d+zizZz8aNAj/yScvBryflB7WrPkJaHwDkWBYvHgxZ555FjZbDCedpNL6oikI/O8/f/6zrF37HeedN4kBA0YAsGPHrxQXryYjYyDdu/cBICmpKy++qKTonDnq2p491eY+frzv+4wceRNZWUMwmy0sWPA6Y8aopr3NtQhMJjXm1dVeQTBx4iwGD27afRsDtxs+/vg9SkvNpKWdSWxsArq4OBxB0Nj2k6A2+vrSRePjfXmiNEwmZTFUVAS6rFJTT+aoo8JjK24NOOIFgZReLcQoCO655/hazRX27Tu2jgHx++8hKan+9NKSEm8j9ttvhxUr3mDfvhx69RrcaP+tyeT102royTdoUF+WLIHjjru+RSwCfwKw+fOn43JV88QTq+rqAb75Rr12zjmwZ4+T55/PDxpvCQe6VqGpG5sRCQkJVFZWUFVVGXWLQM8n4/1Xr/6a77+fw1FHjWXAAFWo9eqrO9myZRcnnRTL7bf3CbiPjmn4xwI0unXrVddC8qyzxtY19mnqeJnN3phUTIyvICgpaZngp9sNDz/8B4qLN/H0079itSbUpcsOrCcb02ZT6yRcinINs7nhugSbzSsY/REfr9aiJsDTKaU6wN5WaCaOeEFgDBRrt4eUErdbvfDQQ5t46SVvkPjLL51s2zYhINPDWFU7c6a617BhcOKJcOKJSuPVJmZjNQS7PVAQgNcM3rOnZYLF/oJg1qx7qagoRUoTa9bcwe7dipc9IQHKy5288kpegAUQHIJgVdPduqVjsTQ/PgDQt29f/vGP10hJ6cWMGepYtAWBceMYPXoK+/ZN4+WXc3j3XV1kdipwKosXK2bWYcPg7bcf5LvvZnLZZfezZYvS8EMJAiOMfvHmCE6z2SsIDh70zrG9e1tmU3O74cwzR7F2bRHJyT1Yv17Nu+7dQ7ONxsWpDKqmaN4NdXAzvkcoQbBnj3LZXXQRZGRAYSHs3l3Dli3FDBqU0/iHOgxocAiEEO8KIS6qzSBqdzAGivXfQghef72ao46q4IEHsti2TZt+TrZuzQuZ7ldSspk9e5R7xGQKNOUbkzoa7DoNbcZqTWbnTldUF6mUanPwZ4Ls1q03dnsnzOZzWLbM25zjlFPg7bcDazGCwWaL49xzf09sbGAgoG/fwY1mGw39PjbGj7+GE04YcVgsgqSkk/n11xxACYGYGLj0UjjvPPX6Cy9U8vHHB1mzJpZt237hueeuYetWdaOMICwUGzf+wJw5U1m3TlGQGgVBc3oG6Gv1/XQmzVdfzeeJJx5s+o3DhMcDjz76Ig888F9iYuLqqDSMbUyNEEKR7jXV/RJu/ClUdbKuMDab4eqr4bTT1P+lpSYKC6e2mRhBOMP3Aoo+el1tf4L+UX6mFoW2CLQ1sGCBopa46ioTK1cOwGRyctxxcNddYLEEUiUYkZqaxQcfqI1g+HClwVRXV/LWW/czf/70JgsC/ywIPXlXrFC9gT7/fH5UJ5y+d0WFd3zGjRNs3ryCiopSXn/9LMBJdvYKJk6EsWND12IYoWsPJk9+gcceKyQ93Tc999RTz4mIW0jDn94jmoLAv9HRZ58pgXrKKVBQoNIMr7wSJkyAnj13UFERy6uvJrJy5Z/Jzb0b6IPHY6ZLl+DFdCtWfMTMmfl8+63yQRrdG821CMA757RFUFZmZf36NcEviiD8rSktCIKxjZrNqrq6qcWGNlv4tOZWa/Bz4+J8Ba/FAnFxlYCZuLi+bcY1FA7X0KdSSgcwFCgCPhVCfCuEuE4IESF97fBBC4Ly8kBKZNiExzORlSvjyMwElyv05mazxXH++QV1rQMvvlj9LinZwrvvPsJrr/2hbiI1VmPTDcY1tEWQmKikl9vdJaym8k2F3tQ++8w4PhgsoxIgD6v1Uc49Vy2O+jiEQAmB6dOLiI/vzJw5D9GzZw4LF27iiiuu56ab7mbRomJuuumuiAkCp9NJSkoCubmCt9/uCTijlj7q8fgKmepq+Phj5ds799waevXyapJCSC64YCnwOlbrktrrH+G6674CQruFcnOP58IL72To0NHY7V5fvhCRFQT6vl26nMKUKdOivrEdPFjO/v37qKyUHDqkuKrMZhg0KPDcwYPD68kcCo3NRgt2vhCBXfO6dlULdOTIu9qVRYAQIhXVqOYG4AfgGZRgaPN1BEaLIBi1BFRTU1OBlJLk5FCbm5m+fQt5/30HVVXK16s7PEnpITGxC507pzfZIgBf95DZrBbqZZcp3qKUlJOiKgjcbjVOwcdHo5z9+7+v+y9YLYaG3R7H7bf/hS+++BNPP30Zr7zyIA7HSObMcTJ8+FnMmzeT4cN7MmJEDu++G7rHQbhwOp3k5eVxqNa3VVlZDOTVUmNHHrqYTGPxYqisjAX+R26u94vau7eY8eNjmDFjPM8+exovvHAsnTrBpk02Pv1UOcRD0ScPGXIu48f/naOPPsen/WJzW0nq67WyoQVBebmd1NSMqM4zgA8+mMNxx6Xw3HOOOnr3Pn0CN+G4uOanFUdCEECgINDW2e7dbae6uEHdQQgxG1VU9jpwsZSytkSKmUKIpdF8uJaANkUrKupzZwiklDgcBbz0Uh4ul3EzjAMmsGpVPjAeqzWLoUMLAJVKmp7en8JC1btSa1lNFQTGYG1sLHTtqm64b1/0eXNqahp29xgpOHQqrUqx3YTJZMbjcZORkc3NN/+Ze+/17W1UXV3F3XdfBwhqatQuWly8iVtvzcNma14v5vz8fMr9I92UM39+Pvp7iiS04NT45BMJCHr1WoLN5m1rl5CQSnx8Z7p370NamtIcunWbRWnpFXU1BH37eli48E2OP/5SYmMDHdVWq28lbXMtKP9ai4QEdezQIfVTU9P4LnGNQXl5BQkJnejUqWtd2mjfgOa1zbMEQPn8G5uWHBPjSw2v4S8ItDtt1662kzUUzpb0rJRykJTyMYMQAEBK2Tbqp+uB0SII5c5IS8vCZDIxYoSDm24qrF20AsgGJiDEvwHlTqqp2cS//50XlLZaC4KmaG3B4gSxsWpCq0268fcMF3pja8jd40/BMWKEg+nTi5gxQ+J0uliwQLJgQREOR/AGdzU1NXVCQCMSvZhDtfA8cCA6rT3dbq9g3rgR1q0TxMXBfffd5MNAarPFMmTIefTrdypCCCoqSlm3bjzwFLm5nzFs2GMsW3Yjzz3nYN68aXXXVVdXsHLl55SUbCEtzVexiJQgEELNOZMJkpLUbjZt2uNRVTgArrjier744gDjxz/J+vXqmKbaNsJ/820MLJam01AEqzeIj/cdd5NJcVLMmjWjzVgE4QiCzkKIy/x+RgohGtk6unXC5fJmDI0dW4DJVD+OXuUzAAAgAElEQVS1hHdz83DKKV8BbyJlhc81RqZSl8uFx+Px4ctprmsIVIBs06YVVFSoJq71UeY2F9oiqM/dA6qewti7oaxsL089dTmvvXYHEFh9GS6a24s5VAtPIUw4nZF3D3k8XtfQp5+q36efHnwTmTTpdRyOx/noo+d45pmxjBx5LVdd5WLjxnP43//u47TTxpOSkkGPHv3qrikuXk1BwUj++tdRASmVzXUNGeemf5zgnXdmU14ePUmgs9Oqq9V3oy0CTYdtRHMEQWpq07OMQgWmfcnq1BiVlcVF3ZUWKYSjP1wPDEf1FAY4E0VClyuEeFhK+XqoC4UQF6DiCWbgn1LKv/q9fi3wBKq5PcBzUsp/NuYDNAc1Nb60CX36OGoleD6gKoYzM4/mww+fQkrJaaddDcD48bG43TXcf/9XfPtt8OYT2k0ye/bDvPvuI6SkpLNsmfqYTZmEZrOvWWq3g9vtwuPZBgyo4zSKBjweJTBHjHDgdrt4440HKCvbhPpafe1kY3FdWlo233//DiaTmRdeeKquHmDOHCdCiLomKg2hub2YCwoKyMvLC3APSekmL089ayS7u2mLoKZGsYYCnHTSHmpqErFagxPhrFmzgBUrPuKWW/6P004bj81mZ//+7fTrdwpPP73e5zqPx03//iPIyuoXsDFFyiIA5esuLYXkZPXFjRr1Zyor3UB0fEPGjKE9e1QdQ0JCYNVuYmLTBV5sbPMozUNdq+suAHJyutX+HtVmBEE4W5IVGCil/K2U8rfAIFRKzUnAn0JdJIQwo8jqRtVeM04IEST2z0wp5bG1Py0mBMBrvutiLVXB6CAu7mUcjieYPr2IDRuWsnHjMl54YXydtutyVSGlh86dM0K6S7SbZP16lQmyd+82RozIYc4cZ5O1EaNVYLdD9+59yMxUkaloCgK9se3ZAy+/3IWysgWA5NprXXW+bSO0RRQbm0Bm5lEMGTLMpyhs2rT8kELAavU1fSLRi9nhcFBYWIg5yO4RCdeTEcYagtWrlbXZtetBHnqoC3/724UhrzvnnN9z221vMmjQmQAcd9xFzJkzlT/96RgfUjqA3r1P4MEHv+HRR/8VcJ9ICwLw+rwHDLgUs7mB1l3NgNsNkyZdwe23n8X//qf6u/buHVhQ2JgOZf5oKheRhtkcPEZiXJtpaeqE/fttUXelRQrhbEk9pZRGItZdQKaUci9Q38c8EfhVSrmhtrXlm7SyXsf6S6qqUr9/UV4Wysvf48cf57NggZOyMm+fQa3tXnPNMzzyyCJSUzM57riLUPECL7Q7acECJ6tXeznVi4s3cc89efznP01zRxgnm8UCycmdOP74E2ufrUm3DAvaNfTaa07c7luALCAbj8dZb8/hrVtX8eqrPzF79iKf1+pru/n446+QkaF6LmRmZlNYGJlezA6HA08Ih21zXU9GGAXB8uXq7169dpGYmEanTqE5lAcNOpOcnKFs2bKSXbs2snt3ESkpGWRlqUqqbdvWsGjRWz4CNBivTnMFgRBei9VmUy4YTduwf7+aC9Hye7vdsHz5In788Uu2blWqt79bKDlZsdk2BfHxzaczh+DZQ8b7amGzb190xyuSCGfafCmEmAe8Vfv/b2uPxQP767kuA9hi+H8ryorwx2+FEKcDa4E7pJRb/E8QQuShup83201ghL8gWL7ciXILbaKoKJWioh9wu31lXXV1OR9++CTTpxexYIGTr756DV96BMEZZ0xgxAgHkyfnBKRbVlQoDbQpm1uwOIE2VcvKlJsrQt0QfeDxwMcfO1m2zNuAHjbz5pt5JCSk+AhLI15+OY9u3aB3b9/PGqrtZkZGNmPGOBgzxoHFEjp1sqnIyspi06bA943knNKLvroafvxR/X3++b35wx92N3jt4sVvMXNmPpdc8ifGjfsrzz23hYoK5W944IFTKSsr4bnnNpOU1I2kJFvQrJdI1F1omglQcR1dVbthw1Z277bQo0f3iGyo/nC54NVX/8uiRTuYOVNJH6MgsFhUKmlTYDI1z5Iwwm4PJKEzjocer/JyDyUl+0hPT40IcWI0EY5FMAl4FTi29uf/gElSykNSyrOa+f7vAzlSyiGomoTXgp0kpSyUUg6TUg7rEk5nijBhFAQffuikrCwPlf0DZWUlITc47f8Pnlcv+eGHD4HQ6ZZN1UD9TVK7HX78UcnnvXvLo6Z5vP22k2nTJiBlIHMoEDKAXF1dzrPPTmH//r0+x4O13bTb45gyxesCigT1tD8KCgqI87txJFxPRmiLYMsW3WC+Jmj6oz+qqyvr6CJ69lStx4QQxMV1QgjBMcdcwNCho6mqKuePfxzAtdd2Z9s2X53J2HOhOTC6h5KSvN/FV199zFdfza+LrUXa/+12Q79+gxkwYCTFxWprMrabTExsuqBLTm5+IF0jNjbwXkZBYDKBEIcAE2vXbm4T7qF6BUGtn/9zKeU7Uso7an/eluFF+YoBY11kT7xBYQCklCVSylp9nH8Cxzfi2ZsNoyCYPbt++ggjhDDxyCNn1+MWUcdDxQ+aqoFarb4LPS4OVq/+AIBdu0oD8psjAafTyd13h+ZXOnRoLzfeWBjy+j17djB+/Hk+x3TbTe0CysjIZurUQsaM8VoOobhdmgMdK0hI6AEIYmN7Rsz1pOF2q59PPikCoLp6LpWV9RnOGpL//e99zGYLp546LuDVW299g7vuep9u3Xpz4MBO9u/fTVqab2f2SFVhGzc5q9X7XSQk9KZTp2Sqq1WOfEBpRjOhx66yUmncZrOvT7+xzKIa8fHNyzIKBv+gsVHjV8VuovbvrDYRMG6oMY0b8AghmlK+sQToK4TIFULYgCuBucYThBBGb98lwOomvE+T4HJ5qRNcLigrC09Lt1hseDxu1q9fXE+gWPk0gnU0s9ubroEK4WsVxMZCjx6q9ZnbbY+KRZCfn09FRf38SiNGOIIGjTW6dOkWcGzMGAcLFhSxYYOHBQuKfISA1RoZX24wOBwOLJbLAA89e86JqBAA73zasUMFVUeMyCU+vmGSfJvNzumnT+C8826lutq351PnztCtm26uY+GNNw7y7bdbsPn5GyJV6GUUBCaTdxPNzT2D884bQ2mpyrSLNEXH2rXrmDbtPj777CNAZQsZEytCNYipDzZb09OW64O/xWo2U8eU27kzJCerE0ym1DZhEYSjQ5QBPwkhPgHq+CellLfVd5GU0iWEuBX4CJVn+IqUcpUQ4mFgqZRyLnCbEOISwAXsRdFYtAiM1oDKezfhnwoJYLd3qvXTStLSsjn33Ens2rWe+PjOZGYe5dOXAJSb5MorHwNUuuX69d/y9devU1FRRnp6Fg8+WNCszcfIi263w3XX/RUlV5KiIgjqc2MZayzGji0IGAu7PS5A0w8H0bAGjEhP78b+/WC1Rt7/5PHomJMS0EOHDg372ptv/nfAsdhY6F9L85iS4mHt2mKOPjqTmJj0gHOjYRGAVxD4d1zTsbVIYdWqn/jHPx6lb9+HgPN9NnAhGi8ITCZF/BiNuJlun2r0jegCvNhYr6A4cCDyLrRoIJyp827tT6MhpfwQ+NDv2P2Gv/8C/KUp924utCCYPdtZm/ceKARstjgmTnyhji4hWHk5qFhBSclmUlN9O5V16QIvvvg8KouWumPNgVEJtFq9Jmp5efBnay4yM7PYvDkwwGoymbnxxsK6z2qklCgp2Ux6ehZTphQ0WghA0zS/xuDuu+/j2muhV696Op00ETrVdn+tN6i56Yp6LFwuF8ceq1T+VavKgEBpGS1BoLOTDh1SvTp0dbSOFURqo83N7U9e3oOsWXMB69b5rpWEhMbV3wihro8ke63//a1WX6tIN8dRFm01YGPhwu8580yV2Rdteo7mIBz20deAWcAiKeVr+if6jxZdaCn9xBN/CEqk5r/RpaUF54XXlcb/+Y+HkSNv5pVXJjFunOC223JYsSIwTbS5E9N/IkmpeIzKymqiYhE8/HBBQK8Amy2Om29+zac1Z0wMTJzoYPDgo8nO7oPT+VmThEBMTPQWr/E9IDr8TN6aC7VDWCzBCw7DhbaOLBYLxx13MgB79uwMem60BIGXO+cA11xzvs9rkXIPeTzQp89grr32ATp1UhunvyAIF3FxKuOsOYVj4cA/EygmRj2nOl4KwNy5c3C5VNxjZ/CvrVUgnMY0FwPLgfm1/x8rhJhb/1WtH7NmOTnuuDQOHAieGSSlp26ji4mBrCwPnTt7WLZsLm+88Uf+9795PucvWODkrbfyqahQeWW7d2/iT3+6jlGjjmH27DfqzoukIJgzx8kDD2QCJrZt68XMmZGnS7jiCgd33PEcildJ1PUQMAoBUD7slBRYtOhTiorWsXTpQk48sQcDB8bxxRcfBr23P+z25mvQ4UALgqqqyJtQmiLhwAGlJm/f/nXQ87Sro2vX+snPjG6y559/i3ff/Y6srCCcC0RO2/Sfo16Ct0RKSnwLViLlHjLWX+yuzbQ1CoLGBHsjmSFUH/zjWEZB0Lmz+uKysk4AlBDQccnWiHC2pQdRxWFfAkgplwshgs/ENgKn08mdd+Y1GAQ1m5V/9qST4qmsLMfp/IxPPnmWH3/8jHXrFjF06Oi682fOzA/IrKmpqeGXX1YwZ84b/OY3Vze6X3Ew6IDU7NlO7rknD49Hq2Rbuf32POLjI0uX4PHA4sVrgCLM5s1Mnx4YINdmOMBvfjOeiopDDBp0LPv27cHlcmEyNfyh4+Ob7zYLF5999h5wKQsWLEK1i4wc3G7VgUxKKyZTGWkGR7fVqloqgtostEtl/35vMaM/jIKgR4+e9OgRvLgiEnNLw18Q2O0QGyuprDTx6qvf+7wWKYvA7Yaff17O5s2SXbuGAOa6+RCM8z8ULJbGs4o2Ff7vk5ho5GdS5sjxx/8G8MYSamqilwjRHIQjCGqklAeEryOwlcq18NBQJgyo4Gdamp6A6lvcvn0rAwceTXHxLxx3nC/xan0UzT/+uIQ5c5xcfnlkNmirVdE0+H+G5hSrhYLHAwcOKFXTbN6PqipWMJnUBE9N9Wqjjz3mTSV1Oj9ny5YNDB06vMH3aWpqYFOQkqJ2FY8nsmqjJk3TLoDu3RPo398raLKygm8CycnUNj5SfDU6KBssXz0UIulO00JFa+lWKyQkCCoroaTEQjdDElikBIHLBQ8+eBtLlnxDfHwVRkGQlBT+OESj/iQUtDDXm7zRfaX/1vxDGm1ZEKwSQlwFmIUQfYHbgG+j+1jRRUMFXQkJqYwY4aC7Svzgk09Wk5ycSkJCAr/97TU89thTgKocrahQkyEtLauuc5c/DhzYyz33KF79W25p/iZttYamaYgkXQKozeCyyx5h2TIYONA3uJqern5CBalPPPE0TjzxtAbfw2oNzswZLZx55ik88ggce2ywQvemQ5v92rVhpIBITKzf4tHxp7IyWLlS/d0Yv3ik4yoWi/d7tdm8G+xuvwLp6mr1uZvKn6XhdkNubl927qxi82YbZrN3/BrjLmxJQRAsYKyhLZhduw5RWuqiUyflX2utqaThfH2TgcFAFTADFQW5PZoPFW3UV9Bls8UxYcIzdOrkDTb17JlNQpBVmZ6uJt5xx0F+fmC1rBEVFeU89lhkyM2sVgL6+2pEki4B1CIvqQ2jpKT4OqFTUtQGYPRNb9++leeff4zp0x8Jer+uXZVm3K2bV6OKdpaQPxITlUpWUxPZvEK9cWreJ2PzlG6BpRRBkZDgpUJoTPOVSGejGAWL1erdYJ944j727o18nMDthr/97V/cfvtiwLeGIBinkj9sNuVGa0mFQr9vMOjvbv782cybN7PueJsVBFLKcillvpTyhFqah3wpZWVD17VmFBQUEBMTOGMSElK58cZCTjvNEbJX7M6d2yirtd3T0lTfVJvNWy1rsYRekcXFkdHWrdbgNA0xMZGlSwAlCPbWMkQY3Td2e3Dt68UXH2PatHt48sn7yc0V5OaKOtZVrVmaTOr69HTV0rO53aYaC71ZRHpRut3KTaAF55IlL7Bz53rM5sbx3GRnK+Ui3JiJEJF3rfkLAi2sV61aSUnJLp9zIyEIXC41djsU6WhdDUFcXMOulPh4NZdaKsZkRCjBo+e0xdKFykqvC7fNCgIhRD8hRKEQ4mMhxOf6pyUeLloYN87BhAnGerhsBg58g5df3sOIEQ769vVdWI89djcnn5zB/fdP4pxzBnL00Ym88sozAQG6MWMcnHVWaKrhnj0jo61brV7Bk5DQCd0tbdKkyNIlgNrcZs+eAcC+fT/WHQ/W4WnOHCezZr0acFyzrs6fH50ewY2F1uLWrVvPd999F7H76oyhfbUZoy5XEWazNaCLWEOIiWmcHzkhoeUsgvPOu5euXX3zqCMhCGpq1Nj5Zww1pCTY7dGpHA4X8fHBv1v93P36nc/EiV4HihZ4rQ3hTM+3UA3r7wXuMvy0WbjdcO21k7niirvo3ftroIghQ9QGmpQUqL2tXbuSnTu38eOP39cV06SlBW/Q9vTT/+HJJ1/HbPZ12trtcTz8cGS0db3ox4xx8OGHK8jI2AYUMXSoI+JFZR4PHDyoPovFsr+OxTGY9jVtWj5VVRWBL6BcYw8/HDne/+ZAj5/HY2LFihURu69/Mdl1191HSkpGVDVVIcJznTQW/jEHrRh17Xo8Npvv7txcQSAlrF27lqFDE3nvPZVqrTf3+tyGRuqNw4VQ1pixCM9YWRwNsr5IIJwQk0tK+WLUn6QF4fGoVLyrr36cjRth/XqvDzdYmtrVV99Cr14DGD78TM4555KQvPag2CxVqqhg2rR8tm3zVtmOHx8ZbV0ItVBdLsjMzKZ7dyguVhkKHk9kc6g9HkhPP5WtW1WwODMzNB98fX0GIPKB7KZCC4KEhFTOO++8+k9uBPwFQY8eidjt0Y2B6ObykUYoQVBern6MxVq6X0VTrRKXCw4c2E95eRkmk4oM6wBxKJeXxdLyLsVQ6NRJdXIzavpamSwvVwklxs/RGiuMw7EI3hdC3CKE6CGESNE/UX+yKELv4xUV3lQ/3fs12OQaOXI09933JOeccwkAJpMJUwhbf84cJyNG5HDnneMBePLJ11mwoIjLL3dEdMEaJ5LONS8tjTzNhNsNJpPitcnM7FrvphYqgK0R6UB2U6HGzkl5+RB69+5NTk5ORHoX6w1RC4Lk5KY3SQ8XkWbV1AhVVLZ27Wr+97+ldUyhGs2xCmpqYMiQYcyff4CMjHMBNW4xMaGDsS2ZHdQQzObA59SCrKSklJtuGuXzWqQ5miKBcATBBJQr6FtUr+JlwNJoPlS04XbDBx+8x/PPT2TbNhW96dZNfaHNITybM0cVeRUXb0JKWecbnzPHGfHcYX2/srIyVq5Uhd6lpZGvXFRVsurvpKT6tdtgAWyNSPP+NwfvvecE8vB41Pe0adMm8vLymi0M3G41Xvv3y9r3uS2qldJxcdHTLP3jX1oQrFy5lA8/fIclS7xBcWi+IDCZTFitnSgtVTtq5871B8CjTUzYWPgLTv29ezxx/PzzMp/X2qQgkFLmBvlp05XFHg+89darfP31PFwuK/HxaoPr1Cm4v3H79q3cc8/vGTv2dHr1MvlkwhgRqshr2rT8qAkCm83G3r1rADhwwF0nCCJhGXg8UFy8gwMH1M169KjfH2vsMwDU9QjOzo5cy8lIoKAgsPdEJHoXu93KPVdeLoBqli59NaqFctEuwjNquVoQpKQcRVbWsYBvsVRzCsuMvcN1hlpKSujPZza3vqKsYI1qbDYJWHj00YU+r0WavjsSCCkIhBB3G/7+nd9rU6P5UNGGIrgaSufOpwP1u4UAtm3bwowZL/H999/U9Yw1avve84L7wLdt2xzxiasXqc1mo0cPFY08cMCD2600jorgMdtGwe2GZcvWoFjE94el3eo+Azt3Sg4edCGlpKioqNUIAYCtW6NTjOfxqIYtAAkJNUyZErphT3NhNkc/Z75LF68LRgc/u3Q5juHDxwLKAtVoTlpkdTXMn/8uU6fmUVWlNtG4uNDWZ2tyC2kYLQKtLOnmNLGxvi3qdHZZa0J9FsGVhr/9qaIviMKztBjcbrjqqvsZN+5twCsIQmkg2dm967RbI7S2rxHKR56enhVx/hPdCAPg8suvBaCy0orHE7lYgWq8rdI3bLaDYQc94+PVmEab/bGpyMyMTjGe2w3bt6u/e/SI55JLAjuNRQpxcdHPljGZvDEOYxaMRlWVd0PT8ZGmoKYGfvppGQsXKs05JUV9tmDzx2JpGWLCxsIoCLSA1u6r/fvVOBn7ObQlQSBC/B3s/zYFj0dlKmjtTaeghdI00tK6hswUMloBoXrx/uUvBVFZtNrK0AHDgwfVBItUbwKPBxISBgOQm5sZliuiscVThwNTpxYAke1drHmGjAVR0cwMaSkfudZ/vILAw9693o6zzXUP6bz6UaPGMnr0M4CaPzZbYH6+EGqtNpfOIhqoTxDMmfMcH3ywjrVrvee0tjhBfUMqQ/wd7P82BY8H1q9fxaZNahZ361a/hjVnjjNklpDRCgjWi3fatEImTIiOW0QLgu3bVS787t0HqahQCysSgsDt9hb4dOpUP6uj2ay0xx49WoYCuDlwOByYTIWA+p4iEcPQeoIWBBUVP7Ns2afNfladp965s3cDbAm3kBFG4b5vXzn33Xdy3WvNFQTaisjNHUJ6+jmAeq9gn89ub31plxpaEFgs3r+1IFi4cB7FxT9TXe0do7YkCI4RQpQKIQ4CQ2r/1v8fHc7NhRAXCCHWCCF+FUL8uZ7zfiuEkEKIYaHOiSTcbrjrrtNYskRVynbtGlrD0plA7iA7q90ex5QpvlqksRfvL78UccstjqjlkWtBMGuWCtkUF++oey0SguDNN5387W89ARMrVmQFBMeNSEpSG1a0m8pECjExVwFFzJ37eURiGLqGQGfSLF/+Is89d2+zn9NmUwI2KUkJ2ZQURafQkjCb1fsLIYEEYmK8vpnmCgK9IRorsjt3Dh4Mbq2uRlBCWgj1fek1oNf9Kaf8nvT0AYDXtabJ+loLQi5bKWWz9DohhBnVo/FcYCuwRAgxV0r5s995icAfgMXNeb/GwOOhlhOoN6AsglCbdbBMIFAZMfX1401JiT6ZmtaOunVLoqwMPB6vNGuuIHA6ndx2m7dnQ1XVFu65Jw8g4DObzS1LIx0JmM0SEFx88W+QsnldxMDrI9eCYMCAXE4/vfnObKNmbLUeHo1Yx6O6dBHs2gW33eatxtaVsxZL0wSBvubTT99n9epBQO+6GgJ/tGZBAGoMrFavRazX/6BBY+qE96FD3hhHRUXrSYONprftROBXKeUGKWU18CZwaZDzHgH+BrQYkZ3bDY8/vhPoQUyM0rhCxQdCZQJ5PJ6QQiAxMXqFPkZoLWTatJcAiI31qorNFQTBejb4B8fNZjVuOrjXlmCzqQe2WOKojkDkTpv9WhBcf/2d3Hnnw0HPNY6VbngeCq0hTVILgr61yS+//ur7uq4z8S8yCwfaInjxxXtYuVLpiJ07B7qGrNbWb236CwKtHBkz+IzB9khk9kUK0RQEGcAWw/9ba4/VQQgxFMiUUn4QxefwgZRq8ulMwaws74bmj/j40JkkoTJP9MbYUrBYfCecNjc9nuaRW4VKpTQKxqSk+t1qrRlWq9qNi4qKsUUgpevQIV+LQPeyMMJiUdZnVpb6ychQ7p76SNNamlY5GMxmJbz69VP/hxIE0Djft1FwDBs2irg41b4tWIygNaaM+kMLAl2Mpy2CLVu2UlS0HDgyBUG9EEKYgCeBP4Zxbp4QYqkQYulu/84YjYQ24TfV9pDJyvJSI/sjKUlRVsfFBWaYTJ1aULcBxsUpC6BLF7UxtqR2rP23ABUV0ieFrznkVqEEoA6OH44+ApGE1i4jQQvscqkNcP9+tdCtVondXkqN4eZWqxIOdrsaO2Mfh7g4lZXj704MljlzOKA13AHKzc3ChRtYt25R3etGQdAY48ooNMaNexyLJRdQ4+BvCbV2txB4BQGoMdNU9l9/vZhZs1S8yBgw1pXorQHRnGbFgJHVv2ftMY1E4CjgSyFEEXAyMDdYwFhKWVjbC2FYl2ZSObrdsH9/KU6nYjnMzg6ubdjtaiE6HA4KCwvJzg7MMNFcMl27qsl7ODRjsxmmTZsMQFmZy2dja4576MILA+m0jcHxUPS7bQV6wUZCEOj88OLa2W23l3L55Unce+/NdeckJdXv2khOVspE585eRaI1WAPgFQR9+4IQ1bhcvdi+3auQVVWpqmD9d7jQm6DOsS8tpY7d1hgLaeksqabCKLgtFtAN/SyW4fTo0a/uvNZoFURzKS8B+gohcoUQNlSB2lz9opTygJQyTUqZI6XMARYBl0gpo8pjVFMDW7duQUplhmZnB04ym83XXHc4HBQVFeHxeHwyTKzWwx8ktVi09lQNWH0mWVMFgdPp5LXXXvM7KrjssgmMGeOISiOUlobeaAYNOparrrqKnJwcTCZTkwjo9JjrYrKEhDLs9gTi4pRmUF+Nij+0haetzNYAvbnZ7ZCVpczM2Nizfc7RVkFjBIE+98ABNxs3Km6JYPG6tuJ6NO4jZjP06aPWpsuVzpgxT9a9ZqzIbi1ppFETBFJKF3Ar8BGwGpglpVwlhHhYCHFJtN63Ibhc0LlzLiaTyoDNzPT9Ai0WZcK39lx4DbMZ7rjjIRITzYCTiy/OoVcvEyNG5DBjRtNI1PLz8ykv98+Uknz55YfExirfdmsIYjYHWjt3ufby1ltvsWlT0wjodNoowLZt6nffvhl8+eVBHnhAFUjZ7Y2znpKTlZXZWoKjei1YrTB4sNqlly+P93E96s1NF2s2BI/Huwlu2LCZBx5QylW3boFzqy3EB8DXJWyxKIUyW9FusXGj9zWjK62ylfR6jKpxL6X8UErZT0rZW0pZUHvsfinl3CDnnhltawDUJN22LQ6Px1xHg2AUBKHiBa0Vqsl3CjExbxj3L5oAACAASURBVAJ57N7tZT697bamMWrWFyhuS7UC9UFbBMnJ1bj8dq7GENAZfbya0jw11de10ZZjKeAVBBYLHKv45vjiC/jzn73WUGO1XN07A2Dv3nJstiGAEgT+mnVbcAv5Q2da5aqwBxs3yjqesvJyr/LQWniH2tCWFxm4XLBGkXXWSWvjRGsLQSkj9KZcWhrIqFlR0TRGzfoCxW1xUQaD3qgPHNgV9PVwCeiMi1hTlqSmequwdX/mtgydNaSUjpWcfPKbJCaWUVwMS5aoc2pqvP7uhgSBlN5CNCkhNXUwI0f+DVCWkDGJq61YA/4wm9WPFgRvvvkO+/Ztr3u9tbmHjkhB8NVXqwEoLf0Mm82r8QjR9rQPsxleffVZqqs3BX29KYyaBQXBOZP+/OeCNuMyawhaEKSmNo+AzpgBsmeP+nvDhne47rozmD//XeLj216NRTDoLKeSkq0sWjSOuLiXAfjR28a6zuVRVlZ/fOrgQa/7SKc8a2vK3zXU1tajhqaa6FVH2D+Uffu21b3eFPdQNBvfH3GC4O23nSxefBZgYu3ay/juO6/rRKf2tSXMnOnk8cdDsnc0iVHT4XBw8snDgSRAYLdnM3VqIePGtR4q6ebCq7H3q+tDrdEYAjojRYKuITh0aAVLlnxNScmuNhPobAheV8dQRo++i1GjVErM998f4LXXpgC+cQJNF2GkUaipUQF13XPAeI22prp2bR+CwGxWwjMjA6xWD9CLVauG1QnApggCI3tppHFECYLXX3fyl7/k4fHsBCRSljJ9urenQFs04fPz86msDJ6DZrc3h1HTBBQAHq65pogxYxxtdlEGg7YIdu0yk5CQSGJtGlRWVlbYBHTGwKhREPzud9cwY8YXnHfe6HYzZmazGrOkpK44HI9z/vkX0LnzITyeJObPX4jH4/Fxd5SVKS1/yxY1LjU1ipDP3w1y8CB8/fUbFBer3bBbN2OvjbaTtOEPHWeMiYELLlD/zJgBOhmvqsrrHgunnqCiIrpN748oQRCMNqGqykub0BYXbX2un6lTC/nd75qmxf/tb9Pp0+diQBXKQdscn1DQgmDgwBO45ppJHKxdld98802DQkBXbBsX79atarOLj4f+/Xtz8sln0qdPz2g8+mGB9nkbccIJytwZNepjTCYTLpcKhGpoJtyDB1WNRTB3UWkpbNq0EyljsdkO+SQjtPX5ZjKpMbvqKvhjbdnsd995raRdhvDUvgborqJpDcARJghCdabatm2zT6VnW0Io109aWjajRzuaHIjq1as/Qqh7d+0afCNoy9Df9fjxt2M220hJSWXAgAE+1cDBIKWi5t62zZd585df1O+0NK9roy3Op1AwNkIqLd3DDz98SNeuKuvil1+8RSVGq6AhbN9ewm23DURKFVHt0cPcLtxCGnrMysr28u23V2Kz7eDQIW8qaUmJVzhWVIR2Ean2p9F91iNKEGRkhM6Gaat58cECuwCXXnqPTwepxsLt9vpy21JdRbjQm/SyZd/z7LMPUVlZyapVq+ndu3fIa6RUAeHycjWuOnVy/35vDUFqKnzzzX94+eW/s337lpD3amvQriGAxYvf4vHHL2LjxmnExKiNTff2MPq+G8KiRd+zbdsvdYHijIxYn4yhtromNbRFEBubyPffv0N19fsA/PSTet3j8boTQf2tu5np13fsUMebwxsW1rNG9/atC/n5BcTEBGbDTJlS0GYnncPh4JlnCunRIxvVOC6b3NzTOPnkK5olCG644SpKSpS60n4FgZP33rsKgJqaGv75z+A1F1KqTb+42JceQEMvVlCC4L33XmDq1Cls3VoUlWc/HNDBT5USeTw2m52FC/9Jly4qbegvf5lKSckWDh4Mf9MymZI5/vhLqKhQZfzGjCH9Xm0ZJpPOHrIyefKbjB17JgArV3rPMQqCmhqvUrFnjwqst1TB2RElCH7zGwdXXqk6U4EgOblbXU+BtioIAMaOdfDxx0Wkp3uAIm6++WsSEpKbLAjcbvjkk+8AM7GxlSQktP1F6Y+tW51AHi6Xcs7W1FRz22038OSTz1Ja6k3Vq6xUAc/du4MH61wutXh16mhqKlx00VVcf/0dZGdnBl7QRqG//06doE+fExk7ViUhJCd/A4CUv2PdukUBcYJQqK6G9PThTJnyHgkJpwO+geL24FYzCrOTTvotI0f2RQhVx6RdtqH6i5eVRTddNOBZW+6tWgd69nQARZx0koe3395R11OgLQsC7YvUDS+0S6eqSmlnjZ1Qe/bAySdPABTdQUxM+xMEy5cHFuBVVVWSn/9n9u5VWv6hQyqgV18nKR3E05pdWhpcc80t3H//k/TqlROVZz8c0N+/Zro9//zJTJ26DIdjJLGxHmAo2dm/o7j4F1auXOfT43vv3j289darPhXcGzeqDbCqClbU9rkZPLh9xVe0RaCRmAg5OUp5WK1KmZCyce60aOGIEwS6p2znzt7Sf6u1bdFK+MNk8rI2AnzyyXx++GF5ndbRmIDxwYMqcHXJJQ8C0L17bLsUBIcOBU8c0Km4ul9zQ+0EdXDU6Bpqj+Ol14duYm82W8jNHUpOzkBOOEG9uGABvP32A1x5ZT9mzfKSFl5zzXncffdEXnttOqDW4L59UFFxkB9+cFNVBb17+wba2wONiTEBpaRkK/Pm/Z3kZMWis8jL4t1gxpBGR/poBLFjh1rZnTt7y9cj0JfksEJbBFoQLFt2AY8/PoT169X/4WYcSKncHKDSIaF9ZgwBJCYGTxzIyMhu1H105pAWBOnpsG7dzxQVrQ3a57qtQtNMxMYGWs+nK88OX38N8fGpJCd3p7w8lcpKNxUVMHr0lQBUVLhZuRKKitT5Tz/9O555ZiYAJ52kjrU315BWNvfv34HTOYXi4ocAWLqUoMVloSClNyEhGjiiBEF1NaxYsQqAefP+WFf12dYnnbYIUlN9jvLjj0qjragIj5L64EF1Xnl5OV98oTQX3WmrvQmCESMKgOCJA+Fi9mwn116bw7hxJvbuzQGcpKfD5ZefyogR/SltTC5lG4C2CrR7SGPQILDb97FnD/Trdy92eyceeeRSPvqoiB9/hOHD7+bLLyUnnDDFJx++uloCqlblxBPVsfYkCHSXMtWkZjDnnPN7LrnkEjIzldtRu8Sqq5X1WR/27Ilu74IjShBUVEBpqZphFsvuuondHiwCUD5Wq9Vrvm/erHzYRpKvUHC7vZrJunWr+OEHZU706OH7Hu0FRx/tAAqJi1MNhzIysusSB8LBnDlO7rknjz17NgES2ATk8d13TrKze9OrVx9i23oivB/0HPDvDWUyQVKS6jb7+ecuUlOzSErqxoEDKi+0okJlwPhnE1100UdAIjk5so51VLN9tAdBoHuKJyaCzWbn+utfZOTIGxk+XL1udA8VFYV24VZVeS30qD1rdG/fulBRAXa76rd3992P1h1v65NOCPUzcCD8619w443q+JYtXgGgBUIwVFYqs1NbDS6XC5NJsWX1rC2ObW+CQAl/B6NGFfGf/3h45JGZ3HvvzRx/fNcGr926FR57LJ/KSn+fWzn/+lc+c+cu5Ycf1mFvi5wl9cDYlD3TLyFq3LiBgGT9+kwmT57HP/6xg379TuHvf/8Nr7wyidLSPVRVleN2ex3d33+vfp90ktr99XBpN1RbRygLyigIdFc7t1tlE+3a5VtHsGkTLF8efYbSI0oQHDrkDcwMHer1EbeHwJTmbbdaVR9m8BUELpfifnG7vU1BND/Ojh2+rqPjjx9OUtIJgFrwusdue4IW/vpz79sXz6FDB9m3b0/Ia9xuWL9eCYJdu4IHm/Xx9jCn/GFUBjIyfPssnHji8SQm/oLLJXj//Z8BKCvbx7Jlc/nqq1eZPn0c112XwIYNyuXocsGyZepaHR/QMbu2rphp6DWjO81VVpbxyy/fUFr6LWeeqbL5XnrJm5BQXg4bNsAPP6h59tNPwS2pqDxr9N+i9WDfPrUBxsR4/elWa/vRPmJiYP786UyeLIBSSkt9TcrKSqWBbN6sJpg/TYLGunVqrIRQC769WQPgdQfqgF3Xrv245Zbn+de/5gWcW12tfLQrVnh9uWlpwYPN3bur4+1xzPw/U1c/4yk2dj4AGzcqazIhoTN//etyxo4toFOnLphMZkpKVLX1ggU7KC+HhITiOvej9qS1N0EQH68+08qVn/HQQ6fzzjsPcfXVKmFl3Tr4/HPf6zSNSUv2M46qIBBCXCCEWCOE+FUIEcCVLIT4vRDiJyHEciHEAiHEoGg+j+Znc7nWsGbNd0D7mXTaIkhIUKlDQqigeFGRb9ZQQ+mQO3bAz0qhIyVFTeL2uKlpRUCnE1ssNk477RbS0y/k55+9G35xMTz7rJNRo3K47DITkyfn8Mort1BZGcgCZrPFcdNNd3PKKZmMHHlaC32SloO/VZiS4qtEPfDAHQCsXduJBx64gDvu6Etm5lFceOEdXHvtdP7970OcfPLvkBIWLlQ3s9k+rLteu4baizVlHK+cHMjOPoZevYaRlTWE+HjQ3IYffxyo9Usp2bt3m48rLarPGq0bCyHMwPPAKGAQMC7IRv8fKeXRUspjgceBJ4kiFN10Dm73AP7wh98wZ46z3QgCk0kJghNP/C0vvrids846GVDCL9yCldmzVc/j228XQA6lpY+1y5x4gIsuUpvYjz8qQblggZPJk3O44AITEybk8NprTn76CWbMcPLyy96g8J49m/jkkxcpKyvxuV98fCq33FLIuedejMfjYd++vcHfuA3Dfx4YixhBCde+faGmRrBpUxY7dvxa15UrMTEVi8VGRQW88AKsXNkVISRXXTWs7vr2KAi0oExNhYEDcygoWILD8QSgMqUSE5ULV6d6a1RUHGTSpAwmTuzEihWfAMqV1pAi1+Rnjc5tATgR+FVKuUFKWQ28CVxqPEFKacyvi0elX0QFTqeTTz/NQ2V3wJ49O7nnnjxmz25ag/fWBrNZuYZstliSk7uTlaVm4NatSuttaALNmaN6NagND2ATNTUPMXeus90sTCPS02HIEOWn/c9/Ajf755+/mt/9LoEXXriG6uqGCzHs9gTOO89Benomb7/9DY899lj0P0QLI5hC4JuyDCcr/QO3+x+cf/5+iop6sG+fcq99+SXceacqPIuJgVtvFZx66nGAbxFee1HOwNcq8A+wW63eGgx/99ChQ/uwWGxcfPHdZGQMYOlSuP12GDMmOjGDaC7xDMBIv7gVOMn/JCHEJOBOwAacHa2Hyc/Px+MJ7On70EP5TJzY9jtvaV4Tq1VtbnrSbdqk4iI7d3pTQYPh8cfzqary3/CqmDYtn+uua/vjEwxnnaUsgq+/zqemJnCzr6oKwjAXAnv2bMZsrgRi6dOnF92792rwmraGYIIgJUXFW3Smy7nnKiv0q69MfPRREh99pI7reQmQm1vDzTdbfTZGY6Zte1I8TCZvQkJMjLKgiotL+eqrVzn//MmcdZaJDz6Ab7+VlJU9zNlnn8Sxx15Aly7ZvP66ShXatQv+8Q91j9NOi05M87AHi6WUz0spewN/Au4Ndo4QIk8IsVQIsXR3Q5UXIRCqgcuWLY3v6dsaoRfpd985ufpqG488ophIN2xwUlamfN3BUtAqKmDVKti+PXSvhvboGgI44wy1UGtqIjEHJNOn38L+/XvblUZrRLB5IIS36BDUhv/730N+Ppxzjio2i4lRQiA2djUwgTFjPmDHjjnMm/d3iotVIwftFtLFke0F/p+la1fJo4+ezf/93+0sWPAGGRkqa6qqSrBkyW08/fTb7N+vfLnl5fD++/DIIyrj8dRTYcqU6DxnNGVvMWA0hnrWHguFN4EXg70gpSwECgGGDRvWJMOoS5csdu0KbPDelJ6+rREmk3LvPPdcHm63ZpnbDOQxaxZMnOhgxQqVWlpZqSaWxaIoJTwelQXjdQt5kZSU0m43tpQUtQi/+y4L7TJsDubNe5Uvv3yHp556gRtuaH9WVCiFoFu3wA5kRx2lfkAdV60r92Ox3EZ29jFMn34Vixe/RWpqTzIyBrSbKn9/+AuCzp0Fo0ffxkcfvURGhgqZTpoEFRUVrFjRmaqqf3LHHXDMMYqYThenJyfvIT8/LWoZjtGUvUuAvkKIXCGEDbgSmGs8QQjR1/DvRcC6aD3M6acHpxRoek/f1gWzGaZNC+beKefrr1UrTrdbsT5u364m2Ny5TiZNUhQJlZVlqPi+Lw4dOshbb7WPOIo/hICJEyEhIXBuNBVlZaXcdlseTmf7HLNgVfhms4q5hILZrIqq+vUbTq9ex2M2Wxg27FJGjbqdnj2PIiFBEc5B+3ILQXDr5sorr+bBBxfQu7cKlFutcNdddiZMgF69lKK2eLFao9nZh4DR5ORMJCEhegUFURMEUkoXcCvwEbAamCWlXCWEeFgIcUntabcKIVYJIZaj4gQTovU8VVWKUkCIREBRCjz7bHhNytsCTCblxgmGqqrNAVxDCxb4BkjLykqQMpCQqKammnvvzY/CEx9+aC6Yu+92IEQhkNrgNeGgoqKc/Pz2OWbGIjIjMjK81CbhYMQIB9dc8xS5uYPp29fr9z4SBEH37iZsNoGUkk8+eZGnnrocqOaCC6CgAJ56CsaPV4H1qVPjyM3dQXV1dJsWC9kSZWsRxLBhw+TSpUsbfd0TT8DMmWqAzz1XVTH26NG2+xAY4XZDdnYOxcXBXRx2eyoTJz7DiBFK8E2enBPUFRQMQggffvn2gkWLvEyYCxfCc88BOIGrm33v9jpmbrfKRAu2bbhcig6hPrrkJUtm8+23b3L++bcyYMBp9OzppTEBlYWUmBj6+raG/fu9jL5GbNumgup33XUUW7euYtiwS7niikfJzDwq4Fy324XbXUOvXnZGjGj6swghlkkphwV7rR2FZerHXXfBtGnednhCtH2yOSNMJpgyJXj/YoCKihJeemkiCxYol8WePeEHSNtLHMUfRp/3qacqN1Hnzg5UB7tAaNeZyaR+p6Vlk5AQ3Ipoz2MWikLJYvENHAfD8uX/ZdGiWWzYsAyTSa1HI9pbjCDU5+neXVlRY8b8mYyMgSxd+h7//e8zQc81my3YbNHlrToiBIHT6aR79+6cdZZg0qRM3n/fic3WPqglNISAyy5zMHVqIeYQUT2Xq5o338xn587QfPz+aE9xFH/4f//nnquKnW66qQCz2Veg2mxx3HLLa8yYIXE6XcyYIZk+vYgJE54J6IMdF9d+xwxCu4dAbez1Zf1cdNEf6dt3OD169CMtLXCjbG+uobi44ONhMqkU77y8q5kw4VnOOONahg4d3fIPWIt27xpyOp3k5eVRbuBZsNvjeOqpQm66qX3EBzR27FCBpl69TIT+XgVCeJBS9ez1b9doREZGNgUFBUyY0L7GSWP1alVHEAwLFjiZOTOfkpLNpKZmMXZsQZ1bzR+bNzt59tl8tm3bTM+eWTz2WEG7iT2FQnFx6BaoW7Yo10eoKdili7LK9W8NISC7cX2B2gT27MGnD4M/1q9vuB8BKBdatFxD7V4Q5OTksGlToC88MzObzZuLIvhkhx9796pMgxEjQscKIBuzuYh+/WDbNicHDkwAAoPE3btn8913RWRnty/LyYidOxUV8qHw68YCkJIC/fp5/+/a1cui2Z5RVqY2uFCQUp2ze7cqNtP9e9PSvGyc/rDZ6s8+aquorPRyWgVDdTWsXOktygsGk0ml4w5qBhvbER0jCFVItnVr+ygkM0LHPKZMKcAawjlpsewhNjaN1asFBw9qIeC709tscfzhDwVYLO1XCID6bMZAZVPg7xNvT3Gn+hAfX78bRzdk6dULBgxQwrJXr9BCANrv2MXG1j9WNhsceyzk5gYqEXa7lw7FvyFQJNHOPHKByMrKCmERtL9gnl5IusvWQw/9gf37fcnRXK5DuFxKBfZ4tCUgUcJA0q1bNnffXcBllzna7cLUEEKV/CcnB8/saAjx8b4bm+4dfSRACFUbUFLS8Lnhor1k8AVDYmL9Tep14LxbN1Xtf+CAEgr1Cc5Iot1bBAUFBcTFBRaSTZ3a/oJ5xt4KY8Y4+OGHPfToEa7TVZKWls3ChUVcdpkSJO15YYJ3rPr2bVzKos6O6dPH93h7Hy9/6H68kUJ7VjwSE8O3ru12Nb9aSgjAESAIHA4HhYWFZGd7e9NOm9Z+CsmMECIwC2PHjvBdYCUlvrxC7X1j0wvTbFbuCyOlcjCYTIpX/rjj1G//NMr2vJEFg7YKIoX2PH4mU/3ZVocbR4Qh63A4cDgc7NypzK5ITt7WBiMTJEB6elY9gWNf9Ojh6y47UgQBKGHQv78Kbu7dq0xzj8dbfWyxqHhCfW2I2/t4BUNiogoK1xfoDAftpVNgfUhKUkRy/lX+rQHt3iIIhvZWtGKEv1ZVX5GZEXZ7HHfd5XWXtbc6i2AI9vm6dFEC4fjjYeBA7+++fesXAnBkCgIhVCZQc+fKkTB2FovKKmuN66pDELQzJCT4Zh6MGaOKzLp3zwg411Rb6ZKRkc3UqYV1QWY4MhZmfdBEaeFSIlss7Ys+uTGw2RRdS48evn0FwkFsrAq6HynzLSbGS7DXmnBEuIb80d59kV27qgwF3aJSb/D33JNHRYW3gCwmJjZAAHhfa5HHPayIpGbWmv2/LQG9prp0Uey2oMY3WNFZfLxykZjNaq4eaQI0Pl6NS02NmjclJfXzM7UE2n1BmRE7dyr/XHssWgmGXbu8jetDFZllZGSzYEFR3f9JSWpRx8a2z17FRhw4UH9KX7hITm4c82Z7h8ejNncpvXz6OnYVE6PmVk2Ner09K2Xhwu1W4+TxBI8hWK1ejqfmxDfrKyg74iyChjJD2hPS0rwNQ0JRVBuPWyxqQ2uNPsxoIC5OLcDmBO8SEjqEgD+0hu+fVWSMsbRn92xjYTZ796WUFNVJsLparUe7vWXW4xFllNntDQf82hNMJjWxQGUPBUN6ehaJid7JeKQIAVCbUUMkaQ1d79+8vQMdaA6EUBZTp05KUWmp9XhECYL2xHMeLuLjldb6pz8FZg/Z7XE8/HABqakqNVK3CzySoAOdjdVQ4+JU0c+RJDg70H5xRAmCI3XRpqXB5MkO/vGPQnr2VIV12dnZvPxyIRMnqkDxkTo2oIRAerqynuqjiDCZlNWUnq6CnO09htKBIwdHVLC4Ax1oCJo1s6JCZXLotFApVSygw7fdgbaKwxYsFkJcADwDmIF/Sin/6vf6ncANgAvYDUyUUoZXBtuBDkQBmjXzSHQjduDIRdRcQ0L19XseGAUMAsYJIfzZtH8AhkkphwBvA49H63k60IEOdKADwRHNGMGJwK9Syg1SymrgTeBS4wlSyi+klLrCaRHQTHb4DnSgAx3oQGMRTUGQAWwx/L+19lgoXA/8N9gLQog8IcRSIcTS3eH0dOtABzrQgQ6EjVZRUCaEuBoYBpwR7HUpZSFQWHvubiHE4Y4jpAH1NOo7bOh4rsajtT5bx3M1Dq31uaD1PFvI5iTRFATFQKbh/561x3wghDgHyAfOkFJWNXRTKWUUG7aFByHE0lDR98OJjudqPFrrs3U8V+PQWp8LWvezaUTTNbQE6CuEyBVC2IArgbnGE4QQxwEvAZdIKXdF8Vk60IEOdKADIRA1QSCldAG3Ah8Bq4FZUspVQoiHhRCX1J72BJAAvCWEWC6EmBvidh3oQAc60IEoIaoxAinlh8CHfsfuN/x9TjTfP4ooPNwPEAIdz9V4tNZn63iuxqG1Phe07mcD2mBlcQc60IEOdCCyOKK4hjrQgQ50oAOB6BAEQSCE6Ha4nyEYhBCtspuCEKLVkjF3jFnjIIQ47Fl5wdBa1yS03jFrDDoEgQFCiAQhxNPAf4UQLwkhLjvczwQghIgTQjwPzBdCTK7NtkIIcVi/v9rxegr4QAjxqBDirMP5PEZ0jFnjIISIFUK8CHxRm9Bxdu3x1jBerW5NQusds6agzT1wtCCEyABeBwRwIfAVrYf76E4gFf6/vTMPkqOq4/jnO7u5TCAYwhEMEJdkIQFiRBREikoZgnIpyFElyJUIAnIZouCBgGBEURQJAiqKEeWwIoUXEIWAXKKCSQCNGiqxUJArHCESSDY//3hvksews5tlp6d7Zn6fqq7p6X6989lfz5v3+vV7rzkGGEzocouZrc1LSNI44CagC5hGmDTwc3n5dIPHrG9MAzYnDOpcCvxA0uCc41XkPAkFjNmbxQuC9awizJB6upn9F7gRWCBpYh4ykgbH13ZgIPBTM1tsZhcDz8RaZZ61j5XAd81sppn9ldA77ElJuc0X5THrG5KGpW+B+83sOTP7IXA/MCumy+tpFYXKk9AQMXtTtGxBIGl7SVdKGgJgZs8BdyZJtgY6gL/X2atT0k+AyyTtGsdjDAPemyQ7EThK0uh61T5ivNbVxszsCV4/N9RbgB3M7N/18Klw85j1zWuspBuBayTtL2lQ3LV5kuzTwMGStjMzq8cPW1HzZHQrZMxqRUsWBJL2JFxynkBoQkCSzGxlkmwgsGxDpr2oodcQQhPGQmAR8ElJ04GvAidKGglgZo8D1wLH18lrf+DnwExJZ8dt7Wb2cpJsBPlkUI9Z37xKwLeARwh54EDgi8AcYD9JOwHEwulmYtOVZdzPvKh5MnoUMma1pCULAuA5QvteJ3CcpG27OWnvBB4DkHR8nS5HtwNWmtnXzOwy4PvAwcAQ4ApePzDlH4QZXetxGfoUcCQhXmdJGmZmaySVks+eADwafY6Q1JmxUxmPWd8YBbwAfNnMbgYuAKYC4wgF6ue1vofOrUC9Jngsap6E4sasZrRkQWBmfyM8K2EJ8FvgS/CGtuMpwKaS5gJHENors/Z6BBgjaa+4aRFwO/AZwsR8IySdK+lwwpPdXonHZVrzMLM/A4tjvG4Froy7lHz2nsBmkm4i/ACuztIpcfOY9UJa6JnZfwgz/U5N3l8BzIoF6UrgfEkfJ1xVLc/CqRuvQuXJjsvADAAACK1JREFU9HOLFLPMMLOmXQiX3hsn71W5DmwELAGmVBx7C6G2dmgGXiOBLVIXoBTXTwWuTfZNAq6Ox3QCRwPzgCPr4dVNvDYm1I7enewbRPgBfhA4PKNzOQrYo2JbEWL2Bq8ixCx6Ta/Y1hZfjwXuSbZvQrgROwl4K6Hp4/oM4zW9yr7c8mT8+28Dvg4MLFLM6rHkLpDZPwbnECa7ux44L24rVaQpn+QzgF/F9Y/GH+bJGXl9AVhMeDTnRalHXB8LzAWOie83JUzct2XG8erOq1q8zgHmx/UPxteDMvZ7lFCz3iW+TwupXGLWm1deMYuf9SAwo8r+EnAHcEaybQ6wU8ax6tGrIl51y5PxM04k3AOYTehoUPndzyVm9VpyF8jghA4lzGp6A7AFoUb4IjAm7n9DLTeuPx/TXQ0MzsBrMHARoRaxWXT7HzAi7i8lafchtIXuAhwOzAe2yShePXpVpE3jtQZYAVwKDMjwfJZixryFcNn9KWBonjHbAK9q37HMY0ao0a7o7u9XuLyL0Pf9IOBj8Qd6QobxqurVg2OmeTL9DgGXVftRZ/2VSl1jVs8ld4EantBN4ms7MBloT/Z9D5hW5bjhhIJjEfC+rLzi+qhkfTJwHbBjRfryl+4k4Nvxy5a7V7J/ZIznX7LwqnRLts0GZsYf0b3yjtmGeNUrZhXncjzh+d8bESpB04DdK9KXf/w+DJwP/B7YM2+vJG2mebIbtxLwMKEStGP87GNJKkOsv1LJNGZ5LbkL1OCEbhoz4zzgNGBssk+ELmfzgUlVji8BE+vgtUPc3k6ovS4DvgH8kXDpW/6ipbXctqJ4Jce3Z5g5U7dTgfFx+1jgmrg+g1ADPwMYXT7PdYzZBntlHbNuzmXZ6zzCjef7gHMJvViOTr5jqrVLLbyS4zPJk1XO5c5x+yzgm3H7JwiD/WYl+aOUhU9RlobuNSRpd8Kl+bPAhYSbPaclSUqEL95rdPOYTAhTDpjZojp4nRw/bw3wENBhZmcSahczoiuWDHYys66ieCVOa8zs3lp6VXEbnbgtAV6S1AZsD5wO7GZxIJbFnBrXs47ZBnslTjWPWZVzeVLcfSmh183eZnY+4QFRJyc+Rkb0xyvxq3merOI2Gpged5ebFX9mZlcBZwFbEgeMWQNOG9EXCvHw+n7wAnCJmV0P62aanBJH/a02sy5JHXH9GYUJqwaW0+fgNRh41czWPcjazH4taSYhwyxrUa+e3AYQ+tvvTGgqeIzQ3mySxpnZP91rndfe8Vy+aGYXlBOa2S8lzSD88GXdx72oXtXcpsZ9dxFGou8S3R6OgxGbugAo0zAFQRxl+LqajJktlvR4sm81oWkoHXk4BRgiaQ6h1nZWjl6r0mMkjSfUTP4FPNEKXm/CbTWwUNI9wN1mNk/S2wnPwK5pP/Im8NqufC6TYycQzuUy8vuO1dWrj24dcd8SSbOBsxXmpOogXA0vrbVbEWmIpiFJA9KTWjEQZWWybwyhdpYyEtiJ0Ad4NzO7swBegyQdRejZdIeZHWtmrzW7V3/czOwcM5sX15ea2VcsTBvhXt14SWqXdDCh+/TtZnZcLLya2qs/bma2gNBUdQ/wCzM7wMLgsaan8AWBpFOA3ynM930ghDbOdORfst4BPBC3fUTScMK0v2PMrKbPDe2PF2GysdsI7cmXt4JXf90kbVlrn2b2IvS8uQt4T8G+Y5l59ddN0lZmttzM5prZ1bV2KzKFLQgkjVBozvkA8FnCDZ5j4uX3ups3kiba+hs5E4BOSbcAhxHuByw2s1cK5tVmZk+3gleN3A4hg7baJvY6lNDLZXllk0wzetXI7RDCOI/WxArQdam7BWgjzERY7iPeAVxD7N9OuKM/B7gb2ArYBniJMG1tZqNc3at53NyrObyK7tYIS+4CyYlsJwzM2TrZNixZLxEGpIyL76cCJ1f8jePcK1+vIru5V3N4Fd2tEZfcBeIJ2ZnQh/0p4LoqacYDv6myb6B75e9VZDf3ag6vors16lKUewTPEqYG2IEwpfA+AJLakjv+owjPeEXSbooP/ZYkq3HPFvdqSjf3ag6vors1JIUoCMzsSeAGM3ue0K5XfsJPF2GaCIB3AAMlXUwYCl4+NrNRku7VPG7u1RxeRXdrVApREADY+p4qc4BVkk6L29fGUn4v4P3AcjPbw8zmu1fxvIrs5l7N4VV0t4Yk77ap7hZCF7AH4vrE+PohkhtD7lV8ryK7uVdzeBXdrVGW3AV6OLm3Aq8SZgEcmbePezWfm3s1h1fR3RphKUzTUBmFh3tfSLjrf4qZ7WfJZGju1RheUFw392oOLyi2WyNRHnxRKCTtS5jr5tVeE9cR9+o7RXVzr75RVC8otlujUMiCwHEcx6kfhWsachzHceqLFwSO4zgtjhcEjuM4LY4XBI7jOC2OFwSO4zgtjhcEjtMLkrokLZD0qKSFks5U8sSrKseMkXREvRwdpz94QeA4vfOKmU0ysx0J89rvC5zbyzFjAC8InIbAxxE4Ti9IetnMhiXvO4A/ASOBbYEfA0Pj7lPM7D5JfyCMdl0K/IgwbfJFwGRgEHC5mV1Vt3/CcXrACwLH6YXKgiBuewHYHlgBrDWzVZLGER6UsqukycBMMzsgpj8B2NzMLpQ0CLgXOMzMltb1n3GcbmjPW8BxGpwBwGxJk4AuoLNKun2AiZIOje+HA+MIVwyOkyteEDhOH4lNQ13A04R7BU8RHoRSAlZVOww41cxuq4uk4/QBv1nsOH1A0mbAlcBsC+2qw4EnzWwtcBTQFpOuADZKDr0NOEnSgPh3OiUNxXEKgF8ROE7vDJG0gNAMtIZwc/iSuO87wFxJRxPmxF8Zty8CuiQtJDxO8VJCT6KH4hO0ngEOqtc/4Dg94TeLHcdxWhxvGnIcx2lxvCBwHMdpcbwgcBzHaXG8IHAcx2lxvCBwHMdpcbwgcBzHaXG8IHAcx2lxvCBwHMdpcf4P52uqBjEF3qgAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "4080c93185c14e0b81496fe7d64e0e64", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Testing', layout=Layout(flex='2'), max=356.0, style=Progr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 12789, {'val_loss': '3.416766881942749', 'val/kl': '0.007747343275696039', 'val/std': '0.14099794626235962', 'val/mse': '0.13895587623119354'} {}\n", - "----------------------------------------------------------------------------------------------------\n", - "TEST RESULTS\n", - "{}\n", - "----------------------------------------------------------------------------------------------------\n", - "\n" - ] - } - ], - "source": [ - "trial, trainer, model = run_trial(name=\"anp_b\",\n", - " params={\n", - " **default_params,\n", - " 'det_enc_cross_attn_type': 'multihead',\n", - " 'det_enc_self_attn_type': 'multihead',\n", - " 'latent_enc_self_attn_type': 'multihead',\n", - " 'use_deterministic_path': True,\n", - " 'use_lvar': False,\n", - " },\n", - " user_attrs=default_attrs,\n", - " PL_MODEL_CLS=LatentModelPL)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "ExecuteTime": { - "end_time": "2020-03-15T17:10:35.479120Z", - "start_time": "2020-03-15T16:53:19.150638Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "now run `tensorboard --logdir lightning_logs`\n", - "trial.number -3\n", - "INFO:root:GPU available: True, used: True\n", - "INFO:root:VISIBLE GPUS: 0\n", - "INFO:root:\n", - " | Name | Type | Params\n", - "---------------------------------------------------------------------------------------------------------------\n", - "0 | model | LatentModel | 3 M \n", - "1 | model.norm_x | BatchNormSequence | 34 \n", - "2 | model.norm_x.norm | BatchNorm1d | 34 \n", - "3 | model.norm_y | BatchNormSequence | 2 \n", - "4 | model.norm_y.norm | BatchNorm1d | 2 \n", - "5 | model._latent_encoder | LatentEncoder | 267 K \n", - "6 | model._latent_encoder._encoder | BatchMLP | 70 K \n", - "7 | model._latent_encoder._encoder.initial | NPBlockRelu2d | 4 K \n", - "8 | model._latent_encoder._encoder.initial.linear | Linear | 4 K \n", - "9 | model._latent_encoder._encoder.initial.act | ReLU | 0 \n", - "10 | model._latent_encoder._encoder.initial.dropout | Dropout2d | 0 \n", - "11 | model._latent_encoder._encoder.encoder | Sequential | 0 \n", - "12 | model._latent_encoder._encoder.final | Linear | 65 K \n", - "13 | model._latent_encoder._self_attention | Attention | 0 \n", - "14 | model._latent_encoder._penultimate_layer | Linear | 65 K \n", - "15 | model._latent_encoder._mean | Linear | 65 K \n", - "16 | model._latent_encoder._log_var | Linear | 65 K \n", - "17 | model._deterministic_encoder | DeterministicEncoder | 2 M \n", - "18 | model._deterministic_encoder._d_encoder | BatchMLP | 201 K \n", - "19 | model._deterministic_encoder._d_encoder.initial | NPBlockRelu2d | 4 K \n", - "20 | model._deterministic_encoder._d_encoder.initial.linear | Linear | 4 K \n", - "21 | model._deterministic_encoder._d_encoder.initial.act | ReLU | 0 \n", - "22 | model._deterministic_encoder._d_encoder.initial.dropout | Dropout2d | 0 \n", - "23 | model._deterministic_encoder._d_encoder.encoder | Sequential | 131 K \n", - "24 | model._deterministic_encoder._d_encoder.encoder.0 | NPBlockRelu2d | 65 K \n", - "25 | model._deterministic_encoder._d_encoder.encoder.0.linear | Linear | 65 K \n", - "26 | model._deterministic_encoder._d_encoder.encoder.0.act | ReLU | 0 \n", - "27 | model._deterministic_encoder._d_encoder.encoder.0.dropout | Dropout2d | 0 \n", - "28 | model._deterministic_encoder._d_encoder.encoder.1 | NPBlockRelu2d | 65 K \n", - "29 | model._deterministic_encoder._d_encoder.encoder.1.linear | Linear | 65 K \n", - "30 | model._deterministic_encoder._d_encoder.encoder.1.act | ReLU | 0 \n", - "31 | model._deterministic_encoder._d_encoder.encoder.1.dropout | Dropout2d | 0 \n", - "32 | model._deterministic_encoder._d_encoder.final | Linear | 65 K \n", - "33 | model._deterministic_encoder._self_attention | Attention | 0 \n", - "34 | model._deterministic_encoder._cross_attention | Attention | 2 M \n", - "35 | model._deterministic_encoder._cross_attention.batch_mlp_k | BatchMLP | 70 K \n", - "36 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial | NPBlockRelu2d | 4 K \n", - "37 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial.linear | Linear | 4 K \n", - "38 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial.act | ReLU | 0 \n", - "39 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial.dropout | Dropout2d | 0 \n", - "40 | model._deterministic_encoder._cross_attention.batch_mlp_k.encoder | Sequential | 0 \n", - "41 | model._deterministic_encoder._cross_attention.batch_mlp_k.final | Linear | 65 K \n", - "42 | model._deterministic_encoder._cross_attention.batch_mlp_q | BatchMLP | 70 K \n", - "43 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial | NPBlockRelu2d | 4 K \n", - "44 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial.linear | Linear | 4 K \n", - "45 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial.act | ReLU | 0 \n", - "46 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial.dropout | Dropout2d | 0 \n", - "47 | model._deterministic_encoder._cross_attention.batch_mlp_q.encoder | Sequential | 0 \n", - "48 | model._deterministic_encoder._cross_attention.batch_mlp_q.final | Linear | 65 K \n", - "49 | model._deterministic_encoder._cross_attention._W_k | ModuleList | 524 K \n", - "50 | model._deterministic_encoder._cross_attention._W_k.0 | AttnLinear | 65 K \n", - "51 | model._deterministic_encoder._cross_attention._W_k.0.linear | Linear | 65 K \n", - "52 | model._deterministic_encoder._cross_attention._W_k.1 | AttnLinear | 65 K \n", - "53 | model._deterministic_encoder._cross_attention._W_k.1.linear | Linear | 65 K \n", - "54 | model._deterministic_encoder._cross_attention._W_k.2 | AttnLinear | 65 K \n", - "55 | model._deterministic_encoder._cross_attention._W_k.2.linear | Linear | 65 K \n", - "56 | model._deterministic_encoder._cross_attention._W_k.3 | AttnLinear | 65 K \n", - "57 | model._deterministic_encoder._cross_attention._W_k.3.linear | Linear | 65 K \n", - "58 | model._deterministic_encoder._cross_attention._W_k.4 | AttnLinear | 65 K \n", - "59 | model._deterministic_encoder._cross_attention._W_k.4.linear | Linear | 65 K \n", - "60 | model._deterministic_encoder._cross_attention._W_k.5 | AttnLinear | 65 K \n", - "61 | model._deterministic_encoder._cross_attention._W_k.5.linear | Linear | 65 K \n", - "62 | model._deterministic_encoder._cross_attention._W_k.6 | AttnLinear | 65 K \n", - "63 | model._deterministic_encoder._cross_attention._W_k.6.linear | Linear | 65 K \n", - "64 | model._deterministic_encoder._cross_attention._W_k.7 | AttnLinear | 65 K \n", - "65 | model._deterministic_encoder._cross_attention._W_k.7.linear | Linear | 65 K \n", - "66 | model._deterministic_encoder._cross_attention._W_v | ModuleList | 524 K \n", - "67 | model._deterministic_encoder._cross_attention._W_v.0 | AttnLinear | 65 K \n", - "68 | model._deterministic_encoder._cross_attention._W_v.0.linear | Linear | 65 K \n", - "69 | model._deterministic_encoder._cross_attention._W_v.1 | AttnLinear | 65 K \n", - "70 | model._deterministic_encoder._cross_attention._W_v.1.linear | Linear | 65 K \n", - "71 | model._deterministic_encoder._cross_attention._W_v.2 | AttnLinear | 65 K \n", - "72 | model._deterministic_encoder._cross_attention._W_v.2.linear | Linear | 65 K \n", - "73 | model._deterministic_encoder._cross_attention._W_v.3 | AttnLinear | 65 K \n", - "74 | model._deterministic_encoder._cross_attention._W_v.3.linear | Linear | 65 K \n", - "75 | model._deterministic_encoder._cross_attention._W_v.4 | AttnLinear | 65 K \n", - "76 | model._deterministic_encoder._cross_attention._W_v.4.linear | Linear | 65 K \n", - "77 | model._deterministic_encoder._cross_attention._W_v.5 | AttnLinear | 65 K \n", - "78 | model._deterministic_encoder._cross_attention._W_v.5.linear | Linear | 65 K \n", - "79 | model._deterministic_encoder._cross_attention._W_v.6 | AttnLinear | 65 K \n", - "80 | model._deterministic_encoder._cross_attention._W_v.6.linear | Linear | 65 K \n", - "81 | model._deterministic_encoder._cross_attention._W_v.7 | AttnLinear | 65 K \n", - "82 | model._deterministic_encoder._cross_attention._W_v.7.linear | Linear | 65 K \n", - "83 | model._deterministic_encoder._cross_attention._W_q | ModuleList | 524 K \n", - "84 | model._deterministic_encoder._cross_attention._W_q.0 | AttnLinear | 65 K \n", - "85 | model._deterministic_encoder._cross_attention._W_q.0.linear | Linear | 65 K \n", - "86 | model._deterministic_encoder._cross_attention._W_q.1 | AttnLinear | 65 K \n", - "87 | model._deterministic_encoder._cross_attention._W_q.1.linear | Linear | 65 K \n", - "88 | model._deterministic_encoder._cross_attention._W_q.2 | AttnLinear | 65 K \n", - "89 | model._deterministic_encoder._cross_attention._W_q.2.linear | Linear | 65 K \n", - "90 | model._deterministic_encoder._cross_attention._W_q.3 | AttnLinear | 65 K \n", - "91 | model._deterministic_encoder._cross_attention._W_q.3.linear | Linear | 65 K \n", - "92 | model._deterministic_encoder._cross_attention._W_q.4 | AttnLinear | 65 K \n", - "93 | model._deterministic_encoder._cross_attention._W_q.4.linear | Linear | 65 K \n", - "94 | model._deterministic_encoder._cross_attention._W_q.5 | AttnLinear | 65 K \n", - "95 | model._deterministic_encoder._cross_attention._W_q.5.linear | Linear | 65 K \n", - "96 | model._deterministic_encoder._cross_attention._W_q.6 | AttnLinear | 65 K \n", - "97 | model._deterministic_encoder._cross_attention._W_q.6.linear | Linear | 65 K \n", - "98 | model._deterministic_encoder._cross_attention._W_q.7 | AttnLinear | 65 K \n", - "99 | model._deterministic_encoder._cross_attention._W_q.7.linear | Linear | 65 K \n", - "100 | model._deterministic_encoder._cross_attention._W | AttnLinear | 524 K \n", - "101 | model._deterministic_encoder._cross_attention._W.linear | Linear | 524 K \n", - "102 | model._decoder | Decoder | 1 M \n", - "103 | model._decoder._target_transform | Linear | 4 K \n", - "104 | model._decoder._decoder | BatchMLP | 1 M \n", - "105 | model._decoder._decoder.initial | NPBlockRelu2d | 262 K \n", - "106 | model._decoder._decoder.initial.linear | Linear | 262 K \n", - "107 | model._decoder._decoder.initial.act | ReLU | 0 \n", - "108 | model._decoder._decoder.initial.dropout | Dropout2d | 0 \n", - "109 | model._decoder._decoder.encoder | Sequential | 524 K \n", - "110 | model._decoder._decoder.encoder.0 | NPBlockRelu2d | 262 K \n", - "111 | model._decoder._decoder.encoder.0.linear | Linear | 262 K \n", - "112 | model._decoder._decoder.encoder.0.act | ReLU | 0 \n", - "113 | model._decoder._decoder.encoder.0.dropout | Dropout2d | 0 \n", - "114 | model._decoder._decoder.encoder.1 | NPBlockRelu2d | 262 K \n", - "115 | model._decoder._decoder.encoder.1.linear | Linear | 262 K \n", - "116 | model._decoder._decoder.encoder.1.act | ReLU | 0 \n", - "117 | model._decoder._decoder.encoder.1.dropout | Dropout2d | 0 \n", - "118 | model._decoder._decoder.final | Linear | 262 K \n", - "119 | model._decoder._mean | Linear | 513 \n", - "120 | model._decoder._std | Linear | 513 \n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validation sanity check', layout=Layout(flex='2'), max=5.…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 0, {'val_loss': '0.43972402811050415', 'val/kl': '0.0007097976631484926', 'val/std': '0.6919826865196228', 'val/mse': '0.30210795998573303'} {}\n", - "\r" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "41a9362e14d3443eb5e288822f429987", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=1.0, bar_style='info', layout=Layout(flex='2'), max=1.0), HTML(value='')), …" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOydd3xUxfr/35NKQqgJgRAIAQICggICKgRERcHev4ixoAJ6LdeuCL9rx4pdrgpXETEIekVsKIJXaQIKSJFeE0ggkJCe7G6yO78/Zk+2nW3pm+zn9dpXNnPOmTM758w8/XmElJIggggiiCCaL0IaegBBBBFEEEE0LIKEIIggggiimSNICIIIIoggmjmChCCIIIIIopkjSAiCCCKIIJo5goQgiCCCCKKZI0gImiCEEFIIkdLQ4wgiiCACA0FCEES9QQhxoRBitxCiTAjxqxCim5vz4oUQnwshsoUQhUKItUKIs+2OCyHEdCFEphCiSAixUAjR2k1fkUKIj4QQGUKIYiHEFiHEJb6OSwjxf0KI363HfnO6Ls46tjwhRIEQYp0QYoSXOZgthNgjhLAIISY6HbtNCLHJ+puOCiFeFUKEeejLp/OFEL2EEAYhxGdexvaQEOK4tb+PhRCRTscfEEIcEkKUCiF2CSF6u+nnfCHEduuc5AkhvhZCJNodj7T2X2S938NexuXp+fjVVxD6CBKCIOoFQog4YDHwL6A9sBFY5Ob0GOBP4CzrufOAH4QQMdbjtwK3ACOAzkAU8K6bvsKAI8B5QBvg/wFfCCGSfRzXKeAt4GWdvkuAO4AOQDvgFeA7T5s3sBW4B9iscywaeBCIA84GLgQe9dCXr+fPQs2nWwghxgJTrX10A3oAz9odnwTcCVyGej6XA7luutsJjJVStkU9n33A+3bHnwF6We9zPvC4EGKcm3F5ez4+9xWEB0gpg58m9gEkkGL93gb4FDgJZKA2whDrsRRgJVCIWtSLrO0CeBM4ARQB24H+NRzTFOB3u/9bAuVAHx+vLwLOsn7/L/CY3bHhgAGI9rGvbcB1/owLmAT85qHPEOAK69zH+zCGNcBEL+c8DHznxxy7nA/cCHyB2jA/83DtAuBFu/8vBI7b/bYjwIXVeO6RwEvATru2bOBiu/+fBxZW573xp6/gx/0nKBE0fbyLIgY9UFzxrcDt1mPPAz+juNku2Ljqi4FRQG/rtf8H5AEIIaZaRX7dj4dxnI7ihgGQUpYCB6ztHiGEGAhEAPvtm52+R6I4Q299dbT+rh01HZddn9tQhOhb4D9SyhO+XusFo+zG6ff5VnXZcygC4Q0O82D93lEIEYt6N7oA/YUQR6zqoWeFECHW+yRZn3+S3b2TrO9DOUpKedXa3g5I0LnX6XbXFgghUvXGZf98fOkrCN/gSYQNIsAhhAhFcYQDpZTFQLEQ4nWUWuUjoAIlUneWUh5FcalY21sBfYA/pJS7tD6llC+jrybxhhiUVGKPQut9PP2G1sB84FkpZaG1+SeUCuALIB94wtoe7aWvcCAdmCel3F2TcdlDSnmGEKIFcA2KYNUYQog7gCEoSaS65z8PfCSlPCqE0L/QhhjU79agfW+FUu+AYhAGAG1RDMRRYI6UMtPaVgWtTQjRHpgM2M+3ff/a91Z219r35en5eO0rCN8QlAiaNuKAcJRKSEMGoBnuHkdx038IIXZYNxOklP8D3kPplk9YDZy6xlg9WLnBEu1jbS4BnPtoDRR76CcK+A5YL6V8ye7Qx8DnwG8oDvhXa/tRD32FoAiKCbjP7pDf49KDlNIgpfwcmCqEONN6zxK7T5KXLuzHejVKnXKJlDLX2pZm19ePPpw/EBiDUvH5Aud50L4Xo7h6gFellAVSysPAh8Cl3jqVUp5C2Xi+sdpOtPfB+V7u5tvT8/G3ryDcIEgImjZysXH9GpKALAAp5XEp5WQpZWfgLuDfwup2KqV8R0p5FtAPpUp5DEAIMc1pgytx3vSllJlSyhjtY73vDuBMbRBCiJZAT9yoPqweK0tQm/td9seklBYp5dNSymQpZRdrH1na79LpS6AkoI4o20CF3WG/xuUDwlFqOOznwMohe4XV0DkHuEJKuV1rl1Km2/V1ibfzgdFAMpAphDiOUs9cJ4TQM1KD0zxYv+dIKfOAPSgCap+q2J+0xWFAPNBaSpkPHNO5l7v5dvt8qtFXEO7Q0EaK4Kf2Pzgaiz8DvkaJy91QIvok67EbgC7W76ejOL8ewFCUF0o4yjj3E0o1U5MxdUCJ7dcBLVAeNuvdnBuOkgSWAGE6x9ujNgOBIlR/A1M83PsDYD0Q4++4gFBr+93AKuv3cOuxc4BUlDooCqWiKkap2tyNJcLax1qUyqQFNuP9BShbzCgf59Tt+Sg1WSe7z0yUkb2Dm77GAcet89kW+B/wst3xT4Hvre9RF+t7dKebvq4FTkMxmh1QxurNdsdfRjkptEOpH48B46rz3vjTV/Dj4V1q6AEEP3XwUB0JQTsUMTiJ8vx4ym7jeRXFRZegDHBTrO0XojxrSlBSRbreJlqNcY2xbiDlKLVOst2xD4APrN/Ps/6GMusYtM9I6/HeKC61DKXqetjDPbtZ+zI49ZXm47gmWq+3/3xiN86tqM3/lHVD8riJW/t37m+09divQKXTOH/00JfP5+PFa8h6zsNADspDay4QaXesNbDQ+lu190hYjyVZ751k/f9+4BBQiiIuC4Fudn1FotR7Rdb7Pew0jqpn7cPz8dhX8OPbR3uQQQQRRBBBNFMEbQRBBBFEEM0cQUIQRBBBBNHMESQEQQQRRBDNHEFCEEQQQQTRzBEkBEEEEUQQzRwBl2IiLi5OJicnN/Qwag2VlWCx+HauEBAeXrfjCST4MndhYRASZHewWNR8+YqIWkmU0fghpZobi0V9h6b7zmzatClXStlB71jAEYLk5GQ2btzY0MOoNRw5Amazb+eGhECSz4kKmj5OnICyMs/nxMRAXFz9jKcx4+RJKC31/fwuXdSG2BSRlwft26uNPyvLdf2FhUFiomK8mhKEEBnujjVBuhc4qKz0nQiAjXMJQsEXDre83Ps5zQFGo3/nV1R4PyeQUGzNPmQ0qu/5+VBQoL/+KiuhpMS1vSkjSAgaEP4QAQ3+iPdNHb7MhdkMJlPdj6Uxw2z2/71pSoTAZIJTp9Rv0ghCUZH6uENhYfXWZ6AiSAgaENV50ZrSAq0J/JGOmjsh8FcagMB/z8xmG1dfVqbUQHl5vqvHKivh6FElNTQHBAlBAyIoEVQf/sxDdTbCpoTmSAgMBtsmrm3+BoPNIOwLpGw+kkGQEDQgqrOpBwmBgj/zEJQI/L+mKRCCykpFDGryW6S0qZOaMuqUEAghxgkh9ggh9gshpuoc7yaE+EUIsU0I8ZsQoktdjqexISgRVB9BQuAbpKweITCbA9sxwWBQf2tDtVNc7J8kEYioM0JgLZM4C7gEleN8ghCin9NpM4FPpZRnoGqrvkQzQpAQVB/+zIOUgc/hVhcVFdXfxAJtzqRUH7O5dsduNsPx403bk6guJYJhwH4p5UEppQmVk/wqp3P6oQpggMqt7ny8SaM6hKA56Ct9gb8EsblKBTWxjwTau2YwqHiJunAZNhohN1e9d1u3bmXDhg1YAllkckJdEoJEVAELDUex1crVsBVVzQhU4e9WQojYOhxTo0J1uPtgLIFCkBD4huZECIxG5SGUl1d39ygpgZdeeolzzjmHW265hYIm4lbU0MbiR4HzhBB/oao9ZQEur58QYooQYqMQYuPJkyfre4x1Ai20XQ8WCxw75v7aoHooSAh8RU1+d6AxHBrRq0t9fkkJ9OzZE4AFCxawfv36urtZPaIug8izgK52/3fBqbi4lDIbq0QghIhBFRZ3IbFSytnAbIAhQ4Y0CbONJ24rM1PpJM1mFervz7XNAf7kZ9IQaPru2oCUNSMEgfae1YebcGUlPPHEDEpLy1m3bi1hTSQPR13+ij+BXkKI7igCcCNwk/0JQog44JSU0gI8iao92izgbpEVFysiACqgJT7eNQFYc5cIqusF09xQ042xsUoEFouFEGtWuOJiaNmyfr2cTp2CBx98g1dfbTrJ+epMNSSlrATuA5YBu4AvpJQ7hBDPCSGutJ42GtgjhNgLdARm1NV4GhvcbeYaEdCQn+96TnPc1OxRnQ1O8yZpTqipOqyxztf777/PwIEDWbJkCQaDCvqqr6DBrKxMSkuV+1BTii+oUxuBlHKplLK3lLKnlHKGte0pKeW31u//lVL2sp4zSUrZbGJA9RZZRYXiNuyhZ/gKSgTVu665zVtNN8fGSgi++eYbtm7dysSJE9m+fSfFxZ6z0P7661Kee+5BjEZDje99660X079/K/bu3UFpKZjNjVRs8hMNbSxuttBbZLm5roauoiJX/XZz29DsURO9d3ObN1/m6ehR2L9ff24aq2ooPf07AAoLC9m/fx8Wi2dC8J//vM7cuW/z5Zdza3zvFi2iiIxsgcFQzrBhiQwaNLjGfTYGNA1LRwBCb+Hl5uqfm5+vbAUaGiunVh8wmarvFdKc5s2XILrSUkUINKSkOB5vrPNlMkWyePE3ZGQcpU+fAV7Pv/XW+zh8eD/Dho2q8b1/+OEvpJTk5+eRk5ON0WjAZAp8W0GQEDQQnLk1i8V9ZsSiIkdC0Nw4W3vURN3RnObNF2ng0CHb91On1DtoX5lLi9RtTAVazGZJRYXggguuRErfUkiMHXsNY8deU2tjEELQrl0sa9ZkEB+fwPHjqpBNaGit3aLeEVQNNQD0uDVP0ZDORqnmaPjUECQEvsGbNFBW5pgywWJp3I4JUsLhw4fp0aM7r702ndJSz++C2WzmlVemsnnzOmQdBBYIIUhMTCI8PByLJfALIAUJQQNA7wX2pOM0Gl03scayQOsbNfGEaU6EwNs8nTjh2qanmmwsdoKiIli6dCmZmRkcPryPo0ePsWzZMv7+e7Pu+X/8sYoPPniFBx9MA6CsrJQFCz5k/vx/V3sMCxf+h7Fj+/Ppp7NcjgV6qvOgaqgBoLdIvXEUJSXQtq3t/8rKwNdL+ouaJo9rTsTTEyGwWPQ3fa10o72KozHMmVYXYMqUu+nefTAWSySrVi3jscdu59prb+X11+e5XNO5cxKTJj1Cp06JCCEwmYxMn343rVq14ZZb7qnWOA4c2G31FlIi+uLF81m+/BvGj7+TsWMvqdFvbGgECUEDwF+JAFwJQWNYoPWN2vCLb2w677qCp7nKz9eXjqRUDElMjK2tMbxnJhNWz6AQzjjjHGvJySJSUy+iV6/Tda/p1q0n06fPrPq/Vas2jB8/ibZt2yOlRFTjJbj//n9xzTU3065dHAB79mznp5++on//wZx//iUB/W4FCUEDoDoSgbMhuTmpOTTURr6gykoID695P40Z3lJw6NkCNDgTgsagGtKee1GR7b0/55zzOOec83zuIzQ0lJdfnlOjcbRu3YZ+/QZW/X/FFTcyYMBZ9O9/VpVbc2RkjW7RYAgSgnqGxaIfF+BNx+icCz1ICKoHs7npEwJP6jMpPRMC5/ewsUgEmZkHmTXrRXr3Pp0773zI4/lFRQVs2vQ7SUk96NmzT52Nq3//wfTvb4sjMBoDlxAEjcX1DL3NzJtaCNTitr+2MSzQ+kZtSQRNHZ5+Y1GR53fHWTJtDBJBRQUcPXqYL774iBUrvnU4ZtThoHbu3MIdd1zG1KmTHNpPncrlwIHdlJX5WMHeDiaTiSeemMR777nPghPIBuMgIahn6C1Cg4+R7/bnNYcNzRneDMXl5bBzJxw+7H6zaw5ZSD1t9M4pTJzhTAgaA8NhMkH37r158cXZTJz4T0DZCE47rQVDhnRwOT8ysgWpqRcxaNC5Du333nsDY8b0ZcuWDX6PIScniy+++IjPP/+wqq2oqJAlS9L59tvPgcAmBEHVUD1Db2EVFvp2rf2L1hgWaH3Cm967pAR27VLzUlSkPKo6d3Y9rzkQAmcmYdeubUydOonnnpuF2TzU47XOTElDSwTac09I6MKECZOr2lu2jKGiwgRIzGYzoXauToMGncP8+T+79NWlSzLJyb2qNY7o6BiefvodoqNbVrUVFOTx0EM3k5jYjSuvnEBlpRpvIGamDsAhBzacN3BfoyPBkRBoQWWBHM3oDzyphSoqYO9ex7k9dgw6dnSdn+ZICJYs+Yxt2/7k/vsn8Oqr+z1ea7E46robkuE4csS9F05ISAg7d5YSGdnCZw+g116rfq6h2NgOTJx4v1NbPJdfPp5OnWxFQwwGR2N7oCBICOoZ2sJasiSdmTOnk52dSWxsEuPHzyA1Nc3jtc6iZ2VlkBBIqZKmOR+vqFBBUwkJju2VlU3fhdR587722lvJycnmjDMu8+l6g8FGCBpKBWk2O/6OnTu3kp2dSZ8+A+jSJRlQCeD0YDCU+0UgqouWLWN4992FDm1GY2ASgqCNoJ5hNisiMG3aFLKyMpBSkpubwZw5U1izJt3jtXqEoLnAHSefleVetaYXPStl058359932mn9eeutzxg8eIJP19urhxoqnYnz8/7yy4+ZPPlKfv55iddrx48/j9NPj3EbdVwdZGQcYNWqn8nMPOjxPF/tfY0NQUJQzzCbYebM6ZSXO7oKmUxlLFo03eO1jdG1r76gJxEUFTlmz3RGebm+R1ZTVg9pQXP2OHx4P5mZOZSV+abwdzYYNwThdH5GKSl9ueCCy+jevXdV27vvvsBtt41jy5Y/HM4tLi6kvLyMtm1jHdp/+OFLLrywD6+++qTf41m69Etuu20s6ekfOLSXl5eRlZWJwVBeNe6GtqtUB0FCUM8wmyE7O1P3WF6efrsGo9FxkTd1zlaDOy6+qMj7tXpeMk153vSYg7S0CzjvvE78+edi9u793WsfzlxtYyAEaWl389FH33P++ZdWte3c+RerVi1zWU//+98etm0rpHPnrg7tJpORgwf3uF1/npCQ0JURIy4kJaWvQ/ttt40jNbWbgydSIEoFQRtBPcNiUXlQsrIyXI7FxiZ5vd5ohBYt1PemvKHZo6JCvwaBLwsuLw+6dHFsa8oSgd470b59B7Kzj/DWWzfQt+95PPXUbx77aIwSgR6mTHmc8eMncfrprsVhWrVq7dJ2wQWXsXz5TmJj412OecPVV6dx9dWuNrxOnRLp2LEzFXYDDsT3q04lAiHEOCHEHiHEfiHEVJ3jSUKIX4UQfwkhtgkhLtXrp6nAYlEb2qOPziAqKtrhWERENOPHey/Z3BxdSN0tLF8IQXm568YWiAvVV+ht2t9+u4k5c06SkNCbxMR+XvswGh3VG42BEJSXl7mkkx406GxGj76EDh06+tRnmzbtSEnpS7t2sd5P9hHvvPM569dnMXLkRVVtgcig1RkhEEKEArOAS4B+wAQhhPNb+P9QRe0HATcC1c8RGwDQNu6rr07jxRdn07atLRhm8uTZul5Da9akc//9yUyYEML99yfzzTc2g3IgvnDVgTuPIV9FcOf0HE2ZEOgxByUlEBMTxxtv7OHOO31bYvbEs77fMz1V4EUX9SMlJYyjRw97vHbNmhXcfPMY5s59u1bHZPaD6wrEdVmXEsEwYL+U8qCU0gQsBK5yOkcCmgzXBsiuw/E0OOzfpVGjxvLEEx9X/T9r1i3cf3+yg+fQmjXpzJkzhdzcDEB5F7344hSWLEmv6q8Oam40Ouht3BUVvi84Z4NxIBrzfEV1bSnOaEhCoHc/s7kSi8VCTIxN5XPw4F4+++x9Vq5cVtW2b99O1q79hYMH97r0UVZWyssvP8GMGY/6PaYbbxxNnz5RbNrk3cYSJASOSASO2P1/1Npmj2eAm4UQR4GlwP3oQAgxRQixUQix8eTJk3Ux1nqBPSH44ouPefLJK+yOurqRLlo0HZPJcRczGsuYOdPmXdQc1EN6hMAfg5xz5tamTDydN6EVK77jhhtS+Pxz5SlTXl7MM8+M5IEHenqs3NUQ6Uy0DJ56z3vduqPs3WuiTZt2VW1bt/7Bv/51D4sX2+oRXHbZDXzyyU9MmDDFpY+QkBA+/PBVPv30PY/j2LLlD1544REHV9HS0mKMRoOLSnflyp+44oqzeOmlx6vaApEQNLSxeALwiZTydSHEucB8IUR/KaUDzyalnA3MBhgyZEjALmP7TTvCTVUZzY00NTWN3Fx97wZ7r4dADWn3B3oLyx9C4EtSv6YC57nKzj7CsWMHKC1V7lMtWsRw9OgOSkvzyc/Ppn17Z95MwV4i0FQ1df2emUwqItxddthwpwPJySlcf/1ERo+2mRbj4xOIj09wvhRQOYieeOJlWrVqg8ViISREnw+eO/ctvv32cyIiInj88ZcAVbS+vLyMiAjH9KJGo4G//95MfLwtn0kgRv3X5aPNAuz9t7pY2+xxJzAOQEq5TgjRAogDdEKBAh/2hOCOOx7khRce1uXKNDfSuLgkq1rIEZ0727yLApH78Afu1F/+JPjS0nzbpwhuitHFFourhDhu3G3ExFxIeLhyNRNC8OSTy4iN7UqbNu6NrM7Esz4IgfYu+2rDGTToHAYNOsfn/oUQ3H33E17PmzTpEcLCwrnxxslUVFQQHh6OEMIhz5CGYcNG8fXXG+jY0TGxVaBF/delauhPoJcQorsQIgJlDP7W6ZxM4EIAIURfoAUQuLofL3BepO7cRVu3TmLRIrjqqhdQNncbIiKiefRRm3dRU1cNuSN0/vpqNwepQM+obrG0pHPn0+jQoVtVW8+eQ2nbtpPHFAwGQ/3HrLgjAIcO7eOmmy7g+ec91yF46qn7+Ne/7iUry/84AXsMGHAWAKNHp7B8+Tcez23btj0DBw4jIcHRRznQGLQ6IwRSykrgPmAZsAvlHbRDCPGcEOJK62mPAJOFEFuBz4GJ0pPiMsBhv2mbzTB+/AwiIhzzpYSHR1NWNoMlS2DFiquQUj0iIQRxcd2YPHk2l1xi8y4KtBfOX9QWIWgOdgI9QuDsMeUrpKx/V2V3hODEiWOsW/cr27ZtdDlWXl7G1q1/cuDAbr788mM++8yzV9Tu3dv59del5OV55jc1W0BhYT6lpSVMnHgJjz9+h28/hMBbl3Uq7Ekpl6KMwPZtT9l93wmMqMsxNCbYL6bHHruD775Lp3PnvuTnZ1FcnEdsbBJm8wwKCtIQAjIyWhER8RWxsY/yxht7qq61V3ME2gvnL4ISge/QIwRz586guLiIceP+WWUPKCrKZcmSGZhMZUya9KHrRVYYDLbgxfognO4IQZ8+A5g/f7lukrlXXpnKvHnv8vjjL7Fo0Sq2b99IYqL7wMyXX36clSt/4qOPvueCCxyT8K1d+wuLF3/KzTffw7RpM3nmmXcJCwsjKyuTlSt/cuH6AaSUvPfeDAoK8pg+/fUqu0OgrcsmbmZsXLB/0Y8fz6Ky0kRERAtmz1bcyfLl8PHHkJgI//gHPPssmExXEBr6b1599XIef/x7oHkFlbkzFPu70JyDypqDRFBRAb/8MpecnAOMHm3jZsPDI/nxx7cIC4tg4sT3CAvTt87av68NSQjatGlHauoY3WP9+w+md+/TadmyFWecMYQzzhji8R5nnDEUKSWtWrVxOfb557P54YcvSE7uxaBBZ1e1t2sXy0cffa/bnxCCOXNmUlxcyP33/4u2bdsDQUIQhBuYTI6L6dFH/83atX8TG2uzp69dq/5edRX07AmDBsEff8DRo305ccKW7MqeEATaC+cv9H6fr4V87BHI1aN8gZSuG2lJCVx33TPk5R2hfXsbNxsV1YrbbnuH+PjuHvusT0KgpQf3F9dfP5Hrr5/o8/kPP/yc22OPPfYiycm9uO662xzao6NbukgP9rj33umEhIQQGmrbTgNtXQYJQT3BmVvr2LEnQ4f2BODzz6fx/fdvYrEYgSQqK2ewZg1s3/4YcBwhEujTZ5RuXxaL+rjxhAt41BYhsFjUvGleu01NItDLx1RSAiNH3qx7/rhxuiE7Ln1qqOv58uQptGHDKnbu3MLQoakOxeI1/PXXeubOfZtrrrnFISmdv+jWrSePPvoCRiNkZWXy/PMPEhPTmpkzP/F43V13PebSFmiSehPdPhofnDlSbTNfsyadpUvfwGIxoAKtM/joo9v58MM7KC8/BkikzGbXrtVVgWbNKR21MyGQsnqEAJq2VKBnHygurlmfjYUQLF/+Dc899wBr1/6ie3zVqmV8991Cfv11qe5xZ0gpMbnJW1JcDAcOqOCzZcu+ZtWqZezbt5P09A98iiq23cPnUxsFghJBPcH5vXvjjXvZtWsjOTkHqKx03KHMZtdVUVFhCzRz7quy0n0QTiBDL4agpES1r1mTzqJF08nNzSQuzvcKb61aqe+BtlC9Qc8YnpWVw549G4iP705S0gCHYyUl+WzZshSDQXLBBTfrSpT1QQhKS5X9xlPaj6FDU6moMLnV/0dGRhEVFc0NN9zu9X7ff7+Ihx++hcsuG8+bb84nM/MgnTsn8d//pmMyldK169VERXUmKakjs2Z9SXx8AuvX/8ZTT93LTTfdxVlnDXfpMzv7CJmZB+natXuVobou5qsuY1+ChKAeoIXO22P9+u/dRg67gxZo1lwqlblTC2k5mLT0G1pqDsAjMWiqEoHJ5EoIDAbYs2cDr79+FQMHXsoTT/zgcDw/P5tZs2YgxGp+/BGmToUOHRz7qA9CYDJ5d3EdO/Yaxo69xu3xO+98iBtuuJ3Y2A5uz9EQFdWSiooKSkuL+eOP1YwfP4qrrrqdLVv+IiNjC88+O5DevTtTVBTOpZdeT06OqmNw442TGTZslG6f//nP68yd+zbTp7/OpEkPV7XX5sZdUaHmqV077+dWB0FCUA9w1t8ajTBy5K3s3/8HGRl/UVTkWwydZvCzWBwjPZtqEjU9QlBcrJ+DyT41hzs4l2BsKtBTlRUXQ8uWbRk06DJSUlyjb1u37k1k5AqMxliys5WH2tNPOxKD+sjS6i6zrD8IDw/3iQiASva4e7eqabx58zoAvvlmLhMnvsuhQ5vo0qU/oOpYWCyqFOqwYRcwfPgFbvvs2bMPQ4aMoH17xzHUJiHIyXGMjK9tBAlBPcCZEy0uhv/7v+cBxd1++OEUKiu9ObpHc9FF0xz61AhBU9rU7KG3EZWV4VaS8qXCW1OD2ewaLORUCkwAACAASURBVAeqrW/fUfTtq8/FLlwYjtHYmaQkFSuwdy989x3cYRczVV8SgTds3ryOrl27ExfXscYF6VW+IqVHTUo6h3/8Yxa9el1EQkIvh/NKS2HDhl84fPgvQkIuZ+jQPm77TEu7m7S0u13aa2vOtEy7dUkIgsbieoCzD7v9wk1NTaN//9lAN9wjFJhN1662l81+ATVVQuC8cRuNalHExekHDLVs2d7n/prKnDm/Wxr0iIOGsjL43Wr3fOABmDhRff/jD1fpUiMGdTFfZrN3R4eCglNcd91wzj+/l+cT/URODuzfLxg16h4XIqBh1ap5pKc/xtKlX3Py5HEOHqzwax5qa85qQ2ryhiAhqGNYLK6LtaQEfvttLsuXv09h4QkgDThMixYXIITjI4mIiGbgwHlAGgdtWXGbJHfrDOcFoG1u48fPIDTU1TpuMBTz8cf3OBTysa/v4FzzuSlAjxBIqd4xg6FUN6nhhg1qbvv2lQixFyG2Eh+vVEx79jieW5eEwBfVU1FRAWecMYT+/c+qsTQAymPo3ntvZNKkMXz33WssWPAEGzb8lwMH/sRkcpzMM88cxyWXPMiXX77GsGEJ/PTTMo+eWM5zXVsq2/ogBEHVUB2jrMxxEUmpNrSPP/4HFRVGYmJiOXLk/wB48cVfOHBAecPk5WUSG5tk3fTS2LIFDhyQgFoMTZG7tYcet6gRgtTUNObNe4CSkjyH45WVJpYv/wDlhqtvRDaZlIjdVOZML9WG9s699trl7NmzhunTf3FQEa1apf4mJ2/n4YfPpG/f8zj77N/47jtYvx762tVn1+w0dTFfvmxwSUk9+OabP2vtnqWlglWrfqakJJ/jx/c7ZPe9884PGDPmrqr/R4y4iREjbqKg4Bg7dvxKTEx78vKgtVM55H37dnL99SNITOzG0qVbqtoDSSIIEoI6hrM3h+Yq165dIkVFJ4iOTiIvT7l/7t+fzhdfuLpE3nnnWcAmdu8uR8pohGj6hMBbArWSklNurnScDGcjsnM66kCG0aivWtGkBKOxFLO5kpgYm8osJwd271ZzcPHFnfj553Dy8jKxWB4C3uSPP+C222wBitpzaChCUJs4dUrZQu6+ex7h4ZEUFBzn1KmjZGZuZ8eOXxgyxLmAosI//7mw6ntBgfqbna08eKKiIDo6hqKiApc01UFCEASgrxbSOLi33z4A2ETxNm3SmTNnMhUV6gJ7blaIDOAUBkN7CgrUC1jfi6i+off7ysqUcX327Ek4b/ieYG9ENhgUR9cUiKc7+4DGJLzwwh+YTAaHXELrlKMMQ4ZAp07xPPPMavbuXcf8+Q8RFvYvCgrac/IkdLSWKqgr1ZDZ7FviQCllraiEKirg0CH1/ayzrnA45s89jEY4fhwyM9X67tIFOnVKZNOmkw7V01S/NR62T3aU2kDQRlCHcM7pDq4bXKZ1jyounl5FBGznKm72jTd206OHSpKlVepsbhKB0Qi//qriByoq3O0g+ovZvu6Du80zEOHOTmTfHhHRgpAQW02L9evV3+HWuKiUlLMZPnwCjzyyhKQklX/j2DHb9XWhGiothaNHfYt/ufXWsYwY0Y0tW/6o0T0PHXJvk/CX0Bw+rP7m56u/oaGhtG8fR6hTJZramLP6Yvi8EgIhRIgQYpAQ4jIhxAVCiPj6GFhTgF60p/OD/ftv9ddodO8S2bp1HPHx6iXTCEFFhc0Y1RwIQUmJfvyAhri4blx00d2EhzvqfSIiohk/3lbIRyMETWHO3G1s7ghEdjZkZEB0NAywCzRu27YjQ4ZcRffuMYDieDXUhWpIj0Fyh8zMA2RnZ9K6ddtq3+/wYaUW0rB37zoWL36er756joyMrdXut7TUs9NGIBECt6ohIURP4AlgDLAPVTmsBdBbCFEGfAjMc64vHIQNetynyQQWi4W0tFAgghYtDICgXbsk8vNdy1Jq3KwW6HPSLvbMaFQ6yqawqdmjokI/k6anSOy4uG6kpf2bw4dHsG/fdCCTqKh23HHHOw5BZk1FItDqCOvBaISjR3fy0Uf/ICXlbNLSXgVs0sCQIfopSTp1Un/tJYK6UA35s7mtWLGbrKwMunRJ9vs+FosiAiecCt+uW7eIn356G4Dt25fzzDOr/e5bw7Fj6jksXvws+/ZtZurUV+nZ8zSg5nMmZc3zRfkKTxLBC8BnQE8p5Vgp5c1SyuullGcAVwJtgFvqY5CBCJNJX7en0gEUWf8bicEg6NoVbrppBhER0Q7natzs3Ln3s2LFVMCREDRVO4Hey19c7D5+AGD3bgPTpsG+fcoVFywMG5bnEmlsNKoNItCJpyfXS6NREc3du1eRkaG8WKS0EYJzdMr8rl79GZmZXwGOEkFdqIb8iVgODw8nOTmFMD8LJldWKmnbmQiACrTr2XMo4eGR9O7tmjvIHxw/Drm5sGHDSlas+JbsbBuzUtM5Ky6uv/QxbmdXSjnBw7ETwFveOhdCjAPeRkVE/UdK+bLT8TeB863/RgPxUsrqy4CNCJ4MedHRrfnggxzS08NZvRoGD7a5Nzq7jqampvHLL7MpL1dEwlkigMDf1OxhsbjmnrFYlBg+fvwMZs+e5GAjiIiIJjp6NIWF35CdrYr63HgjvPkmrF4N114L8U7KzKYgFbjbTLW6FykpZzN9+i9VpVAzMuDIEYiJcVQLaVi0aBp5edHAdbqqIaidlAlmc/2kRDlyxH1VumHDrmXYsGtr9X7jx09j8uT76Nv3zKq2mqxLi8XmoVQf8InMCiGGA8n250spP/VyTSgwC7gIOAr8KYT41lqeUuvjIbvz7wcG+TP4xgx3L2FFhUpx27p1fJXH0GBrivXU1DTdXDmXXvowHTvuY+XKpk8ISktdN4rSUvUbU1PT2L59OatWzQOUOmjUqBl8/30aUsKYMXDq1P/x+uv/pU2bZRQWXsQPP8DtTkkpy8sDf8682QdiYtrRv78tP85qq/Zj+HBbahJ7nHfeRAwGEz/+KDl5UlBRodRHSpWp3ElrgxD4Iw1s3ryOTz55h6FDR3LLLff4fF1xsXKTrU/07j2GgQMd22ryjmnzXl/wxVg8H5gJpAJDrR/P9eAUhgH7pZQHpZQmYCGg76irMAFVwD7gYTbrG5EqK20Pt6hIia1RUZCS4rm/oUOv4vbbHwWUGKr10RSji/VSI9hLCKNGTeS001I599wbeeyxwyxbptJyn3++ypNTUpINSAoLVRbI1atd3RT9rXfcGOGPodhstlW/GzlS/7obbniOW255mQ4dBFI6qlRqk+HwhxAcOrSP775bWJUczldoXj3uYDZXcvz4fnJyDvjVrycYDK6q4JrMV30k/LOHLxLBEKCf1ItV94xE4Ijd/0eBs/VOFEJ0A7oD//PzHo0S7qQBTczes2ctb7wxA1hKXJxv1cUiI5X/e1GREhnbt6/bYJ+GgJT6G5k9ITj99NGcfvpqCgrgyScV4UhM/A8bNjzGr78WEhvbhV69zmXfvnWEhm6kvHwI69YpQqGhKUgE7uxD2vytX/8lBQXHGDz4CrKzu1NYCAkJqgSqJ3TqpIjAsWNKzQZqk6stpwR/Nrhhw0by1lvpJCR09X6yFbm5nvMsAWRmbmPatLMAePzxHxg0qPpVzTTk5BxkwYJVpKR049xz1ctWk/mq79TyvhCCv4FOwDFvJ9YANwL/lVLqhk4IIaYAUwCSktwbDBsLvBGCY8f2UlSkpj421nt/+/f/yYoV7xMa+jyQSG6uIgRNTTXkzq1Qb2GvX68IYseO6Rw7djcWi3p18vKOUFR0kmHDriU2NpQff4QVKxwJgbvnE0jw5DEE8OuvH7Ft2zLi43uyZYuqTTx8uHvVjsFQSn5+Nu3aJQAxDnYCTYKqb0LQtWt3unb1XFfZHlIq24A3tGoVV/W9ZcvaMUnu3r2aDz64nauuSqsVQtBoJAIhxHeo8M1WwE4hxB9AFb8mpbzSS99ZgD0p72Jt08ONwL3uOpJSzgZmAwwZMqRRb3sWi3vVg0YIevceTp8+Ldm92zdCsG3bMlaunEtY2JVAIidPQu/eTS+JmrsEavZSwq5dqygoOM7+/ZcArSgpmV5FBDRUVBg4eHAT9947iFWr4OBB5UPfubM6HujzplefWIM2V8OGXUenTr1ISOjNggWq7Ywz3Pf588/v8fnnUzn99K+Bqx1cSGuTENSlp1tOjm/q0ri4JD7/XGIyGRwKztcEiYl9GTPmFoYNS61qaxKEAGUXqAn+BHoJIbqjCMCNwE3OJwkh+gDtAP8UgY0UmmFTD9oi6Nz5NE477TR271acvTckJw+kY8eegJmcHFcXUq0ge6DDmRAsWZLOa69NJzvblnvpm29e5ujRv2nVagfQj9JS/diC3NxMIiJUArWNG1VkqUYIAr2Qj6eazdpGeOGFk6vOzcpS70iPHu6va9++C/HxPWjXTunhsrNd+6wNd0h/0iX89dd6jhw5xJlnDqNbN886LbNZ/U5/EBHRwr8LPCAlZRj9+n3KIDt3l+rOl6cYkbqCW+20lHKlp4+3jqWUlcB9wDJgF/CFlHKHEOI5IYS9NHEjsLAaNohGCV8WKdgiHX0hBIMHX85bb+3nssuuA1w9h5rCzJlMjlzQkiXpTJs2hezsDEBW5V6S0kJ4eCQGg6rf0K6dvqowNDSMF14YQ5cuaufJdKIXgTpnRUXuSzvq5e/ZvVv97d1b31tIQ2pqGm+/fYAJE24GVAoIbY5qQyLIy1Mff7Bo0Uc88MBNbovW2+PYsfrnop1hMjnGwFR3vior6//99MVr6FohxD4hRKEQokgIUSyEKPJ2HYCUcqmUsreUsqeUcoa17Skp5bd25zwjpZxa/Z/QeFBS4pmSay/qjh3/4++/le+oL4RAg7vo4kBHZaVr4M/MmdMpL3ctR3ns2B5uueUjKipaEhUFEya4BuKFhIRiNlewY8cvtG2r/AgDmRCYTIrbdU6V4AyNQFgsZg4d+ou8vCPstDpr9+vn2720jJolJYrogI3ZqMmcVec9PeOMoVx++Xh69Ojt9pzycti1SxGuhobFYmb9+q1kZChvpOrOV0MQNF+Szr0KXCmlbCOlbC2lbCWlbO31qmaIIi/kUVsMq1bNJz9fWe18sRFYLBZycg5gMKjERE1NIjh50pWA2kdo2sNiMTN//hQgncREGDkyjcmTZ1clDouJac8//jGPXr3OJSXlHBITlUSQkeHcT23/irqBxeI7t6txoyUlp5g2bTBTpw6sIgT2NQY8QQiVURNsm6uUtkC16qI6m9tNN03h3XcXcs45o92ec/iwZym8PrFkyYvcdddA5s//N1AziaC+4YulJEdKuavOR9LIoaWMiIrSP15R4dkQZjbbdOCqQLayo/siEeTlHeHBB1OAKKCsKpYgJKTmC7ShYTTqc4udOyeRleWaewmgoqIMmE5iogq+S01NY8GCx8nPz+bii+91CMyzWJTrbX6+ItRaUZFAIQT+qAk0iaCiwkBS0hlERCSxf7+yD3hzGzWZDEyfPgSDoYQBAw6zb5+SQk4/XR2vCcPhybhdE5SWNh4iAJCScg7x8d0JC1MvWZOQCKwqoWuBjUKIRUKICVqbtb3ZoLRUcWX2Yrkz1fbmu2x//PzzHwGiiIpyT1hatbJ9//tvLbyiHCG6UVmZXhV+HugSgbukWo8+OoOoqGj9gwBkVnGuAC+/vJVZs7LIzz/ON9/YMpmEhIDmcWyvHgoUQuDPpqARgtjYrrzyylYuv/w7QNkH9JLM2SM8PJKcnAPk5mbQsaOizPbqFn8yhjqjuhtbQcEpysvLdMttgqNBuzFgwIAxvP32QW655WmgevNVWdkwKVA8SQT21RvKgIvt/pfA4joZUSODyaSCVKRUL7SWAqG01JatEbz7pturjTSjmTtpoFcvpavdvRuWLk3nk0/uqzomZSYwhV9+gRtuSAtIG4HJpOajXTv3BPTqqxVH/8gjt7m4hyokVXkBAbRuHceff37Dr7/OISwsgvDwKL788l8YDBqlieW3396mf3+bpBAI8FVNUF7ueq4/aiEhBE89tZKEhN7s26dSedsTgppwqdW99rrrhnPw4B6WL99JSortR5SUKKLuTRVb39DUk9X1sqqsVAxnfRSicYYnQrAcWCal9NPW33SgGTHtH+ipU7bslWYzhIZ6VwuBennXrFH1iFU65SSEeB7nBK7x8Ta7Qe/ecNttejn4y1i+fDo33JAWkKqhvDy1WJzrOTtj7NgJ7N8Pc+ZMcZqDaGCGg0QAEB3dhg4duiOlZP78B53vyu+/38HAgUqVFChz5usmqudJtMuq0PXVUJySMgyArtboH3t3zJoYi6tLCCIiImnRIoro6BiH9v37G3eakOpG/JeWNgwRAM/G4q7Al0KI1UKIZ4QQZ4vaqBkXIKioUClmnbkss9n2gDVu1hc95Y8/qupaqli2BDI4evRWPv7YMZmWvfE4LMyxzKI9iotVu8VSdzrYukBJiY1j8saVX3PNWbz//kT69h1FWJgKloiOjgdm07p1GnG2AFEOHtzI22/fgMlUjrsyllKaWLRouk/3bizwVSKwjwT++edZ3HvvQI4cUSohb/YBZ7RvDy1aKI5b47prkrq7ukFkP/64lV27yujc2RaXmp/fuInAvHkPcOWVLViwYLbf89WQ7q+e4ghekVJeAFwKbAXuADYLIRYIIW4VQnSsr0E2BAoKvC/C0lLPft0aysthwQL96lrLl3/AmjXpgFq0rZ38sTp10veTj4y0tQeSesgf497x40ewWCrp0WMI8+cb+fxzyXnn5QBpDB/umKOpZctYiotzKSw87rGAjUZYA4Vw+rI55OU5qthOncri1CkVPdarl3f7gK2fo3z00T188sl9VXmGNKmgJoSgNje4xmYX0ENFhRGDoczv+WrI+iJe3UellMVSyq+llHdJKQehCtZ0ADymoQ50+LK5Go22uqWeUFzsqbqWrOJS27VzzQXz+OOufvIQTYcOtvKLgaIeMhj82xTmzs3kiSeWMmbMPwBYvXohy5apgIMRIxzP3bt3LS1aKAt7iIcsfloAWkOJ4P7AYvE+Tr38OldfPZ1Ro+YCvquFQMVfrFjxPmvWfEZcnHqhNAeJ6qqGais46uRJ2LOn/ip2VRcTJrzMvHll3HzzA379bs0G2VDwtR5BItDN7vw/pZSv19moGhhms+8iuS8Pe9GidEJCQtwYPW1cqr2qQ8PVV6eRmwvvvPMQxcW5tGmTSGHhy1RW2uoWBIrnkD/GvSVL0pkxQ9lTtPQSv/+eh8UST0jIIXr2tCUjW7Mmnf/8564qicvdPEMEo0crAhoI8+XLO1hU5KoqadGiZVUqZn8IQdu2nbjttnfo0qUfGzeqNo3RqY5EIKXnADhPKCg4xe23X0qnTom8885XHDwYGM9MKwRkMim3ZV/R0Opdr4RACPEKMB7YCWgrTAKr6nBcDYraVLUsWJDOe+9N8bA52eoSx8ToH7/mmrQqbxejESZOxCGWIBC424oK393ilixJ58knp2AwqI09NzeDDz64HbM5AniQkJAOrF37hkNVN/2i9gLNXiBEG6ScRYcO6ppA2FR8VQs5o7hYedX4ax8QQjBu3P0AHLCm6tfclKsjEeTmVj/Ta3FxIVu2bCAxsVuV114gwWh0v5710NBlZ32RCK4GTpNSBpAmumaoTULw1lvuNikFrS5xixbu6xLYv1B6dQlqGv5f1zCbVWZIX8c4c+b0KiJg66MCUDtjZeUJ5syZAigPIHdqNyFgwQJ10//+F776ymZUbczzpcGbROCO454z5zPgZrp3NxIR4Qdbaoe2bS1ASBUh8FcisFhqlu47Pj6BxYvXYbFYdOsON1b8/fcvrFjxIampo7nvvnt8rurW0ITAlxQTBwEfzU1NA7X1UMrK4ORJ94bLuLhuTJ48m9TUNKI9xE5FRsK6dek8++woPvvssaqcQ7m56m9jL8ael+df2Ly79BL2MJnKqmwr7oraa5IWqKIsQFV65cboNaS5JGvfvXnHFBbqz+u2berCnj2rF5m0bdvPLF6svNmqqxqqqboyMrIFgwadQ69ewwOqxnRubiYbNnzJ33//Afg+Bw2dMM9TPYJ3UXJ1GbBFCPELjvUI/ln3w2sY1JZEcOqU2qSUy6gjYmK68e67h6v+90QIAHbt+pXdu1dz6lQWPXq8xoEDVNUlaOwSgb/ufgkJSdaso56h2VbGj5/hEmugSVoaYmONQGSVRNDYCIHRqAi72axciEtKvKvS3OnfW7W6DqMRBg50E7Zuh5AQx7mQUrJ48XOcOKFEgepKBLXl4mnvFhsI6NdvNP/850JSUpROztucGQzq09Cef54kgo3AJuBb4Hngd+v/2qdJwmCovU0iP19tUnpeP1ddNcOhxV2qCQ0jR15C377nMWLETS5ZSBvbpmaPigr/xzdlit6cuULj+FNTVeK5uLhuCCEcJK3KykrS0sJ49lnl7Xz8uBpPQ83Z22+/TVhYGJdffjklVr/jsjI1Lm2uTp70zZ6i57ZcUgJ5ee0ID4c+fTyrhUJCoE8fW0lKUHaCBx/8imuvVfUMNInAX2ajpoRg794dvP32i6xY8UPNOqpnxMd359xzx9Otmyrr7m3OCgrUp6HXsCcbQSHwu5QygDR0NYPJ5JoOubowGpVvt2bQnDfvn5SUnAK6ERk5g8suS3M435tEcOml19Grl6pHsHy5atMIQWOWCKqzIZx5ZhqTJysjcF5eJi1btqe0tBgpbTo7Z47fPtGcPcKqkvAXEh1toqwsgvz8hpuvlStXYjab+eGHH/jrr/307DmwWqpIdzr4/fvVb+vRw3vBopQUZW9q3Vr1pW36bdt25PrrH+DbbxVBMhqhZUvf58xiqTmHu337Jt56azojR97C4MGX1ayzBoAv0cXuanQ3BDxJBDcDf1lrEcwTQkwRQvSvr4E1BPLyao8y24vtqalpzJmTx2OPSeAwvXqlORiQhFCRnJ5gbzB2lggaMyHw90UvKFDEo7y8iCFDruLpp1czZ04u0dEfozyYHTl+X/Dii5uZO7eYrl3VznjsWMNxYG+++Sb9+vXjsssup7Iyutr2KHcSQ0aGiiyLjPRsZ4mIUHErGuzzZoF6J9tay/kWFPj2jmkpWbwFWPqCXr1O56qrpjJoUGARgeLiPFavns/69UsAz3PWmNy+3UoEUsrrAYQQycBw6+cuIUQSKo7g0voYYH2iNg029jUDNGjSRkenmOzoaO+eBUKY+P33LykoOMmZZz7ocI+GFis9wV9CkKPqyPDdd69y8uRhKiqMxMWNoLQ0jejoNObMce9d5Q7duqlivZ06qaCk7OyGW4DdunVjx44dFBb6FozoDu48cjZu3A6cQ1bW98A9+ieh7BD271zr1iqlib3x2WQ6APTk4MEsunVL9DpnpaVqXDXxFtKQnHwWN954Vs07qmfk5R3h3/++lW7dzuTee6/2OGeNKVWGL5HFh4HNwF/AFuAEKjG+Vwghxgkh9ggh9gshdKuQCSH+TwixUwixQwixwPeh1y7M5trbUAsKHBfDyZMZvPjiWFasWAbYOHoN3tRCACaTiXffvZn58x+ibVu1WrVYgsbqNaTlQfIVFRW2zbF797No374LycmD2LxZtfXt6z8RABVwdv/9yaxcGQIk8+ef6Q1GPDUusKYRss5cd3l5MTNnXkVenuLtRo0aoXOVDc7Bi0I4SggAoaHKLW337v0+SQS1QQA0aEbqQEPr1h0YMSKNwYOv8LouGxMh8OQ1NA04F5VOYg+wHngPmCKl9BrCJIQIBWYBFwFHgT+FEN9KKXfandMLeBIYIaXMF0LE1+TH1AR1mQ/lyJHtbN/+M0KoVAnxTr/Sl8CTmJgYoqJaERIShtlcQOvWcVWxBG3bNk5C4K1GgzPsg6Meeui/Vd9fekn9HTrU/zGsWZNuDUbTHnAGO3ZM4Ycf4IwzfFMt1Ra+//4Hli1bx8UXX0XXrj0pLMz3WpTdHZw33YKC42za9C2hoa8BMHTomW6vjYpSOn9ntGvnKMn27duL33+HTp3O87qpVVbWrr57794M8vOLiY3tSnR0m9rruI7Rvn0i9933GeCZQasNO0ptwhN/dSvQGfgJSAcWSCn/8oUIWDEM2C+lPCiVlW8hcJXTOZOBWVLKfICGNEzXFiEoLnZNpdC+fRd69hxGZOQAwFUi0HSx3rB0aRH/+c8pWreOc4klaAzQCviUlGjeK/5dr6dOKyuDHTsUxzpokP9jWrRouh0RUJCyjHffne5/ZzXEV199zXvvzSA9fTaDBsUyadIV3i9yA2dC0KZNRx56aDGgCIuz+tEeeqlMQL2H9uqiLl1UwQzNq0VvU6uoUM/aX6LvCSYTLFjwAo8/PoB16xbVXsf1DHdzduKEivxuTMybp+yjfVDc/EZgNPC1EOIPIcQcIcTtPvSdCNinwzpqbbNHb6C3EGKtEGK9EGKcX6OvRdQWIdDLjpicPJAXXthASIhapPYSQXS07zlJHL1A0oFknn46hIkTk1m4ML26Q64VlJSojVzzh/eXQBUVOW4mOTkHKCk5xebNFsxm5ebonJnVF7iLOj5+3HvQWm3jggsu5aGHnuOmm+6iZcsYYmKqV/rbYHBNKxId3ZqUlGswm0Np1cqzutEdIQgJcXRj1hiU/Hz3m5pKqFgze4czCgsVYUtM7EebNvWb5LikBFavrn7aFiklZWWFFBQc150zk6l2VWi1BY8pJqSUp4DvhRA/AWcBo4C7UCmp59bS/XuhCE0XYJUQYoCU0kFDKISYAkwBSNLqDtYyaoMQlJe7XxAlJeoFiIx0LEPprJf1BI1grF79GYcP34WK9VM2iPvum0JkJKSl1a+6A9QmUZONwGy25bbR8PDDp2GxmOnf/wTQgSFDfO8vMtJWcN1dQJ+WhbQ+MWbMtYwcqaq8bt9eVFXRyh9YLFQllHOGZmj3JA20bu2Z8WjRwrZRae/m1q1bKSnpp7DqfgAAIABJREFUhpSuomttSgKgft/RozB+/AuMH/9C7XbuAxYtghUr1Fq++GL1DoWH+5YmAhQhuPNONU/btpmR0pHXbqzZUz3VLL5SCPGyEGI1ykA8E4gFHgE6ubvODlloFdoVuljb7HEU+FZKWSGlPATsRREGB0gpZ0sph0gph3Rw1qvUErwRgspK7y+9u1zpOTkH+O233wAlDdi/VG38UH/eeOMAJkwQfPzxPZjNjmxFeXkZ06fXv7oDFBGoSeK7w4dd9aXaJnn8uFpU/f1wXO7SxZZSwl1A3/DhM1yuq0tYLI6pS/whApWVao4yM5XXk54hde/edaxatRbwTAi8LR97N2aNEBQVhXLqVFbVM9b+lpfXfsLDrKyG1Z3//bf6u2WL+j5xIixb5vv1ISEhtG4dT5s2HTEYjFUSgRaoWhuutXUBTxLBRGAt8DiwSdpH8/iGP4FeQojuKAJwI3CT0zlLgAnAXCFEHEpVdNDP+9QYUnrOhVNZqeoHh4UpFQXYMn9q0Gob6+Hrr2ewcmUhMNphIYaEOEoHPowUwK4OryMyM+tX3WE2K3VQTbwfSkrg669tJTy1lNOffVaB0Qi3367KgdrXJ/aE6Gi12ZnNalPRYg0++ugfGAzFREcnUVb2Ii1a1K/kZDDAmjW/EBPTmgEDzvJYM8EeFgts2+Y9/9XatQv47beOwAi3hCA01H2dbA32hEBTIYWF9aFt2+IqT6ucHN+L3fgDk6lhC88UFNhSWuzapdanlLBqFYwZo6SFfv2826o+/FCJZhER6vrycjVnQjQuu4A9PNkIrrXWHGjrTASEEHd761hKWQncBywDdgFfSCl3CCGeE0JcaT1tGZAnhNgJ/Ao81hA1kj1JAwaDMlaWlNgHO8GhQ47necquGRXVhpCQFMCRI4uM9F3kBOjffxAqtbI+6kpt5g5z5qQzZEgyPXqEkJqazJIlvtkpLBabdDVvnmMJz9zcDObMmcKaNelkZak57dRJEWFvaN3alnY5NNQWJJWamobRqG54/fW/AGkuz68uUVAAx45VcvPNY7jmmrMB+PTTWZx/fi/mzn3H47Xl5b4lQUxJGUZc3IWAe4mgQwc1L55gTwhatlRzWlkZRkVFOywWZcsxmdTzq221kBa4BvDMM6k88EBPcnLqjy/cs8f23WCATdZEOocPw//+B99/Dx9/bGMcvbkgazYCzXmksRIB8C0N9b+EEEYp5f8AhBCPA+cDH3i7UEq5FFjq1PaU3XcJPGz9NBjcLbTSUti501H8zc5WOtTychXGL4QtzbI73Hbbm1gs8PPPjoZibykA7LFkSTrffJOOu3q8UVHRzJhRf+qO+fPTefjhKZSXKxVVVlYG06ap1NBXX+3KbS9Zks7MmdPJzs6kQ4ckbrhhBpdfnsYnn7im6dYyi95wg+rHuUi9Hnr0cHXLTUiw1Z3u3n0wFRVGEhPV6q0vQmA2qw3OaDQyfPgFmM1mQkJCKC8v4/Dh/WRlHfZ4va+ZN0eOvIVly5RU6o4QOEcP68E5wr1TJ7WRadHYdenfb29nys7eQ3FxblWhl7rEL7+oTV8zsIeHOzKHUsIXX6jvublqD3jjDcXIzZjhnpnTXEQDIXuqL4TgSpTB+DFgHNAHVzfQgIZe5SyTSXEIzjpQ+1xExcWKYzpxwnuaZe06Z4nAV8ycOR3pgaV4553Z9WoonjZtehUR0FBeXsbMmdNdCMGSJelMm2YjGidOZFTVE3Dn1ZObm8Enn3wI3OWREISEqLq8ekb30FBFDI4cgRkz/gRsC7y+jHaavjs6uiXp6b9UtV977a2MGXMFHTs6O9I5wle1m8EAGRlqU0rU6bJNG+9pTEAxJ/YZSdu1KwFi2Lx5D2lpp9VZIJ7F4ljP+o039lJYeLzOvYYqK+Hzzx2lmwsvhJ9+Ut87dFDqT/vjCxbYVFhHjoCzID579iQyMrby0kufEhvbt07HX1vwJbI4F0UMZqHiCq6vhr2g0cJg0JcIPvkknbvuSmbChBDuvz+5qsC8PfLz1UI/etT7fbQ8+NWVCDzl6G/VKpHrr68/IlBUBFlZ+uPRG+fMma5EQ+P63dUSADAYlK9B1676x8PCVLSxJ88rZ7WSphqpr9KA7gyfHTp0pGfPPsTEeDYS+cpN/v77cSoroWdPqRug6I+PhT3BEGI/AH/9ta9Oo7ELCx1VLTEx7UhM7OuzLaW6+Ptvx00+NBSuvFL9DQmBm2+2HdOGokW6g7LfZGZSVdoT4OjRnRw8uJHCwlr0qa1jePIaKhZCFAkhioD9KEPuDYDW1iSgJw0sWZLOG2/o663tceqU4sK8eU5MnXoFOTkQGmpw4G79kQg6d3a3YQp69ryn3vSPRUXqd7sbj167OyKWl5ep69UTERHFeedNpGXLkYB71VDHjt6N7aGh6pySklPs3buOnJx9VQvan2I51YVGCDxJc57gCyGwWMzMmbMYgAEDXO+jlz7CE+wJQffuaoJDQ/vVKSGobm3j6mLvXti6FdavV/8PHKgYhv791Vw9+ig88ggMHmybj7FjXfvZuFGph15/XTknANx55/s8//wGuncfUD8/phbgyVjcSkrZ2u7TQkoZo7XX5yDrEnoL7bXXpmM06nOw9jAafXuBT53qDUDbtnsdjHX+SASPPjqDqCi9KKG7SUiYUm+EQFOp6I0nKiqaRx91tVO4IxqxsUmkpqaRnDywqk1lFp3DxIlzKSlpRViYe922XpoEPURHw8svX8LTTw9n7tz7qiSE+qgKpUmby5d/Q9++0TzyyG2AUqO98spUnnnGc30nX1RDpaVFhIRcDsCgQa5Luk0b70Zie9gTgjPPVNZ3i6VHnRGC4mLHqPL9+zfwwQe3s3LlvDq5X2UlvPyy+qxZo9puvhneeQceekj9P3CgIgJhYXDZZSpl97XX2giqxpzs2WNjJjW7U7duZ5KSMowWLfxyCfSKuiTEniSCZE8XCgUfzHiNF5WV+uqBY8fcc7DVwWmnPQ3AqFGOOg5/JIKrr07jxRdnk5BgK75y3nmfAf/GYIirlwL2RqNt87z66jSefHJmVb7/xMRuvPjibF1D8aOPziAy0pXr1+oJWCxq8P37j+Hddw+TmppWpW5LSHC/iflKCKKiVA6YkJBQwsLCqwhBXdeJNZlsi7e4uAiDoRyLtSEsLJwPPniF+fNnYXbz8IxG3xZ/SUk7LJYkYmL0i9V7cxl1hn10sUaEc3LqhnCazaqGgj0yMraxcuUn7N69qvZviPIC0hhAs1mpHhMT1Savtyavvx6ef17lBBs8WLVdeil06+Z4nrP3dm0zZ3VZu9mTsfg1IUQI8A2qItlJoAWQgvIauhB4GhUUFpBw92J36JDEiROu0aj2NXB9hZRw8KASoM4+21E+90ciALX5jhuXxpYt6v8tW2DlSsVN1QchcA6GSUhIpLKykrCwcNasOez2uoED05g0CT7++B7KyxX7dO65N1b5+D/44H85eHATsbGKUK5d+zlffVUMTHExxGkIC/OdkLZsCQ8/vLjq/ynKTl3nEoE9obn22lsYN+7aqk0/PDycadNm0qpVG8xmM6FWaiel5N13X2Do0FT69j3fp/usVXFkDBign53VH7UQOEoEkZHQvr3k1CnBkSOVxMb64l/iO06ccLWj9Ot3HpMnz6Fjx+ol5PMGzU00JUW9A1f54fpy002KGAwapOx+GRk2L6MM65axZctPHDz4JxdeeAldu/oREu8BRUX6auzagqd6BDcIIfoBaaiUEgmonAa7UC6hM6SUjSiRqv9wpyO+6aYZ/Pvfnmvg+orjx5X6qFUrR6NnWJjnlMrOLmwa7De/Eyf+B1xAdrYBKX1wCakBpHT1G09K6sno0Zdw4MAePv74Le6440Hd606etFUQe+aZkRw6tImVKz9hx47/MX78DFJT09i+fQVvvnktUlqIiIjCZPp/AJx9tv54fEndraFFC8dgnvqSCOzVOkIIWrZ0tOJOnvyIyzV//rmGN99UHta//+6Zpdy8+Xt++ulbdu58D4ggNbUMcJyYmBj/g7+c57a4eB0wnM2bTzBwoI+RfT5Cj8tNSOhNQkLvWr2PPfbuVX8vvBBGj/bv2uhom1QwbpxyGBk2TLmTahLBpk3fsmLF+yQktGfs2NohBNnZvmUpri685RraCTRM3oJ6gN5GazTC2WenUVEBCxc+SV7eUdq168xNN73ic0Use2jh6Wbzz2Rmxlfpw91xsyEhysMjMlIREefNSgh1zGiEpUsfALaTnx9Wr2oODb17n84ddzzErbdezEsvPaZLCEpLbdLKmjXpHDq0GZNJyeWaEX7v3rWsXDkPKS3We5UDMwgJSWDgQP38hr6qhUDNWVSULYeORgjqOpWBv/7jFgt06XIa8fEJ9Op1ulcX1927V7N9+zggAljI/2fvvOOjqtL//z4zyWRSISRAICGhBRSlCIiNol8RO7CrP1tkERVUXNxVsYFt1ahrR8WCBVHjChZYG7gWLLiwAoooUgTpRUpo6WXO748zJ3Nn5s5k2k1C4PN65ZXJzJ07J2fOeZ7ztM+zYsVi+vZ93Oua8CrXFex2zxoDSE7exb59sHFjbM3OgwcbNsd+1y4lTLVF0L17dPdr1Qquv159b06nqrE4cAB69z6LlJRWdO0am8Y6lZXq3o2mCJo7zCwCbd516tTXHeyR5Oef6KcEFizwp0XwvebLL7UiqKKs7B7277+37rVAbqHUVI+Ptk0b6qprjdCbNC+vGzt3/oGUbdm2zd9nGUsEEppdux5NUlIKLVuaO6K1OfvBB48we/YDpsVjn332vMk7y3A4/kF8fPSKAGDjxv8xceJpxMUlkJam0vqsdA1VVXm766ZPf5off1zIqFHXc/zxAwHYsGEta9eupGvXo2nZsivr10N1dRvmzNnG/v31JyIcddQEPvwwh/j4arp1m8vJJ0/wuyYSRQBqDervfNCg4Xz4ISQnB8jjjRCBfN5Llvwbm81Ojx6n4nTGRvrt3auygBIT1ZpMSwutwC4U2GzK2v/tN2UV9O8/nP79h5OREZv7m9GzxxqHtSLwFQR793o236RJ/epOrvqkqrFggaJF0EJNn2zBw21TUgKvvaauP/rot0lMbENOzjF19wikCIxmeVyc90lWQ1sTN974HnffrRbg5s1w0kkh/NMRwrzW4hmqq6v4z39WkJ3t78yfM6eIhx6abBpvCQUVFYGD8+EqglatUqiqKqeqqqIueGqlReB70v3++2+YN+89hg37U91zM2Y8w2uvPc211z7OkCGe4vqNIU7XkiUqV+P//i+eK64wz7CJVBEkJXmqiB0OVTobS6uzqipwv4oZM/7G7t0beeqptTFTBKtWqf2u93y3buHRu9SHvDy1Dzdu9BAkxirLpyF6jhzWisDXItB5wFJKamvVi1Om/E6bNp3qrlmwoIjnnx9dl+miodNLtSL4/nu16I49FiZP/guqz48HZopAm+RGpKYGVgSgiMG0IrASZkLz8cfvpKRE0SlffbU3S4hvNXFwCMyoM9LTzf3RTqd3ZksoyM/P57rrZtCmTWdmuGWmle40X0UwbtxEzjzzTxx33Il1z7VseRx9+pyNw+FJvnv33XtZuHAmf/7z3ZxyyqUB73/woCf10Sy/HdQcRUoOZ5xf7UqLZWvFLVsCC8o+fc5m164NtGzZLmafpzOTdNV0jx4xuzXgqS7euBFKSvayZ88mystb0L17x6juW1LSMC0t61UEQoj3gVeAudL3aHwIwyx1VAtcIQRvvllFcfE2WrXyCCNtCfgqAQ1jeqnO5DglQOtYs3J/swBoYqJSEEY3g1ERZGRIQFjK2hio93BeXhc2blxH794DqKmpweVy4XBrOLNqYjM4HEkMGTKar7+e4eM2ivOyoIwIVGkcDC1aOBg8WCljnY5qlSKQ0l9xHnfciV5KYO9eOOGEKzjhhCtwuWpZtOgdevQ4jT/+WMe2bat49tnLEEJw8smXmH7G++9vpbo6m65d99GunXmLu0itAfBeizt2/Az05McfFwEnBnpLyCgvD54KedVVZq7C6KD7XYwfr76fAQNie/98N3n+woWQkfElc+ZcyLBhV3HaaS9Hdd+G6kAYSv32cyj66N/c/QmiDLE0DfhaAzpnWzc6v/RSG/fcc7JXNfHMmf4EaUbo9NLiYkVjGxcHvXtX8M47dzNv3jNe15oFfgJlwvi6QbQSefnl6/joI1WjYGXQzSjU5swpYuDAjnTqJFi1ajklJQe45JJTyc+P59lnH2HzZnVaDUaJoaGKx6Zx5ZXPMXbsNFq0yEVZBzmAoGfPoX7vSUoiIt9rQoJHAVidNVRVVX8OudGCW7ToHaZMuYi3376d0aOn0LPnGUBgHiaApUvVmSwl5f2A10TS0U3DaBFIqRbX/v2xIWgKRtBoBWprPcVevXrBwIHhp27Xh44dFVV1TQ3Mn38W2dknBLRoQ4XL1XCKoF6LQEr5OfC5EKIFqnfA50KIzcBLwJtSygaoz4w9fBVBebm573/q1MuZNm0sr79eFnRjGtNLv/lGCYI+faCiYjPvv38/IDjrrAnua82zhgKRgjmd3jnE+r0JCYmA2qRWmo9aEfi6e3ROvLaQ5s//hpNPVi62jAzzzmAamZl5PPPMBn788RPeffcfHHvsUHJzN/Lzz9C163xuvLG7lzWm0S5Cb8GcOUXcccc1VFSUYrfnAA9TVWUNP5NZEsJ7771OQkICOTl/Ahx135eUErtdbcMVK74kJaUV1177GrW1VQEFSXU17N2rXjv11MC59qH2wjaDzabWXUUF5OUp4rTu3U+O/IYGBOtmV1lZRnV1JcnJLSPq4GZEba1iFm3ZUinnUChJosGoUSojafPmZC6/fBFD/c8xYWHPnoahQYEQYwRCiAzgcmAU8COqYe5AYDSqzeQhB19XR3l54BN/dXU5UsqAbQ9tNjtjx05j4MACfvgB3nlHPT9kiAo0p6a2Ji7OcwQxswbi4gIHr3xPLw6Huvbiix8kPd1GUZG1FoE+Odfn7tmxY03d44svLvRSqkY4HEmMGHEHb711G3PnTqGmppI5c56gtvY5HA4oLp7M9debZ2NFspG1Aquo0ApsCzCO//wHhg2LvTIw27yTJo2jqqqSGTPK6r7P4uKt3HBDJ5zOZJ5+ej3p6Yo21EwBGrF+PdTU2MnOhhNOGGJ6TWpqaD0cgiExUSmCVPekCxFmhN4EpaXBg/RLlszh2WcLOPnkS5kw4a2oPmvBApg+3bOvunaN6nb1wuFQhWabN6tMn2grixsiW0gjlBjBbKA78AZwvpTSzaPJTCHEksDvbNrwFZzl5cFMcYGU0lS4aR/3zJmTmTp1FJALFDJ8eIG7z253pk3zdoiaKYJgpqouPjMG11RfXmedO8nKDBitNOtz9xhjJFp4qxTbjdhsdlyuWjIz8xg+/HZeecW7t1Ft7QFgDDU1guJipXl8s7EcjtColH1hrsDKmDFjMo89Zr0iqK2t5U9/GsWuXQeJj/f8AykpGSQnp5OV1ZXMTJX7+/LL15KamsH/+3/3Y7PZcLlcLFz4Nv36jcDpVIJYF0QFy4OPxhrQ0GtS/46FK62+3tZVVeUkJqaRltYm+IUh4Mcf1W8tkK1WBOBxW+7eHV3WUEWFtZXEvgjlzPC0lHK+2QtSytiUzTUwamv9F3V5eeBG55mZuezcaSM+voCxY5Vw27NnExkZHejefRDz579KTY2WxBux2ca5SanMhYzZqbY+n6XD4e3+0Wa7fp9VriFjG8/27XPZujWwu8eXgkNXE5vh1VevM3m22m/zGLOxIjXrg7GfWgFfRWC323n44Zf46SfvA4jD4aRXr2G0bNkOIQRlZfv54osXAaioKKW6upza2hq++upVLrjgXi68UMWDVq6sBexkZ+9BtRH3R7i0EmbQa0uIGiCOdetWodqRRI76aiNOO+0qTjvtqjpOpkhRWws//6weZ2erytxw+l5HCt3e89tvv2LXrkI++OCziO5jZQMgM4QSLE4XQvzZ5+d0IUT0KruRYOZGKS83b3TucCRx7rmF3HMPPPUUpKUV8MwzGygqcnHttdP57rsigxJQcLnKmDVLFWTrbBoNIcxz4OtL8/ONKTidipxr+vSrAesUgTG7KjADqsLu3Ru9ejeUlBTz5JMXMmPGjVGNQQvsSBVBIPZTIWwUFYXWXjMcmLmGysvN1931179BQcEjfPrps0yZcjGnnz6Oyy57hHnzpjB//isMGjSKVq2y6ygXpIRVq9R6+uyzy/1viFor4VBwBILHIlBiYtu2LVRHUYV38KB/KnQgRNqHwOVSHEC//aY+q107xTL6zDOhdbqLFloRVFe3obg48lQ+Y5OehkAoFsFVwEmonsKgYgJLgU5CiPuklG8EeqMQ4ixgCmAHXpZSPuzz+hXAo6jm9gDPSimjy7cKAb5Cs6pKbV6jO0Od+HNp3fpE3n67V53r5csv4Z//nIDL9SBXXhk4fUULr9mz7+P99+8nPb09zz23leRkc46hUCwCIxISoLa2hrKybab/U6xg3PcjRxZQW1vDk0/ew9atHnePEUZ3TmZmHt9//x42m53Ro5+su0YpCvPaATNoSyNSRTBxYqFpTYPLVcs4NwNdLLu7+WekVbB8+X6qq1sSH2/OLbJ69QKWL/+U8eNfZ9CgUTgciezbt51u3U7moYfWsXp1Atu3q/hAWVk8dvseunc3jyXEiorAk5SgFmzbtke5v+/IihNCLZSLBv/5D8yY4cmY6t1buVZjVeVbH7QicDiO4q67vkbK8AvXjH2OGwqhqN144Ggp5QVSyguAHqgdfAJwW6A3CSHsqK5mZ7vfc6mbxM4XM6WUfdw/lisB8D+ZGYXorl0bSE5O55JLHiM3dwMrV55PZeX5qKnqyPffF+FyPQSksmpVp4AdtrTwWrdOtUjcu3cbEyZ05L//9T+BClF/YM9XETidkJXVlRNPVNSJVqZCGvHAAzexa9cObrzxLYqKaup8297vUe4cpzOFnJxj6dzZ40EsK4OXXppMICVgDKqDJxvLbo/8lKspvO0mfNZlZWVMnhw7Oq3aWv8g4Ucffcsll2Txz3+eE/B9Q4deyw03vE2PHqcCcNxx5zJnzoP87W/XcccdDp54Am66SZ1sAc4/P4Nrr33F9F7hFNsF61Og15y2Vlu0yCEhITJyw127/NlrzfDUUxdx//2qniIS/PST+q0FaZ8+ga+1AklJ6qeqyobNlhlRnODgwYZhEzYiFEWQI6U0Zv7uBDpIKYuBYHbiAGCtlPJ3d2vLt2kCvY6rq/0n2ah9lyyZw8aNy/jyyzR++KEIGAeoTmWwESnHoZi5Yc2aVHr3Phd1uvVAC68FC4pYudLDqb5790aeeGIcc+Z4K4P4+PpPDfHx3paE0wlJSWmcffY1QMNYBLNnv8m+fcVUVVUyffrNLFhQFLTn8JYtK3j00Z+5/37VBqq4GO6+G6qqAvvmr7nmVTIzPT0XdDZWZmZ0lAAjRxYE9Dtv8iWSjwJm9Sm7dtWQmppJWlrgfpE9epxKx4592bz5F3buXM+uXRtIT+/Mvn3PUlwsaN26Cru9FptNcvnlcNFFgccQKj13QgK0bx+43kArgljUXezYEdp1a9cu4tdfv8JmCz/lSUpPBXHr1urn6EZoGWwMGEci0BvaGoDQXENfCSE+AtxJkVzgfi4ZCBbSyAaMxAdbUFaELy4QQgwG1gA3Sin9yBKEEONQEpncQAT1IcLMf6uLNhYsKGLnzt8B+OOP+4FSFPO2EWXAZBITC9i9+y3mz5+B9+lWMGTIaAYOLGDChI5+6ZOVlf4N3kOlAYiL82xGvdn1ZrUqa0grgjlzipg8+Zq65/ft285LL40jJaUVJSXmpDG+/EtvvqlqDOz2XGprzYLyeaYBZpvNvCF7uAgU7I52TRnhu76KixVlwrRp9ecC/u9/7zBz5mSGD7+NSy99mFtuWcukSYK2bSUlJTnU1lZx//2/0rFjJkIE9iWGahG0bq0sgvR0ZSX7uv9tNrXm9PosKSlj164DtG4dHltbRYU/hXkg3HbbXPbv30F6evgFIzt3KqsjLU3F81yu6FNoI0FmpkohnTHjMU47bQxZWaH7pWpqGjZtVCMUi+B6YDrQx/3zOnC9lLJUShla54zA+BDoKKXsBXwGmDJnSSmnSSn7Syn7tw6nC7cJfDdqaalaqLqYrKREpzVsAgKwYrGJ3r0BJuNy+SoKyY8/fgIETkf1zWIJ9QRnNONtNvW+jz9WRWxlZdZUnlRXKyUwceJo0wb0gF+A3fj6m29OpKSkmO3bVX9Yux0KCsyD8oH6PbRvH5tK0IkTC3E6vT83KSmJwsLw+0wEgnF9PfbYnXzzzdchva+qqoLfflOWU06OSm/ZskWZQB07Cvr0GUbfvoNISjrIzTcfxbXXZrFnjznBVCiKICHBIySFUO0szeBweBTB7t07+frreSH9P0YEIpczQ4cOx3Dssaf7uQhDgbYGunb1KLHGgI4TrF69ic2b14f8PpdLFaRZTY9uhqBT5fbzf+4W+O+Fee+tgJEVJgdPUBgAKaVxibwMPBLmZ4QNX0WgF2l99BFG2Gw2Nm58DKUs/KEVQKB0VN8sllB9374LOyEBvvvuVWCyWxHEduXX1MDs2aoYK1A7xdLSYsaPf4OpU80zWPbv38GDDw4jL28JUsLgwXD22SoV1BiUN6Px1tAbK1qoYDdMnnwrlZXbSUnJ5oUXHrYkULxs2fdMnVpIQsJTTJ26heTk+hL7JT/88CF2e1wd2ZymocjJgQsvfBNQCQL79/9BVVUFLVq09buLwxFaf2LfzLVAa9Dh8Kw7uz2FtLTwCxSsbkwvpTrMGRVBY0Kv1969r6Ft29CTK7dvp94eFFahvsY0tUIIlxCihZQy3ISmxUC+EKITSgFcguIsqoMQop2hQG04qvuZpQikCILRRxgRF+egpqaKPXteRhWPmbUQ1fyLAAAgAElEQVS0VHlqF19c6CcgfRu8x8eHfnIxUwSdOh3F779DbW0Y3clDRHV1/dXEugG9Lhzzh+DgwXv5+mt18hw+XD0brMbACLs9siKyQLjgggLuumsHcDPdu8+loODs2N0cj3vF5arl+usfwm7vFIISUD2cBw8eTXJyOlVVFTidyXWKwOi5stvjePXVg+zbt8P01BzqXPkqAiOlhBEJCR5rzOnMZNiwkaF9gBvl5aG7hbZv/41vv32dvLzenHDChSF/xvTpKptPW0KNrQh0jMDpPCaswr6G4hUyQygiqAT4WQjxGcppDoCU8oZgb5JS1ggh/gp8ikoffVVKuUIIcR+wREr5AXCDEGI4UAMUA1dE9m+EDqMiqK1VZtiCBUXuKk7/U29iYhrl5QcBSWZmHmeccT07d64jOTmdzZuP5aefxnm5hxyOJC655CFACbs1a/7Lt9++QUVFCW3a5HLHHYVe8YFoMjycTpg8+WOuugpqauIjSlULhqqq4NXERndOoKrrTp2msXr1edjtcPHF4TcDCbfvQChIT29FeTkkJETBymYCI+to374nkZp6Ulhukeuue83rb60INNuqy+Vi796tZGR0CEhDEYoicDrNrQZNKWGE0SIIt4TA5fJvTB8Mmzf/zOzZD9C//4iQFUFFheL2qq1V8QEhoIs1rY5DhvZe794dOs1EWVnDdmvzRSiK4H33T9iQUn6C6m9sfO5uw+M7gDsiuXekMCoCI9GcmRJwOJK48srngp5cFywI7uK48sqpXHnlVECZ+L5FLeEoAl+LwOm0NlhcXR04wGrkVwLzGowLLyzktdfU8//4R2Qb1Ir2fMOHj+GFF6B//wAc4RGistJ740dTFFRWpqzV+HhFllZbW8Pllytn/fTpJXV0E74IZT0FqsdISvKngDDGCGpqwOWS2GyhnTbWrw/dGgBo1647F1xwL+3a5Yf8nh9+UPOekaHcKp07x6aYLhpoi2DHjgq++upzRow4r973NKY1ACEEi6WUM4BZwCIp5Qz9Y/3QYg8pvdO5ystVNySz2ICvoAuEgQNVpfFbb7k4/fTrePXV67n0UuFVYavhu0mFCM/tYaYIDhzYhs0mA/YMiAbV1ebVxA5HEtddN8NvbgYOLCA3tydt23blzju/ID29gIoK5dqI9JQWiUVgzHQJds9Y114YT9PLlv3CL78s4ODBMEwCA7ZsUb9zcpTbxm6PIz9f9QLYvz8wj3N9iiBYPUZ8vL+loOm7hVBrbNSowLUQRhQXh5/90qHDMVx44T2ccspl9V5bXKwUzX//q/4+7zx47jmYNCm8z7QCWtGWlkpeeOGeoNe6XOrA0OQVgRDifGAZMM/9dx8hxAdWD8wKGK2BOXOKGDo0M2Dqo5QuL0HncrlwuVwsXfoBb755Mz/88JHX9QsWFPHOO5MpL1fHwN27N/LCC2O49dbefPutCvT5CrVgjKNm8N2kn35axIQJebhcdqAjr70WW7qE6moVYL333mfJzOzgl9tvhp9//pwdO35j9ervePxxVfCUnR2Gf8AHkVgEycmBs2DAIyzLy2ObaWVUBE8+eRf/+McgVq4MLWsI1Glcu1J0aYPRgvzb397hvvsW0rZt54D3qE8RJCcHX3O+ClRntMXFqRqM4uL6zZyaGtiwod7LIoaUUFiohP7Sper/OfFE9b9F2pEtllB1QRJI5PjjA7SPc2PlSvVjZbe8UBCKa+heVHHYVwBSymVCiMArsQlDK4JQ2igaCdRGj06mqqqMO+/8grlzn2bFii/47bdF9O3rMflmzpzs516qra1m8+blLFjwJkOHXu53+g83vU0IT7eyOXOKuPPOcbhcWpht5O9/H0dycmzoEpQbQD1evPhbdu/eTPv2R/H448Hj+YMGjaKyspTc3D5UVSkffH7+biD8CF58fOiptUYkJSmXxt695gU9y5fPB07jrbf+xWuvjQr/A0zg25UsK6s73bqdbJrZ44sDB2DePPj4YyUQ+vXztE01dmPLyMipS0QwQ1pa/fNVH02H75rUlOcOh43qanj99W/M34hyzWzZohRiJIJtw4ZlSClp165bQNcXqOwaY0e+nj1jw7YaK6j5ElRWwhVXPBjwut27Gy9LyBehiKJqKeV+nyYRh2TLSq0IQmmj6J3Trhy/e/ZsoUOHnmzbtsqLNgGCZx2tW7eYpUuLOO44bwEdSZ5zXJwSbmb/Q3m5okuIhSIwupkOHFDcAEYKZTOUlcGAAdPIyYFly9RziYnlDBoUWYPYSN1CWhi2aGGeutiypbpxLDOtjPEBKeHCCx/mT38K/p41a+Czz1R9hV6b8fHqlAuKMG3w4NDHUF+JTSgnZt/XhdC9j9X+r6nxXrRGob96dXTUCDNm3MCqVd9y551fcswxgUuUfvlF/e7XT3UbOyo6QlRLkJCg1oQZyZ4+NFjdZzwchCKKVgghLgPsQoh84Abgv9YOyxrozVYfr35KSoaX6+Oxx1aSmpqB05nC4MF/8SJQ0whUMwAq1/7xx8eRmYlXxlAo+d6+0O8J9D/Eii7BqAjuuWcWo0bVBKyzcLmgqEh1g/INWp9zTiIpKWF2mncjkt7ERldSWpp5I5RevRQBzfDhgZvDhwvjCbi8vH6B+O678J67MkcIxYkzcqQKNM6erYrozjwz9MOC3R6cWE2I0E7NZp+nFIF6/Ntvyvffrp2KUa1eHbsuWllZ+ZSV7adVq+Bl5FoR9O2rXEJNEfowsmXLTjp0SMDhaEFiorICfv89ul4FViCUyuIJwDFAJfAv4ADwdysHZRWMvPqB4HAkMXr0FK/nWrfOw+kM7qw2o7A2oqJCUUsYEalFAIH/h1jRJRgFW1kZxMXFkZRknm759dfwySdK4ObkVBEXV0l8fDnXXQcXXBDZ52dnh2cRpKQo4ekr7Fq39veJJyerVKuqqtjl2hoVZ328T2vWwPvvq3Gdf76iQ7jtNtVoJjMTxo6Fc88Nb320bm3OaqsRqv/c7BqjInjkkQns2LGbdetgxYrYtlK85ppX+Oc/f6qj3PZFSYlai7/+qv5uiP4CkUIrguuu+z+mTZvJTz+pRjlr1zY9JQChZQ2VSSknSymPd9M8TJZSWtgh1zroL2DixEJTFkUhMurNFCou3kZFhT+N4sCBBYwdOw27PfBu8z3FR6IItEVgls2TkBA7ugSjYAvGGrl/v7IGAMaPh6OPvpGaGifV1Uk8/7zgssvMM6iCweEInVvIboc2bZQANaOhiIvzz8yyonm9ryK47bbeXH11Ky8WzdJS+PBDmDJFuQfOPx8uu0yNPxokJNTPtR8qhbfZmnQ6Pc+vWPEtBw7s9L/IYpSUwM03w7XXqnls0yb6ebMSWhEkJWVz8KCypBuDOiJUhJI11E0IMU0I8R8hxJf6pyEGZxVGjizgwgs99XCpqXnAm/TsudtUCRQV3cr48dm8+ur1TJx4NGPGpDJ37hS/6wYOLKBPn8Dpdb6n+GgsAk2tnJKShmI/zWPcuGkxo0vQgq22Fm68sR/XXNOWRYve9bpm50549FG1MXv1Aijiq6+m+91L9ygIVRm0aRP8dKuh2TPryxv3VRD6dPvVV/NZuHBhSGOqD76KoKSkmNLSvV4HgyeegLfeUnGLTp3gwtCLZ4OiS5fgaymcoLtKVfV+zmgRXHLJk/W6bqzA4sUqqK7n+ZhjGnwIYUHP9003fco55zR9B0ooougd4AUUF1ADs2Rbh/POm8D+/RK7PZ6EhEJmzQp8qtq8+Rf27t3GunXfoymnA/VU/etf32Lx4vd54YUxhowef2oJiCxGYNzwI0cW0KvXQMaMiWfTpvb07et5zeUKTZiaobbWYz2VlsL27auorCyjosKT4rB+vUrhKy1VvumrroL7759MdbV5eaSx5WQw2GyqgCoUpKSENoe+7g6tGGpqYPny5Zx00kmhfWAAuFzeMYGKCnjiidVUVZXX0UusX69cGklJcPXVyr8di1TH1q0D00hrhJuCqxMSNIyKID//NEsKtrZvX8OkSf3Iy+vDvfd+6/e6rhc47TQ13/UF4hsbVrMCxxqhKIIaKeXzlo+kgeFw5FBQoDjudLOPQIpg2LDxZGcfRY8ep9Kv3/Cg/VSdziQGDbocIQSzZ09m+/ZNtG+fy8SJhX6B4kjoIHyFR6dOebRtq/LOKyo8mSvl5ZHTMxhdJqWlMGbMc2zfvppjjz0dUCdabQkcd5xyCaWk1M/XFEqP4DZtQheQoRbj+VoEWpm2a9eFYcM6hnaTIPAt5KusVG66hASPxPz8c/V78GCIUu/UwW4PLaAeriKIj/cWYDabt/K0AqWl+6ioKKG62t/rvH+/ikfY7cqVZkW1eayhLYLmpAg+FEKMB2ajAsYAuBvTHJLwzXPWVZyBNlXfvud51QwE66e6YEFRHc1C+/a5PPHEG14KQCNSilybTf1oXWSsTq6oUBu1tlb9f5EqAqNgKyuDIUNG1/1dUwOPP65y9I86Cm680SO4g2VOgX9ze1+0bQt5/g3PTGGzha4wfK9Tfxexe/dkunTZRG5uLoWFhRG71Yzz5XL5b/7SUvjuO/X4jDMi+ghThELPrSuDw0GgOAHAjz9+SXJyGl269Pe/KAp07tyfV17Z76UI9u6F++7zpOb27n1oKAHwKIK33y7k668XcPvtcxt3QPUgFHGkpcAthuckcEgWlYE6YSxe/G+WLv03Rx99Otu2KQFQX8DNKIDNsGBBES+/PI7KShUc2rp1I5MmqeYsvsogGq50Y4OakpISfv75a+BcKio8RHrRnNyCBYr/9S+V/ta6tbcSAHPiOY1g/QYAWrVSfvNQEQ41hxBqnPr/+u471XmuulqNc+PGjVH1LvaND9TUVDN16uU4nSlcc80rdRlVxxyjhHesEAo9dyTMrWYKVt9n3rzncTi6xlwR2Gw2d1aax8+1dKl3Z7NTYksNZSm0Iti5czsVFUsbdzAhoF5xJKUMY3seGti/H77+ejpLl/6b334rpqamgNatA2+aPXu28PHHD7B1668sX74AzUTqSzA3c+bkOiWgUV7u35EMolME8fEeReBwONi3b737s2qpqbFTURFdipq+t8sF27fvYNq0q8nMzKNPn6l88ok6YU6Y4O+bNhLP7d7taW5vNle+qE8J+yJcAWdUBK+/PhnfznO6d3EkisBoXSprs5xFi2bhdKYwYsQrfOAmZIlVcBhUrCGUAHCsFIG2PLp3P52OHdPDv2kE0HQbQ4cqJXqCWX/DJgr93QwdOpFzzglK1NwkEFAcCSFulVI+4n78/6SU7xhee1BK2QTonSLDgQPQqVNfNm/+mYyMkWzbFlgQORywb99m5s590et5nQkDHgEYyAduVvwVSaBYw6hEHA4Hbdu24Y8/oLRUKYJo/ZJaYJaVwebNK/jxx48RIpeFCxWL6kUXQX4AgshQ+wwY0apV+IyR4VJPGIXbrl2xLcbztQji4xOYMOFfuFySGTOUdTZ4cGwrYFu1qv+acEkNNXQPbSOTqp7vwYOvjVmMw4jvv3+f779/nwED/syAAX8GVPEawJAhDdtjwPi/B3pcH/R8paV1pF34XTcbHMHySi4xPPalij7LgrE0CMrL1ca84IK7mTJlHa1aXQGYb9KMDJXdMWxYF+wmkltnwmi0bWvuAzcr/oqm9aKvNXHWWaqTeW2tg/JydZLXP+HCmDGkAs7pdOzYj8TE9ykpUWmi59XPqhsUTqeifxBCCbRQ4wIaxmYpocJ4fZs2sSvG273b2w2nFcHJJ1+C03kpy5YpJXdp7IqYgdCqhDVPULjQrjQjjFTUVmD9+qV8910RW7asAJRLcts29bkdO1rzmYFgVLJG95vxcX0WmX6tscnkQkUwRSACPDb7+5CBkftDSli+XD1WPYg9EMLTGap16zYBM4X27NlEfDx06wa33eZf5GWWNipEZGRqGr6b1BgsNloDetOGs3l9K4o7d+7LLbcsoaysH4mJKkMo0rRUUAH5Pn3g6KNhwAA1b+HMhcOhgsrhCjijIrjuukIg+t7Fe/b4x1B0VXFlJcxwk7VfdFH0pGjGOXc4QguaRtPZLRALaWlpOcXFW/3fECVOPPFixo9/nX79VAu7de46vI4dG773sFHgG9daWponASMlxVOkJ4R/Yoaerw0b1lBUdCvbt/9m7aCjRLAtLQM8Nvv7kIHuArR58wqWLdvM3r1qk/oeBrOyPF/mnDlFATOFMjJyyctTpwhd5JWdnYcQguzsPB58cJpffCDSk5qG78bYuXM1ADt2eCdy1dQoZXfgQOj3NioSPVeaUrhz5+D0zvXB6fQOlkYyB+npkSki7e4AOP/8AmAaQqjvKS8vj2nTwivGq6z0Z46UUimGAwd28+KLS9m9W1k7Q4eGP14jcnOhf38VTM/MDL2YKpp8f1+LS++FWbPu4667Yk/wk5fXi0GDRpGXp05k2i0UyAVpFTQnk87OS072KN3UVI/w930cSBFs27aZjz56lK1bf22YfyBCBNO1vYUQB1Cn/0T3Y9x/h3TWEEKcBUxBtap8WUr5cIDrLgDeBY6XUi4JdfCRQAu3f/xjEKWlVwGP0ru3v1DSRU2astqseXtCQhKXXVboRfY1cmSBabqo9/ui+Afw9DHQ/spPP30FeIRVq9aiGMMVqqvVYg41ZuCrND79tIjXXruFfft2ALnExRUCkVcu5+REpwCjtaQcDjUX6rRbgNN5CW+//RXDh58eUictKRXhWlqaOatpaalyq+3Y8RsLF6objhgRXTzIqDzbtg292M7IwhoJfBWB/ttuT6uXdytalJd7LPWG7j/sdKp1poW/flxerl7Tz6eleYrutOIwQs9Xq1b5DBv2EO3bN0GKVAMCKgIpZVQcvUIIOzAVOAPYAiwWQnwgpfzV57pU4G/A/6L5vFChXUOq9F+FOnzdQsnJHrM6EGW13W7n7runMXhwQdjCLRbN2OPiPEHKVq1SKSsDIbw3qK4pCLVz2cGDnvjA7NlFPPecMRV0IytWjGPBAsIOBjudKt00lHTHYHA4onNLaWpg7fYoL69mxIihSCnZt08973Dg1/u5ulq9pknPzKiFwWMhOJ3p2GzH4XIpF1g0iDRvPtp8+0CK4Nxz7+DSS2PfXXbp0g+prq6gVathPP54Cw4cUJ/Z0BTTem+mpHgOWikpnu88NVWNy9OwRykCX/erfj0lJZcRI263fuBRIoptVS8GAGullL9LKauAt4ERJtfdD/wTsJzITkqPD/f55/8gPl5Vyvqa2kaBFYju2eVycfHFBRERX0VrEYC3e2jChLsAyMry5v2vqVEL2JcCIRCM1sCjj072qweoqfEOjoeKHj1CJ5ELhmgVqBZmHv93PHFx8Rw4UEV1tcdaLCnxPC4rgz/+UHNZXw9irQiqqo7C5XKSlRV9bCBS9060isBu97Zk9JqNdTtUjZkzJzFlykV88kk1Bw4oN+TkycoV2JDQHd5SUjxzaIwHJCR4B5MzMtR35NsZ7lCrLLZSEWQDxtYLW9zP1UEI0RfoIKX82MJx1KG83KPl//hDLepWrfzz4Y2unkB0z+3b52K3h5+9YtYXNhIYg3laWJT70PzoSmPwbOBAmUS+RWg7dpgrwFBoIoxo0SK6DCkjQmnMHgwe94a2LOysWlVFebl6Qc/fgQMepXjwoJqXbdvqD7prRbBqlfodi9NsJAI9ISE2AVbjGrNaEfTufTYDBlzA+vVKc44ZoxIJGgp6vvRhwxgb8BX+xnRQfcCJj/eecz1f5eU1rFmzkA0bllkz8BjBSkUQFEIIG/AEcHMI144TQiwRQizZFW5HbAOMgtLYHNwIX8FlRvdslgkUKmJhDYD3JvX04PWO4RtznvUG3rfP/H6+SiRQimV9NBG+iNYdpBFtfAC8g/R60xotAd1RSj9XUeF5rb5U3IoKzxyvXKnMr/z86HMtI7EIYrXGzATbypX/4/bb+/Dbb4ti8yFuFBQ8wqhR77JzZxyJieFVmUcLITz0MloRJCR4z6PxezA+b5QVZtccPFjOPfeczKxZd8Z20DGGlYpgK2Bk78lxP6eRChwLfCWE2ACcCHwghPCrXZdSTnP3Qujfur5+fEGg/XxlZQd46ql71KB8FIGvqyfUTKBQYcUmfeutxwFYufKHgNdXVyvFcPCgR2DpmgP92Ijjj/en066PJsIXNltohU/1IT7evMFMJNAb16gINKRUKaEaO8Og3dfWgMsFK1aom/78811RjDTyk32sGribn3Ar2LjxJ/bu3Wb+piigO4/16BEbqzlUJCer9WXWuyIcGC1WPV+1tQ66dBkQsNlOU4GVGbqLgXwhRCeUArgEuEy/KKXcD9SdF4UQXwETrcwa0sJuz57NuFzdAW9FEBdn7pMMJRMoVMTKTeJttitpXlsbXxfY9KWhrq5WilDHSeLjlfCqrFSuMaMvc86cIj77bIbPJwqGDBkdcqA4Pl6lPcZiQ7dtG7tccp05pO/Xt297zjnnVJYu/S/btnkzxYZTkKezjv74AyorncAOWrQI3he7PkRKGhirNeZdwa5+t29/HBMn/kDbtl1i8yGAy1VLSUkxP//cCrA3eOex1FS1V7Kyops7o0Wg7+NyJfDAAw2SBxMVLLMIpJQ1wF+BT4GVwCwp5QohxH1CiOFWfW4w6IBp69adyMhQJ14j42hGRnRZKfVBiNhuUn1CvvJKRXWRmrqcIUM60rmzjVNO6cicOZ5GMFoRAHVcROXlyhfumzr56KP+nEkg+fHHTwKOJyHBUyTWr5+ip47CeKtDXFxsC4p8A8Y1NaV8/PE7bN26ESllHVGgce5CgZ7brW6bt1evLK64wr95UTDYbN4n0kgVQawsAuN99Lji49Po1Om4gG1LI8Hq1du45prX61JuG0oRGAPDED0hYMuWqklQWppnvg6VYLGlNXtSyk+AT3yeuzvAtadaORYj4uOT2L9fqW9jNkuw5t+xQLSFZL7QKaSZmS2AIvbtu4Z9+5RE2rHDm/m0psbjBqqo8FgHUiq6XyO2bw8/UKw3AMRWmUYbIPaFryJo2dLJvn3eFXeBiAKDQSuCbW6PSahCRQg1bykpyvKJj1dWhcMRWcZMXFzs5t+ogLVgsyJY/N57LYCbkVKdymORYVYfdHe7des8GUHRzltCgjr8VFR4YnGaQlvX4IpYCoAYotGCxY0JnQ6YmektaCI9gYWKWMUHNLQwU5vUn1FTCzQNrQhqa72Dxr4ukHADxW3a1N8lK1LEoubCCD1nWsjt32+efBAobdgMxowrbRGEoghatfLQbXTo4DkoZGWp12LRuCgaGJsn6bVbUlLKu+/ey3ffvRWTz6iuhrVr1eK54QbJAw/E9rAUCE6n2v9pabGz0jV0vYv+Lm65ZQCjRjnYu3d7xPfct081g/riixgN0geHpSL44gvVJcRmW133XCQNPMKFVYrg/fefAcwbwgQSaMFSIf/yl0IcDu90lUCB4nbtrM3wiLUi0BtUz13r1qETBQaC0bWmLYLPP7+B779/P+B7srLC51kKBbEWalphevLiq3nvvX/wxRfTYnL/VauUIu3QAU46SVh+GNPQFcRdYhfqqIOeK/3bbk9DShlVgH3pUvjgA9X32gocdopgwYIiPv30T4CNXbtOrmuobkUfVl9YoQjmzCni6advC3hNOAJNY8CAAvLzT0KVfQhatsxj7NhpXoHiuDglyPLyrDvBORzWKGejIrDZcvzM9XDTg7VbSEqPRbBp09vs3++fdmS3K8VpFaNmLC0C8CgCrWBstmTOO+8WzjxzAmVlB7j99j688cZNEd9/mTu9/rjjohxomDCmicYaeq70va++uogZM8qiauazxJ1CY1Wv5gbm9WtcfP55ES+9NI7aWrVzpSyu6ylw8cWxyQoKBKcz9iyKcXGKAqOy0rxhvNMZfr2DdnPU1GQBn2OzHWDq1DQv/6ndDj17WrOJwEP8ZZVydjg838WOHVWkpKQCkpKSg7Rvn8sttzwYVnxAWwR796oAfFJSLTfdNIusLG+iHJtN0XhbNW9gnUWgXahSxtf1+l62bB4bN/7Exo0/UVDwWNAWrr7YsUORGf74o/p76dLxZGb24owzro3h6AMj1pamEb4WQWJi26j2flmZSq212WC4RWk2h5UiePllf9oE3VNgzBhrFYEVvVbj44P7sm+/XdU7FBeHns+v8+FPOumfrF4NnTrV+gXROnSwVpglJUXHclofHA7PyblXr5M55ZShPP/8QwDMmvUt2dnhWVG+geKcHDvHHHOq33XZ2dbOm9NpnSLQgtNIU96nz1k8//x2XC5XWEpASuXv1vMVF1fB1q0vsW9f7DmMAsHK70HTc8SKZmLZMnU4693bv84pVjisFMHOnYGzYaw4fRo9Dlbc325Xrp+tW/3jA5mZeQwerJTAH3+Ergh0QVV5uUrd6N7dO3UlOTl0BsxIYaUSAG9FMGbMnaxf/yzp6Rmkp7empia8tJht2zwbXQs2s6yXhAQs7VQlhDVZb74xgpoaRbO9bt33pKZm0rXrgMBvDoAtW9RcxcVJamoq6d59JRdeOJ/09Bg2dDaBw+FRZFZaBPqz9Jzt23eAp58eR0VFCbfe+lFY96mqgu9USJNBg2I8SAMOqxhBsGyYUBZGuL7wpCQlFCLl0A8Ft9/uT4EBMGLEJHerSf86gUCoqvKkkpqlQbZurTJcrMzqsOJU6wu73aMIvvnmO55++h9UVlbwxRcrycsLPXpYUqLmV0PHB6qqfuCjjx5nzx7Pizk51taotGgR+/gA+CuC6mr43//e4ZFHzuWzz56ru66sLPSmF9rfffTRW4BEunV7n6OOGkjbtp1jNGpzJCcrl2O0LLahwLuLXhLff/8ey5Z9QlWVuRvXDKtXw3XXwQ8/qD13RBHECFdfXYgQ/tkwf/lLYb3CzeHw5BsHg3GBpaWpjWRVaiXARRcpCozExDxAYLe3okuXAZx44kUcPOhpzRmKeWqkcfrhBxyAYLUAACAASURBVNUiqrZWEcMnJKgMC6u6RaWkqMCz1dYGGFsxFvHhh6MBqKqqDquIrLpaNU8x8jlppbBhw78oKprIrl0bALV2YsW5ZIbExOhZTgNBKxct1KqroVOnfjgciXzzzQxmzryThx8+m7FjW3kpvmDQiuDYY0vp12+4mxLeeiQkqO/BamsA1Hzpz6mpiWPChLe5776FYf2vs2crt2NuLkyYEH3BWzAcVopgyJACbLZpgGqS26JFW8aOnca555rHB4y9W30brAcSiC1bKgvAl7TKKsTHq4Kx8eM3AC5OPnkPDzzwP1JSvCWDb0tFM2huHSmhtFQ5I10uRQBjdVZVWpqa74aqt9mzpwgYR02N4pauqanittuuZvr0p4O+TyvVNWu8lWttLfz+u3o8aFAPzjnnRjIyVNl6VpZ1/5fmYbIKNhteLLvV1dC164C6VOL9+3cQH5+AlK6QiOi2blXzlJAAZ511FBMn/psLLjCtMY05NItoQ2QIOhyeOaushBNOuICuXU/Abg/tJKUDxEIoOu6TTrJwsBxmMYI1a6C2toD27Qt4/HHP84FO+ikpauGUlnq0u83myWrZvdv7eptNvUe3uGsIaIWkW/ptChA7Li1VPuRdu8wFx969HsGmum+lYrfvpUePXoC1m6ch3EG+WLfOvwCvqqqCRx65nQsuuMFrTLpRzf79Ku9dSv/7bdqk5i8rC0aMGAOodZWebp2VExen7m21m8PhUIrOZvP0tjjzzAkcffQQ4uOdpKS04vrri3A6k9m6dRU2m522bbvUBZAPHNjN0qUf8s03V7BqldKIPXs2/HeekKD+BytjNcbPiiZY/OOPap6POspaj4LGYaUINLuhL0+82UQLofyuxrZ1oARifLy5eamVADRcw21tsWhFsHmzi/fff5Revf6Prl2Pr7uutFSVvq9bp5RUUpI63epxbjcUPWpfd35+Orm5KlgcK6oHbZpLqWIS1dUNY6r7oqLCXGNWVJSzerX67rt1U1bS5s1Kee7YYa4EQB0ywLvHbk6OtYHvzMyGWWfx8crFmJKiuKm+/x5OOimOTp36+l377rv3sGjRLK655lVOPVUpxIceGsaGDanAGOLj1bz++c9QXn4QhyMx5FNytPBN67T6s4yKYM+eLSxcOBOnM4WhQ6+p9/2LF6vfA8KPxUeEw8o1pBVBfr6HU8EY3TciOdl8kyUnq5OekQytRQt1ErQ628UMegypqep06HLZeOedIubOfcXrutJSj7WgYwHr1sH69brhuudarQiM2S+xsHB0z9e4OCVcdPCuMRRBUpJ54kBmZh61tcoq2rxZzU91tQqeB2MjNTZb37LlV7ZvX0NiYght4SKE0QdtNfTJ/aKL1O8XX1SBTDOkpLSiZcssUlIycLnU/3/SSR7i4XPOgTvvVEV1Tz31/xg1ysHy5f+x+D9QaAgFoGGUK5WVsG/fDoqKJjJvXnDXI6j9pwvt+kdegxYWDhtFIKVHEbz4Yjf+9jeVHRLILRRIqCcmek79+ovWbIMNyaGuoVlIbTYVVFL4kkWLnmXHDs91NTWehuu7dim31t69KrXUd1Nv2lTtfs9PgLp/tEJHiNj0JogV+vQpBILTaGzdGtgCAFWlPmFCRy691MbChR2BIrp1g3vvPYWbbupOeXnomTThoiHcBRpaEZx/PpxyihJs994LDz7oOUD861+3M2lSf847byKJiWk8/viIumD5OefcSnKyOgWfcornvjU1KpczOdm6haFjM3Z7w1npoA46+jv64gsoK+vJ0KHXcvbZfw/6viVLVEygslKxsFoZ/zHisFEEv/2Gu0H5fmAdqkGauSJITAwtFS8hQV3bGArAiLg4NQaPIsjE5YqrO1X4oqZGWQMavoyS69erxs5ff62oK5KSogt2ZmerjKCG9gkHQ/fuBcA0kpNVw6HMTH8ajWBYsEBVqe/evRGQuFwbgXFs2lREmzZdyM7uSkJCbI7sycneXPl2e8PFoMCzF+x2GDcOzjtPrfuff4YHHlAKc/36taxfv5QNG34kIyOXFi3asnfvH3z8Mbz0krJIc3O9ad/vuutL3nijik6drOOX0NlaDW112u0weDB0764OXA8+mMCmTc+TlTU24Hu2bIFnn1VK4JRT4KbImTvCxmETI9BFGccd14IxY7ZTWamS680UQaguHh18amzEx6txHH20+tvpVPGANWvgrLPM3xPopFteDlu2JAMu0tJUP89oAsXJydbkt0cLJVRVw6HzzoO1a/9HYeEZvP76jUybVn9rspkz/avUoYxZsybzzDMb6NIlNsLHmBWUlaW+18TEhsuuAk/2nO6nUVCgXDwPPKDcZxMngt0+izPP/JWOHTtyzDEjufLKOJYuhSJDRu4JJ1RRW2vziglYHR9IS/M0YmpopKQoN9h778G8eWo/PvQQ/OUvSilmZSnX6LZtylvx6adKCQwcCOPHN+x3fNgpgm7doGXLLEAJT18hF47v1Zgi1pjQFsExx8Ajj6gT/6RJyuWjM15Cxc8/Q22tjfx8uO++6FNHGyNuEgr096ZZWB2OZCoqDlJZGUKeLbB7d/CeDbGiFDH6tc3Wa0NBHzY00tOVkHvxRXWS3bPHxqef9uDTT4uBFD76CKqqJCCw2Z4jMzOJd965np49vyA//8QGG7fTqcZqRR+F+qDdURdfDCNGwMyZVcyb52D6dM/r3bvDypWeg1l2Nlx1VcMqATiMXEM6x7t7d89zZi6PcDZaQ+a9B4PmNgFYseIZJk2yAXspLvZPca0PP7jbHvc1JIREUqykG640BUVpBl9F0L59N8aMmcott4RGAZCZGbhK3W6PXZZVQwY4g0FbBEakp8Pttyt3xqWXghInmSQn11BaCtXVgr5991JQUEnXrv/Bbq+qKzrbuXM999xzCq+8Mt7ScScmqthUY8yjUXE6nXDMMXOBq0hK+pUuXVTywa+/qutOOUVZWnff3TjJE5ZaBEKIs4ApgB14WUr5sM/r1wLXA7VACTBOSvmrFWP58kuYORNuuqk31dUH+Otf32LgQP8qjcY6cUUDu92z6FJSWgESIRYh5dmsXh16wMnl8rBBakWQlBSaULPbPYJfc/43BbdZIGhXgW5fGhfnYNgwc6G0YEERM2dOZvfuTWRm5nLccedQUeFvOTgcSZx//q2MH9+Bjh078s4730Y9zqaiCHRCQiAMH66sv71793H66XbuuON9Skqyufba00lNvZGDB/dw3XWvERenNHBx8VbWrPkvMlg0PkLoegfNMhsXZ13ldTDExXnXEOTl9aZz5wfo0WM6BQWPsn27UgQ9e/qTyan+Bdtp0aJNg6TXWvYJQgg7MBU4A9gCLBZCfOAj6N+SUr7gvn448AQQwKsdPX7+uYht2xRlwhNP/AkpH6dzZ09wMD6+6Z5gg0FXfwIMGHABxx57OvPnt2HWLJgxA154Ae64Q7mOgmH27CIOHJgMbOK22yRZWfm8++6akMaQkXFoKVFjpSz4C/uLLy5k4MCCuqCwjgfs3r2Rzz573u9+NlsGY8dO4eijB/Phh4Xs318c9Rhj2eM6FqhPsQ8ZAtASKSWVlTdRWVlMdfVWoD2pqd6MeLm5vbjnnm+w2WKfadG6tcqGM56sG+OU7ZtE0rp1RwoLF9f93a5d4OK28vKDXH99Ng5HIjff/G969TrDwpFaaxEMANZKKX8HEEK8DYwA6hSBlNKYX5eMbuxpAYqKinjssXF1f+/f/wcPPzyOFi2o454/lASZEUbXkMPhxOHIqgsca2qJ+fODK4IFC4qYPXscxmrbP/5Yx8KFRVx4YfBMGl2gdighT7GMsHo1psJ+6tTLefnla6iqKkfKIAUEbsTHp9RlHL300rfs2vVL1GNsKtYAhOcGFUJw221zSU9vR3q6uaRLSkrjqKOsYVHLzFSp0rHudx0uorGIS0v3Ehfn4PzzbyU7+6j63xAlrDTeswEjC9UW93NeEEJcL4RYBzwC3GDVYCZPnkxlpXeWR0WFd0/fxl44kUIvOOMJpFs3lfd9hvsgsXx58IKomTMn1zXs0ZDSxVNPTQ7wDoXkZGsJ1azCmWcq5bV2LRQVmWUAQWVlaUhKQF27iaoqlXbbtWtnzjgj/A4ixj63cOgqAlB8RBkZHby6v02f/lduvDGfAwfCDFyFCadTuYIaez8HSisvKzvA3LlTcBk2pJSSadPGsmzZPABat87jjTcqufDCe+s4q6xEo3txpZRTpZRdgNuAO82uEUKME0IsEUIs2bXLvNl4fdgUgITH2NilKZnh4UAvuORkdbq9/HIHBQWCb79tT35+EZmZquHM+vWB7xEoCyZQ45uUFOXXbN26aQTMw0VyskrTA9i3L/RG9YFh59VXx1NSUhyWdZSYqNxqGRmKkiI7W81p69ZNK+OqvhhBKNiyZQU7dqxl9eoFLF48h48+epytW1fFZoBuaIrx9PTGVwRm8yWl5IEH/o/XX/87Cxa8Wff8L798wfz5L/Pss5dRVra/AUepYKUi2AoYVVmO+7lAeBsYafaClHKalLK/lLJ/6whL7XJzgzcpj4tr2sHNYNDjXrRIt+JUju99+7bz8svjaNNGJXMvW6YK68xS6ZxO8/lp0cK/6tPpVFbAoeYOMsJmg6FD1WMhwu/r7I8avv56Ojfc0IkPPqifzjouTs1h27aqliU11fM9Jiern6a0HmOhCC6++EEKC5fQt+95fPfdWxQVTWTTpp9iM0A3tBXVokXjr08zi0AIwVln3UC3bieTnd2j7vn27Y9izJipjBnzLElJnhPAwYN7+Oyz55k37xlLx2rlUlsM5AshOgkhHMAlwAfGC4QQBoouzgV+s2owhYWFQZuUNyUzPBLYbIFbcW7erNw7772n0tMee0y5iYwUCSoLxn/llpYe9OPpT0/3u+yQgxCqAC87G6T0p5uIFOXlB5g0aVzQ3gYtWqjPtaJ9qVWIRap0t24n0blzP+z2OPr3H8HZZ/+dnJxjYzNAN3RQ2Nh8qLEQyDU0cODl3HvvAq9m9hkZOQwbNp5TTrnM69ri4q28+up4li//1JIMKw3LFIGUsgb4K/ApsBKYJaVcIYS4z50hBPBXIcQKIcQy4CZgtFXjKSgooF+/YdhscYCgXbs8HnxwWl2g+FB1C2nY7bBjh7mL4+DBTdjtnqKV5cvhwQeLeP55D0UC7EFl8XqjurqqLo7idKoU0UNdaYLnhDtpEtx0UwEdOkwDYtPrsbzcO/ZkRHq6+jnU3GmxsAiMGDiwgL/85Uk6dKgnlS1EaB6rprQ2A82XzWZDCIGUks8+e54nn7ywjnfJF7m5PenUqZ9ffDPWEFZqGSvQv39/uUS3OAoTX32lqISFgOOP9/6i2rZtfJ9iNNi+HY4/vqNp/2KAxMQMBgyYQr9+BTzxBEBHwPxaXwgh2LzZZdqL91BFaSl8+63inwLVq3niRKioKAIuj/r+Qgh+/9070NyqVcOSxcUS5eXKtbgxtCUTEIsXz+a//32bM8/8a8yyhmw2RS3/66+K1bQhutyFgh07YMOG4NfccsuxbNmygv79R3DRRQ/QoYO/hVRbW0NtbTWdOyfWxbUigRBiqZTSlM+0CXkhGw5Gf6xGc7AIJk4sxOk0d3GUl+/hu++upLKyiFGjAEIPkLZvn3vIz48vfE+4GRmqP2xWVgG6g50/7F6/MzLySEkxtyJ07EkjNfXQVQIasbAIli2by6JFs/j996XR38yNpCQ1v3Z749QLBEIoZJTDh99OdvbRLFnyb+bOnRLgPnE4HNaeUg8LRVBUVERWVhannSa4/voOLFrk7b815uEfqrDZVD3EQw9NC1ikU1NTxcyZkznnnMAUCb7QcZTG9rfGGmY+7wED4Mkn4aqr/HtbQxJpaTPo00dy//01/Otfkmef3cDo0VNwOLyvNcaeNELpd92UESvX0Lnn3kx+/km0a9ct6nvpw4mmimnZ8tBwDRkxaNDljB79NEOGXEHfvudZP6gAaPakc0VFRYwbN46yMuVjKy7ewqOPjqNVK5pNfAA8imzkyAJuumlUwOs0KdrFFxd6FVGZITs7j4kTCxk5sqBZKoJAG3Xo0AISElR9wf79m2jRIpdLLy1kyBD/wjpdRDZz5mT27NlE+/a5XnNWXd10yAmjQax4tdq378599/036vvY7SrFdutWDyV3YyoCTWthRKiHy549h9Kz59DYDyoMNHtFMHny5DoloKELyZqTIjAKtfbtcwPGCjIylCWgBdjzz4+u6yRlRFZWHgsWbKj7uznMkRH1CbZBgwoYNCi03gQDBxYwcGABubnQvr3n+YwMFYNo7DTGWCDWweJooVlFt271zG9GRsMF4ePjVfJFTY2aF6dTNZw34lDyMjR7RRBKIVlTMicjhXHRTZxYyK23jqHapGDg4MHdjB2bSUnJHmw2u1sJCIzsHg5HEjfe6HFtCNGw3Z0aAjZb7AWbbzpoQkLDdZiyGk2FaVdDtz1NSPBYBFYrqoQED4mctpBratQhycxiPpQUQRPS8dagvkIyaB6nXeMmGDmygEcemU5amn8gs7KylJKSPQAGS0DxxoPq2fu3v03joou8yfiakhCIBawQbMauYQ6Hun9ziD9B07QIQNVjWDku43dnbEdr7El8RBEcAigsLCQpKXAwr6F7mVoF30U3cmQBixfvpnXrQBkwvpBkZubxzDMbuPxyb5dIc4sPQOwFW1KS93fQHA4XRjRFiwCssbiM/6dRdBjZiePjPYogIcF8jzQlxVkfDqGhRoaCggKmTZtGXp7qTZud3bwKyTTMFp3DEZhDyAx79mwiLc0/zbG5zJERsRZsvllBzcHdaERTsAiMBzY9v1YoJ+N3Z2xe5WsF6H3RHCyCZnAWrh8FBQUUFBTwxx+qMMaI5rJhAy26YIFjX2Rk5JqesJpDsNMXsRZsvo1Pmsu6MqKxFUFKisrMOXDA2nqBpCTV5xg8Qr6qymMR6JiZ7hehlYDd7ml0BI0/X+HgEBqqNWgup12bzfx0NHFiIYmJ9UtyhyOJiy8u9GO8TE1tvq6hjIzYbFYhvJlCdbP35oSm4BpKSlIK12azdt9qhgHd8El3OjMKfj0XRkvwULYKDntF0JxObmabY+TIAh58cBpt2vjzQwihvv7MzDzGjp3GWWcVeN3DZmucFn8NBaeTmNBmtGjhrVD0qbE5oSm4hhITVcqoldaAVuJxcR7Bbjz1x8V5ywxjgoBWEMbxHSqK4LBwDQVCXNyh80WFgpYtVYs+X+h4yO23j/Mir4qPdzJ27LS6mgJfoW/MkmiOsNlU3n9xseIeihS+bKzN6XBhRGMogrg4laIJSugmJlp7ONHrPT7eO0NIjwG804SNcxIf77EMtWupsZVnqDhEhmkNmotbSCMxMfD/9Nhj/h3aqqrKmDlzMjk5Snj5CrTm5t7whXZ3dOsW3f/qK5ia27rSaIxDQUaG56StXTZWksoZhb+ZRQCBFX1iolIExnk6VA5Sh7UiaI4nt0CnpUCdxvbs2URODvTp423mwuGhCECtg+7dIxPgZrQGzXFdQeOcbrU7KDHR+/uyCmaKwGYLjZlYKyxjdtMRRXAIoDlu2KQk87oIXzZM3+fNfNqHiyIAZe736hV+e0gjpQT49x1uTmgMoeZ0KqugoTLX9N7xtQLCqTUyXnvENXQIoDkqAjBnujTLHjJjyTSiuQo0DV/lFxcH+fmhr4ukJP+ai+a6pqBxhJpuhtRQFN7GGEGkhaZGhXmoFKsetoqgOWZ2aKSk+P9vOnsoO9u8sM4Xdvuhc5qJFGbfv1YGwU6h8fGq0Xx+vv9rzVkRQMMLtoQE9T1ZzdmkXT/G/y9S+WDksTpU9tAhoq9ij+Ya0AMlxFu08HTf0hg5siCg4PdFc7cGIPBGT0lRQt7lghUrVEZRTg7s3q1Ix/LzA59Qm/O6EkJ1Wdu5s2E+TysB/dlWwWZTVnR5eezcX3a7Wj9HYgSAEOIsIcRqIcRaIcTtJq/fJIT4VQixXAjxhRAiVGKcqNHcT24tW0bXHP1wUAT1ndZsNpVRlJ+vFMGxx6q/g7kpmvO6EgIyM63/HH0qb6jWsfHxygUVS5ZdfZ/DXhEIIezAVOBsoAdwqRCih89lPwL9pZS9gHeBR6wajy+aUks7q5CREflCPBwUQSinzIQENY+gNrdviq0RzYVpNBCEUErQamXXvr1/YZaViI9XSj8hIbYWARw6fdCttAgGAGullL9LKauAt4ERxguklPOllDq5fRGQY+F46tCcMzuMECLyFomHy/zEEs3ZGgDPfFntr09LUy4oqyuIjQRyoNKnY7UmtEXQqtWh4S60UhFkA5sNf29xPxcIVwFzzV4QQowTQiwRQizZtWtX1ANr7hvWiNTU8Bd3cvLhMUexVgSHwoaPBnq+cnJUqq1v3UmskJgIbdpYqwjsds9pXR96Yvn/aEUghLUFcLFCkwgWCyEuB/oDQ8xel1JOA6a5r90lhAiNTtM6ZAK7G3kMZjgyrvDRVMd2ZFzhoamOC5rO2ALGYK1UBFuBDoa/c9zPeUEIMRSYDAyRUlbWd1MpZaM3/xNCLJFS9m/scfjiyLjCR1Md25FxhYemOi5o2mPTsNI1tBjIF0J0EkI4gEuAD4wXCCGOA14EhkspGygp7QiO4AiO4AiMsEwRSClrgL8CnwIrgVlSyhVCiPuEEMPdlz0KpADvCCGWCSE+CHC7IziCIziCI7AIlsYIpJSfAJ/4PHe34fFQKz/fQkxr7AEEwJFxhY+mOrYj4woPTXVc0LTHBoCQUjb2GI7gCI7gCI6gEXGIMGEcwREcwREcgVU4oghMIIRokpm/Qoggda2NByFERmOPIRCOzFl4EEI0elaeGZrqnoSmO2fh4IgiMEAIkSKEeAqYK4R4UQjx58YeE4AQIkkIMRWYJ4SY4M62Quimw403rhQhxJPAx0KIB4QQpzXmeIw4MmfhQQjhFEI8D8x3J3T8n/v5pjBfTW5PQtOds0hwyA3YKgghsoE3AAGcA3xNA3If1YObgAxgNOBEpdwipXQ11oCEEPnAbKAWuBLYBUxqrPGY4MichYcrgTaoos71wKtCCGcjz1dT3pPQBOcsUhxRBB5UAC9LKf8mpdwBzAKWCSF6NcZghBBO9+84wAG8JaVcJaV8FNjlPlU25umjFJgmpZwopfwVlR22XQjRIHxRZjgyZ+FBCGHkpxXAQinlHinldGAh8KD7usbq3NGk9iQcEnMWEQ5bRSCE6C6EeEEIkQggpdwDfGW4pAPQGVjdwOPqJoQoAp4RQvR312OkACcZLrsWGCWEyGmo04d7vupOY1LKbXhzQyUBR0kptzTEeHzGdmTOwhtXVyHELOA1IcS5QgjNLNXGcNktwJ+EEF2klLIhBFtT3ZPusTXJOYsVDktFIIQYiDI5x6FcCAghhJSy1HCZA9gQCu1FDMeViHJh/AQsB64XQlwF/BO4VgiRCSCl3Ay8CYxtoHGdC7wPTBTuvhJCiDgpZYnhslY0zgY9MmfhjcsGPAX8gtoD5wN3A68D5wghjgVwK6d/43ZdSYvzzJvqnnSPo0nOWSxxWCoCYA/Kv9cNGCOEyDP50o4D1gEIIcY2kDnaBSiVUj4ipXwGeBn4E5AIPI93YcoaFKNrQ5ihfwAFqPm6TQiRIqWsEULYDJ/dA1jhHs9lQohuFo9J48ichYd2wD6gUEr5b+B+4AwgH6VQJwtPhs48oKEIHpvqnoSmO2cxw2GpCKSUK1G9EtYCnwH3gZ/v+HQgQwjxHnAZyl9p9bh+AToKIQa7n1oOfAHciiLmayWEuEcIcRFwNVDufp+lJw8p5RJglXu+5gEvuF8Shs8eCLQWQsxGCcBqK8dkGNuROasHRqUnpdyKYvo9w/D388CDbkVaCvxDCHE1yqoqtmJMJuNqUnvS+LlNac4sg5Sy2f6gTO80w9/C9zGQCqwFTvd571zUae1CC8aVCbQ1jgWwuR9PAN40vNYHeMX9nm7AX4D/AAUNMS6T+UpDnY6ON7yWgBLAS4GLLPou2wEn+zzXFObMb1xNYc7c47rK5zm7+/cVwALD8y1Rgdg+QDrK9fG2hfN1VYDXGm1Puu+fDTwGOJrSnDXET6MPwLJ/DO5Ckd29Ddzrfs7mc43+kv8OfOR+fKlbMJ9q0bjuBFahWnM+bByH+3FX4D1gtPvvDBRxX5bF82U2rkDzdRcw3/34LPfvkRaPbwXqZN3X/bdRSTXKnNU3rsaaM/dnLQVuCvC6DfgS+LvhudeBYy2eq6Dj8pmvBtuT7s+4FhUDeBaVaOC79htlzhrqp9EHYMEXmoxiNZ0JtEWdCPcDHd2v+51y3Y/3uq97BXBaMC4n8DDqFNHaPbYyoJX7dZvh2mEoX2hf4CJgPpBr0XwFHZfPtcb5qgEOAlOAeAu/T5t7Y85Fmd03AsmNOWchjCvQGrN8zlAn2oNm9/cZSz9U7vtI4HK3gO5h4XwFHFeQMVq6J41rCHgmkFDHY6k06Jw15E+jDyCGX2jL/9/euYbYcZZx/PfPbhJLWwIapS1R49qkTWNiEDFFpQR7kUq9tv0itLYVlIQ0ShqofpBaDFUQK5VULCLU+KGK9ItSNUWttResQk1ShIKVRARLL8TaWpo02fz98LwnGZc92ax7Lu+Z8/xg2Dnzzuz+dt6Z88y81/JzEtgETDbSvg/c1OW4ZUTg2A98oF9eZf3cxvom4D5g7Yz9OxfdZuA75WIbulcjfXk5n3/uh9dMt8a2XcCO8iV6ybDP2el4DeqczcjLNcT832cTD0E3ARfP2L/z5fdx4Hbg98AHh+3V2Lev9+QsbouAp4iHoLXlb99A42GIk28qfT1nw1qGLtCDDH1TuRkfBLYB5zfSRDQ5ewjY0OX4RcD6AXhdWLZPEk+vB4FvAX8kXn07F1rzKXeiFq/G8ZN9vDmbbjcDa8r284F7y/p24gn8i8CKTj4P8Jydtle/z9ksednx+ipR8fw4cBvRPjIWNQAABfpJREFUiuX6xjWmXrv0wqtxfF/uyS55ua5svwP4dtn+eaKz3x2N+2NRP3xqWUa61ZCki4lX8xeBnURlz7bGLouIC+91ZpkmE2LIAdv7B+C1pfy9Y8CTwJTtW4ini+3FFTc6O9mersWr4XTM9mO99OritqLh9gzwsqQJ4ALgC8BGl45YLndqWe/3OTttr4ZTz89Zl7zcXJLvIlrdXGb7dmKCqC0NH9MnFuLV8Ov5PdnFbQXw2ZLcKVb8qe17gFuBcygdxjyCw0bMhyomr18ALwF32v4xnBhp8tLS6++o7WlJU2X9BcWAVUs6+w/B6w3AEdsnJrK2/YCkHcQNc3BMvU7ltphob7+OKCr4G1HebEmrbP81vU54XVby8t+2v9bZ0fbPJW0nvvj63ca9Vq9ubpeXtIeJnujvKW5Plc6IrQ4AHUYmEJRehv/zJGP7aUn/aKQdJYqGmj0PLwXOkLSbeGq7dYheh5vHSFpDPJn8HfjnOHj9H25HgX2SHgUesf2gpHcQc2D3tB15C7ze2cnLxrEXEXl5kOFdYwP1mqfbVEl7RtIu4EuKMammiLfhA712q5GRKBqStLiZqTM6orzaSFtJPJ01WQ68i2gDvNH27yrwWirpOqJl029t32D79bZ7LcTN9ldsP1jWD9j+umPYiPSaxUvSpKRPEs2nf2P7xhK8Wu21EDfbe4miqkeBn9m+ytF5rPVUHwgkbQV+rRjv+6MQZZzNnn+N9SngibLtU5KWEcP+rrTd03lDF+JFDDa2hyhPvnscvBbqJumcXvu02YtoefMw8L7KrrG+eS3UTdJ5tg/Zvt/2D3rtVjPVBgJJb1QU53wY+DJRwfOZ8vp9ovJG0nqfrMi5CFgt6ZfAtUR9wNO2X6vMa8L28+Pg1SO3q+lDWW2Lva4hWrkcmlkk00avHrldTfTzGE9cQdOl2RZgghiJsNNGfAq4l9K+najR3w08ApwHvA14mRi2tm+9XNOrPW7p1Q6v2t1GYRm6QCMjJ4mOOW9tbDursb6I6JCyqny+HNgy43fcmF7D9arZLb3a4VW72yguQxcoGbKOaMP+HHBfl33WAL/okrYkvYbvVbNberXDq3a3UV1qqSN4kRga4EJiSOErACRNNGr8zyXmeEXSRpVJvyXJPW7Zkl6tdEuvdnjV7jaSVBEIbD8L/MT2v4hyvc4MP9PEMBEA7waWSPom0RW8c2zfekmmV3vc0qsdXrW7jSpVBAIAn2ypshs4LGlb2X68RPlLgA8Bh2y/3/ZD6VWfV81u6dUOr9rdRpJhl03NthBNwJ4o6+vLz4/RqBhKr/q9anZLr3Z41e42KsvQBU6Rub8CjhCjAC4ftk96tc8tvdrhVbvbKCzVFA11UEzuvZOo9d9q+yNuDIaWXqPhBfW6pVc7vKBut1Gi0/miKiRdSYx1c2TOnQdIes2fWt3Sa37U6gV1u40KVQaCJEmSZHBUVzSUJEmSDJYMBEmSJGNOBoIkSZIxJwNBkiTJmJOBIEmSZMzJQJAkcyBpWtJeSX+RtE/SLWrMeNXlmJWSPj0oxyRZCBkIkmRuXrO9wfZaYlz7K4Hb5jhmJZCBIBkJsh9BksyBpP/YPqvxeQr4E7AceDvwI+DMkrzV9uOS/kD0dj0A/JAYNvkbwCZgKXC37XsG9k8kySnIQJAkczAzEJRtLwEXAK8Ax20flrSKmCjlvZI2ATtsX1X2/xzwFts7JS0FHgOutX1goP9MkszC5LAFkmTEWQzskrQBmAZWd9nvCmC9pGvK52XAKuKNIUmGSgaCJJknpWhoGnieqCt4jpgIZRFwuNthwM229wxEMknmQVYWJ8k8kPRm4HvALke56jLgWdvHgeuAibLrK8DZjUP3AJslLS6/Z7WkM0mSCsg3giSZmzMk7SWKgY4RlcN3lrTvAvdLup4YE//Vsn0/MC1pHzGd4l1ES6InywxaLwCfGNQ/kCSnIiuLkyRJxpwsGkqSJBlzMhAkSZKMORkIkiRJxpwMBEmSJGNOBoIkSZIxJwNBkiTJmJOBIEmSZMzJQJAkSTLm/Bc/DK9psKe7vQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 1826, {'val_loss': '-0.5858442187309265', 'val/kl': '0.0006598228355869651', 'val/std': '0.09410605579614639', 'val/mse': '0.006958892568945885'} {'train_loss': -0.33417654037475586, 'train/kl': 0.0014772284775972366, 'train/std': 0.1403888314962387, 'train/mse': 0.01704699546098709}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 3653, {'val_loss': '-0.6686775088310242', 'val/kl': '0.0009602832142263651', 'val/std': '0.07635167241096497', 'val/mse': '0.005667319055646658'} {'train_loss': -0.5634565353393555, 'train/kl': 0.00099954626057297, 'train/std': 0.08863253146409988, 'train/mse': 0.008533040061593056}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 5480, {'val_loss': '-0.6738855838775635', 'val/kl': '0.0011280584149062634', 'val/std': '0.06758157163858414', 'val/mse': '0.005165729206055403'} {'train_loss': -0.6472221612930298, 'train/kl': 0.000892972166184336, 'train/std': 0.07482174038887024, 'train/mse': 0.0071046543307602406}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 7307, {'val_loss': '-0.70184725522995', 'val/kl': '0.0010905503295361996', 'val/std': '0.06405500322580338', 'val/mse': '0.0052343374118208885'} {'train_loss': -0.6811671853065491, 'train/kl': 0.0009102242183871567, 'train/std': 0.0716802105307579, 'train/mse': 0.006746941711753607}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 9134, {'val_loss': '-0.5500525236129761', 'val/kl': '0.0009421015274710953', 'val/std': '0.06198791787028313', 'val/mse': '0.007641741540282965'} {'train_loss': -0.6953110098838806, 'train/kl': 0.0009224566165357828, 'train/std': 0.06881076097488403, 'train/mse': 0.0062933326698839664}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 10961, {'val_loss': '-0.6818557381629944', 'val/kl': '0.0011996693210676312', 'val/std': '0.06289203464984894', 'val/mse': '0.005356952082365751'} {'train_loss': -0.714325487613678, 'train/kl': 0.0008994181989692152, 'train/std': 0.06746730208396912, 'train/mse': 0.0061125620268285275}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 12788, {'val_loss': '-0.6514759063720703', 'val/kl': '0.001041244249790907', 'val/std': '0.06694939732551575', 'val/mse': '0.005263098515570164'} {'train_loss': -0.7261911630630493, 'train/kl': 0.0009054846595972776, 'train/std': 0.06656865775585175, 'train/mse': 0.005964844953268766}\n", - "Epoch 6: reducing learning rate of group 0 to 3.0000e-05.\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 14615, {'val_loss': '-0.6710492372512817', 'val/kl': '0.0007999538211151958', 'val/std': '0.05366721376776695', 'val/mse': '0.004832404665648937'} {'train_loss': -0.7789111137390137, 'train/kl': 0.0008972201612778008, 'train/std': 0.059919100254774094, 'train/mse': 0.005034992005676031}\n", - "INFO:root:Epoch 00008: early stopping\n", - "\n", - "Loading checkpoint lightning_logs/anp_c/version_-3/_ckpt_epoch_3.ckpt\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "0869b8294d5b45dd9c4dce1d9c7c8533", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Testing', layout=Layout(flex='2'), max=356.0, style=Progr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 14616, {'val_loss': '10.456031799316406', 'val/kl': '0.0010208823950961232', 'val/std': '0.06455948948860168', 'val/mse': '0.13285928964614868'} {}\n", - "----------------------------------------------------------------------------------------------------\n", - "TEST RESULTS\n", - "{}\n", - "----------------------------------------------------------------------------------------------------\n", - "\n" - ] - } - ], - "source": [ - "trial, trainer, model = run_trial(name=\"anp_c\",\n", - " params={\n", - " **default_params,\n", - " 'det_enc_cross_attn_type': 'multihead',\n", - " 'det_enc_self_attn_type': 'uniform',\n", - " 'latent_enc_self_attn_type': 'uniform',\n", - " 'use_deterministic_path': False,\n", - " 'use_lvar': False,\n", - " },\n", - " user_attrs=default_attrs,\n", - " PL_MODEL_CLS=LatentModelPL)" + " user_attrs=default_user_attrs,\n", + " PL_MODEL_CLS=PL_NeuralProcess)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# NP" + "## NP" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": { "ExecuteTime": { - "end_time": "2020-03-15T17:24:47.170013Z", - "start_time": "2020-03-15T17:10:35.481682Z" + "end_time": "2020-04-11T04:38:49.867893Z", + "start_time": "2020-04-11T04:38:46.400Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "now run `tensorboard --logdir lightning_logs`\n", - "trial.number -3\n", - "INFO:root:GPU available: True, used: True\n", - "INFO:root:VISIBLE GPUS: 0\n", - "INFO:root:\n", - " | Name | Type | Params\n", - "---------------------------------------------------------------------------------------------------------------\n", - "0 | model | LatentModel | 1 M \n", - "1 | model.norm_x | BatchNormSequence | 34 \n", - "2 | model.norm_x.norm | BatchNorm1d | 34 \n", - "3 | model.norm_y | BatchNormSequence | 2 \n", - "4 | model.norm_y.norm | BatchNorm1d | 2 \n", - "5 | model._latent_encoder | LatentEncoder | 267 K \n", - "6 | model._latent_encoder._encoder | BatchMLP | 70 K \n", - "7 | model._latent_encoder._encoder.initial | NPBlockRelu2d | 4 K \n", - "8 | model._latent_encoder._encoder.initial.linear | Linear | 4 K \n", - "9 | model._latent_encoder._encoder.initial.act | ReLU | 0 \n", - "10 | model._latent_encoder._encoder.initial.dropout | Dropout2d | 0 \n", - "11 | model._latent_encoder._encoder.encoder | Sequential | 0 \n", - "12 | model._latent_encoder._encoder.final | Linear | 65 K \n", - "13 | model._latent_encoder._self_attention | Attention | 0 \n", - "14 | model._latent_encoder._penultimate_layer | Linear | 65 K \n", - "15 | model._latent_encoder._mean | Linear | 65 K \n", - "16 | model._latent_encoder._log_var | Linear | 65 K \n", - "17 | model._deterministic_encoder | DeterministicEncoder | 341 K \n", - "18 | model._deterministic_encoder._d_encoder | BatchMLP | 201 K \n", - "19 | model._deterministic_encoder._d_encoder.initial | NPBlockRelu2d | 4 K \n", - "20 | model._deterministic_encoder._d_encoder.initial.linear | Linear | 4 K \n", - "21 | model._deterministic_encoder._d_encoder.initial.act | ReLU | 0 \n", - "22 | model._deterministic_encoder._d_encoder.initial.dropout | Dropout2d | 0 \n", - "23 | model._deterministic_encoder._d_encoder.encoder | Sequential | 131 K \n", - "24 | model._deterministic_encoder._d_encoder.encoder.0 | NPBlockRelu2d | 65 K \n", - "25 | model._deterministic_encoder._d_encoder.encoder.0.linear | Linear | 65 K \n", - "26 | model._deterministic_encoder._d_encoder.encoder.0.act | ReLU | 0 \n", - "27 | model._deterministic_encoder._d_encoder.encoder.0.dropout | Dropout2d | 0 \n", - "28 | model._deterministic_encoder._d_encoder.encoder.1 | NPBlockRelu2d | 65 K \n", - "29 | model._deterministic_encoder._d_encoder.encoder.1.linear | Linear | 65 K \n", - "30 | model._deterministic_encoder._d_encoder.encoder.1.act | ReLU | 0 \n", - "31 | model._deterministic_encoder._d_encoder.encoder.1.dropout | Dropout2d | 0 \n", - "32 | model._deterministic_encoder._d_encoder.final | Linear | 65 K \n", - "33 | model._deterministic_encoder._self_attention | Attention | 0 \n", - "34 | model._deterministic_encoder._cross_attention | Attention | 140 K \n", - "35 | model._deterministic_encoder._cross_attention.batch_mlp_k | BatchMLP | 70 K \n", - "36 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial | NPBlockRelu2d | 4 K \n", - "37 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial.linear | Linear | 4 K \n", - "38 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial.act | ReLU | 0 \n", - "39 | model._deterministic_encoder._cross_attention.batch_mlp_k.initial.dropout | Dropout2d | 0 \n", - "40 | model._deterministic_encoder._cross_attention.batch_mlp_k.encoder | Sequential | 0 \n", - "41 | model._deterministic_encoder._cross_attention.batch_mlp_k.final | Linear | 65 K \n", - "42 | model._deterministic_encoder._cross_attention.batch_mlp_q | BatchMLP | 70 K \n", - "43 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial | NPBlockRelu2d | 4 K \n", - "44 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial.linear | Linear | 4 K \n", - "45 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial.act | ReLU | 0 \n", - "46 | model._deterministic_encoder._cross_attention.batch_mlp_q.initial.dropout | Dropout2d | 0 \n", - "47 | model._deterministic_encoder._cross_attention.batch_mlp_q.encoder | Sequential | 0 \n", - "48 | model._deterministic_encoder._cross_attention.batch_mlp_q.final | Linear | 65 K \n", - "49 | model._decoder | Decoder | 1 M \n", - "50 | model._decoder._target_transform | Linear | 4 K \n", - "51 | model._decoder._decoder | BatchMLP | 1 M \n", - "52 | model._decoder._decoder.initial | NPBlockRelu2d | 262 K \n", - "53 | model._decoder._decoder.initial.linear | Linear | 262 K \n", - "54 | model._decoder._decoder.initial.act | ReLU | 0 \n", - "55 | model._decoder._decoder.initial.dropout | Dropout2d | 0 \n", - "56 | model._decoder._decoder.encoder | Sequential | 524 K \n", - "57 | model._decoder._decoder.encoder.0 | NPBlockRelu2d | 262 K \n", - "58 | model._decoder._decoder.encoder.0.linear | Linear | 262 K \n", - "59 | model._decoder._decoder.encoder.0.act | ReLU | 0 \n", - "60 | model._decoder._decoder.encoder.0.dropout | Dropout2d | 0 \n", - "61 | model._decoder._decoder.encoder.1 | NPBlockRelu2d | 262 K \n", - "62 | model._decoder._decoder.encoder.1.linear | Linear | 262 K \n", - "63 | model._decoder._decoder.encoder.1.act | ReLU | 0 \n", - "64 | model._decoder._decoder.encoder.1.dropout | Dropout2d | 0 \n", - "65 | model._decoder._decoder.final | Linear | 262 K \n", - "66 | model._decoder._mean | Linear | 513 \n", - "67 | model._decoder._std | Linear | 513 \n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validation sanity check', layout=Layout(flex='2'), max=5.…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 0, {'val_loss': '0.43965253233909607', 'val/kl': '0.0007104985415935516', 'val/std': '0.7188370823860168', 'val/mse': '0.28676602244377136'} {}\n", - "\r" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "a52b006d94954fc2a55bdd8cee72f350", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=1.0, bar_style='info', layout=Layout(flex='2'), max=1.0), HTML(value='')), …" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 1826, {'val_loss': '-0.34990647435188293', 'val/kl': '0.00030192238045856357', 'val/std': '0.11379449814558029', 'val/mse': '0.006947554647922516'} {'train_loss': -0.439557820558548, 'train/kl': 0.0012542756740003824, 'train/std': 0.11547033488750458, 'train/mse': 0.013290957547724247}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 3653, {'val_loss': '-0.6986027956008911', 'val/kl': '0.0006248955614864826', 'val/std': '0.06708841770887375', 'val/mse': '0.003856524359434843'} {'train_loss': -0.6183815002441406, 'train/kl': 0.000953543814830482, 'train/std': 0.07871614396572113, 'train/mse': 0.007680246606469154}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 5480, {'val_loss': '-0.6144722700119019', 'val/kl': '0.0006286696880124509', 'val/std': '0.08452112972736359', 'val/mse': '0.005910444539040327'} {'train_loss': -0.6634783148765564, 'train/kl': 0.0009074566187337041, 'train/std': 0.07310361415147781, 'train/mse': 0.006944151595234871}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 7307, {'val_loss': '-0.6824144721031189', 'val/kl': '0.0009006955660879612', 'val/std': '0.056882087141275406', 'val/mse': '0.004766825120896101'} {'train_loss': -0.6888368725776672, 'train/kl': 0.0008937152451835573, 'train/std': 0.06954135000705719, 'train/mse': 0.006349148694425821}\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 9134, {'val_loss': '-0.6076558828353882', 'val/kl': '0.0007585150306113064', 'val/std': '0.06220545992255211', 'val/mse': '0.006551452446728945'} {'train_loss': -0.712720513343811, 'train/kl': 0.0008679977036081254, 'train/std': 0.06662549078464508, 'train/mse': 0.005996646825224161}\n", - "Epoch 4: reducing learning rate of group 0 to 3.0000e-05.\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=117.0, style=Pr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 10961, {'val_loss': '-0.5856883525848389', 'val/kl': '0.0006908770883455873', 'val/std': '0.054788023233413696', 'val/mse': '0.005983424372971058'} {'train_loss': -0.7709274888038635, 'train/kl': 0.0008735057199373841, 'train/std': 0.06009318307042122, 'train/mse': 0.005061835516244173}\n", - "INFO:root:Epoch 00006: early stopping\n", - "\n", - "Loading checkpoint lightning_logs/np/version_-3/_ckpt_epoch_1.ckpt\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "7bd4eb87b2eb4149b8d3e624301bb831", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='Testing', layout=Layout(flex='2'), max=356.0, style=Progr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step val 10962, {'val_loss': '11.563106536865234', 'val/kl': '0.0010463492944836617', 'val/std': '0.057270597666502', 'val/mse': '0.1271519660949707'} {}\n", - "----------------------------------------------------------------------------------------------------\n", - "TEST RESULTS\n", - "{}\n", - "----------------------------------------------------------------------------------------------------\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "trial, trainer, model = run_trial(name=\"np\",\n", " params={\n", - " **default_params,\n", " 'det_enc_cross_attn_type': 'uniform',\n", " 'det_enc_self_attn_type': 'uniform',\n", " 'latent_enc_self_attn_type': 'uniform',\n", " 'use_deterministic_path': False,\n", " 'use_lvar': False,\n", " },\n", - " user_attrs=default_attrs,\n", - " PL_MODEL_CLS=LatentModelPL)" + " user_attrs=default_user_attrs,\n", + " PL_MODEL_CLS=PL_NeuralProcess)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-11T01:24:32.163872Z", + "start_time": "2020-04-11T01:24:32.160011Z" + } + }, + "source": [ + "## Transformer" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": { "ExecuteTime": { - "end_time": "2020-03-15T17:24:47.225677Z", - "start_time": "2020-03-15T17:24:47.172935Z" + "end_time": "2020-04-11T04:38:49.869900Z", + "start_time": "2020-04-11T04:38:46.400Z" } }, "outputs": [], "source": [ - "# trial, trainer, model = run_trial(name=\"np\",\n", - "# params={\n", - "# **default_params,\n", - "# 'det_enc_cross_attn_type': 'uniform',\n", - "# 'det_enc_self_attn_type': 'uniform',\n", - "# 'latent_enc_self_attn_type': 'uniform',\n", - "# 'use_deterministic_path': False,\n", - "# },\n", - "# user_attrs=default_attrs,\n", - "# PL_MODEL_CLS=LatentModelPL)" + "trial, trainer, model = run_trial(name=\"PL_Transformer\",\n", + " params={\n", + " 'det_enc_cross_attn_type': 'uniform',\n", + " 'det_enc_self_attn_type': 'uniform',\n", + " 'latent_enc_self_attn_type': 'uniform',\n", + " 'use_deterministic_path': False,\n", + " 'use_lvar': False,\n", + " },\n", + " user_attrs=default_user_attrs,\n", + " PL_MODEL_CLS=PL_Transformer)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Transformer Seq2Seq" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-11T04:38:49.871823Z", + "start_time": "2020-04-11T04:38:46.400Z" + } + }, + "outputs": [], + "source": [ + "trial, trainer, model = run_trial(name=\"TransformerSeq2Seq_PL\",\n", + " params={\n", + " 'det_enc_cross_attn_type': 'uniform',\n", + " 'det_enc_self_attn_type': 'uniform',\n", + " 'latent_enc_self_attn_type': 'uniform',\n", + " 'use_deterministic_path': False,\n", + " 'use_lvar': False,\n", + " },\n", + " user_attrs=default_user_attrs,\n", + " PL_MODEL_CLS=TransformerSeq2Seq_PL)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## LSTM" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-11T04:38:49.874413Z", + "start_time": "2020-04-11T04:38:46.400Z" + } + }, + "outputs": [], + "source": [ + "trial, trainer, model = run_trial(name=\"LSTM_PL_STD\",\n", + " params={\n", + " 'det_enc_cross_attn_type': 'uniform',\n", + " 'det_enc_self_attn_type': 'uniform',\n", + " 'latent_enc_self_attn_type': 'uniform',\n", + " 'use_deterministic_path': False,\n", + " 'use_lvar': False,\n", + " },\n", + " user_attrs=default_user_attrs,\n", + " PL_MODEL_CLS=LSTM_PL_STD)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## LSTM seq2seq" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-11T04:38:49.876588Z", + "start_time": "2020-04-11T04:38:46.400Z" + } + }, + "outputs": [], + "source": [ + "trial, trainer, model = run_trial(name=\"LSTMSeq2Seq_PL\",\n", + " params={\n", + " 'det_enc_cross_attn_type': 'uniform',\n", + " 'det_enc_self_attn_type': 'uniform',\n", + " 'latent_enc_self_attn_type': 'uniform',\n", + " 'use_deterministic_path': False,\n", + " 'use_lvar': False,\n", + " },\n", + " user_attrs=default_user_attrs,\n", + " PL_MODEL_CLS=LSTMSeq2Seq_PL)" ] }, { @@ -4578,23 +582,15 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": { "ExecuteTime": { - "end_time": "2020-03-15T17:24:47.346452Z", - "start_time": "2020-03-15T17:24:47.229296Z" + "end_time": "2020-04-11T04:38:49.878400Z", + "start_time": "2020-04-11T04:38:46.400Z" }, "scrolled": true }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[I 2020-03-16 01:24:47,330] Using an existing study with name 'anp-rnn1' instead of creating a new one.\n" - ] - } - ], + "outputs": [], "source": [ "import argparse \n", "\n", @@ -4612,42 +608,15 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": { "ExecuteTime": { - "end_time": "2020-03-15T17:24:48.735987Z", - "start_time": "2020-03-15T17:24:47.349364Z" + "end_time": "2020-04-11T04:38:49.880310Z", + "start_time": "2020-04-11T04:38:46.400Z" }, "scrolled": true }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[W 2020-03-16 01:24:47,560] Setting status of trial#1 as TrialState.FAIL because of the following error: TypeError(\"objective() missing 1 required positional argument: 'PL_MODEL_CLS'\")\n", - "Traceback (most recent call last):\n", - " File \"/home/wassname/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/optuna/study.py\", line 569, in _run_trial\n", - " result = func(trial)\n", - "TypeError: objective() missing 1 required positional argument: 'PL_MODEL_CLS'\n" - ] - }, - { - "ename": "TypeError", - "evalue": "objective() missing 1 required positional argument: 'PL_MODEL_CLS'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mstudy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptimize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobjective\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_trials\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m200\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTimedelta\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'3d'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtotal_seconds\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/optuna/study.py\u001b[0m in \u001b[0;36moptimize\u001b[0;34m(self, func, n_trials, timeout, n_jobs, catch, callbacks, gc_after_trial)\u001b[0m\n\u001b[1;32m 300\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mn_jobs\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 301\u001b[0m self._optimize_sequential(func, n_trials, timeout, catch, callbacks,\n\u001b[0;32m--> 302\u001b[0;31m gc_after_trial, None)\n\u001b[0m\u001b[1;32m 303\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 304\u001b[0m \u001b[0mtime_start\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdatetime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdatetime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/optuna/study.py\u001b[0m in \u001b[0;36m_optimize_sequential\u001b[0;34m(self, func, n_trials, timeout, catch, callbacks, gc_after_trial, time_start)\u001b[0m\n\u001b[1;32m 536\u001b[0m \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 537\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 538\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_run_trial_and_callbacks\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcatch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcallbacks\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgc_after_trial\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 539\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_storage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mremove_session\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 540\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/optuna/study.py\u001b[0m in \u001b[0;36m_run_trial_and_callbacks\u001b[0;34m(self, func, catch, callbacks, gc_after_trial)\u001b[0m\n\u001b[1;32m 548\u001b[0m \u001b[0;31m# type: (...) -> None\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 549\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 550\u001b[0;31m \u001b[0mtrial\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_run_trial\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcatch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgc_after_trial\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 551\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mcallbacks\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 552\u001b[0m \u001b[0mfrozen_trial\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_storage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_trial\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrial\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trial_id\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/optuna/study.py\u001b[0m in \u001b[0;36m_run_trial\u001b[0;34m(self, func, catch, gc_after_trial)\u001b[0m\n\u001b[1;32m 567\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 568\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 569\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrial\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 570\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mexceptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTrialPruned\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 571\u001b[0m message = 'Setting status of trial#{} as {}. {}'.format(trial_number,\n", - "\u001b[0;31mTypeError\u001b[0m: objective() missing 1 required positional argument: 'PL_MODEL_CLS'" - ] - } - ], + "outputs": [], "source": [ "study.optimize(objective, n_trials=200, timeout=pd.Timedelta('3d').total_seconds())" ] @@ -4669,8 +638,8 @@ "execution_count": null, "metadata": { "ExecuteTime": { - "end_time": "2020-03-15T17:24:48.738563Z", - "start_time": "2020-03-15T14:02:03.500Z" + "end_time": "2020-04-11T04:38:49.882517Z", + "start_time": "2020-04-11T04:38:46.400Z" }, "scrolled": true }, @@ -4722,8 +691,8 @@ "execution_count": null, "metadata": { "ExecuteTime": { - "end_time": "2020-03-15T17:24:48.740108Z", - "start_time": "2020-03-15T14:02:03.500Z" + "end_time": "2020-04-11T04:38:49.884711Z", + "start_time": "2020-04-11T04:38:46.400Z" } }, "outputs": [], @@ -4737,8 +706,8 @@ "execution_count": null, "metadata": { "ExecuteTime": { - "end_time": "2020-03-15T17:24:48.741420Z", - "start_time": "2020-03-15T14:02:03.600Z" + "end_time": "2020-04-11T04:38:49.886818Z", + "start_time": "2020-04-11T04:38:46.400Z" } }, "outputs": [], diff --git a/smartmeters-lstm-deterministic.ipynb b/smartmeters-lstm-deterministic.ipynb index 1bd5327..74ef11f 100644 --- a/smartmeters-lstm-deterministic.ipynb +++ b/smartmeters-lstm-deterministic.ipynb @@ -85,13 +85,13 @@ }, "outputs": [], "source": [ - "from src.models.model import LatentModel\n", - "from src.data.smart_meter import collate_fns, SmartMeterDataSet, get_smartmeter_df\n", - "# from src.plot import plot_from_loader\n", - "from src.models.lstm import SequenceDfDataSet, LSTM_PL, plot_from_loader\n", - "from src.dict_logger import DictLogger\n", - "from src.utils import PyTorchLightningPruningCallback\n", - "from src.train import main, objective, add_number, run_trial" + "from neural_processes.models.model import LatentModel\n", + "from neural_processes.data.smart_meter import collate_fns, SmartMeterDataSet, get_smartmeter_df\n", + "# from neural_processes.plot import plot_from_loader\n", + "from neural_processes.models.lstm import SequenceDfDataSet, LSTM_PL, plot_from_loader\n", + "from neural_processes.dict_logger import DictLogger\n", + "from neural_processes.utils import PyTorchLightningPruningCallback\n", + "from neural_processes.train import main, objective, add_number, run_trial" ] }, { diff --git a/smartmeters-lstm-seq2seq.ipynb b/smartmeters-lstm-seq2seq.ipynb index 2a4a56f..c311718 100644 --- a/smartmeters-lstm-seq2seq.ipynb +++ b/smartmeters-lstm-seq2seq.ipynb @@ -96,13 +96,13 @@ } ], "source": [ - "from src.models.model import LatentModel\n", - "from src.data.smart_meter import collate_fns, SmartMeterDataSet, get_smartmeter_df\n", - "from src.plot import plot_from_loader\n", - "from src.models.lstm_seqseq import LSTMSeq2Seq_PL\n", - "from src.dict_logger import DictLogger\n", - "from src.utils import PyTorchLightningPruningCallback\n", - "from src.train import main, objective, add_number, run_trial" + "from neural_processes.models.model import LatentModel\n", + "from neural_processes.data.smart_meter import collate_fns, SmartMeterDataSet, get_smartmeter_df\n", + "from neural_processes.plot import plot_from_loader\n", + "from neural_processes.models.lstm_seqseq import LSTMSeq2Seq_PL\n", + "from neural_processes.dict_logger import DictLogger\n", + "from neural_processes.utils import PyTorchLightningPruningCallback\n", + "from neural_processes.train import main, objective, add_number, run_trial" ] }, { diff --git a/smartmeters-lstm_std.ipynb b/smartmeters-lstm_std.ipynb index ac2aa3d..0f50136 100644 --- a/smartmeters-lstm_std.ipynb +++ b/smartmeters-lstm_std.ipynb @@ -96,13 +96,13 @@ } ], "source": [ - "from src.models.model import LatentModel\n", - "from src.data.smart_meter import collate_fns, SmartMeterDataSet, get_smartmeter_df\n", - "# from src.plot import plot_from_loader\n", - "from src.models.lstm_std import SequenceDfDataSet, LSTM_PL, plot_from_loader\n", - "from src.dict_logger import DictLogger\n", - "from src.utils import PyTorchLightningPruningCallback\n", - "from src.train import main, objective, add_number, run_trial" + "from neural_processes.models.model import LatentModel\n", + "from neural_processes.data.smart_meter import collate_fns, SmartMeterDataSet, get_smartmeter_df\n", + "# from neural_processes.plot import plot_from_loader\n", + "from neural_processes.models.lstm_std import SequenceDfDataSet, LSTM_PL, plot_from_loader\n", + "from neural_processes.dict_logger import DictLogger\n", + "from neural_processes.utils import PyTorchLightningPruningCallback\n", + "from neural_processes.train import main, objective, add_number, run_trial" ] }, { diff --git a/smartmeters-transformer-seq2seq.ipynb b/smartmeters-transformer-seq2seq.ipynb index 708e564..bdc5c6d 100644 --- a/smartmeters-transformer-seq2seq.ipynb +++ b/smartmeters-transformer-seq2seq.ipynb @@ -96,13 +96,13 @@ } ], "source": [ - "from src.models.model import LatentModel\n", - "from src.data.smart_meter import collate_fns, SmartMeterDataSet, get_smartmeter_df\n", - "from src.plot import plot_from_loader\n", - "from src.models.transformer_seq2seq import TransformerSeq2Seq_PL\n", - "from src.dict_logger import DictLogger\n", - "from src.utils import PyTorchLightningPruningCallback\n", - "from src.train import main, objective, add_number, run_trial" + "from neural_processes.models.model import LatentModel\n", + "from neural_processes.data.smart_meter import collate_fns, SmartMeterDataSet, get_smartmeter_df\n", + "from neural_processes.plot import plot_from_loader\n", + "from neural_processes.models.transformer_seq2seq import TransformerSeq2Seq_PL\n", + "from neural_processes.dict_logger import DictLogger\n", + "from neural_processes.utils import PyTorchLightningPruningCallback\n", + "from neural_processes.train import main, objective, add_number, run_trial" ] }, { diff --git a/src/models/lightning_anp.py b/src/models/lightning_anp.py deleted file mode 100644 index 5439cf5..0000000 --- a/src/models/lightning_anp.py +++ /dev/null @@ -1,217 +0,0 @@ -import pytorch_lightning as pl -import torch -import torch.nn.functional as F -from argparse import ArgumentParser -from test_tube import Experiment, HyperOptArgumentParser -from src.models.model import LatentModel -from src.data.smart_meter import collate_fns, SmartMeterDataSet, get_smartmeter_df -from src.plot import plot_from_loader_to_tensor, plot_from_loader -from src.utils import ObjectDict -from matplotlib import pyplot as plt - - - -class LatentModelPL(pl.LightningModule): - def __init__(self, hparams): - super().__init__() - self.hparams = ObjectDict() - self.hparams.update(hparams.__dict__ if hasattr(hparams, '__dict__') else hparams) - self.model = LatentModel(**self.hparams) - self._dfs = None - self.train_logs = [] - - def forward(self, context_x, context_y, target_x, target_y): - return self.model(context_x, context_y, target_x, target_y) - - def training_step(self, batch, batch_idx): - assert all(torch.isfinite(d).all() for d in batch) - context_x, context_y, target_x, target_y = batch - y_pred, losses, extra = self.forward(context_x, context_y, target_x, target_y) - y_std = extra['dist'].scale - loss = losses['loss'].mean() - - tensorboard_logs = { - "train_loss": loss, - "train/kl": losses['loss_kl'].mean(), - "train/std": y_std.mean(), - "train/mse": losses['loss_mse'].mean(), - } - assert torch.isfinite(loss) - self.train_logs.append(tensorboard_logs) - return {"loss": loss, "log": tensorboard_logs} - - def validation_step(self, batch, batch_idx): - assert all(torch.isfinite(d).all() for d in batch) - context_x, context_y, target_x, target_y = batch - y_pred, losses, extra = self.forward(context_x, context_y, target_x, target_y) - y_std = extra['dist'].scale - loss = losses['loss'].mean() - - tensorboard_logs = { - "val_loss": loss, # This exact key is needed for metrics - "val/kl": losses['loss_kl'].mean(), - "val/std": y_std.mean(), - "val/mse": losses['loss_mse'].mean(), - } - return {"val_loss": loss, "log": tensorboard_logs} - - # def training_end(self, outputs): - # logs = self.agg_logs(outputs) - # tensorboard_logs_str = {k: f'{v}' for k, v in logs["log"].items()} - # print(f"step train {self.trainer.global_step}, {tensorboard_logs_str}") - # return logs - - def validation_end(self, outputs): - if int(self.hparams["vis_i"]) > 0: - self.show_image() - logs = self.agg_logs(outputs) - tensorboard_logs_str = {k: f'{v}' for k, v in logs["log"].items()} - - # agg and print self.train_logs HACK https://github.com/PyTorchLightning/pytorch-lightning/issues/100 - train_logs = self.agg_logs(self.train_logs) - train_logs_str = {k: f"{v}" for k, v in train_logs.items()} - self.train_logs = [] - print(f"step val {self.trainer.global_step}, {tensorboard_logs_str} {train_logs}") - return logs - - def show_image(self): - # https://github.com/PytorchLightning/pytorch-lightning/blob/f8d9f8f/pytorch_lightning/core/lightning.py#L293 - loader = self.val_dataloader() - vis_i = min(int(self.hparams["vis_i"]), len(loader.dataset)) - # print('vis_i', vis_i) - if isinstance(self.hparams["vis_i"], str): - image = plot_from_loader(loader, self, i=int(vis_i)) - plt.show() - else: - image = plot_from_loader_to_tensor(loader, self, i=vis_i) - self.logger.experiment.add_image('val/image', image, self.trainer.global_step) - - def agg_logs(self, outputs): - if isinstance(outputs, dict): - outputs = [outputs] - aggs = {} - if len(outputs)>0: - for j in outputs[0]: - if isinstance(outputs[0][j], dict): - # Take mean of sub dicts - keys = outputs[0][j].keys() - aggs[j] = {k: torch.stack([x[j][k] for x in outputs if k in x[j]]).mean().item() for k in keys} - else: - # Take mean of numbers - aggs[j] = torch.stack([x[j] for x in outputs if j in x]).mean().item() - return aggs - - # # Log hparams with metric, doesn't work - # # self.logger.experiment.add_hparams(self.hparams.__dict__, {"avg_val_loss": avg_loss}) - # if f"{name}_loss" in outputs[0].keys(): - # avg_loss = torch.stack([x[f"{name}_loss"] for x in outputs]).mean() - # assert torch.isfinite(avg_loss) - # else: - # avg_loss = 0 - # return {f"avg_{name}_loss": avg_loss, "log": tensorboard_logs, "progress_bar": {}} - - def test_step(self, *args, **kwargs): - return self.validation_step(*args, **kwargs) - - def test_end(self, *args, **kwargs): - return self.validation_end(*args, **kwargs) - - def configure_optimizers(self): - optim = torch.optim.AdamW(self.parameters(), lr=self.hparams["learning_rate"], weight_decay=0) - scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optim, patience=self.hparams["patience"], verbose=True, min_lr=1e-7) # note early stopping has patience 3 - return [optim], [scheduler] - - def _get_cache_dfs(self): - if self._dfs is None: - df_train, df_val, df_test = get_smartmeter_df() - self._dfs = dict(df_train=df_train, df_val=df_val, df_test=df_test) - return self._dfs - - def train_dataloader(self): - df_train = self._get_cache_dfs()['df_train'] - data_train = SmartMeterDataSet( - df_train, self.hparams["num_context"], self.hparams["num_extra_target"] - ) - return torch.utils.data.DataLoader( - data_train, - batch_size=self.hparams["batch_size"], - shuffle=True, - collate_fn=collate_fns( - self.hparams["num_context"], self.hparams["num_extra_target"], sample=True, context_in_target=self.hparams["context_in_target"] - ), - num_workers=self.hparams["num_workers"], - ) - - def val_dataloader(self): - df_test = self._get_cache_dfs()['df_val'] - data_test = SmartMeterDataSet( - df_test, self.hparams["num_context"], self.hparams["num_extra_target"] - ) - return torch.utils.data.DataLoader( - data_test, - batch_size=self.hparams["batch_size"], - shuffle=False, - collate_fn=collate_fns( - self.hparams["num_context"], self.hparams["num_extra_target"], sample=False, context_in_target=self.hparams["context_in_target"] - ), - ) - - def test_dataloader(self): - df_test = self._get_cache_dfs()['df_test'] - data_test = SmartMeterDataSet( - df_test, self.hparams["num_context"], self.hparams["num_extra_target"] - ) - return torch.utils.data.DataLoader( - data_test, - batch_size=self.hparams["batch_size"], - shuffle=False, - collate_fn=collate_fns( - self.hparams["num_context"], self.hparams["num_extra_target"], sample=False, context_in_target=self.hparams["context_in_target"] - ), - ) - - @staticmethod - def add_suggest(trial): - trial.suggest_loguniform("learning_rate", 1e-5, 1e-2) - - trial.suggest_categorical("hidden_dim", [8*2**i for i in range(8)]) - trial.suggest_categorical("latent_dim", [8*2**i for i in range(8)]) - - trial.suggest_int("attention_layers", 1, 4) - trial.suggest_categorical("n_latent_encoder_layers", [1, 2, 4, 6, 8, 12]) - trial.suggest_categorical("n_det_encoder_layers", [1, 2, 4, 6, 8, 12]) - trial.suggest_categorical("n_decoder_layers", [1, 2, 4, 6, 8, 12]) - trial.suggest_int("num_heads", 8, 8) - - trial.suggest_uniform("dropout", 0, 0.9) - trial.suggest_uniform("attention_dropout", 0, 0.9) - - trial.suggest_categorical( - "latent_enc_self_attn_type", ['uniform', 'multihead', 'ptmultihead'] - ) - trial.suggest_categorical("det_enc_self_attn_type", ['uniform', 'multihead', 'ptmultihead']) - trial.suggest_categorical("det_enc_cross_attn_type", ['uniform', 'multihead', 'ptmultihead']) - - trial.suggest_categorical("batchnorm", [False, True]) - trial.suggest_categorical("use_self_attn", [False, True]) - trial.suggest_categorical("use_lvar", [False, True]) - trial.suggest_categorical("use_deterministic_path", [False, True]) - trial.suggest_categorical("use_rnn", [True, False]) - - trial._user_attrs = { - 'batch_size': 16, - 'grad_clip': 40, - 'max_nb_epochs': 200, - 'num_workers': 4, - 'num_context': 24* 4, - 'vis_i': '670', - 'num_extra_target': 24*4, - 'x_dim': 18, - 'context_in_target': True, - 'y_dim': 1, - 'patience': 3, - 'min_std': 0.005, - } - return trial - - diff --git a/src/models/lstm.py b/src/models/lstm.py deleted file mode 100644 index 21c4613..0000000 --- a/src/models/lstm.py +++ /dev/null @@ -1,299 +0,0 @@ -import os -import numpy as np -import pandas as pd -import torch -from tqdm.auto import tqdm -from torch import nn -from torch.nn import functional as F -from torch.utils.data import DataLoader -from torchvision.datasets import MNIST -from test_tube import Experiment, HyperOptArgumentParser -import torchvision.transforms as transforms -from argparse import ArgumentParser -import json -import pytorch_lightning as pl -from matplotlib import pyplot as plt -import torch -import io -import PIL -from torchvision.transforms import ToTensor - -from src.data.smart_meter import get_smartmeter_df - -from src.utils import ObjectDict - - -class SequenceDfDataSet(torch.utils.data.Dataset): - def __init__(self, df, hparams, label_names=None, train=True, transforms=None): - super().__init__() - self.data = df - self.hparams = hparams - self.label_names = label_names - self.train = train - self.transforms = transforms - - def __len__(self): - return len(self.data) - self.hparams.window_length - self.hparams.target_length - 1 - - def iloc(self, idx): - k = idx + self.hparams.window_length + self.hparams.target_length - j = k - self.hparams.target_length - i = j - self.hparams.window_length - assert i >= 0 - assert idx <= len(self.data) - - x_rows = self.data.iloc[i:k].copy() - # x_rows = x_rows.drop(columns=self.label_names) - # Note the NP models do have access to the previous labels for the context, we will allow the LSTM to do the same. Although it will likely just return an autoregressive solution for the first half... - x_rows.loc[x_rows.index[self.hparams.window_length:], self.label_names] = 0 - assert len(x_rows.loc[x_rows.index[self.hparams.window_length:], self.label_names])>0 - assert (x_rows.loc[x_rows.index[self.hparams.window_length:], self.label_names]==0).all().all() - - y_rows = self.data[self.label_names].iloc[i+1:k+1].copy() - # print(i,j,k) - - # add seconds since start of window index - x_rows["tstp"] = ( - x_rows["tstp"] - x_rows["tstp"].iloc[0] - ).dt.total_seconds() / 86400.0 - return x_rows, y_rows - - def __getitem__(self, idx): - x_rows, y_rows = self.iloc(idx) - - x = x_rows.astype(np.float32).values - y = y_rows[self.label_names].astype(np.float32).values - return ( - self.transforms(x).squeeze(0).float(), - self.transforms(y).squeeze(0).squeeze(-1).float(), - ) - - -class LSTMNet(nn.Module): - def __init__(self, hparams): - super().__init__() - self.hparams = hparams - - self.lstm1 = nn.LSTM( - input_size=self.hparams.input_size, - hidden_size=self.hparams.hidden_size, - batch_first=True, - num_layers=self.hparams.lstm_layers, - bidirectional=self.hparams.bidirectional, - dropout=self.hparams.lstm_dropout, - ) - self.hidden_out_size = ( - self.hparams.hidden_size - * (self.hparams.bidirectional + 1) - ) - self.linear = nn.Linear(self.hidden_out_size, 1) - - def forward(self, x): - outputs, (h_out, _) = self.lstm1(x) - # outputs: [B, T, num_direction * H] - y = self.linear(outputs).squeeze(2) - return y - - -class LSTM_PL(pl.LightningModule): - def __init__(self, hparams): - # TODO make label name configurable - # TODO make data source configurable - super().__init__() - self.hparams = ObjectDict() - self.hparams.update( - hparams.__dict__ if hasattr(hparams, "__dict__") else hparams - ) - self._model = LSTMNet(self.hparams) - self._dfs = None - - def forward(self, x): - return self._model(x) - - def training_step(self, batch, batch_idx): - # REQUIRED - x, y = batch - y_hat = self.forward(x) - y = y[:, self.hparams.window_length:] - y_hat = y_hat[:, self.hparams.window_length:] - loss = F.mse_loss(y_hat, y) - tensorboard_logs = {"train_loss": loss} - return {"loss": loss, "log": tensorboard_logs} - - def validation_step(self, batch, batch_idx): - x, y = batch - y_hat = self.forward(x) - y = y[:, self.hparams.window_length:] - y_hat = y_hat[:, self.hparams.window_length:] - loss = F.mse_loss(y_hat, y) - tensorboard_logs = {"val_loss": loss} - return {"val_loss": loss, "log": tensorboard_logs} - - def validation_end(self, outputs): - # TODO send an image to tensroboard, like in the lighting_anp.py file - if int(self.hparams["vis_i"]) > 0: - loader = self.val_dataloader() - vis_i = min(int(self.hparams["vis_i"]), len(loader.dataset)) - if isinstance(self.hparams["vis_i"], str): - image = plot_from_loader(loader, self, vis_i=vis_i, window_len=self.hparams["window_length"]) - plt.show() - else: - image = plot_from_loader_to_tensor(loader, self, vis_i=vis_i, window_len=self.hparams["window_length"]) - self.logger.experiment.add_image( - "val/image", image, self.trainer.global_step - ) - - avg_loss = torch.stack([x["val_loss"] for x in outputs]).mean() - keys = outputs[0]["log"].keys() - tensorboard_logs = { - k: torch.stack([x["log"][k] for x in outputs if k in x["log"]]).mean() - for k in keys - } - tensorboard_logs_str = {k: f"{v}" for k, v in tensorboard_logs.items()} - print(f"step {self.trainer.global_step}, {tensorboard_logs_str}") - assert torch.isfinite(avg_loss) - return {"avg_val_loss": avg_loss, "log": tensorboard_logs} - - def test_step(self, *args, **kwargs): - return self.validation_step(*args, **kwargs) - - def test_end(self, *args, **kwargs): - return self.validation_end(*args, **kwargs) - - def configure_optimizers(self): - optim = torch.optim.Adam(self.parameters(), lr=self.hparams["learning_rate"]) - scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( - optim, patience=self.hparams["patience"], verbose=True, min_lr=1e-5 - ) # note early stopping has patient 3 - return [optim], [scheduler] - - def _get_cache_dfs(self): - if self._dfs is None: - df_train, df_val, df_test = get_smartmeter_df() - self._dfs = dict(df_train=df_train, df_val=df_val, df_test=df_test) - return self._dfs - - @pl.data_loader - def train_dataloader(self): - df_train = self._get_cache_dfs()["df_train"] - dset_train = SequenceDfDataSet( - df_train, - self.hparams, - label_names=["energy(kWh/hh)"], - transforms=transforms.ToTensor(), - train=True, - ) - return DataLoader( - dset_train, - batch_size=self.hparams.batch_size, - shuffle=True, - num_workers=self.hparams.num_workers, - ) - - @pl.data_loader - def val_dataloader(self): - df_test = self._get_cache_dfs()["df_val"] - dset_test = SequenceDfDataSet( - df_test, - self.hparams, - label_names=["energy(kWh/hh)"], - train=False, - transforms=transforms.ToTensor(), - ) - return DataLoader(dset_test, batch_size=self.hparams.batch_size, shuffle=False) - - @pl.data_loader - def test_dataloader(self): - df_test = self._get_cache_dfs()["df_test"] - dset_test = SequenceDfDataSet( - df_test, - self.hparams, - label_names=["energy(kWh/hh)"], - train=False, - transforms=transforms.ToTensor(), - ) - return DataLoader(dset_test, batch_size=self.hparams.batch_size, shuffle=False) - - @staticmethod - def add_suggest(trial: optuna.Trial): - """ - Add hyperparam ranges to an optuna trial and typical user attrs. - - Usage: - trial = optuna.trial.FixedTrial( - params={ - 'hidden_size': 128, - } - ) - trial = add_suggest(trial) - trainer = pl.Trainer() - model = LSTM_PL(dict(**trial.params, **trial.user_attrs), dataset_train, - dataset_test, cache_base_path, norm) - trainer.fit(model) - """ - trial.suggest_loguniform("learning_rate", 1e-6, 1e-2) - trial.suggest_uniform("lstm_dropout", 0, 0.75) - trial.suggest_categorical( - "hidden_size", [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] - ) - trial.suggest_categorical("lstm_layers", [1, 2, 3, 4, 6, 8]) - trial.suggest_categorical("bidirectional", [False, True]) - - trial._user_attrs = { - "batch_size": 16, - "grad_clip": 40, - "max_nb_epochs": 200, - "num_workers": 4, - "vis_i": 670, - "input_size": 6, - "output_size": 1, - "patience": 2, - } - return trial - - -def plot_from_loader(loader, model, vis_i=670, n=1, window_len=0): - dset_test = loader.dataset - label_names = dset_test.label_names - y_trues = [] - y_preds = [] - vis_i = min(vis_i, len(dset_test)) - for i in tqdm(range(vis_i, vis_i + n)): - x_rows, y_rows = dset_test.iloc(i) - x, y = dset_test[i] - device = next(model.parameters()).device - x = x[None, :].to(device) - model.eval() - with torch.no_grad(): - y_hat = model.forward(x) - y_hat = y_hat.cpu().squeeze(0).numpy() - - dt = y_rows.iloc[0].name - - y_hat_rows = y_rows.copy() - y_hat_rows[label_names[0]] = y_hat - y_trues.append(y_rows) - y_preds.append(y_hat_rows) - - plt.figure() - pd.concat(y_trues)[label_names[0]].plot(label="y_true") - ylims = plt.ylim() - pd.concat(y_preds)[label_names[0]][window_len:].plot(label="y_pred") - plt.legend() - t_ahead = pd.Timedelta("30T") * model.hparams.target_length - plt.title(f"predicting {t_ahead} ahead") - plt.ylim(*ylims) - # plt.show() - - -def plot_from_loader_to_tensor(*args, **kwargs): - plot_from_loader(*args, **kwargs) - - # Send fig to tensorboard - buf = io.BytesIO() - plt.savefig(buf, format="jpeg") - plt.close() - buf.seek(0) - image = PIL.Image.open(buf) - image = ToTensor()(image) # .unsqueeze(0) - return image diff --git a/src/models/lstm_seqseq.py b/src/models/lstm_seqseq.py deleted file mode 100644 index 8e378c9..0000000 --- a/src/models/lstm_seqseq.py +++ /dev/null @@ -1,281 +0,0 @@ -import os -import numpy as np -import pandas as pd -import torch -from tqdm.auto import tqdm -from torch import nn -from torch.nn import functional as F -from torch.utils.data import DataLoader -from torchvision.datasets import MNIST -from test_tube import Experiment, HyperOptArgumentParser -from src.data.smart_meter import collate_fns, SmartMeterDataSet, get_smartmeter_df -import torchvision.transforms as transforms -from src.plot import plot_from_loader_to_tensor, plot_from_loader -from argparse import ArgumentParser -import json -import pytorch_lightning as pl -import math -from matplotlib import pyplot as plt -import torch -import io -import PIL -from torchvision.transforms import ToTensor -from src.models.modules import BatchNormSequence -from src.data.smart_meter import get_smartmeter_df - -from src.utils import ObjectDict - -def log_prob_sigma(value, loc, log_scale): - """A slightly more stable (not confirmed yet) log prob taking in log_var instead of scale. - modified from https://github.com/pytorch/pytorch/blob/2431eac7c011afe42d4c22b8b3f46dedae65e7c0/torch/distributions/normal.py#L65 - """ - var = torch.exp(log_scale * 2) - return ( - -((value - loc) ** 2) / (2 * var) - log_scale - math.log(math.sqrt(2 * math.pi)) - ) - - -class Seq2SeqNet(nn.Module): - def __init__(self, hparams, _min_std = 0.05): - super().__init__() - self.hparams = hparams - self._min_std = _min_std - - - - self.norm_input = BatchNormSequence(self.hparams.input_size) - self.encoder = nn.LSTM( - input_size=self.hparams.input_size, - hidden_size=self.hparams.hidden_size, - batch_first=True, - num_layers=self.hparams.lstm_layers, - bidirectional=self.hparams.bidirectional, - dropout=self.hparams.lstm_dropout, - ) - self.multihead_attn = nn.MultiheadAttention(self.hparams.hidden_size, num_heads=8) - - self.norm_target = BatchNormSequence(self.hparams.input_size_decoder) - self.decoder = nn.LSTM( - input_size=self.hparams.input_size_decoder, - hidden_size=self.hparams.hidden_size, - batch_first=True, - num_layers=self.hparams.lstm_layers, - bidirectional=self.hparams.bidirectional, - dropout=self.hparams.lstm_dropout, - ) - self.hidden_out_size = ( - self.hparams.hidden_size - * (self.hparams.bidirectional + 1) - ) - self.mean = nn.Linear(self.hidden_out_size, self.hparams.output_size) - self.std = nn.Linear(self.hidden_out_size, self.hparams.output_size) - self._use_lvar = False - - def forward(self, context_x, context_y, target_x, target_y=None): - x = torch.cat([context_x, context_y], -1) - - # Sometimes input normalisation can be important, an initial batch norm is a nice way to ensure this - x = self.norm_input(x) - target_x = self.norm_target(target_x) - - _, (h_out, cell) = self.encoder(x) - # hidden = [batch size, n layers * n directions, hid dim] - # cell = [batch size, n layers * n directions, hid dim] - - # context_x, d_encoded, target_x = k, v, q - - # query, key, value = target_x, context_x, d_encoded - attn_output, _ = self.multihead_attn(h_out.permute(1, 0, 2), h_out.permute(1, 0, 2), h_out.permute(1, 0, 2)) - h_out = attn_output.permute(1, 0, 2).contiguous() - attn_output, _ = self.multihead_attn(cell.permute(1, 0, 2), cell.permute(1, 0, 2), cell.permute(1, 0, 2)) - cell = attn_output.permute(1, 0, 2).contiguous() - - outputs, (_, _) = self.decoder(target_x, (h_out, cell)) - # output = [batch size, seq len, hid dim * n directions] - - # outputs: [B, T, num_direction * H] - mean = self.mean(outputs) - log_sigma = self.std(outputs) - if self._use_lvar: - log_sigma = torch.clamp(log_sigma, math.log(self._min_std), -math.log(self._min_std)) - sigma = torch.exp(log_sigma) - else: - sigma = self._min_std + (1 - self._min_std) * F.softplus(log_sigma) - y_dist=torch.distributions.Normal(mean, sigma) - - # Loss - loss_mse = loss_p = None - if target_y is not None: - loss_mse = F.mse_loss(mean, target_y, reduction='none') - if self._use_lvar: - loss_p = -log_prob_sigma(target_y, mean, log_sigma) - else: - loss_p = -y_dist.log_prob(target_y).mean(-1) - - if self.hparams["context_in_target"]: - loss_p[:context_x.size(1)] /= 100 - loss_mse[:context_x.size(1)] /= 100 - # # Don't catch loss on context window - # mean = mean[:, self.hparams.num_context:] - # log_sigma = log_sigma[:, self.hparams.num_context:] - - y_pred = y_dist.rsample if self.training else y_dist.loc - return y_pred, dict(loss_p=loss_p.mean(), loss_mse=loss_mse.mean()), dict(log_sigma=log_sigma, dist=y_dist) - - -class LSTMSeq2Seq_PL(pl.LightningModule): - def __init__(self, hparams): - # TODO make label name configurable - # TODO make data source configurable - super().__init__() - self.hparams = ObjectDict() - self.hparams.update( - hparams.__dict__ if hasattr(hparams, "__dict__") else hparams - ) - self.model = Seq2SeqNet(self.hparams) - self._dfs = None - - def forward(self, context_x, context_y, target_x, target_y): - return self.model(context_x, context_y, target_x, target_y) - - def training_step(self, batch, batch_idx): - # REQUIRED - assert all(torch.isfinite(d).all() for d in batch) - context_x, context_y, target_x, target_y = batch - y_dist, losses, extra = self.forward(context_x, context_y, target_x, target_y) - loss = losses['loss_p'] # + loss_mse - tensorboard_logs = { - "train/loss": loss, - 'train/loss_mse': losses['loss_mse'], - "train/loss_p": losses['loss_p'], - "train/sigma": torch.exp(extra['log_sigma']).mean()} - return {"loss": loss, "log": tensorboard_logs} - - def validation_step(self, batch, batch_idx): - context_x, context_y, target_x, target_y = batch - assert all(torch.isfinite(d).all() for d in batch) - y_dist, losses, extra = self.forward(context_x, context_y, target_x, target_y) - loss = losses['loss_p'] # + loss_mse - tensorboard_logs = { - "val_loss": loss, - 'val/loss_mse': losses['loss_mse'], - "val/loss_p": losses['loss_p'], - "val/sigma": torch.exp(extra['log_sigma']).mean()} - return {"val_loss": loss, "log": tensorboard_logs} - - def validation_end(self, outputs): - if int(self.hparams["vis_i"]) > 0: - self.show_image() - - avg_loss = torch.stack([x["val_loss"] for x in outputs]).mean() - keys = outputs[0]["log"].keys() - tensorboard_logs = { - k: torch.stack([x["log"][k] for x in outputs if k in x["log"]]).mean() - for k in keys - } - tensorboard_logs_str = {k: f"{v}" for k, v in tensorboard_logs.items()} - print(f"step {self.trainer.global_step}, {tensorboard_logs_str}") - assert torch.isfinite(avg_loss) - return {"avg_val_loss": avg_loss, "log": tensorboard_logs} - - - def show_image(self): - # https://github.com/PytorchLightning/pytorch-lightning/blob/f8d9f8f/pytorch_lightning/core/lightning.py#L293 - loader = self.val_dataloader() - vis_i = min(int(self.hparams["vis_i"]), len(loader.dataset)) - # print('vis_i', vis_i) - if isinstance(self.hparams["vis_i"], str): - image = plot_from_loader(loader, self, i=int(vis_i)) - plt.show() - else: - image = plot_from_loader_to_tensor(loader, self, i=vis_i) - self.logger.experiment.add_image('val/image', image, self.trainer.global_step) - - def test_step(self, *args, **kwargs): - return self.validation_step(*args, **kwargs) - - def test_end(self, *args, **kwargs): - return self.validation_end(*args, **kwargs) - - def configure_optimizers(self): - optim = torch.optim.Adam(self.parameters(), lr=self.hparams["learning_rate"]) - scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( - optim, patience=self.hparams["patience"], verbose=True, min_lr=1e-5 - ) # note early stopping has patient 3 - return [optim], [scheduler] - - def _get_cache_dfs(self): - if self._dfs is None: - df_train, df_val, df_test = get_smartmeter_df() - self._dfs = dict(df_train=df_train, df_val=df_val, df_test=df_test) - return self._dfs - - @pl.data_loader - def train_dataloader(self): - df_train = self._get_cache_dfs()['df_train'] - data_train = SmartMeterDataSet( - df_train, self.hparams["num_context"], self.hparams["num_extra_target"] - ) - return torch.utils.data.DataLoader( - data_train, - batch_size=self.hparams["batch_size"], - shuffle=True, - collate_fn=collate_fns( - self.hparams["num_context"], self.hparams["num_extra_target"], sample=True, context_in_target=self.hparams["context_in_target"] - ), - num_workers=self.hparams["num_workers"], - ) - - @pl.data_loader - def val_dataloader(self): - df_test = self._get_cache_dfs()['df_val'] - data_test = SmartMeterDataSet( - df_test, self.hparams["num_context"], self.hparams["num_extra_target"] - ) - return torch.utils.data.DataLoader( - data_test, - batch_size=self.hparams["batch_size"], - shuffle=False, - collate_fn=collate_fns( - self.hparams["num_context"], self.hparams["num_extra_target"], sample=False, context_in_target=self.hparams["context_in_target"] - ), - ) - - @pl.data_loader - def test_dataloader(self): - df_test = self._get_cache_dfs()['df_test'] - data_test = SmartMeterDataSet( - df_test, self.hparams["num_context"], self.hparams["num_extra_target"] - ) - return torch.utils.data.DataLoader( - data_test, - batch_size=self.hparams["batch_size"], - shuffle=False, - collate_fn=collate_fns( - self.hparams["num_context"], self.hparams["num_extra_target"], sample=False, context_in_target=self.hparams["context_in_target"] - ), - ) - - @staticmethod - def add_suggest(trial): - trial.suggest_loguniform("learning_rate", 1e-5, 1e-2) - trial.suggest_uniform("lstm_dropout", 0, 0.75) - trial.suggest_categorical("hidden_size", [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]) - trial.suggest_categorical("lstm_layers", [1, 2, 4, 8]) - trial.suggest_categorical("bidirectional", [False, True]) - - - trial._user_attrs = { - 'batch_size': 16, - 'grad_clip': 40, - 'max_nb_epochs': 200, - 'num_workers': 4, - 'num_extra_target': 24*4, - 'vis_i': '670', - 'num_context': 24*4, - 'input_size': 18, - 'input_size_decoder': 17, - 'context_in_target': True, - 'output_size': 1 - } - return trial diff --git a/src/models/modules.py b/src/models/modules.py deleted file mode 100644 index 064c04b..0000000 --- a/src/models/modules.py +++ /dev/null @@ -1,410 +0,0 @@ -import torch -from torch import nn -import torch.nn.functional as F -import math -import numpy as np -# from .attention import Attention as PtAttention - - -class LSTMBlock(nn.Module): - def __init__( - self, in_channels, out_channels, dropout=0, batchnorm=False, bias=False, num_layers=1 - ): - super().__init__() - self._lstm = nn.LSTM( - input_size=in_channels, - hidden_size=out_channels, - num_layers=num_layers, - dropout=dropout, - batch_first=True, - bias=bias - ) - - def forward(self, x): - return self._lstm(x)[0] - - -class BatchNormSequence(nn.Module): - """Applies batch norm on features of a batch first sequence.""" - def __init__( - self, out_channels - ): - super().__init__() - self.norm = nn.BatchNorm1d(out_channels) - - def forward(self, x): - # x.shape is (Batch, Sequence, Channels) - # Now we want to apply batchnorm and dropout to the channels. So we put it in shape - # (Batch, Channels, Sequence) so we can use BatchNorm1d - x = x.permute(0, 2, 1) - x = self.norm(x) - return x.permute(0, 2, 1) - -class NPBlockRelu2d(nn.Module): - """Block for Neural Processes.""" - - def __init__( - self, in_channels, out_channels, dropout=0, batchnorm=False, bias=False - ): - super().__init__() - self.linear = nn.Linear(in_channels, out_channels, bias=bias) - self.act = nn.ReLU() - self.dropout = nn.Dropout2d(dropout) - self.norm = nn.BatchNorm2d(out_channels) if batchnorm else False - - def forward(self, x): - # x.shape is (Batch, Sequence, Channels) - # We pass a linear over it which operates on the Channels - x = self.act(self.linear(x)) - - # Now we want to apply batchnorm and dropout to the channels. So we put it in shape - # (Batch, Channels, Sequence, None) so we can use Dropout2d & BatchNorm2d - x = x.permute(0, 2, 1)[:, :, :, None] - - if self.norm: - x = self.norm(x) - - x = self.dropout(x) - return x[:, :, :, 0].permute(0, 2, 1) - - -class BatchMLP(nn.Module): - """Apply MLP to the final axis of a 3D tensor (reusing already defined MLPs). - - Args: - input: input tensor of shape [B,n,d_in]. - output_sizes: An iterable containing the output sizes of the MLP as defined - in `basic.Linear`. - Returns: - tensor of shape [B,n,d_out] where d_out=output_size - """ - - def __init__( - self, input_size, output_size, num_layers=2, dropout=0, batchnorm=False - ): - super().__init__() - self.input_size = input_size - self.output_size = output_size - self.num_layers = num_layers - - self.initial = NPBlockRelu2d( - input_size, output_size, dropout=dropout, batchnorm=batchnorm - ) - self.encoder = nn.Sequential( - *[ - NPBlockRelu2d( - output_size, output_size, dropout=dropout, batchnorm=batchnorm - ) - for _ in range(num_layers - 2) - ] - ) - self.final = nn.Linear(output_size, output_size) - - def forward(self, x): - x = self.initial(x) - x = self.encoder(x) - return self.final(x) - - -class AttnLinear(nn.Module): - def __init__(self, in_channels, out_channels): - super().__init__() - self.linear = nn.Linear(in_channels, out_channels, bias=False) - torch.nn.init.normal_(self.linear.weight, std=in_channels ** -0.5) - - def forward(self, x): - x = self.linear(x) - return x - - -class Attention(nn.Module): - def __init__( - self, - hidden_dim, - attention_type, - attention_layers=2, - n_heads=8, - x_dim=1, - rep="mlp", - dropout=0, - batchnorm=False, - ): - super().__init__() - self._rep = rep - - if self._rep == "mlp": - self.batch_mlp_k = BatchMLP( - x_dim, - hidden_dim, - attention_layers, - dropout=dropout, - batchnorm=batchnorm, - ) - self.batch_mlp_q = BatchMLP( - x_dim, - hidden_dim, - attention_layers, - dropout=dropout, - batchnorm=batchnorm, - ) - - if attention_type == "uniform": - self._attention_func = self._uniform_attention - elif attention_type == "laplace": - self._attention_func = self._laplace_attention - elif attention_type == "dot": - self._attention_func = self._dot_attention - elif attention_type == "multihead": - self._W_k = nn.ModuleList( - [AttnLinear(hidden_dim, hidden_dim) for _ in range(n_heads)] - ) - self._W_v = nn.ModuleList( - [AttnLinear(hidden_dim, hidden_dim) for _ in range(n_heads)] - ) - self._W_q = nn.ModuleList( - [AttnLinear(hidden_dim, hidden_dim) for _ in range(n_heads)] - ) - self._W = AttnLinear(n_heads * hidden_dim, hidden_dim) - self._attention_func = self._multihead_attention - self.n_heads = n_heads - elif attention_type == "ptmultihead": - self._W = torch.nn.MultiheadAttention( - hidden_dim, n_heads, bias=False, dropout=dropout - ) - self._attention_func = self._pytorch_multihead_attention - else: - raise NotImplementedError - - def forward(self, k, v, q): - if self._rep == "mlp": - k = self.batch_mlp_k(k) - q = self.batch_mlp_q(q) - rep = self._attention_func(k, v, q) - return rep - - def _uniform_attention(self, k, v, q): - total_points = q.shape[1] - rep = torch.mean(v, dim=1, keepdim=True) - rep = rep.repeat(1, total_points, 1) - return rep - - def _laplace_attention(self, k, v, q, scale=0.5): - k_ = k.unsqueeze(1) - v_ = v.unsqueeze(2) - unnorm_weights = torch.abs((k_ - v_) * scale) - unnorm_weights = unnorm_weights.sum(dim=-1) - weights = torch.softmax(unnorm_weights, dim=-1) - rep = torch.einsum("bik,bkj->bij", weights, v) - return rep - - def _dot_attention(self, k, v, q): - scale = q.shape[-1] ** 0.5 - unnorm_weights = torch.einsum("bjk,bik->bij", k, q) / scale - weights = torch.softmax(unnorm_weights, dim=-1) - - rep = torch.einsum("bik,bkj->bij", weights, v) - return rep - - def _multihead_attention(self, k, v, q): - outs = [] - for i in range(self.n_heads): - k_ = self._W_k[i](k) - v_ = self._W_v[i](v) - q_ = self._W_q[i](q) - out = self._dot_attention(k_, v_, q_) - outs.append(out) - outs = torch.stack(outs, dim=-1) - outs = outs.view(outs.shape[0], outs.shape[1], -1) - rep = self._W(outs) - return rep - - def _pytorch_multihead_attention(self, k, v, q): - # Pytorch multiheaded attention takes inputs if diff order and permutation - q = q.permute(1, 0, 2) - k = k.permute(1, 0, 2) - v = v.permute(1, 0, 2) - o = self._W(q, k, v)[0] - return o.permute(1, 0, 2) - - -class LatentEncoder(nn.Module): - def __init__( - self, - input_dim, - hidden_dim=32, - latent_dim=32, - self_attention_type="dot", - n_encoder_layers=3, - min_std=0.01, - batchnorm=False, - dropout=0, - attention_dropout=0, - use_lvar=False, - use_self_attn=False, - attention_layers=2, - use_lstm=False - ): - super().__init__() - # self._input_layer = nn.Linear(input_dim, hidden_dim) - if use_lstm: - self._encoder = LSTMBlock(input_dim, hidden_dim, batchnorm=batchnorm, dropout=dropout, num_layers=n_encoder_layers) - else: - self._encoder = BatchMLP(input_dim, hidden_dim, batchnorm=batchnorm, dropout=dropout, num_layers=n_encoder_layers) - if use_self_attn: - self._self_attention = Attention( - hidden_dim, - self_attention_type, - attention_layers, - rep="identity", - dropout=attention_dropout, - ) - self._penultimate_layer = nn.Linear(hidden_dim, hidden_dim) - self._mean = nn.Linear(hidden_dim, latent_dim) - self._log_var = nn.Linear(hidden_dim, latent_dim) - self._min_std = min_std - self._use_lvar = use_lvar - self._use_lstm = use_lstm - self._use_self_attn = use_self_attn - - def forward(self, x, y): - encoder_input = torch.cat([x, y], dim=-1) - - # Pass final axis through MLP - encoded = self._encoder(encoder_input) - - # Aggregator: take the mean over all points - if self._use_self_attn: - attention_output = self._self_attention(encoded, encoded, encoded) - mean_repr = attention_output.mean(dim=1) - else: - mean_repr = encoded.mean(dim=1) - - # Have further MLP layers that map to the parameters of the Gaussian latent - mean_repr = torch.relu(self._penultimate_layer(mean_repr)) - - # Then apply further linear layers to output latent mu and log sigma - mean = self._mean(mean_repr) - log_var = self._log_var(mean_repr) - - if self._use_lvar: - # Clip it in the log domain, so it can only approach self.min_std, this helps avoid mode collapase - # 2 ways, a better but untested way using the more stable log domain, and the way from the deepmind repo - log_var = F.logsigmoid(log_var) - log_var = torch.clamp(log_var, np.log(self._min_std), -np.log(self._min_std)) - sigma = torch.exp(0.5 * log_var) - else: - sigma = self._min_std + (1 - self._min_std) * torch.sigmoid(log_var * 0.5) - dist = torch.distributions.Normal(mean, sigma) - return dist, log_var - - -class DeterministicEncoder(nn.Module): - def __init__( - self, - input_dim, - x_dim, - hidden_dim=32, - n_d_encoder_layers=3, - self_attention_type="dot", - cross_attention_type="dot", - use_self_attn=False, - attention_layers=2, - batchnorm=False, - dropout=0, - attention_dropout=0, - use_lstm=False, - ): - super().__init__() - self._use_self_attn = use_self_attn - # self._input_layer = nn.Linear(input_dim, hidden_dim) - if use_lstm: - self._d_encoder = LSTMBlock(input_dim, hidden_dim, batchnorm=batchnorm, dropout=dropout, num_layers=n_d_encoder_layers) - else: - self._d_encoder = BatchMLP(input_dim, hidden_dim, batchnorm=batchnorm, dropout=dropout, num_layers=n_d_encoder_layers) - if use_self_attn: - self._self_attention = Attention( - hidden_dim, - self_attention_type, - attention_layers, - rep="identity", - dropout=attention_dropout, - ) - self._cross_attention = Attention( - hidden_dim, - cross_attention_type, - x_dim=x_dim, - attention_layers=attention_layers, - ) - - def forward(self, context_x, context_y, target_x): - # Concatenate x and y along the filter axes - d_encoder_input = torch.cat([context_x, context_y], dim=-1) - - # Pass final axis through MLP - d_encoded = self._d_encoder(d_encoder_input) - - if self._use_self_attn: - d_encoded = self._self_attention(d_encoded, d_encoded, d_encoded) - - # Apply attention as mean aggregation - h = self._cross_attention(context_x, d_encoded, target_x) - - return h - - -class Decoder(nn.Module): - def __init__( - self, - x_dim, - y_dim, - hidden_dim=32, - latent_dim=32, - n_decoder_layers=3, - use_deterministic_path=True, - min_std=0.01, - use_lvar=False, - batchnorm=False, - dropout=0, - use_lstm=False, - ): - super(Decoder, self).__init__() - self._target_transform = nn.Linear(x_dim, hidden_dim) - if use_deterministic_path: - hidden_dim_2 = 2 * hidden_dim + latent_dim - else: - hidden_dim_2 = hidden_dim + latent_dim - - if use_lstm: - self._decoder = LSTMBlock(hidden_dim_2, hidden_dim_2, batchnorm=batchnorm, dropout=dropout, num_layers=n_decoder_layers) - else: - self._decoder = BatchMLP(hidden_dim_2, hidden_dim_2, batchnorm=batchnorm, dropout=dropout, num_layers=n_decoder_layers) - self._mean = nn.Linear(hidden_dim_2, y_dim) - self._std = nn.Linear(hidden_dim_2, y_dim) - self._use_deterministic_path = use_deterministic_path - self._min_std = min_std - self._use_lvar = use_lvar - - def forward(self, r, z, target_x): - # concatenate target_x and representation - x = self._target_transform(target_x) - - if self._use_deterministic_path: - z = torch.cat([r, z], dim=-1) - - r = torch.cat([z, x], dim=-1) - - r = self._decoder(r) - - # Get the mean and the variance - mean = self._mean(r) - log_sigma = self._std(r) - - # Bound or clamp the variance - if self._use_lvar: - log_sigma = torch.clamp(log_sigma, math.log(self._min_std), -math.log(self._min_std)) - sigma = torch.exp(log_sigma) - else: - sigma = self._min_std + (1 - self._min_std) * F.softplus(log_sigma) - - dist = torch.distributions.Normal(mean, sigma) - return dist, log_sigma