From 048796350cdcd29a7828208c8a1abde8da55f134 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jonas=20K=C3=B6hler?= Date: Fri, 7 May 2021 18:47:17 +0200 Subject: [PATCH 01/68] refactored compact flows --- bgflow/nn/flow/__init__.py | 3 +- bgflow/nn/flow/root_finding/__init__.py | 3 + bgflow/nn/flow/root_finding/approx_inverse.py | 114 ++++ bgflow/nn/flow/root_finding/bisection.py | 73 +++ bgflow/nn/flow/root_finding/newton.py | 90 +++ bgflow/nn/flow/transformer/__init__.py | 1 + .../nn/flow/transformer/compact/__init__.py | 1 + bgflow/nn/flow/transformer/compact/compact.py | 356 ++++++++++++ notebooks/__init__.py | 0 notebooks/compact/compact.ipynb | 534 ++++++++++++++++++ notebooks/toy_data/__init__.py | 1 + notebooks/toy_data/toy_data.py | 138 +++++ 12 files changed, 1313 insertions(+), 1 deletion(-) create mode 100644 bgflow/nn/flow/root_finding/__init__.py create mode 100644 bgflow/nn/flow/root_finding/approx_inverse.py create mode 100644 bgflow/nn/flow/root_finding/bisection.py create mode 100644 bgflow/nn/flow/root_finding/newton.py create mode 100644 bgflow/nn/flow/transformer/compact/__init__.py create mode 100644 bgflow/nn/flow/transformer/compact/compact.py create mode 100644 notebooks/__init__.py create mode 100644 notebooks/compact/compact.ipynb create mode 100644 notebooks/toy_data/__init__.py create mode 100644 notebooks/toy_data/toy_data.py diff --git a/bgflow/nn/flow/__init__.py b/bgflow/nn/flow/__init__.py index f4cf9bbd..0465e38d 100644 --- a/bgflow/nn/flow/__init__.py +++ b/bgflow/nn/flow/__init__.py @@ -4,6 +4,7 @@ from .estimator import * from .stochastic import * from .transformer import * +from .root_finding import * from .affine import * from .coupling import * @@ -19,4 +20,4 @@ from .triangular import * from .pppp import * from .diffeq import DiffEqFlow -from .cdf import * +from .cdf import * \ No newline at end of file diff --git a/bgflow/nn/flow/root_finding/__init__.py b/bgflow/nn/flow/root_finding/__init__.py new file mode 100644 index 00000000..d5de8a85 --- /dev/null +++ b/bgflow/nn/flow/root_finding/__init__.py @@ -0,0 +1,3 @@ +from .approx_inverse import * +from .bisection import * +from .newton import * \ No newline at end of file diff --git a/bgflow/nn/flow/root_finding/approx_inverse.py b/bgflow/nn/flow/root_finding/approx_inverse.py new file mode 100644 index 00000000..3fccc9b3 --- /dev/null +++ b/bgflow/nn/flow/root_finding/approx_inverse.py @@ -0,0 +1,114 @@ +import torch + +from bgflow.nn.flow.base import Flow +from bgflow.nn.flow.transformer import Transformer + +__all__ = [ + "DifferentiableApproximateInverse", + "WrapFlowWithInverse", + "TransformerToFlowAdapter", + "WrapTransformerWithInverse" +] + + +class DifferentiableApproximateInverse(torch.autograd.Function): + + @staticmethod + def forward(ctx, root_finder, bijection, y, *params): + + def callback(x): + y_, log_dy_dx = bijection(x) + return y_ - y, log_dy_dx + + with torch.no_grad(): + x, log_dx_dy = root_finder(callback, x0=y) + + ctx.save_for_backward(x, *params) + ctx.bijection = bijection + + return x, log_dx_dy + + @staticmethod + def backward(ctx, grad_out_x, grad_out_dlogp): + x, *params = ctx.saved_tensors + + with torch.enable_grad(): + x = x.detach().requires_grad_(True) + y, dlogp = ctx.bijection(x) + + force = torch.autograd.grad(-dlogp.sum(), x, create_graph=True)[0] + + grad_out_x = (-dlogp).exp() * grad_out_x + grad_out_dlogp = (-dlogp).exp() * grad_out_dlogp + + grad_in_y = grad_out_x + force * grad_out_dlogp + + grad_in_params = torch.autograd.grad( + [ + y, + y, + dlogp.exp() + ], + params, + grad_outputs=[ + -grad_out_x, + -force * grad_out_dlogp, + -grad_out_dlogp + ], + create_graph=True + ) + + return None, None, grad_in_y, *grad_in_params + + +class WrapFlowWithInverse(Flow): + + def __init__(self, flow, root_finder): + super().__init__() + self._flow = flow + self._root_finder = root_finder + + def _forward(self, x, *args, **kwargs): + return self._flow(x, *args, **kwargs) + + def _inverse(self, y, *args, **kwargs): + return DifferentiableApproximateInverse.apply( + self._root_finder, + self, + y, + *self.parameters() + ) + + +class TransformerToFlowAdapter(Flow): + + def __init__(self, transformer, x): + super().__init__() + self._transformer = transformer + self._x = x + + def _forward(self, y, *args, **kwargs): + return self._transformer(self._x.expand_as(y), y, *args, **kwargs) + + def _inverse(self, y, *args, **kwargs): + return self._transformer(self._x.expand_as(y), y, inverse=True, *args, **kwargs) + + +class WrapTransformerWithInverse(Transformer): + + def __init__(self, transformer, root_finder): + super().__init__() + self._transformer = transformer + self._root_finder = root_finder + + def _forward(self, x, y, *args, **kwargs): + return self._transformer(x, y, *args, **kwargs) + + def _inverse(self, x, y, *args, **kwargs): + flow = TransformerToFlowAdapter(self._transformer, x) + return DifferentiableApproximateInverse.apply( + self._root_finder, + flow, + y, + *flow.parameters() + ) \ No newline at end of file diff --git a/bgflow/nn/flow/root_finding/bisection.py b/bgflow/nn/flow/root_finding/bisection.py new file mode 100644 index 00000000..fdaa37ef --- /dev/null +++ b/bgflow/nn/flow/root_finding/bisection.py @@ -0,0 +1,73 @@ +import torch +import numpy as np + + +__all__ = [ + "BisectionRootFinder" +] + + +def bisection_inverse( + f, + x0=None, + left=None, + right=None, + abs_tol=1e-5, + max_iters=100, + verbose=False, + raise_exception=True, + *args, + **kwargs +): + if verbose: + print(f"Starting bisection search with abs_tol={abs_tol:.4} and {max_iters} iterations.") + assert (left is not None) or (x0 is not None), "either left or x0 has to be given" + assert (right is not None) or (x0 is not None), "either right or x0 has to be given" + if left is None: + left = torch.zeros_like(x0) + if right is None: + right = torch.ones_like(x0) + for i in range(max_iters): + x = (left + right) / 2. + fy, dfy = f(x, *args, **kwargs) + if verbose: + print(f"iteration: {i}/{max_iters}, error: {fy.abs().max().detach().cpu().numpy():.5}") + if torch.all(fy.abs() < abs_tol): + return x, -dfy + gt = fy > abs_tol + lt = fy < -abs_tol + right[gt] = x[gt] + left[lt] = x[lt] + if raise_exception: + raise ValueError(f"Root finding did not converge: error={fy.abs().max().detach().cpu().item():.5}") + else: + return x, -dfy + + +class BisectionRootFinder(torch.nn.Module): + + def __init__( + self, + abs_tol=torch.tensor(1e-5), + max_iters=100, + verbose=False, + raise_exception=True + ): + super().__init__() + self._max_iters = max_iters + self.register_buffer("_abs_tol", abs_tol) + self._verbose=verbose + self._raise_exception=raise_exception + + def forward(self, callback, x0): + left = torch.zeros_like(x0) + right = torch.ones_like(x0) + return bisection_inverse( + callback, + left=left, + right=right, + abs_tol=self._abs_tol, + max_iters=self._max_iters, + verbose=self._verbose, + raise_exception=self._raise_exception + ) \ No newline at end of file diff --git a/bgflow/nn/flow/root_finding/newton.py b/bgflow/nn/flow/root_finding/newton.py new file mode 100644 index 00000000..7a8d2787 --- /dev/null +++ b/bgflow/nn/flow/root_finding/newton.py @@ -0,0 +1,90 @@ +import torch +import numpy as np + + +__all__ = [ + "NewtonRaphsonRootFinder" +] + + +# TODO this is not really working so far! +def newton_raphson_inverse( + f, + x0, + abs_tol=1e-6, + max_iters=100, + verbose=False, + max_step=0.1, + min_step=0., + step_shrink=0.9, + log_derivative=True, + raise_exception=True +): + x = x0 + last_val = None + max_step = torch.ones_like(x) * max_step + + for i in range(max_iters): + fy, dfy = f(x) + if last_val is not None: + max_step=torch.where( + fy.abs() > last_val.abs(), + (max_step * step_shrink).clamp_min(min_step), + max_step + ) + max_step = (max_step * step_shrink).clamp_min(min_step) + if verbose: + if verbose <= 1: + print(f"iteration: {i}, error: {(fy).abs().max().item()}") + else: + print(f"iteration: {i}, x: {x.detach().cpu().numpy()}, f(x): {fy.detach().cpu().numpy()}") + if fy.abs().max().item() < abs_tol: + return x, -dfy + else: + dfy = (-dfy).exp() + step = fy * dfy.expand_as(x) + step = torch.where( + step.abs() > max_step, + step.sign() * max_step, + step + ) + x = x - step + x = x.clamp(0, 1) + + last_val = fy + if raise_exception: + raise ValueError(f"Root finding did not converge: error={fy.abs().max().item()}") + else: + return x, -dfy + + +class NewtonRaphsonRootFinder(torch.nn.Module): + + def __init__( + self, + abs_tol=torch.tensor(1e-6), + max_iters=100, + max_step=torch.tensor(0.1), + step_shrink=torch.tensor(0.9), + verbose=False, + raise_exception=True + ): + super().__init__() + self._max_iters = max_iters + self.register_buffer("_abs_tol", abs_tol) + self.register_buffer("_max_step", max_step) + self.register_buffer("_step_shrink", step_shrink) + self._verbose=verbose + self._raise_exception=raise_exception + + def forward(self, callback, x0): + return newton_raphson_inverse( + callback, + x0, + abs_tol=self._abs_tol, + max_iters=self._max_iters, + max_step=self._max_step, + step_shrink=self._step_shrink, + verbose=self._verbose, + raise_exception=self._raise_exception + ) \ No newline at end of file diff --git a/bgflow/nn/flow/transformer/__init__.py b/bgflow/nn/flow/transformer/__init__.py index 25e05f0c..6d75e919 100644 --- a/bgflow/nn/flow/transformer/__init__.py +++ b/bgflow/nn/flow/transformer/__init__.py @@ -2,3 +2,4 @@ from .affine import * from .entropy_scaling import * from .spline import * +from .compact import * \ No newline at end of file diff --git a/bgflow/nn/flow/transformer/compact/__init__.py b/bgflow/nn/flow/transformer/compact/__init__.py new file mode 100644 index 00000000..c569fba3 --- /dev/null +++ b/bgflow/nn/flow/transformer/compact/__init__.py @@ -0,0 +1 @@ +from .compact import * \ No newline at end of file diff --git a/bgflow/nn/flow/transformer/compact/compact.py b/bgflow/nn/flow/transformer/compact/compact.py new file mode 100644 index 00000000..de42b409 --- /dev/null +++ b/bgflow/nn/flow/transformer/compact/compact.py @@ -0,0 +1,356 @@ +from functools import partial +from typing import Callable + +import torch +import numpy as np + +from bgflow.nn.flow.transformer.base import Transformer + + +__all__ =[ + "SmoothRamp", + "PowerRamp", + "AffineSigmoidTransformer", + "MixtureCDFTransformer", + "ConstrainedSigmoidTransformer", + "ConstantConstrainedSigmoidTransformer", + "ConstrainedBoundaryCDFTransformer" +] + +# TODO: docstrings and tests! + +def polynomial_ramp(x, power=3): + rx = torch.relu(x) + ramp = rx.pow(power) + grad = power * rx.pow(power - 1) + return ramp, grad + + +_SMOOTH_RAMP_INFLECTION_ALPHA_2 = 0.3052033 + +def smooth_ramp_pow2(x, alpha, unimodal=True, eps=1e-8): + if unimodal: + alpha = alpha + _SMOOTH_RAMP_INFLECTION_ALPHA_2 + xinv = x.clamp_min(eps).reciprocal() + arg = xinv.pow(2).neg() + ramp = ((1 + arg) * alpha).exp() + + grad_arg = xinv.pow(3) * 2 + grad = ramp * grad_arg * alpha + + return ramp, grad + + +_SMOOTH_RAMP_INFLECTION_ALPHA_1 = 0.8656721 + +def smooth_ramp_pow1(x, alpha, unimodal=True, eps=1e-8): + if unimodal: + alpha = alpha + _SMOOTH_RAMP_INFLECTION_ALPHA_1 + xinv = x.clamp_min(eps).reciprocal() + arg = xinv.neg() + ramp = ((1 + arg) * alpha).exp() + + grad_arg = xinv.pow(2) + grad = ramp * grad_arg * alpha + + return ramp, grad + + +def generalized_sigmoid_transform(x, ramp): + (fx, fx_), (dfx, dfx_) = ramp(torch.stack([x, 1.0 - x], dim=0)) + denom_recip = (fx + fx_).reciprocal() + cdf = fx * denom_recip + numer = (dfx * fx_ + fx * dfx_) + pdf = numer * denom_recip.pow(2) + + return cdf, pdf + + +def affine_sigmoid_transform(x, ramp, mu, log_sigma, min_density, periodic=True): + sigma = log_sigma.exp() + inv_sigma = (-log_sigma).exp() + + mu = (mu - 0.5 * inv_sigma) + if periodic: + mu = mu % 1 + + diff = x - mu + + zs = torch.stack([diff, -mu, 1 - mu], dim=0) + if periodic: + zs = zs % 1 + + zs = zs * sigma + + (y, y0, y1), (pdf, *_) = generalized_sigmoid_transform( + zs, + ramp=ramp + ) + pdf = pdf * sigma + + y = y - y0 + + if periodic: + offset = diff.floor() + offset += torch.where(mu != 0., torch.ones_like(offset), torch.zeros_like(offset)) + y = y + offset + else: + scale = 1. / (y1 - y0) + y = y * scale + pdf = pdf * scale + + # regularize cdf and compute log density + y = y * (1. - min_density) + min_density * x + log_pdf = torch.log(pdf * (1. - min_density) + min_density) + + return y, log_pdf + + +def mixture_cdf_transform(cdfs, log_pdfs, log_weights): + + weights = log_weights.exp() + + y = (cdfs * weights).sum(dim=-1) + + log_pdf = torch.logsumexp( + log_pdfs + log_weights, + dim=-1 + ) + + return y, log_pdf + + +class ConditionalRamp(torch.nn.Module): + + def forward(self, y, cond): + raise NotImplementedError() + + +class PowerRamp(ConditionalRamp): + + def __init__(self, power: torch.Tensor): + super().__init__() + self.register_buffer("_power", power) + + def forward(self, y, cond): + return polynomial_ramp(y, self._power) + + +class SmoothRamp(ConditionalRamp): + + def __init__( + self, + compute_alpha: Callable, + unimodal: bool=True, + eps: torch.Tensor=torch.tensor(1e-8), + alpha_constraint: Callable=torch.nn.functional.softplus, + ramp_type: str="type1" + ): + super().__init__() + + assert ramp_type in ["type1", "type2"] + if ramp_type == "type1": + self._ramp_fn = smooth_ramp_pow1 + elif ramp_type == "type2": + self._ramp_fn = smooth_ramp_pow2 + + self._compute_alpha = compute_alpha + self._unimodal = unimodal + self.register_buffer("_eps", eps) + self._alpha_constraint = alpha_constraint + + + def forward(self, y, cond): + alpha = self._alpha_constraint(self._compute_alpha(cond)).view(*cond.shape, -1) + return self._ramp_fn(y, alpha, unimodal=self._unimodal, eps=self._eps) + + +class AffineSigmoidTransformer(Transformer): + + def __init__( + self, + conditional_ramp: ConditionalRamp, + compute_params: torch.nn.Module, + min_density=torch.tensor(1e-4), + periodic=True, + zero_boundary_left=False, + zero_boundary_right=False + ): + super().__init__() + self._conditional_ramp = conditional_ramp + self._param_net = compute_params + self.register_buffer("_min_density_lower_bound", min_density) + + self._periodic = periodic + self._zero_boundary_left = zero_boundary_left + self._zero_boundary_right = zero_boundary_right + + + def _compute_params(self, cond): + params = self._param_net(cond) + mu, log_sigma, min_density = params.chunk(3, dim=-1) + + if self._zero_boundary_right: + # avoid that any mu is placed on 1 + mu = mu = mu.view(*cond.shape, -1) + mu = torch.cat([ + mu, + mu[..., [-1]] + ], dim=-1) + mu = mu.view(*cond.shape, -1).softmax(dim=-1).cumsum(dim=-1) + mu = mu[..., :-1] + else: + mu = mu.view(*cond.shape, -1).softmax(dim=-1).cumsum(dim=-1) + + log_sigma = log_sigma.view(*cond.shape, -1) + if self._periodic or self._zero_boundary_right or self._zero_boundary_left: + # if boundary constraint exist assert that sigma in [1, \infty] + log_sigma = torch.nn.functional.softplus(log_sigma) + min_value = torch.tensor(1.).to(cond) + if self._zero_boundary_left: + min_value = torch.minimum(mu, min_value) + if self._zero_boundary_right: + min_value = torch.minimum(1. - mu, min_value) + log_sigma = log_sigma - min_value.log() + + # min density in [lb, 1] + lower_bound = self._min_density_lower_bound.expand_as(min_density) + if not (self._zero_boundary_right or self._zero_boundary_left): + lower_bound = lower_bound + min_density.sigmoid() * (1. - self._min_density_lower_bound) + + lower_bound = lower_bound.view(*cond.shape, -1) + + return mu, log_sigma, lower_bound + + def _forward(self, x, y, *args, **kwargs): + + mu, log_sigma, min_density = self._compute_params(cond=x) + + # condition ramp with inputs (necessary for smooth ramps with trainable alpha) + ramp = partial(self._conditional_ramp, cond=x) + + y = y.unsqueeze(-1) + + return affine_sigmoid_transform( + y, ramp, mu, log_sigma, min_density, periodic=self._periodic + ) + + def _inverse(self, x, y, *args, **kwargs): + raise NotImplementedError("No analytic inverse") + + +class MixtureCDFTransformer(Transformer): + + def __init__( + self, + compute_components: Callable, + compute_weights: Callable, + ): + super().__init__() + self._compute_components = compute_components + self._compute_weights = compute_weights + + def _forward(self, x, y, return_log_density=True): + cdfs, log_pdfs = self._compute_components(x, y) + log_weights = self._compute_weights(x).view(*x.shape, -1).log_softmax(dim=-1) + return mixture_cdf_transform(cdfs, log_pdfs, log_weights) + + def _inverse(self, x, y): + raise NotImplementedError("No analytic inverse") + + +class ConstrainedSigmoidTransformer(Transformer): + + def __init__(self, compute_params: Callable, smoothness_type: str="type1"): + super().__init__() + assert smoothness_type in ["type1", "type2"] + if smoothness_type == "type1": + self._k = 1 + self._alpha_offset = _SMOOTH_RAMP_INFLECTION_ALPHA_1 + self._ramp_fn = smooth_ramp_pow1 + elif smoothness_type == "type2": + self._k = 2 + self._alpha_offset = _SMOOTH_RAMP_INFLECTION_ALPHA_2 + self._ramp_fn = smooth_ramp_pow2 + self._param_net = compute_params + + def _compute_params(self, x): + params = self._param_net(x) + mu, log_sigma, log_pdf_constraint = params.view(*x.shape, -1).chunk(3, dim=-1) + log_sigma = torch.nn.functional.softplus(log_sigma) + log_pdf_constraint = log_pdf_constraint + return mu, log_sigma, log_pdf_constraint + + def _forward(self, x, y): + mu, log_sigma, log_pdf_constraint = self._compute_params(x) + alpha = ( + log_pdf_constraint.exp() / (torch.tensor(2.).to(x).pow(self._k + 1) * self._k * log_sigma.exp()) + ) - self._alpha_offset + ramp = partial(self._ramp_fn , alpha=alpha, unimodal=True) + + min_density = torch.zeros_like(y).unsqueeze(-1) + return affine_sigmoid_transform( + y.unsqueeze(-1), ramp, mu, log_sigma, min_density, periodic=False + ) + + def _inverse(self, x, y, *args, **kwargs): + raise NotImplementedError("No analytic inverse") + + +class ConstantConstrainedSigmoidTransformer(ConstrainedSigmoidTransformer): + + def __init__(self, mu=torch.tensor([0.]), log_pdf_constraint=torch.tensor([np.log(4.)]), smoothness_type: str="type1"): + super().__init__(compute_params=None, smoothness_type=smoothness_type) + self._mu = mu + self._log_sigma = torch.nn.Parameter(torch.zeros_like(mu)) + self._log_pdf_constraint = log_pdf_constraint + + def _compute_params(self, x): + mu = self._mu.expand(*x.shape, self._mu.shape[-1]) + log_sigma = torch.nn.functional.softplus(self._log_sigma).expand(*x.shape, self._log_sigma.shape[-1]) + log_pdf_constraint = self._log_pdf_constraint.expand(*x.shape, self._log_pdf_constraint.shape[-1]) + return mu, log_sigma, log_pdf_constraint + + +class ConstrainedBoundaryCDFTransformer(Transformer): + + def __init__(self, transformer: Transformer, compute_constraints, left_constraint=True, right_constraint=True, smoothness_type: str="type1"): + super().__init__() + self._transformer = transformer + self._compute_constraints = compute_constraints + self._mixture = MixtureCDFTransformer( + compute_components=self._compute_components, + compute_weights=self._compute_weights + ) + self._constrained_cdfs = ConstrainedSigmoidTransformer( + compute_params=self._compute_constrained_params, + smoothness_type=smoothness_type + ) + self._n_constraints = sum([left_constraint, right_constraint]) + self._log_sigma = torch.nn.Parameter(torch.zeros(self._n_constraints)) + self._left_constraint = left_constraint + self._right_constraint = right_constraint + + def _compute_constrained_params(self, x): + mu = [] + if self._left_constraint: + mu.append(torch.zeros_like(x)) + if self._right_constraint: + mu.append(torch.ones_like(x)) + mu = torch.stack(mu, dim=-1) + log_sigma = self._log_sigma.expand(*x.shape, self._n_constraints) + log_pdf_constraint = self._compute_constraints(x).view(*x.shape, self._n_constraints) + np.log(self._n_constraints + 1) + return torch.cat([mu, log_sigma, log_pdf_constraint], dim=-1) + + def _compute_components(self, x, y): + boundary_cdfs, boundary_pdfs = self._constrained_cdfs(x, y) + center_cdf, center_pdf = self._transformer(x, y) + cdfs = torch.cat([boundary_cdfs, center_cdf.unsqueeze(-1)], dim=-1) + pdfs = torch.cat([boundary_pdfs, center_pdf.unsqueeze(-1)], dim=-1) + return cdfs, pdfs + + def _compute_weights(self, x): + return torch.zeros(*x.shape, self._n_constraints + 1, device=x.device, dtype=x.dtype) + + def _forward(self, x, y): + return self._mixture(x, y) \ No newline at end of file diff --git a/notebooks/__init__.py b/notebooks/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/notebooks/compact/compact.ipynb b/notebooks/compact/compact.ipynb new file mode 100644 index 00000000..e45ac837 --- /dev/null +++ b/notebooks/compact/compact.ipynb @@ -0,0 +1,534 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import torch\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Some helper" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "from bgflow import (\n", + " DenseNet,\n", + " \n", + " WrapTransformerWithInverse,\n", + " MixtureCDFTransformer,\n", + " AffineSigmoidTransformer,\n", + " SmoothRamp,\n", + " BisectionRootFinder,\n", + " \n", + " ConstrainedBoundaryCDFTransformer,\n", + " \n", + " SequentialFlow,\n", + " CouplingFlow,\n", + " SplitFlow,\n", + " InverseFlow,\n", + " SwapFlow\n", + ")\n", + " \n", + "from toy_data.toy_data import dataset_names, inf_train_gen\n", + "\n", + "from matplotlib.colors import LogNorm\n", + "\n", + "\n", + "def plot_transformer_density(transformer, label, grid_size=100):\n", + " with torch.enable_grad():\n", + " ys = torch.linspace(0, 1, 100).view(-1, 1).requires_grad_(True)\n", + " xs = torch.zeros_like(ys)\n", + " ys_, dlogp_ = transformer(xs, ys)\n", + " computed_density = dlogp_.exp()\n", + " ad_density = torch.autograd.grad(ys_.sum(), ys, create_graph=True)[0]\n", + " \n", + " plt.figure(figsize=(10, 3))\n", + " plt.title(label)\n", + " plt.plot(ys.detach(), ys_.detach(), label=\"cdf\")\n", + " plt.plot(ys.detach(), computed_density.detach(), alpha=0.5, label=\"computed pdf\")\n", + " plt.plot(ys.detach(), ad_density.detach(), linestyle=\"--\", label=\"AD pdf\")\n", + " plt.legend()\n", + " \n", + "\n", + "def make_transformer(\n", + " d_in,\n", + " d_out,\n", + " d_hidden,\n", + " n_components,\n", + " periodic=False,\n", + " zero_boundary_left=False,\n", + " zero_boundary_right=False,\n", + " activation=torch.nn.SiLU(),\n", + " smoothness_type=\"type1\"\n", + "):\n", + " return WrapTransformerWithInverse(\n", + " transformer=MixtureCDFTransformer(\n", + " compute_weights=DenseNet([d_in, d_hidden, d_hidden, d_out * n_components], activation),\n", + " compute_components=AffineSigmoidTransformer(\n", + " conditional_ramp=SmoothRamp(\n", + " compute_alpha=DenseNet([d_in, d_hidden, d_hidden, d_out * n_components], activation),\n", + " unimodal=True,\n", + " ramp_type=smoothness_type\n", + " ),\n", + " compute_params=DenseNet([d_in, d_hidden, d_hidden, d_out * (3 * n_components)], activation),\n", + " min_density=torch.tensor(1e-4),\n", + " periodic=periodic,\n", + " zero_boundary_left=zero_boundary_left,\n", + " zero_boundary_right=zero_boundary_right\n", + " \n", + " ),\n", + " ),\n", + " root_finder=BisectionRootFinder(abs_tol=torch.tensor(1e-5), max_iters=100, verbose=True, raise_exception=True)\n", + " )\n", + "\n", + "\n", + "def make_constrained_transformer(transformer, left_bound=None, right_bound=None, smoothness_type=\"type1\"):\n", + " def compute_constraints(x):\n", + " bounds = []\n", + " if left_bound is not None:\n", + " bounds.append(torch.tensor([left_bound]).log().expand_as(x))\n", + " if right_bound is not None:\n", + " bounds.append(torch.tensor([right_bound]).log().expand_as(x))\n", + " return torch.stack(bounds, dim=-1)\n", + " \n", + " return ConstrainedBoundaryCDFTransformer(\n", + " transformer=transformer,\n", + " compute_constraints=compute_constraints,\n", + " left_constraint=left_bound is not None,\n", + " right_constraint=right_bound is not None,\n", + " smoothness_type=smoothness_type\n", + " )\n", + "\n", + "\n", + "def make_coupling_flow(transformer_factory): \n", + " return SequentialFlow([\n", + " SplitFlow(1),\n", + " CouplingFlow(transformer_factory()),\n", + " SwapFlow(),\n", + " CouplingFlow(transformer_factory()),\n", + " SwapFlow(),\n", + " CouplingFlow(transformer_factory()),\n", + " SwapFlow(),\n", + " CouplingFlow(transformer_factory()),\n", + " SwapFlow(),\n", + " InverseFlow(SplitFlow(1))\n", + " ])\n", + "\n", + "def train(flow, dataset=\"pinwheel\", train_with_inverse=False, batch_size=1_000, learning_rate=1e-3, n_iters=1_000, print_interval=100):\n", + " optim = torch.optim.Adam(flow.parameters(), lr=learning_rate)\n", + " for it in range(n_iters):\n", + " x = (inf_train_gen(dataset, batch_size=batch_size) + 4) / 8\n", + " x = torch.FloatTensor(x) % 1 \n", + " y, dlogp = flow(x, inverse=train_with_inverse) \n", + " nll = -dlogp.mean() \n", + " optim.zero_grad()\n", + " nll.backward()\n", + " optim.step()\n", + " if not it % print_interval: \n", + " print(f\"it: {it}/{n_iters}, nll: {nll.item():.4}\", end=\"\\r\")\n", + " \n", + "\n", + " \n", + "def plot_evaluation(flow, dataset=\"pinwheel\", train_with_inverse=False, n_samples=100_000):\n", + " \n", + " print(\"Computing energy plot...\")\n", + " with torch.no_grad():\n", + " xs = torch.meshgrid(\n", + " torch.linspace(0, 1, 100),\n", + " torch.linspace(0, 1, 100)\n", + " )\n", + " xs = torch.stack(xs, dim=-1).view(-1, 2)\n", + " ys, dlogp = flow(xs, inverse=train_with_inverse)\n", + " u = -dlogp\n", + " u = u.view(100, 100)\n", + " \n", + " norm = LogNorm()\n", + " plt.figure(figsize=(8, 8))\n", + " plt.title(\"Energy\")\n", + " plt.imshow((-u).exp().detach(), norm=norm)\n", + " \n", + " print(\"Sampling ground truth...\")\n", + " norm = LogNorm()\n", + " x = (inf_train_gen(dataset, batch_size=n_samples) + 4) / 8\n", + " x = torch.FloatTensor(x) % 1\n", + " plt.figure(figsize=(8, 8))\n", + " plt.title(\"Ground truth samples\")\n", + " plt.hist2d(*x.detach().numpy().T, bins=100, density=True, norm=norm, range=((0, 1), (0, 1)));\n", + " \n", + " print(\"Sampling model...\")\n", + " norm = LogNorm()\n", + " with torch.no_grad():\n", + " z = torch.rand(n_samples, 2)\n", + " x, _ = flow(z, inverse=not train_with_inverse)\n", + " plt.figure(figsize=(8, 8))\n", + " plt.title(\"Flow samples\")\n", + " plt.hist2d(*x.detach().numpy().T, bins=100, density=True, norm=norm, range=((0, 1), (0, 1)));" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## How to create compact transformers" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "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" + } + ], + "source": [ + "plot_transformer_density(\n", + " make_transformer(d_in=1, d_out=1, d_hidden=40, n_components=4, periodic=False, zero_boundary_left=False, zero_boundary_right=False),\n", + " label=\"no constraints, non-periodic\"\n", + ")\n", + "\n", + "plot_transformer_density(\n", + " make_transformer(d_in=1, d_out=1, d_hidden=40, n_components=4, periodic=True, zero_boundary_left=False, zero_boundary_right=False),\n", + " label=\"no constraints, periodic\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Zero density constraint at boundary" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "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" + } + ], + "source": [ + "plot_transformer_density(\n", + " make_transformer(d_in=1, d_out=1, d_hidden=40, n_components=4, periodic=False, zero_boundary_left=True, zero_boundary_right=False),\n", + " label=\"left boundary is zero\"\n", + ")\n", + "\n", + "plot_transformer_density(\n", + " make_transformer(d_in=1, d_out=1, d_hidden=40, n_components=4, periodic=False, zero_boundary_left=False, zero_boundary_right=True),\n", + " label=\"right boundary is zero\"\n", + ")\n", + "\n", + "plot_transformer_density(\n", + " make_transformer(d_in=1, d_out=1, d_hidden=40, n_components=4, periodic=False, zero_boundary_left=True, zero_boundary_right=True),\n", + " label=\"both boundaries are zero\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Value constraint at boundary" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_transformer_density(\n", + " make_constrained_transformer(\n", + " make_transformer(d_in=1, d_out=1, d_hidden=40, n_components=4, periodic=False, zero_boundary_left=True, zero_boundary_right=False),\n", + " left_bound=5\n", + " ),\n", + " label=\"left boundary = 5\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_transformer_density(\n", + " make_constrained_transformer(\n", + " make_transformer(d_in=1, d_out=1, d_hidden=40, n_components=4, periodic=False, zero_boundary_left=False, zero_boundary_right=True),\n", + " right_bound=5\n", + " ),\n", + " label=\"right boundary = 5\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_transformer_density(\n", + " make_constrained_transformer(\n", + " make_transformer(d_in=1, d_out=1, d_hidden=40, n_components=4, periodic=False, zero_boundary_left=True, zero_boundary_right=True, smoothness_type=\"type1\"),\n", + " left_bound=3,\n", + " right_bound=5,\n", + " smoothness_type=\"type1\"\n", + " ),\n", + " label=\"left boundary =3, right boundary = 5\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Density Estimation Example" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "from functools import partial\n", + "\n", + "flow = make_coupling_flow(partial(make_transformer, d_in=1, d_out=1, d_hidden=200, n_components=20))" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "True\n", + "True\n", + "True\n" + ] + } + ], + "source": [ + "for block in flow._blocks:\n", + " if isinstance(block, CouplingFlow):\n", + " block.transformer._root_finder._verbose=True\n", + " print(block.transformer._root_finder._verbose)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "it: 900/1000, nll: -1.753\r" + ] + } + ], + "source": [ + "train(flow)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computing energy plot...\n", + "Sampling ground truth...\n", + "Sampling model...\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": "iVBORw0KGgoAAAANSUhEUgAAAesAAAHiCAYAAADI/ORpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABcWElEQVR4nO3deZRkV30n+O+NJSMzI5fItbKyNpW2KiGVNgohlWhAZoQE0zb2aRmDPTZm7NFosHvGwHDUpxna7oN7jMaNAHdbrcMwYDzuY4aRaTfdltGUsQy2ChmV1tJWqlItqqw998otMiPizh+ZkvJ3fzcrXkbFciPi+zlH5+hG3njx4r0XcaPu7/d+11hrQUREROGK1XoHiIiI6OI4WBMREQWOgzUREVHgOFgTEREFjoM1ERFR4DhYExERBY6DNVEVGWMuM8ZYY0yi1vtSScaY3zPG/Fmt94OoUTT0FwZRrRhjjgHYACC/6uGra7M3RFTv+C9rosr5WWttx6r/TtV6h4ioPnGwJqohY8ywMeb7xphxY8xhY8z/sPJ4qzFm3hjTv9L+34wxOWNM10r7940xX11jm79ujDlijLlgjDlqjPmVlcevMMb8rTFmzBgzaoz5j8aYzKrnHTPGfM4Y84IxZtYY838ZYzYYY/56ZVt/Y4zpWen75nT+vcaYU8aY08aYz17kfd5qjNlnjJk0xjxvjHl/sf0lordxsCaqrT8HMAJgGMA9AP53Y8wHrLULAJ4C8L6Vfu8FcBzA7avaP3I3ZoxJA/gjAB+y1nYC2APguTf/DOAPVl7rGgBbAPyes4l/BuBOLE/Z/yyAvwbwLwH0Y/n74n92+t8B4CoAHwTwL4wx/41nnzYB+CsAvw+gF8D/CuAvjDEDRfaXiFZwsCaqnL9c+ZfkpDHmL90/GmO2AHgPgPuttQvW2ucAfAPAr650+RGA960ko12P5UHtfcaYVgDvAvD3a7xuAcB1xpg2a+1pa+1LAGCtPWyt3WutzVprzwN4EG//GHjTv7PWnrXWnlzZ/j9aa5+11mYB/CcANzn9/7W1dtZaewDAtwB83LM//x2AR621j1prC9bavQD2A/jwxfaXiN7GwZqocn7eWptZ+e/nPX8fBjBurb2w6rHjADat/P+PALwfwM0ADgDYi+XB9VYAh621o+4GrbWzAH4JwH0AThtj/soYsxMAjDGDxpjvGGNOGmOmAfwZlv/FvNrZVf8/72l3OP1POPs+7Hmf2wD84qofLpNY/pGy8WL7S0Rv42BNVDunAPQaYzpXPbYVwMmV/98HYAeAXwDwI2vtyyt//2/hmQJ/k7X2MWvtnQA2AngVwP+58qc/AGABXG+t7cLyv3jNJb6HLc6++5LoTgD4v1f9cMlYa9PW2i8V2V8iWsHBmqhGrLUnsDwg/8FKQtn1AH4DwH9c+fscgKcB/BbeHpz3AfgfscZgvZIQ9nMrseAsgBm8fftY50p7ciWO/LkyvI0vGGPajTHXAvgkgP/H0+fPAPysMeYuY0x85b2+3xizucj+EtEKDtZEtfVxAJdh+V+k/wnA767EdN/0IwBJAD9d1e4E8OM1thcD8NmV7Y1jedr8Uyt/+9dYnlKfwnLC1/fKsP8/AnAYwA8B/Ftr7f/ndlj5UfIRLCeqncfyv7Q/t7KvF9tfIlphrLW13gciqjPGmMsAHAWQtNbmarw7RA2P/7ImIiIKXNHB2hjzTWPMOWPMi2v83Rhj/miloMMLxpiby7+bREREzSvKv6z/BMDdF/n7h7BcFOEqAPcC+A+XvltEFDJr7TFrreEUOFF1FB2srbU/xnLix1o+AuBP7bInAWSMMRvLtYNERETNrhwx602QhRFG8HZRByIiIrpE5Vgi01dUwZtiboy5F8tT5Uin0+/cuZOFiujSvfb0EfXY1e+8vAZ7Qs2qXNdglO0cPHRG9dlx1dC6X4tq4+mnnx611g6s93nlGKxHIKsYbYa/ihGstV8H8HUA2L17t92/f38ZXp6a3Z2xX1SP7d3//9ZgT6hZlesajLKdO+56QPV5/LH71/1aVBvGmOOlPK8c0+DfB/BrK1nhtwKYstaeLsN2iYiICBH+ZW2M+XMsLybQb4wZAfC7WK6oBGvtwwAexfLqOYcBzGG55CARERGVSdHB2lrrW/Ju9d8tlmsXU4O6+4YvqMd+8PwXRds3feezt7C+qcGo2yUqh7Wut/Vet0TlVo6YNRFRUyvXYB5lO4m9zPVpRiw3SkREFDgO1kRERIHjNDhV1eqYYHyX/z57Nx5OVGtuLLtaMWzmbNCbOFhTUVEGT/fLq1xfMkzsoWryXW+hDZj8TDQnToMTEREFjoM1ERFR4DgNTkII95lGmXbkVCBVQmhT3j5R6h64vGVMi3yGQvguoLdxsKaqKvULgqiWajVA5e7crR6Ln5mpwZ5QrXEanIiIKHAcrImIiALHwZqIiChwjFnTul1K4kmtiksQ+VQzRyJKkpfq44lZR912KJioVh4crEmo9QfIfX1f5itRJdX6M1BMtVa8C/04NBtOgxMREQWOgzUREVHgOA3e5EqKo61jW+V4/SjP45QdhSTkGDLVJw7WVJJiA3qUFbWifKHlD7xawt4RRVPtH3nrfb3JK1rKvs1qC33/6gWnwYmIiALHwZqIiChwHKyJiIgCx5h1E2HSC1FllJKE6VukoxG+kEtNGqWLa4Rrgy5RsQ9SlA9aKR/GSm2XqNZ8CZZRkiVzd+7G44/d/1abRYHoTZwGJyIiChwHayIiosBxGpxqplI1jak2QluwoVyx09BjsKHvH5UHB+smwg8wUWWsVQTI7bPeokDuoh31gN8zlcFpcCIiosBxsCYiIgocp8GbnO/WkHqceiOKIsrUc5Rp3FJvqYry+nfc9YBor76Vqx6FlstQrzhYU83ww9pYGvV8usVLUmdmVB/3HupLuc+ayIfT4ERERIHjYE1ERBQ4DtZERESBY8yaiCqmlIIdvue4MeDsUIdo++LIpVLJY85rVZu7PyElgDJ5rHo4WDe5kD74ROVUbID38Q36qTMz4nMSJRN8ekdGPZY+oPu5g1opWeahD4yh71+94DQ4ERFR4DhYExERBY7T4E2OiwBQFKXEkQH/F8y7PvmgaCdnrWin1797FXf9Z77y1v8Pl3G77rHoK8M2GUduTBysiahiZu+5VbSX0qboc87+zh712JIzgscWZXthQ496Tq8nRlzM2LW9RfucvV33yQzJYibz/XrScv6+PXj2oU+/1XYH6rWEnFfCHwDVw2lwIiKiwHGwJiIiChynwZuIu0AA4L8AyrXYQTGMrYXBdx7cqegN1dqZBnfTp96OfUf98nXPj/v5iPJ5LQU/n2HhYN3kcnfuFqv6VOqDT/UtShx5YbCg+sSWZIw635Mr+lqxaR3XLrTl5QN52SdxIa6eM3GNbOcGllSfllNJ0U5O6/1Z2CAT4Fom9P6d62wR7eE/3Kf6jN4nj2HHKb0/riiLf7i4GEhj4jQ4ERFR4DhYExERBY6DNRERUeAYs6aSsJhKGIqdB1+tafc+4f7y7xYFqFiiWqVep5Kv1Uw4WDeR1YlkIeAHOAwjn9fJY4s9Mqkq35FXfVr6FkQ7ltMTdddtOi3ap2e6VJ/puVbR7ts8q/fxuPxJYSD3zyZkGwDi8zIRrOeppOqTeV1WV5m8okX1aT/nPOfbOnkMkNfznZ4Es/6H94k+ez76ZdUn253Bvu9+9u3tlOnODCaO1j9OgxMREQWOgzUREVHgOA3ewHzxSrfOMKfHwuWev6j33JayJjJdump9lio5NV7K80oJZzGuvX4crKkk/GCFwS2AkTozI9oHfzOjnmM7ZDGO1u4F1WeoU8aNt3ZOqD5Hp+QaUS0JXfDk5dNDoj2YuaD6LB2Tq3WdgV69q3VGxp+Hn5Cx5plhXRSl75lx0Y7yY6d/b7QKYcX6uCuS+ayOTa/Ft51SCqWUwvcZr1Z1Q9I4DU5ERBQ4DtZERESB4zR4k6lUPJMxqEvjO35RplKpNqr1OSr1GmAuSnT1smAJB+sGlh2SsT83ngkAk5+4TbRzbXqRAgB49qFPl2/HKBI3NulboOHMLfK+4IXBjGjHBnU8+tbLjol2S0zHmnMFGQPe2jau+pyYka/VltALU2Q65kT77LNDqk/ceVr/83pBkNTUxRe9yHz7J+qxPJx7n0v8Unb/HmWgLldc2bedYvtbycGnXANYaANhPeA0OBERUeA4WBMREQWOgzUREVHgGLNuICpWVeNF6Jl0tjYmAFVHOY5zuZK+QhL1uPDzGg4O1g3MTSgbu7lH9el7Rha7cJPSoopSSILW5ib6AUDHKZlUdfzDeiGKwZ1ylYmr07LoyNZ2XcxkW9uoaBesnmAbz6XX3tkVbkLZ2ZlO1efCjFykw5e+uOnHssDJ2LV6MY30I/tF2022i1o8pByDT/7AqyUVTokipCSwZlEvx4vT4ERERIHjYE1ERBQ4ToPXKU4z1w8urBGOck1XR/n8lfJazPOgtXCwbmBujHpms44Y9j0j24m9+1WfUvALZn1852b8blms5KYtx1Wf9/a+JtrZgoxrb0zqmPVcISXaw54+T89tF+2xRZ3LcHysV7RtQb+Hrh+1q8dc2W75NdQxUtCLXDwoi/K4g5pbAMWn1B+4UfMxohRgCQU/n/WH0+BERESB42BNREQUOE6DE1FwyhG7rfZU9HpfL/Sp8npZ4KJZcLBuIKP37RHtvLzFFR0jVj2nUvei0tt897fP3S3PVdttY6pPX4u8/3h7Wve5vEXeZ31ty3nRvlDQH/FjuT7RfnFhs+ozsiD3ef/ZLapPbkTei50a1THrtlG5KEdqSi8aUkqeRKnXaKXuY2ZiGFUap8GJiIgCx8GaiIgocBysiYiIAseYdYBqnXjC+NulUUVQPDFrCkM9Xuv1uM906ThY1ynfwg9TO2QCWWJGJvzEF3QC0Oh9e/DsQ28XnKj1D4VmMX/jvGh3xvOqz89vel6039F6UvXZFJ8S7VkbF+2T+W71nOfntoq2m0wGAI+/fpVoF861qj6Zg/J6WuhTXZB+5En1WKWKl6z3dcqpVot2VFLo+9dsOA1OREQUOA7WREREgeM0OHGhiXWIMkXrW1uZ3latmGstY7ulFhQpxz77Ps9R6ikwFh62SIO1MeZuAF8DEAfwDWvtl5y/dwP4MwBbV7b5b6213yrzvjYN3wfE/QDm2nT8OZ+WBSc6jsvTm5jXRVH6npGLOMR37cQPnv9i5H0lLTskF70Yu1H32dgvY8039Ol49JbkuGi78WkAaI/JWPfLi4OifT7XqZ5zflE+9uTpbapP7w/aRNu9ToCIBXW+ePEFOHxCjzXXWj3uM126otPgxpg4gD8G8CEA7wDwcWPMO5xuvwXgZWvtDQDeD+DLxpiWMu8rERFRU4oSs74FwGFr7RFr7SKA7wD4iNPHAug0xhgAHQDGAei6gkRERLRuUabBNwE4sao9AuDdTp9/D+D7AE4B6ATwS9baAigSxoqoUYR+61+tP2vu65fy2rV+D8VE2b/Q30OIogzWOji6/C/p1e4C8ByAnwFwBYC9xpi/t9ZOiw0Zcy+AewFg69atoOimd2REe/Ia/VvIOA+lJuRpihp3pLW5Xyh33PWA6jN2rYwAdVyuj/vNfSOi/d5ufR52tpwV7S1x/VE8lJOv1RubEe0/OX+7es6LpzaKduFEu+rTMavzG8qlWl/KUQaIar12NV+fOSeNKco0+AiA1UvubMbyv6BX+ySA79llhwEcBaBSYq21X7fW7rbW7h4YGCh1n4mIiJpKlMH6KQBXGWO2rySNfQzLU96rvQHgAwBgjNkAYAeAI+XcUSIiomZVdBrcWpszxvw2gMewfOvWN621Lxlj7lv5+8MAvgjgT4wxB7A8bX6/tXa0gvtNRETUNCLdZ22tfRTAo85jD6/6/1MAPljeXWtu7/rkg6KdrNF+NLNSC1tQ9UUtBOJTjqSvSgo9aY+qgxXMAuB+ObgDNQBM7JARC9uxpPq0dGVFu+NU8VvdWQTl0rjJZABw4Z0Lon1l5wXV5z1dr4l2V2xe9Wl1MgbHCzrpK+7kf/5kTi7AcXxKL9KRW5SLfSTndeJa10GZFLfWwBfawFZMaElnISnX/kXZTujHIkSsDU5ERBQ4DtZERESB4zQ40YqoC5rs+eiX325s5u/dRlOpgh3VKgSy1nW83nAXczbCwsE6QL5FOhZ7nHjlgh4kcq0yFnnuRjee2ouXHvg0qHSz99wq2jPbdBy5p2dWtN8/cEj1yTuTWne26eq8EwXZ52xev9ZzC7K40OE5uZBHW1LnNswcaxXttF5DpO6K5fgGolIWDWEyF4WK/ywgIiIKHAdrIiKiwHEa/BI0QjH6RngPVDuh36NM1Cg4WAeobVQv0jGxy4lXdugYZ9tzbeoxxqijc+OeIpFsxdlbZT6B7c+qPrv6T4v2xuSk6nNr6xuiPVGIqz4FZ72cM/kO1WeuIPMSTs93ifbJo/3qOQOHiy/SMfmJ2/DUtz5z0T6hx3dL+eFQyR8b1br/uFx1E/jDKyycBiciIgocB2siIqLAcbAmIiIKHGPWAVCxP+de3nJum3Gotfli1M0s9Jh0vWPREVoPDtaXoFIfqhlfVay4k1BW0IVTlmRuEbZ9YV/R1+IXw/rkO/Ki3dqmi45sb5erwxagz1VvTH708tBJX5POwh0XCjqB8IWZLaJ9drZTtNOv64943zPj6jFXvRVFIWp0nAYnIiIKHAdrIiKiwHEavMoYBwyD9zyUMVeAomuEwjxR3kPUz34l8kyi7J+7AEipa5g3wvkMEQfrAGUzngfzTtwzqydFlrpkMRV30Qlan7Hr9DGOdy+I9sbMlOozmJwW7R0tp1UfN0Y9VcirPgeyQ6J92Gn7jE7Iwikpdy0XANkh2Sexd793W/yCJQoHp8GJiIgCx8GaiIgocJwGbzKlxJMaIQbFXIH1C/ke/Ua4JqMqdh5KPRbu8+K7dpawd6VppvNXLhysqyzKB8LqNR0QyyyKdmFRd2p37qlNTcnnrBWbpGVdBydFe2JHr+qTd477YNus6nNZy3nRbjE6Hj1n5WNLVt+LnYnPifbhuUHV5x9Gtot28pC8F7t1TD0FqTMz8oFdO9XiD9X8cdMIX9Khv4coA3z+wKtleR+hH4t6xWlwIiKiwHGwJiIiChwHayIiosAxZl1htUziIIqqERLw3KIeAFQsvhSlHptKxW6j7E/UAidUPzhYV5lbkALQCT+FpH5eflY+GJ/VCWbZvotv15dIFEUjJIwUq9YEAGM394j2Uqfqgk1DE6K9rV1ncC04J7Azsaj6LDnrdkwWUqrPIacIyom5jOozd6FVtLsm5d8zr+vXbsSiKPXwI7iUDO1SRD0WtTy/9XRthYLT4ERERIHjYE1ERBQ4ToPTuq01VcepLSqmlrFxX+ijmrHcSsXUy6XUxUiqGZtv5u8YDtYVFuXi2vPRL4t2rlMX0ejZOK0ecxV+KIt4+OLjtMx3bKa3y8IkvvNwflo+L7lB95n1xJ9d7Ua+VszYNXq+rcMT+46flyt1pCbkdsau1St5bPjqPvVYPX4Jrt7nSv8IKKXKXyl8i+/s++5ni75WNY8F1QanwYmIiALHwZqIiChwHKyJiIgCx5h1GdVj4lWzJHGo93nn7trsSKAadTW21fkgXZewndXJYb58B98XqZuL4nv9O+56QD7Qrbfk9inXl3aU2HapfUK7DhoBB+sATG2XExyZreNFn1Mo6FWaZrbJ5KINX63MKluN8EH0FQJJ3LhHtLPbc6pPb8eceszVl5DFaDpjBdWnAHn+5go6EewNp8qN+xxAr9A2Nyj7DD6nk9Jyd+7G44/d/1a71itsqQELEPsHFN9HXyGQ6R0Z0XaL3gBAcodM6HJXXovKlxjmcjPPc54fjOlHnizapxjfMS7nOa5WMlsjfM+UE6fBiYiIAsfBmoiIKHCcBq+CYvEu3KinQGltjJFdOl+BjnIoNi0adVo3yv7d9KmvvPX/GyJttXG5oQQ3jED1j4N1GfkGjChfOrm0bM+e1KkoN7zjuGgfPDeo+uTTskDHG7+3R/VxNesg54txdh+VseXF3TpmPT7TLp+TmFd9JvPyhM4VdA5C0imCsugGnz2OTvaqx5JTOo69mq8oyvAP5f7Ey7TAS6nxS7XgTASj98lr2xePjmK+P+a09TFuG5XXxcQOPSHpLvrSeUy/1szvyH1eSus+rVfIPr6FWMoVxy6HZv3+qAVOgxMREQWOgzUREVHgOA3eZEJfTKAcWBu5Onicw3X9Z74i2m7oY60FTKLcllWtqW/mpkgcrCvMTSjzxefyrTJO1tqv46Cu7f1j6rGXxzeLdvsZ+fcNTxS/f7selPqBXf08348W9373pQm9IMdN1x4T7e64vu/6suR50Z61no+Zs25Hi9ELgqRiMmaeXdLbWRiWfQafkLHvXJuOaZ+9vRfPPvRpvU9lUEocOzvUIRKifPddZ537oRPz8gBOXKPfZ3zB2caAPsaxxeKTi5O367ixK9Eitz25SecgxBIy9p042K76TF4j+yz06ZyDQlK2+16Uz5nZzAnTRsSzSkREFDgO1kRERIHjYE1ERBQ4xqyJqGxKLbYiYttcZKVmKlUshy4dB+sKcysJveuTD6o+uU6ZnNKe1MU4RudlBYXLu3SCWTy95DzC07sWXzZs4edkQQqT1RNPr40OiPaOzgHVJ+MknQ0lplQftwjK8wtbVZ+XLgzL7bbrxMPZZJtoZ3vkOe8Y0YuIlIubTOb7ovcV8Ci2SMfMsJNBBZ1AlrzgvM4GnQSW6MzKB0bbVJ/MVTLpsrtVH+PFvDymvs9ezC1yU9AJZj0t8rp4JrNF9Tk3Lqur2E36uyDrvI+zHfK1Ep4aM26iq5uwB+hFTEotllMuzZz57cNpcCIiosBxsCYiIgoc50nLKFKRiE/cVvkdWSd3vxt1+olFPN62esp6rQIZLve62PPRL4u2rmjvx/NQP6KsNe5iMZPK4GAdgNR5GXPqvDKr+lzZPbru7c5uku0jH+3Fa5+XxTAa8YvT98UQ5Qtk+7/7surjisdkDDjpKWbimizo4hdqu26VFADDbZOi/dMj2/QTCzKW68aol9K6WEjfMxNF96cU0zsy2Pfdz4rH3Di274fBWWeBi+mrPMc0Lo9Px7XToj3Q6lRAAZCKy3jvDVe8pLfreHfHYfXY+Zz8GdIX10Hh9pj8zBY8k5Z5K8/FdemTqs/EZpmbMuGu8gPgx+1XqMdWG53QK/sdHZDFVYYf18+b3pER7dSUjpdT7XAanIiIKHAcrImIiALX8NPgtS5GHxr31rGMp0+zxJzU+/yavp2F1qfUODbVj9Vx7FLWIqfSNPxgXU2+Ac2N2fniheO7eopuO2ZkLLIjru8r3bZB3v95dHFQtAf+Tt+/OvmJ2/DUtz7zVrsRY9hAtAUmNv69bJ/8oL5HeWFRHsNjc32qz5JzD/XVrWdUn9aYvCd+wbPYx7msvOfWXSwCAJZycnJs7DrZdhdzAaIt5BHlOnDj0+5ADeg46Llf2aP6mO2zoq2vUqCtVV7vXU6MemO7c+M1dMx/S0rfH31Zi8wFGYrre+IvS8rnpY1bzwDIwzh9iucyHPMsApNvkedvzurFZNz38ePxq0V7W5f+jtk/eqVon7pD50h0HZLX7dR2vYjI4HPFFzWp9f3ZjYrT4ERERIHjYE1ERBQ4DtZERESBq6uYNZPF6kep56pZkttqzc2liBJjLHrP9D1M0KNlxQot8XO+fnU1WJei1heA+yXoW8gjPSKTU85s0jm0V2fOifZQSifCnGmVzzuuEpJ8qTtSrY9XtcR37VSPuQVEep/RH4+Jd8ukm6dPb1Z9OrfK5KfXFwZVnyNz/aLdndQLSByakIuExOM64S12XO5PalL+vW1UP8ddsCEK3/Fy+YponHyv3L+4rl2CRIt83mCnThbrdRbY6GuRSWnv7DymntPpvJib+AcAvbH1ZzMnjU7O6nQSQC8U9KRlu9OnM6aLHw2o4ira5UmZFNcZk+/zQqFVPaflFnmMj033qj4nW51kySVdUOcc5PkcfE4XYEns3a8eo0vHaXAiIqLAcbAmIiIKXMNPg1Nxq6fmffeB++o5lzpdXqtFQ3xrLdPbGvX+eqJGUVeDdSPEU32D4ZGPyvhRb9es6jPsxKhTMV2Y4dquU6L9UtsG0U7O6gILvoUeyiHqYhpRnlcJbrEOAEjOylhktkcfm/iYjPvPZfXk1Ctd8rhf33NK9XGddwqgAMDkbFvR5y0OyVhkYlZ+pH3nd+zmnkiFcFafC9+PHXcBjtSEjuXmLpex5s2D+vrva5XFQfpS+vq/ufO4aLcat6iMzsfYlJCv5T5n+TF5/NpjupjJ+byMAS9Yfc7P5GSfLk88+mCuW7QHPAuCnHAW7rgqqQunxCD38Z2t8tjMeo7FcFIei8OdG1Sfl7uGRfvvX7tS9cml5fWV7dZDSDZComEjfJdXG6fBiYiIAsfBmoiIKHB1NQ1ej9wpxii3wNSDkKa0af0Yw6dqcuvGpx95UvXh98XFcbCusvyBV9VFec0XviLamTZ9z617j6gv/laIyYmSnrTczsgH9UL2HYfkJZDxJJMB8oNUajJSLT+M7v3uUQar1JS+h3ShT95nmh/QMc6jJ+X90UsFfX+vK53UCyTknUU68nOe++TzMibdom9RVty8iSgLL5z6gL4v171neupKHR/fPiTvCd6c1vUB3EVqtreNqj5TeRm/72uR8d6zi7o2wWShXT2mXtu5k7ngmWyczMvtuM8BgAsFuX+dMf0ZTjtxbDdeDgDTzj3S/5jV16B7b7gbH1/yLAozGJcXRrpNx9SXCvJ5l92oFz75h02Xi/YbHZtUn9az8jroPuq7W5zWi9PgREREgeNgTUREFDgO1kRERIFjzDqici4ictOnZIwaff5+Ian3ohlMqLq4osfHE7MmKicu7nFxHKwrzL3Y1EANINsvi0mMzelEsNNtsqDC+7teUX3cxJJdvXKxiNOjchsAMLdZTq6M3rdH9el/eJ96rBE+RG5S1R13PSDaZ26RyWQAkG+T58rEdCGQ/l6ZzJNd0h+zuUW5bduuk7NswXnMs7BC4oJMXlt0aqtseEIXIQHke4/yQ6ZjRCcJndstr52lXp0wdeyc/CXatVknNrU4hUgmcvr6b4vJBLzji/LazhZ08t2L83KRFd92d7WfEO2RxeI/SvKeoiivz8mkwoynmEnBeV4qro/XUMukaMehr68XC/J9XZk6K9qtnoJJ7cZNbtN9rmuTx2LB6ut/3kmwPH2Z/k6ZbZMJeUtdOsFyarv8nhn+Q/0dQxKnwYmIiALHwZqIiChwnAankoQUXyp1X9T075C+p7VRMYZPVF8iDdbGmLsBfA1AHMA3rLVf8vR5P4CvAkgCGLXWvq9sexmAcg1EG54YV48t9Mk42eSgLubQu1EubjCZ1/G3PqfwwTXp06Kd3KHjjo+1yIpqC+f0gHXqc/UfXyqlKErPQX28prY7cdr5VtXHLemhYs8AWtMyBntyRGcZmhkn1pfS+5Ny6lZky5Ss6K60tnTzbapPISXjqbE2HYMdyMgCHnM5HVve3Dkp2jM5HSudgXzsWK74G+1MyqotR2f0cw5dkLHmjqSOqZ+bl5+JqYXiC6x0t+qiKG4uiq9Pb6vcx46E3p/JRfn6r7XIRTm2t+uiMte0ysVkZgt6UZ8pp/hLZ1zvnxvjPzmsY9YHWwdFe6JLf1eln5Cfm0ap7FhJRQdrY0wcwB8DuBPACICnjDHft9a+vKpPBsBDAO621r5hjBn0boyIiIjWLUrM+hYAh621R6y1iwC+A+AjTp9fBvA9a+0bAGCtPVfe3SQiImpeUabBNwFYPfcxAuDdTp+rASSNMX8HoBPA16y1f1qWPaxzjbqQh8/qqWV3GvVNtYprM0ZLVH/c2ykff+z+Gu1J7UUZrHXADermvwSAdwL4AIA2AD8xxjxprX1NbMiYewHcCwBbt25d/942AN8g1nq7jAnP5/SEh7uQx4LnvlI3RrczJeNU7jYAoLVF3m95YeeC6tP5tIwvTX5Cxy/dxSHqUeqMjK8m9np+cNxzq2ie/KCOIxvn/GX6Z1SfyVEZB0126IU8lpZkXLHr1eIf155X5EfzxN36vmF3YYWug5Oqz8jn5TXZqtd0gO2X10qyVces3bjs4TMDqo9rV+a0euzkvIyNDrVOi/ar0zJuCwCvjstonPF8ky3m5Wdidk7Hcpcm9GOKs6DK2aS+Pzo5Ls/fjL7VGccvl8errV1fF7OTMmbtXl/nOnXeyfNxeW92V1J/znd1joj2eE5vx/0OuanrhOrT0yLvMZ/q0zH+fePyHy35Vn2d9r2k33szizINPgJgy6r2ZgCnPH1+YK2dtdaOAvgxgBvcDVlrv26t3W2t3T0wUPxDS0RERNEG66cAXGWM2W6MaQHwMQDfd/r8ZwD/xBiTMMa0Y3maXJfYIiIionUrOq9mrc0ZY34bwGNYvnXrm9bal4wx9638/WFr7SvGmB8AeAFAAcu3d71YyR0nIiJqFpHus7bWPgrgUeexh532HwL4w/LtGjUiN+HOTTir9wVDiKhyQk5irTRWMKuwKINR26hM+BnP6kSw8wtyhYbObl2wYMgpYtBqZMLPnvZD6jlPD2wT7YVenbj2wtkrnEd0pk7Wqf6VOKC6VFSxD6hbFCWKKBnkiWl9ruLz8mOVPexZHGJYLl5hRnQhkIRzKuI6JwiJeZnINDcoz83gc/4kndVZtb73OfRT+bxzN+r9i52ViVeFnC4Qc9Rpp9t1kY9cQUbj/uHM5aqP64Wzw6LtJl0BQKxFHuOWlE6Amx8vXuAkdb7412RS5rvBs2YI+l6Un3O3wA4AJJ+T+zP4nL6+ZoblhZGczYj2G9v19TZzlXzvGzbrhNCjF+Tz/ulGPTnqS1J19SVlAaepJX2MN10jFx8ZO7dR9XHfZyMksV4K1gYnIiIKHAdrIiKiwHEanGpqz0e/LNqe2cOKWCs23qjxLheLxFCjcq/tUkJgIeJgHYD0I0+KtrnDLRCnFzfwFUV5aVHeuz7oLOzhxrAB4J3dx0X7wIXNqk98m4xBzcT1kLrgLEq/ba/qosw6BUbWUqsB1JfAkj4g9+ddn3xQ9ck5Ibq8DuWi9YCM/c0N6T6paf2YKzkrY9aDz8lKG4m9+9VzolTRc+OFPvk++Vpdz+u49vSAjGvbDp3vcGxOLl6RSulqIXNTzkGdk8ev65COpbrHtOWM6gKbke3tf6EX2jl7uyfnwOHmnQDAvu9+VrTdalxbfqCL5bjcXBBAn/P5fjlB2n5OF2RpuSC/6hde1nUuzt0g8xS+OaWLH/3MZaLOlYpPA8DIQka0OxM62aKvVRZOOXu93s7ooBvr7pHNm2/DU9/6jHiokX+EchqciIgocBysiYiIAsdpcAqeb2prdRyq2vdmi9fz1Eknoupww1BlWs49SBysq8wXf3UHo9R5HX977bRclOD57m2qz/s6ZYXX3ri8p3XJ6nihe+/1hsSU6uPan9iiHps5L+PYZ39nj+6zTcbS+p7T23YXCankvZXFYuG+97Dhq/tE27d/YzfL2NpCn28tHCmhQ3be2GM55A+8Kt67m+QHAB2nZNw4Oau/KuJLMka95MkOjE/I59nzOhae65W5FPkpHfuOz8jPRMGzUIbLJmSffFKfh66jso8vRuzGo90YMQCkpnQ+iKtSK0aVEqd1r1EA6PlH97jr8/BXN8slH27ceVz1aU/I2Pe05z7rW3qOifbovL54Ts7I1x+9WV4D/c/o87lWoZRGwGlwIiKiwHGwJiIiChwHayIiosAxZk11afU9q6VexG5imrr/+APF76+tV+Ke325+DVSCL/Fxda6A7+++e+AbpahHKIqdl1DxUxoA98PoK7Qx3iGTNH7c7S6uAQy1TIp2V0wWI9iSkEVSAL34R2friOpzoVu+9tY2XTjivySuE+25Hp2cghGZRJLt0Qkiwz+U2/YlwrjJT+4XnC9JyFccpBg3mcxnekemaJ+OEZ0M5Xvvrlyb7OMu2gEAS2l3O84iIp7CM24ylC85yi2K4u6LT89BXRjEXayi4LksbEImDm14Ur/Pmc3y9bMZ2c57arhc9W2Z/Hcqwo+vrOeHi1u0KHXnbu9zVyeQVfMOBff7I8qPgMy3f1J0u74Ey+6X5fF5vqATXQe2yOM+1KG/dx47c41oL+V1Um1mUD5vEnIxo7lBfdLnPrcHLz3wafV4I+A0OBERUeA4WBMREQWO0+CXoF5jH0RUflGmvkuZHnef437HVLsoUOhW1w1wQxj1jIN1gHyFNjLfljf7T/7VVarPq7NyAfctSRn/zcRkfBoAtjlXQD90bDKdlq99ILlB9RkZzIj2gieI+Hq6X7TPdWVUn6W0jCsudaouGN8lt90yIZ/ji52mIixeAcj431rFJor1cWPmZ27RgVo3ju2LYbsxajdWDwBj17ZctM/kFfq1U07dG1+cdnq73J++F4vHo31fjBOfl3FPz/oz6DosX8uNTwO6oE5ySvaZH9Zx7uM/J68L32vDud7dRTJ8ouQ/+BLFohTscAvWlDoQl/KPBvda9uVs5Jx4fT6pr69zMZlncqFXr2Qz2C3j0dZz2DtSsqjTbIdcFCbbp0/o4H59nTYKToMTEREFjoM1ERFR4DgNXmGMa9eX1edrrXWfV8fEuiq+R0TrV657vJtFKcfL7VNpHKwvQaVOlK8IghtPmnpG3zN6dI+8r/qEE//NeyZS2mMnRLvTczttd0zeA7kloe+z/pmMXERkPK/vdXa1JPT9vSMxuW5Osl3HaQun2kU7JtcNwJnb9ZsYu04ei+EnFlUfNxbpizHOOvct++6z7jo4KdpDP9XHwo0lxxdUl2jx5wkn9u3En333ZqfOzIj28Q/re9n7npPP8y1eMficPIZuPBPw32PucmPUvthyalT2cbc7vks/x92OL+7u3qfunjsAyDrvyz1+b6pE8ZJqDgZuvNyXjxE/M1M0Z+PQBnk9meM68WT6Vv25drUZ2WcwI+PcJwc8N+1Dfle5CwO96alvfeat/6+XBD1OgxMREQWOgzUREVHgOFgTEREFrilj1kz6IqJyc+O3UWp2l/K9U+sYa5QkTFpWznPVlIN1NZXrR4Cb7JS+XRfZf31kULQfWZRFBD6y5Xn1nC2JMdFeiuvCKQNxmcyTNjox7Pa246J9MpdWfS4bHBXt/entqs8bXXJ/ClYni73aId/n5LBMOCuM6iIM2W150T46pCeVWt4rj+nl39WJdG5Ckm9BhGnP4hmutlGZ7DSzWe+Pm1DmPgfQiV9uUQ9fgZHkbEa0r/6mLsJz9naZkOd7bTeZTS8qEq3ISHLWTR7Tr+Uen/O3yfPZdkJ/leWdy8B3jN3EPt/CMW6RIt9CMWslnVXLer9novT3Jcy5g4+blAbIuyWW6WvgXKdT/KhXf6dc6JQnsLXVWcBnQp/zsevkteRLJHVFORYh/GOO0+BERESB42BNREQUuIabBmc8mohCcMddD4h2KV+2a9Wnd5USG23m78Vii6OUY5vl1nCDdRT1mBThFpzwxRCnxmWM83yLjK39TYt+35s3y7jsoUV9SdzedkS0N8Z1nynrFDCIz6k+LUbGGXenj6o+G1smRfuNbJ/qs5iRr1/oljHF0T4ZwwaAsVkZQ58e0bXHli6TAcwjH9WFZ1plSN1bdCHXJuNmG57QsW83NuoriuIWNPHFhBecw7PhiUnR7jqot+u+9qkP6PfZ95KM9flism5BGN9CI26hmdH7dK7F3JBsL6X1hJ9b4CQ+I4tfuIVxAL0IzPROHRd1t+MuKgL449iri2oA+ovaVyCmXGq56laUQS01JY+z79qZ2excc2f0d8rie2T+TD4vr4tcl/w+AYAWJ449M6wr7PjyTOoBp8GJiIgCx8GaiIgocBysiYiIAteUMetyYTIbUXO65gtfEe3NZdqu+51SzfwalRDn5Bu8qRG/4+rhu7zhButSb/YP3eOP3V+0j5s5evhXZBLH63M62eL7qZtE+67+F1WfV5dkEZKUOav6LEEm5nR652yyohUzk6pHu5F9JjzFVd7XK7Om3CS0ze36sn6jVR6L5+ZSqo+r46Yx9djYqW7RTp3Vr+UmoR3/ueKJaot6YSLkW+UxdZO+lnmWqFrFtyqYmwCX92xi7FqZrNjRrbfjJhL5uAl4vvdpE84KX1t04pDJygvKdsg+2Zx+E7kBmfCWOH/xYwUA01fqAh5u0pmb1AfohLJyDXS+oiOlbLOaSWhuQplv9boNB+R+uz9+AMC+KC8We63cbnxWJgcCQLZfnr9t39cFf7BrpxgDynVsop5bYzxLG0bAaXAiIqLAcbAmIiIKXMNNg4emUrEQ33br8f5xomZSiWIcxV6j3Nza3/u++9mKvl6ofAVrKhli5WB9CUJLQHAXGGg/I/8+ndGxkoNjA6LdkbxS9bmy/XzR1x6KT4l2IZZVfVLGiQcWX+MBt7S/rh47mN0o2huS06Kd9Cw0ki3IS/3Wy3QBjwUnePvKuUHVJ9Ep48aLujYNshtkOzavJ7DyrfKxpS69of5n5Pk69k/1x7V9RPbJOQtw+AqyzPfLPp60AMQn9WOuczfKuPbgc8UXTYjrw45C0rkQ8p4FQaad49UrX8sm9LFJnZDnM9ehL7h8mzzuiQs6Djq7SbbTJ1UXtahJyvPD2Re7raZi31dR8mL0Ih1aKQPW0E/1tfPGXfL8FU45xY5i+nyagrx2fPkirnr5Rw6nwYmIiALHwZqIiChwNZsGf+3pI+uO36wViwltOpqIKDSVipdXO3ZbDqun8/UqAVoIOUKMWVdYpX5I+LbrxpPc+3IvbPcswHFW3sv4NLaoPq+0yJUWDvcOqD63dx8W7Q2JKdWn4Ezk5K2OTXbG5IoWcaNjuXOFlNN2YqdODBsAFp2YdcwTMC84+7OtV9+jefCkE5Bu0/cExxPOPs+26v0ZkHH1xKQ+N7k22e5/RnXBnBNWd2PUvvus3QVC+l7Ux2K+X56rsev0JNzwE/L68t1b3OHcf5yc1e8zn5Tbnr1O5zsUnFhyd0YuFKOvNqDrmguifX7U87WccxaH8GynZVy+dub14rH5teLT5bhnupbcZLKoq4IV44uXu0VaTt0uP+dWpxfAWSsIHSP62k7Oysemd2RKSpKLcg98OXEanIiIKHAcrImIiALHwZqIiChwQcesq1XPNkriWjWT20p+3/fcWt4dIaKyWh3jLTWuXQ+qUfylnNz4OBDtvvNqqtlgffU7L8fe/es/gaGf9FpKP/Kkemz18brpU7pY/uwmJ7mnUy9wcWFaZjqlW3QCUF/LsGiPxHUxgo64TB5rj+lEndnYvGi3xnQVjZTzmJtgdjLbo56TzctLPZ3Q72FkVi7SMTHfrvp0dMj3MHsoo/rkB5z31aXTltKvOgUfWlQXlSx26gP6mLbIHCqVUOZbbGO+X76Yu7AHoBer6DpavIKNLzt2cli+Tze5BwDmh+VjsXF9MBJXyjfampDvq2ODTgY8NyWTJ2/YPqL6HBrtF+25qTbVJ7ZBJrMdu0wvCNLyukwibL9ij+rjK1BTCdX8jqxkoRd3QRDrfKe4i+EAQMeITO6c2KEnj1vH5PUeJWEwBJwGJyIiChwHayIiosAFHbOuNyEWbRH3Qd5evE4uEdVWsXhvLYuQlJpPU2xBoxCKjrjKdQ95uQQ9WIcUn67mvkR5Ld+F5MaP3Iu9bdSz6oQzubKwoOO0C4PyeUegi6KcnMiI9lUDevGPjW2yWMmAG3AFEDNyO0ueygevz8jXb0/ImNO5Bbmgic8zZzYX7eMzNyNj+rFN86pP/KSMe7ae1THh9nMyTttxSsfm3fizG48DgK6Dk6LtLuZy5hYd/3UXTfD12fZ9GV91twvoxSuy3RnVJ/Ptn4j26H06lpt0KpoUrplVfbraZa7AYl5eF748ipuG5YobrZ5VRDZl5Iu39ulA6LjzmTg1n1F9sgOyGkffi/qcn7jb+bF89x689MCnxUPVSqotJ/f7qlzvwf0+6775NtE+f5suSLSUXv+Q5ivm4353xnftrHlVNk6DExERBY6DNRERUeCCXsgj6nRKsdhHpaawqzllFVr8hIguXT1Oe1NtBB2zrpZyDubVim1Hub/R7dMFnbCxlJb3JHeMAE996zPisWu+IO/PXoCOcca3ypjhSyMbVZ8TXRnRTsZ0zKk/LeOVs0v6tTalZZzx5TG5uEamTceRD52QfZKt+v7jpYUIH4cZ2Sc+rmPqi73u+/KsOBCBe9+8L+HGPcen/pmMCfvuj568Qh7TpA4Rq3u6nVvkAej7hs96EhhTzkIei52qC1KTsn1hUR+viQsybnzzZnnPtC8e3ZWQOz2T19fSnYPy+PlyJE4syM/I1k59T/dPj28T7ZMf1K/VekpOZG79vX2qTxS1jp0WU67vQPd673tGHvdcm77e3Lycqe168ti9r3rk8zqPYvO/Ke3cVBKnwYmIiALHwZqIiChwHKyJiIgCF1TMOqQkqmomqkV57WoWCFDn4edYTIWIonEXxfDdx1yP3Pfl1i4HKptPEMxCHr6B2r0RPbTMyVoXzC/2+u7xyh94tehzfOehY0QmKSVn9YRMfkQugoFhndg0fU4udlBo0UU+xjKy+IaJ6e288YYsimJmZFLQuTZf8RdpMasTiUxcvpa7XQBoHyk+GWWcgh3dR4sXM/Gd35yTnDXbrT+uU3fL5Jj2M/Lvc4O6OMfMVTK5ziT1/g3/lXytpbTejrvPGzwJjG6fFs8CF9NXFl8kpFCQr39uPi3aWzsm1XMSTgLjlSldqMddBGYwOa36bOyU235tYUj1Wdwij9czR7eoPrEl2ceX2NRzsPi1W0uV+s6Lkjzp9tnwxLgaHK+9XybDDj6nF+kYuzZCguXn5LnxbafaOA1OREQUOA7WREREgQsqZu0TZeq7WKy7loXvo6hlrD6kPAEi0vZ89Muive+7n63RnoTHjSPjRs/C8A0imMHaN3hGSfJyB5tyJWLVchGRKPGbSvEt2OAuxuDGUgEdB+o47olxJmU7l9Yx4axTcCW2qCd/4k7Nkfi8fK3Wo/o5s5tlXHTDkzpO6sZlp7fr9+CuPZJvVV0w7BS78B0v9zinPPFet2yLG+cGgKntMvlvaod8X6lR/R5i8/L4xKb1eTh7q/Pah/V2Ru/bg2cfenshCvXFCf2+3EIqAJBvle9hYV4fVLfQzEhMFiq5rFNvtzshi+N0x+dUn6SR2817JhsHEjKOfaFF7998m7y4J4d1n/Nd8pxnn+1RfdxrMDlbPJ4fmscfu3/dz4myYqHbx/e5chfIcRebAYDUhNOnp/jn3Jckp0s6VRanwYmIiALHwZqIiChwwUyDR1WrGGuUaZpSt1PNe6jd16/1Au9U33xT31RZtawBUS6h3YZbKeV8n0EP1sXi00Dx+4/r4aJw738u1w+DKKuYua/t/THkDOh6CQyg7yV5H+LMcFL1mbpSxob6n9f3lC6l5WSPL57kxr7deyDP3KKTTHoPuK+jt+suFADomGLHKb1ghGv0Pn3/rMsXu3XzNtxzcdxTnKbgHIt8WkbSFvr12bKz8mNv+/V7anuuTW7XE5t3z7mvSAQg35dvcHe34zt/cO6Bd++7Xix47kHPyfdwdesZ1ScdkwvQtJus6uMaTuqFPOKQ1/J0Th+wiXm5GMn8NZ4bfI/KPqkp36etMa33+y2xd3/R5/iut6W0/NC4MWwAyLXJ68sXH1/req8UToMTEREFjoM1ERFR4DhYExERBa5mMevXnj6iYqjFYqxRk6GixKmj9ClH0kbUmHkti5Os3kcmnNXOuz75oGj31Wg/iEJQakGskApelVPQCWauKAtRRMmULCXprJzZllEKu1TigvO9B99iH67Ze25Vj7lVlNxEDl8iVt8zMiFjekdG9UnOWrHtKNnz7j4PoXgyiO+13e1kDqguJR2LKIkoYzfrZLYTd8uEMjeZLIpkqyfBrKV4OYfZy2SfngO6cEopqw75Cma413/HiKdYSKf8qsrlZQLQa11ycRcAgJOPd761U3VpTcrkttaYvm43JWQiWB5Tqs+xmCy4EjM6aWkulxLtZ+c3qT5jN8p2ctZT1KMBflCX+n1aNBnW4btGZ4bl9eVLYu0YKb6giu87xOV7n8bo14uC0+BERESB42BNREQUuKCmwUuZni5XfJqoVOr68tyT2SzcqcliaxJTuMpV76GcouTXhJSDU85cpEiDtTHmbgBfAxAH8A1r7ZfW6PcuAE8C+CVr7SOXunOlHuhSiqJU6gKMst1qLdLhU6737cYivQVYnHbaExN2Rdk/97V8cSr3GPte2y184NuOW6TCV+DfLdZwzRe+ovps+74siuKLm+XSznY9NTTmrl+Q++fEqBdndIGR9m65wEUur+PR6WPysYUKZru55ya5Q+cFJC/I45Mak/t3vr1bPccNDfYm9UIerWkZo96VOqv6LFm5oVlb/GuzYPX5HEzJ1SFaW3R83L3iprbryc/0I7X7vqimYrlGUb43fX3cXJQo44xvgaNqF6wpOg1ujIkD+GMAHwLwDgAfN8a8Y41+DwB4rNw7SURE1MyixKxvAXDYWnvEWrsI4DsAPuLp988B/AWAc2XcPyIioqYXZRp8E4ATq9ojAN69uoMxZhOAXwDwMwDeVba984gyrb16sfb0Rfo1mxBjUKVgDgLR2hrlc16PKrlQUpTB2ndTmHsT4VcB3G+tzV/sHjJjzL0A7gWArVu3Yu/xi8eWoy5wsZp7H+xaB6tRb5wPRbW/GMqxEEqUFaR8MepS3qt7j2Y2o/tkh5z4c1ZPhLV3yIUnrPPJTGZkfBoAkgmZPTB3QS86sXid3O7A3+rY96kPyBuZh3+oFydx+WoluOfLt8jK5n+zT7TP/o5cLCU2qW9Czw3I45WK6xjjgpXPO7akY99bE/K+6mHPdtJG9mk1Oh7t3ns9Ptiu+uyblouPtD+XUn18i0pUQmiDeyn5K75j5X6GffdLpx95Uj4wVHw7PuXMR4oyWI8A2LKqvRnAKafPbgDfWRmo+wF82BiTs9b+5epO1tqvA/g6AOzevVtXDSAiIiIlymD9FICrjDHbAZwE8DEAv7y6g7V2+5v/b4z5EwD/1R2oiYiIqDRFB2trbc4Y89tYzvKOA/imtfYlY8x9K39/uML7SERE1NQi3WdtrX0UwKPOY95B2lr765e+W5Xn3qxeLIbtu7ndF48ILc6zXpVMTolSt70erU5oBDzxrs/L+CpRudVyISBXtWpbNFuiaTAVzKKcuCgLUXQdnFR93IE4pAsbaIwBKySlHk/fIhMu93rzLezh6hjR6RmjN8jkJ+NZW8M4CWU2o5OWtvZMiHZ/SlZOyVmdlLaQl0lVB5d0UZT8CzLRaupKvX+Xf1cmlJ29vVd3un0Pnn3o0/rxVaKcr7ufkZ9ZN5nt1ft0Ytj48Yxo/0P8ctXnZzfL49XiORGLzh2unTF9vFqNXPhhEQuqT19cljxJGL1YRKpNnuOpK3Xyn7u4h/udV6mFgOrFepNNvf8Qc9puoSOgtAV7AAAvROvmYm1wIiKiwHGwJiIiClww0+BR1i2u9uuXMp1ay7hsI8SESy0qsN74VZT775stJlYp7nGst2uyHtXDd0Etr4uQFvuIKpjBulRufKaUeHSUG9ejxIBC/3IvNS8gNO45r+Zxj/LBdvskZ3XMeqlLPmZTOn7Z2i8LmmzMTKk+E/OysMaVHaOiPV/QxULGs/I5C/O64EnMCZXGdQhWLW6QeX0x0oIupXA/f+52t/+lLlpx5BflxOFCTn/dnVvsFO2TqR7VZ8iNNcNTIKYgY80DnjnL1pjOOXD1dcoY+siGNtVnZrN8H6kpeR6iFOuopFKKl1TqdaLwFeqJMo64MepKL8jEaXAiIqLAcbAmIiIKXM2mwV97+kjZpsiKxR8qWVw9inLc0x3leZVSD/Evamyhh5io8dV6HAkqZl1sAIhamKTY393HKnnQq3lCQx9AKxUzjxJvcs95lPhSlH3xLf7h3m+80KefF3fW18h16Pt73735uGgXrF7gYlfnSdEez8l15paW9OTZYl7eJ1zI6T5JT4zaFSU2WslrcvW2feeh+2X59TY9q+PRL7ZvFO1NqUnVZ1NC3sueNBdUn7SzgNGCu6IKgN6YjHHe3HVc9RmZlfeLt3RnVZ9sxolZu7FT9YzwVOu7qtTXKZYjAfhj3VFcbLGri+E0OBERUeA4WBMREQWOgzUREVHggopZh6zWRVsaQZQkId8xjRI/qkQMLNI5d+41pouLUqs5ajKZ6Henvs+apEoUISnXwj+VXECoUdRssL76nZdj7/71nYgo2dBuoknigO7jLr6gVkkqUbMX0A+F7xxUKpt4ZlgXHUnMy+SipU6dUNJytSxw0tWSU33chLIr0ueL7k8csrjKbC6l+iwVZIKZmdTvwbX9L8bVY9VOZFrvgJ6akOdh+ipdeOb0VJdoH+vW2YApp5hJe/th1WcoLhPB4p4colM5meA2lWtXfYbbp0X7TEuX6uOuuzK9IyMf2HEr9n33s+IhZtNfmhB+NHAanIiIKHAcrImIiAJX9zFrNb1TxthVKXXGfc9Zbx3rUmPhUbZdbDqn1OmySsaR17tPvntu6/5CrxMqDFXjOtXNqhzT3qHHkUPfv3JruO8wt0BANsLg7cawgdIWdC9lcPepdEH4WnE/RFEKDZQrsS935261yEQxvg/9TZ/6imi78WkAmLhGBixzGxZVn2v75YIbt/YeUX3m8jLefFv6kOqzaOVH+ImZq0U7FdexcPex2KCugNL+ioynqrgogLSTD5KrYpJXKV/I7rkDgNlBGQB+5vwW1efyrTJXYDyvY82Z2KLT1kHrLckx0Z70bOfZnHz92Um9kEfCSTFwv6vW+v6oxCBWrm026gBbTpwGJyIiChwHayIiosA13DR4JbnT3O56vvommWWNeNtEKe8p9OPgxlsnr9DrFlNlrPfaiNqf06uV1Wxx44up9LGo+8G6lMU/AGeQdeLcADB2s7wnsu+ZCdXHFTXWXNo+X/p2y7WNcl6UxZ7j+3uxL+pKJjXNDcl2zlMTpfUKeQ/1rn59f/T0ovxpd25R3097Y/oN0T6x5LkH2Mh7gEcX5Q7N5vQPDvfe4vxU8R8lS+niiw8k9u4v6RqoVpGbtlF9n/XkgvwKbOvR+QWvzcqTflXqrOpzPt8q2hcKOldgLC/PTdLoO9W73BVUCvq4F1IyT+LUB+TCMfjAHrzw4KfV89Yr9AE39P0rN06DExERBY6DNRERUeA4WBMREQWu7mPW9ahYzHWt+4gvtRB/qUk55bp/PIpKJqGt3vbkJ25Tf+eSHOVXrXh0pNf31FNoVLU+7uXQCO+hnBp+sPYmfQ3J4g2+gg/ZHpnYoZI4APS9pJNRyiH0oiilLlhSzg/axbZVSlIaoBPTFm7Zo/osdcvknvjwnOqTTsnrwl2QAwB+bbNcPKY3rpMc3aIZGxK6z+GsTH5qcxadODqvr9uFeZlQ1nJefw24yVipKZ0wVa5V50rZTimJkG7xEACYeVoen6M3Dag+va3zon0+16n6dMZknzh0sZytCZmkeqGgC55kkvJ6irXq445peb7c76FqVo1r5sHTVeljwWlwIiKiwHGwJiIiClzDT4M3smIxndCLkPhqNfdHfO7q9+ZOo4YeRiCi+hJC8ZemHKzd4g2+E5F22r5FCmaGZUX97O/oGKcbT/IVYAGKr8xVrgGplIurmoPf6H178OxDbxd0KOcPjtXv3Zc0N+0kIOWun1V9EjEZi+xun1d9ruqRRVBuzxxWfTJxGZtsMTo22RWXBTIG4xdUnxcKW0X72KyMwcaMjp0WJmXM2lObwxvfdfMUoiQeRrneSsl/iCJKomQ+qR5SZpbk8Rr3VMIZSMhzs2Tiqk/MiWOP59xvGSBbkF/JhQX9FR13zpdbaa9/r3pKXWI8XOI0OBERUeA4WBMREQWu4abBQ4/TrmXPR7/81v/rybHw+aYYS53erNQ5vP4zb8fIhyvyCo2tHPfbhxD7o2jKda54zsuj4QZrn1IWi3D5LrjcfTJG3TGiFwoYu1bGk4bP6G2793nPeoo3qPtch3bj8cfuX2Nvl4W+MPzq2PSbShmo9epn+r5d9z751/77HtXHOvHotqSOI/d3yjj29s5x1ecjfc+Itm/BhgUrg6WZmOd+WserixvVY3N5J566IO/NPj+t46up8zKemprUr+XmKfjuhXaPez0afE7mlBzdqScbRyYzon0uoxdd2dF6WrTd+DQAXCjIxT46nZwEADi7ILc9NKwXEDo7I9MwM6/Le+tzdxb/bqD1CeGHBafBiYiIAsfBmoiIKHAcrImIiAJXVzFrJipI5UjqilIsv9SC+lHiz8167ki61EVqiBpdXQ3WUVTqQ17q4hAzTqGUQ5/QiU3pEbnQg69QQ/s5+WDfMzrxpJbKVTjFLT7jKyLjW3hFPkc/NrtZJvyYIV3MJJGQCYI7Bs6rPjd0j4j21a36xdyEMncBBwBYsPKj5yteEivI/Tm71K36/HR8m2ifOpeRHcZlAhoAJJ16HakJ/dqTn7gNT33rM2+1fdd64oB6qKhSP0fl4Pshu/ouDACweZ0k2tchkwpncvqYutxkMkAXwpnM6/s+OhJZuZ2FlOoTn6/OhGjoCarNhtPgREREgeNgTUREFLiGmwZvdnfc9cCaf4u6zm2U4hflKJAB6GlIPelHtVKuc0zV5/seqMS91/WYR1RqDk6t1dVgHdoBdffHHXgAwK174ManAWBmm4wZxrK6T7ZPPja9vVf1GX5iUT1WzOQnbhNtXyw8ShzZLeQy368nbWY3yXb/8zo+mO2Wl+Qbd+kYf2JGHovFHrmdiR362MS2yLjjZQNjqs/OrnOi/Z6u11QfV29cH4sWJ2adNPp9zlrnHOuwMQ46RVBem9ug+kwttMnNzDqx8IK+ljb9ONriMqvFd+2s2oIbtZSY1gtwLCzJfJHz2U7VZ8xZ3CMT14vALFm57ZfnN6k+R6b7RDuf158jm5AXi/sj3LfoENU/ToMTEREFjoM1ERFR4DhYExERBa6uYta1FOleUM8CHERERJeKg3UZdR2cVI8tpWWC1GKnTvgptBScdvHXym3UqzQdv0puJ3lIJh+1XyELtABA3qndcPZ2nZzl9olfofu4yWMFX2EXp37I6A16YmepS74H069XJurKyISoC/NyBy+7QSePbWmfFO0NqWnVpzUmVy/aktTbOZmT5/PalinVx31XJ/LFT+h/nb5RPTaykBHtn5zYrvosjMpzbLLy1bsP6ustSkIZUPoSp/Uk/ciToh2/QX9Gpufk9dXXr5PH3GvnfE6vzDXuJBq2xXRCaGtCbsc9vwCQPivPqS+hrFqrboWUHBhVPe4zwGlwIiKi4HGwJiIiChynwYnIqxyLa0St+12Jqclq1RwPUb0W/qC1cbCOyHehuxWefItZZJzFDjo88aWxJRnT9C3kkXNq/i9ldLyrrV0+trBDFk+Yv04W6wCApWOymEN8m6eYw6l20W49pydkFjc7+xPTVT4Wr5R92lNLqk9Pm1zsYKj9gupzclYuaNGflvt8bbdeXCNl5Gtd2XpW9RlIyDh2q9F5ATemTov2+bwuovGGE9desPqEuoty/O2Zq1WfxZzetisxKT/Cbl5A/8P79JN27RTNci3CUo/izrEw+iOiCpNMLek48rjzAR1O6uJCFwryedmC/vqdXpDxcTcHAQBanI9E1MqEVN84DU5ERBQ4DtZERESBC3oanHEXonDw80hUO0EP1vUmymIHvpWMhs/Ie1rf9ckHVZ+5QXlvpT2i42azA05sNCXv68wv6NO9/caTon12Wi9SsG3XiGjnCnpCpr9VxpoL0Pf3zuXk/vWm5lSfja0ybhyDXgTj1swR9dhqvvuj40bG0Ifi+v7oTCwr2gtWx4znCvKxvOd9Hl/sF+0X3ZvQAbw4IRfpmJzznM9TMp+g65Den84J+b46TsnYvBuTfdPq662SiVihD+bTOzKi7TnlSLfL62J6Sa8N5+YluPFpADieldfFdK5V9ZmcKZ4fsuGJcflABRdZoXBwGpyIiChwHKyJiIgCx8GaiIgocIxZl1mx+N9aMUSiatrz0S+/9f/pi/Sj5sEEwrAFPViHfqG4SR1REnXyB14t+r4y3/6JeizprOi1lNaJTed75WNm2jm9vbqQymJe9il4kscyLXIxjYFWXajk9Lws8rG5bVL1aYvL1+9J6gIsnTH5Wu2+xQ6cRRPSTmJYJqYT15JOgRM3mQzQyWLn8h2qzymn4Ilb3AQAXpvbINp/84r+gWazMpOp/bj+KHY5hyeu1zRB3zO6+MZqvoIns861NHvPrdj33c9edDv1yP2c+ZI7uw5Ois/xlf/HV1SfjpS8VlpiunKKe91O5ttVnzOLcnGP1y/0qz72qPzp5FsQp5mL2DQzToMTEREFjoM1ERFR4IKeBi9FpeIua01xl7Jt33Qc75OkWmrEeKX7ntbKF1kdv8du/vuFwtRwg3UtRfly8w3UUXQdnBRtf9zqNtFy45kn7u5Vzzh5hYyb+RYOeDq7RfbxLNLxjmG5gsSZhS7Vpz0h48+pmF4oIw657S0t46qPG3+ezMs43/mcLuziLqzwclYXKpktyGIXo0t6O2ez8n29MDas+pw5k5EPzOlKG/FFeZx7DuriL6kpfXxc7nWQcxeKGdqNxx+7/6LbaJbVqXz5ImKgBlBI6Ws7uyS/Jjf26II6Fwq6wIkr5xTUOXR8SPWJOa/f80rRzZZNvf84a3T8GUlERBQ4DtZERESB4zR4IEqdHiciosbXcIN1peIu5Spm4os1u9sudUEQ3z23xbbjxuzm+/Vky/SVxeNxB6a2inayR9/H3NYqY9aTPXqxA3exj1fSOq53bccp0X5pRsaN+1r0fdaPjV4n2gnPvbJHp/pEO1/w3Mt+Qt5n3XZCf4TSzq3hg8/pe8VnhuVx9sWnU2dm1GMu911EeU6ziPJd4F7vSR2OVjoS+nxOLMm8iazVN0iPLRYvP9N9UF5zuTbg2Yc+LTt9q/g+UuPhNDgREVHgOFgTEREFjoM1ERFR4BouZh2akO5h9Sax7chUfT+ouspR8KScRYFqxfse7ttT/R1pII1wXdQLDtYRlbPCmHshlzKgl2t/3IUMovAN+m7BlfiSvrQ6RmRC2fN36MIppksu0nFoVhcdebxth2gnW2VyVj6nJ4wKC87+LOg+LeOyaEVyWnVBW4ts+4qZuAVsskN6QRDfYi1RrotyDbKXss1Glt2ypB5zF/I47Sn4098iE/tGF/U5f+mMTJbser5F9Wkb1dcTEcBpcCIiouBxsCYiIgocp8FJYAyKyinKVH61F9+pN+774GexOUUarI0xdwP4GoA4gG9Ya7/k/P1XALy5WsAMgP/JWvt8OXe0XkX5YFXrw1euRet9MW43jh2l+EvXQb2td33yQdFOzuqFFWY2u5etXIAjNaGfk2uTxSYS87pPxylZ7CLb7f947PvuZ9/6f9+AkEd5zmko2yjndmpJLXICYKHP09GRSS2IdsLouPKZhW7RPjTRr/oszMoY9WU/1IvUlOszWi2NcF3Ui6LT4MaYOIA/BvAhAO8A8HFjzDucbkcBvM9aez2ALwL4erl3lIiIqFlFiVnfAuCwtfaItXYRwHcAfGR1B2vtPmvtm7UunwSwuby7SURE1LyiTINvAnBiVXsEwLsv0v83APz1pewUUb1jnLGyKhXnJgpVlMFar2YA6IAfAGPMHVgerN+zxt/vBXAvAGzdutXXhSqokvHzct337bv/2OUuh+BbZMXdH3fBEt/CGYm9+2UbHAAuVS1zNtztXv+Zr6g+eWeNmq5+vRBKi2fRF1fMiWOPnerWfeaLT2S6i/g0SpIcXboo0+AjALasam8GcMrtZIy5HsA3AHzEWjvm25C19uvW2t3W2t0DAwOl7C8REVHTiTJYPwXgKmPMdmNMC4CPAfj+6g7GmK0AvgfgV621r5V/N4mIiJpX0Wlwa23OGPPbAB7D8q1b37TWvmSMuW/l7w8D+FcA+gA8ZIwBgJy1Vt8nQUREROsW6T5ra+2jAB51Hnt41f//JoDfLO+u0cWUUrykmQqeqPd6z6212ZEVXEyj8ph0Ro2MFcwoKJWqXJV+5Emx7XINfFH6M0mo/EpZDCef1I8t9srksW2dF1Sf8axcgGa4XS/28eRTcnGZ1LSOMKZPyvbZ23vx7EOfXmt3AfDHBr2NtcGJiIgCx8GaiIgocJwGp6bB6ejmI2rND/pKRhDVB2Ott75Jxe3evdvu37+/eEeiMmDyUfOJsijM+MdmRXtjZkr16W+dE+2DY7pGRP4fekQ7rsPaGPYs3FGuYkJUP4wxT5dytxSnwYmIiALHwZqIiChwjFkTEZHC+/rDwsGamgK/YJpPtkcmlM15Esz6OmXMeiabUn2mFuR91rOHMqpP2olR9720qPdnqAOPP3b/WrtLdFGcBiciIgocB2siIqLAcbAmIiIKHGPWRFT39nz0y/rBzfy3CDUODtZE1JAW+mQ7d/m86pNx2226z6FXNol23PNabkJZYm/9F3xiUmZY+NOTiIgocBysiYiIAsdpcCKqO3ff8AX5wI5MTfaDqFo4WBNR3es6OKkeO3O7XFzDFnRRlNOj3aJduJBUfXY+LBf3yB94VfWJ79opH9i1k4t0UFlxGpyIiChwHKyJiIgCx2lwIgoKF5Ag0jhYE1HdcePBVzz4oOpTaCk4D+iYtRmVC3f4phqzQx2incJOTy+9T0TlxGlwIiKiwHGwJiIiChwHayIiosAxZk1EdeGOux546/+Pf1jeD62j0UR+vgTGekhe5GBNREHxfXGuHqijMl1Loh0/2Vr0OT2vWPVY6syMeozJZFRtnAYnIiIKHAdrIiKiwHEanIhqyl2UY9qzKEdKPRKWeo2DUv3gYE1EwZu8okW0Cy152SGuY83xs3KI7zymt7vhiXHR9i3SkQcH3kZSr+eS0+BERESB42BNREQUOE6DE1HV+GK7ai1oIjAPwMXBmohqyk0oW0oXL3HSMh4X7cXhJdVnw5Myjt11cEL18cWoSxkQmnkQoergNDgREVHgOFgTEREFjoM1ERFR4BizJqKyYPIYUeVwsCaiqsnduVs9duZ2mVBW6MqpPi2n5Cpb6ZPy75t+rIuiJPY+KdosblJfeK4kToMTEREFjoM1ERFR4DgNThQoFoUoPx5TqlccrImoLGbvuVU9NrFDTt7FFvXz2k45DzjxaQDoPloQbbdwSurMjN7wrp34wfNffKvpG6iJ6gWnwYmIiALHwZqIiChwHKyJiIgCx5g1ERXli/eO3rdHtNuqtTNETYiDNVGg6i1LeWaznqhLzsp2XueOof2cLmji6jo4KdrZoQ65Xc/qWS5WU6N6xmlwIiKiwHGwJiIiChynwYlIedcnHxTtTG12oyrceHy9hR+oOXCwJqKifPHetlFZqCQ1pRfgcIuVXEpsuViBk2KD7OrnX2w7RCHiNDgREVHgOFgTEREFjtPgRE2Gi1kQ1R8O1kSkdJxaEu2zt/eqPpnX5aocvsU03PuhU9Dx6OkdGdFOP/Jk0f0r148L/kihesFpcCIiosBxsCYiIgocB2siIqLAMWZNVMfKlSymtnPn7lJ3qWKK3RNd7H2v9XzGrakecLAmajLu4OQbxLLd8qvBTSbz8RU88SWUuboOTnoLlqzG4iXU7DgNTkREFDgO1kRERIHjNDhVDYtxVN/dN3zB+3ixaedq42IaRBfHwZqojlVrUPMVPHGLmfi+TPIHXi058Wu1crxP/gCgesZpcCIiosBxsCYiIgocp8GJmtBasexKKOW2K+Y3EEkcrKlq+GVbfb5EsigDdWoqJ9q+e6jTB/TzotzDTUTrx2lwIiKiwHGwJiIiChwHayIiosAxZk3UwKqZSAYwRk1UKRysiZqMW8wkNVR8ha3cnbvx+GP3i8fuuOsB0U7s3V90O/Fd/oU9QquoRhQaToMTEREFjoM1ERFR4DgNTtRAKhmjVtse6qjYaxXDoinUbCIN1saYuwF8DUAcwDestV9y/m5W/v5hAHMAft1a+0yZ95WI1smNTwNA18FJ0fYVPAHk4Of7EZA6M8NYM1GVFJ0GN8bEAfwxgA8BeAeAjxtj3uF0+xCAq1b+uxfAfyjzfhIRETWtKDHrWwActtYesdYuAvgOgI84fT4C4E/tsicBZIwxG8u8r0RERE0pymC9CcCJVe2RlcfW24eIiIhKECVmbTyP2RL6wBhzL5anyQEga4x5McLrU+n6AYzWeieaQLjH+YXSn7qcilKsz++X/gLrU/QYR9lfuqhwr+PGsqOUJ0UZrEcAbFnV3gzgVAl9YK39OoCvA4AxZr+1tng1BioZj3F18DhXHo9x5fEYV4cxpnj1II8o0+BPAbjKGLPdGNMC4GMAvu/0+T6AXzPLbgUwZa09XcoOERERkVT0X9bW2pwx5rcBPIblW7e+aa19yRhz38rfHwbwKJZv2zqM5Vu3Plm5XSYiImouke6zttY+iuUBefVjD6/6fwvgt9b52l9fZ39aPx7j6uBxrjwe48rjMa6Oko6zWR5niYiIKFSsDU5ERBS4ig/Wxpi7jTEHjTGHjTH/wvN3Y4z5o5W/v2CMubnS+9RoIhzjX1k5ti8YY/YZY26oxX7Ws2LHeFW/dxlj8saYe6q5f40iynE2xrzfGPOcMeYlY8yPqr2P9S7C90W3Mea/GGOeXznGzEFaJ2PMN40x59a6Pbmkcc9aW7H/sJyQ9jqAywG0AHgewDucPh8G8NdYvlf7VgD/WMl9arT/Ih7jPQB6Vv7/QzzG5T/Gq/r9LZbzO+6p9X7X238Rr+UMgJcBbF1pD9Z6v+vpv4jH+F8CeGDl/wcAjANoqfW+19N/AN4L4GYAL67x93WPe5X+lzVLlVZe0WNsrd1nrZ1YaT6J5fvgKboo1zEA/HMAfwHgXDV3roFEOc6/DOB71to3AMBay2O9PlGOsQXQubJAUweWB+tcdXezvllrf4zl47aWdY97lR6sWaq08tZ7/H4Dy7/oKLqix9gYswnALwB4GFSqKNfy1QB6jDF/Z4x52hjza1Xbu8YQ5Rj/ewDXYLmw1QEA/4u1tlCd3Wsa6x73Kr2eddlKldKaIh8/Y8wdWB6s31PRPWo8UY7xVwHcb63Ns+xlyaIc5wSAdwL4AIA2AD8xxjxprX2t0jvXIKIc47sAPAfgZwBcAWCvMebvrbXTFd63ZrLuca/Sg3XZSpXSmiIdP2PM9QC+AeBD1tqxKu1bo4hyjHcD+M7KQN0P4MPGmJy19i+rsoeNIer3xai1dhbArDHmxwBuAMDBOpoox/iTAL5kl4Orh40xRwHsBPDT6uxiU1j3uFfpaXCWKq28osfYGLMVwPcA/Cr/BVKSosfYWrvdWnuZtfYyAI8A+BQH6nWL8n3xnwH8E2NMwhjTDuDdAF6p8n7WsyjH+A0sz1zAGLMBywtPHKnqXja+dY97Ff2XtWWp0oqLeIz/FYA+AA+t/MsvZ1mwP7KIx5guUZTjbK19xRjzAyyvJ1YA8A1rLVfviyjitfxFAH9ijDmA5ena+621XI1rHYwxfw7g/QD6jTEjAH4XQBIofdxjBTMiIqLAsYIZERFR4DhYExERBY6DNRERUeA4WBMREQWOgzUREVHgOFgTEREFjoM1ERFR4DhYExERBe7/B1J+Y7L8fvpfAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_evaluation(flow)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/toy_data/__init__.py b/notebooks/toy_data/__init__.py new file mode 100644 index 00000000..f63267f9 --- /dev/null +++ b/notebooks/toy_data/__init__.py @@ -0,0 +1 @@ +from toy_data import * \ No newline at end of file diff --git a/notebooks/toy_data/toy_data.py b/notebooks/toy_data/toy_data.py new file mode 100644 index 00000000..6f86f163 --- /dev/null +++ b/notebooks/toy_data/toy_data.py @@ -0,0 +1,138 @@ +import numpy as np +import sklearn +import sklearn.datasets +from sklearn.utils import shuffle as util_shuffle + +__all__ = [ + "dataset_names", + "inf_train_gen" +] + +dataset_names =[ + "swissroll", + "circles", + "rings", + "moons", + "8gaussians", + "pinwheel", + "2spirals", + "checkerboard", + "line", + "cos" +] + +# Dataset iterator +def inf_train_gen(data, rng=None, batch_size=200): + if rng is None: + rng = np.random.RandomState() + + if data == "swissroll": + data = sklearn.datasets.make_swiss_roll(n_samples=batch_size, noise=1.0)[0] + data = data.astype("float32")[:, [0, 2]] + data /= 5 + return data + + elif data == "circles": + data = sklearn.datasets.make_circles(n_samples=batch_size, factor=.5, noise=0.08)[0] + data = data.astype("float32") + data *= 3 + return data + + elif data == "rings": + n_samples4 = n_samples3 = n_samples2 = batch_size // 4 + n_samples1 = batch_size - n_samples4 - n_samples3 - n_samples2 + + # so as not to have the first point = last point, we set endpoint=False + linspace4 = np.linspace(0, 2 * np.pi, n_samples4, endpoint=False) + linspace3 = np.linspace(0, 2 * np.pi, n_samples3, endpoint=False) + linspace2 = np.linspace(0, 2 * np.pi, n_samples2, endpoint=False) + linspace1 = np.linspace(0, 2 * np.pi, n_samples1, endpoint=False) + + circ4_x = np.cos(linspace4) + circ4_y = np.sin(linspace4) + circ3_x = np.cos(linspace4) * 0.75 + circ3_y = np.sin(linspace3) * 0.75 + circ2_x = np.cos(linspace2) * 0.5 + circ2_y = np.sin(linspace2) * 0.5 + circ1_x = np.cos(linspace1) * 0.25 + circ1_y = np.sin(linspace1) * 0.25 + + X = np.vstack([ + np.hstack([circ4_x, circ3_x, circ2_x, circ1_x]), + np.hstack([circ4_y, circ3_y, circ2_y, circ1_y]) + ]).T * 3.0 + X = util_shuffle(X, random_state=rng) + + # Add noise + X = X + rng.normal(scale=0.08, size=X.shape) + + return X.astype("float32") + + elif data == "moons": + data = sklearn.datasets.make_moons(n_samples=batch_size, noise=0.1)[0] + data = data.astype("float32") + data = data * 2 + np.array([-1, -0.2]) + return data + + elif data == "8gaussians": + scale = 4. + centers = [(1, 0), (-1, 0), (0, 1), (0, -1), (1. / np.sqrt(2), 1. / np.sqrt(2)), + (1. / np.sqrt(2), -1. / np.sqrt(2)), (-1. / np.sqrt(2), + 1. / np.sqrt(2)), (-1. / np.sqrt(2), -1. / np.sqrt(2))] + centers = [(scale * x, scale * y) for x, y in centers] + + dataset = [] + for i in range(batch_size): + point = rng.randn(2) * 0.5 + idx = rng.randint(8) + center = centers[idx] + point[0] += center[0] + point[1] += center[1] + dataset.append(point) + dataset = np.array(dataset, dtype="float32") + dataset /= 1.414 + return dataset + + elif data == "pinwheel": + radial_std = 0.3 + tangential_std = 0.1 + num_classes = 5 + num_per_class = batch_size // 5 + rate = 0.25 + rads = np.linspace(0, 2 * np.pi, num_classes, endpoint=False) + + features = rng.randn(num_classes*num_per_class, 2) \ + * np.array([radial_std, tangential_std]) + features[:, 0] += 1. + labels = np.repeat(np.arange(num_classes), num_per_class) + + angles = rads[labels] + rate * np.exp(features[:, 0]) + rotations = np.stack([np.cos(angles), -np.sin(angles), np.sin(angles), np.cos(angles)]) + rotations = np.reshape(rotations.T, (-1, 2, 2)) + + return 2 * rng.permutation(np.einsum("ti,tij->tj", features, rotations)) + + elif data == "2spirals": + n = np.sqrt(np.random.rand(batch_size // 2, 1)) * 540 * (2 * np.pi) / 360 + d1x = -np.cos(n) * n + np.random.rand(batch_size // 2, 1) * 0.5 + d1y = np.sin(n) * n + np.random.rand(batch_size // 2, 1) * 0.5 + x = np.vstack((np.hstack((d1x, d1y)), np.hstack((-d1x, -d1y)))) / 3 + x += np.random.randn(*x.shape) * 0.1 + return x + + elif data == "checkerboard": + x1 = np.random.rand(batch_size) * 4 - 2 + x2_ = np.random.rand(batch_size) - np.random.randint(0, 2, batch_size) * 2 + x2 = x2_ + (np.floor(x1) % 2) + return np.concatenate([x1[:, None], x2[:, None]], 1) * 2 + + elif data == "line": + x = rng.rand(batch_size) * 5 - 2.5 + y = x + return np.stack((x, y), 1) + elif data == "cos": + x = rng.rand(batch_size) * 5 - 2.5 + y = np.sin(x) * 2.5 + return np.stack((x, y), 1) + else: + return inf_train_gen("8gaussians", rng, batch_size) From 059ef83522b6efde1586ed4c40bdb7c31f6465dc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Fri, 7 May 2021 23:17:15 +0200 Subject: [PATCH 02/68] rough comments for approx_inverse --- bgflow/nn/flow/root_finding/approx_inverse.py | 59 +++++++++++++++++-- 1 file changed, 55 insertions(+), 4 deletions(-) diff --git a/bgflow/nn/flow/root_finding/approx_inverse.py b/bgflow/nn/flow/root_finding/approx_inverse.py index 3fccc9b3..03b53884 100644 --- a/bgflow/nn/flow/root_finding/approx_inverse.py +++ b/bgflow/nn/flow/root_finding/approx_inverse.py @@ -12,16 +12,42 @@ class DifferentiableApproximateInverse(torch.autograd.Function): + """First-order-differentiation of an elementwise bijection under black-box inversion. + """ @staticmethod def forward(ctx, root_finder, bijection, y, *params): + """ + Inverse pass + + Parameters + ---------- + ctx : object + context object to stash information for the backward call + root_finder : Callable + Root finding method, which takes two parameters (residue, x0) + bijection : Flow + a flow object, whose forward function returns (y, dlogp) + y : torch.Tensor + the input to the inverse + params : tuple + further arguments for the ctx.save_for_backward call + + Returns + ------- + x : torch.Tensor + the root of the bijection, bijection^-1(y) + log_dx_dy : torch.Tensor + the log derivative + + """ - def callback(x): + def residue(x): y_, log_dy_dx = bijection(x) return y_ - y, log_dy_dx with torch.no_grad(): - x, log_dx_dy = root_finder(callback, x0=y) + x, log_dx_dy = root_finder(residue, x0=y) ctx.save_for_backward(x, *params) ctx.bijection = bijection @@ -29,7 +55,26 @@ def callback(x): return x, log_dx_dy @staticmethod - def backward(ctx, grad_out_x, grad_out_dlogp): + def backward(ctx, grad_out_x, grad_out_dlogp): + """ + Backpropagation through the inverse + + Parameters + ---------- + ctx : object + context object to stash information for the backward call + grad_out_x + grad_out_dlogp + + Returns + ------- + A tuple: + - None + - None + - grad_in_y : torch.Tensor + - + + """ x, *params = ctx.saved_tensors with torch.enable_grad(): @@ -58,10 +103,12 @@ def backward(ctx, grad_out_x, grad_out_dlogp): create_graph=True ) - return None, None, grad_in_y, *grad_in_params + return (None, None, grad_in_y, *grad_in_params) class WrapFlowWithInverse(Flow): + """A flow, where the inverse is computed in approximate fashion by a root finder. + """ def __init__(self, flow, root_finder): super().__init__() @@ -81,6 +128,8 @@ def _inverse(self, y, *args, **kwargs): class TransformerToFlowAdapter(Flow): + """Transformer with constant conditioner. + """ def __init__(self, transformer, x): super().__init__() @@ -95,6 +144,8 @@ def _inverse(self, y, *args, **kwargs): class WrapTransformerWithInverse(Transformer): + """Transformer with approximate black-box inversion (and variable conditioning). + """ def __init__(self, transformer, root_finder): super().__init__() From d8d325dde00b3a16a6218e539793a731542075b3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Sat, 8 May 2021 00:29:11 +0200 Subject: [PATCH 03/68] fixes in compact interval flows --- bgflow/nn/flow/transformer/compact/compact.py | 35 ++++++++++--------- 1 file changed, 19 insertions(+), 16 deletions(-) diff --git a/bgflow/nn/flow/transformer/compact/compact.py b/bgflow/nn/flow/transformer/compact/compact.py index de42b409..e3a154f5 100644 --- a/bgflow/nn/flow/transformer/compact/compact.py +++ b/bgflow/nn/flow/transformer/compact/compact.py @@ -19,6 +19,7 @@ # TODO: docstrings and tests! + def polynomial_ramp(x, power=3): rx = torch.relu(x) ramp = rx.pow(power) @@ -28,6 +29,7 @@ def polynomial_ramp(x, power=3): _SMOOTH_RAMP_INFLECTION_ALPHA_2 = 0.3052033 + def smooth_ramp_pow2(x, alpha, unimodal=True, eps=1e-8): if unimodal: alpha = alpha + _SMOOTH_RAMP_INFLECTION_ALPHA_2 @@ -43,6 +45,7 @@ def smooth_ramp_pow2(x, alpha, unimodal=True, eps=1e-8): _SMOOTH_RAMP_INFLECTION_ALPHA_1 = 0.8656721 + def smooth_ramp_pow1(x, alpha, unimodal=True, eps=1e-8): if unimodal: alpha = alpha + _SMOOTH_RAMP_INFLECTION_ALPHA_1 @@ -137,6 +140,7 @@ def forward(self, y, cond): class SmoothRamp(ConditionalRamp): + """Smooth ramp function with variable slope alpha.""" def __init__( self, @@ -158,14 +162,15 @@ def __init__( self._unimodal = unimodal self.register_buffer("_eps", eps) self._alpha_constraint = alpha_constraint - - + def forward(self, y, cond): - alpha = self._alpha_constraint(self._compute_alpha(cond)).view(*cond.shape, -1) + alpha = self._alpha_constraint(self._compute_alpha(cond)).view(-1, *y.shape[-2:]) return self._ramp_fn(y, alpha, unimodal=self._unimodal, eps=self._eps) class AffineSigmoidTransformer(Transformer): + """Elementwise transformer, whose PDF is a sum of bump functions. + """ def __init__( self, @@ -185,24 +190,23 @@ def __init__( self._zero_boundary_left = zero_boundary_left self._zero_boundary_right = zero_boundary_right - - def _compute_params(self, cond): + def _compute_params(self, cond, y_shape): params = self._param_net(cond) mu, log_sigma, min_density = params.chunk(3, dim=-1) if self._zero_boundary_right: # avoid that any mu is placed on 1 - mu = mu = mu.view(*cond.shape, -1) + mu = mu.view(*y_shape, -1) mu = torch.cat([ mu, mu[..., [-1]] ], dim=-1) - mu = mu.view(*cond.shape, -1).softmax(dim=-1).cumsum(dim=-1) + mu = mu.view(*y_shape, -1).softmax(dim=-1).cumsum(dim=-1) mu = mu[..., :-1] else: - mu = mu.view(*cond.shape, -1).softmax(dim=-1).cumsum(dim=-1) + mu = mu.view(*y_shape, -1).softmax(dim=-1).cumsum(dim=-1) - log_sigma = log_sigma.view(*cond.shape, -1) + log_sigma = log_sigma.view(*y_shape, -1) if self._periodic or self._zero_boundary_right or self._zero_boundary_left: # if boundary constraint exist assert that sigma in [1, \infty] log_sigma = torch.nn.functional.softplus(log_sigma) @@ -218,13 +222,13 @@ def _compute_params(self, cond): if not (self._zero_boundary_right or self._zero_boundary_left): lower_bound = lower_bound + min_density.sigmoid() * (1. - self._min_density_lower_bound) - lower_bound = lower_bound.view(*cond.shape, -1) + lower_bound = lower_bound.view(*y_shape, -1) return mu, log_sigma, lower_bound def _forward(self, x, y, *args, **kwargs): - mu, log_sigma, min_density = self._compute_params(cond=x) + mu, log_sigma, min_density = self._compute_params(cond=x, y_shape=y.shape) # condition ramp with inputs (necessary for smooth ramps with trainable alpha) ramp = partial(self._conditional_ramp, cond=x) @@ -240,7 +244,8 @@ def _inverse(self, x, y, *args, **kwargs): class MixtureCDFTransformer(Transformer): - + """ + """ def __init__( self, compute_components: Callable, @@ -252,7 +257,7 @@ def __init__( def _forward(self, x, y, return_log_density=True): cdfs, log_pdfs = self._compute_components(x, y) - log_weights = self._compute_weights(x).view(*x.shape, -1).log_softmax(dim=-1) + log_weights = self._compute_weights(x).view(*y.shape, -1).log_softmax(dim=-1) return mixture_cdf_transform(cdfs, log_pdfs, log_weights) def _inverse(self, x, y): @@ -260,7 +265,7 @@ def _inverse(self, x, y): class ConstrainedSigmoidTransformer(Transformer): - + """SigmoidTransformer in a bounded interval.""" def __init__(self, compute_params: Callable, smoothness_type: str="type1"): super().__init__() assert smoothness_type in ["type1", "type2"] @@ -278,7 +283,6 @@ def _compute_params(self, x): params = self._param_net(x) mu, log_sigma, log_pdf_constraint = params.view(*x.shape, -1).chunk(3, dim=-1) log_sigma = torch.nn.functional.softplus(log_sigma) - log_pdf_constraint = log_pdf_constraint return mu, log_sigma, log_pdf_constraint def _forward(self, x, y): @@ -298,7 +302,6 @@ def _inverse(self, x, y, *args, **kwargs): class ConstantConstrainedSigmoidTransformer(ConstrainedSigmoidTransformer): - def __init__(self, mu=torch.tensor([0.]), log_pdf_constraint=torch.tensor([np.log(4.)]), smoothness_type: str="type1"): super().__init__(compute_params=None, smoothness_type=smoothness_type) self._mu = mu From 7acf3a79e8c51e44bef83b772037a7a6c5ee4428 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Sat, 8 May 2021 00:40:15 +0200 Subject: [PATCH 04/68] remove expand_as --- bgflow/nn/flow/root_finding/approx_inverse.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/bgflow/nn/flow/root_finding/approx_inverse.py b/bgflow/nn/flow/root_finding/approx_inverse.py index 03b53884..f6a16d50 100644 --- a/bgflow/nn/flow/root_finding/approx_inverse.py +++ b/bgflow/nn/flow/root_finding/approx_inverse.py @@ -137,10 +137,10 @@ def __init__(self, transformer, x): self._x = x def _forward(self, y, *args, **kwargs): - return self._transformer(self._x.expand_as(y), y, *args, **kwargs) + return self._transformer(self._x, y, *args, **kwargs) def _inverse(self, y, *args, **kwargs): - return self._transformer(self._x.expand_as(y), y, inverse=True, *args, **kwargs) + return self._transformer(self._x, y, inverse=True, *args, **kwargs) class WrapTransformerWithInverse(Transformer): From 132435058a12ea1c1e73d4ca430bf0fe18ddeafa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Sat, 8 May 2021 00:42:40 +0200 Subject: [PATCH 05/68] reduce dlogx in Mixture --- bgflow/nn/flow/transformer/compact/compact.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bgflow/nn/flow/transformer/compact/compact.py b/bgflow/nn/flow/transformer/compact/compact.py index e3a154f5..d6f06454 100644 --- a/bgflow/nn/flow/transformer/compact/compact.py +++ b/bgflow/nn/flow/transformer/compact/compact.py @@ -258,7 +258,7 @@ def __init__( def _forward(self, x, y, return_log_density=True): cdfs, log_pdfs = self._compute_components(x, y) log_weights = self._compute_weights(x).view(*y.shape, -1).log_softmax(dim=-1) - return mixture_cdf_transform(cdfs, log_pdfs, log_weights) + return mixture_cdf_transform(cdfs, log_pdfs, log_weights.sum(-1, keepdim=True)) def _inverse(self, x, y): raise NotImplementedError("No analytic inverse") From cc568ed2365f1a7a984b4433b806e65d0b8d3150 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Sat, 8 May 2021 01:03:18 +0200 Subject: [PATCH 06/68] moved reduction to WrapTransformer... --- bgflow/nn/flow/root_finding/approx_inverse.py | 5 +++-- bgflow/nn/flow/transformer/compact/compact.py | 2 +- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/bgflow/nn/flow/root_finding/approx_inverse.py b/bgflow/nn/flow/root_finding/approx_inverse.py index f6a16d50..abfe8875 100644 --- a/bgflow/nn/flow/root_finding/approx_inverse.py +++ b/bgflow/nn/flow/root_finding/approx_inverse.py @@ -157,9 +157,10 @@ def _forward(self, x, y, *args, **kwargs): def _inverse(self, x, y, *args, **kwargs): flow = TransformerToFlowAdapter(self._transformer, x) - return DifferentiableApproximateInverse.apply( + y, dlogp = DifferentiableApproximateInverse.apply( self._root_finder, flow, y, *flow.parameters() - ) \ No newline at end of file + ) + return y, dlogp.sum(-1, keepdim=True) \ No newline at end of file diff --git a/bgflow/nn/flow/transformer/compact/compact.py b/bgflow/nn/flow/transformer/compact/compact.py index d6f06454..e3a154f5 100644 --- a/bgflow/nn/flow/transformer/compact/compact.py +++ b/bgflow/nn/flow/transformer/compact/compact.py @@ -258,7 +258,7 @@ def __init__( def _forward(self, x, y, return_log_density=True): cdfs, log_pdfs = self._compute_components(x, y) log_weights = self._compute_weights(x).view(*y.shape, -1).log_softmax(dim=-1) - return mixture_cdf_transform(cdfs, log_pdfs, log_weights.sum(-1, keepdim=True)) + return mixture_cdf_transform(cdfs, log_pdfs, log_weights) def _inverse(self, x, y): raise NotImplementedError("No analytic inverse") From eaffeb8c4e895b4d8f3e3381577f1a0124a8fe74 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Sat, 8 May 2021 01:56:54 +0200 Subject: [PATCH 07/68] added missing args and kwargs --- bgflow/nn/flow/root_finding/ksection.py | 79 +++++++++++++++++++ bgflow/nn/flow/transformer/compact/compact.py | 8 +- 2 files changed, 83 insertions(+), 4 deletions(-) create mode 100644 bgflow/nn/flow/root_finding/ksection.py diff --git a/bgflow/nn/flow/root_finding/ksection.py b/bgflow/nn/flow/root_finding/ksection.py new file mode 100644 index 00000000..feeff26b --- /dev/null +++ b/bgflow/nn/flow/root_finding/ksection.py @@ -0,0 +1,79 @@ +import torch +import numpy as np + +__all__ = [ + "KsectionRootFinder" +] + + +def ksection_inverse( + f, + x0=None, + left=None, + right=None, + abs_tol=1e-5, + max_iters=100, + verbose=False, + raise_exception=True, + n_bins=100, + *args, + **kwargs +): + if verbose: + print(f"Starting bisection search with abs_tol={abs_tol:.4} and {max_iters} iterations.") + assert (left is not None) or (x0 is not None), "either left or x0 has to be given" + assert (right is not None) or (x0 is not None), "either right or x0 has to be given" + if left is None: + left = torch.zeros_like(x0) + if right is None: + right = torch.ones_like(x0) + + bins = torch.arange(n_bins) + for i in range(max_iters): + xs = left + (bins-1)*(right-left) #(bins - left)/(right - left) * n_bins + fs = f(xs) + indices = fs < 0 + + x = (left + right) / 2. + fy, dfy = f(x, *args, **kwargs) + if verbose: + print(f"iteration: {i}/{max_iters}, error: {fy.abs().max().detach().cpu().numpy():.5}") + if torch.all(fy.abs() < abs_tol): + return x, -dfy + gt = fy > abs_tol + lt = fy < -abs_tol + right[gt] = x[gt] + left[lt] = x[lt] + if raise_exception: + raise ValueError(f"Root finding did not converge: error={fy.abs().max().detach().cpu().item():.5}") + else: + return x, -dfy + + +class KsectionRootFinder(torch.nn.Module): + + def __init__( + self, + abs_tol=torch.tensor(1e-5), + max_iters=100, + verbose=False, + raise_exception=True + ): + super().__init__() + self._max_iters = max_iters + self.register_buffer("_abs_tol", abs_tol) + self._verbose = verbose + self._raise_exception = raise_exception + + def forward(self, callback, x0): + left = torch.zeros_like(x0) + right = torch.ones_like(x0) + return ksection_inverse( + callback, + left=left, + right=right, + abs_tol=self._abs_tol, + max_iters=self._max_iters, + verbose=self._verbose, + raise_exception=self._raise_exception + ) \ No newline at end of file diff --git a/bgflow/nn/flow/transformer/compact/compact.py b/bgflow/nn/flow/transformer/compact/compact.py index e3a154f5..fd95bb15 100644 --- a/bgflow/nn/flow/transformer/compact/compact.py +++ b/bgflow/nn/flow/transformer/compact/compact.py @@ -255,12 +255,12 @@ def __init__( self._compute_components = compute_components self._compute_weights = compute_weights - def _forward(self, x, y, return_log_density=True): + def _forward(self, x, y, return_log_density=True, *args, **kwargs): cdfs, log_pdfs = self._compute_components(x, y) log_weights = self._compute_weights(x).view(*y.shape, -1).log_softmax(dim=-1) return mixture_cdf_transform(cdfs, log_pdfs, log_weights) - def _inverse(self, x, y): + def _inverse(self, x, y, *args, **kwargs): raise NotImplementedError("No analytic inverse") @@ -285,7 +285,7 @@ def _compute_params(self, x): log_sigma = torch.nn.functional.softplus(log_sigma) return mu, log_sigma, log_pdf_constraint - def _forward(self, x, y): + def _forward(self, x, y, *args, **kwargs): mu, log_sigma, log_pdf_constraint = self._compute_params(x) alpha = ( log_pdf_constraint.exp() / (torch.tensor(2.).to(x).pow(self._k + 1) * self._k * log_sigma.exp()) @@ -355,5 +355,5 @@ def _compute_components(self, x, y): def _compute_weights(self, x): return torch.zeros(*x.shape, self._n_constraints + 1, device=x.device, dtype=x.dtype) - def _forward(self, x, y): + def _forward(self, x, y, *args, **kwargs): return self._mixture(x, y) \ No newline at end of file From ade7117ae97ecf1f683743c3e20e086b7d9c9fef Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Sat, 8 May 2021 01:58:22 +0200 Subject: [PATCH 08/68] added missing reduce --- bgflow/nn/flow/root_finding/approx_inverse.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/bgflow/nn/flow/root_finding/approx_inverse.py b/bgflow/nn/flow/root_finding/approx_inverse.py index abfe8875..3162ab77 100644 --- a/bgflow/nn/flow/root_finding/approx_inverse.py +++ b/bgflow/nn/flow/root_finding/approx_inverse.py @@ -153,7 +153,8 @@ def __init__(self, transformer, root_finder): self._root_finder = root_finder def _forward(self, x, y, *args, **kwargs): - return self._transformer(x, y, *args, **kwargs) + y, dlogp = self._transformer(x, y, *args, **kwargs) + return y, dlogp.sum(-1, keepdim=True) def _inverse(self, x, y, *args, **kwargs): flow = TransformerToFlowAdapter(self._transformer, x) From 4456055ecdfe96ff0c2e6014b0a9e127ecb0dece Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Sat, 8 May 2021 02:07:52 +0200 Subject: [PATCH 09/68] raise error in ksection --- bgflow/nn/flow/root_finding/ksection.py | 1 + 1 file changed, 1 insertion(+) diff --git a/bgflow/nn/flow/root_finding/ksection.py b/bgflow/nn/flow/root_finding/ksection.py index feeff26b..08564ecc 100644 --- a/bgflow/nn/flow/root_finding/ksection.py +++ b/bgflow/nn/flow/root_finding/ksection.py @@ -28,6 +28,7 @@ def ksection_inverse( if right is None: right = torch.ones_like(x0) + raise NotImplementedError bins = torch.arange(n_bins) for i in range(max_iters): xs = left + (bins-1)*(right-left) #(bins - left)/(right - left) * n_bins From 756385917f0dff11272dde6c1fb134c0fb343a42 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jonas=20K=C3=B6hler?= Date: Sun, 9 May 2021 02:59:03 +0200 Subject: [PATCH 10/68] fixed shape bug --- bgflow/nn/flow/root_finding/approx_inverse.py | 26 +-- bgflow/nn/flow/transformer/compact/compact.py | 145 ++++++------- notebooks/compact/compact.ipynb | 196 +++++++++++++++--- 3 files changed, 256 insertions(+), 111 deletions(-) diff --git a/bgflow/nn/flow/root_finding/approx_inverse.py b/bgflow/nn/flow/root_finding/approx_inverse.py index 3fccc9b3..70b3056e 100644 --- a/bgflow/nn/flow/root_finding/approx_inverse.py +++ b/bgflow/nn/flow/root_finding/approx_inverse.py @@ -16,12 +16,12 @@ class DifferentiableApproximateInverse(torch.autograd.Function): @staticmethod def forward(ctx, root_finder, bijection, y, *params): - def callback(x): + def residual(x): y_, log_dy_dx = bijection(x) return y_ - y, log_dy_dx with torch.no_grad(): - x, log_dx_dy = root_finder(callback, x0=y) + x, log_dx_dy = root_finder(residual, x0=y) ctx.save_for_backward(x, *params) ctx.bijection = bijection @@ -82,16 +82,16 @@ def _inverse(self, y, *args, **kwargs): class TransformerToFlowAdapter(Flow): - def __init__(self, transformer, x): + def __init__(self, transformer, cond): super().__init__() self._transformer = transformer - self._x = x + self._cond = cond - def _forward(self, y, *args, **kwargs): - return self._transformer(self._x.expand_as(y), y, *args, **kwargs) + def _forward(self, out, *args, **kwargs): + return self._transformer(self._cond, out, *args, **kwargs) - def _inverse(self, y, *args, **kwargs): - return self._transformer(self._x.expand_as(y), y, inverse=True, *args, **kwargs) + def _inverse(self, out, *args, **kwargs): + return self._transformer(self._cond, out, inverse=True, *args, **kwargs) class WrapTransformerWithInverse(Transformer): @@ -101,14 +101,14 @@ def __init__(self, transformer, root_finder): self._transformer = transformer self._root_finder = root_finder - def _forward(self, x, y, *args, **kwargs): - return self._transformer(x, y, *args, **kwargs) + def _forward(self, cond, out, *args, **kwargs): + return self._transformer(cond, out, *args, **kwargs) - def _inverse(self, x, y, *args, **kwargs): - flow = TransformerToFlowAdapter(self._transformer, x) + def _inverse(self, cond, out, *args, **kwargs): + flow = TransformerToFlowAdapter(self._transformer, cond=cond) return DifferentiableApproximateInverse.apply( self._root_finder, flow, - y, + out, *flow.parameters() ) \ No newline at end of file diff --git a/bgflow/nn/flow/transformer/compact/compact.py b/bgflow/nn/flow/transformer/compact/compact.py index de42b409..e00f41ed 100644 --- a/bgflow/nn/flow/transformer/compact/compact.py +++ b/bgflow/nn/flow/transformer/compact/compact.py @@ -10,10 +10,8 @@ __all__ =[ "SmoothRamp", "PowerRamp", - "AffineSigmoidTransformer", + "AffineSigmoidComponents", "MixtureCDFTransformer", - "ConstrainedSigmoidTransformer", - "ConstantConstrainedSigmoidTransformer", "ConstrainedBoundaryCDFTransformer" ] @@ -160,12 +158,12 @@ def __init__( self._alpha_constraint = alpha_constraint - def forward(self, y, cond): - alpha = self._alpha_constraint(self._compute_alpha(cond)).view(*cond.shape, -1) - return self._ramp_fn(y, alpha, unimodal=self._unimodal, eps=self._eps) + def forward(self, out, cond): + alpha = self._alpha_constraint(self._compute_alpha(cond)).view(1, 1, *out.shape[2:]) + return self._ramp_fn(out, alpha, unimodal=self._unimodal, eps=self._eps) -class AffineSigmoidTransformer(Transformer): +class AffineSigmoidComponents(torch.nn.Module): def __init__( self, @@ -186,27 +184,27 @@ def __init__( self._zero_boundary_right = zero_boundary_right - def _compute_params(self, cond): + def _compute_params(self, cond, out): params = self._param_net(cond) mu, log_sigma, min_density = params.chunk(3, dim=-1) if self._zero_boundary_right: # avoid that any mu is placed on 1 - mu = mu = mu.view(*cond.shape, -1) + mu = mu = mu.view(*out.shape, -1) mu = torch.cat([ mu, mu[..., [-1]] ], dim=-1) - mu = mu.view(*cond.shape, -1).softmax(dim=-1).cumsum(dim=-1) + mu = mu.view(*out.shape, -1).softmax(dim=-1).cumsum(dim=-1) mu = mu[..., :-1] else: - mu = mu.view(*cond.shape, -1).softmax(dim=-1).cumsum(dim=-1) + mu = mu.view(*out.shape, -1).softmax(dim=-1).cumsum(dim=-1) - log_sigma = log_sigma.view(*cond.shape, -1) + log_sigma = log_sigma.view(*out.shape, -1) if self._periodic or self._zero_boundary_right or self._zero_boundary_left: # if boundary constraint exist assert that sigma in [1, \infty] log_sigma = torch.nn.functional.softplus(log_sigma) - min_value = torch.tensor(1.).to(cond) + min_value = torch.tensor(1.).to(out) if self._zero_boundary_left: min_value = torch.minimum(mu, min_value) if self._zero_boundary_right: @@ -218,25 +216,22 @@ def _compute_params(self, cond): if not (self._zero_boundary_right or self._zero_boundary_left): lower_bound = lower_bound + min_density.sigmoid() * (1. - self._min_density_lower_bound) - lower_bound = lower_bound.view(*cond.shape, -1) + lower_bound = lower_bound.view(*out.shape, -1) return mu, log_sigma, lower_bound - def _forward(self, x, y, *args, **kwargs): + def forward(self, cond, out, *args, **kwargs): - mu, log_sigma, min_density = self._compute_params(cond=x) + mu, log_sigma, min_density = self._compute_params(cond=cond, out=out) # condition ramp with inputs (necessary for smooth ramps with trainable alpha) - ramp = partial(self._conditional_ramp, cond=x) + ramp = partial(self._conditional_ramp, cond=cond) - y = y.unsqueeze(-1) + out = out.unsqueeze(-1) return affine_sigmoid_transform( - y, ramp, mu, log_sigma, min_density, periodic=self._periodic + out, ramp, mu, log_sigma, min_density, periodic=self._periodic ) - - def _inverse(self, x, y, *args, **kwargs): - raise NotImplementedError("No analytic inverse") class MixtureCDFTransformer(Transformer): @@ -244,22 +239,26 @@ class MixtureCDFTransformer(Transformer): def __init__( self, compute_components: Callable, - compute_weights: Callable, + compute_weights: Callable=None, ): super().__init__() self._compute_components = compute_components self._compute_weights = compute_weights - def _forward(self, x, y, return_log_density=True): - cdfs, log_pdfs = self._compute_components(x, y) - log_weights = self._compute_weights(x).view(*x.shape, -1).log_softmax(dim=-1) - return mixture_cdf_transform(cdfs, log_pdfs, log_weights) + def _forward(self, cond, out, log_weights=None): + cdfs, log_pdfs = self._compute_components(cond, out) + if log_weights is None and self._compute_weights is not None: + log_weights = self._compute_weights(cond).view(*cdfs.shape).log_softmax(dim=-1) + else: + log_weights = torch.zeros(*cdfs.shape).log_softmax(dim=-1) + out, dlogp = mixture_cdf_transform(cdfs, log_pdfs, log_weights) + return out, dlogp.sum(dim=-1, keepdim=True) def _inverse(self, x, y): raise NotImplementedError("No analytic inverse") -class ConstrainedSigmoidTransformer(Transformer): +class ConstrainedSigmoidComponents(torch.nn.Module): def __init__(self, compute_params: Callable, smoothness_type: str="type1"): super().__init__() @@ -274,30 +273,27 @@ def __init__(self, compute_params: Callable, smoothness_type: str="type1"): self._ramp_fn = smooth_ramp_pow2 self._param_net = compute_params - def _compute_params(self, x): - params = self._param_net(x) - mu, log_sigma, log_pdf_constraint = params.view(*x.shape, -1).chunk(3, dim=-1) + def _compute_params(self, cond, out): + params = self._param_net(cond) + mu, log_sigma, log_pdf_constraint = params.view(*out.shape, -1).chunk(3, dim=-1) log_sigma = torch.nn.functional.softplus(log_sigma) log_pdf_constraint = log_pdf_constraint return mu, log_sigma, log_pdf_constraint - def _forward(self, x, y): - mu, log_sigma, log_pdf_constraint = self._compute_params(x) + def forward(self, cond, out): + mu, log_sigma, log_pdf_constraint = self._compute_params(cond, out) alpha = ( - log_pdf_constraint.exp() / (torch.tensor(2.).to(x).pow(self._k + 1) * self._k * log_sigma.exp()) + log_pdf_constraint.exp() / (torch.tensor(2.).to(out).pow(self._k + 1) * self._k * log_sigma.exp()) ) - self._alpha_offset ramp = partial(self._ramp_fn , alpha=alpha, unimodal=True) - min_density = torch.zeros_like(y).unsqueeze(-1) + min_density = torch.zeros_like(out).unsqueeze(-1) return affine_sigmoid_transform( - y.unsqueeze(-1), ramp, mu, log_sigma, min_density, periodic=False + out.unsqueeze(-1), ramp, mu, log_sigma, min_density, periodic=False ) - - def _inverse(self, x, y, *args, **kwargs): - raise NotImplementedError("No analytic inverse") -class ConstantConstrainedSigmoidTransformer(ConstrainedSigmoidTransformer): +class ConstantConstrainedSigmoidComponents(ConstrainedSigmoidComponents): def __init__(self, mu=torch.tensor([0.]), log_pdf_constraint=torch.tensor([np.log(4.)]), smoothness_type: str="type1"): super().__init__(compute_params=None, smoothness_type=smoothness_type) @@ -305,10 +301,33 @@ def __init__(self, mu=torch.tensor([0.]), log_pdf_constraint=torch.tensor([np.lo self._log_sigma = torch.nn.Parameter(torch.zeros_like(mu)) self._log_pdf_constraint = log_pdf_constraint - def _compute_params(self, x): - mu = self._mu.expand(*x.shape, self._mu.shape[-1]) - log_sigma = torch.nn.functional.softplus(self._log_sigma).expand(*x.shape, self._log_sigma.shape[-1]) - log_pdf_constraint = self._log_pdf_constraint.expand(*x.shape, self._log_pdf_constraint.shape[-1]) + def _compute_params(self, _, out): + mu = self._mu.expand(*out.shape, self._mu.shape[-1]) + log_sigma = torch.nn.functional.softplus(self._log_sigma).expand(*out.shape, self._log_sigma.shape[-1]) + log_pdf_constraint = self._log_pdf_constraint.expand(*out.shape, self._log_pdf_constraint.shape[-1]) + return mu, log_sigma, log_pdf_constraint + + +class UniformIntervalConstrainedSigmoidComponents(ConstrainedSigmoidComponents): + + def __init__(self, compute_constraints, left_constraint=False, right_constraint=False, smoothness_type: str="type1"): + super().__init__(compute_params=None, smoothness_type=smoothness_type) + self._n_constraints = sum([left_constraint, right_constraint]) + self._log_sigma = torch.nn.Parameter(torch.zeros(self._n_constraints)) + self._left_constraint = left_constraint + self._right_constraint = right_constraint + self._compute_constraints = compute_constraints + + def _compute_params(self, cond, out): + mu = [] + if self._left_constraint: + mu.append(torch.zeros_like(out)) + if self._right_constraint: + mu.append(torch.ones_like(out)) + mu = torch.stack(mu, dim=-1) + log_sigma = torch.nn.functional.softplus(self._log_sigma).expand(*out.shape, self._n_constraints) + print( self._compute_constraints(cond).shape, out.shape) + log_pdf_constraint = self._compute_constraints(cond).view(*out.shape, self._n_constraints) + np.log(self._n_constraints + 1) return mu, log_sigma, log_pdf_constraint @@ -317,40 +336,22 @@ class ConstrainedBoundaryCDFTransformer(Transformer): def __init__(self, transformer: Transformer, compute_constraints, left_constraint=True, right_constraint=True, smoothness_type: str="type1"): super().__init__() self._transformer = transformer - self._compute_constraints = compute_constraints self._mixture = MixtureCDFTransformer( - compute_components=self._compute_components, - compute_weights=self._compute_weights + compute_components=self._compute_components ) - self._constrained_cdfs = ConstrainedSigmoidTransformer( - compute_params=self._compute_constrained_params, + self._constrained_cdfs = UniformIntervalConstrainedSigmoidComponents( + compute_constraints=compute_constraints, + left_constraint=left_constraint, + right_constraint=right_constraint, smoothness_type=smoothness_type ) - self._n_constraints = sum([left_constraint, right_constraint]) - self._log_sigma = torch.nn.Parameter(torch.zeros(self._n_constraints)) - self._left_constraint = left_constraint - self._right_constraint = right_constraint - - def _compute_constrained_params(self, x): - mu = [] - if self._left_constraint: - mu.append(torch.zeros_like(x)) - if self._right_constraint: - mu.append(torch.ones_like(x)) - mu = torch.stack(mu, dim=-1) - log_sigma = self._log_sigma.expand(*x.shape, self._n_constraints) - log_pdf_constraint = self._compute_constraints(x).view(*x.shape, self._n_constraints) + np.log(self._n_constraints + 1) - return torch.cat([mu, log_sigma, log_pdf_constraint], dim=-1) - def _compute_components(self, x, y): - boundary_cdfs, boundary_pdfs = self._constrained_cdfs(x, y) - center_cdf, center_pdf = self._transformer(x, y) + def _compute_components(self, cond, out): + boundary_cdfs, boundary_pdfs = self._constrained_cdfs(cond, out) + center_cdf, center_pdf = self._transformer(cond, out) cdfs = torch.cat([boundary_cdfs, center_cdf.unsqueeze(-1)], dim=-1) pdfs = torch.cat([boundary_pdfs, center_pdf.unsqueeze(-1)], dim=-1) return cdfs, pdfs - def _compute_weights(self, x): - return torch.zeros(*x.shape, self._n_constraints + 1, device=x.device, dtype=x.dtype) - - def _forward(self, x, y): - return self._mixture(x, y) \ No newline at end of file + def _forward(self, cond, out): + return self._mixture(cond, out) \ No newline at end of file diff --git a/notebooks/compact/compact.ipynb b/notebooks/compact/compact.ipynb index e45ac837..3bd23aee 100644 --- a/notebooks/compact/compact.ipynb +++ b/notebooks/compact/compact.ipynb @@ -12,7 +12,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -21,6 +21,19 @@ "import matplotlib.pyplot as plt" ] }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "module_path = os.path.abspath(os.path.join('..'))\n", + "if module_path not in sys.path:\n", + " sys.path.append(module_path)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -30,7 +43,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -39,7 +52,7 @@ " \n", " WrapTransformerWithInverse,\n", " MixtureCDFTransformer,\n", - " AffineSigmoidTransformer,\n", + " AffineSigmoidComponents,\n", " SmoothRamp,\n", " BisectionRootFinder,\n", " \n", @@ -87,7 +100,7 @@ " return WrapTransformerWithInverse(\n", " transformer=MixtureCDFTransformer(\n", " compute_weights=DenseNet([d_in, d_hidden, d_hidden, d_out * n_components], activation),\n", - " compute_components=AffineSigmoidTransformer(\n", + " compute_components=AffineSigmoidComponents(\n", " conditional_ramp=SmoothRamp(\n", " compute_alpha=DenseNet([d_in, d_hidden, d_hidden, d_out * n_components], activation),\n", " unimodal=True,\n", @@ -197,12 +210,12 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -214,7 +227,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -246,12 +259,12 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -263,7 +276,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -275,7 +288,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -312,12 +325,19 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 20, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([100, 1, 1]) torch.Size([100, 1])\n" + ] + }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -340,12 +360,19 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 21, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([100, 1, 1]) torch.Size([100, 1])\n" + ] + }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -368,12 +395,19 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 22, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([100, 1, 2]) torch.Size([100, 1])\n" + ] + }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -405,7 +439,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -416,7 +450,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -439,14 +473,14 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "it: 900/1000, nll: -1.753\r" + "it: 900/1000, nll: -1.761\r" ] } ], @@ -456,7 +490,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -465,12 +499,93 @@ "text": [ "Computing energy plot...\n", "Sampling ground truth...\n", - "Sampling model...\n" + "Sampling model...\n", + "Starting bisection search with abs_tol=1e-05 and 100 iterations.\n", + "iteration: 0/100, error: 0.95456\n", + "iteration: 1/100, error: 0.9293\n", + "iteration: 2/100, error: 0.90683\n", + "iteration: 3/100, error: 0.8972\n", + "iteration: 4/100, error: 0.57549\n", + "iteration: 5/100, error: 0.39775\n", + "iteration: 6/100, error: 0.22548\n", + "iteration: 7/100, error: 0.11836\n", + "iteration: 8/100, error: 0.059673\n", + "iteration: 9/100, error: 0.029727\n", + "iteration: 10/100, error: 0.014701\n", + "iteration: 11/100, error: 0.0073451\n", + "iteration: 12/100, error: 0.0036977\n", + "iteration: 13/100, error: 0.0018435\n", + "iteration: 14/100, error: 0.00091162\n", + "iteration: 15/100, error: 0.00044754\n", + "iteration: 16/100, error: 0.00021845\n", + "iteration: 17/100, error: 0.00010628\n", + "iteration: 18/100, error: 4.7743e-05\n", + "iteration: 19/100, error: 1.8567e-05\n", + "iteration: 20/100, error: 9.9987e-06\n", + "Starting bisection search with abs_tol=1e-05 and 100 iterations.\n", + "iteration: 0/100, error: 0.73037\n", + "iteration: 1/100, error: 0.75983\n", + "iteration: 2/100, error: 0.57355\n", + "iteration: 3/100, error: 0.47781\n", + "iteration: 4/100, error: 0.25884\n", + "iteration: 5/100, error: 0.12872\n", + "iteration: 6/100, error: 0.064533\n", + "iteration: 7/100, error: 0.032572\n", + "iteration: 8/100, error: 0.016246\n", + "iteration: 9/100, error: 0.0080941\n", + "iteration: 10/100, error: 0.0040419\n", + "iteration: 11/100, error: 0.0020023\n", + "iteration: 12/100, error: 0.00099915\n", + "iteration: 13/100, error: 0.00049984\n", + "iteration: 14/100, error: 0.00024462\n", + "iteration: 15/100, error: 0.00011712\n", + "iteration: 16/100, error: 5.3406e-05\n", + "iteration: 17/100, error: 2.1935e-05\n", + "iteration: 18/100, error: 9.9987e-06\n", + "Starting bisection search with abs_tol=1e-05 and 100 iterations.\n", + "iteration: 0/100, error: 0.79407\n", + "iteration: 1/100, error: 0.5806\n", + "iteration: 2/100, error: 0.45161\n", + "iteration: 3/100, error: 0.34981\n", + "iteration: 4/100, error: 0.21019\n", + "iteration: 5/100, error: 0.11319\n", + "iteration: 6/100, error: 0.051066\n", + "iteration: 7/100, error: 0.024652\n", + "iteration: 8/100, error: 0.012184\n", + "iteration: 9/100, error: 0.0085212\n", + "iteration: 10/100, error: 0.0041946\n", + "iteration: 11/100, error: 0.0020293\n", + "iteration: 12/100, error: 0.0009461\n", + "iteration: 13/100, error: 0.0004456\n", + "iteration: 14/100, error: 0.00021285\n", + "iteration: 15/100, error: 9.65e-05\n", + "iteration: 16/100, error: 3.8326e-05\n", + "iteration: 17/100, error: 1.2398e-05\n", + "iteration: 18/100, error: 9.9987e-06\n", + "Starting bisection search with abs_tol=1e-05 and 100 iterations.\n", + "iteration: 0/100, error: 0.50732\n", + "iteration: 1/100, error: 0.35421\n", + "iteration: 2/100, error: 0.23326\n", + "iteration: 3/100, error: 0.15495\n", + "iteration: 4/100, error: 0.10143\n", + "iteration: 5/100, error: 0.053316\n", + "iteration: 6/100, error: 0.027018\n", + "iteration: 7/100, error: 0.013552\n", + "iteration: 8/100, error: 0.0068004\n", + "iteration: 9/100, error: 0.0034032\n", + "iteration: 10/100, error: 0.0016899\n", + "iteration: 11/100, error: 0.00084066\n", + "iteration: 12/100, error: 0.00041842\n", + "iteration: 13/100, error: 0.00020385\n", + "iteration: 14/100, error: 9.644e-05\n", + "iteration: 15/100, error: 4.3631e-05\n", + "iteration: 16/100, error: 1.6928e-05\n", + "iteration: 17/100, error: 9.9987e-06\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -482,7 +597,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -494,7 +609,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAesAAAHiCAYAAADI/ORpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABab0lEQVR4nO3de5Rc110n+u+uV3dXd6tLrVa33g/LUhRhxy/FsZWnEuMkDEwmN2RB4JKVLBgnPIYBAtcD98IwhIGYIU8GSHJzM1keZpG7jANkwCSOLybJWFZiO7Yj27EVWe9nq9Xq96O6q/b9o9t2//Zvt+r00amqXVXfz1pey7t616lTp06dXdq/3/ltY60FERERhStV7x0gIiKiK+NgTUREFDgO1kRERIHjYE1ERBQ4DtZERESB42BNREQUOA7WRDVkjNlmjLHGmEy996WajDG/b4z5q3rvB1GzaOoLBlG9GGOOAxgAUFry8K767A0RNTr+y5qoen7CWtu15L+z9d4hImpMHKyJ6sgYs8EY81VjzLAx5ogx5t8uPt5ujJk2xvQttv8vY8y8MWbVYvsPjTGfWmabHzDGHDXGjBtjjhljfnbx8R3GmH82xlwyxgwZY/6HMaaw5HnHjTG/ZYz5vjFm0hjz/xhjBowx/7S4rYeMMasX+740nX+XMeasMeacMeYjV3iftxljDhhjRowxTxtj3lJpf4noFRysierrrwGcBrABwE8C+CNjzNustTMAHgPw5sV+bwJwAsDrl7S/6W7MGNMJ4DMA3mmt7QawD8BTL/0ZwB8vvtarAWwG8PvOJt4D4EexMGX/EwD+CcDvAOjDwvXiV53++wHsBHAngP9gjLnDs08bAfwjgD8E0AvgNwHcb4xZW2F/iWgRB2ui6vm7xX9Jjhhj/s79ozFmM4A3ALjbWjtjrX0KwBcA/Nxil28CePNiMtprsDCovdkY0w7gtQC+vczrlgFcZ4zpsNaes9Y+CwDW2iPW2m9Ya2ettRcBfAKv/Bh4yZ9Zay9Ya88sbv871tonrbWzAP4WwE1O//9krZ201h4C8N8AvM+zP/87gAestQ9Ya8vW2m8AeBzAj11pf4noFRysiarn31hrC4v//RvP3zcAGLbWji957ASAjYv//00AbwFwM4BDAL6BhcH1NgBHrLVD7gattZMAfgrAhwGcM8b8ozFmNwAYY/qNMV82xpwxxowB+Css/It5qQtL/n/a0+5y+p9y9n2D531uBfDeJT9cRrDwI2X9lfaXiF7BwZqofs4C6DXGdC95bAuAM4v/fwDAqwC8G8A3rbXPLf79X8EzBf4Sa+3XrbU/CmA9gOcB/N+Lf/pjABbAa6y1q7DwL15zle9hs7PvviS6UwD++5IfLgVrbae19mMV9peIFnGwJqoTa+0pLAzIf7yYUPYaAD8P4H8s/n0KwBMAfhmvDM4HAHwIywzWiwlh/3oxFjwLYAKv3D7WvdgeWYwj/1YCb+N3jTF5Y8yPAPgggP/X0+evAPyEMebtxpj04nt9izFmU4X9JaJFHKyJ6ut9ALZh4V+kfwvgPy7GdF/yTQBZAN9d0u4G8K1ltpcC8JHF7Q1jYdr8lxb/9p+wMKU+ioWEr68ksP/fBHAEwP8H4E+ttQ+6HRZ/lLwLC4lqF7HwL+3fWtzXK+0vES0y1tp67wMRNRhjzDYAxwBkrbXzdd4doqbHf1kTEREFruJgbYz5ojFm0BjzzDJ/N8aYzywWdPi+Mebm5HeTiIiodUX5l/WXALzjCn9/JxaKIuwEcBeAv7z63SKikFlrj1trDafAiWqj4mBtrf0WFhI/lvMuAPfaBQcBFIwx65PaQSIiolaXRMx6I2RhhNN4pagDERERXaUklsj0FVXwppgbY+7CwlQ5Ojs7b9m9m4WKiOjqHX7iaKR+u265psp7kizf+2q090DSE088MWStXbvS5yUxWJ+GrGK0Cf4qRrDWfh7A5wFg79699vHHH0/g5Ymo1f1o6r2R+n3j8fuqvCfJ8r2vRnsPJBljTsR5XhLT4F8F8P7FrPDbAIxaa88lsF0iIiJChH9ZG2P+GguLCfQZY04D+I9YqKgEa+1nATyAhdVzjgCYwkLJQSIiIkpIxcHaWutb8m7p3y0WahcTEQXNO61cvvK0cpTnRJ6Gr/BaRMtJImZNRERVwMGdXsJyo0RERIHjYE1ERBQ4ToMTEa1Q1Bh1peclMc0dJw5fze1QdXCwJqKmlL5eF1362tMfXfF2kkomizvAEwGcBiciIgoeB2siIqLAcRqciIJXzbhsEtutFsaR6SUcrImo4UUZwJKKGYc2WCa1P6G9L5I4DU5ERBQ4DtZERESB42BNREQUOMasiYhWIPRFO5bbv6X7E6UPhYWDNRG1BN9AVMtCJRwI6WpwGpyIiChwHKyJiIgCx2lwqoiFGaia4p5flRbFeMcNv6ueE6c2eC3tv/Me0Y5ygWbN8dbAwZqIgletRTHi/OisZex7/o69ePjBu1f8vErviz+2Gw+nwYmIiALHwZqIiChwHKyJiIgCx5g1JSJKkhAT1SiqWiWHxT1vk3it9PW7daeBrorP43emNXGwpop4caBa8g5ijijnZOnQ80nsTmRJfE/aLkyIHyWNtqQnVQ+nwYmIiALHwZqIiChwnAZfBuOrV4/FGihJlc6nOIVUquVqXoffG/LhYE2JiJqUwx885Kr3IJtUYZQknsd/JNByOA1OREQUOA7WREREgeM0OCXCd18skStKeKTW59LS16v17V5xxJkqj3PfOkNZYeFgvQyekEThmHrPbaKdv/9gxedE+Q5H/WFQq+sBrzu0HE6DExERBY6DNRERUeA4WBMREQWOMesAVOveyqS2G2kBAmo5Uc6vqDHhJJLK3G0M37RatHufvBx725UW02ilBEsuLFIfHKwpEb4sWn6JyZW+frfKQnYHulnPylOu+Tv2inbbhYmr3zn49y9OQRbfdpIS53sVZ198r8PqavXDaXAiIqLAcbAmIiIKXDDT4LwB/8qSig+y9jC5fOeEO80MAA8/ePeKt+XLb7j1A58Q7d6KW62t/XfeI9q+i6Tbpy1KH2eqfrkCLFf7feS1tDkFM1i3smp9idy4Wdx4k++CW614HDUOd0DPPPS46jO+qyDac51G9Tn+bjlct43o15qVm0HbSE60p96qh3wzL9vzHbpPZtqKdufZOdXH98NF7d9Al/gx4w7UzYIDfv1wGpyIiChwHKyJiIgCx2nwJrfS+z9903e+eFyc2Dfj5WGIGw7Z/fufFO31SexME7nh1145PlcTh6/WfcxxPnd+P8MRzGDNk+LKohyfSvevxi1m0ggrEVF8vvNicI+MCbsxYwA4eWdWtEvvuk13SsuYcMeAvh+6OCO3M5eyqk86UxbtsbN50U7N6lh4CvKx4ZvnVZ/+R9JyX3r0JXG6T05AdgyVVZ+JjZUnKd34fTf0cU/iu8b7o5sTp8GJiIgCx8GaiIgocBysiYiIAhdMzJpWZrnEsTj3P4t4VoR7SiNtB8ksGhJ3O63KPX6+e4T5pW8slb5XjEe3Bn5vW4ib4AIA+fsPinbmoccTG2RdHHTDMPr+20V7ql8nZ01cPyva2XadnHVt/5Dc7kyH6rO5e0S0V+emVJ/ZsrwMDc7ohTzmy3IS8GJ7UbRHjhfUc8oF+R7McE71Gdsm3/uq46oLit2y3TGk+/R/5oBo+5L2Mg/J5LGS3kykQjNJ4aDfWDgNTkREFDgO1kRERIFrqGlwFqivbOkxintf9ZW2+RIe89pLMk+BKI6krgW8pqxcQw3W9IrZAR3XqxTfcuPTQHIDelJfNH5hr86lD+0T7dEdusBIdkLGafvecE71GUjLGHVv27Tqc2PPKdE+46mcMl2SBU/OTPWoPlPzss+x0/2qD2adScB2GfHtfUZPEmamde29737pN0Tb/QHk+151npUrjnl/NDmL5sQVJUHQFeU7w3h04+M0OBERUeA4WBMREQWO0+ARxY2XVy3GcxX3Q4esVWJZUd5n1EVYrvnUJ17+/wL0bVhUG5WmmkNbF36li/xQfTXUYN2MF+24lotPLz1G7sVj6j16oYW5zsoXdx73cB3+4GrRHr5BxnILm0fVc24dOCnaZc8A352ZEe35clr1GS+1i/aJCb3W1JlxGaMe++Fq1ce4t3B36Di7G5Ne87nvqj5xzlN3sIwS2/UNsEnFhOP+YFupuLkqzE2pH06DExERBY6DNRERUeA4WBMREQWuoWLWVFnISSOtkjwWV8ifHdWG+x3xxZYrfY+qeU81v8P1w8E6orgnZDVP5ErJKG6BjP4Dw2obpUPPq8fwpavetdha5YsfJcHHXXhlYqOeCCu3XzmhbGvPZfWcTEo+Jw2d0NWTkUVQTkzr5LHvXdok2mPT7arPxIlVor3hEf1abrEeXyJk/v4D6rFqnCuhfc+9388YomSis3BK2DgNTkREFDgO1kRERIHjNHiCar3QSLVinIxLUTOqd2Gj0ESZ9t5/5z2i7RswkoqhN8MxrSYO1g3KF4PyLUKwlBsDBQDsug2P3PeRl5vVjFvxy/gKNxbp5hcAwMirZHw3t2Vc9ekwss+/2vysaN/YeUI959isXCgja0qqz3dHt4n28TEds75wScaj8092qD6rirLdfdiTN+G08/cfbNlzJYn3fTULeyx9rjtQAwsLiyxd1IRx7trhNDgREVHgOFgTEREFjtPg1HAaLYbom07kF4+IVoLXjAbhxqiHb9ILIoxcKxdk2PgtGTBsuzBR8XVCHvSaybnflDHqia1l3alTrnDxzmueU13G5+W9zW0p+ZycJx7txqiPTq9VfYZn83J/T6xRfdKjcnGPnA6po+dFeQ4mdd9wHKHdQ11PUd7T0tj01WzH14ex7pXjNDgREVHgOFgTEREFjoM1ERFR4BizrrEo9ze+/r0fV3/vrtoe1U+ti8jUiipWU+H+d1q5KEmG1UpEDL24SrN+r1odB+sGUangCQB0nZHtYo/8eDMP1S+5J0mNdtGZ3JBVj806NUZSvbOqz01bT4t2PlVUfa5fJft0p+UCHOfnetRzfjgti6J858JW1WdkTCaY5S7oS4Wz1odKJgOAzEOPq8ca7fOj5PEcWDlOgxMREQWOgzUREVHg6jYNfviJoyq20qxTI1HuKRR9POv51koI8a5K50U9i6JE+SyjrFVNYah1XLtWrx/ndX2a9ZrciCIN1saYdwD4NIA0gC9Yaz/m/L0HwF8B2LK4zT+11v63hPc1eFFv/q80+OTvP6ie4w4Akxt0UZSOIVlYo/vwiGjP3rFXPaeemrVYgptfMN9hVB+zUxaouX3TSdVn7yq5CMdAdlT12Zi5LNojZRlrniq3qeecm5Zx7EunC6qPG6MuHLGqT8+9j6rHfKpxwY9bjKNWrx3ludU61znANqeK0+DGmDSAPwfwTgB7ALzPGLPH6fbLAJ6z1t4A4C0APm6MySW8r0RERC0pSsz6VgBHrLVHrbVFAF8G8C6njwXQbYwxALoADAOYBxEREV21KNPgGwGcWtI+DeB1Tp//CuCrAM5i4Zbgn7LWeoodE9AcU71EUYWcg9AqeM1pfFEGax1wW/iX9FJvB/AUgLcC2AHgG8aYb1trx8SGjLkLwF0AsGXLFnzjRPN/IaNcmNx+vj6D++SNuVMDehuZKfejKoiWLxZ+pf2oh3rGIuOY9+QBuAumDL+roPq8eu2QaGeM/m17bdt50S6kplSfKSujTSMlGbM+PqMX4Hj2/DrRNjN6gs29hzo7qWPWU++5DY/c9xH1+FKtOkg0wnlc79enlYkyDX4awOYl7U1Y+Bf0Uh8E8BW74AiAYwBUSqy19vPW2r3W2r1r1+qVfoiIiEiLMlg/BmCnMWb7YtLYT2NhynupkwDeBgDGmAEArwJwNMkdJSIialUVp8GttfPGmF8B8HUs3Lr1RWvts8aYDy/+/bMAPgrgS8aYQ1iYNr/bWju07EaJiIgoskj3WVtrHwDwgPPYZ5f8/1kAdya7a/XFpJfGFUJhF1qeWuiEXtaq1x1+ZyvjQh4Nougsu5XRuUYorpJttygKWFnrqrnFaS7t0OUExt8qkwHXXTuo+mztHBbttxWeU3360+OiXfLkemZREu3Hx7eL9uFxnRsyOyILpWRm9Xa7zsiEsijJiT7uxZYDdX1w0Gt8rA1OREQUOA7WREREgeM0eCA4PUiNjnFHourhYL2MWl5g3DholFWbyln9WG5MP7ZU6dDzK9kt8hi+SS6gMnxDSfXJrpkR7Vf3nld9bu0+JtpbMsOqTz41J9plq2PL35veJtojcx2ifeS8jlnnLsqTp/8JXZDFzXfQ7zKerz39UfVYPQunhPZDIrT9qZVWfd8rwWlwIiKiwHGwJiIiChynwRPEmN0rGvFYtOo9rlej0Wt/t8pn3irvs5lxsA7A7ECXaF+8Ud+7O90v73tNzXvuuZW35artYkAvOkFXx8zpz+HmTadF+9r8RdVnR07ee70hM6P6XCzJ2PLxOb0ox3i5XbTPT8sb8ktj+lzqckLoo9v1BFtuVJ87Dz94t3goqQGAgwZRZZwGJyIiChwHayIiosBxsCYiIgocY9YUtCQT1dxtMVZKzYDJY62Bg3WC4n5BMg89Ltr5DberPrO9MpGpnLGqT9eZK283SrGVpNTzYuF77ShZy1H2eWKj/Bw27L6g+vS3yUy/geyo6nONkw04VdaJagWnKEq70waAB8+/WrSPne4X7ewl/RVPz+r29/7y18VjSR2v0DXDe4iiVd5nM+M0OBERUeA4WBMREQWO0+BEy/AurvLjvfqxJtBoxU3ixGkbsVBPLTH2HTYO1jXmO/n333mPaE/16/hl2qmZkfUU4+h90lkMwhOj9i2kELKkLhZJxeunts2L9mpPn2vzMo59c/sJ1WeknBbtdqMX0xgvy6/n09NbVJ9iyfkKz1aeLOs/IM8TLvDS2DigtgZOgxMREQWOgzUREVHgOA1eZaHHgaLGKuPEA5O4F7qar+3GpN3p4Fre6kaNI6nvTJKvVY3XprBwsA5QcZV+bK5HxjRTszpmfW6/TH7q/8yBRPerkbmxem/ymMM9ngCQ650Q7b19J1WfduPcH21Kqs+mtIxZT1kdsx628ut5aa5b9ZmZd77CJXleuIu7AMDgPud97dun7rMOHRcMSR6PT9g4DU5ERBQ4DtZERESB42BNREQUOMas60Aljdyxtz470sRCT+xrBjzGjYOfVePjYB2A0R25in2yo3ISZO3TOiHJXWQirnom7yTx2lEyaH3FYdziNO6CFwCwdpVMMEsZvaDKNblB0c57Cp4MleVjkzat+hwuDoj2xdku1SebktvJjsjtZCfVU1BqA57+VGMllDWCagx+HFDpJZwGJyIiChwHayIiosBxGrzFNNqCDUmqeG/1gJ5mblbuedCq062+c6LR6ue7WuU73moLs3CwrrIo8dRSm2wXtxRVH5OWscnT63WMc+DbMmY9+v7bRbvn3kcj7WOj872fKEVQij3y6zB8nY41r52Xx319blT1mbLyA203Opcga+Sk1mNT61Wfk8U+0T47pavlnD9XEO2cXGfEG3df87lkiuU023kTVaO+70bdb1rAaXAiIqLAcbAmIiIKHAdrIiKiwDFmTUKrJW1Q84qbPMYCIhQiDtY1Nu+pVjYt84iQyupVmjI5+Zg91a633SHb/QeG5QPX7274TNe4orzvXX/4SfnAKp2dtWfNBdHOp3Sf7tS0aI/ruinIWvl5ljyTXF3pGdE+O9qj+phx+RXuGJJ/Xy6ZjIPPAndZ1GbQKp9tq7zPl3AanIiIKHAcrImIiALHafAqU3GzFiq8ERL3c/BOf/7BvhrtDa1UpfizL86cvn53pO2s9PVnPd/hyQ1Z0e48O6f6ZB56PNJrhTK9y/yVsHCwrrG2CxMqfnrd/yFjpW2dOg46NS0X+ygVdFy7dF4W7Di3v3fFCza08hexuFoWQUlldFGUjrQsWNOTnlJ9Oo3sU/bErKecSa2psl7M5fJ8p9wfz6Ihq16U25ktyL+7hXFaifuDzDd4RxH3eURJ4jQ4ERFR4DhYExERBY7T4HXgrpuMGyuvZ53Ea7VdmPD2adXbuSgM6vsA4OEH7674vBt+7ZXwUX+ie1RfN//iK+8rSh133zR9nO90nAVAGNeuHQ7WVebGzXz3Wc/2yvZAflr1mXMWkCh1zqs+swVnkYkDekGQVuV+Dr5YbrpPHvdUSseIs0bGsdOeOHI+Nee0dZ+z83Kxj5lyVvU5PbNatCcn21Qfu0Puz7X//qBo+863ZnBuf2/FPpc+JBMGJzbqPh37ZZ+5Tt1n9WF5jEe36wnJ/KD8jEd36B/g/RfkoOpLcnT3ud446IaD0+BERESB42BNREQUOA7WREREgWPMmlSSCONUVC3ehCRPXN1NOtPRerqSKMVfapWERsngYF1l7sD3+vd+XPWZ63YSWKY6VJ++VTKT+0JpleozvVlOlLhJLmsear5FC5JUHpSLo/S/6qLqsyojk9DWpMf1dqwR7ZFyWvUZKcvPeLysF2Y5NVmQ2x3WQ9bGb8m2m6AUJZu43ty7FHwVwnyPLXXCU32u1C6Tvqznaje6WvYxug4OspPyezW5WXea2Ckf6+jTxXKObpRJccW7blN9uk7I9vE/qpxw1v+EfO3uwyMVn+MT90c6f9zXBqfBiYiIAsfBmoiIKHCcBq+yWz/wCdHWd9OGxxeXaqSpLsbVVibK8fIV3vDdJ+yeJ3EXzqDqc0NyuVFZuyHqwiNUGxysa2y6T09m5C7Ldmqrjol155zFPVaPqT4XXlwv2sXule9fs3IHm+ykLlRi2z0BS8dz4/IYb2y7rPqUcvIznvMES/NGfp696UnVZ1VW9knNGdVnYqN8rOtM5fdQT1EG/eH9Ok473ec8x4lHlwZ0AaCe1fKYGn34MDkl8wC2rb2k+my6bUTu36yunLK2XcbdJ+d1UZSeLUdEe3RO56YMX5cX7bOjParP+Ijscz4j/wlw6Ud0wRinTo8q9LISjfTDvZlwGpyIiChwHKyJiIgCx2lwohZUrbg+Y9TNz70HPsqiK5VwQZDKOFhXWc+9j4r24K967gfdKe/J3FbQcdB8RsbkLk/nVZ/SVnkPcP55ee/u1Hv0fZ0A8Mh9H/E+3qh8X3D3YjC9z3f/qozjXRrXscmb+k6LdndKL7pSSOl7bF2n5taI9tOTm1WfCSfuWer2Ld4i45XpWTlZNv2hffjeX/66eCxOAqHvOb74cyWD+3Q8derd8rOYXaPjqdZ574W1Mka8Jq9j/tcVzol22eqJxDU5uZ18Sse+t+aGRDtr9Odwdk4uunJ9+2nVZ6Qsv7NHZyuvFXauoGPWD2d3ivZ4l/yed3Y4+S0AJr8jg/6Xd+ljkZ2U51svmnMRmEbFaXAiIqLAcbAmIiIKHAdrIiKiwAUds04qtsYkhSuLkmzUSMeQRVGkOElfTBSjqHznSpxFQujKgh6sm4E7yN38i59UfdwFJM6u0ot0vGH90Yqvde60THJxC2YMPOZURkDrVClyk6F8BWPMjJxoymZKqs/4nPyshub1ZzVrZdLXTFnXrRvIjop2W0onLRVLcgEQk9aFXMrON7hjqPKiDunrd6/4YholOdG3SI3azkDl17I9+lh0F2TS3o/0nRft3qxO6uvPyUVW2tzKIACuyQ2Kdtboz7zdyOcV0jqp8K0dMgmtK6UXXZkoy4Ir1+cuqD7jzgd6qUMnkr6x+wXRPjK7TrSPTq9Vz3nyDfI9TMzq/bt8Xn4pus7o4cEt6tR/YFj1iaOR/jFQL5wGJyIiChwHayIiosC15DR4LePa6rU+VHl9WqJGEWXqm1qPG+5z7/WnlQt6sI4zgIYe+8hMexaQcGJ023o8RVGcYg2+Ag99G2QcdHK1jEtdgA7UbnxI72PoxzAJ8zoUqBbymJrQcb3nhmXQtTOjC1Bs7ZCxye7UjOqTdgqwnJ/Rse9SWX7GbiEQAJg5rouMiG14VsaKwn1eN3QBlPFdBdH2Fdpod0KavoInpk8ew3W946rPzWtPibYbj/YVM9mUky8+VdaLa6SN/D668WkAWOMssrLZk8vQlZKLckyV9f50GJm70JPS14JtGbmdsbKOxZ8tyfNgV1bGyw+3OaueANjsfBDHZ9aoPj/okOf2sX+tY9/pC/IYZqZXqz7zHZ4VU+iqcRqciIgocBysiYiIAhf0NHg9Rb1XtxWmjKn58D5qqiU3hr3mcwdUH15Lr6wlB+tanhTu/b3uwh4AMHjb60Q7l9b3mV52gqzr2kdVnzUDMpb1z8d3ibbndt+W4cZXM561Ntqd+0pn1uqJp44BGdM8M1VQfWade2Vf3Xle9XlmWi7ckTE6lptNy9jo3Hxa9Sm1q4eE+Tv0YgxtF3TsuxJf7Pvyj8tkyfkO1QXD+5yY/pg+CdetGRPtvg69KIdrdUb22dmmj/GpoozLFtL6Q3cXXUlBfw5zVh73s/M61nzeyLyEcU98vKTyTPSH58bHez1x7awTEt6SltspQeZMAEB/Wsb4r20rqD7b2uXzvp29VvV5Lifv6R6Z0ckfbsmAvL6dnGLgNDgREVHgOFgTEREFjoM1ERFR4FoyZk1XxsVQiKjWeN25Mg7Wy0jqJHETc3wJP66OtC7MsC4nk3DcpBffY50dMrnncqFLPeeSU1HNl6XZDPL3HxTt0d+sXEnOk/OFoTF5DGc79FdopiQfG5zWxWiKZflZla0uJHF+TBZK8SWY5Z28qrlOuZ38/XqhFl3SQ5/vbrb4uf26+Mrqw/IAXbxBT9TZonysY71OHiu0y4Uxru2+qPpsaZNFPdwFN9xkMkB/Hy7O68/BfazHk4Q2XHI+c0+mZso5WSY8mX8vTsoiIzs69ft0C7lMlnVhHjdR7mJOngQjZV2oZFtGFlra7SxgAgDtzkInc736fBvokIlqj7ZvU32mTspj2jaiz4vR998u2r7EW5I4DU5ERBQ4DtZERESB4zQ4rdhyBWNqFV9ibCt57jF16wMQ1YMbjqm0DnszXxsiDdbGmHcA+DSANIAvWGs/5unzFgCfApAFMGStfXNie9lEij2eQ56W8a5j4zo+uN1Z3H5r25Dq8+zURtF+Td9Z0T44ows1TEzIuOjU7zX+qmC+L6f7Jc7ptSLUYzPrdEGK6csyFumLNc858eiN3bqAzfC0LCbR36kLlZTLctvFi7rqSJdTc6TzrIw7+nIk3HPQjecDOtcivU+fF+dfJ/ev1KcXr0hl5bm9rmdM9XGP4dEJvRDFjnYZYx2ck+etG8P2PXau2FOxT9YUVJ9nxjaIdm+bjrsfG5Mxc2P0uTM4LmO5j5W2qD6FThm/n5nX14tbB06K9vfSW0V7XZs+346nZbz8+rZTqs+alHxfr24/o/q4Mf3JAX1NOZKTn9/wrP4807OVF/vgD0ap4mBtjEkD+HMAPwrgNIDHjDFftdY+t6RPAcBfAHiHtfakMaa/SvtLRETUcqLErG8FcMRae9RaWwTwZQDvcvr8DICvWGtPAoC1VqcaEhERUSxRpsE3Alg6Z3IawOucPrsAZI0x/wKgG8CnrbX3JrKHFIT9d97z8v/HTXSoZjzJ3XazxKmI6BWt/D2Pct31BRfcgEwGwC0A3gagA8CjxpiD1trDYkPG3AXgLgDYskXHa1rBdJ+ezGg/Ix8b26Tv0Ryak/d6bsnpmHVfVsY93ftM23J6gZDRHhlTXP2c3r+eF2Usst6xJPcLGmWFtCj3t7v3mA//2W2qj3Emo3xx5NmsvDc2m9Lx1Mlp2ee5szqemmqXz2s/r+97LTq3DrvxaPe+ayBaXPvijTIWmR/UMdieF+W2R6HvPy6vl0H1jqyuIZDPyMd2dumJuRem1ov2+RkZs96Ul/cRA8C8kzvw/JiOzk0U5eeQz+q4u77ffUD1KQ4739k2fZN+algen3JWH9ORi/IDnevSfR4tyXNwYly+9tZ1eiGPXT3ynu4fTuv38NquY6I95VmMxI3x39JzQvUpOgvZjGzVi30M98lj0fOiPgfTzoIzvsVkXM08eEeZBj8NYOkSQZsAnPX0+Zq1dtJaOwTgWwBucDdkrf28tXavtXbv2rVr3T8TERGRR5TB+jEAO40x240xOQA/DeCrTp+/B/BGY0zGGJPHwjT5D5LdVSIiotZUcRrcWjtvjPkVAF/Hwq1bX7TWPmuM+fDi3z9rrf2BMeZrAL4PoIyF27ueqeaOExERtYpIuULW2gcAPOA89lmn/V8A/Jfkdq3xRImdNrOQ3r/alwgxayJqLG7RFKBy4ZRGxQpmNbA06cE3oLmFSIaG9YID2Q0ysaPsiWDc0CGTPba3yeSnwT693aecxSEmRnWiU6lNJpqsv6C6REr+qBY3QSrzkF68IvPQ4+JzWJrd/pKp98iEstxlfYxTTo7ezI5Z3WdEJs+MTukkNDchKd2lE6/SJ+Tz8r7j7qzzMLFR7nNa7x6G98jPc65T93EX6fAlqs04tXtK/fo9pC7KHSxu0Elyl50CMYeHdD5Lu5OYlsvI74O7eIqPm0wGAIOX5XeiVNT7t/Gr8vO8vMuzYInz1XIXWPFpG/Hso6xrhK7Tnvze0wXRzDo1Ry4/5mwEwIM3ymOa7tDJpkPbZBJrX5su1LO745zcjso1Bl5XkIlqGc+KON8/LxMGj/6U/o7s+rdXvqbUO9G11lgbnIiIKHAcrImIiALHaXAiImoazVo4hYN1ANzY1fSMjpudmJILBazO6sUE1mXkhtKQsaLrunVhfrdwxGNdq1Sf2XkZNzu3Xy800nZT5cXkoxQmiePhB+9e8XN8C6q4cdnMtOqCOSc2mTuh46DFPhlPLc1HmMC6oAvhuNwYMQC0D6/8OQOPycIfozt08Qs3Ltt1xrOoyTp5fmXP6u3MrZOvdXJI71BxTD6vq29K9ZmY0cd5qcERnY8xNyKfY2b055CZlI91eI7n6HbZ9h1zN8bffXjEv6NLzA50qcd6n5yo2MfVdkHHll3j21aLdsdz+rP69tirRDu9SheIOb5JXofmy/qYvrXvBdFe164XFjnZWRDtVEqfX0f/RF5Tdv53Wfimnnky9cBpcCIiosBxsCYiIgpcMNPgy92j2yzxBvKrtLhHnPPCd++lsqtQuQ8RUSCCGaybQZQfFlHuDcx47rmdt3ISpDetY9aD8zLevCMnF0TYnNWLHazNjMttvEbfdHvyoowzzozpeFf/IzL2felD+1Qfd0EQ3/3QtZIb1feZul+H1Yd1HM29j3m2oLfiLrhRHtILGZScuHZmQt9P2+Gs1eK7H9o9pu491L5Y8+QGed/wlF7TAWue1ffGula9WPlYzE06C4t4tmOcHI25Q/pe/3lnQYvCC/J4Xd6j97f9ktw//3uSj41u9082PvMnv/7y/y/3Y7BSMQ73h2fmUOVrhu/HqnsNcWO3br0AAMif9a3H5PQ5Lj+rmbU6d+bJabkA0/oN+pryreGdou1bmOWaHrnYyFCbPrmPQF7Phm+ScfeeQ+opAJr3H3icBiciIgocB2siIqLAcbAmIiIKXEvGrCslNVF9hbQgCBEQLWkxTjEOXouSt/SzWu5e7EY8xsEM1o148JLiLrZQuqwLQDzf3i/a2zsvqT6v7Twq2pNluZ0ydJKJm2D23o3fU33+KXudaB8q6oUCLl0nk1G6TqsuKvmpF7pIShJJZ1EKSfhM98mJJl/i1foDlQuKuHzbSTkFOuZ6dPKTzcg+m/5ZF6m48Fr5+ikng2u2oD/z3ufc7WRVH/dYFHXNEeQHZdKXb2GKVcfl649t8xROcZLHNn5Lv0/3OK/53AHZwZPQmJmW241SqKT7cMUu3vMrynnrXuOi/CiNM+Dn7z8Y63r6+vd+XLSnh/XEq7uoz4WRftVnZKtclOPkWEH1uW6NXOlkQ14XTjm7Sz42cVlup5cLeRAREVFIOFgTEREFLphpcKKVWDr1V62a40RXg/HocDXiYh8tOVjX84PxJTxknEUw3HgmAKSMjL8dm1yj+mxuk3HsbVlZVaPd6EIgM1aeAiMlXcDjxoIMQGeu0fHVY72ycMrkVh13L51xt+2J9+7Zh6c/deUCFJUK+Pvih+6A7uuz5iHndX5Vx0HP7XNip55CG+6CIG0jOm686rhsu8VWfNyYv0/RWYfFLawCAKffKreTP6/7dJ2R78u3HbewjG9xFLdP51m9HbdIi29hijUP6c986fc4ynky7ikWAgCP3PeRl/8/Shw5bjGT0OXvPyjaOc+PYPVZPaW3MzIhT8Kh9boUzgspZ+GTthnVZ02nLPx0fLeMhZ+e04vCrP/TA+qxOLkCIeI0OBERUeA4WBMREQUumGlwLuRBL7n1A594+f89yzETAYi4YEsE+++85+X/j3pB9L12pdrg9dTK8fOkzpN6C2awbhW+hTx6n5TF8LOTBdXnTKe8t3O4S8f1Ls/LYvjnS3JBhG0ZfW92ISVv8n5zxzHVpzs1LdrrcyOqzyOZa0V7al7HV5/BetEeS3eoPmufkPHd4+/Ww3V+n4wldww5cWNPrM2Ng5ZUD/3ZtI3oRTDg3KvuizW7z5vYVHk7Wb0uC8Z2yPeVfVG/lvs8d+GOy7t1vNwXo3ZFuScZkANUlEUnfNouVH4dd3EKd//cRR4AoHNAngf+xVuu/DqAjuVGeU9RBsKkBstqDbqZhx5X23YHPl/+SKfz/Tt5p76P/0K7jGvPFPRQNNAla0DYonPvv5OfAVQ+T4CFzy/kH1bL4TQ4ERFR4DhYExERBY6DNRERUeAYsyai2Br1ntVqc+tsAzr2naRWSRZrZcEM1q1ysvkSG9wL3pxTJAUA2s/Ij2psU7vqc2JaJmOtz46Idt44K4YA2OH06UzpyZbXtsuMpONz46rPtv6Lon12Tif8zJfltk/lC6rPhbxcMSLVrlPByhn53se3uvusk9vy5+Wx6drlL5CxlJv4B/gTmVzzHTKpa8uDemEKt7iEb8GNDd+S7dyo3o5b3MVNsNn2O4/q/YtQ8c1drMJXqMSXXBSnAIW7z75BLecki7mfg++zct+Dr2iLyy1o41M69HzLXK9cURKz3CS0dd8pqD5znbJo0sVb9Hc2fa1MsMx0yeIqxT59rZrukwsK5e+/cgGlRsJpcCIiosBxsCYiIgpcMNPgjYjxOiKpVb8T6n0vU4c8JK36WQFcyIMS0nlWF74f2yZjOpdHOlWfwxm5EPzWjmHR7k7rYvkbM2OiXSrrAh5rU/I02dum48hTdkS0v1nWhRB+YeO3Rfton164fmizjDP+3bHXqD6lPfL4zEw4i4bM6gmjKedUn/bEuwpH5Hsf3KcLspScl+r/jF44wI3B+mKl+jPWxytOQpJbBGLWE59249zLFfmoFJ+MUiAjKe4xdI+fL5cgOyk/z9Ht+jPf9HX5HfG9hyhFUFz5+w/GGgCqVWmslotZuMcwf0j3cfMmpvp1zPpSj6x60l2YEu3xMf0c9/sZpchNo+A0OBERUeA4WBMREQWOgzUREVHgmi5m3cqryxBROJKK6SeRDBV35SleT8PRdIN1LSV10i5dog/wF6DITMlkp9IJvWLVmQmZpPSQeZVoD/bKgiMAMJyXiWo3dxxXfdyVubIoqz5zVj72xo5B1We87KwiZfQqSNe0OafkdtUFF4vyfZyZkquLnR6TbQAYhUxWSa/SBUYGV8tiKx0bdPGX6VHZZ+JPdAGb7IQsrNE2orog3SeTYzLTOrEvSrEQV5SCHe4FOO4gEqVARpRz2125bO79+pi6pp3jV9SnNvLOKbj2Kf2Zj+8qyAc8xXKiFEpxxUlKC8HScyduElqUZDY3yTG3Y5/qkz0rP+PJrExstSn9nRndKa8xpZyePO5u0M+G0+BERESB42BNREQUuJacBo8Th1luSojxGwrN0qln37RzVEvjnGq6GPqebi+nPjddvSixcF6Xmk/TDdaNeJK6BR/aLug+brzt4o2eggDtsoj92YsF0Z4vyb8DQNuAjBtPldtUn5n8UdHenNGx3EJKxvVS0HG+rPPQ9blLqs/ZeRkT3tKm+7iPFbKyuMqP9JxTzxlZlxftS0VdVObFrjWiPTmlj0VHjywsM+spEDM7JJ9X9CzSUc7KeNvGf1FdkBt1PhtPgQe3TxSjTkzYV4Tnagb5K/EVL+k6I+OMbgwbAGYLsp13viNTG3T8Es45OFvQ35ne53Qc++EH7xbtKMlZvhh1lJi+K8o/JOImiy2Vvn53xf1L6loaZTu+VcrWfE7maBz/IxnXNttlkRQAKDnfq3RRf+buAi+NgtPgREREgeNgTUREFLiGnwaPcntBUjV6iaj5qdvNqvQ6oV9jksrTaYR8Hze04Jsqd8Mjtdbwg3UccU+Sap1cj9z3EdH23pd4SL6+e0EBgOIx+XGeeYu8zIy8oO/NfvKNMl45u1qfElNlGffZ1X5e9VmTlnHs63Mjqs+MrXy/6oyV94pv9sS1x0vyffTn5GIkZ2Z1XLQjLWOT82V9Y651wp6d+dmKfVKeez2n+5zXzuu46PQxed/3nA6hY3S7PO45nSqg7jd2FzJY78l/6H3ysmj7kscAebHyJZO5FzRfnHt0h9y/Gb02CspOMkOxoI9pbkT2Gd0h+3hu2ces81p5fdqq3A/fvdi+OLsrTnx6OZWuM3ESypLcv2pwr4EAcOsHPiHa3Sfk3zuekPktAHD2TbLt5joA+pzsPzCsOwWI0+BERESB42BNREQUOA7WREREgQsmZh0lCaFVEjKIKGyV7of23QsdtwZ7nP2pZpEn972FHg9vFsEM1lejGoNhPQfYKIsAeBf7eEheDHbeL//uFhUAgFNPbhDtS7t0plMuK7N33rReJ6qtz43K1yquVX3cgivXtumMn7NzlZN5xssysSRrZGGSrrRODDs9UxDtV3XrzKuUkUlL5yZWqT6DwzIxzZZ10pydkxNWk3P6eKWdhKhL16ku6HlRP+ZyE8rcAiO+rFa3CI9vgZBLH5LnSr8nUW14j1NwYo/OHptap59X0cCMemim1yno46wlY0v6c+hYLbczui5KXrcuotFzTL5YlAVVopi/Y28i26mlOAuUxL2W9tz76BX/7isS1HZJfvdm1+hFh/IXZJ/lEgi/+6XfqLSLNcVpcCIiosBxsCYiIgpcU0yDNxLGtYnoSlYaf07S0hrd+Sv0W4lGveYtrWXhrr/9klq+h4YarEP/cJPavyiJKMv1uVKSy6Z/1gUfLrzWKarxnYLqM3bjpGg/eELHrdpzsrjKNT260MCmvCzG4RZbAYCe9JTTR8cZh+dlXL09JV97bF4XS2hLySDxi5M6pn54SD5WKumJp/KELNqSLej4+NyU/FqlR/UCKtmJygViMtO+xSmknhfle3dzGaIsWjD4qzqXYf3D+vNzE4lu/sVPivbERr3tcka+B+u54pR75XvI5fTiKCWn+EypKI/pql69qMOmwohon84UVJ/JSXl++RYESRfleTDhOV6uKN/hzEOPq2tGtSoyRtmGbzENV+nQ88Fch/P3H1T7svv35TnZcV5/h8e3yvaOv76s+oS42AenwYmIiALHwZqIiChwdZsGP/zE0eDvm66lKMciyjq2S7cT5zYLouW4094kiRhnxOdE+d67fdzvdZxa4Um5mnh0PWPzjSiomDU/rFckseB8lPiSuyCIu7ABAKz+R5lqcnm3jrdOrJVxx5liVvU5nJYrXHRk9eoLtw8cW35nFw0XZcx6eFbuXyal760s5GRM86znHmrX3JyONcOJX85N6veZPy6/VnN6zRDknfuWe17U+QRuUovvvtLJDVmnvVrcH+pb8GW6T76HthEdpx3c51lxw90/J6bedcZzXmyUj6U8C25MdzsLeVzU96V3DMi8iYE+GWfsyMrzDwC2dsq4+8y8vtxtKcjtHG1fo/pMzchzxY3DA8CWB+Xrj77/dtUHkPfu+ga6KANxtSR1/3g1Vbqebftb+Zmf26/P44HH5HfNd591dlJ+xsX33OZdbKSWOA1OREQUOA7WREREgeNgTUREFLigYtb10qg37a+U9302YH1iujLxOfPzDUo1io741Op+7VoLKSmt0mIuSeNgXWNxP8woK9vEya53CzNESWSb6vclH8lEp7lzPaqHmwI0tl0v2PAotld8/faM3NLlaZmQ1JvXBTJOjhVEe+is3r/cKpl4kjqmL6dt47JdzuqEPFf3Cf2Ym5zlJooBQKcz0PoSgNykM7ePr/JSDyoP4GqRDo/+AzI5y5eokxuTyWO+oiPGWfgku0afF5m0TBo0zqIruZQupLKubUy0r10/qPrMWZlE2JXViX7PO4mQo6f1ueMer97n9HbcBVR8ksjsjnuXTa0HvkqvF6dgjHudjHI9G92hr2edZ3XCYr1xGpyIiChwHKyJiIgCx2nwBhE3PsJCKkSNzf0Ou1O9SRWXcu/Jr/fiFaEVzYpT6yJJdRusd91yDb7xeBgJDo2YaOFTqZBK+vrdFb/oUQqp+L5Ebuw0N6qrX7iLhhSn9Ok3PCHjxMXzOm6cuywnhNzFISa264U8StOykxsnBYDSGfla7eOqC5w1Q9Cu17tAyVl7ZGpA99n8B4+Ktu9Hkhu/jPJDyv0cJjbq9+ku0uErgNJ1RsaI5zp1wRNfjNqVc2P8F/V2pjbIx8wLnarP+BYZA+5sk+1XF5wqMwB60tOiXYJ+7Q3ZEdFeu0Z/6OvaN4n2M53rVZ/jq2UxlVJOn7drn5L77Cty4+YcxP3x3CzXNNdK35cvB8AtWNMxpIsouTkIvoVtao3T4ERERIHjYE1ERBS4YGLWLX2vM5J5n27MSa8ETUTEmgvVUs17r4MZrOnK4nzgswNdePjBuxPfbtzEti3/IJNjfKs4TWyUi773DOltT2xyFpA4LWOR4+16IQh0yvtwu47qRTrSzq2x6Vm9GTce7Yt3dR8ekc9JaDGG2YEu9ZgbS3bvD+3yfMXdxQ1879Nd7GPGc2u9uyCCLyFp8Ff3iXZ2UnVB7zPytca36j6ukUn5GV9apY9Nm7NqyI2dJ1WfFOTnd03ukuqTT8n3WbZ6QrK/Y0K0f9ClExWO7ZQLguz8UDILZySVFOrWXEiqsErcwSqJQS7KNm79wCfUY27Ohu+7lzkUf7/i4DQ4ERFR4DhYExERBY6DNRERUeAaKmZdreSsKNutdwJctRIX4mx3ueIAUeqXi+d67u8loitzv7O+mHWtF5kI5bWbWUMN1s2gmidtpWSyWvIN3O4g339guGLhfV9iR+9zsn1un1PA4BG9WIQ7iTTX6esDfPdLv7HsvgDA+K6CaPsW19BLSvhV+jE478nOdT9jN0nv4o3yWExu1glwtlsmTPU8VXnRjnlPzl7bBZlU5XvfbqLO6HY9mecuelFq0/szslYm0pVKcjuD07qQyrWdcuGO00X94/A1HTLpLOt5F7tz50R7pksvunJuriDa56e6VZ+RrDyXz/z2PtVn4x8fEG33fAOAvJPYFCeBsZqJYY2m98nL6jH3uuNbhKWtxtUeOQ1OREQUOA7WREREgQt+GjzKvX4rXZC8lgXi48RvQitgT9Xx+vd+/OX/15Wk/Xz3phOtVFI5OFGvVUlcB32x+SiLmtR7Oj+p63mkwdoY8w4AnwaQBvAFa+3Hlun3WgAHAfyUtfZvVrIjvgMa5cNKquBEI6jGSRdnm1ESyeI+L0of97zY/JB8H75YsxuDyo3Gi/F3Hx6puI9Rvpy+RRxcbpGRSx/SMc6RV8nYe7uzUIanfgcwIwvCjO7Uce30tNzOuu/4Y/ziOZ7vpxvTn3MWUQB07Bt7dGw5d1HGiUt5WfBkek7HuUvOxOGWnK6wsyo1I9obM7pqy8WSXBhmZ+686jNn5TG9sfeM6jM8JX+SjULnY7h5Cr4FcXzqPSC5VlpcpZ58Y0jmkHwPbnXI5Z7nfg5JvveK0+DGmDSAPwfwTgB7ALzPGLNnmX73APh6YntHREREkWLWtwI4Yq09aq0tAvgygHd5+v07APcDGPT8jYiIiGKKMg2+EcCpJe3TAF63tIMxZiOAdwN4K4DXJrZ3MVVarD2qkKdvruZe56WixHhCjAMloVnfF7W2q7lurTT/p96Wuw5eSaw4ewCLnEQZrPWK7YAbwPoUgLuttSVjfN0XN2TMXQDuAoAtW7ZUfOE48/9RitpHOQGTupDX6jmtpNLxiRP3jruduNxY5Kgnlttz76Oi7S4i4jO1U96znHPuqQaA0rycUCsNtas+2Qn5Pb68S3+vL+/qxXP/+ddfbkc5pj33Plrxe907oC+M7r31F2+UN35fvEXH1C/0ynudd7Xry92lkrw/e2tmXPXJp+TiKAXolU/KbfJe7PGyPqY3D5wW7f81vUP1OfMmuT/X3Des+nwtoetDEvHVat6vXSmhzDdQp6/fXZXvrW+Rmih5J4nuQ4Q+pwFsXtLeBOCs02cvgC8vDtR9AH7MGDNvrf27pZ2stZ8H8HkA2Lt3b+WMFSIiIoo0WD8GYKcxZjuAMwB+GsDPLO1grd3+0v8bY74E4B/cgZqIiIjiqThYW2vnjTG/goUs7zSAL1prnzXGfHjx75+t8j4SERG1tEj3WVtrHwDwgPOYd5C21n7g6nertfhiL9WMl7aiuMUbmD9wZXEKu9DVSSqfplYJtHEXSoqSf9RKgq9gtlSUoiilQ88ncoEN/SKd1GDeygX9q1XAwN2uNxHmwoT4DG/4NV2ZzC2CMrFJp3m0bZUJUcWi/EpvKIyq5xgjt3Py1EbVx6kDgvwF1QUdQ7KYytR7bsMj931EPBYlW1d9rz3JPG6xkLVPycS5c7fpBTiGZmTRkSfTW1WfOwrPivacJ5+228ht6xIywKSVRVnazZynl1Qu69dac0R+Nuf26wIx/YfUQ0LcBNqoz62VStfyJP9BE6eqZPfhkVjbvVIS9pWwNjgREVHgOFgTEREFrqGmweOIGgupVUH4VonNNMI0WxSVzoMo61Avd3u0qDe8p/Ka0kRR1PK71yzfc1ecYitAdfMAGmqw9sUoQq4yRgToRUR8fPHoUo+MlWYLuhiHtTL+tWWtLKLhLh4BAB1ZWZDFfR0AyJ6Rl4bMtN4/d5EOnyjv3f1eR4nxL01sA4DMQf1j54XXyWNz7Y6Lqs/R2X7R7k1NqD7u4h49qbTq48aoez0LgkzMyUSA9nYd1x65Vn5ehSPVKUdRy8E0tLyYOK8VpdhKtcciToMTEREFjoM1ERFR4IKeBg9toYU48Uu3TzX3pVqvVUuhfeZEjSBujHWpuIv61PK14qyTXa01Jmot6ME6ijgX8ij3YtfqHtwktx2S0AbYKPvjfkF9i8vH2a7vQnr67fL+2XKb5+7drHys0DWluuzqlXHY4VkZ89y9RsdpnxlcJ9qpSR2DneuqHCsdff/t+O6XfuOKfXwLIFQS5f5ZdyGUtU/pPidvkROHBwe3qT5H832ivXW9Pl5uzDrtuRd7XVrGurPQeQA7uuS2R4p6sY+j7atEe6pfv1aP03bP22otZrGc0L7rSYhTr2O5Ad79LHifNRERUZPiYE1ERBQ4DtZERESBa/iYdVxJLdhQrXhzNRKt6p2UVstCM3Fq/cZJKnHv9wV0PHW5oijNIM75n8h3xik8Q40v5Nydel87gcAH60ZMXGjEfQ5JPY+fm1SS1MXj6Hv1YgzF1U7y2LYR1Wd995ho31w4VfG1tnVcEu1nxjaoPoX8tGhPD+iCIh1PdjiP6ISznnsfrbg/QLwM3koyDz0ututL4mv7vjzuU7fPqD69q2Xy2GRZ/7Rypx+zxjchKT/PzlRR9Ug7fUam3WMMlNvkcc6N62Skan1Halm8JGoCb5zXq9VzXNVO6uM0OBERUeA4WBMREQUu6GnwKEIrolFpms9d5AEI/0MI7RhH4ZsWTWqaShyP99yWyDabWcixyEYkFoBZ9PCDd7/8/9WMr8YtRJLU68VZqzvk8WAlQh8nrprvg4pT7edqFnSvZP6OvZG+bCvdnySek6RaxdqifL5xiqQAulCKbwF6t+CJG58GgGy/jBtv7B5VfV7be0K0+7Njqs+Z2dWivTorY7DrO/R2j4/I55RHdcy6nJXt2UK8Qg4u749VT+GUJM6V1YflcT+zUy8qMlzoFO1DU5tVny1ZuTjKrNWLfQyk5STl00Udj25LycTDLT0jqs/F1BrR9i2g0oziFIuqZYGpECqacRqciIgocBysiYiIAtf00+BRVWvqOaokCvFXUutYVr2n3VeqFp8BJcM930KYpqyn0PICQoobN4uGH6zjLuRRDVEKuUcpxlHrQvyVNNqFMKnPd3Cfvj+6Z0DGXE/t0/HembVOjDqt446v2XhWtG/uOan6bG+TCz/MWb3gxq6O86L9vYmton1hRi4MAQDTs84+5/WiE4B8rfUPD6sevmfFKUYT5XmV+BZeUAVrZvTxG52Vi2n0rJ5WfUbKcnGU3rReUGW07Dsa0kBW5g/Ml7dUfI53IY97Ky+OUs97sau56FESz6nlmOF7LS7kQURE1KQ4WBMREQWOgzUREVHgGj5mXcvEJrcYgXt/6HKx3dCSP4iqpZaLtVBrq2bCbNRkU7dfNXONGn6wjiPKh+kmp7grKUXlS0xotMzIKMkVIb2npPal/4BOqnLNda3WD3bLc2XH5guqy+qcTFJanx1RfTpTs6Kdgi6uMl6WxTf6c+Oi/fTwRvWcbEYmQ+We0Uly+UGZFDc7oAuKZA6ph2qq0ufsFqzJ79IJg8fTA6J9uU8vlnJ+rke016V1oZk1GWdhlpROVMs7n+fglD6muctystP9HJbTjN+/0NU68ZbT4ERERIHjYE1ERBS4lpwGjxT/quICDVEKOsSJfTRDYZI4orxvFtGoH8abwxM33lvPa0wjnEfVPD4NP1hX60TJ33+w4uL24xEG9Lmbbhftnnsfvfqdi6kVBu4kDd+k49GXd8uCBqWBWdVnx6ZB0b6lV8dB39j9gmi78WkAyDplR6asji2Pl2RRj1Mzcp8ni/o5k+dkrDSfVV0w3yHfp2+xjTji/kiKc+66P3hv/cAnVJ+pbbL9wli/6tOVnhHtzblLqk97SeYpjJfbVZ9ZKw90W1rnwRQ3FeX+jenPr5c/NF9WrWtaUv9YShKnwYmIiALHwZqIiChwDT8NXk1LpzWaIcapaiUveuS+j7z8/40QF4qiWd4HxafOgfff7u9I1ABacrCOU4x+fFdB9XHvvS726MM5W5Cxv/k79qo+6Qt6Mfs4pqqYFBdyvNv9IRXlvnBfnzO/vU+05ztUF5S3y/ujr99wXvX5yXVPiPbu3DnVpzctY9S9KT3J9XSxU7Tzpqj6jJbkIhNPX5L3VU/MtKnnpGbkaw08prcbV6XEvmotohOFG4cHgK4fyu/s1LU6gN+WmhNtN5cAAPIp+VgJM6pP1sg+q9v1vdinhuTrpz0fTRKFN+J+n+t5HQj5GlQLnAYnIiIKHAdrIiKiwHGwJiIiClxLxqxdISYj+e7rXhqr8u5zFWPWK1XNIvvUfKIkc1Y6/1vl3IpyvWqVY9FKOFhHNNepk1Pcw+fr0/uczBCZ3KATWIb3yAUG1j9ceQEJn/z9B6/496VZ38tphi+5L9HOTQa8eKMuNlF2P5pX68S/3rxMCnKTyQCgNy2ftzWjC56MO+sznJ7X586MU0Tjh8V1qs+5olxkoq9jUrSHRj0LcExULnjiJkJWs5hJrX4sr/ncAbU/13xKFkqZmtPnxeFJudjHtW16YZYZKxdQmbNp1WfESQa8ON2p+pR6ZBJa2zN6OxSmal87OQ1OREQUOA7WREREgeM0eANZWtQkf4V+SYs6TVmNaSDfa7tTtPpOYgpFaLFllQvyQc965BRZPXNTorx2Lfev2q/FwRrxD+b+O+8R7e7DOsZ59L0yHl04oheTn3JCke5zAGDt03Jxe19ctvvwyHK7WnOhxb7PvEnGIosDehGFVJcsfnHH1iOqz9sKz4n2njZd8KTTLX6R0tVVhudlHLsIHZs8VVwj2hfmelSf/3XuGtEeGu4W7bYf6gUl1h+QeRS+eHT6woRI6PIlPCZV4KRW54rvfXYfl/H7c7168L6+V37Gq1K6mMkPi2tFu+SZtDw+0yfas3OVL7+9T15Wj30tsO8W1QanwYmIiALHwZqIiChwHKyJiIgCx5j1MioVJWkUe/7PT778/+2e27d7XpTxy7arWFTEjeG73IVOpvv0b0V3f3iCNpYk7plmQR1qJknVEeC18Cq4A9vsgC5A4SaUTWzUxS/mO2XymM3qJLRzr5cDW6lbJ0jlbpGJadlx1SUWN/vaV9il8+yceiwJvqSgU/tkslg5I9/3XI88ngDQe+2QaG/qHtV92mRBkWvzg6rPNbmLoj1e1kU0NmflsZiweumkvJH7eLGkt/P89HrRPj65RvW5eFomRLmrSE1s1cdCf376vHX5fqjW8y6BONv0rZzXNuJ816Z0ol+nU9RmpKSLmWzIyESwOU/CYFtKfmf7OidVn8njMlHNd00JSeircNVy/3yvlWTBH06DExERBY6DNRERUeA4Db4C7pRG3HrJRPSKEBfSCVlohWZC0szHhoP1MqIUfCgder5itRy3jMXEb+9Tfbb9TxnLOva/eeJdW2UAen5e95nLyfjknJXx8Sn1DODyHnkK2KwuvNF1tPJiApeuk3HQlGdhChWb79ax3JE3yYIimZyO5RanZAzx+m1nRDuXltsAgN1d50V7S9sl1cctZLEjpxdsmLOyz6uynvdQlq+fM/pYvDAnY80PjNyg+syWnfizZ5EJFOX+TPfLGOzGf9FP6T7sKbQRI3mymhfBJLbtbsOXNKpiwrqGDB4b2iLafVmdhJlPyXPyRLFP9Tk2KR87NqRzEGY2yO+Ib5EVahy+89h4rgdRcBqciIgocBysiYiIAsdp8Kvkm1ojajRR4sYhxf6aOTZJfq3+mXOwXoFKMbD09btjxf6WrqYFADt/6aDqc+IPnFj3q/Q9mp2rZkS7PVf53ufJLrlmVXub5zmbZbNU0hMypVG5WEVv35jqMzEjX2tNt34PPTn5HgptetGEje0jor0+J++Z7s3omGK3s/jCmrR+7RTKTh/92hede2xPz+vj9Xxxk2i/MLNe9Xlxaq16zPXcpQHRnirqmHX7RflZZJzEhOk+HR/Ljco4bb3jorW64PryUNrgJImm9T3Um7tG5HasPv9HSnIdvKmyXgvuxJjMU5gZ1Gvn9fyw8mRnKw1QK9XMx4bT4ERERIHjYE1ERBQ4DtZERESBq1vM+vATR1XCQL3iDSzKQNR8+L2mZsIEs6sQpXBKFPn7dUJZpWS2kz8uF68AgKl1MkGquE4mSA2s1klf1xZkcZDu7Izq84PLMtEp7ykE0u4sXlHo0MlZ1xTksl9jczoJZ9cquXjGtvYh1aeQlllU7SaZRUTchDI3mQwAskYWsHm2uEH1+cG0fMwtbgIAz1xaJ9ojYzrZKP1D/ZircFwWQel9UhY8We4crVTMx+0TmqT2TS/uoc+lXEoWuRnI6kVg5qz8jM/MutsFOnOycEpqRk9suguLuIvotLKQz8da4DQ4ERFR4DhYExERBa6hpsEbcbqu1W/kp+bQiN+9ZsVrSnTNdN7WbbDedcs1+MbjYRywuB9cUh94lO24xVb233mP6lPskR/npR9xCnis06sUnFstF+4orNLLffTlZQGRsVm9nf5OWYikv2Nc9Vmbk31Sxqo+Ljc+DegY9XhZ7s81ORn3BoBOI+PsI+UO1efM/CrRfnpmi+ozVZJx9h9MrFN9fuAUMxmf0MerdNkpRnPeszBLlzw+676jj1duVMbQZwe68PCDd7/cbuUKe+73ynfhvniDnFw0KX2Ms07M2j3fACBrZJ/nRvV58eLpftHuOqsL1vTce0A9FuV9UPPjNDgREVHgOFgTEREFrqFi1qHj9BSFYOl5mL5+t7dPlOnxep3PzRRnJEpKQw3WjfplrcZ+L41LvsS9yOXvl6/tLhgCABdvkPfyDvfoeNz4BvnY3Iw+bVZtkvdnn5xYrfrM52VctpDV92JvaJf3CbsLJABAZ0rer3q6KO85d+OHAHBsVi6cMVjsVn0uzMiY9fFR/R5KZTkZNTObVX1mzslcAd/iDOsflvecn367vm9+/QF9z6/7uVcaUEuHno+1AE0z/vBc7ofLUvmuWfVYLiXzAsqehTwG5+RnPjKtcyLUdnVaB6bec1vF5zXqdbAemulYcRqciIgocBysiYiIAsfBmoiIKHANFbMmanWhxZKTWIwntPdEFCIO1gmqdzJDpdf3LRiy9f7KizqMvv920Z7v0MUcTvVuFe2pnXqxjyMlWSgit0r3cRcbWdsxqfo8PyiLS7TlZAJQV5tOEnITw4olXYTk8gtrRDszod9nxsmJ2/YPw6rP6bfL10rr3VE2fV1vB5DFcKIOapXOAzeZLMo2aj2gVuO7NLhPJ/HN9cjFb/o7dRGe1Rn52ODcKtXniUubRHuqmFN98s/LQjj9Byp/5kQv4TQ4ERFR4DhYExERBa6hpsFZLIGospXGkZv1e6Xe14f21WdHViiJPABqPpEGa2PMOwB8GkAawBestR9z/v6zAF6q1jAB4BettU8nuaN09eJ+6XuflIVKSoeeV33cghPDN+mCIrMF47R1QZHxEVlcYrBP70+pXS620PGi3K6OOgJuDRRfQYqC53muzLR87fFd+lk9x8p45L6PvNz2VQvzHcNKn0+Uz69aseVqDhi1Gow6hsrqscu9Mm+iM6vzKErOBORUSZ+350bkgjjl53TRnbWH5ev7zh1fXgkREGEa3BiTBvDnAN4JYA+A9xlj9jjdjgF4s7X2NQA+CuDzSe8oERFRq4oSs74VwBFr7VFrbRHAlwG8a2kHa+0Ba+1L//w6CGATiIiIKBFRpsE3Aji1pH0awOuu0P/nAfzT1ewUab6pVN7iQSGJEvtu1vh4PfmOKY9n84kyWOubTQG9QjsAY8x+LAzWb1jm73cBuAsAtmzZEnEXX8ETsPqSOsbLreq09AfG/jvvUX/PPPR4xW27ix3kRuWCF20XJtRz3Bjxcos6RLmvOcrgc6XX9m0nKfyOvML9jC/v0hOJdk4+dtPq06rP0yMbRXtmXl82Zy7JhTt6z0Tbx6W5DURXEmUa/DSAzUvamwCcdTsZY14D4AsA3mWtveTbkLX289bavdbavWvXrvV1ISIiIkeUwfoxADuNMduNMTkAPw3gq0s7GGO2APgKgJ+z1h5OfjeJiIhaV8VpcGvtvDHmVwB8HQu3bn3RWvusMebDi3//LIDfA7AGwF8YYwBg3lq7t3q7TURE1Doi3WdtrX0AwAPOY59d8v+/AOAXkt01LanklHomZDDBJmxJ3afMxSmSVek76/v7cnkJrYBJZ82noSqYtbJGy/yOsr8PP3h3xT5RuBemEiovRFE69HykxSriFCpptAtlUvsW2nt0i47MrNV5sZs2yfQaN5kMAOadRWDcAigA0PXDypfS3Oh8xT5x1HvRFaoN1gYnIiIKHAdrIiKiwHEanIIWeoyfU45Ua40WZqFkGGu99U2qbu/evfbxxysXwKDW1qiDdSj718q2/9nHRTuzblr12bRGLlJzfnSV6jM93i4fGNf/xtn+9zIe7Svu40t4i5OLwsG6sRljnohztxSnwYmIiALHwZqIiChwDRWz5pTjK3gsCIgWM2/Gc8J935c+tE93chfyJWpgDTVYU+sJfaAJff9aWWay8sTh4Hi3aOey+l7o2eGsaK9/pHKez/wde1UdgaSSEXnOtSZOgxMREQWOgzUREVHgOFgTEREFjjFrMFmLyMV7eYnC0lCDNS8Wr+CxIKB1zwO3wMhMr+5TXDsn2l05nTw2MZQX7VR7SfVZddyIdm50TvXxFUFxtepnRcngNDgREVHgOFgTEREFrqGmwYl8GF8NA3M/iKqHgzV4MSFyhf6dOP5uGaSe69KFSjKX5eVtqr1N9TFZ+by139B9Os8W5XYjxKeJksZpcCIiosBxsCYiIgocp8GJKCivf+/H1WPdh0fkA+/23KtF1MQ4WFPDCz2+2ipq+TmsebYs2mfeovvkLsuJw/mZtOrTeVQu0jGxEXjuP/+6eIwJjBQCToMTEREFjoM1ERFR4DhYExERBa6hYtYsukDUfPbfeY98oKe+l6XlrjOV+vA6RNXUUIM1ETW/iY16wm+6T2Z/X95TVn1c1rm6uclkADDwWLSCJ0sH4iiDOVHSOA1OREQUOA7WREREgeM0ODW8VokfNmLORqQp4zv2Vn9HiBpcQw3WIV+UiCie0R050S7ldJ/ZgmxnR+Wk4DX3DavnDO6Tce6eF4uqjy9GXek6w+sQ1QOnwYmIiALHwZqIiChwDTUNXi2NGAskIqLWwcGaGl6r/KhqxPeZvn63aI/vKqg+M84CWmV9OzRm1pVEOzckF+WYHehSz1nzuQOR9rERjyu1Hk6DExERBY6DNRERUeA4WBMREQWOMWuihDVjkZYoSZjvuOF3a7U7RC2HgzUa/0JKFKrhm1aL9qXrdJ+OQdn2JZj1PC8TyrrOyIU8ij0ZPHLfR8RjXHCDmgmnwYmIiALHwZqIiChwnAYnanFXUxTo1g984uX/771CPyK6OhysiRLWjDkQU++5TT0212lE241PA0Dn2TnRHrlWr9LRc0zGn7sPj6g+pUPPq8dWuuAGY9jUyDgNTkREFDgO1kRERIHjYE1ERBS4hopZJ7U6VtTYVTPGHomiWpo85rn1mYhqqKEGayJKnu9H6dKBGgAmNupJOLcwiZtwBgCjO2RC2dbf0ythzd+xN9J+Xi3++KZGxmlwIiKiwHGwJiIiChynwYlajDvFPVvQ09dttdoZIoqkoQbrpGJOjF0RXZlbzKTzbOXn5EYr9/EVVwEgFuFIKpGUqJlwGpyIiChwHKyJiIgC11DT4LQyvulETiUSETUeDtZELSY7aUW798nLqs/sQFesbT/84N2i/Y4bfle02y4AX3v6o1fcBn9QEmmcBiciIgocB2siIqLAcbAmIiIKXMPHrJlERc0qzrntxoi9dhVi7lFl7j6nr99dsY8Pv8NEUsMP1rQ8XvDIJ3//QdEuQZ8rN//iJ0W758Wid1tLE8p8g3Dp0PMx95KIluI0OBERUeA4WBMREQWO0+BEDSxKjLiWr1/L12GYh1oJB2uiQMUZjHzFTNxCJfvvvKfidvoPDFfs44tHV9pn36Bb6x8YRI2I0+BERESB42BNREQUuJacBo8S/2KMbGV4vMIVZdqbiMLW8IM1BwSiV7RdmBBtXwy72FP5ax8nHh1F3G3we06tjtPgREREgeNgTUREFDgO1kRERIFr+Jh1PTGpiqJYrnDISs+VahYgibIAiK/P157+6Mv/n9T7JCKtJQfrKBcPXmBWhserPtyCIm5iWOaQfk5bjCIkLFxCVF+cBiciIgocB2siIqLANf00+HIFIdx6ybSAccerV6vFLRqFezx4LhGtXKTB2hjzDgCfBpAG8AVr7cecv5vFv/8YgCkAH7DWfi/hfQ0OLzoUVa3OlUox7JceW7o/vh8X83fslW3wBy5RPVWcBjfGpAH8OYB3AtgD4H3GmD1Ot3cC2Ln4310A/jLh/SQiImpZUWLWtwI4Yq09aq0tAvgygHc5fd4F4F674CCAgjFmfcL7SkRE1JKiDNYbAZxa0j69+NhK+xAREVEMUWLWxvOYjdEHxpi7sDBNDgCzxphnIrx+VRjzH+r10rXUB2AoiQ0tpCXQMioe56odv+/He1rF/fnG33iek8x3JuaxSOxcpmXxGNfGq+I8KcpgfRrA5iXtTQDOxugDa+3nAXweAIwxj1tr97p9KDk8xrXB41x9PMbVx2NcG8aYx+M8L8o0+GMAdhpjthtjcgB+GsBXnT5fBfB+s+A2AKPW2nNxdoiIiIikiv+yttbOG2N+BcDXsXDr1hettc8aYz68+PfPAngAC7dtHcHCrVsfrN4uExERtZZI91lbax/AwoC89LHPLvl/C+CXV/jan19hf1o5HuPa4HGuPh7j6uMxro1Yx9ksjLNEREQUKtYGJyIiClzVB2tjzDuMMS8YY44Yz70fi0lpn1n8+/eNMTdXe5+aTYRj/LOLx/b7xpgDxpgb6rGfjazSMV7S77XGmJIx5idruX/NIspxNsa8xRjzlDHmWWPMN2u9j40uwvWixxjzP40xTy8eY+YgrZAx5ovGmMHlbk+ONe5Za6v2HxYS0l4EcA2AHICnAexx+vwYgH/Cwr3atwH4TjX3qdn+i3iM9wFYvfj/7+QxTv4YL+n3z1jI7/jJeu93o/0X8VwuAHgOwJbFdn+997uR/ot4jH8HwD2L/78WwDCAXL33vZH+A/AmADcDeGaZv6943Kv2v6xZqrT6Kh5ja+0Ba+3lxeZBLNwHT9FFOY8B4N8BuB/AYC13rolEOc4/A+Ar1tqTAGCt5bFemSjH2ALoXlygqQsLg/V8bXezsVlrv4WF47acFY971R6sWaq0+lZ6/H4eC7/oKLqKx9gYsxHAuwF8FhRXlHN5F4DVxph/McY8YYx5f832rjlEOcb/FcCrsVDY6hCAf2+tLddm91rGise9aq9nnVipUlpW5ONnjNmPhcH6DVXdo+YT5Rh/CsDd1toSS7PGFuU4ZwDcAuBtADoAPGqMOWitPVztnWsSUY7x2wE8BeCtAHYA+IYx5tvW2rEq71srWfG4V+3BOrFSpbSsSMfPGPMaAF8A8E5r7aUa7VuziHKM9wL48uJA3Qfgx4wx89bav6vJHjaHqNeLIWvtJIBJY8y3ANwAgIN1NFGO8QcBfMwuBFePGGOOAdgN4Lu12cWWsOJxr9rT4CxVWn0Vj7ExZguArwD4Of4LJJaKx9hau91au81auw3A3wD4JQ7UKxblevH3AN5ojMkYY/IAXgfgBzXez0YW5RifxMLMBYwxA1hYeOJoTfey+a143Kvqv6wtS5VWXcRj/HsA1gD4i8V/+c1bFuyPLOIxpqsU5Thba39gjPkaFtYbKwP4grW2bqv3NZqI5/JHAXzJGHMIC9O1d1truRrXChhj/hrAWwD0GWNOA/iPALJA/HGPFcyIiIgCxwpmREREgeNgTUREFDgO1kRERIHjYE1ERBQ4DtZERESB42BNREQUOA7WREREgeNgTUREFLj/H5KTLmmGNLH+AAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -508,6 +623,35 @@ "source": [ "plot_evaluation(flow)" ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "t = make_transformer(d_in=5, d_out=7, d_hidden=200, n_components=20)\n", + "\n", + "x = torch.zeros(1000, 5)\n", + "y = torch.linspace(0, 1, 1000).view(1000, 1).repeat(1, 7)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "16.9 ms ± 853 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" + ] + } + ], + "source": [ + "%timeit t(x, y)" + ] } ], "metadata": { From 748e679af3f143e2f70cf0105ce1e25370feb094 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jonas=20K=C3=B6hler?= Date: Sun, 9 May 2021 03:18:54 +0200 Subject: [PATCH 11/68] some speed comparison with spline flows --- notebooks/compact/compact.ipynb | 47 +++++++++++++++++++++++++++++---- 1 file changed, 42 insertions(+), 5 deletions(-) diff --git a/notebooks/compact/compact.ipynb b/notebooks/compact/compact.ipynb index 3bd23aee..441335d7 100644 --- a/notebooks/compact/compact.ipynb +++ b/notebooks/compact/compact.ipynb @@ -626,32 +626,69 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 55, "metadata": {}, "outputs": [], "source": [ "t = make_transformer(d_in=5, d_out=7, d_hidden=200, n_components=20)\n", "\n", - "x = torch.zeros(1000, 5)\n", - "y = torch.linspace(0, 1, 1000).view(1000, 1).repeat(1, 7)" + "x = torch.zeros(100, 5)\n", + "y = torch.linspace(0, 1, 100).view(100, 1).repeat(1, 7)" ] }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 56, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "16.9 ms ± 853 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" + "2.69 ms ± 108 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" ] } ], "source": [ "%timeit t(x, y)" ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [], + "source": [ + "from nflows.transforms.splines import rational_quadratic_spline" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "ws = torch.randn(100, 7, 20)\n", + "hs = torch.randn(100, 7, 20)\n", + "ds = torch.randn(100, 7, 21)" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "731 µs ± 27.2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n" + ] + } + ], + "source": [ + "%timeit rational_quadratic_spline(y, ws, hs, ds)" + ] } ], "metadata": { From 3de759ba17f82f69779989af342d33c5c65cf471 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Mon, 10 May 2021 12:53:09 +0200 Subject: [PATCH 12/68] delete ksection --- bgflow/nn/flow/root_finding/ksection.py | 80 ------------------------- 1 file changed, 80 deletions(-) delete mode 100644 bgflow/nn/flow/root_finding/ksection.py diff --git a/bgflow/nn/flow/root_finding/ksection.py b/bgflow/nn/flow/root_finding/ksection.py deleted file mode 100644 index 08564ecc..00000000 --- a/bgflow/nn/flow/root_finding/ksection.py +++ /dev/null @@ -1,80 +0,0 @@ -import torch -import numpy as np - -__all__ = [ - "KsectionRootFinder" -] - - -def ksection_inverse( - f, - x0=None, - left=None, - right=None, - abs_tol=1e-5, - max_iters=100, - verbose=False, - raise_exception=True, - n_bins=100, - *args, - **kwargs -): - if verbose: - print(f"Starting bisection search with abs_tol={abs_tol:.4} and {max_iters} iterations.") - assert (left is not None) or (x0 is not None), "either left or x0 has to be given" - assert (right is not None) or (x0 is not None), "either right or x0 has to be given" - if left is None: - left = torch.zeros_like(x0) - if right is None: - right = torch.ones_like(x0) - - raise NotImplementedError - bins = torch.arange(n_bins) - for i in range(max_iters): - xs = left + (bins-1)*(right-left) #(bins - left)/(right - left) * n_bins - fs = f(xs) - indices = fs < 0 - - x = (left + right) / 2. - fy, dfy = f(x, *args, **kwargs) - if verbose: - print(f"iteration: {i}/{max_iters}, error: {fy.abs().max().detach().cpu().numpy():.5}") - if torch.all(fy.abs() < abs_tol): - return x, -dfy - gt = fy > abs_tol - lt = fy < -abs_tol - right[gt] = x[gt] - left[lt] = x[lt] - if raise_exception: - raise ValueError(f"Root finding did not converge: error={fy.abs().max().detach().cpu().item():.5}") - else: - return x, -dfy - - -class KsectionRootFinder(torch.nn.Module): - - def __init__( - self, - abs_tol=torch.tensor(1e-5), - max_iters=100, - verbose=False, - raise_exception=True - ): - super().__init__() - self._max_iters = max_iters - self.register_buffer("_abs_tol", abs_tol) - self._verbose = verbose - self._raise_exception = raise_exception - - def forward(self, callback, x0): - left = torch.zeros_like(x0) - right = torch.ones_like(x0) - return ksection_inverse( - callback, - left=left, - right=right, - abs_tol=self._abs_tol, - max_iters=self._max_iters, - verbose=self._verbose, - raise_exception=self._raise_exception - ) \ No newline at end of file From 16a8d01327051b1ef832f274a0a5c2e1cda9dae8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Mon, 10 May 2021 12:59:28 +0200 Subject: [PATCH 13/68] added missing args/kwargs --- bgflow/nn/flow/transformer/compact/compact.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bgflow/nn/flow/transformer/compact/compact.py b/bgflow/nn/flow/transformer/compact/compact.py index 0960a39c..9dc47af7 100644 --- a/bgflow/nn/flow/transformer/compact/compact.py +++ b/bgflow/nn/flow/transformer/compact/compact.py @@ -247,7 +247,7 @@ def __init__( self._compute_components = compute_components self._compute_weights = compute_weights - def _forward(self, cond, out, log_weights=None): + def _forward(self, cond, out, log_weights=None, *args, **kwargs): cdfs, log_pdfs = self._compute_components(cond, out) if log_weights is None and self._compute_weights is not None: log_weights = self._compute_weights(cond).view(*cdfs.shape).log_softmax(dim=-1) From ae727bbb974154dc7141bd850e9e708b5f49ff23 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Mon, 10 May 2021 15:23:24 +0200 Subject: [PATCH 14/68] make softplus picklable --- bgflow/nn/flow/root_finding/approx_inverse.py | 1 - bgflow/nn/flow/transformer/compact/compact.py | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/bgflow/nn/flow/root_finding/approx_inverse.py b/bgflow/nn/flow/root_finding/approx_inverse.py index 3c84b968..5ad7470a 100644 --- a/bgflow/nn/flow/root_finding/approx_inverse.py +++ b/bgflow/nn/flow/root_finding/approx_inverse.py @@ -135,7 +135,6 @@ def __init__(self, transformer, cond): super().__init__() self._transformer = transformer self._cond = cond - def _forward(self, out, *args, **kwargs): return self._transformer(self._cond, out, *args, **kwargs) diff --git a/bgflow/nn/flow/transformer/compact/compact.py b/bgflow/nn/flow/transformer/compact/compact.py index 9dc47af7..2b8150bc 100644 --- a/bgflow/nn/flow/transformer/compact/compact.py +++ b/bgflow/nn/flow/transformer/compact/compact.py @@ -145,7 +145,7 @@ def __init__( compute_alpha: Callable, unimodal: bool=True, eps: torch.Tensor=torch.tensor(1e-8), - alpha_constraint: Callable=torch.nn.functional.softplus, + alpha_constraint: Callable=torch.nn.Softplus(), ramp_type: str="type1" ): super().__init__() From 21c00282f4f4a18b5f615b7eccca326ff9ba242c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 11 May 2021 10:38:27 +0200 Subject: [PATCH 15/68] add sirens --- bgflow/nn/dense.py | 25 +++++++++++++++++++++++- bgflow/nn/flow/root_finding/bisection.py | 4 ++-- tests/conftest.py | 2 +- tests/nn/test_dense.py | 23 ++++++++++++++++++++++ 4 files changed, 50 insertions(+), 4 deletions(-) create mode 100644 tests/nn/test_dense.py diff --git a/bgflow/nn/dense.py b/bgflow/nn/dense.py index a7c03bc8..308927f0 100644 --- a/bgflow/nn/dense.py +++ b/bgflow/nn/dense.py @@ -4,7 +4,7 @@ from ..utils.types import is_list_or_tuple -__all__ = ["DenseNet", "MeanFreeDenseNet"] +__all__ = ["DenseNet", "MeanFreeDenseNet", "SirenDenseNet"] class DenseNet(torch.nn.Module): @@ -53,3 +53,26 @@ class MeanFreeDenseNet(DenseNet): def forward(self, x): y = self._layers(x) return y - y.mean(dim=1, keepdim=True) + + +class Sin(torch.nn.Module): + def __init__(self): + super().__init__() + + def forward(self, x): + return torch.sin(x) + + +class SirenDenseNet(DenseNet): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs, activation=Sin()) + with torch.no_grad(): + self._init_siren_weights(self._layers) + + @staticmethod + def _init_siren_weights(layers): + linear_layers = [layer for layer in layers if isinstance(layer, torch.nn.Linear)] + for layer in linear_layers: + n = layer.weight.shape[-1] + layer.weight.data = -np.sqrt(6/n) + 2*np.sqrt(6/n) * torch.rand_like(layer.weight.data) + linear_layers[0].weight.data *= 30 diff --git a/bgflow/nn/flow/root_finding/bisection.py b/bgflow/nn/flow/root_finding/bisection.py index fdaa37ef..e9992c23 100644 --- a/bgflow/nn/flow/root_finding/bisection.py +++ b/bgflow/nn/flow/root_finding/bisection.py @@ -34,8 +34,8 @@ def bisection_inverse( print(f"iteration: {i}/{max_iters}, error: {fy.abs().max().detach().cpu().numpy():.5}") if torch.all(fy.abs() < abs_tol): return x, -dfy - gt = fy > abs_tol - lt = fy < -abs_tol + gt = fy >= abs_tol + lt = fy <= -abs_tol right[gt] = x[gt] left[lt] = x[lt] if raise_exception: diff --git a/tests/conftest.py b/tests/conftest.py index c02a7a34..2d0ef2fe 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -31,7 +31,7 @@ def ctx(dtype, device): return {"dtype": dtype, "device": device} -@pytest.yield_fixture(params=[torch.enable_grad, torch.no_grad]) +@pytest.fixture(params=[torch.enable_grad, torch.no_grad]) def with_grad_and_no_grad(request): """Run a test with and without torch grad enabled""" with request.param(): diff --git a/tests/nn/test_dense.py b/tests/nn/test_dense.py new file mode 100644 index 00000000..302fc821 --- /dev/null +++ b/tests/nn/test_dense.py @@ -0,0 +1,23 @@ + +import bgflow as bg +import torch +import numpy as np + + +def test_siren_net(): + siren_net = bg.SirenDenseNet((100,200,300,1)) + linear_layers = [layer for layer in siren_net._layers if isinstance(layer, torch.nn.Linear)] + activations = [layer for layer in siren_net._layers if isinstance(layer, bg.nn.dense.Sin)] + assert len(activations) == 2 + assert len(linear_layers) == 3 + for layer in linear_layers: + assert torch.isclose(layer.weight.mean(), torch.zeros(1), atol=0.1) + assert torch.any(linear_layers[0].weight > 30 * 0.9 * np.sqrt(6/100)) + assert torch.all(linear_layers[0].weight < 30 * np.sqrt(6/100)) + assert torch.any(linear_layers[0].weight < - 30 * 0.9 * np.sqrt(6/100)) + assert torch.all(linear_layers[0].weight > - 30 * np.sqrt(6/100)) + for layer in linear_layers[1:]: + assert torch.any(layer.weight > 0.9 * np.sqrt(6/layer.weight.shape[-1])) + assert torch.all(layer.weight < np.sqrt(6/layer.weight.shape[-1])) + assert torch.any(layer.weight < - 0.9 * np.sqrt(6/layer.weight.shape[-1])) + assert torch.all(layer.weight > - np.sqrt(6/layer.weight.shape[-1])) From 99f2a9c2cf934d8db8b51cd2c1a4e2c8be0fdc3d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 11 May 2021 14:11:08 +0200 Subject: [PATCH 16/68] added stupid code for debugging --- bgflow/distribution/distribution.py | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/bgflow/distribution/distribution.py b/bgflow/distribution/distribution.py index 05bca668..7ccf99b6 100644 --- a/bgflow/distribution/distribution.py +++ b/bgflow/distribution/distribution.py @@ -2,6 +2,7 @@ import torch from .energy import Energy from .sampling import Sampler +import warnings __all__ = ["TorchDistribution", "CustomDistribution", "UniformDistribution"] @@ -72,4 +73,18 @@ class UniformDistribution(TorchDistribution): def __init__(self, low, high, validate_args=None, n_event_dims=1): uniform = torch.distributions.Uniform(low, high, validate_args) independent = torch.distributions.Independent(uniform, n_event_dims) - super().__init__(independent) \ No newline at end of file + super().__init__(independent) + + def log_prob(self, x): + try: + y = self._delegate.log_prob(x) + assert torch.isfinite(y) + return y + except (ValueError, AssertionError): + if torch.any(x < torch.distributions.Uniform.low): + indices = torch.where(x < torch.distributions.Uniform.low)[0] + print("too low", x[indices], "at indices", indices) + if torch.any(x > torch.distributions.Uniform.high): + indices = torch.where(x > torch.distributions.Uniform.high)[0] + print("too high", x[indices], "at indices", indices) + return self._delegate.log_prob(self._delegate.sample(sample_shape=x.shape)) From 0e58c1d3d7bf8eb9c2eda5482234c191f0599064 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 11 May 2021 14:17:22 +0200 Subject: [PATCH 17/68] ... --- bgflow/distribution/distribution.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/bgflow/distribution/distribution.py b/bgflow/distribution/distribution.py index 7ccf99b6..96536f0a 100644 --- a/bgflow/distribution/distribution.py +++ b/bgflow/distribution/distribution.py @@ -81,10 +81,10 @@ def log_prob(self, x): assert torch.isfinite(y) return y except (ValueError, AssertionError): - if torch.any(x < torch.distributions.Uniform.low): - indices = torch.where(x < torch.distributions.Uniform.low)[0] + if torch.any(x < self._delegate.base_dist.low): + indices = torch.where(x < self._delegate.base_dist.low)[0] print("too low", x[indices], "at indices", indices) - if torch.any(x > torch.distributions.Uniform.high): - indices = torch.where(x > torch.distributions.Uniform.high)[0] + if torch.any(x > self._delegate.base_dist.high): + indices = torch.where(x > self._delegate.base_dist.high)[0] print("too high", x[indices], "at indices", indices) return self._delegate.log_prob(self._delegate.sample(sample_shape=x.shape)) From aa7ed2cf7bfdb842383f6704f49fafa435169946 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 11 May 2021 17:21:44 +0200 Subject: [PATCH 18/68] ... --- bgflow/distribution/distribution.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/bgflow/distribution/distribution.py b/bgflow/distribution/distribution.py index 96536f0a..a2943965 100644 --- a/bgflow/distribution/distribution.py +++ b/bgflow/distribution/distribution.py @@ -75,9 +75,9 @@ def __init__(self, low, high, validate_args=None, n_event_dims=1): independent = torch.distributions.Independent(uniform, n_event_dims) super().__init__(independent) - def log_prob(self, x): + def _energy(self, x): try: - y = self._delegate.log_prob(x) + y = - self._delegate.log_prob(x)[:,None] assert torch.isfinite(y) return y except (ValueError, AssertionError): @@ -87,4 +87,4 @@ def log_prob(self, x): if torch.any(x > self._delegate.base_dist.high): indices = torch.where(x > self._delegate.base_dist.high)[0] print("too high", x[indices], "at indices", indices) - return self._delegate.log_prob(self._delegate.sample(sample_shape=x.shape)) + return -self._delegate.log_prob(self._delegate.sample(sample_shape=x.shape))[:,None] From 7fb1e2718276060992832aacd025db0829c09503 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 11 May 2021 17:37:34 +0200 Subject: [PATCH 19/68] ... --- bgflow/distribution/distribution.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bgflow/distribution/distribution.py b/bgflow/distribution/distribution.py index a2943965..e0817a9f 100644 --- a/bgflow/distribution/distribution.py +++ b/bgflow/distribution/distribution.py @@ -78,7 +78,7 @@ def __init__(self, low, high, validate_args=None, n_event_dims=1): def _energy(self, x): try: y = - self._delegate.log_prob(x)[:,None] - assert torch.isfinite(y) + assert torch.all(torch.isfinite(y)) return y except (ValueError, AssertionError): if torch.any(x < self._delegate.base_dist.low): From caf167e7ac15dca8196bd89123c82622f2f47e1a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jonas=20K=C3=B6hler?= Date: Tue, 11 May 2021 21:13:27 +0200 Subject: [PATCH 20/68] fixed broken sigmas/alphas; working grid inversion? --- bgflow/nn/flow/root_finding/approx_inverse.py | 137 +++++- bgflow/nn/flow/root_finding/bisection.py | 34 ++ bgflow/nn/flow/root_finding/newton.py | 132 +++-- bgflow/nn/flow/transformer/compact/compact.py | 65 ++- notebooks/compact/compact.ipynb | 456 +++--------------- 5 files changed, 354 insertions(+), 470 deletions(-) diff --git a/bgflow/nn/flow/root_finding/approx_inverse.py b/bgflow/nn/flow/root_finding/approx_inverse.py index 70b3056e..ec2f355e 100644 --- a/bgflow/nn/flow/root_finding/approx_inverse.py +++ b/bgflow/nn/flow/root_finding/approx_inverse.py @@ -1,13 +1,19 @@ +import numpy as np import torch from bgflow.nn.flow.base import Flow from bgflow.nn.flow.transformer import Transformer +from bgflow.nn.flow.root_finding.bisection import ( + find_interval +) __all__ = [ - "DifferentiableApproximateInverse", - "WrapFlowWithInverse", - "TransformerToFlowAdapter", - "WrapTransformerWithInverse" +# "DifferentiableApproximateInverse", +# "WrapFlowWithInverse", +# "TransformerToFlowAdapter", +# "WrapTransformerWithInverse", + "WrapCDFTransformerWithInverse", + "GridInversion" ] @@ -111,4 +117,125 @@ def _inverse(self, cond, out, *args, **kwargs): flow, out, *flow.parameters() - ) \ No newline at end of file + ) + + +class TransformerApproximateInverse(torch.autograd.Function): + + @staticmethod + def forward(ctx, oracle, bijection, cond, out, *params): + + with torch.no_grad(): + inp, dlogp = oracle(cond, out) + + ctx.save_for_backward(cond, inp, *params) + ctx.bijection = bijection + + return inp, dlogp + + @staticmethod + def backward(ctx, grad_out_x, grad_out_dlogp): + cond, x, *params = ctx.saved_tensors + + with torch.enable_grad(): + x = x.detach().requires_grad_(True) + y, dlogp = ctx.bijection(cond, x) + + force = torch.autograd.grad(-dlogp.sum(), x, create_graph=True)[0] + + grad_out_x = (-dlogp).exp() * grad_out_x + grad_out_dlogp = (-dlogp).exp() * grad_out_dlogp + + grad_in_y = grad_out_x + force * grad_out_dlogp + + grad_in_params = torch.autograd.grad( + [ + y, + y, + dlogp.exp() + ], + params, + grad_outputs=[ + -grad_out_x, + -force * grad_out_dlogp, + -grad_out_dlogp + ], + create_graph=True + ) + + return None, None, grad_in_y, *grad_in_params + + +class WrapCDFTransformerWithInverse(Transformer): + + def __init__(self, transformer, oracle): + super().__init__() + self._transformer = transformer + self._oracle = oracle + + def _forward(self, *args, **kwargs): + return self._transformer(*args, **kwargs) + + def _inverse(self, cond, out, *args, **kwargs): + return TransformerApproximateInverse.apply( + self._oracle, + self._transformer, + cond, + out, + *self._transformer.parameters() + ) + + +class GridInversion(Transformer): + + def __init__( + self, + transformer, + compute_init_grid, + verbose=False, + abs_tol=1e-6, + newton_threshold=1e-4, + max_iters=100, + raise_exception=False + ): + super().__init__() + self._transformer = transformer + self._compute_init_grid = compute_init_grid + self._verbose = verbose + self._abs_tol = abs_tol + self._newton_threshold = newton_threshold + self._max_iters = max_iters + self._raise_exception = raise_exception + + def forward(self, cond, out, *args, **kwargs): + + def _residual(inp): + extra_dims = len(out.shape) - len(cond.shape) + out_pred, dlogp = self._transformer( + cond.view(*np.ones(extra_dims, dtype=int), *cond.shape).expand_as(inp), + inp, + *args, + **kwargs + ) + return out_pred - out, dlogp + + + init_grid = self._compute_init_grid(cond, out) + left, right, fleft, dfleft = find_interval( + _residual, + init_grid, + verbose=self._verbose, + threshold=self._abs_tol, + max_iters=self._max_iters, + raise_exception=self._raise_exception + ) + + return left, -dfleft +# return stable_newton_raphson( +# _residual, +# left, right, fleft, dfleft, +# verbose=self._verbose, +# abs_tol=self._abs_tol, +# max_iters=self._max_iters, +# raise_exception=self._raise_exception +# ) \ No newline at end of file diff --git a/bgflow/nn/flow/root_finding/bisection.py b/bgflow/nn/flow/root_finding/bisection.py index fdaa37ef..0e8b5a29 100644 --- a/bgflow/nn/flow/root_finding/bisection.py +++ b/bgflow/nn/flow/root_finding/bisection.py @@ -42,6 +42,40 @@ def bisection_inverse( raise ValueError(f"Root finding did not converge: error={fy.abs().max().detach().cpu().item():.5}") else: return x, -dfy + + +def filter_grid(f, grid): + fgrid, dfgrid = f(grid) + lidx = ((fgrid < 0).sum(dim=0, keepdim=True) - 1).clamp_min(0) + ridx = (lidx + 1).clamp_max(len(grid) - 1) + left = grid.gather(0, lidx) + right = grid.gather(0, ridx) + fleft = fgrid.gather(0, lidx) + dfleft = dfgrid.gather(0, lidx) + return ( + torch.linspace(0, 1, len(grid), dtype=grid.dtype, device=grid.device).view(-1, 1, 1) * (right - left) + left, + (left[0], right[0], fleft[0], dfleft[0]), + ) + + +def find_interval(f, grid, threshold=1e-4, max_iters=100, verbose=False, raise_exception=False): + if verbose: + print(f"starting grid search with max_iters={max_iters}, threshold={threshold:.4}") + converged = False + for it in range(max_iters): + if torch.all(grid[-1] - grid[0] < threshold): + converged=True + break + (grid, (left, right, fleft, dfleft)) = filter_grid(f, grid) + if verbose: + print(f"it: {it}, interval: {(grid[-1] - grid[0]).abs().max().item():.4}, err: {fleft.abs().max().item():.4}") + if not converged: + msg = f"interval finding did not converge: err={(right - left).abs().max().item():.5}" + if raise_exception: + raise ValueError(msg) + else: + warnings.warn(msg) + return left, right, fleft, dfleft class BisectionRootFinder(torch.nn.Module): diff --git a/bgflow/nn/flow/root_finding/newton.py b/bgflow/nn/flow/root_finding/newton.py index 7a8d2787..1791b889 100644 --- a/bgflow/nn/flow/root_finding/newton.py +++ b/bgflow/nn/flow/root_finding/newton.py @@ -1,90 +1,70 @@ +import warnings + import torch import numpy as np __all__ = [ - "NewtonRaphsonRootFinder" + "stable_newton_raphson" ] -# TODO this is not really working so far! -def newton_raphson_inverse( +def stable_newton_raphson( f, - x0, - abs_tol=1e-6, - max_iters=100, + left, + right, + fleft=None, + dfleft=None, + abs_tol=1e-5, + max_iters=20, verbose=False, - max_step=0.1, - min_step=0., - step_shrink=0.9, - log_derivative=True, - raise_exception=True -): - x = x0 - last_val = None - max_step = torch.ones_like(x) * max_step + raise_exception=False +): + if verbose: + print(f"starting stable newton raphson with max_iters={max_iters}, abs_tol={abs_tol:.4}") + if fleft is None or dfleft is None: + fleft, dfleft = f(left) + x = left + fx = fleft + dfx = dfleft + + converged = False - for i in range(max_iters): - fy, dfy = f(x) - if last_val is not None: - max_step=torch.where( - fy.abs() > last_val.abs(), - (max_step * step_shrink).clamp_min(min_step), - max_step - ) - max_step = (max_step * step_shrink).clamp_min(min_step) + for it in range(max_iters): + + + + step = fx / dfx.exp() + x_cand = x - step + x = torch.where( + (x_cand > left) & (x_cand < right), + x_cand, + (left + right) / 2 + ) + fx, dfx = f(x) + err = fx.abs() + if verbose: - if verbose <= 1: - print(f"iteration: {i}, error: {(fy).abs().max().item()}") - else: - print(f"iteration: {i}, x: {x.detach().cpu().numpy()}, f(x): {fy.detach().cpu().numpy()}") - if fy.abs().max().item() < abs_tol: - return x, -dfy - else: - dfy = (-dfy).exp() - step = fy * dfy.expand_as(x) - step = torch.where( - step.abs() > max_step, - step.sign() * max_step, - step - ) - x = x - step - x = x.clamp(0, 1) + print(f"it: {it}, err: {err.max().item():.4}") + + converged = torch.all( + ((right - left) < abs_tol) | (fx.abs() < abs_tol) | (x == left) | (x == right) + ) + + if converged: + break + + lt = fx < 0 + gt = fx > 0 - last_val = fy - if raise_exception: - raise ValueError(f"Root finding did not converge: error={fy.abs().max().item()}") - else: - return x, -dfy - - -class NewtonRaphsonRootFinder(torch.nn.Module): - - def __init__( - self, - abs_tol=torch.tensor(1e-6), - max_iters=100, - max_step=torch.tensor(0.1), - step_shrink=torch.tensor(0.9), - verbose=False, - raise_exception=True - ): - super().__init__() - self._max_iters = max_iters - self.register_buffer("_abs_tol", abs_tol) - self.register_buffer("_max_step", max_step) - self.register_buffer("_step_shrink", step_shrink) - self._verbose=verbose - self._raise_exception=raise_exception + left[lt] = x[lt] + right[gt] = x[gt] + + if not converged: + msg = f"root finding did not converge: err={err.max().item():.5}" + if raise_exception: + raise ValueError(msg) + else: + warnings.warn(msg) - def forward(self, callback, x0): - return newton_raphson_inverse( - callback, - x0, - abs_tol=self._abs_tol, - max_iters=self._max_iters, - max_step=self._max_step, - step_shrink=self._step_shrink, - verbose=self._verbose, - raise_exception=self._raise_exception - ) \ No newline at end of file + return x, -dfx diff --git a/bgflow/nn/flow/transformer/compact/compact.py b/bgflow/nn/flow/transformer/compact/compact.py index e00f41ed..b7820201 100644 --- a/bgflow/nn/flow/transformer/compact/compact.py +++ b/bgflow/nn/flow/transformer/compact/compact.py @@ -11,6 +11,7 @@ "SmoothRamp", "PowerRamp", "AffineSigmoidComponents", + "AffineSigmoidComponentInitGrid", "MixtureCDFTransformer", "ConstrainedBoundaryCDFTransformer" ] @@ -29,12 +30,26 @@ def polynomial_ramp(x, power=3): def smooth_ramp_pow2(x, alpha, unimodal=True, eps=1e-8): if unimodal: alpha = alpha + _SMOOTH_RAMP_INFLECTION_ALPHA_2 + + nonzero = x > 0 + xinv = x.clamp_min(eps).reciprocal() +# xinv = x.reciprocal() arg = xinv.pow(2).neg() ramp = ((1 + arg) * alpha).exp() +# ramp = torch.where( +# nonzero, +# ramp, +# torch.zeros_like(ramp) +# ) grad_arg = xinv.pow(3) * 2 grad = ramp * grad_arg * alpha +# grad = torch.where( +# nonzero, +# grad, +# torch.zeros_like(ramp) +# ) return ramp, grad @@ -44,12 +59,26 @@ def smooth_ramp_pow2(x, alpha, unimodal=True, eps=1e-8): def smooth_ramp_pow1(x, alpha, unimodal=True, eps=1e-8): if unimodal: alpha = alpha + _SMOOTH_RAMP_INFLECTION_ALPHA_1 + + nonzero = x > 0 + xinv = x.clamp_min(eps).reciprocal() +# xinv = x.reciprocal() arg = xinv.neg() ramp = ((1 + arg) * alpha).exp() +# ramp = torch.where( +# nonzero, +# ramp, +# torch.zeros_like(ramp) +# ) grad_arg = xinv.pow(2) grad = ramp * grad_arg * alpha +# grad = torch.where( +# nonzero, +# grad, +# torch.zeros_like(ramp) +# ) return ramp, grad @@ -141,7 +170,7 @@ def __init__( compute_alpha: Callable, unimodal: bool=True, eps: torch.Tensor=torch.tensor(1e-8), - alpha_constraint: Callable=torch.nn.functional.softplus, + max_alpha: torch.Tensor=torch.tensor(10.), ramp_type: str="type1" ): super().__init__() @@ -155,11 +184,12 @@ def __init__( self._compute_alpha = compute_alpha self._unimodal = unimodal self.register_buffer("_eps", eps) - self._alpha_constraint = alpha_constraint + self.register_buffer("_max_alpha", max_alpha) def forward(self, out, cond): - alpha = self._alpha_constraint(self._compute_alpha(cond)).view(1, 1, *out.shape[2:]) + alpha = self._compute_alpha(cond).sigmoid() * self._max_alpha + alpha = alpha.view(1, 1, *out.shape[2:]) return self._ramp_fn(out, alpha, unimodal=self._unimodal, eps=self._eps) @@ -170,6 +200,7 @@ def __init__( conditional_ramp: ConditionalRamp, compute_params: torch.nn.Module, min_density=torch.tensor(1e-4), + log_sigma_bound=torch.tensor(4.), periodic=True, zero_boundary_left=False, zero_boundary_right=False @@ -178,6 +209,7 @@ def __init__( self._conditional_ramp = conditional_ramp self._param_net = compute_params self.register_buffer("_min_density_lower_bound", min_density) + self.register_buffer("_log_sigma_bound", log_sigma_bound) self._periodic = periodic self._zero_boundary_left = zero_boundary_left @@ -202,14 +234,15 @@ def _compute_params(self, cond, out): log_sigma = log_sigma.view(*out.shape, -1) if self._periodic or self._zero_boundary_right or self._zero_boundary_left: - # if boundary constraint exist assert that sigma in [1, \infty] - log_sigma = torch.nn.functional.softplus(log_sigma) + log_sigma = log_sigma.sigmoid() * self._log_sigma_bound min_value = torch.tensor(1.).to(out) if self._zero_boundary_left: min_value = torch.minimum(mu, min_value) if self._zero_boundary_right: min_value = torch.minimum(1. - mu, min_value) log_sigma = log_sigma - min_value.log() + else: + log_sigma = log_sigma.tanh() * self._log_sigma_bound # min density in [lb, 1] lower_bound = self._min_density_lower_bound.expand_as(min_density) @@ -233,6 +266,27 @@ def forward(self, cond, out, *args, **kwargs): out, ramp, mu, log_sigma, min_density, periodic=self._periodic ) + +class AffineSigmoidComponentInitGrid(torch.nn.Module): + + def __init__(self, components: AffineSigmoidComponents): + super().__init__() + self._components = components + + def forward(self, cond, inp): + mu, _, _ = self._components._compute_params(cond, inp) + if torch.any(mu.min(dim=-1).values > 0): + mu = torch.cat([ + torch.zeros_like(mu[..., [0]]), + mu + ], dim=-1) + if torch.any(mu.max(dim=-1).values < 1): + mu = torch.cat([ + mu, + torch.ones_like(mu[..., [-1]]) + ], dim=-1) + return mu.permute(-1, *np.arange(len(mu.shape) - 1)).contiguous() + class MixtureCDFTransformer(Transformer): @@ -326,7 +380,6 @@ def _compute_params(self, cond, out): mu.append(torch.ones_like(out)) mu = torch.stack(mu, dim=-1) log_sigma = torch.nn.functional.softplus(self._log_sigma).expand(*out.shape, self._n_constraints) - print( self._compute_constraints(cond).shape, out.shape) log_pdf_constraint = self._compute_constraints(cond).view(*out.shape, self._n_constraints) + np.log(self._n_constraints + 1) return mu, log_sigma, log_pdf_constraint diff --git a/notebooks/compact/compact.ipynb b/notebooks/compact/compact.ipynb index 441335d7..5df607d9 100644 --- a/notebooks/compact/compact.ipynb +++ b/notebooks/compact/compact.ipynb @@ -23,7 +23,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -43,16 +43,20 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "from bgflow import (\n", " DenseNet,\n", " \n", - " WrapTransformerWithInverse,\n", + " WrapCDFTransformerWithInverse,\n", + " GridInversion,\n", + " AffineSigmoidComponentInitGrid,\n", + " \n", " MixtureCDFTransformer,\n", - " AffineSigmoidComponents,\n", + " AffineSigmoidComponents, \n", + " \n", " SmoothRamp,\n", " BisectionRootFinder,\n", " \n", @@ -95,26 +99,35 @@ " zero_boundary_left=False,\n", " zero_boundary_right=False,\n", " activation=torch.nn.SiLU(),\n", - " smoothness_type=\"type1\"\n", + " smoothness_type=\"type1\",\n", + " init_weight=1.\n", "):\n", - " return WrapTransformerWithInverse(\n", - " transformer=MixtureCDFTransformer(\n", - " compute_weights=DenseNet([d_in, d_hidden, d_hidden, d_out * n_components], activation),\n", - " compute_components=AffineSigmoidComponents(\n", - " conditional_ramp=SmoothRamp(\n", - " compute_alpha=DenseNet([d_in, d_hidden, d_hidden, d_out * n_components], activation),\n", - " unimodal=True,\n", - " ramp_type=smoothness_type\n", + " return WrapCDFTransformerWithInverse(\n", + " transformer=(\n", + " t:=MixtureCDFTransformer(\n", + " compute_weights=DenseNet([d_in, d_hidden, d_hidden, d_out * n_components], activation),\n", + " compute_components=AffineSigmoidComponents(\n", + " conditional_ramp=SmoothRamp(\n", + " compute_alpha=DenseNet([d_in, d_hidden, d_hidden, d_out * n_components], activation),\n", + " unimodal=True,\n", + " ramp_type=smoothness_type\n", + " ),\n", + " compute_params=DenseNet([d_in, d_hidden, d_hidden, d_out * (3 * n_components)], activation, weight_scale=init_weight),\n", + " min_density=torch.tensor(1e-4),\n", + " periodic=periodic,\n", + " zero_boundary_left=zero_boundary_left,\n", + " zero_boundary_right=zero_boundary_right\n", + "\n", " ),\n", - " compute_params=DenseNet([d_in, d_hidden, d_hidden, d_out * (3 * n_components)], activation),\n", - " min_density=torch.tensor(1e-4),\n", - " periodic=periodic,\n", - " zero_boundary_left=zero_boundary_left,\n", - " zero_boundary_right=zero_boundary_right\n", - " \n", - " ),\n", + " )\n", " ),\n", - " root_finder=BisectionRootFinder(abs_tol=torch.tensor(1e-5), max_iters=100, verbose=True, raise_exception=True)\n", + " oracle=GridInversion(\n", + " transformer=t,\n", + " compute_init_grid=AffineSigmoidComponentInitGrid(\n", + " t._compute_components\n", + " ),\n", + " verbose=True\n", + " )\n", " )\n", "\n", "\n", @@ -165,7 +178,7 @@ " \n", "\n", " \n", - "def plot_evaluation(flow, dataset=\"pinwheel\", train_with_inverse=False, n_samples=100_000):\n", + "def plot_evaluation(flow, dataset=\"pinwheel\", train_with_inverse=False, n_samples=100_000, norm=\"log\"):\n", " \n", " print(\"Computing energy plot...\")\n", " with torch.no_grad():\n", @@ -178,13 +191,20 @@ " u = -dlogp\n", " u = u.view(100, 100)\n", " \n", - " norm = LogNorm()\n", + " \n", + " if norm == \"log\":\n", + " norm = LogNorm()\n", + " else:\n", + " norm = None\n", " plt.figure(figsize=(8, 8))\n", " plt.title(\"Energy\")\n", " plt.imshow((-u).exp().detach(), norm=norm)\n", " \n", " print(\"Sampling ground truth...\")\n", - " norm = LogNorm()\n", + " if norm == \"log\":\n", + " norm = LogNorm()\n", + " else:\n", + " norm = None\n", " x = (inf_train_gen(dataset, batch_size=n_samples) + 4) / 8\n", " x = torch.FloatTensor(x) % 1\n", " plt.figure(figsize=(8, 8))\n", @@ -192,7 +212,10 @@ " plt.hist2d(*x.detach().numpy().T, bins=100, density=True, norm=norm, range=((0, 1), (0, 1)));\n", " \n", " print(\"Sampling model...\")\n", - " norm = LogNorm()\n", + " if norm == \"log\":\n", + " norm = LogNorm()\n", + " else:\n", + " norm = None\n", " with torch.no_grad():\n", " z = torch.rand(n_samples, 2)\n", " x, _ = flow(z, inverse=not train_with_inverse)\n", @@ -210,32 +233,20 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 5, "metadata": {}, "outputs": [ { - "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" + "ename": "NameError", + "evalue": "name 'NewtonGridInversion' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\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 1\u001b[0m plot_transformer_density(\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mmake_transformer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0md_in\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md_out\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md_hidden\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m40\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_components\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mperiodic\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mzero_boundary_left\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mzero_boundary_right\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\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 3\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"no constraints, non-periodic\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m )\n\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mmake_transformer\u001b[0;34m(d_in, d_out, d_hidden, n_components, periodic, zero_boundary_left, zero_boundary_right, activation, smoothness_type, init_weight)\u001b[0m\n\u001b[1;32m 73\u001b[0m )\n\u001b[1;32m 74\u001b[0m ),\n\u001b[0;32m---> 75\u001b[0;31m oracle=NewtonGridInversion(\n\u001b[0m\u001b[1;32m 76\u001b[0m \u001b[0mtransformer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 77\u001b[0m compute_init_grid=AffineSigmoidComponentInitGrid(\n", + "\u001b[0;31mNameError\u001b[0m: name 'NewtonGridInversion' is not defined" + ] } ], "source": [ @@ -259,46 +270,9 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkkAAADSCAYAAABevlSdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABKBklEQVR4nO3dd3xUVfr48c+Zkpkkk95JgNBFIEDoghQRRRQRdRULirq6umtbV3f169rX37quZW276tob4KIiYFkLKwgiGIr0XkMgvbdp5/fHDDGQAAmZyUyS5/16zWvKvfecZ+YmmSfnnHuO0lojhBBCCCGOZgh0AEIIIYQQwUiSJCGEEEKIRkiSJIQQQgjRCEmShBBCCCEaIUmSEEIIIUQjJEkSQgghhGiEJElCtFFKqU1KqfFN3HevUursFtT1llLqL6d6vK8opcYrpbJbqa6rlFJftUZdQojgJEmSEG2U1rqf1vq7lpbTmolHW6K1fl9rfU6g4xBCBI4kSUK0MUopU6BjaIva0ufWlmIVoj2TJEmINsDbXfYnpdR6oFIpZarfhaaUClVKva2UKlZKbVFK/bGR1qFBSqn1SqlSpdRcpZRVKRUOfAF0UkpVeG+djhNGvFLqa6VUuVJqiVKqa734zlBK/eQt+yel1BnHxH52vecPK6Xe8z5OV0pppdS1Sqn9SqkCpdT99fYN9Xb1FSulNgPDjvlc7lVK7fLGtFkpNb3etllKqeVKqWeVUkXAY0qpIqXUgHr7JCqlqpVSCY185rOUUsu8j5W3nDzve1yvlOrfyDGj6n2OFUqpGqXUXu82Q714C5VSHyqlYo/5HG5QSu0HFnv3/7NSap+33neUUlHHOTdCCD+QJEmItuMK4HwgWmvtPGbbQ0A60B2YBFzdyPGXAZOBbkAGMEtrXQmcB+RorW3eW85x6r8KeAyIB9YB7wN4v+g/A54H4oBngM+UUnHNeG9jgD7AROBBpVTfeu+rh/d2LnDtMcftAs4EooBHgPeUUin1to8AdgOJwKPAHI7+bK4AvtFa558kvnOAsUBvIBq4HCg8diet9YojnyMQA/wIzPZuvh24CBgHdAKKgZeOKWIc0Nf7Xmd5bxPwnFcb8OJJ4hRC+JAkSUK0Hc9rrQ9orasb2XYZ8P+01sVa62w8CUtjx+dorYuAhcCgZtb/mdZ6qda6FrgfGKWU6owncduhtX5Xa+3UWs8GtgJTm1H2I1rraq31z8DPwMB67+txrXWR1vrAse9La/0f73tya63nAjuA4fV2ydFav+CNqxp4G7hSKXXkb99M4N0mxOcAIoDTAKW13qK1PnSSY54HKvF8VgC/Ae7XWmd7P8OHgUuP6Vp7WGtd6Y31KuAZrfVurXUFcB8wQ7rihGg9kiQJ0XYcOMG2Tsdsb2zfw/UeV+FpmTil+r1f2kXeejsB+47Zdx+Q2oyyjxfbse/rqHqUUtcopdYppUqUUiVAfzwtXQ1i9sa9Ek/iMk4pdRrQE1hwsuC01ovxtOK8BOQqpV5VSkUeb3+l1G+A8cCVWmu39+WuwCf1Yt0CuICk48R77Oe6DzAds78Qwo8kSRKi7dAn2HYISKv3vLOPyq2vrkyllA2IBXK8t67H7NsFOOh9XAmE1duW3IzYDnH0e+lSL4auwL+BW4E4rXU0sBFQ9fZv7L29jafLbSYwT2td05RAtNbPa62HAP3wdLvd09h+Sqkz8XRLTtNal9bbdAA4T2sdXe9m1VofrLdP/XiP/Vy7AE4gtynxCiFaTpIkIdqHD4H7lFIxSqlUPIlDU+UCcU0YFDxFKTVGKRWCJwlY6e0C+xzorZS60jug/HLgdGCR97h1eLqJzEqpocClp/i+0oDb6m0Lx5NU5AMopa7D05J0Mu8C0/EkSu80JQil1DCl1AillBlP0leDpxXo2P06A3OBa7TW24/Z/DLw+JEB70qpBKXUtBNUOxv4vVKqmzcp/X/A3EbGowkh/ESSJCHah0eBbGAP8A0wD6htyoFa6614vpB3e7uCjnd12wd4BlIXAUPwjJlBa10IXAD8Ac9g5j8CF2itC7zHPYBn4HUxnsHVHzTjfT2Cp5tpD/AV9cYPaa03A08DK/AkegOA5Scr0Dtmaw2eBOv7JsYRiafVqtgbTyHwVCP7TcTTUjav3hVum7zbnsPTtfeVUqocz6DuESeo8w0873cpnvdfw9FJohDCz5TWTW1pF0K0FUqpW4AZWutxgY4lGCml3sAzqPvPgY5FCBG85CoJIdoB72Xv3fG0qvTC06ojl4s3QimVDlwMDA5wKEKIICfdbUK0DyHAK0A5sBj4FPhnQCMKQkqpx/AM7v671npPoOMRQgQ36W4TQgghhGiEtCQJIYQQQjRCkiQhhBBCiEb4ZeB2fHy8Tk9P90fRQgghhBA+tXr16gKtdYOFrv2SJKWnp5OVleWPooUQQgghfEopdezSSoB0twkhhBBCNEqSJCGEEEKIRkiSJIQQQgjRiCaNSVJK/R74NZ61jjYA1zV15WwhhBCiI3A4HGRnZ1NTI1+PwcpqtZKWlobZbG7S/idNkrwrit8OnK61rlZKfQjMAN5qSaBCCCFEa3I67by2/GEuG/xbYiPTfF5+dnY2ERERpKeno5TyefmiZbTWFBYWkp2dTbdu3Zp0TFO720xAqFLKBIQBOacYoxBCCBEQS3d8wkt7F/L8qif8Un5NTQ1xcXGSIAUppRRxcXHNauk7aZKktT4IPAXsBw4BpVrrr045SiGEECIAdhdsBsDpqPZbHZIgBbfmnp+TJklKqRhgGtAN6ASEK6WubmS/m5RSWUqprPz8/GYFIYQQQvjbxiJPknReZO8ARxJYNput7vE999xDv379uOeeewIYUfBqysDts4E9Wut8AKXUx8AZwHv1d9Javwq8CjB06FBZNVcIIUTw0Jq7owdxraUzg0PiAx1N0HjllVfIz8/HYrEEOpSg1JQxSfuBkUqpMOVpp5oIbPFvWEIIIYQP1ZaR5jbQ15rIzrI9aLc70BH5zTvvvENGRgYDBw5k5syZ7Nmzh1GjRjFs2DAeeOCBuv0uvPBCKisrGTFiBHPnzg1gxMHrpC1JWuuVSql5wBrACazF22IkhBBCtAUb9i9lS/kOysJieO7gVyypuIXYyFS/1ffIwk1szinzaZmnd4rkoan9TrjPpk2bePzxx1m+fDnx8fEUFRUxa9YsbrnlFq655hpeeumlun0XLFiAzWZj3bp1Po2zPWnS1W1a64e01qdprftrrWdqrWv9HZgQQgjhK1/u+4q/Fa+ma+IAALKLtgU4Iv9YvHgxl156KfHxni7F2NhYli9fzhVXXAHAzJkzAxlem+OXBW6FEEKIYLK+ZAenhyXTLf50ALKLd5GRfpbf6jtZi4+/aK0bvYJLrro7NbIsiRBCiHbN4ahhS/VhMqJ7kxp3GgDZZXsDG5SfTJw4kQ8//JDCwkIAioqKGD16NHPmzAHg/fffD2R4bY4kSUIIIdq17TkrqdUuMhIHE2qJJN4YSnZl+5wTuV+/ftx///2MGzeOgQMHctddd/Hcc8/x0ksvMWzYMEpLSwMdYpsi3W1CCCHatV15PwMwsPMYAP7U6WySQ6IDGJF/XXvttVx77bVHvbZixYq6x/fee2/d44qKilaLqy2SJEkIIUS7dmF4OuO7X0tEdE8AJiePhNIDAY5KtAXS3SaEEKJ9K8shMqYbyuD5yisymlhWsg2Ho+lreImOSZIkIYQQ7VZxeQ6/2/cJ6/Qv67Utq9jDLXn/42A7nQZA+I4kSUIIIdqtDfuXsrQmB4c1uu61tOgeAGQXbQ9QVKKtkCRJCCFEu7U+bw0GFP06n1n3WlqcZ4Hb7NI9gQpLtBGSJAkhhGi31hdvpbc1njBrVN1r8ZFdsSgj2eXZAYxMtAWSJAkhhGiX3G4XGyqyyYjscdTrBoORVHMk2VWHAhRZ+7Zu3To+//zzZh83fvx4srKyTrlem81W9/iee+6hX79+3HPPPadcHsgUAEIIIdqp0pK99A6JZkjSkAbbHul6EVFuVwCiav/WrVtHVlYWU6ZMCVgMr7zyCvn5+VgslhaVIy1JQggh2qWY2greTprElD6/arBtUMIAumkDaB2AyPznnXfeISMjg4EDB9YtZrtv3z4mTpxIRkYGEydOZP/+/QDMmjWLW265hQkTJtC9e3eWLFnC9ddfT9++fZk1a1ZdmTabjT/84Q9kZmYyceJE8vPzgaNbfgoKCkhPT8dut/Pggw8yd+5cBg0axNy5c6msrOT6669n2LBhDB48mE8//RSA6upqZsyYQUZGBpdffjnV1dU0Jj09nT/96U8MHz6c4cOHs3PnTgD27NnDqFGjGDZsGA888EDd/hdeeCGVlZWMGDGCuXPntujzlJYkIYQQ7ZK7NBuDyQJhsQ22HcLFspLNTK7MJ8KW6PvKd3wDFbm+LdOWBL3OPu7mTZs28fjjj7N8+XLi4+MpKioC4NZbb+Waa67h2muv5Y033uD2229n/vz5ABQXF7N48WIWLFjA1KlTWb58Oa+99hrDhg1j3bp1DBo0iMrKSjIzM3n66ad59NFHeeSRR3jxxRcbjSEkJIRHH32UrKysun3+7//+j7POOos33niDkpIShg8fztlnn80rr7xCWFgY69evZ/369WRmZh73vUVGRrJq1Sreeecd7rzzThYtWsQdd9zBLbfcwjXXXMNLL71Ut++CBQuw2WysW7eumR9wQ9KSJIQQol268udn+GvZRlCqwbZt9iIeLVrFnoKNAYjMPxYvXsyll15KfHw8ALGxnuRwxYoVXHnllQDMnDmTZcuW1R0zdepUlFIMGDCApKQkBgwYgMFgoF+/fuzduxcAg8HA5ZdfDsDVV1991PFN8dVXX/HEE08waNAgxo8fT01NDfv372fp0qVcffXVAGRkZJCRkXHcMq644oq6+yNLrCxfvrzu9SOtZr4mLUlCCCHanarqErbU5HNmYsPxSABpMZ4lSrKLd5KRfpbvAzhBi4+/aK1RjSSEx6q/z5ExOwaD4ajxOwaDAafTecLjTSYTbrcbgJqa489errXmo48+ok+fPieMpakxH++xP0hLkhBCiHZnS84PuNEMSGy8Cyc17jQAssv2tWZYfjVx4kQ+/PBDCgsLAeq628444wzmzJkDwPvvv8+YMWOaVa7b7WbevHkAfPDBB3XHp6ens3r1aoC67QARERGUl5fXPT/33HN54YUX0N7xX2vXrgVg7NixvP/++wBs3LiR9evXHzeGI2OL5s6dy6hRowAYPXr0Ue/LHyRJEkII0e7kl+cAkBrbs9HtoZZI4o2hZFfmtGZYftWvXz/uv/9+xo0bx8CBA7nrrrsAeP7553nzzTfJyMjg3Xff5bnnnmtWueHh4WzatIkhQ4awePFiHnzwQQDuvvtu/vWvf3HGGWdQUFBQt/+ECRPYvHlz3cDtBx54AIfDQUZGBv37968bZH3LLbdQUVFBRkYGTz75JMOHDz9uDLW1tYwYMYLnnnuOZ599FoDnnnuOl156iWHDhlFaWtqs99RUSvthZP/QoUN1S+Y6EEIIIVri/RVP8MT291ky/QtiI9Ma3eea/0zGpIy8celnPqlzy5Yt9O3b1ydlBRObzUZFRUXA6k9PTycrK6turFVLNXaelFKrtdZDj91XxiQJIYRod7pZYpge3oOosKTj7vPXXldiq8hvxahEWyNJkhBCiHbnjPCunJEyAUzm4+6TGtUNSnLA7QKDsRWja1sC2YoE1F1lFwgyJkkIIUS7U1NbgjaFnnCf/e4aXiz+mdzina0UlWhrJEkSQgjR7vxm+9vcmL3ghPsU4OKVso3syDv+VVWiY5MkSQghRLtT5Kggymw74T5pcb0ByC7d0xohiTZIkiQhhBDtTrGzmpiQqBPuEx/ZFYsykl2e3UpRibZGkiQhhBDtisNZQ6m7ljhrzAn3MxiMpJojya461EqRtY5PPvkEpRRbt26te23v3r2EhoYyePBg+vbty/Dhw3n77bdbVM/DDz/MU089BcDWrVsZNGgQgwcPZteuXS0qN5hIkiSEEKJdKfUuLBtjbbiw7bE6W+PJqyn2d0itavbs2YwZM6ZuNuojevTowdq1a9myZQtz5szh2Wef5c033/RJnfPnz2fatGmsXbuWHj16+KTMYCBJkhBCiHbF5LLzm8j+DIjrd9J9n+x7Pe+nTAY/TKwcCBUVFSxfvpzXX3+9QZJUX/fu3XnmmWd4/vnnG2x76623mDZtGpMnT6ZPnz488sgjddsef/xx+vTpw9lnn822bdsA+Pzzz/nHP/7Ba6+9xoQJE3z/pgKoSfMkKaWigdeA/oAGrtdar/BjXEIIIcQpiVYmbo3OgPj+J903LDwJXBvAUQ0hYT6N47ovr2vw2rnp5zLjtBlUO6v57Te/bbB9Ws9pXNTzIoprirnru7uO2vbm5JO3+syfP5/JkyfTu3dvYmNjWbNmDZmZja9fl5mZeVSXXH2rVq1i48aNhIWFMWzYMM4//3yUUsyZM4e1a9fidDrJzMxkyJAhTJkyhZtvvhmbzcbdd9990hjbkqa2JD0HfKm1Pg0YCGzxX0hCCCHEqauoLqTIVYPbfOJ5kgD2uav4c+GP7Mxd2wqR+d/s2bOZMWMGADNmzGD27NnH3fdEy5JNmjSJuLg4QkNDufjii1m2bBnff/8906dPJywsjMjISC688EKfxx9sTtqSpJSKBMYCswC01nbA7t+whBBCiFPz6f6veeLgxyzVv+HEQ7fBaQ7j08rdnFGwiZ6dR/s0jhO1/ISaQk+4PcYa06SWo/oKCwtZvHgxGzduRCmFy+VCKcWTTz7Z6P5r16497lpzSqkGz7XWDV5v75rSktQdyAfeVEqtVUq9ppQKP3YnpdRNSqkspVRWfr6shSOEECIwiqqLMKCICj/+um1HdIrrA8DB8v3+Dsvv5s2bxzXXXMO+ffvYu3cvBw4coFu3bixbtqzBvnv37uXuu+/mtttua7Ssr7/+mqKiIqqrq5k/fz6jR49m7NixfPLJJ1RXV1NeXs7ChQv9/ZYCrilJkgnIBP6ltR4MVAL3HruT1vpVrfVQrfXQhIQEH4cphBBCNE1RbTHRRguGJqzHFmqJJFyZKWoHV7jNnj2b6dOnH/XaJZdcwgcffADArl276qYAuOyyy7jtttu47rqG46YAxowZw8yZMxk0aBCXXHIJQ4cOJTMzk8svv7zutTPPPNPv7ynQmjJwOxvI1lqv9D6fRyNJkhBCCBEMiu2lxJqaPgg7xhRKUW2J/wJqJd99912D126//fa6x9XV1U0uKzExkRdffLHB6/fffz/3339/g9cffvjhJpfdlpy0JUlrfRg4oJTq431pIrDZr1EJIYQQp6jIXk6sOaLJ+6eGRGPQbj9GJNqqJk0BANwGvK+UCgF2A423zwkhhBABdmV0f4yh0U3e/7Xes6C2zG/xtDWzZs1i1qxZgQ4jKDQpSdJarwOG+jcUIYQQouUmh6ZC4sknkqwTEgYVh/0XkGizZMZtIYQQ7YbLaWdr5SHKDU2/VP2Lki3cfGAR2t3yLrcTzT0kAq+550eSJCGEEO1GUcVBfnX4Cz4vXNfkY/KcVSyvyaG8urBFdVutVgoLCyVRClJaawoLC7FarU0+pqljkoQQQoigV+TtNosNbfpUNDGhcQAUVxwiMvzUp7BJS0sjOzsbmSsweFmtVtLS0pq8vyRJQggh2o2iSk+SFBOW2ORjYr37FlcepisZp1y32WymW7dup3y8CD7S3SaEEKLdKK7ytOLEhic3+ZgjCVVRVZ5fYhJtlyRJQggh2o2i6gIAYm0pTT4mzpZCuikSg0uWJRVHk+42IYQQ7cYZkT14JHYkkeFN725Lju7Gwk4XQPRpfoxMtEWSJAkhhGg3upsj6R47AJqwblsdo9lzc1T5LzDRJkl3mxBCiHZjU/EOtrubn+z8qeAH/rHrEz9EJNoyaUkSQgjRbjxx4HMsBhOvNfO4A85ySitdfolJtF3SkiSEEKLdKHZUENOMxW2PiDFHUOSo8ENEoi2TJEkIIUS7UeSqJsYS3ezjYkIiKXJW+j4g0aZJkiSEEKJdcDhqKHfbibXGNPvYWEsUxc5qn6zfJtoPSZKEEEK0C8WVOQDEWmObfWyPiK4MtiRgly43UY8M3BZCCNEuRGLi5YTxdE8Z2exjp3U5m2lVteCWwdviF9KSJIQQol2wup2MDu1ESmSX5h9sDvPc22WuJPELSZKEEEK0C/tKdvNt1QFqDM3vJNldU8D5OQtYnrPcD5GJtkqSJCGEEO3C0sMrubPge2oNzf9qs1ij2O+sIK/ysB8iE22VJElCCCHaheKaIkwoIsISmn1sjK0TAEXVhb4OS7RhkiQJIYRoF4pqiok2WjE0Z902rzBrFKHKRHFNsR8iE22VJElCCHGKXE4H87NeYMmm2YEORQBF9jJiTGGnfHyM0UpxbYnvAhJtnkwBIIQQp2B79goe/uFBNlQfJlyZ+aLLOGIiOgU6rA6tyFFO7CksSXLEhMhepFjifBiRaOukJUkIIZrDaYed31C68UNy7KXc2f1iqrSDN1c+GejIOry/JE3gvq5TT/n4e7tewLUxGT6MSLR10pIkhBBN9MO2j9m883N+HdaDYd3O4ctxD2INjWFn6W4Ol+xC15SjrKfekiFaJl2FQFS3Uy/AHAqV+b4LSLR50pIkhBBNUGuv5O5Vj/NZ+U4cAy+HPudhDfWsEfbo+Kd5Mn4M6sDKAEfZcTns1bxfvJ6d9pJTLuOVw8s4c+ebaK19F5ho0yRJEkKIJli27WPK3XbuGXQr5tjuR20z2xIhuT/79y2hoHhPgCLs2IoqcniieDVrKvefchkmk5USdy3VNaU+jEy0ZZIkCSFEE3y553NiDFaG92x8zEtZSgaX5Czk5ZV/beXIBEBR5SEA4kKbP0fSEbGhnkHbRRU5PolJtH2SJAkhxElU1ZSypGQr5yQMxmSyNLpPZFRnpiWO4KPclRws2NzKEYriylwAYsIST7mMmNB4b1ky67bwaHKSpJQyKqXWKqUW+TMgIYQINmW56xkb2onze04/4X43Dv8jBuCVVX9vncBEnaIqz4DrWFvKKZcRG5YEQHFlnk9iEm1fc1qS7gC2+CsQIYQIVslluTyVOpnB3c894X5JsT24LGUMC/JXsy93fStFJwCKqgsAiLEln3IZKVFduDi8B3GmUF+FJdq4JiVJSqk04HzgNf+GI4QQwaWqqoi9uesgoS80YeHUG0b8iXCDmZ+3fez/4ESdSxOHsbDThUS2YExSQmQXHokbQb/QJB9GJtqyprYk/QP4I+A+3g5KqZuUUllKqaz8fJlnQgjRPny9+QOmHvyUrSEhTdo/PqoLXw97hAt1OLgcfo5OHBHmcpEenoxqQiJ7XMYQ3MpIba1c3SY8TvrTpJS6AMjTWq8+0X5a61e11kO11kMTEk49kxdCiGDy5f5vSDVF0KfzmCYfE5bQF9xO3CX7/BiZqO/Twz+wsLKFn7dSTDk4n0e3f+CboESb15SUezRwoVJqLzAHOEsp9Z5foxJCiCBQXJ7Dj+W7OTd5RLNaKNxRaVxx+L88u+Z5P0Yn6vswbxULyra1uJxIUyjF9jIfRCTag5P+1mut79Nap2mt04EZwGKt9dV+j0wIIQLsm82zcaI5r/elzTrOYLIQHmLjh8INfopMHKvYWUlMSGSLy4k12yh2VPggItEeyDxJQghxHF9nf0d6SDR9Ukc1+9hRiUPYXltAfonMwN0aipzVxFqiWlxOTEgkxY5KH0Qk2oNmJUla6++01hf4KxghhAgateX8PXooT/a/5ZQGA4/qejYAP+7+wteRiWPY7VVUagexlpgWlxVjiaLIVe2DqER7IC1JQgjRmLytRBlC6Nv9nFM6/LS0M4gxWFmR86OPAxPHOrKMSIx3WZGWGB0/kGsjTsPtrG1xWaLtMwU6ACGECEaPrXuOYaGpTA6PP6XjDQYjv0mbSFxtNWgNSvk4QnFEstnGyrTLMHSZ1OKyRicNY3RJATiq4ThL0IiOQ1qShBDiGEVl2XxY9DP7zC37P/Kq065gsiUZKmXuOL+yVxJmMGENbXl3m8tspcBVTU1NScvjEm2eJElCCHGM1Xu/AWBEl/EtKyimGwedFWzf/33LgxLHtTZvLU8Wr6ZUu1pc1oaKA0w4+AmrDq30QWSirZMkSQghjvHToR8JVSb6dT6zZQVZI/ltwfc8s/Ud3wQmGrW2YCPvlm/DZIlocVmx4d5Fbr1rwYmOTZIkIYQ4xk/FWxlk64zZZG1xWWfEDSCrYh+1drms3F9yq3KxKTPhobEtLismvBMAxdWFLS5LtH2SJAkhRD2OmjJiMTE6cYhPyhuVNpZa7WLNnq98Up5oKK+mkESzzSdl2UJjMWOgqKbIJ+WJtk2SJCGEqMdcfojXkyZybf/rfVLe0G7nYsLAigNLfFKeaCi3tpgkS7RPylIGAzGmUIrtJT4pT7RtMgWAEELU4yrei9FogshOPikvLDSaQeGprChc75PyREPVrlq6h6f6rLxbEkaSEpbks/JE2yVJkhBC1HPl2icZZOvCfQajz8q8//Tric5ZD7UVYPFNt5Dwcrv5JGUKri4jfVbkpUkjQSaTFEh3mxBC1CmtOMyWmjxibb5pRTqiZ9po4o2hULLPp+UKwF4BWmO0tHxx2yOKcbOj4oDPyhNtlyRJQgjhlbXnazQwLK2Fl/4fy5bEJ9X7eW/ze74tV7AzfwN3Fyxjl73UZ2W+mrucmfs+9ll5ou2SJEkIIbyyDv2IVRnp33msbws2GFjuLOHNg4vRbrdvy+7g9hTv4L9V+3GYQnxWZqwlhkrtkGkbhCRJQghxRFbxFgaGpxESEubzskckDyPPVcXevJ99XnZHlld5CIDEqHSflRnjnW+puOKgz8oUbZMkSUIIAWh7FdNCu3Bp55YvktqYoV0mAJC1/39+Kb+jyq08jBkDMbYUn5UZE5oAQFFFrs/KFG2TJElCCAGosoNcHdGHyb2n+6X89MSBxBlDycpd7ZfyO6rc6gISzTaUwXdfZ7FhniSpuFKSpI5OkiQhhAC2HVxBgXZAhG+vbDtCGQyMiOpFTW0ZaO2XOjoii9b0sib6tMxusX14LHYkPUN9W65oe2SeJCGEAB7Y+jY2o5U3jP77s/jE4N+jdnwN1cUQ1vJ1xgQ8mjgWIn3X1QYQbUvmIlt3MLZ87T7RtklLkhCiwyurzGdrTR7D4gf4tR4Vk+55UCpz8PiE1lBbDpYI35ZrsrLBXsTukt2+LVe0OZIkCSE6vLV7v0EDQ1NH+7eisDj+ULSCx9Y97996OojSisNcnfM5S8t8nMwoxZ35S3nzwJe+LVe0OZIkCSE6vJ9yVhCCgYyuZ/m3IqVwm6wsK9ri33o6iMMle/jZXkCND5eQOaKTJZqc6gKflyvaFkmShBAd3k9FmxkQnoolJNzvdQ1NHEyOs5ycgq1+r6u9yy3bD0BSZGefl50Wmkh2TZHPyxVtiyRJQoiOzVHD32NH8MfeV7ZKdUO7jAcga9+3rVJfe5ZbmQNAkg8nkjwiNTyFw84KHI4an5ct2g5JkoQQHVvpAbqYbJze2cfrtR1Hr5ThRBksZOVmtUp97Vlu5WEMKOIju/i87LSIzrjRHCre7vOyRdshUwAIITq0hdvmQfV+pkamtkp9BoORq5JGEi9LuLVYtDIyPLQTJh+u23bEGalj+Hf+TuLla7JDk7MvhOjQ3jjwJQkhUUz14/xIx7ql7zWw81uoKQNrZKvV295cHTOQqyP6+KXsxJjuJFqTQbrbOjTpbhNCdFgFJfvYWVvEiITBrVtxdBfK3HbyDq9r3XrbG3/MkXRESATf1eRIt2gHd9J/nZRSnYF3gGTADbyqtX7O34EJIVpAa6gu5ott/2Hl4VX8XLoLszLSJ6IzoxKGMKXnhWBLAnPHnlF45R7PPDgju/j50v9juMPimZKzkLPt+3k4fWyr1t2eTN/5Dhd1Gsu1XOL7wg0Gni5ZRy9HPkMzb/J9+aJNaEr7shP4g9Z6jVIqAlitlPpaa73Zz7EJIZrpcNFOFq79Fzdau4K9kjm5X7PDUcpAWxfc2s3Sok04KguZUlGBW2serdjEJRk3MCC9dZOEYLHy0I9EGEI4LfWMVq3XYDQx0NaF1SUyKPhUVVWXsNNRgtOP3aSpljgOylxJHdpJf7q01oeAQ97H5UqpLUAqIEmSEEHC6bQze9XfeXHnPIxKcV3mnzFFp/NsxqVEx3THUG+yvdqqQqgu4WDeBpasns9HS+7gwk2Z3Dn6YRKiuwXwXbQyrcmrzGVEZA+MJnOrVz80YSBLd80jv2RPx/rcfSS3dA8ASeG+XbetvrSwJDbkyxIyHVmzxiQppdKBwcBKv0QjhGi2DXsXc+VH5/HkjjlkRqTz4eR3MfW7GFIziY3rdVSCBGAJi4O4HnTuexGLLvmS69PO5ouCdVyw4GJe//4hHPbqAL2TVlZdzMvxZ/Lk4D8EpPqhaZ4pB1bvlfmSTkVu6T4AkiL8d1Vimi2VMredssp8v9UhgluTkySllA34CLhTa13WyPablFJZSqms/Hz5gRLC79wuyrYs4NdL/0Cho4KnB93FP6d9RFpCvyYXER4ay+8nPsv8895leGQPPt7/FXrNW1BT6r+4g0WJ50vWHNczINX3TRtDmDKRdXhVQOpv63IrDgKQFNXVb3Wkecs+WLTNb3WI4NakzlyllBlPgvS+1vrjxvbRWr8KvAowdOhQ7bMIhRANOO1VmLYsILJoD8/1/TX9+8/AFhp3yuV1SczghYvmUXpoHSE7F1Ob9QY5PcbSLWWID6MOLg+vfQ5lr+ShsNiA1G8yhfDX9Ol0Ux178PypilVmxlk7keCH2baPGJE6hoWHtpJqjvZbHSK4nbQlSSmlgNeBLVrrZ/wfkhDiREorDjNr/nT+s/9rOG0KI4f9rkUJUn1RKYNg8EyeKljJVd/cxE87Fvmk3GDjdrtYXLQJuzkUlApYHGd1nUQ3pwtqKwIWQ1t1pq0rL6ZOJtTiv3mmIiJSSTdHYrbL+emomtLdNhqYCZyllFrnvU3xc1xCiEbklexm1qIZbK4+TGz6OEgZ6PtKbAlcf+YjJJjC+c0P9/PVz2/6vo4A23FwJcXuGkakjAhoHM7oLnxeuZesnZ8FNI62SNeU+W+OpCPMVj6u3s9/Dy71bz0iaJ00SdJaL9NaK611htZ6kPf2eWsEJ4T4xf689Vzz2dXk2Ev556hHmTjgGr/VlRLXh3emfkj/sBTuXvcMH6z4m9/qCoQf93sGS4/oNjmgcRgjUni69Gfe3/lRQONoi67a+ir3HVrs93o+LN/Bx4eW+70eEZxkWRJxXIVlB9hxaDU7CjeRX5XHgIiuTIofBMCzexdiNVrpGduH3kmZdE7o1+AqKuE7xUW7uOarX+PSbl4f9wz9u07we51RtmRevfA//PGL63hxx1zOTRlJXPo4v9fbGlbmrSE9JJqk2B4BjUMZDIyLHcBn+VnY7VWEhIQFNJ625KC9lN4Rvl/Y9lipofFsq8j2ez0iOEmSJOpUlhwgvHgvuuQAUza/SLazvG5bCAYujujFpBoXAO9lL8aBG73PM2YlVJn4bdJoZnWbCvG9cEam+WXRyQ6ptpyYbf/ld7FDyBx8Az1ShrZa1VZLBE9f8B45a94kbu8KCE+BhN6tVr9fuF0MMkYwIuW0QEcCwPguE/lP3o/8tOtzRve9NNDhtAkORw1FrmqSQhP8XldaeAqLi7fgcjoCMp+WCCxJkjq4A3kb+HLrXL7MWU6IdjM75TyULYlpySMJD42jZ9zp9EoeQnzU0f+xrR53DzW15ew6vIbt+T+zvWgrPSyJcHgDO/Ys5tf5izknfgjn9bqIQd0mSSvTKaqoLuRg1r/po038asyDEOm/ifOOx2yy0jXzBvS6D3hzxeNknH45Q3u24WGJZTncFNEX+l0c6EgAGN7zfKyrn+C7fd9IktREeXUTSSb7va60iM44cZNXupuUOP8spiuClyRJHZHW/LT9U15Y/zJrqzxzjQwM68R5aePRg3+LskZycxOKsVoi6Nd1HP261uuCcTlh3/8YWruPT/J+ZE7uclJ+tHFV1/O4bOgdhFqj/POe2iG7o5o7P5/F5qocvpz0BpEBSJDqmEKo7nsB83e8wWsrHuCt0Fh6p44MXDwtkHN4DXG4sUT7v6umKayWCEZG9mRP+V7PmnsBvNqurcjzTiSZaPPfRJJHpHqnGDhUvEuSpA5IkqQOxO124crbgjl7FdmHfiDXXspdPS5lct8ZvvvlN5ro1X0ST3efRGV1Ef/b8iGf7FnEv3Z/wkUuC6HpZ6JTBqNCQn1TXzvldrv485c3sLJiL4/3v5nIZD9cxdZMYeHxvHLOv7n6y2u5+X938O7kt0iN7xvosJrtvo0v43K7eM98f6BDqfO3IXcTtvN/UJkPtsRAhxP0IjFyma0n3WL932U6LHU0K9MuIyzc/wmZCD7NWpZEtE1ut4vP1r7C9LkTmLvy7+BycEHmb1l0+f+4bsxDfvvvKDw0lgsyb+b1Sxbx6TlvEhXTDb3rO278ZBov/u+PlFfKwpHH8/S3d/JF0Qbu6DadC4f8LtDh1EmJ68PL45+nRju5+eubKCk/FOiQmqWqppT1lTlkxp4e6FCOEpbonSW9YEdgA2kjeoRE8UDscFJje/m9LnNYPGFGc8eYhV40IElSO7dp3xKu+WgK965/EaMy0Ln72TDsRsypmZhNrTfTb1LyIMi4jMqBl2GzRvHK/i+44JPz+CTredxuV6vF0RZ8s+Zl3sn5jiuSR3PDmIcDHU4DvVKH8+IZj5PrqOCn1f/0dLG2ET/uXIgTNyM7jw10KEezRPCvmj3cvPqJQEfSJlRW5uEyGMBk8X9lBiOvV+7ivT0y801HJElSe2Wv5LXFf+SK727lQG0Rj/W7iXmXfcu4ATPBELjTbovryT+m/Yc541+ksyWWBzf9m5nzzuNw7vqAxRRUCnYyrrSIBzqfz58mvoAK4Lk6kcwek/li/EtM0mGw/UvPWJo2YNHuRcQarQzrEXwDz1VYPMsr9lJQuj/QoQS9B7e/x/Scz1pt/NaKmkN8Wbi2VeoSwSU4/wKLU+ZyOqjdtwJWvsJgu4uZncazaPoXXDT0tqC6wqxf13G8c8nnPN7/ZkzaTezmhbD1c3RtZaBDC5hdOaso2DAbc0Qyl419NOgvN47rcgakj2Hpni95e/mjgQ7npMorC1hSvIXJCUNbtRW1qcZ3Px+A73fMD2wgbUBebTEJIf5bjuRYqaGJZNcWt1p9InhIktSO7D60mms+Pp9nsp6CiBSGnHkf90x6gYjw+ECH1iiDwciFQ37HWxcvIqTzCKpy1nDVJ1P5789voN3uQIfXqvJL9nDz/+7grryl6H6XQFuZYyp9DF+6S3lq1zz++/MbgY7mhGwlB3gnaRJXZ/w60KE0qk/qKJJNNr7L/j7QoQS9XHsZSZbWW5g4zdaJQlc11bVlrVanCA6SJLUDDmcNry19gEu/up59tUUM6DYJBs6AIE2OjqXMVuh5NiX9puFWBu5e9yx3LZxBQcm+QIfWKqpry7j9q5soddVw3xkPoULb0DQJSvHQOS8zKKwT9//8PBv2+n+ZiFOl8jbTL6YXnZMzAx1Ko5TBwLi4Aawo20mtveO2qJ6M2+0i31lJYmjr/X1Li+wKwMHCra1WpwgOkiS1cbsPruKqj87nuT3zGR99GvMv/JgLMm9uk3OtdEoawHuXfM7vu1/C0pJtTFt4MQvX/LNdtyq53S7u//JGNlUf5m9D7qZv5zGBDqnZLCHhPHfu68Sbwrlt2b3kFATfF8mhgm08tOs/ZEcmB/XvxnndL+BXtp7UFMpVbsdTVJaNE01SWFKr1Zka3YNog4Xi8pxWq1MEB5knqa1yu2D/Ckw7vqTMWc0zg//ApIxZgY6qxUymEK4/82HG97yQB5fdx8fbP+J8YzzqtPP8v+J3ALzz/UN8XbKZu3texoR+VwU6nFMWG5nGSxOeY+Y3v2HByqe4+ZwXwBw8c2F9tvk9Pq7cxY3xPQMdygkN6TGFIYe3Q3kuBHDu0GBmdtZwe9RAMhMH+6X8ylonu/Mr2V1QQWGFncpaJzVVUTxSMYZlK6p4K2sNGo3W4Na6rVyz0GaZTQZeujJwrb+SJLVBuw5l8dmaf3FbaA+6dBrKojP/iMnaeoMYW0P3lEzenr6I8v3fYziwmvwVz7M6OpnJg24IdGi+c+AnLnKYMKZfyNWjgmdiw1PVI2Uo8856mZQdi2HDPBh4BRgD/ydGu90sPLiEzLA00hL6BTqcEzOacER3Zv2B78nsOSlor24MpCgM3BjVDxIGtLisshoHP+4q5MfdRWzLLWN3fiWHSmsa7BdiVFhDasg257DV0gmlFAYFChXMDZPtgsUc2AuOAv8XTDSZy+ngvR//yvO7PiLcEMJlY2eR3PXMdnsSjSYz0d3PgqSBvPvd3by5bw7f7P+G+yc8TUxEp0CH1yJrtn5M/5zNRCcPYObp0wM6LYMvdUodBmYbu9e9zdz/3swfz/lXwK/S25K9nN32Yh7oPi2gcTTVZ/Y8Hsj+lNkHJtK/64RAhxN0CsuzcTgrSQqx0dz8pNbpYvW+YpbvLGD5zkLWZ5fg1mA1G+iTHMmoHnH0SLDRIyGc7gk2EmwWwi0mQkwGnl30ISnG7Tx93t1+eV8iOLXX79d250DeBv689I+sqcxmQlQfHpzwTINFZ9ut8DhuP/cVIn54lH/uWUjWpxfx0OA72mz31I/b5nPLykeYmTCUu/re224SpDqJfVkZEc0H2z+Db2/n3kkvBbRFZNHWuZgxcG7/qwMWQ3Oc1XcGT2x+k7d+fpWnJElq4JXtc/k490dWhTxy0iRJa83ewiqWbs9nyfZ8VuwqpNrhwmhQDOocza1n9WJ0jzgGd4khxHTin9E9zgoOVOQjKVLHIklSsNMa5/6V3Ljs95S57Tze/2amDr6lwzXDm0wh3Dj2L4ztNoX/W34/t2c9wQP5W7hs9P1BNfblZLYcWMadKx8l3RLDr8c9ERTdUf5wxah7ya44yDs535H8w2NcN+ahwATidhNRW86F8YOICm+9gb4tERmewIzUcbyR/Q17c38mPSnw6/YFC7fbxbf5axkd2avBvG9aa/LLa9l0qIzNOWVsPlTG+uwSDhRVA9A1LoxfDU1jbK8ERvaIw2Zp3u9eWngyP5btQrvdHe7vb0fWPv9CtxPZ+ZtI3p+FqSyHx7tdQuppF5EcG9wDT/2tT+czmHPJF7z9w2Oc4wyBVf+mqvs4wlKC/4skO38Ttyy5iwijhX+d8xqR4QmBDsmv/jDxH+Qtuppnds0j2hrD9KG3t34QxXu4xXYa9L+49etuAq01VXYXlbVOKmqdVNldVNQ66RF7Debsxfztu79xbu+/43C5cbo1bq1xa8B7r7WmvYwbPt4AaM971rjcUFy6lDxXFaH2wdz/yQZKqhwUV9kprnKQV1ZDYaW97ri0mFD6dYrkxjO7M7ZXAunx4S2KL83WmWrtpLA8u+O04gtJkoKRy+ng/ZV/44Vd8/hdzGBmDbuLIUn9g/rS5dZkNlv59bjHoTwX55YFXPfd7XS1pXHf+L8H7VglXVHAH769DYd28frEf3aIZNdgMPL45NcpW3QFi3YuYFryGRjShrZqDHv2fkdXkwVDbI9WrRfA6XJzqLSGA0VVZBdXc6C4ipySGgoraymssFNYUUtBpR27s/EpLron92B9+A6WfbiEct2G5s7yo+7JCzBGGfhkXU/CQw8THWYmJiyE1GgrGalR9EmO4PROkfRNiSQq1Ldj4dKi0gHILtomSVIHIklSkNm0bwl/WfkXNlYfZlxkL6ac+QBEdw90WMEpIgmdOZMJ1Xt4Ze9nrPx0Gneddi0XZv42uJrDy3NR6+fwcOJoVK/J9Ehp3UQhkEJCwnj+gg9wbZqPYcfXONxOzF1GtkrdVdUlXL7pRWYkj+EuP3ZrFlfa2Zlfwa68CnblV7Arv5Jd+RVkF1fjcv/SPGJQkBRpJd5mIc4WQu+kCOJtIcSEh2CzmAi3GAkPMRFuMREWYsRd25O0bXNwDwrH2WMCJqPCqBQoMCiFgrqrrNoL1dgoIwVGg0JpFxfMe5QJEafxzOO/QrXyP41dYvtwmjkGR01Jq9YrAkuSpGDhqOHt5Y/xzL6FxBitPJFxK1MG3hhcX/ZByGyycvO4/8eEnlN57IeH+fOmV/h472c8Ne5ZEhJOC3R4rN31JT9tms1NCcPpO/L3ENZ6SykEC0tIOAycQdWGudz8w/8xcf94rh3zoN/rnbfmRaq1k/E9zm9xWW63Jqe0mr0FVezKr2BHXjk7civYmVdxVBePxWSgW3w4/VOjmJrRic6xoXSOCaNzbBjJUVbMxub8PseAaxi1h9bjCBmJzdY2xlT5TfFBZidNorrHhFZPkADSE/rzn5TzIDQ4W6uFf0iSFGDa7caRu56Q3UsZWFPDZUlncNuZj7X78Sq+1id1FO9c8jnzV7/Ap7sXEbXxY+g8At11DMpsCUhMy7fM486f/kKyOYIrJ/wVWwdMkOoYjJj7XUzivoU8tes/2N12bhz7F79Vty93PS/smseYyJ4M7nbOSfd3uNzkl9dyqLSGw6U1HC6r4VBJNfuKqthbUMm+oqqjusUirSZ6JUUw6fQkeiba6JFoo2eCjdToUAw+bNqp6jSQqVkPc4H7ML+f+A+fldsm5W0h2RIFXc4MTP1GE1hsIC1JHYrSfpgudOjQoTorK8vn5bY3a3Z9yXNrnqO3IZT7u06F3pMhUqbZbSldW4nas4TKg1ncVLCE6d3O56LMWzG14qKxi9a8zAMb/kVPaxwvn/c2cZGdW63uQHK43NQ4XNQ63Z6bw0WNw+0deOym2m7n/XV3sqxqE5Nsw5nQ488ogwWXW+Ny1xuMrEFz5Dl1MxzX/bXyDljW3v0B3N4ZkB1OO18c+C257hIujn8KtzGFWoebWqeLWoebaoeL0moHpdUOSqoclFU7KK91NngvFpOBLrFhpMeH0817S48Lp0dCOAkRllZrzfjjwitZWryV/17yRZu5Qs/XnE47//fpr7gsdQJDR94ZsDie/OwGssp38870BVjb4QoAHZlSarXWusFYCGlJCoBt2St4/qe/s7RsB/HGUKb2ngGZ17a/+XICRFnC4bQpFEbEw/JlPLLlTd7a+TG/O/1azs24vsGlwz5lr+KRr3/HvIIsMsPSeGHKO22iVVBrTUWtk5IqT+JwJIk4ciurcVBR47kCq7zGSUWtw3M1Vq2LKruLKrvnyiyn++T/dCmuoFvSO3zNKjYvvZmcnBsoo2VXHtWXYV5DYZcyLAVj+dfWakJMe7GYDFjNRqxmA1aTkahQM8mRVvokRRAZaiY6zExSpJXkSCvJUVZSoqxEhZoD0q1zrBsyb+OLb27ig5/+wS3j/xrocALip12f8UXFbs4JD+xVihN6T+fdH+7jrR//ys3j/l9AYxGtQ1qSWlNVEXNXPc3j+xZgM4RwQ/oFXDnsLkKtcuWKv2i3m++2zOb5Df9mZ20hfSzxvD72GaJSBvn8akGdtw2140sWlmzhkC2O60c/1KqtV3VxaE1ZjZPiSrv38mg7RZUOiivtFFXZKamyU1Rpp7jSUfe8pMpxwgTHZFBEWE3YrCZsFjMR3oHGYRYT4SFGwkJMhIYYCTMbsZqNWLzJiMVsIMRoIMRkwGw0YDIqQowGTEYDP++dTb/ifXQNiaay+7kQ29szIFl5Tk3dY47cA+qXwb1HXlN1g5jBWFOIZd3b1EZ3wTLgMkxGo0+7vwLltvmXsLZ8H19d+g1hodGBDqfVPfzFDXyRv4Ylly8NeAvOHxbMYGnJVhZe8CHJsb0DGovwneO1JEmS5Gdut4sV2z8hvuQQfWoqOeCq4iPKuW7kvR226TwQXE4HX6x/nRX7vuEvUZmo8Di+t5gY0GMK0REt6+IsrTjME9/dwyC3mctTRkPfqWBLPOXytNbUOt11c+eUe1twKmqcda06dS081U5PklPtmS+mtMpBSbXjqKuq6jMbFTFhIZ5buOfy6eiwEGLCPK0p0WEhRIeaiQo1ExXmvQ81E2o2+qdVpaoIvekT7ts7n4Tobtw+4UnMJuspFeV02nn3mzu5PKwbYSNu8YwfaSfW7/mWq5beyZPpl3DemPvBGNilXlqTw1nDhNljGB3dh79NfT/Q4XCwYAvTPr+Cs2L68WQQxCN8Q7rbWllVdQkLfn6VD/YsYo+9mIsievPY4Dvp3Gkwd7ajP96B4HZr7C7PmBeHy43d6bk5XG4cLo3T7b13uXG5NU7veBeLdTpn9pzK9yU7MB3K4o7Sd+Hn5xlqOY2MuAuJjxwFyoTml9W9j0zW53b/MgbGrTUul4OC0u/YUf4tG53bceKmOmQ8OUWjcC4vwuUuwuWNw+Fy4/Te273xesbseMbuVNtdVDs83VZHHh8vyanPZjHVJTEx4Wb6Jkd6Ex1P8hMb7rm8PLZeUmSzmIKiC6lOWCyuQVdhK1zJWzn/Y+l/zuGWvtdwTsZ1ze4WfX35I7yY+z1dM0dyVjv7HcvoNpG3Ku4js2AfrP8Q+l8C5lNLJtualTsWUuquZXK3KYEOBYDU+L7M6nwObx34itxDa0lKGRzokIQfSUuSLzmqoXAnf13zDz4qWE2tdtE/NJmrel7COf2vISQkLNARtqoah6uuBaSi9pfWkEq7s248S6V3LEtlrZNquzdRcHhv3sc13sG/Rwbe2l2NT77XXLGWHUTHLKEkcg8Oowuzy0jfwwNxV/QjhwhylQ23NmM2VGNUNZgN1VgdEXSngNLkb9kTlYvZZSS6vDOlRRMorO0DeOZ0MSqF0aAwG1VdN5PZ6OlyspgMWMxGz73JgMVkJCzEcwsNOfLYhM3ivVlNRHjvo0LNRFrNRFhNmJp1OXnwW7zxPZ7f8G922YvoaYnliaH30afHuSftFnW7XXy3eTZ/WP13JsX248mpH7RSxAGQu4kdP7/H38p+5olJL3eISQ2XrHiK1/Z9wWsXL/BMJxEEqmpKKV75T1LDkyBzlownbQda1N2mlJoMPAcYgde01k+caP+OkiQ5HDVsz1nJupwVZOVm8feoIZiANyp3cdhs4vzelzKw29mBDrPZjnT3lFU7KKtxUl7joLzG6b056u7LapyU1Xt+ZJ8jyVBTkxmr2UD4kTEtIUZCzZ5kIdQ7viXUbKxLKqxHkot6Y12O3JuMBkKMCpPhl6TkSKJiNBjqEhfPzTOWxagUtfZSsvZ8xObidVxi7UEvl+bb6r08UPpjg1g/iD+XXpZY1lss5IZHcWbvS7FaIuoSo/Yw/iWQXE4HX218i3e2zeGfcWOIierM+vAoQiI60SNlyNFdcfZKduz8ktvXPUO2o4xUcyRzps5rcfdpsFux9WPuWPUYCaZwXpn0CmkJ/QIdkv+4XbD8OYjv5enGDia5m9CbPiUvfSRJ3c8KdDSihU45SVJKGYHtwCQgG/gJuEJrvfl4x7S3JMnldJBftodItyLMWcOKA0t5cc+nbK3OxY4nEehijuLlgXfQufNoiEhp1SVEjiQ1NfVaYI60zlTZva01tZ5WncpaJxV27329q5XK67X2lNc4cLhO9nPh6e450qpx5N5mNXnuLZ7nEVYT4SG/tIaEe29HZhgOCzFhDLbEwmln76Esluz7Bg2EmcMINYcRag5neOJgImN6QgdrFWx1bjfkb4G9y7l2zxzW1OYTgoHTQpM4PbI7Z0Z2Z6wDqp213F26mgu6n8/Z/WZi7iBdUOv2fM3vlt2LRZm4tc8VjE4/h6S409pdi8ahAyuI3v4NoQOvgPggW8pHa5794kbmF/3MoulfEBEeH+iIRAu0JEkaBTystT7X+/w+AK31ca9F9XeStHTlMn7I/77B66nmVDqFdKLWXcvPVeu9r2qOLAHZ1dKFZHMyVc5K1lWvxa1ddTendpBh7k4XYyy59kN8UrWUKncNxe4yinQVLjR/NA4jUyWyiRLm6J10DkknJawv8bZMwqzdQBk8Y1nwJC5u77wvRxZodGvq5oNxuj3bnW7P2Bmnu97YFbfn3u78ZQyL3emm1uWZd6Zu/hlvYlTjcNGEISx1LCaDN0n5pTsn0up5HGE11yU6EVYzkUc9PjrxkVYT4XdacyB/IxtzfmRj/no2le5ic9UheoREMzvzPug0GGzBP8WCP+zMWcWt/7uTg85y/h43mslRvdhtNrOgcg+JYckYDQYMyohRGZiQOIwYSyR7Kw+xoXRng7ImJA7BZgpjZ0U2W8r2NNg+KWkEVmMIW8v2sqPiQIPt5yWfgclgZFPpbnZXHmywfWonzwSQ60q2c6Aq96htJmXkvJQzAPjiwHdkFaxnX9Vh9tcUcMhZQbIxnP9e8T2GIBysvmnfEq747lbOjOzFwNi+WIwWLuw0lhhrNLurDrOpbHeDYyYmDiPMZGVb+X62l+9rsP3c5JGEGMxsLtvDrorsBtvPTxmNQRlYX7KTfVWHjtpmwMD5nUYDsKZ4Kwer84/abjaYmZzsWRbop6LNHK4pPGp7mNHKxKRhAPxQsIFCe8lR2yNN4YxLzARgaf5aSh0VR22PMUcyJsGz2Pj/8lZT4aw6anuCJYaRcf0B+PrwKmrctUdtT7HGMzS2LwBfHlqBQzsZkzCYmM6jGnwOvtaSgdupQP3fimxgRCMV3ATcBNCli3/7yVctnc/7if9t8HpmYScGF3WiwmRnbrf1DbaPyO9M/5IkikOq+bjrpgbbi3LTSS9NJT+klt3J+RjdZozOWGId6bgdMbxS0ZsqRzIl2HBjYE3dkVVAw/JO5kjXj8l7OzJ2xWQwYDYqT1dSve6kSLMJa4SlrsvJav5lPIvVfHRXVViI99Js7yXaoSHGusSoeUsjCBFAStE5cQCdEwdwnvcll9Ph+ccnANMrBJOenYbz+RXfsy9vPfEOO1SXsO3AYt7O/hYnR//X1LfoIDEhsawq38FjxT81KGtRygXYzJF8X7aZZ0rWNdg+qugwVmMo35Ss55WyjQ22TywuxGQwsah4Ne+VbztqmwKmlpYCML9wJR9V7jpqu02ZOa+kCIAlBT+wrOYQXS2xZEb2oGtEGqO6nBWUCRJAv67juD7tbN7I/oalZTsAOLOqihhzFD+UbeVvJWsaHPN1pxzCTOF8V7qRF0sbfk+NLc4nxBDCl8VrebN8S4Pt55UUY1AGFhT9xNyKHUdtsygj55cWA/Cfgh9YVLX3qO2xBguTiwsAeC9/KYurj07C0kw2JhZ5ktg3cr9lZe3RCW1vczTjUjwD6F8+/F822I9OsgZbEhiTNAmAf+QsYrez7Kjto60pjEycAMDfDs4n13V0EnVOWBeGxo8B4NED/6FcO/ig05RWSZKOpyktSb8CztVa/9r7fCYwXGt92/GO8XdLUvbhHHLKG2bYNnMEEeZIXG4XeTV5da8r78QrNlME4eZwnG4XpY4yjAYzRqMZg8GMyRBCiDGswVppx+s1O/J6/Tla6i86qRSeMSpKoQz1HiswGw0YFMF1lZEQol2w26uorC3B5XbidjtwuZ3EW2IwG0yUOyooqS1tcExyWCJmg5kyezml9rIG21PCkjAZTJTayyizlzfYnhqegkEZKK4tocJR2WB7Z1sqAIU1xVQd07qglIG0cM84MofBhNkaeUrvO5C0243TZafWWUmoMmNEU1ZTcpLPspyyRrZ3Ck/GqIyU1JZSfkxLDUBaeCeUUhTVllDZ4LNWdLZ51pYrqCmi2ll91FaDMpDq/awLagqpdtYctd2ojHQKTwYgr7qAWtfRLT1mg5nkMM/0Joer8nC4HUdtDzGGkBTqadk9VJWL0330TPYWo4XEUE+35MHKQ7j10eNWQ01W4q1xAGRXHkJrN4lhCVhsyQ0+B19rV91tQgghhBC+crwkqSn9Lj8BvZRS3ZRSIcAMYIGvAxRCCCGECCYnHZOktXYqpW4F/otnCoA3tNbNH4AjhBBCCNGGNGnGba3158Dnfo5FCCGEECJoyGVOQgghhBCNkCRJCCGEEKIRflm7TSmVDzScJcu34oECP9chmkfOSXCS8xJ85JwEJzkvwae1zklXrXWDmWn9kiS1BqVUVmOX64nAkXMSnOS8BB85J8FJzkvwCfQ5ke42IYQQQohGSJIkhBBCCNGItpwkvRroAEQDck6Ck5yX4CPnJDjJeQk+AT0nbXZMkhBCCCGEP7XlliQhhBBCCL8J+iRJKTVZKbVNKbVTKXVvI9uVUup57/b1SqnMQMTZkTThnFzlPRfrlVI/KKUGBiLOjuRk56TefsOUUi6l1KWtGV9H1ZTzopQar5Rap5TapJRa0toxdjRN+PsVpZRaqJT62XtOrgtEnB2JUuoNpVSeUmrjcbYH7nteax20Nzxrxe0CugMhwM/A6cfsMwX4AlDASGBloONuz7cmnpMzgBjv4/PknAT+nNTbbzGeJYYuDXTc7f3WxN+VaGAz0MX7PDHQcbfnWxPPyf8Bf/M+TgCKgJBAx96eb8BYIBPYeJztAfueD/aWpOHATq31bq21HZgDTDtmn2nAO9rjRyBaKZXS2oF2ICc9J1rrH7TWxd6nPwJprRxjR9OU3xOA24CPgLzWDK4Da8p5uRL4WGu9H0BrLefGv5pyTjQQoZRSgA1PkuRs3TA7Fq31Ujyf8/EE7Hs+2JOkVOBAvefZ3teau4/wneZ+3jfg+Q9A+M9Jz4lSKhWYDrzcinF1dE35XekNxCilvlNKrVZKXdNq0XVMTTknLwJ9gRxgA3CH1trdOuGJ4wjY97ypNSppAdXIa8dejteUfYTvNPnzVkpNwJMkjfFrRKIp5+QfwJ+01i7PP8iiFTTlvJiAIcBEIBRYoZT6UWu93d/BdVBNOSfnAuuAs4AewNdKqe+11mV+jk0cX8C+54M9ScoGOtd7noYnu2/uPsJ3mvR5K6UygNeA87TWha0UW0fVlHMyFJjjTZDigSlKKafWen6rRNgxNfXvV4HWuhKoVEotBQYCkiT5R1POyXXAE9ozGGanUmoPcBqwqnVCFI0I2Pd8sHe3/QT0Ukp1U0qFADOABcfsswC4xjv6fSRQqrU+1NqBdiAnPSdKqS7Ax8BM+Y+4VZz0nGitu2mt07XW6cA84LeSIPldU/5+fQqcqZQyKaXCgBHAllaOsyNpyjnZj6dlD6VUEtAH2N2qUYpjBex7PqhbkrTWTqXUrcB/8VyV8IbWepNS6mbv9pfxXKkzBdgJVOH5L0D4SRPPyYNAHPBPb8uFU8uikX7TxHMiWllTzovWeotS6ktgPeAGXtNaN3oZtGi5Jv6uPAa8pZTagKeb509a69ZYhb7DUkrNBsYD8UqpbOAhwAyB/56XGbeFEEIIIRoR7N1tQgghhBABIUmSEEIIIUQjJEkSQgghhGiEJElCCCGEEI2QJEkIIYQQohGSJAkhhBBCNEKSJCGEEEKIRkiSJIQQQgjRiP8PPF1w0dx2TPgAAAAASUVORK5CYII=\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" - } - ], + "outputs": [], "source": [ "plot_transformer_density(\n", " make_transformer(d_in=1, d_out=1, d_hidden=40, n_components=4, periodic=False, zero_boundary_left=True, zero_boundary_right=False),\n", @@ -325,29 +299,9 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "torch.Size([100, 1, 1]) torch.Size([100, 1])\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plot_transformer_density(\n", " make_constrained_transformer(\n", @@ -360,29 +314,9 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "torch.Size([100, 1, 1]) torch.Size([100, 1])\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plot_transformer_density(\n", " make_constrained_transformer(\n", @@ -395,29 +329,9 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "torch.Size([100, 1, 2]) torch.Size([100, 1])\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plot_transformer_density(\n", " make_constrained_transformer(\n", @@ -439,255 +353,31 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from functools import partial\n", "\n", - "flow = make_coupling_flow(partial(make_transformer, d_in=1, d_out=1, d_hidden=200, n_components=20))" + "flow = make_coupling_flow(partial(make_transformer, d_in=1, d_out=1, d_hidden=200, n_components=20, periodic=False))" ] }, { "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "True\n", - "True\n", - "True\n", - "True\n" - ] - } - ], - "source": [ - "for block in flow._blocks:\n", - " if isinstance(block, CouplingFlow):\n", - " block.transformer._root_finder._verbose=True\n", - " print(block.transformer._root_finder._verbose)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "it: 900/1000, nll: -1.761\r" - ] - } - ], - "source": [ - "train(flow)" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Computing energy plot...\n", - "Sampling ground truth...\n", - "Sampling model...\n", - "Starting bisection search with abs_tol=1e-05 and 100 iterations.\n", - "iteration: 0/100, error: 0.95456\n", - "iteration: 1/100, error: 0.9293\n", - "iteration: 2/100, error: 0.90683\n", - "iteration: 3/100, error: 0.8972\n", - "iteration: 4/100, error: 0.57549\n", - "iteration: 5/100, error: 0.39775\n", - "iteration: 6/100, error: 0.22548\n", - "iteration: 7/100, error: 0.11836\n", - "iteration: 8/100, error: 0.059673\n", - "iteration: 9/100, error: 0.029727\n", - "iteration: 10/100, error: 0.014701\n", - "iteration: 11/100, error: 0.0073451\n", - "iteration: 12/100, error: 0.0036977\n", - "iteration: 13/100, error: 0.0018435\n", - "iteration: 14/100, error: 0.00091162\n", - "iteration: 15/100, error: 0.00044754\n", - "iteration: 16/100, error: 0.00021845\n", - "iteration: 17/100, error: 0.00010628\n", - "iteration: 18/100, error: 4.7743e-05\n", - "iteration: 19/100, error: 1.8567e-05\n", - "iteration: 20/100, error: 9.9987e-06\n", - "Starting bisection search with abs_tol=1e-05 and 100 iterations.\n", - "iteration: 0/100, error: 0.73037\n", - "iteration: 1/100, error: 0.75983\n", - "iteration: 2/100, error: 0.57355\n", - "iteration: 3/100, error: 0.47781\n", - "iteration: 4/100, error: 0.25884\n", - "iteration: 5/100, error: 0.12872\n", - "iteration: 6/100, error: 0.064533\n", - "iteration: 7/100, error: 0.032572\n", - "iteration: 8/100, error: 0.016246\n", - "iteration: 9/100, error: 0.0080941\n", - "iteration: 10/100, error: 0.0040419\n", - "iteration: 11/100, error: 0.0020023\n", - "iteration: 12/100, error: 0.00099915\n", - "iteration: 13/100, error: 0.00049984\n", - "iteration: 14/100, error: 0.00024462\n", - "iteration: 15/100, error: 0.00011712\n", - "iteration: 16/100, error: 5.3406e-05\n", - "iteration: 17/100, error: 2.1935e-05\n", - "iteration: 18/100, error: 9.9987e-06\n", - "Starting bisection search with abs_tol=1e-05 and 100 iterations.\n", - "iteration: 0/100, error: 0.79407\n", - "iteration: 1/100, error: 0.5806\n", - "iteration: 2/100, error: 0.45161\n", - "iteration: 3/100, error: 0.34981\n", - "iteration: 4/100, error: 0.21019\n", - "iteration: 5/100, error: 0.11319\n", - "iteration: 6/100, error: 0.051066\n", - "iteration: 7/100, error: 0.024652\n", - "iteration: 8/100, error: 0.012184\n", - "iteration: 9/100, error: 0.0085212\n", - "iteration: 10/100, error: 0.0041946\n", - "iteration: 11/100, error: 0.0020293\n", - "iteration: 12/100, error: 0.0009461\n", - "iteration: 13/100, error: 0.0004456\n", - "iteration: 14/100, error: 0.00021285\n", - "iteration: 15/100, error: 9.65e-05\n", - "iteration: 16/100, error: 3.8326e-05\n", - "iteration: 17/100, error: 1.2398e-05\n", - "iteration: 18/100, error: 9.9987e-06\n", - "Starting bisection search with abs_tol=1e-05 and 100 iterations.\n", - "iteration: 0/100, error: 0.50732\n", - "iteration: 1/100, error: 0.35421\n", - "iteration: 2/100, error: 0.23326\n", - "iteration: 3/100, error: 0.15495\n", - "iteration: 4/100, error: 0.10143\n", - "iteration: 5/100, error: 0.053316\n", - "iteration: 6/100, error: 0.027018\n", - "iteration: 7/100, error: 0.013552\n", - "iteration: 8/100, error: 0.0068004\n", - "iteration: 9/100, error: 0.0034032\n", - "iteration: 10/100, error: 0.0016899\n", - "iteration: 11/100, error: 0.00084066\n", - "iteration: 12/100, error: 0.00041842\n", - "iteration: 13/100, error: 0.00020385\n", - "iteration: 14/100, error: 9.644e-05\n", - "iteration: 15/100, error: 4.3631e-05\n", - "iteration: 16/100, error: 1.6928e-05\n", - "iteration: 17/100, error: 9.9987e-06\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" - } - ], - "source": [ - "plot_evaluation(flow)" - ] - }, - { - "cell_type": "code", - "execution_count": 55, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "t = make_transformer(d_in=5, d_out=7, d_hidden=200, n_components=20)\n", - "\n", - "x = torch.zeros(100, 5)\n", - "y = torch.linspace(0, 1, 100).view(100, 1).repeat(1, 7)" - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2.69 ms ± 108 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" - ] - } - ], - "source": [ - "%timeit t(x, y)" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "metadata": {}, - "outputs": [], - "source": [ - "from nflows.transforms.splines import rational_quadratic_spline" + "train(flow)" ] }, { "cell_type": "code", - "execution_count": 57, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "ws = torch.randn(100, 7, 20)\n", - "hs = torch.randn(100, 7, 20)\n", - "ds = torch.randn(100, 7, 21)" - ] - }, - { - "cell_type": "code", - "execution_count": 58, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "731 µs ± 27.2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n" - ] - } - ], - "source": [ - "%timeit rational_quadratic_spline(y, ws, hs, ds)" + "plot_evaluation(flow)" ] } ], From 43a8465a9c7125d879302a6fe5d4be6be1effa21 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Wed, 12 May 2021 08:19:42 +0200 Subject: [PATCH 21/68] ... --- bgflow/distribution/distribution.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bgflow/distribution/distribution.py b/bgflow/distribution/distribution.py index e0817a9f..13c1a880 100644 --- a/bgflow/distribution/distribution.py +++ b/bgflow/distribution/distribution.py @@ -87,4 +87,4 @@ def _energy(self, x): if torch.any(x > self._delegate.base_dist.high): indices = torch.where(x > self._delegate.base_dist.high)[0] print("too high", x[indices], "at indices", indices) - return -self._delegate.log_prob(self._delegate.sample(sample_shape=x.shape))[:,None] + return -self._delegate.log_prob(self._delegate.sample(sample_shape=x.shape[:-1]))[:,None] From 5fa0cc4fe3272ddf169d80e2b6c1c7e6813848a7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jonas=20K=C3=B6hler?= Date: Wed, 12 May 2021 19:23:00 +0200 Subject: [PATCH 22/68] minor bug fixes; added trainable smooth ramp exponent; added moebius trafos --- bgflow/nn/flow/root_finding/approx_inverse.py | 2 +- bgflow/nn/flow/root_finding/bisection.py | 4 +- .../nn/flow/transformer/compact/__init__.py | 3 +- bgflow/nn/flow/transformer/compact/compact.py | 57 ++- notebooks/compact/compact.ipynb | 355 +++++++++++++++--- 5 files changed, 357 insertions(+), 64 deletions(-) diff --git a/bgflow/nn/flow/root_finding/approx_inverse.py b/bgflow/nn/flow/root_finding/approx_inverse.py index ec2f355e..11761676 100644 --- a/bgflow/nn/flow/root_finding/approx_inverse.py +++ b/bgflow/nn/flow/root_finding/approx_inverse.py @@ -163,7 +163,7 @@ def backward(ctx, grad_out_x, grad_out_dlogp): create_graph=True ) - return None, None, grad_in_y, *grad_in_params + return None, None, None, grad_in_y, *grad_in_params class WrapCDFTransformerWithInverse(Transformer): diff --git a/bgflow/nn/flow/root_finding/bisection.py b/bgflow/nn/flow/root_finding/bisection.py index 0e8b5a29..77dca6d9 100644 --- a/bgflow/nn/flow/root_finding/bisection.py +++ b/bgflow/nn/flow/root_finding/bisection.py @@ -1,3 +1,5 @@ +import warnings + import torch import numpy as np @@ -63,10 +65,10 @@ def find_interval(f, grid, threshold=1e-4, max_iters=100, verbose=False, raise_e print(f"starting grid search with max_iters={max_iters}, threshold={threshold:.4}") converged = False for it in range(max_iters): + (grid, (left, right, fleft, dfleft)) = filter_grid(f, grid) if torch.all(grid[-1] - grid[0] < threshold): converged=True break - (grid, (left, right, fleft, dfleft)) = filter_grid(f, grid) if verbose: print(f"it: {it}, interval: {(grid[-1] - grid[0]).abs().max().item():.4}, err: {fleft.abs().max().item():.4}") if not converged: diff --git a/bgflow/nn/flow/transformer/compact/__init__.py b/bgflow/nn/flow/transformer/compact/__init__.py index c569fba3..5a102f06 100644 --- a/bgflow/nn/flow/transformer/compact/__init__.py +++ b/bgflow/nn/flow/transformer/compact/__init__.py @@ -1 +1,2 @@ -from .compact import * \ No newline at end of file +from .compact import * +from .moebius import * \ No newline at end of file diff --git a/bgflow/nn/flow/transformer/compact/compact.py b/bgflow/nn/flow/transformer/compact/compact.py index b7820201..4f34dc5b 100644 --- a/bgflow/nn/flow/transformer/compact/compact.py +++ b/bgflow/nn/flow/transformer/compact/compact.py @@ -13,7 +13,8 @@ "AffineSigmoidComponents", "AffineSigmoidComponentInitGrid", "MixtureCDFTransformer", - "ConstrainedBoundaryCDFTransformer" + "ConstrainedBoundaryCDFTransformer", + "SmoothRampWithTrainableExponent" ] # TODO: docstrings and tests! @@ -83,6 +84,31 @@ def smooth_ramp_pow1(x, alpha, unimodal=True, eps=1e-8): return ramp, grad + +def smooth_ramp_pow_beta(x, alpha, beta, eps=1e-8): + + + xinv = x.clamp_min(eps).reciprocal() +# xinv = x.reciprocal() + arg = xinv.pow(beta).neg() + ramp = ((1 + arg) * alpha).exp() +# ramp = torch.where( +# nonzero, +# ramp, +# torch.zeros_like(ramp) +# ) + + grad_arg = xinv.pow(beta + 1) * beta + grad = ramp * grad_arg * alpha +# grad = torch.where( +# nonzero, +# grad, +# torch.zeros_like(ramp) +# ) + + return ramp, grad + + def generalized_sigmoid_transform(x, ramp): (fx, fx_), (dfx, dfx_) = ramp(torch.stack([x, 1.0 - x], dim=0)) denom_recip = (fx + fx_).reciprocal() @@ -191,6 +217,35 @@ def forward(self, out, cond): alpha = self._compute_alpha(cond).sigmoid() * self._max_alpha alpha = alpha.view(1, 1, *out.shape[2:]) return self._ramp_fn(out, alpha, unimodal=self._unimodal, eps=self._eps) + + +class SmoothRampWithTrainableExponent(ConditionalRamp): + + def __init__( + self, + compute_params: Callable, + unimodal: bool=True, + eps: torch.Tensor=torch.tensor(1e-8), + max_alpha: torch.Tensor=torch.tensor(10.), + max_beta: torch.Tensor=torch.tensor(2.), + min_beta: torch.Tensor=torch.tensor(0.5), + ): + super().__init__() + self._compute_params = compute_params + self._unimodal = unimodal + self.register_buffer("_eps", eps) + self.register_buffer("_max_alpha", max_alpha) + self.register_buffer("_max_beta", max_beta) + self.register_buffer("_min_beta", min_beta) + + + def forward(self, out, cond): + alpha, beta = self._compute_params(cond).view(1, 1, *out.shape[2:], 2).chunk(2, dim=-1) + alpha = alpha[..., 0] + beta = beta[..., 0] + alpha = alpha.sigmoid() * self._max_alpha + beta = beta.sigmoid() * (self._max_beta - self._min_beta) + self._min_beta + return smooth_ramp_pow_beta(out, alpha, beta, eps=self._eps) class AffineSigmoidComponents(torch.nn.Module): diff --git a/notebooks/compact/compact.ipynb b/notebooks/compact/compact.ipynb index 5df607d9..203bbf54 100644 --- a/notebooks/compact/compact.ipynb +++ b/notebooks/compact/compact.ipynb @@ -46,6 +46,21 @@ "execution_count": 4, "metadata": {}, "outputs": [], + "source": [ + "class PeriodicBasis(torch.nn.Module):\n", + " \n", + " def forward(self, x):\n", + " return torch.cat([\n", + " (2 * np.pi * x).cos(),\n", + " (2 * np.pi * x).sin()\n", + " ], dim=-1)" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": {}, + "outputs": [], "source": [ "from bgflow import (\n", " DenseNet,\n", @@ -55,9 +70,11 @@ " AffineSigmoidComponentInitGrid,\n", " \n", " MixtureCDFTransformer,\n", - " AffineSigmoidComponents, \n", + " AffineSigmoidComponents, \n", + " MoebiusComponents,\n", " \n", " SmoothRamp,\n", + " SmoothRampWithTrainableExponent,\n", " BisectionRootFinder,\n", " \n", " ConstrainedBoundaryCDFTransformer,\n", @@ -66,7 +83,8 @@ " CouplingFlow,\n", " SplitFlow,\n", " InverseFlow,\n", - " SwapFlow\n", + " SwapFlow,\n", + " \n", ")\n", " \n", "from toy_data.toy_data import dataset_names, inf_train_gen\n", @@ -89,6 +107,11 @@ " plt.plot(ys.detach(), ad_density.detach(), linestyle=\"--\", label=\"AD pdf\")\n", " plt.legend()\n", " \n", + "def make_net(d_in, d_hidden, d_out, activation, periodic=False):\n", + " return torch.nn.Sequential(\n", + " PeriodicBasis() if periodic else torch.nn.Identity(),\n", + " DenseNet([d_in * (2 if periodic else 1), d_hidden, d_hidden, d_out], activation)\n", + " )\n", "\n", "def make_transformer(\n", " d_in,\n", @@ -100,33 +123,43 @@ " zero_boundary_right=False,\n", " activation=torch.nn.SiLU(),\n", " smoothness_type=\"type1\",\n", - " init_weight=1.\n", + " init_weight=1.,\n", + " min_density=1e-6,\n", + " verbose=False\n", "):\n", " return WrapCDFTransformerWithInverse(\n", " transformer=(\n", " t:=MixtureCDFTransformer(\n", - " compute_weights=DenseNet([d_in, d_hidden, d_hidden, d_out * n_components], activation),\n", - " compute_components=AffineSigmoidComponents(\n", - " conditional_ramp=SmoothRamp(\n", - " compute_alpha=DenseNet([d_in, d_hidden, d_hidden, d_out * n_components], activation),\n", - " unimodal=True,\n", - " ramp_type=smoothness_type\n", - " ),\n", - " compute_params=DenseNet([d_in, d_hidden, d_hidden, d_out * (3 * n_components)], activation, weight_scale=init_weight),\n", - " min_density=torch.tensor(1e-4),\n", - " periodic=periodic,\n", - " zero_boundary_left=zero_boundary_left,\n", - " zero_boundary_right=zero_boundary_right\n", + " compute_weights=make_net(d_in, d_hidden, d_out * n_components, activation, periodic=periodic),\n", + " compute_components=MoebiusComponents(\n", + " compute_params=make_net(d_in, d_hidden, d_out * n_components * 3, activation, periodic=periodic)\n", + " )\n", + "# compute_components=AffineSigmoidComponents(\n", + "# # conditional_ramp=SmoothRampWithTrainableExponent(\n", + "# # compute_params=make_net(d_in, d_hidden, d_out * n_components * 2, activation, periodic=periodic)\n", + "# # ),\n", + "# conditional_ramp=SmoothRamp(\n", + "# compute_alpha=make_net(d_in, d_hidden, d_out * n_components, activation, periodic=periodic),\n", + "# unimodal=False,\n", + "# ramp_type=smoothness_type\n", + "# ),\n", + "# log_sigma_bound=torch.tensor(10.),\n", + "# compute_params=make_net(d_in, d_hidden, d_out * (3 * n_components), activation, periodic=periodic),\n", + "# min_density=torch.tensor(min_density),\n", + "# periodic=periodic,\n", + "# zero_boundary_left=zero_boundary_left,\n", + "# zero_boundary_right=zero_boundary_right\n", "\n", - " ),\n", + "# ),\n", " )\n", " ),\n", " oracle=GridInversion(\n", " transformer=t,\n", - " compute_init_grid=AffineSigmoidComponentInitGrid(\n", - " t._compute_components\n", - " ),\n", - " verbose=True\n", + " compute_init_grid=lambda x,y: torch.linspace(0, 1, 100).view(-1, 1, 1).repeat(1, *y.shape).to(y),\n", + "# compute_init_grid=AffineSigmoidComponentInitGrid(\n", + "# t._compute_components\n", + "# ),\n", + " verbose=verbose\n", " )\n", " )\n", "\n", @@ -163,11 +196,13 @@ " InverseFlow(SplitFlow(1))\n", " ])\n", "\n", - "def train(flow, dataset=\"pinwheel\", train_with_inverse=False, batch_size=1_000, learning_rate=1e-3, n_iters=1_000, print_interval=100):\n", + "def train(flow, dataset=\"pinwheel\", train_with_inverse=False, batch_size=1_000, learning_rate=1e-3, n_iters=1_000, print_interval=100, cuda=False):\n", " optim = torch.optim.Adam(flow.parameters(), lr=learning_rate)\n", " for it in range(n_iters):\n", " x = (inf_train_gen(dataset, batch_size=batch_size) + 4) / 8\n", " x = torch.FloatTensor(x) % 1 \n", + " if cuda:\n", + " x = x.cuda()\n", " y, dlogp = flow(x, inverse=train_with_inverse) \n", " nll = -dlogp.mean() \n", " optim.zero_grad()\n", @@ -178,21 +213,28 @@ " \n", "\n", " \n", - "def plot_evaluation(flow, dataset=\"pinwheel\", train_with_inverse=False, n_samples=100_000, norm=\"log\"):\n", + "def plot_evaluation(flow, dataset=\"pinwheel\", train_with_inverse=False, n_samples=100_000, use_log_norm=True, cuda=False, eps=0.):\n", " \n", " print(\"Computing energy plot...\")\n", " with torch.no_grad():\n", " xs = torch.meshgrid(\n", - " torch.linspace(0, 1, 100),\n", - " torch.linspace(0, 1, 100)\n", + " torch.linspace(0 - eps, 1 + eps, 100),\n", + " torch.linspace(0 - eps, 1 + eps, 100)\n", " )\n", - " xs = torch.stack(xs, dim=-1).view(-1, 2)\n", + " xs = torch.stack(xs, dim=-1).view(-1, 2) % 1\n", + " if cuda:\n", + " xs = xs.cuda()\n", " ys, dlogp = flow(xs, inverse=train_with_inverse)\n", " u = -dlogp\n", " u = u.view(100, 100)\n", + " if cuda:\n", + " u_ = u.cpu().detach()\n", + " del u\n", + " del xs\n", + " u = u_\n", " \n", " \n", - " if norm == \"log\":\n", + " if use_log_norm:\n", " norm = LogNorm()\n", " else:\n", " norm = None\n", @@ -201,7 +243,7 @@ " plt.imshow((-u).exp().detach(), norm=norm)\n", " \n", " print(\"Sampling ground truth...\")\n", - " if norm == \"log\":\n", + " if use_log_norm:\n", " norm = LogNorm()\n", " else:\n", " norm = None\n", @@ -212,15 +254,23 @@ " plt.hist2d(*x.detach().numpy().T, bins=100, density=True, norm=norm, range=((0, 1), (0, 1)));\n", " \n", " print(\"Sampling model...\")\n", - " if norm == \"log\":\n", - " norm = LogNorm()\n", - " else:\n", - " norm = None\n", + " \n", " with torch.no_grad():\n", " z = torch.rand(n_samples, 2)\n", + " if cuda:\n", + " z = z.cuda()\n", " x, _ = flow(z, inverse=not train_with_inverse)\n", + " if cuda:\n", + " x_ = x.cpu().detach()\n", + " del x\n", + " del z\n", + " x = x_\n", " plt.figure(figsize=(8, 8))\n", " plt.title(\"Flow samples\")\n", + " if use_log_norm:\n", + " norm = LogNorm()\n", + " else:\n", + " norm = None\n", " plt.hist2d(*x.detach().numpy().T, bins=100, density=True, norm=norm, range=((0, 1), (0, 1)));" ] }, @@ -233,20 +283,32 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 48, "metadata": {}, "outputs": [ { - "ename": "NameError", - "evalue": "name 'NewtonGridInversion' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\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 1\u001b[0m plot_transformer_density(\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mmake_transformer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0md_in\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md_out\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md_hidden\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m40\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_components\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mperiodic\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mzero_boundary_left\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mzero_boundary_right\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\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 3\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"no constraints, non-periodic\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m )\n\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m\u001b[0m in \u001b[0;36mmake_transformer\u001b[0;34m(d_in, d_out, d_hidden, n_components, periodic, zero_boundary_left, zero_boundary_right, activation, smoothness_type, init_weight)\u001b[0m\n\u001b[1;32m 73\u001b[0m )\n\u001b[1;32m 74\u001b[0m ),\n\u001b[0;32m---> 75\u001b[0;31m oracle=NewtonGridInversion(\n\u001b[0m\u001b[1;32m 76\u001b[0m \u001b[0mtransformer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 77\u001b[0m compute_init_grid=AffineSigmoidComponentInitGrid(\n", - "\u001b[0;31mNameError\u001b[0m: name 'NewtonGridInversion' is not defined" - ] + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlkAAADSCAYAAAB5ENV1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABRPUlEQVR4nO3dd3hUZfbA8e+Z9N4DIYWEQAiETgBRBMQCosLa0bWAvYH9p1jWvurq6rp2dBFxV7CtiG3tihQRkBpqSAIphPTeM+/vjxliQEqAJDNJzud55mHm3jv3njuXZE7e99z3FWMMSimllFKqdVkcHYBSSimlVGekSZZSSimlVBvQJEsppZRSqg1okqWUUkop1QY0yVJKKaWUagOaZCmllFJKtQFNspRSnYqIxIhIhYi4ODqW4yEifxaRr4/xvQ+LyL/tzzvF56FUR6RJllLKaYjIdBFZejz7MMbsNsb4GmMaW3C8WBExIuJ6PMdsC8aY/xhjzmiF/bT481BKtS5NspRSHUpXaJFxxqRPKXX0NMlSqhMSkQwRuUtENohIqYi8JyKezdZfKyKpIlIkIotFpMdh9jVGRJaLSImIZIrIdPvyABGZLyL5IrJLRB4QEYt93XQRWSoiz4pIsYiki8iZzfY5XUTSRKTcvu7PItIPeA0Ybe/eKrFvO09EXhWRL0SkEjhFRM4SkbUiUmaP6eFm+96vdUpEfhSRx0Rkmf14X4tIqH3zJfZ/S+zHHC0ivUXkJ/vnViAi77XwM59uP8ZL9vduFZFTm60PEJF/icgeEckWkcf3JYzN3vu8iBQCDx/YqiciJ4rIKvu+V4nIic3WxdljLheRb4DQZusO/DyCReQtEcmxX5tFLTk/pdTR0yRLqc7rImASEAcMAqYDiMgE4En7+ghgF7DwYDsQkZ7Al8CLQBgwBFhnX/0iEAD0AsYBVwAzmr19FLAN2xf+34B/iY0P8E/gTGOMH3AisM4YswW4AVhh794KbLavS4EnAD9gKVBpP14gcBZwo4j86TCfxaX22MIBd+Au+/Kx9n8D7cdcATwGfA0EAVH282ypUcBO+zk/BPxXRILt6+YBDUBvYChwBnDNAe9NA7rZz7WJfR+fY/vcQoDngM9FJMS+ybvAGvtxHwOuPEyM7wDeQBK2z+P5ozg/pdRR0CRLqc7rn8aYHGNMEfAptgQJ4M/AXGPMb8aYWmA2ttaj2IPs41LgW2PMAmNMvTGm0Bizzt4CMw2YbYwpN8ZkAH8HLm/23l3GmDfstUBvY0voutnXWYEBIuJljNljjEk5wrl8YoxZZoyxGmNqjDE/GmM22l9vABZgS/QO5S1jzHZjTDXwfrPP4mDqgZ5AD/uxjqZGLA/4h/2zeg9bknmWiHQDJgO3GWMqjTF52JKbac3em2OMedEY02CPs7mzgB3GmHfs6xcAW4FzRCQGGAE8aIypNcYswXa9/0BEIoAzgRuMMcX2OH86ivNTSh0FTbKU6rxymz2vAnztz3tga70CwBhTARQCkQfZRzS2lpkDhQJuzfdjf958H03HN8ZU2Z/6GmMqgYuxtVrtEZHPRSTxCOeS2fyFiIwSkR/sXZWl9n2FHvyt+8fC/p/FwfwfIMCvIpIiIlcdIbbmso0xptnrXdg+757YPq899m7XEuB1bC1J++x3jgfY75o123ekfV2x/XNtvu5gooEiY0zxkU5EKXX8NMlSquvJwfalD4C9+y4EyD7ItplA/EGWF/B7i88+MYfYxx8YY74yxpyOrXVrK/DGvlWHessBr98FFgPRxpgAbLVc0pJjH2G/GGNyjTHXGmN6ANcDr4hI7xbuL1JEmscRg+3zzgRqgVBjTKD94W+MSTpcLM3sd82a7Tsb2AME2a9j83UHkwkEi0jgkU9FKXW8NMlSqutZAMwQkSEi4gH8FVhp7/I70H+A00TkIhFxFZEQERli7wJ8H3hCRPzstVt3AP8+0sFFpJuITLUnBbVABbbuQ4C9QJSIuB9hN37YWmRqRGQktm7NY5FvP3avZvFdKCJR9pfF2JIfq33dj82L7A8iHJglIm4iciHQD/jCGLMHW53X30XEX0QsIhIvIofr4mzuCyBBRC61X4eLgf7AZ8aYXcBq4BERcReRMcA5B9uJPY4vsSWOQfY4xx5sW6XU8dMkS6kuxhjzLfAg8BG2VpB49q8Nar7tbmy1RHcCRdiK3gfbV8/EVoCehq0Y/V1gbgtCsGBLyHLs+xwH3Ghf9z2QAuSKSMFh9nET8KiIlAN/wZbwHTV7N+YTwDJ7N94J2OqbVopIBbbWsluNMWn2t0QDyw6zy5VAH2wtfU8AFxhjCu3rrsBWdL8ZW/L2IbaWvJbEWQicje06FGLr0jzbGLPvM7oUW+F8EbaC+/mH2d3l2Foht2KrIbutJTEopY6e7F8+oJRS6mDsrVvvG2NOPMT66cA1xpgx7RqYUspp6YB3SinVAsaYLGzDTSilVItod6FSSimlVBvQ7kKllFJKqTagLVlKKaWUUm1AkyyllFJKqTbglIXvoaGhJjY21tFhKKWUUkod0Zo1awqMMWEHLnfKJCs2NpbVq1c7OgyllFJKqSMSkYNOZaXdhUoppZRSbUCTLKWUUkqpNqBJllJKKaVUG9AkSymllFKqDThl4XtHV11bxvLti1iRvZRaax2C8FDc+biIhf8VbqDaw5vxfS8gyK+Ho0NVSimlVBvRJKu1NNRCYSr/3fIuT+3+gmrTgK+44ePiDoAJSAMR1uev49+lKVhS3mSYTxSnRZ7MhITziAjp6+ATUEoppVRrcsppdZKTk01HGcKhrq6Kfy1/hIn1bvRy9WFdYwWfNeRzWtxkkuMn4+rqvt/2xmplc9ZSvktdzPd7V7Gzroh+bkG8P3AW9D4NvAIdcyJKKaWUOiYissYYk3zgcm3JOg7r0r/h4V8eZ2ddEW5Rp9Nr6PUMCYhiiMgh3yMWC0kxY0mKGcssIGPvekpy10JxOpUrX+FD13ouGXk37u7e7XciSimllGp1mmQdg8rqIv655H4W5C6lm6svr4x8kJP7XXRM+4rtNhi6DYaaUr5b+Xee3fkxH+z+hvuG3c6Jiee3cuRKKaWUai96d+HRKs1i/nd3siB3KZd0H8Oi8z4/5gRrP54BTBn3KK+NfAiA61c+zAOfT6eurur4962UUkqpdqc1WUehoWAHrpsXUeXqwY6IfgyOO71NjlNXV8VrS//CG5lfcVHwEB6c+Dpo96FSSinllA5Vk6UtWS309fq3uPDrGRS4eeA9/Ko2S7AA3N29mTXhWZ4bcgfXesfDb/OhsrDNjqeUUkqp1qdJVgt8vPqf3L3uefzcfHEfdAl4+LbLcU8fPIPuydfQ2FDN/f+7hl93LG6X4yqllFLq+B0xyRKRuSKSJyKbDrF+vIiUisg6++MvzdZNEpFtIpIqIve2ZuDt5e1lj/GXlDcY7RfHa+e8h79PWPsGEBBFSdJUNtUVcv3yB/hk9Uvte3yllFJKHZOWtGTNAyYdYZufjTFD7I9HAUTEBXgZOBPoD1wiIv2PJ9j29t7yJ3k29X1OD+zPi2cvxNszwCFxhAT14p0pH5Hs25MHU17n099edUgcSimllGq5IyZZxpglQNEx7HskkGqMSTPG1AELganHsB/H2LuZ06pquLnHBJ4569+4uXs5NBx/nzBePPtdRvj25MGNr/LdxnccGo9SSimlDq+1arJGi8h6EflSRJLsyyKBzGbbZNmXHZSIXCciq0VkdX5+fiuFdWzSs36hfsunhAT35oYJf8fF1c2h8ezj6eHHi5P/zWjfWEJyNkBRmqNDUkoppdQhtEaS9RvQ0xgzGHgRWHQsOzHGzDHGJBtjksPC2rnuqZnMvI1c+cNMnij5DQacDy7ONV6rt1cgr055jyHBibDpIwpy1zk6JKWUUkodxHEnWcaYMmNMhf35F4CbiIQC2UB0s02j7MucVmnlXm767iasGGaMvt95x6Zy84LB0/iwOpNzvr6KlF0/OToipZRSSh3guJMsEekuYpusT0RG2vdZCKwC+ohInIi4A9MApx2DoL6+htu/vIqsujL+MfpRenYb5OiQDs/dhzEjZhHg4skNS+4kMz/F0REppZRSqpmWDOGwAFgB9BWRLBG5WkRuEJEb7JtcAGwSkfXAP4FpxqYBuAX4CtgCvG+McdpM4OnvZrGqcjePDryB5N6THR1Oi3QP7s3rp72GFcPMb2+ivEoHLFVKKaWchU6rA5C7ka3r32GVlyeXj320/Y7bSn7dsZjrlz/AKL9evDL1QyxOVkemlFJKdWaHmlany38bV5bsxmf7/0gMH0Ti4EsdHc4xGdlnCg8Up2LZuxlL+o/Q+zRHh6SUUkp1eV16Wp2qmlIu+9/l/KN4PfSfCpaO+3GcP/IOzk28GDJXUbZrmaPDUUoppbq8jptVtIInv7uVnbVFjOx7Lnj4OTqc4xd/KqvcLEz8aSardnzq6GiUUkqpLq3LJlmfrH6JRQVruDZmEicmnu/ocFqHxULi0KsJd/Pl9l8eIbtgi6MjUkoppbqsLplkpeb8yuOb32SETww3nfxXR4fTqvx8Qnnx1JewYrjju5nU1lU6OiSllFKq/TXWQ02pQ0PoekmW1UrOlkWEu/rw9GkvOc2UOa0pJnwQTwy7g801e3ny25mODkcppZRqd9s3/Ju05c9BfbXDYuh6dxdaLIwdcjUncjWugXGOjqbNnJL0Z67d+xvVJbuwZv+GJXKYo0NSSiml2kfBDhJKcsntNtA2S4qDdL0kCyAkvkuc+Mxxf0M2vg+p34FfBPhHODokpZRSqk0VlOwibe0bjAzsS/fEPzk0lq7XXdiFiIsL9J9CirWCGf+bTmlFrqNDUkoppdqMsVp54PtbuWXPNxTHjwcHD86tSVZn5+6DNW4c66tzuefrG7BaGx0dkVJKKdUm3l35N5aV7+T2hGkEBcc7OhxNsrqCgbETuDfxcpaV72TOzw86OhyllFKq1aXm/Mpz2xdwsn9vpo2829HhAJpkdRkXjriDs0OG8ErGp6zY9rGjw1FKKaVaTV1dFfcsuQdfF3cenfAC4iQzuDhHFKrNicXCg6e9RLxHMB9vmgc1ZY4OSSmllGoVrruWcZ53Tx4bdhehATGODqdJV7jJTtl5ewbwxulvELRpEWz+BIZcChYXR4ellFJKHTNr4U4sWav5c+IlkDDR0eHs54gtWSIyV0TyRGTTIdb/WUQ2iMhGEVkuIoObrcuwL18nIqtbM3B1bEJDEnBJPIv8oh18uOJJR4ejlFJKHbPSilzO//oqlljLIH6Co8P5g5Z0F84DJh1mfTowzhgzEHgMmHPA+lOMMUOMMcnHFqJqdd2S+Lcp4ZHU9/h+078dHY1SSil11IzVyqPf30ZGXTEhfc4EF+ebweWISZYxZglQdJj1y40xxfaXvwBRrRSbakM3j3uKJM9uPLD2eTLzNjo6HKWUUuqofLbuNb4uTuHmuKkkxYx1dDgH1dqF71cDXzZ7bYCvRWSNiFx3uDeKyHUislpEVufn57dyWOpA7u7ePDvhBQS444dbqaktd3RISimlVItkF2zhiU1vMsw7ihkn/sXR4RxSqyVZInIKtiTrnmaLxxhjhgFnAjeLyCFTTWPMHGNMsjEmOSwsrLXCUocRFZbEk8P/j201+bz602wwxtEhKaWUUodntfK/NS8D8NdTnsPF1fm6CfdplbsLRWQQ8CZwpjGmcN9yY0y2/d88EfkYGAksaY1jqtYxtv/FPF2ezYkV5bBnHfQY6uiQlFJKqUPL/IWr3SOZfPLfiQjt5+hoDuu4W7JEJAb4L3C5MWZ7s+U+IuK37zlwBnDQOxSVY5054jYCQhOp2/4/duescnQ4Siml1EFt3vUjO7Z9CuGJRMSOd3Q4R9SSIRwWACuAviKSJSJXi8gNInKDfZO/ACHAKwcM1dANWCoi64Ffgc+NMf9rg3NQx8tigX7ncG/hL1zzwyyKy3McHZFSSim1n/LKAu5Ydj93Fi6lsfcZIOLokI5IjBPW4SQnJ5vVq3VYrfaWsusnLv9xFiP8YnllyodO3c+tlFKq6zBWK/d8fhlfF21i3snPMqTXGY4OaT8isuZgQ1XptDqqSVLPcdzX70qWl6fx4k//5+hwlFJKKQA++e1lvizayE2x5zhdgnU4mmSp/ZyffBsXhI/iX1nf8uW6NxwdjlJKqS5u9971/HXzXEb4xHD1SQ87OpyjokmW2o9YLNx32ktMDRpAYsEuKNvj6JCUUkp1VY0NROxayWUBSTw54Z8droxFkyz1B25unjw+6U3ifHpgNn5IVcVeR4ek2kNjPQVFqaxP/5a0Pb9RW1fp6IiUUl1czY6vcassZNZJD9EtON7R4Ry1VhknS3VC7j4w4Hye+OZmtnzxKW/9aRHu7t6Ojkq1kqz8FH7YsYilub+SU1vEfyOn4NbYwOtFq1hYsaNpu3BXH3p6hPBG/+txCYzGhCQgHj4OjFwp1VV8s2Eez2x4lTcH3UpMaB9Hh3NMNMlSh+bXjVG9z+a9tX/n0W9u4rEz5yIWbfzssMr3snzHJzy3fQHbagsAiHcPJsEnkpqwvrh5h3JBZBIn11dRWltMVtlusipzqKyrwKU4A/amcGfBA9S6enBmzzOY0G8a3l6BDj0lpVTnlJ67lgfX/ZN4z1AiEs91dDjHTJMsdVinD5rOjYVbeHX3F8Qvf4wZYx5ydEjqKK3a8RmhhenEVVfgU1eIj4snd8VfyCkJfyImfNB+2/a1P/7AGKjYS9yqAhbvWc6SjS/juek1JoYM4YaRdxMVltQep6KU6gKqqku4/YfbcBcX/n7aS7i5ezk6pGOm42SpI7JaG/m/zy7jq+JNPD1oJpOHHnaub+UEjNXKyh2LeW3jHNZUZnK+f18eTv4/6JZk6wo+DlZrI+vSv+Hz7R/xSf4qrvTvz8z+06HnaPDwa50TUEp1SfvGw/qqaBOvn/AoJ/T9k6NDapFDjZOlLVnqiCwWF56Y9CY1n/2ZwL2boTgDgmIdHZY6hA3p3/HM6r+xriqHcBdv7k34M+cPu7nVEiCLxYVh8ZMYFj+J64p24rNnI+SsZUna56xxs3DVqHsI8O3eKsdSHURDHY1lmfxr41wyyndT01hHjbWOWms9o31iuCZsFHgFMb9oLRH+PYkL7U9M6ACt81R/UJO5guKqfGbGTe0wCdbhaEuWarn6alj7b6gto2rA+XhrouVc6msg/Sf+tulNvqrazbW9z+fcYTfjcZwtVy1SVcTLyx7m9Zwf8Ld4cE/S1Zw95Hqt4euk6htqWLrtI37e/SO+jfXc4ZsIxjAp+xMaRfCxuONhccPT4sbJAX24JvwEqirzOCH1X+z7xnHFwon+8VyRcBGjEv4Ebp6OPCXlDEoyYd27NAbHIQPOx2JxcXRELXaolixNstTRqSnl4x/u5+Wi1cyf9DY9Qg5awaPakbFa+XrjPMIKdjLMxY+q7gOx9jwBX6+Qdo9lW/YKHlv+MOurchjj35uHxj1N9+CEdo9DtY303LV8vGkei3NXUNhYjZ/FnfEBffnrwBvBvwe1PiF4eAYe8v1VNaVk5G0gvXAzKQUb+TZvDbf4D2CKfx/y/cL4hRpOT7oMT+127nL2Fu3kbz/cwb3dxhI26uYOl3RrkqVazY7slVz5/U2Eufow/5z3tWvIgfYUbuOxJffyc1kqZ/r35W+nvgj+EQ6NqbGhnoWrnuWFHe9zT8hIzh9yHfQY1iEmc1V/1NhQj0vBNsj5jb9lLObd8u2MDUjgvD7nMabvBbi6uh/zvo3VSmNpFq6F23lv+0c8nr+UUBcvpseezYXDZ+ndq11EVXUJ0xefz67aIt459VUSIk9wdEhHTZMs1apW7fiU65c/QD+vbrx+zgKHtJp0ZcZq5bN1r/HXTW/SiGFW7wuZNvKu4/rCa225hdvotnsNUrKLpS4N9Op/IT1CEx0dlmohq7WRrze8xStb5vNA4DBGBvenILgnhCUSGtizTY63KvUz3tj4JisrMgi0eHBFz0lcc8L9SAe+u0wdXmNDPbd9dglLSrfz4oj7Gdv/YkeHdEw0yVKt7ruN73DXb8+Q5B3BW1P/i1t71P4oqK/mu5XPc9vOBQz1juSv4//uvEMoGENdzhrO/OFmqk0Dfxl0E5MGX+3oqNRhGKuV71Le4eWUt0itLaS3RzD3DZ7FiMTz2q01cl36N8xZ9wqWuipe6jERep6IiUxGXPRerc7m2W9m8XbOD8xOuIxLR9/j6HCO2XElWSIyFzgbyDPGDDjIegFeACYDVcB0Y8xv9nVXAg/YN33cGPP2kY6nSVbH8e3Gt8lO/54ro06DQReBq4ejQ+rUSnM3EJD2E411lXzm5cbZw2d1iLm8MvNTuPeH29lQvYc/hQ1n9in/0K4gJ2RKMrnh2xtZXrmLWPdAbup3BRMHXeWwAuS6kt24717JrtzfuLPoF+4YOpMT+57nkFhU66vYtYyLl97FmNAhzJ74qqPDOS7Hm2SNBSqA+YdIsiYDM7ElWaOAF4wxo0QkGFgNJAMGWAMMN8YUH+54mmR1MHlbYfMnbHNzJXrY1frl2Qbq6qp4/se7+WLvSj6Kv4zQgdPAr2PVwtU31PDakgd5I/N/xLgFsGDiPPxCejs6LAUUlu4mKHsdlr0pfFq7BxPWl8mDr3Wa7uf1qV8w+9cnyKwv4/TA/tw95lEi9Kabjq0oDTZ8QKl/d3wGXeI0/9eO1aGSrBbdX22MWQIUHWaTqdgSMGOM+QUIFJEIYCLwjTGmyJ5YfQNMOvrwlVMLT6S8z2lcnfYuN35+CVXVJY6OqFNJ27OGS/97Fv/es4SJ4cn4Dr+6wyVYAG6unsyc8Az/OvFJJvrF47fxI9i90jaavHKI+oYa3l72GGd98ic+TvsUeo7mnNOeZcrwm53qS29w78l8fMHXzIqbys+l25jy+cXM+/kRsFodHZo6Blszl/HET/dQ7x1IwKBpTvV/rbW11iA2kUBms9dZ9mWHWv4HInKdiKwWkdX5+fmtFJZqL36Rw3lg4I2sq8zmxs8uobQi19EhdXjGauWDX5/j4m+uJq++gpeT7+e+ia91+NvbR/Q5m5mTXoPQ3mzZ8iG3fXIhxeXZjg6ry1m7839c+MFEnk19n6F+PRk+4hboNR6c9AvPw92Ha8c+zuKz3uOkgD7szd8Ia+dDhX5fdCRpe9Zw3Y+38WNVFsV9TjvuEhNjDJlFVXyyLps1uw7XFuQYTlNFaIyZA8wBW3ehg8NRx2DSkGsQsTB73Qtc8elFvHr6HL2b7FjVV8PWz1mR8S1DfWN4YsILhAXGOTqq1uPmBUnnsbMmhyUpX3PBJ+fx1KgHGdHnbEdH1vnV1/Dakvt5Oetrerj68c/kexnf75IOM3BsREhfnj/nPRrzNkPqt/y27GlWe3ow46QHcXPtWGMrdTWZeRu55rubcBHhzdNeJzwo/qj3UVPfSEpOGWt3F7Nml+2RV14LQO9wX769Y1xrh31cWivJygaim72Osi/LBsYfsPzHVjqmckITB19FsHc4t/7yEPOXPsy9p74Aft0cHVaHsmLbx0TsSSFW3HlixL149DypQ4183GIinJ08k97dhnH30nu5Zvl9XJ/1M9ed/Fin7j5wFGO1Ys3fgkvqdwysq+eKHuO5ecxjHbKGUiwWXLsPgOA4fvz+Tt7K+Ipvc3/h8TFPdMgxlrqC3KLtXPPN9dSbRt469RV6dht0xPc0Wg1p+RWsyyxhfVYJ6zNL2bKnjAarrR0mOtiLE+NDGN4ziJ+257Mus7StT+OotXgIBxGJBT47ROH7WcAt/F74/k9jzEh74fsaYJh909+wFb4ftk1PC987vl171tIj/WfcGuqo7z8Ft1Ad9ftIamoreOGne/j3niVM9k/g6VNfcvjAou2lqrqEx7+bxaeFa3mwxxlcNOZB6IBf/s4qp2Arf/35PhJwZ1b0GZBwZqf6v/Xtxrd5bP1LlDXWcUuvPzF99AMd4q7bLqO2gnXLn+Wu7C/559hn6R9z8h82qW+0kpZfycbsUjZll7Ixu5TNOWVU1zcC4OfhyqDoAAZHBTI4OpCh0YGE+//ecvnkF1uYtzyDbY+f2W6n1dxxTRAtIguwtUiFikgW8BDgBmCMeQ34AluClYptCIcZ9nVFIvIYsMq+q0ePlGCpzqFnxFAI7k3Jb/OY8fVVXJlwMX9KnunosJzWtszl3LtsNqm1RUzrdhJ3nPI38PB3dFjtxtsrkL+ePZ8zNrzNSSV5sPpfFPYcTUjMiY4OrUNraKjj3ZXP8NLODwEY3ftCGDYdOkjXYEudNvBKhseezmPf384/0v5LWF0NU0bfA97Bjg6ty6upKsRz038Z4uLDF5MX4B7ci9KqerbmlrFlTxmb7Y/tuRXUNdpuZPB2dyGphz8Xj4hmYGQAg6MD6BXqi8Vy6HHafD1cqW2wUtdgxd3Vef5/62Ckqk1VVBdy+xfT+aUigwvDT+CeU//RPhMWdxRWK79ueJvr1/+DQBcPHht+N2P6XejoqByrupjSje9z3vZ/MTKwL/ed8jx+PqGOjqrD2ZG1ggeWPcjmmr2c7N+bB05+stPXSBqrlZ9T/sNJxXtxAbIiBxEZd1qHqTfrbNJzt3LTt9dwhvTE02sGv5T4sy23nNyymqZtQnzc6d/Dn/4R/vSL8GdApD9xob64HCahOph5y9J5+NPN/Pbg6QT7tH+5wXG1ZCl1rHy9Qnh16ke8+NM9zM36lo0fn8PfT/kHMeFH7o/v7OpKMnFP/ZZBpVlcFJbMDSc/RpBfD0eH5XheQfgMm8EFVRm8vutz1i6awuOjHiC592RHR9YxNNRBxs+YtG8oaqjgmSG3MXHgjC6RaIjFwtiBl0NNKcWbPuSS5feRtP4VHhn/d7oFH32RtWqZ0qp6UvMr2Gl/7NhbQXbBbxQHzqHB0siCzP6U1NXTO7yW0fEh9O3uR9/ufvSP8CfczwNphZkE/Dxt3cMVNQ0OSbIORVuyVLtZkrKQ+357lkEeYbwy/nkI79x/VR9KbV0lry19kG/3rOT9mPPw6jsZwhJ1AuWDWJf+DbNXPExWfRkXdzuRe055DjcPbQk9GGO18vXGeazP+Jb/8x8IPYZQHzsGtw4+5MexslobWbjyWZ7fsQA3cWF20jWcPeT6LpFstoW6BiuZxVWk51eSXlBJWkElafkV7MyvpKCitmk7dxcLSd12kO0/DzexcEOvRxjddyyxIT64urTdZ/9VSi7Xv7OGz2aOYUBkQJsd51C0JUs53NikaXzQfSguO76FlI8pyEvAu/dpeHu2/w+Eo6zZ+QUP//okGXUlTAkdRsOwK8AnzNFhOa0hcafzUcRIXlxyH7tLUnFdMw8SJ0NwJxrOohWk7fmNJ5c/xC8VGSR6hlE15hG8Q/rQlUu/LRYXLh19Dyf1OpP7l9zNfRtf4bvM73n6jNfx8NJarYOpb7SSVVxNRmElGQX2R2EVGYWVZBVX02j9vVEm2MeduFAfJiSG0Tvcl/gw28OzZjNTv7+PEFdv5pw+h+h2mlfVz9OWzlTUNrTL8VpKW7JU+7M2QtoP3LLmGXY0lHP/0Fs77MzrLVVVlsPDP93Fl0UbiXT14y/D7+TExPMdHVaH0liyC5dtX5Fdtou3GvKZNfYJ/Lt4glpVXczryx9lftb3eFlcmdn7Ii4acYfeWXeAxoZ65v/yV7bnruGv3U5B+p7ZZVvSy2vq2V1URWZRFbuLqthVaH8UVZJdXE2zPApfD1diQ73pGeJDXIgPvcJ8iAu1PQK9D9Ilt2c9bP+KxXV7OXHELEIDe7bbeW3MKuWcl5byxhXJnN6//YcNOq65C9ubJlldw287v+SRX58kra6YiUEDuGfsk4QFxjo6rFZlra/BkrkSs3sl1+79hiFhQ7hq9P0dcmwip9DYwKKVz/LQjncJdPFgZsIlnDtsZtdLKqyNsGcdxTu/5ayM9zg1dBC3jXmMEP/oI7+3CzPleci2z0kv2s6rNRncPfavnWuQX2ytUXtKasgsrtovmcosqiKzuJqiyrr9tg/ydiMmxIeewd7Ehnjbnod4ExviQ6ive4vqperqq/nbd7dyuvFiVMQJkHQuuLXvwLAZBZWMf/ZHnrtoMOcNi2rXY4MmWcpJ1dVVMXfF47yR8TkeFldeGHonI/pP6/C3mDc01PHputeYu/193gqfQGiP4Zi4cYgmV61ia+Yynlz5OL9VZpHoGcY9w+/qEoXxxmrl203z+SZ1MU8FJmMJ6klR1FCCw/o7OrSOw9rIl6tf4sGtb+EuLtyVeDnnDp/VYWq1rFZDQUUtmcVVZBZV25Mn+/PiKvaU1uzXredqESKDvIgO8iYmxJuY4N8f0cHeBHgd3x8oe4t2cse3N7Kheg+zep7NtWOfcMjv74KKWpIf/5ZHpyZxxejYdj++1mQpp+Tu7s0N4/7KpMSLeXHF4yTs3QGVb5DbLZGwqBM7XAtFXV0Vn6x9lbk7/0tWfRmDvCIoSzyT0KjRaFl760mMPol5kZ/z1ca3+PumN/lq/Zsk19ZCr1M65SCmxmpl5Y7FvLThVdZX5RDvHkxhwmmERY4gWG+YODoWF84ceSv9e57Cwz/fy0Ob/8Xnu7/loZP/6hR3PRtjKK6qJ7OoiqziansC9fvz7OJqahv2nxg7zM+D6CAvhvcMIjrIm+hgL6LtiVR3f882Kzhfs/ML7lzxMFXWep4dcgcTB89ok+O0xL6arPIarck6Im3J6qKMgYLtWNOXcGHqfOpFuCHxMiYOnOH8yVZDHVWZvzBl+f+xt6GSAV7dubb/lYzvf0nnnBLHiVTXltG4+xd8c9bza3UOn1lLuDb5DqLDBzo6tONnDHsyl3PHLw+zqTqXcBdvbu57CVOG3qRTD7UCq7WRj1e/yN+3vcOFvn24fchNEDMaXNr2901lbcNBW6Ky7AlVZV3jftsHerv9njwFeRMV5EVUsDfRQV5EBnrj5d7Ov2OsVrZt+Yhpqx8jyj2Af4x/nviIPzTitLuE+7/kqjFx3Htm+9fbaXeh6jCs1ka+3TifV7fMI7W2iF7uQVwSdzZnDrySAB/nmgdxW/YK1u78immWANvEu7WZDI47nRP6TO0w3Q+dRk0ZC399jmfSP6YRw+SQIVwz/DZ6RQw78nudTH1DDZkZP9KrKJP6ijyuL1jCmbETmTLkeh3Mtw3klaThk7kan4KdrLJWUBQazxkDpx/zz3Cj1bCntHq/mqjdRbbXWUVVFB5QF+Xt7tKUREUF2brxooNsrVFRQV5NY0A5g6rSTLxTv8OU5vAvaz4Xj77faQYLHv7YN0wa0J0nzm3/P7A0yVIdjtXayNcb5/Gvrf9ha00+T4aO4ey4SdSGJeIW0tthLUSlFbl8vvFtFu3+mi01eXiIC98NuouAuPEQ0P4Fl2p/+SXpzFv1HB/sWUqNaeDS8FHcO3I2BMU5fa3f7rwN/HfjW3yyZxkW4Ms+V+EeezKE9XP62DuFkt3c9cNtfFW2g5E+Mdwz+sFDTjhdU99Ipv3uvIzCyqY79XYXVZFVXEV94+/frS4WITLQy14HZUuk9tVERQd5EezTsgJzR2psqOftFU/wdsbnLIyaQkT/8yG8n1ON7zf+mR8YHB3IC9OGtvuxNclSHdqWzKXEVZTiWbCNfxWt5YOKnZwSNpQTIscwoteZbXq3nrFaaajIxa1kNz9lfM3t6R9Rj5VEzzD+FHMGZw24kkC/zjPZbmdRVJbF/FV/J6ymgj9796LO3Yf5jXmcPeAKugc70YTljfWs2f4JL6e8xarK3bggnByQwIUJF3Jy4oXaItrOGhvq+XDNP3hx+3uUW+s4zX8wo3pcT3FNhH38qCp2FVayp6yG5l+ffh6uxIR40zPEm5hgH2KC9z33JiKg7eqi2kNqzq88tPQBNlTv4dTARB4Y/3dCA2IcHdYfnP3iz4T7eTJ3+oh2P7YmWapzaGxgyZb3eHf7B6yuyKDWNOKKMMK3J68P+z/EvwclLq74+0cdc0tXcXkOqbm/kVqQwqbCFJaXbOWWgIGc79ubXHcP/l2VwdmJF5MYfVIrn5xqE40NULiDVdsXc9XOf2NBGOUXy7iI0Zwcf5ZDip0LSnaxZMfHDDEe9KqpYHlFJo+XrOG8qAlMGTSD8MBe7R5TV2W1GvaU1ZCWX0GafTTznfkVZBVkYnFfSEHgdk7I70ldySi2ewwkPCyU2GbDHPQMsY0jFeTt5vStUUfL1JTzxI938sHeX/CzuHPfgOs4c/A1Tpv4XzLnFxqthvdvGN3ux9YkS3U6tXWVrE3/hhVZP1FZmc8D/gPAGC7a8yXpDWX0dA8izrs7oZ7BJPrFMLXHWHBx56v836hqrKa8tozyujLK6yvo59mNqf59qCrPYVTa203HCLJ4ckJgHy7odQ4j488CT38HnrE6Xln5KXy8cR5f7/2FjLoSAD6MnUbfyFHkevrh7h9JsH/rd/nW15SyYueXbMz7jWX5a9lYnQvAraEjuabPRVhD+0BgT71Jog3VNVjZVVjJjrwKUvN+n2dvZ14l1fW/F5r7uLvQK8y3adDNcO8CRpgsYqpT+aw2nV0eXlw54s52HWizvdXXVuK2Zy3s/oVH8pfh7tudG0580OnnVr12/moyi6r4321j2/3Yx5Vkicgk4AXABXjTGPPUAeufB06xv/QGwo0xgfZ1jcBG+7rdxpgpRzqeJlnqmNRXQ2U+n6YuZmvxNtIrskivzqO4oZoTvbrzXOjJAIzN+ohi6+9zbflZ3DnbP4H7oiaCTxjvl6QQFRhP7+5DCfOPddq/2tTxyczbyIq0/3GhZzRSmskjBcv5sCKVcBdvEn0iSQyIp3/YAE6NngDuPtRaXHB39zvk/4fq2jLySjLYW5ZBblkmeypyCDVwvkcPGqpLGJ31AbWmkSSv7ozvNpLxvc4iIfIE/f/VyuoarKQXVLJ9bznb95azY28FO/LK2VVYRUOz8aMiA72ID/clPsyH3uG+9Aq1PQ871ITFVUU8+/P9vJO7DAvC5JDBXD74+k7Vol1dW8bida8zZ8eH/DP0ZJKiTrSN7+cT4ujQWuSO99exMq2IZfdOaPdjH3OSJSIuwHbgdCALWAVcYozZfIjtZwJDjTFX2V9XGGN8jyZYTbJUqzMGrA3QWEd22S6MMfh7h+PjEej8w0OottdQR0rmT6zOXsHWkh1srdhNem0xEa4+fNnD9nfhtXnf81tNHoGuXoBtPKM+7kG83mMiGCtTd/+XtIay/XY7wTeOFxKvAr8ItpoqYsKH6mj/rcRqNWSXVLM1t5xtuWVsyS1ne2456QWVTcmUi0XoGeJNn3Bf+oT70Tvct2mevWMd9mB33gb+vfYVFu1dSbVpYHroSO4cdS8Ex3fYmxPyS9JZ8NvLfJD9IyXWWgZ79+CBkbNJ7Dne0aEdlYc+2cSidTmsf+iMdj/28QxGOhJINcak2Xe0EJgKHDTJAi4BHjrWQJVqEyK2sW9c3IgM1dGx1QFc3UmKO52kuNObFtXUlpNXtAM8AqGukik+XvQrS6e4rhRBsIiFHh7BEJ4EYuF6DxcaXd3p5hdF94BYwgPi8PTwa9pf15wpr3VU1jawNbecLXvKmh7bcsv3G08qOtiLvt38OCOpGwnd/Ejo5kevMB88XFu3CzYmfBD3TXyNmyv38tFvr9K/rhY2fkiOBRbW7+XsftMOeUeiUzEGynOpz1zJBb89QbG1hlMCErl8wAyG95rUIVtY/TzdqKhtwBjjNPVxLUmyIoHMZq+zgFEH21BEegJxwPfNFnuKyGqgAXjKGLPo2EJVSqn24+nhR0yzMbbO6X74sXcmc1pbh9TpGWPIK69lc04Zm/eUkZJTyuacMnYVVTXdyefn6Uq/CH8uGB5F3+7+JEbYEipfj/adwCTApxtXnfywbR7Jgh2s37KQd7K/563s70jwCOXsqPGc3vcCosKS2jWuI9mR/Sv/2/YBGwtTeD1kDG6u7jyUcCm94051ihHvj4evpyuNVkN1fSPe7s4xoU1rRzEN+NAY03y42p7GmGwR6QV8LyIbjTE7D3yjiFwHXAcQE+N8t4YqpZRqPVarYVdRFSk5paTklLEp25ZQNR+os2eIN/26+3PesCj6RfjTL8KPyEAvp2mlAMDiAuGJnBn+MKOGXsNXKf/hs8zveG7nh/xz50cs7XMtPqF9yfTwIqTbILw9A9o3vsZ6duWs4rPURXyTu5KddUVY7Hdkl8WfTECPEUxo58mc20rzqXU6UpKVDTSf2j3KvuxgpgE3N19gjMm2/5smIj8CQ4E/JFnGmDnAHLDVZLUgLqWUUh1AQ6OVtIJKNmWXsim7jE32FqqKWts8c24uQp9wPyYkhpPUw5/+PQLoF+HnVCOdt0SwfxSXjL6HS0bfw+68DWzOXIqPWyjkrueBnC/ZWFtIknd3+vn3ol9IPwZFnEB8xHBbotYKrNZG9hansjNvA2v3/MpEzwgS6hvYWbGL1wuWMNQnivtiJ3N6/0uccpyr47WvNbO8poFuTnIjeEuSrFVAHxGJw5ZcTQMuPXAjEUkEgoAVzZYFAVXGmFoRCQVOAv7WGoErpZRyPnUNVnbklZNiT6Y2ZZeyeU8ZNfW2SY093Sz0i/Dn3KGRDIj0J6lHAH26+bZ67ZSjxYQP+r37rbGBm3cm8POu79hQsoNFe39hQe5STt75Oa90PxW8g7l3z3d4unnTzSuc7r4RBHuFEeUbQbx/HEZc2FKWjohQUVNCeW0J5TUl9PYKJ8mrG3tK0pi5fT6760qoNrbE1QUhKvIMEmLP5ES/yfzs+xenm5astfnbk/LymnoHR/K7IyZZxpgGEbkF+ArbEA5zjTEpIvIosNoYs9i+6TRgodn/dsV+wOsiYgUs2GqyDlUwr5RSqgOpqW9ka245m7JLScmxtVJtyy2nrtGWUPl6uNK/hz+XjIxhYGQAAyID6BXq06FHPz8mLq6MTJjKyISpgK3FaVfeBuor9gJumKoidtcUkFNWSmFjddPbpvn24f7gEdSbRi7OfO8Pu73avz9JQUMJdPch3COQkcFJxAbEEhucQFLUGHy8ggHwtD86u+bdhc5CByNVSil1RKVV9aTssXXzpeTYitJ35lfSaB8uIdDbjaQetpapAZEBDOjhT2yIDxaLE9VPdQB1dVXkl2VQVJFLoJsv0d7hNDTU8XPeKqxWK36eAfh5BuPrGUSwTzd8PIM77NARrW1rbhmT/vEzr/x5GJMHtu9UZ8czhINSSqkuwhhDTmmN7Q6/nDI277EVpmcV/97C0s3fg6QeAUxM6m5PqvydryC9g3J39yYytP9+Q824AqeEOdF8m07KryN2FyqllOqcqusa2b7XNv7UvnGotuaWU1pt+5ISgbgQHwZHB3LJyJimlqowPw8HR67UHzUvfHcWmmQppVQn19BoZVdRFdtyy5tGSN+WW77f+FM+7i707e7H2YMiSIzwJ6mHP4nd/ZzmVniljkSTLKWUUm2m0WrYXVTFjr3l7MirYFuubf6+tPzKpmJ0i0BsiA/9Ivz509BIErv70z/Cn6ggL62fUh2ai0XwcXdpGhrEGWiSpZRSHUxNfSMZhZXszKskNc82AXJqXgVpBZXUNVibtosM9KJPN1/GJoTRJ9yXxO7+9Onmi6db5xouQal9/DzdtCZLKaXU4e2bYiYtv5K0ggrbv/kV7MyvJLP4924+EYgK8qJPuB/jEsKID/e1TYjsgKlmlHI0X09XbclSSillU1pdT0ZBJekFlaQVVDY9Ty+o3O/LwtPNQmyID4OiAjh3aCTx4b7Eh/nQK9QXL3dtmVIKbGNlaU2WUkp1IaXV9ewqtCVOGQVVtueFtoSquOr3ro19rVJxob4MiwmkV5gvvcJ86BXmS4S/p9ZMKXUEfp5uTXfHOgNNspRS6jgZYyiuqiejsJJdhZXsKqxiV2EVGQdJpAAiAjyJDfFh0oAIYkO8iQ31IT7Mh+hg7043vYxS7cnPw5Xs4ipHh9FEkyyllGoBq9VWI3VgIrWrqJJdBVWUN+vaE4EeAV7Ehnpz5kBbItUzxIeeId70DPbR7j2l2oh2FyqllJNqtBpySqptLVCFVey2/7svqaptdueeq0WIDvYmJtibYTFBxO5LokJ8iA720hYppRzA10ML35VSymEarYbs4mrS7S1S6fZi812FVWQWV1Hf+Pt8rh6ulqbEaVxCWFNrVGyIDxEBnl1vomOlnJyfpxtVdY00NFqd4udTkyylVKfTfPgD2516FaQXVJFeUMHuov0TKS83F2JDfUjo5scZSd2baqRiQ3wI9/PQYnOlOhBfT1taU1nbSIC3JllKKXXMauobSS+oZGd+hW0wzvyDD3/g7mohLsSHPuF+nN6/O3GhttaouFAfwvw8dGJjpToJP3uSVVZTT4C3m4OjaWGSJSKTgBcAF+BNY8xTB6yfDjwDZNsXvWSMedO+7krgAfvyx40xb7dC3EqpLqS0up7UvApS7SOb78irYGd+BVnF1fsNytkjwIteYT5cMDyKuFAfeoXZEqkeATpljFJdgZ+TzV94xCRLRFyAl4HTgSxglYgsNsZsPmDT94wxtxzw3mDgISAZMMAa+3uLWyV6pVSnUl5Tz468CnbsLWdbrm26mG255eSV1zZt4+FqoVeYL0Oigzh/WBTxYb7Eh/kSF6p37SnV1fl52lqvnKX4vSUtWSOBVGNMGoCILASmAgcmWQczEfjGGFNkf+83wCRgwbGFq5TqDBoaraQXVLI1t5ytuWVsyy1na245WcXVTdt4ulnoE+7HmD6hJHTzo0+4L73DfYkK8sZFW6WUUgexrybLWeYvbEmSFQlkNnudBYw6yHbni8hYYDtwuzEm8xDvjTzGWJVSHVBZTT1bcsrYvKeMLXvK2LKnnO17y5uGQ3CxCL1CfRgSHci0EdH07e5PQjdfooO8tYtPKXVU9tVkdaSWrJb4FFhgjKkVkeuBt4EJR7MDEbkOuA4gJiamlcJSSrWnvPIaUrLLSMkpJSWnjJScMnYX/T76coiPO/0i/LlidE8Su/uTGOFH73BfHVNKKaC+vp6srCxqamocHUqH1Wg1vDElgkCK2LKlrNX37+npSVRUFG5uLSuqb0mSlQ1EN3sdxe8F7gAYYwqbvXwT+Fuz944/4L0/Huwgxpg5wByA5ORkc7BtlFLOY29ZDRuyStmUbXtszC7dr3YqNsSbgZEBXDwimv49/EmK8Nc7+ZQ6jKysLPz8/IiNjdWfk2NktRqsOaV0D/Ak3M+zVfdtjKGwsJCsrCzi4uJa9J6WJFmrgD4iEoctaZoGXNp8AxGJMMbssb+cAmyxP/8K+KuIBNlfnwHMblFkSimnkVdWw8bs0qakakN2Kfn2hMoiEB/my5jeoSRFBjCghz/9e/g3FaAqpVqmpqZGE6zjJAKCYLW2fluNiBASEkJ+fn6L33PEJMsY0yAit2BLmFyAucaYFBF5FFhtjFkMzBKRKUADUARMt7+3SEQew5aoATy6rwheKeWciirrbAlVZgkbskvZmFVKbpmt+0IEeof5cnKfUAZFBjAwKoB+Ef54u+uQe0q1Bk2wjo+IYLFAYxv1hx3t9WnRb0ZjzBfAFwcs+0uz57M5RAuVMWYuMPeoolJKtYuymnpby1SWLZlan1Wy3x1+vUJ9OKFXMAOjAhkYGUBSD398PDShUqor8/X1paKiAoC7776bL774gsmTJ/PMM884ODIbF0vbtGQdC/1tqVQXUVHbQIq9dmqjvYUqraCyaX10sBeDowK57ISeDIoKYEBkAP7a5aeUOow5c+ZQVFSEi4vz3LxiEaFRkyylVFspr6knJaesqSB9U7Ytodo3OnpEgCcDIwM4d2gkg6JtrVTBPu6ODVop5RTmz5/Ps88+i4gwaNAgHn30US699FIqKiqYOnVq03ZTpkyhoqKC4cOHM3v2bC6++GIHRv07F4vQaDTJUkq1gsKKWltCZR82YXNOGenNWqi6+3syIDKAcwb3aGqhau27bpRSreuRT1PYnNO6QxD07+HPQ+ckHXablJQUHn/8cZYvX05oaChFRUVMnz6dG2+8kSuuuIKXX365advFixfj6+vLunXrWjXO4+UiQn2j1dFhAJpkKdVhNFoNGYWVbNljS6S27LEN8Lm37PdhE6KCvBjQI4DzhkYyICqAAT0CCPPzcGDUSqmO5Pvvv+fCCy8kNDQUgODgYJYtW8ZHH30EwOWXX84999zjyBCPyGIRGhu0JUspdQhFlXVszS1j657fp53ZtrecmnrbX2euFqF3uC8nxYfSL8KfpEh/kiICnGLWeaXU8TtSi1N760h3PbqIFr4rpbDd3bdjr31C5L226Wa25VZQUPF761SwjzuJ3f24dGRPEiP86B/hT59uOkq6Uqr1TZgwgXPPPZc77riDkJAQioqKOOmkk1i4cCGXXXYZ//nPfxwd4hHtG8LBGOPw5FCTLKXaQWFFLal5FezMr2RHXjmpeRXs2FvRNP4UgJebCwndfDmlbxgJ3fxI6O5Hvwg/wnx1lHSlVPtISkri/vvvZ9y4cbi4uDB06FBeeOEFLr30Up5++un9Ct+dlYtFMMZgjG1sP0cS4yQV+M0lJyeb1atXOzoMpY5KfaOVzKIq0vIrSSuoIC2/0p5YVVBc9fuM8F5uLvTp5kvvcF/6hPvRJ9yXPjohslJd3pYtW+jXr5+jw+jwCitqyS6ppl+EP24ullbf/8Guk4isMcYkH7ittmQpdRSMMeRX1JKWX0l6ge2xL6naXVhFQ7M6gBAfd+LDfZk0IILe4b7Eh/nQO9yXHgFemkwppVQb2ff71Wo1tnlqHEiTLKUOYIyhqLKOjMJK0guqyCioJL2wkowC26OyrrFpW3dXC3EhPvQJ92VSUnd6hfnSK8yH+FBfLUJXSikHcLH3ETrDWFmaZKku6fdEypZEZRRW7ve8vKahaVsXixAd5EVsqA8jYoOJC/WhV5gPcaE+2iqllFJOZr+WLAfTJEt1WsYYCivr7IlTFbsKbd17uwqr/pBIWQQig7yIDfHh3JhIYkN8iA31JjbEh+hg7zbp11dKKdX6XOx/92pLllLH6VBde7sKK8koqKKidv8WqaggL3qG+DA0JnC/RCoqyBt3V02klFKqo3Oxt2Q5w6DvmmSpDqG8pp6MgirSCiqaCs73PQ7s2ouyt0gNjwkiNtTHnkz5EBXkpS1SSinVyVmkg3UXisgk4AVsdfpvGmOeOmD9HcA1QAOQD1xljNllX9cIbLRvutsYM6WVYledTKPVkFVcxc582/AHO/MrScuvIK2gkvzy3wfnFIEeAV70CvPhT0MiiQ31IU679pRSqlNYt24dOTk5TJ48+ajeN378eJ599lmGDR8OHH13oa+vLxUVFQDcfffdfPHFF0yePJlnnnnmqPbT3BGTLBFxAV4GTgeygFUistgYs7nZZmuBZGNMlYjcCPwN2Dcdd7UxZsgxR6g6nZr6RtLsg3LutA/QmZpna6Gqa9a+G+TtRq8wX8YnhNErzLep4Dwm2BtPNx3tXCmlOqN169axevXqo06y9rGIYDnOqXXmzJlDUVERLi7H913TkpaskUCqMSYNQEQWAlOBpiTLGPNDs+1/AS47rqhUp1DXYCWtoIJtubbpYrbvrSA1r4JdhZXs+79vEYgJ9qZ3uC/j+4YRH+ZLfLgPvUJ9CfJxd+wJKKVUFzN//nyeffZZRIRBgwbxzjvvkJGRwVVXXUVBQQFhYWG89dZbxMTEMH36dLy8vFi7di15eXnMnTuX+fPns2LFCkaNGsW8efMAWwvRtddey9dff0337t1ZuHAhYWFhTS1PycnJFBQUkJyczPbt2/nLX/5CdXU1S5cuZfbs2Zx99tnMnDmTTZs2UV9fz8MPP8zUqVOprq5mxowZrF+/nsTERKqrq5vOw2KRppas2NhYLrroIr788ku8vLx499136d27N+np6Vx66aVUVFTsN5L9lClTqKioYPjw4cyePZuLL76YY9WSJCsSyGz2OgsYdZjtrwa+bPbaU0RWY+tKfMoYs+hog1TOzRhDblkNW/aUsWVPOVtzy9mWW0ZafmXT4JwuFiE2xJvE7n6cM7hH0yjnsSE+2iqllFIH2vEtVOxt3X36doM+px1ydUpKCo8//jjLly8nNDSUoqIiAGbOnMmVV17JlVdeydy5c5k1axaLFi0CoLi4mBUrVrB48WKmTJnCsmXLePPNNxkxYgTr1q1jyJAhVFZWkpyczPPPP8+jjz7KI488wksvvXTQGNzd3Xn00UdZvXp10zb33XcfEyZMYO7cuZSUlDBy5EhOO+00Xn/9dby9vdmyZQsbNmxg2LBhTftxEaGxWUtWQEAAGzduZP78+dx222189tln3Hrrrdx4441cccUVvPzyy03bLl68GF9fX9atW3esn3STVi18F5HLgGRgXLPFPY0x2SLSC/heRDYaY3Ye5L3XAdcBxMTEtGZYqhU1Wg1p+RVsyillU3YZm3PK2JJbRkmzaWMiA71I7O7Haf260be7H327+xEX6qMTGiullBP7/vvvufDCCwkNDQUgODgYgBUrVvDf//4XgMsvv5z/+7//a3rPOeecg4gwcOBAunXrxsCBAwHbHIgZGRkMGTIEi8XS1Bp02WWXcd555x1VXF9//TWLFy/m2WefBaCmpobdu3ezZMkSZs2aBcCgQYMYNGhQ03tcLNC8t/CSSy5p+vf2228HYNmyZXz00UdN53XPPfccVVwt0ZIkKxuIbvY6yr5sPyJyGnA/MM4Y01SlbIzJtv+bJiI/AkOBPyRZxpg5wBywzV3Y8lNQbaXRatiZX8H6zBI2ZJWyKaeULXvKqKm31U15uFpI7O7HpKTu9Ivwp1+EP4kRfvh76kjnSil1XA7T4uRMPDw8ALBYLE3P971uaGg46Hv2TXjv6uqK1Wr7PqmpqTnkMYwxfPTRR/Tt27fFcVkOaMmSZjNFH+p5W2jJbVirgD4iEici7sA0YHHzDURkKPA6MMUYk9dseZCIeNifhwIn0ayWSzkPYww5JdV8vmEPT3y+mYteW8HAh7/ijOeXcPeHG/h4bTbuLhb+PKonz100mK9vH0vKIxP55JYxPHX+IK48MZaRccGaYCmlVAc1YcIEPvjgAwoLCwGaugtPPPFEFi5cCMB//vMfTj755KPar9Vq5cMPPwTg3XffZcyYMYCtVmrNmjUATesB/Pz8KC8vb3o9ceJEXnzxRYy9xmrt2rUAjB07lnfffReATZs2sWHDhqb3uFj2L3x/7733mv4dPXo0ACeddNJ+59UWjtiSZYxpEJFbgK+wDeEw1xiTIiKPAquNMYuBZwBf4AN7VrhvqIZ+wOsiYsWW0D11wF2JykFqGxrZlF3K6oxi1u4uYW1mMXvLbA2Q7q4WBvTw56LkaAZFBTAoKpBeoT46fYxSSnViSUlJ3H///YwbNw4XFxeGDh3KvHnzePHFF5kxYwbPPPNMU+H70fDx8eHXX3/l8ccfJzw8vCnhueuuu7jooouYM2cOZ511VtP2p5xyCk899RRDhgxh9uzZPPjgg9x2220MGjQIq9VKXFwcn332GTfeeCMzZsygX79+9OvXj+H2oRvA3pLVbAiH4uJiBg0ahIeHBwsWLADghRde4NJLL+Xpp5/er/C9NYlxgmHnD5ScnGxWr17t6DA6ldKqelbvKmJVRjFrdhWxPquUugZbM23PEG+GRgcyNCaIoTGBJHb319HPlVKqnW3ZsoV+/fo5OoxW13z8qfaSU1JNcWUdSZEBxMbGsnr16qZas+N1sOskImuMMckHbqsjvndShRW1rMoo4pe0IlamF7E1twxjwNUiDIgM4MrRPRneM5jhPYMI8/M48g6VUkqpDmLfEA6ObkjSJKuTKK2u59f0IpbvLGB5aiHb9tr6sz3dLAyLCeK2UxMYGRfMkOhAvNz1Lj+llFLto71bscA2hAOA1RgyMjLa/fj7aJLVQdU2NLImo5ifUwtYnlrAxuxSrMaWVI2IDWbKkB6c0CuYgZGB2vWnlFKqS9k3u1qj9ffnjqBJVgdhjGFrbjlLdxTwc2oBv6YXUlNvxdUiDI0JZOaEPpwYH8KQmEAdj0oppVSXZmnWkuVImmQ5seLKOn5OLWDJ9nx+3pHfdPdf73Bfpo2I4eQ+oYzqFYKvh15GpZRSah8X+93wjccxf2Fr0G9nJ2K1GjZkl/Ljtjx+3JbP+qwSjIEALzfG9AllXJ8wTk4IJSLAy9GhKqWUUk5rX0tWo7ZkdW3FlXUs2ZHPD1vzWLKjgKLKOkRgSHQgt57ah3EJYQyKCmzKypVSSqm2tGjRIs4991y2bNlCYmIiABkZGfTr14/ExERqamrw8/PjpptuYvr06cd8nIcffhhfX1/uuusutm7dyrRp0xARPvzwQ+Lj44/rHPZ9Z1q1JatrMcaQklPGj9vy+H5rHusyS7AaCPZxZ1xCGOP7hnFynzCCfdwdHapSSqkuaMGCBYwZM4YFCxbwyCOPNC2Pj49vGm09LS2N8847D2MMM2bMOO5jLlq0iAsuuIAHHnjguPcFv99dqN2FXUBlbQNLUwv4YWseP2zLa6qtGhQVwC0T+jAhMZxBkQE6orpSSimHqqioYOnSpfzwww+cc845+yVZzfXq1YvnnnuOO++88w9J1rx58/j4448pLS0lOzubyy67jIceegiAJ554grfffpvw8HCio6MZPnw4X3zxBf/4xz9wcXHhu+++44cffjju89j3faqF751UekFlU1K1Mq2IukYrfh6unJwQyil9wxnXN4xwP09Hh6mUUspJzfjfH1uIJsZOZFriNKobqrnp25v+sH5q76n8qfefKK4p5o4f79hv3VuTjjwdzieffMKkSZNISEggJCSENWvW7DddTXPDhg1j69atB13366+/smnTJry9vRkxYgRnnXUWIsLChQtZt24dDQ0NDBs2jOHDhzN58mRuuOGGpq7D1rCvzaLR2iq7O2aaZLWS2oZGVqYV8YO9aD29oBKw3Qk4/aRYTukbTnJsEG6OHLBDKaWUOowFCxZw6623AjBt2jQWLFhwyCTrcKOpn3766YSEhABw3nnnsXTpUgDOPfdcvL29AZgyZUprhr4fEbFNEq0tWR1XZlEVP27P56dteSzfWUhVXSMerhZGx4cw46RYxieEExPi7egwlVJKdUCHa3nycvU67Pogz6AWtVw1V1RUxPfff8/GjRsRERobGxERnnnmmYNuv3bt2kPOtSgif3jd3lPcuIhoTVZHUlPfyKqMIn7als+P2/NJzbNNFRAV5MX5w6I4JTGM0b1CddoapZRSHc6HH37I5Zdfzuuvv960bNy4cfz888/ExMTst21GRgZ33XUXM2fOPOi+vvnmG4qKivDy8mLRokXMnTsXi8XC9OnTmT17Ng0NDXz66adcf/31bXY+FosmWU7NGMPO/Ep+2p7Pku35rLSPsu7uYmFUr2CmjYhmfN9w4sN8/pC1K6WUUh3JggULuOeee/Zbdv755zct37lzJ0OHDm0awmHWrFmHHMJh5MiRnH/++WRlZXHZZZeRnJwMwMUXX8zgwYMJDw9nxIgRbXo+LuL47kJpSfOdiEwCXgBcgDeNMU8dsN4DmA8MBwqBi40xGfZ1s4GrgUZgljHmqyMdLzk52axevfrozqSVFFTUsiy1gKU7CliWWkBOaQ0AvUJ9GJsQxtiEUE7oFYK3u+anSimlWs+WLVsO2f3WkcybN4/Vq1fz0ksvOTSO9IJKGhqt9Onm16r7Pdh1EpE1xpjkA7c9YqYgIi7Ay8DpQBawSkQWG2M2N9vsaqDYGNNbRKYBTwMXi0h/YBqQBPQAvhWRBGNM4zGeW6srq6lnVXoRy3cWsiy1gK255YBtlPUT40O46ZRQxiWEER2stVVKKaVUR+EiQl0HKHwfCaQaY9IARGQhMBVonmRNBR62P/8QeEls/WdTgYXGmFogXURS7ftb0TrhH5sl2/NZtrOAX3YWsjG7FKsBd1cLw2OCuHtiX8b0DmVAZICOsq6UUkodpenTpx/XSPCtxWLpGEM4RAKZzV5nAaMOtY0xpkFESoEQ+/JfDnhv5MEOIiLXAdcBfyiwa21PfbmV7XvLGRIdyC2n9OaE+BCGxQTh6aYF60oppVRn4GIRnbtwH2PMHGAO2Gqy2vJYL106lO4BnlpXpZRSyqkYY/RGqlYS6utBiI97q36mRzsMRUtGxswGopu9jrIvO+g2IuIKBGArgG/Je9tdrzBfTbCUUko5FU9PTwoLC9t9PKnOys3FgrurS6smWIWFhXh6tny2lpZkGquAPiIShy1BmgZcesA2i4ErsdVaXQB8b4wxIrIYeFdEnsNW+N4H+LXF0SmllFJdRFRUFFlZWeTn5zs6FHUInp6eREVFtXj7IyZZ9hqrW4CvsA3hMNcYkyIijwKrjTGLgX8B79gL24uwJWLYt3sfW5F8A3CzM91ZqJRSSjkLNzc34uLiHB2GakUtGiervTlynCyllFJKqaNxqHGydLZipZRSSqk2oEmWUkoppVQbcMruQhHJB3a18WFCgYI2PoY6OnpNnJNeF+ej18Q56XVxPu11TXoaY8IOXOiUSVZ7EJHVB+s/VY6j18Q56XVxPnpNnJNeF+fj6Gui3YVKKaWUUm1AkyyllFJKqTbQlZOsOY4OQP2BXhPnpNfF+eg1cU56XZyPQ69Jl63JUkoppZRqS125JUsppZRSqs10+iRLRCaJyDYRSRWRew+y3kNE3rOvXykisQ4Is0tpwTW5Q0Q2i8gGEflORHo6Is6u5kjXpdl254uIERG9i6qNteSaiMhF9p+XFBF5t71j7Ipa8DssRkR+EJG19t9jkx0RZ1chInNFJE9ENh1ivYjIP+3Xa4OIDGuv2Dp1kiUiLsDLwJlAf+ASEel/wGZXA8XGmN7A88DT7Rtl19LCa7IWSDbGDAI+BP7WvlF2PS28LoiIH3ArsLJ9I+x6WnJNRKQPMBs4yRiTBNzW3nF2NS38WXkAeN8YMxTbXL6vtG+UXc48YNJh1p8J9LE/rgNebYeYgE6eZAEjgVRjTJoxpg5YCEw9YJupwNv25x8Cp4qItGOMXc0Rr4kx5gdjTJX95S9Ay6c8V8eqJT8rAI9h+0Okpj2D66Jack2uBV42xhQDGGPy2jnGrqgl18UA/vbnAUBOO8bX5RhjlgBFh9lkKjDf2PwCBIpIRHvE1tmTrEggs9nrLPuyg25jjGkASoGQdomua2rJNWnuauDLNo1IQQuui72JPdoY83l7BtaFteRnJQFIEJFlIvKLiBzur3nVOlpyXR4GLhORLOALYGb7hKYO4Wi/d1qNa3scRKljISKXAcnAOEfH0tWJiAV4Dpju4FDU/lyxdYGMx9biu0REBhpjShwZlOISYJ4x5u8iMhp4R0QGGGOsjg5Mta/O3pKVDUQ3ex1lX3bQbUTEFVvTbmG7RNc1teSaICKnAfcDU4wxte0UW1d2pOviBwwAfhSRDOAEYLEWv7eplvysZAGLjTH1xph0YDu2pEu1nZZcl6uB9wGMMSsAT2xz6CnHaNH3Tlvo7EnWKqCPiMSJiDu2AsTFB2yzGLjS/vwC4Hujg4e1pSNeExEZCryOLcHSGpP2cdjrYowpNcaEGmNijTGx2GrlphhjVjsm3C6hJb+/FmFrxUJEQrF1H6a1Y4xdUUuuy27gVAAR6Yctycpv1yhVc4uBK+x3GZ4AlBpj9rTHgTt1d6ExpkFEbgG+AlyAucaYFBF5FFhtjFkM/AtbU24qtsK5aY6LuPNr4TV5BvAFPrDfg7DbGDPFYUF3AS28LqodtfCafAWcISKbgUbgbmOMtsS3oRZelzuBN0TkdmxF8NP1j/e2IyILsP2xEWqvg3sIcAMwxryGrS5uMpAKVAEz2i02ve5KKaWUUq2vs3cXKqWUUko5hCZZSimllFJtQJMspZRSSqk2oEmWUkoppVQb0CRLKaWUUqoNaJKllFJKKdUGNMlSSimllGoDmmQppZRSSrWB/wfhkWJytXtDGwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ @@ -270,9 +332,46 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 49, "metadata": {}, - "outputs": [], + "outputs": [ + { + "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" + } + ], "source": [ "plot_transformer_density(\n", " make_transformer(d_in=1, d_out=1, d_hidden=40, n_components=4, periodic=False, zero_boundary_left=True, zero_boundary_right=False),\n", @@ -299,14 +398,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 50, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "plot_transformer_density(\n", " make_constrained_transformer(\n", " make_transformer(d_in=1, d_out=1, d_hidden=40, n_components=4, periodic=False, zero_boundary_left=True, zero_boundary_right=False),\n", - " left_bound=5\n", + " left_bound=5.\n", " ),\n", " label=\"left boundary = 5\"\n", ")" @@ -314,14 +426,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 51, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "plot_transformer_density(\n", " make_constrained_transformer(\n", " make_transformer(d_in=1, d_out=1, d_hidden=40, n_components=4, periodic=False, zero_boundary_left=False, zero_boundary_right=True),\n", - " right_bound=5\n", + " right_bound=5.\n", " ),\n", " label=\"right boundary = 5\"\n", ")" @@ -329,15 +454,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 52, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "plot_transformer_density(\n", " make_constrained_transformer(\n", " make_transformer(d_in=1, d_out=1, d_hidden=40, n_components=4, periodic=False, zero_boundary_left=True, zero_boundary_right=True, smoothness_type=\"type1\"),\n", - " left_bound=3,\n", - " right_bound=5,\n", + " left_bound=3.,\n", + " right_bound=5.,\n", " smoothness_type=\"type1\"\n", " ),\n", " label=\"left boundary =3, right boundary = 5\"\n", @@ -353,31 +491,128 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 102, "metadata": {}, "outputs": [], "source": [ "from functools import partial\n", "\n", - "flow = make_coupling_flow(partial(make_transformer, d_in=1, d_out=1, d_hidden=200, n_components=20, periodic=False))" + "flow = make_coupling_flow(partial(make_transformer, d_in=1, d_out=1, d_hidden=100, n_components=20, periodic=True, verbose=False)).cuda()" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_transformer_density(\n", + " partial(flow._blocks[3].transformer.cpu(), inverse=True),\n", + " label=\"wurst\"\n", + ")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 104, "metadata": {}, "outputs": [], "source": [ - "train(flow)" + "flow = flow.cuda()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 106, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "it: 900/1000, nll: -1.833\r" + ] + } + ], + "source": [ + "train(flow, cuda=True, train_with_inverse=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 109, "metadata": {}, "outputs": [], "source": [ - "plot_evaluation(flow)" + "flow = flow.cuda()" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computing energy plot...\n", + "Sampling ground truth...\n", + "Sampling model...\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" + } + ], + "source": [ + "plot_evaluation(flow, cuda=True, n_samples=10_000, use_log_norm=False, train_with_inverse=False, eps=0.0)" ] } ], From 218289a8c6d51237f9a89836b615ce96b2e13bcc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Mon, 17 May 2021 13:08:18 +0200 Subject: [PATCH 23/68] bugfix in cond shape --- bgflow/nn/flow/root_finding/approx_inverse.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/bgflow/nn/flow/root_finding/approx_inverse.py b/bgflow/nn/flow/root_finding/approx_inverse.py index 075a647d..b0215dd8 100644 --- a/bgflow/nn/flow/root_finding/approx_inverse.py +++ b/bgflow/nn/flow/root_finding/approx_inverse.py @@ -214,7 +214,7 @@ def backward(ctx, grad_out_x, grad_out_dlogp): create_graph=True ) - return None, None, None, grad_in_y, *grad_in_params + return (None, None, None, grad_in_y, *grad_in_params) class WrapCDFTransformerWithInverse(Transformer): @@ -263,7 +263,7 @@ def forward(self, cond, out, *args, **kwargs): def _residual(inp): extra_dims = len(out.shape) - len(cond.shape) out_pred, dlogp = self._transformer( - cond.view(*np.ones(extra_dims, dtype=int), *cond.shape).expand_as(inp), + cond.view(*np.ones(extra_dims, dtype=int), *cond.shape),#.expand_as(inp), inp, *args, **kwargs From 656e327291eb206dfde049835c62b9ba23be1c15 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Mon, 17 May 2021 13:13:18 +0200 Subject: [PATCH 24/68] ... --- bgflow/nn/flow/root_finding/approx_inverse.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bgflow/nn/flow/root_finding/approx_inverse.py b/bgflow/nn/flow/root_finding/approx_inverse.py index b0215dd8..54b5bdd8 100644 --- a/bgflow/nn/flow/root_finding/approx_inverse.py +++ b/bgflow/nn/flow/root_finding/approx_inverse.py @@ -263,7 +263,7 @@ def forward(self, cond, out, *args, **kwargs): def _residual(inp): extra_dims = len(out.shape) - len(cond.shape) out_pred, dlogp = self._transformer( - cond.view(*np.ones(extra_dims, dtype=int), *cond.shape),#.expand_as(inp), + cond.view(*np.ones(extra_dims, dtype=int), *cond.shape).repeat(*inp.shape[extra_dims], torch.ones_like(cond.shape)), inp, *args, **kwargs From 0012f1078b46c1c17f9957f21800cc0e892c9729 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Mon, 17 May 2021 13:19:57 +0200 Subject: [PATCH 25/68] ... --- bgflow/nn/flow/root_finding/approx_inverse.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bgflow/nn/flow/root_finding/approx_inverse.py b/bgflow/nn/flow/root_finding/approx_inverse.py index 54b5bdd8..b7fce0b0 100644 --- a/bgflow/nn/flow/root_finding/approx_inverse.py +++ b/bgflow/nn/flow/root_finding/approx_inverse.py @@ -263,7 +263,7 @@ def forward(self, cond, out, *args, **kwargs): def _residual(inp): extra_dims = len(out.shape) - len(cond.shape) out_pred, dlogp = self._transformer( - cond.view(*np.ones(extra_dims, dtype=int), *cond.shape).repeat(*inp.shape[extra_dims], torch.ones_like(cond.shape)), + cond.view(*np.ones(extra_dims, dtype=int), *cond.shape),#.repeat(*inp.shape[extra_dims], torch.ones_like(cond.shape)), inp, *args, **kwargs From 671636e939331c3ae80d3dab286f797ac4d4e6dd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Mon, 17 May 2021 13:26:24 +0200 Subject: [PATCH 26/68] ... --- bgflow/nn/flow/root_finding/approx_inverse.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bgflow/nn/flow/root_finding/approx_inverse.py b/bgflow/nn/flow/root_finding/approx_inverse.py index b7fce0b0..779cc3b5 100644 --- a/bgflow/nn/flow/root_finding/approx_inverse.py +++ b/bgflow/nn/flow/root_finding/approx_inverse.py @@ -263,7 +263,7 @@ def forward(self, cond, out, *args, **kwargs): def _residual(inp): extra_dims = len(out.shape) - len(cond.shape) out_pred, dlogp = self._transformer( - cond.view(*np.ones(extra_dims, dtype=int), *cond.shape),#.repeat(*inp.shape[extra_dims], torch.ones_like(cond.shape)), + cond.view(*np.ones(extra_dims, dtype=int), *cond.shape).repeat(*inp.shape[extra_dims], *(1 for _ in cond.shape)), inp, *args, **kwargs From 1c29be1a7ddeeec0d3ab932e7643f0573fa92386 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Mon, 17 May 2021 13:28:59 +0200 Subject: [PATCH 27/68] ... --- bgflow/nn/flow/root_finding/approx_inverse.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bgflow/nn/flow/root_finding/approx_inverse.py b/bgflow/nn/flow/root_finding/approx_inverse.py index 779cc3b5..2e6afd87 100644 --- a/bgflow/nn/flow/root_finding/approx_inverse.py +++ b/bgflow/nn/flow/root_finding/approx_inverse.py @@ -263,7 +263,7 @@ def forward(self, cond, out, *args, **kwargs): def _residual(inp): extra_dims = len(out.shape) - len(cond.shape) out_pred, dlogp = self._transformer( - cond.view(*np.ones(extra_dims, dtype=int), *cond.shape).repeat(*inp.shape[extra_dims], *(1 for _ in cond.shape)), + cond.view(*np.ones(extra_dims, dtype=int), *cond.shape).repeat(*inp.shape[:extra_dims], *(1 for _ in cond.shape)), inp, *args, **kwargs From 8f09e7a7a92e206f1428dc499a88d650ac95fc75 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Mon, 17 May 2021 13:40:50 +0200 Subject: [PATCH 28/68] ... --- bgflow/nn/flow/root_finding/approx_inverse.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bgflow/nn/flow/root_finding/approx_inverse.py b/bgflow/nn/flow/root_finding/approx_inverse.py index 2e6afd87..1c2c12da 100644 --- a/bgflow/nn/flow/root_finding/approx_inverse.py +++ b/bgflow/nn/flow/root_finding/approx_inverse.py @@ -261,7 +261,7 @@ def __init__( def forward(self, cond, out, *args, **kwargs): def _residual(inp): - extra_dims = len(out.shape) - len(cond.shape) + extra_dims = len(inp.shape) - len(cond.shape) out_pred, dlogp = self._transformer( cond.view(*np.ones(extra_dims, dtype=int), *cond.shape).repeat(*inp.shape[:extra_dims], *(1 for _ in cond.shape)), inp, From a66ec76e130ff7353ece88d5079b786e589267a1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Mon, 17 May 2021 13:56:38 +0200 Subject: [PATCH 29/68] ... --- bgflow/nn/flow/root_finding/bisection.py | 1 + 1 file changed, 1 insertion(+) diff --git a/bgflow/nn/flow/root_finding/bisection.py b/bgflow/nn/flow/root_finding/bisection.py index 25ca0321..069d2fb6 100644 --- a/bgflow/nn/flow/root_finding/bisection.py +++ b/bgflow/nn/flow/root_finding/bisection.py @@ -53,6 +53,7 @@ def filter_grid(f, grid): left = grid.gather(0, lidx) right = grid.gather(0, ridx) fleft = fgrid.gather(0, lidx) + lidx[-1] = 0 dfleft = dfgrid.gather(0, lidx) return ( torch.linspace(0, 1, len(grid), dtype=grid.dtype, device=grid.device).view(-1, 1, 1) * (right - left) + left, From ffa3edeb129e92b50d37ca4c7c27e81e697cee06 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Mon, 17 May 2021 13:58:55 +0200 Subject: [PATCH 30/68] ... --- bgflow/nn/flow/root_finding/bisection.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/bgflow/nn/flow/root_finding/bisection.py b/bgflow/nn/flow/root_finding/bisection.py index 069d2fb6..807166d3 100644 --- a/bgflow/nn/flow/root_finding/bisection.py +++ b/bgflow/nn/flow/root_finding/bisection.py @@ -53,8 +53,7 @@ def filter_grid(f, grid): left = grid.gather(0, lidx) right = grid.gather(0, ridx) fleft = fgrid.gather(0, lidx) - lidx[-1] = 0 - dfleft = dfgrid.gather(0, lidx) + dfleft = dfgrid.gather(0, lidx[:-1][...,None]) return ( torch.linspace(0, 1, len(grid), dtype=grid.dtype, device=grid.device).view(-1, 1, 1) * (right - left) + left, (left[0], right[0], fleft[0], dfleft[0]), From 68b8faa3c398c15c82197e020d5fb502c3e48d17 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Mon, 17 May 2021 14:06:24 +0200 Subject: [PATCH 31/68] ... --- bgflow/nn/flow/root_finding/bisection.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bgflow/nn/flow/root_finding/bisection.py b/bgflow/nn/flow/root_finding/bisection.py index 807166d3..63967bd5 100644 --- a/bgflow/nn/flow/root_finding/bisection.py +++ b/bgflow/nn/flow/root_finding/bisection.py @@ -53,7 +53,7 @@ def filter_grid(f, grid): left = grid.gather(0, lidx) right = grid.gather(0, ridx) fleft = fgrid.gather(0, lidx) - dfleft = dfgrid.gather(0, lidx[:-1][...,None]) + dfleft = dfgrid.expand_as(fgrid).gather(0, lidx) return ( torch.linspace(0, 1, len(grid), dtype=grid.dtype, device=grid.device).view(-1, 1, 1) * (right - left) + left, (left[0], right[0], fleft[0], dfleft[0]), From e5984dc67776134103fb3b3f2a00c5182444df96 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Mon, 17 May 2021 14:10:15 +0200 Subject: [PATCH 32/68] ... --- bgflow/nn/flow/root_finding/bisection.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bgflow/nn/flow/root_finding/bisection.py b/bgflow/nn/flow/root_finding/bisection.py index 63967bd5..6c51dd55 100644 --- a/bgflow/nn/flow/root_finding/bisection.py +++ b/bgflow/nn/flow/root_finding/bisection.py @@ -77,7 +77,7 @@ def find_interval(f, grid, threshold=1e-4, max_iters=100, verbose=False, raise_e raise ValueError(msg) else: warnings.warn(msg) - return left, right, fleft, dfleft + return left, right, fleft, dfleft.sum(-1, keepdim=True) class BisectionRootFinder(torch.nn.Module): From 2f373eedc7c50678ae4da865566adcc5ea3f1f70 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 18 May 2021 22:37:08 +0200 Subject: [PATCH 33/68] siren fixes --- bgflow/nn/dense.py | 14 +++++++------- bgflow/nn/flow/transformer/compact/__init__.py | 2 +- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/bgflow/nn/dense.py b/bgflow/nn/dense.py index 308927f0..83ac945a 100644 --- a/bgflow/nn/dense.py +++ b/bgflow/nn/dense.py @@ -66,13 +66,13 @@ def forward(self, x): class SirenDenseNet(DenseNet): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs, activation=Sin()) - with torch.no_grad(): - self._init_siren_weights(self._layers) + self._init_siren_weights(self._layers) @staticmethod def _init_siren_weights(layers): - linear_layers = [layer for layer in layers if isinstance(layer, torch.nn.Linear)] - for layer in linear_layers: - n = layer.weight.shape[-1] - layer.weight.data = -np.sqrt(6/n) + 2*np.sqrt(6/n) * torch.rand_like(layer.weight.data) - linear_layers[0].weight.data *= 30 + with torch.no_grad(): + linear_layers = [layer for layer in layers if isinstance(layer, torch.nn.Linear)] + for layer in linear_layers: + n = layer.weight.shape[-1] + layer.weight.data = -np.sqrt(6./n) + 2.0*np.sqrt(6./n) * torch.rand_like(layer.weight.data) + linear_layers[0].weight.data *= 30. diff --git a/bgflow/nn/flow/transformer/compact/__init__.py b/bgflow/nn/flow/transformer/compact/__init__.py index 5a102f06..cf41bf98 100644 --- a/bgflow/nn/flow/transformer/compact/__init__.py +++ b/bgflow/nn/flow/transformer/compact/__init__.py @@ -1,2 +1,2 @@ from .compact import * -from .moebius import * \ No newline at end of file +#from .moebius import * \ No newline at end of file From 6cc0ac9df9d9b87b71abc97a3afedd5d6c670198 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jonas=20K=C3=B6hler?= Date: Wed, 19 May 2021 11:53:03 +0200 Subject: [PATCH 34/68] better initialization of log sigmas --- bgflow/nn/flow/transformer/compact/compact.py | 1 + notebooks/compact/compact.ipynb | 515 +++++++++++++++--- 2 files changed, 449 insertions(+), 67 deletions(-) diff --git a/bgflow/nn/flow/transformer/compact/compact.py b/bgflow/nn/flow/transformer/compact/compact.py index 4f34dc5b..335e1e57 100644 --- a/bgflow/nn/flow/transformer/compact/compact.py +++ b/bgflow/nn/flow/transformer/compact/compact.py @@ -289,6 +289,7 @@ def _compute_params(self, cond, out): log_sigma = log_sigma.view(*out.shape, -1) if self._periodic or self._zero_boundary_right or self._zero_boundary_left: + log_sigma = -self._log_sigma_bound log_sigma = log_sigma.sigmoid() * self._log_sigma_bound min_value = torch.tensor(1.).to(out) if self._zero_boundary_left: diff --git a/notebooks/compact/compact.ipynb b/notebooks/compact/compact.ipynb index 203bbf54..28b0542c 100644 --- a/notebooks/compact/compact.ipynb +++ b/notebooks/compact/compact.ipynb @@ -10,6 +10,13 @@ "%autoreload 2" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": 2, @@ -58,7 +65,7 @@ }, { "cell_type": "code", - "execution_count": 97, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -131,34 +138,34 @@ " transformer=(\n", " t:=MixtureCDFTransformer(\n", " compute_weights=make_net(d_in, d_hidden, d_out * n_components, activation, periodic=periodic),\n", - " compute_components=MoebiusComponents(\n", - " compute_params=make_net(d_in, d_hidden, d_out * n_components * 3, activation, periodic=periodic)\n", - " )\n", - "# compute_components=AffineSigmoidComponents(\n", - "# # conditional_ramp=SmoothRampWithTrainableExponent(\n", - "# # compute_params=make_net(d_in, d_hidden, d_out * n_components * 2, activation, periodic=periodic)\n", - "# # ),\n", - "# conditional_ramp=SmoothRamp(\n", - "# compute_alpha=make_net(d_in, d_hidden, d_out * n_components, activation, periodic=periodic),\n", - "# unimodal=False,\n", - "# ramp_type=smoothness_type\n", + "# compute_components=MoebiusComponents(\n", + "# compute_params=make_net(d_in, d_hidden, d_out * n_components * 3, activation, periodic=periodic)\n", + "# )\n", + " compute_components=AffineSigmoidComponents(\n", + "# conditional_ramp=SmoothRampWithTrainableExponent(\n", + "# compute_params=make_net(d_in, d_hidden, d_out * n_components * 2, activation, periodic=periodic)\n", "# ),\n", - "# log_sigma_bound=torch.tensor(10.),\n", - "# compute_params=make_net(d_in, d_hidden, d_out * (3 * n_components), activation, periodic=periodic),\n", - "# min_density=torch.tensor(min_density),\n", - "# periodic=periodic,\n", - "# zero_boundary_left=zero_boundary_left,\n", - "# zero_boundary_right=zero_boundary_right\n", + " conditional_ramp=SmoothRamp(\n", + " compute_alpha=make_net(d_in, d_hidden, d_out * n_components, activation, periodic=periodic),\n", + " unimodal=True,\n", + " ramp_type=smoothness_type\n", + " ),\n", + " log_sigma_bound=torch.tensor(1.),\n", + " compute_params=make_net(d_in, d_hidden, d_out * (3 * n_components), activation, periodic=periodic),\n", + " min_density=torch.tensor(min_density),\n", + " periodic=periodic,\n", + " zero_boundary_left=zero_boundary_left,\n", + " zero_boundary_right=zero_boundary_right\n", "\n", - "# ),\n", + " ),\n", " )\n", " ),\n", " oracle=GridInversion(\n", " transformer=t,\n", - " compute_init_grid=lambda x,y: torch.linspace(0, 1, 100).view(-1, 1, 1).repeat(1, *y.shape).to(y),\n", - "# compute_init_grid=AffineSigmoidComponentInitGrid(\n", - "# t._compute_components\n", - "# ),\n", + "# compute_init_grid=lambda x,y: torch.linspace(0, 1, 100).view(-1, 1, 1).repeat(1, *y.shape).to(y),\n", + " compute_init_grid=AffineSigmoidComponentInitGrid(\n", + " t._compute_components\n", + " ),\n", " verbose=verbose\n", " )\n", " )\n", @@ -196,7 +203,7 @@ " InverseFlow(SplitFlow(1))\n", " ])\n", "\n", - "def train(flow, dataset=\"pinwheel\", train_with_inverse=False, batch_size=1_000, learning_rate=1e-3, n_iters=1_000, print_interval=100, cuda=False):\n", + "def train(flow, dataset=\"rings\", train_with_inverse=False, batch_size=1_000, learning_rate=1e-3, n_iters=1_000, print_interval=100, cuda=False):\n", " optim = torch.optim.Adam(flow.parameters(), lr=learning_rate)\n", " for it in range(n_iters):\n", " x = (inf_train_gen(dataset, batch_size=batch_size) + 4) / 8\n", @@ -213,7 +220,7 @@ " \n", "\n", " \n", - "def plot_evaluation(flow, dataset=\"pinwheel\", train_with_inverse=False, n_samples=100_000, use_log_norm=True, cuda=False, eps=0.):\n", + "def plot_evaluation(flow, dataset=\"rings\", train_with_inverse=False, n_samples=100_000, use_log_norm=True, cuda=False, eps=0.):\n", " \n", " print(\"Computing energy plot...\")\n", " with torch.no_grad():\n", @@ -240,7 +247,7 @@ " norm = None\n", " plt.figure(figsize=(8, 8))\n", " plt.title(\"Energy\")\n", - " plt.imshow((-u).exp().detach(), norm=norm)\n", + " plt.imshow((-u).exp().detach().T, norm=norm, origin=\"lower\")\n", " \n", " print(\"Sampling ground truth...\")\n", " if use_log_norm:\n", @@ -274,6 +281,35 @@ " plt.hist2d(*x.detach().numpy().T, bins=100, density=True, norm=norm, range=((0, 1), (0, 1)));" ] }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['swissroll',\n", + " 'circles',\n", + " 'rings',\n", + " 'moons',\n", + " '8gaussians',\n", + " 'pinwheel',\n", + " '2spirals',\n", + " 'checkerboard',\n", + " 'line',\n", + " 'cos']" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset_names" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -283,12 +319,12 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -300,7 +336,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlkAAADSCAYAAAB5ENV1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABRPUlEQVR4nO3dd3hUZfbA8e+Z9N4DIYWEQAiETgBRBMQCosLa0bWAvYH9p1jWvurq6rp2dBFxV7CtiG3tihQRkBpqSAIphPTeM+/vjxliQEqAJDNJzud55mHm3jv3njuXZE7e99z3FWMMSimllFKqdVkcHYBSSimlVGekSZZSSimlVBvQJEsppZRSqg1okqWUUkop1QY0yVJKKaWUagOaZCmllFJKtQFNspRSnYqIxIhIhYi4ODqW4yEifxaRr4/xvQ+LyL/tzzvF56FUR6RJllLKaYjIdBFZejz7MMbsNsb4GmMaW3C8WBExIuJ6PMdsC8aY/xhjzmiF/bT481BKtS5NspRSHUpXaJFxxqRPKXX0NMlSqhMSkQwRuUtENohIqYi8JyKezdZfKyKpIlIkIotFpMdh9jVGRJaLSImIZIrIdPvyABGZLyL5IrJLRB4QEYt93XQRWSoiz4pIsYiki8iZzfY5XUTSRKTcvu7PItIPeA0Ybe/eKrFvO09EXhWRL0SkEjhFRM4SkbUiUmaP6eFm+96vdUpEfhSRx0Rkmf14X4tIqH3zJfZ/S+zHHC0ivUXkJ/vnViAi77XwM59uP8ZL9vduFZFTm60PEJF/icgeEckWkcf3JYzN3vu8iBQCDx/YqiciJ4rIKvu+V4nIic3WxdljLheRb4DQZusO/DyCReQtEcmxX5tFLTk/pdTR0yRLqc7rImASEAcMAqYDiMgE4En7+ghgF7DwYDsQkZ7Al8CLQBgwBFhnX/0iEAD0AsYBVwAzmr19FLAN2xf+34B/iY0P8E/gTGOMH3AisM4YswW4AVhh794KbLavS4EnAD9gKVBpP14gcBZwo4j86TCfxaX22MIBd+Au+/Kx9n8D7cdcATwGfA0EAVH282ypUcBO+zk/BPxXRILt6+YBDUBvYChwBnDNAe9NA7rZz7WJfR+fY/vcQoDngM9FJMS+ybvAGvtxHwOuPEyM7wDeQBK2z+P5ozg/pdRR0CRLqc7rn8aYHGNMEfAptgQJ4M/AXGPMb8aYWmA2ttaj2IPs41LgW2PMAmNMvTGm0Bizzt4CMw2YbYwpN8ZkAH8HLm/23l3GmDfstUBvY0voutnXWYEBIuJljNljjEk5wrl8YoxZZoyxGmNqjDE/GmM22l9vABZgS/QO5S1jzHZjTDXwfrPP4mDqgZ5AD/uxjqZGLA/4h/2zeg9bknmWiHQDJgO3GWMqjTF52JKbac3em2OMedEY02CPs7mzgB3GmHfs6xcAW4FzRCQGGAE8aIypNcYswXa9/0BEIoAzgRuMMcX2OH86ivNTSh0FTbKU6rxymz2vAnztz3tga70CwBhTARQCkQfZRzS2lpkDhQJuzfdjf958H03HN8ZU2Z/6GmMqgYuxtVrtEZHPRSTxCOeS2fyFiIwSkR/sXZWl9n2FHvyt+8fC/p/FwfwfIMCvIpIiIlcdIbbmso0xptnrXdg+757YPq899m7XEuB1bC1J++x3jgfY75o123ekfV2x/XNtvu5gooEiY0zxkU5EKXX8NMlSquvJwfalD4C9+y4EyD7ItplA/EGWF/B7i88+MYfYxx8YY74yxpyOrXVrK/DGvlWHessBr98FFgPRxpgAbLVc0pJjH2G/GGNyjTHXGmN6ANcDr4hI7xbuL1JEmscRg+3zzgRqgVBjTKD94W+MSTpcLM3sd82a7Tsb2AME2a9j83UHkwkEi0jgkU9FKXW8NMlSqutZAMwQkSEi4gH8FVhp7/I70H+A00TkIhFxFZEQERli7wJ8H3hCRPzstVt3AP8+0sFFpJuITLUnBbVABbbuQ4C9QJSIuB9hN37YWmRqRGQktm7NY5FvP3avZvFdKCJR9pfF2JIfq33dj82L7A8iHJglIm4iciHQD/jCGLMHW53X30XEX0QsIhIvIofr4mzuCyBBRC61X4eLgf7AZ8aYXcBq4BERcReRMcA5B9uJPY4vsSWOQfY4xx5sW6XU8dMkS6kuxhjzLfAg8BG2VpB49q8Nar7tbmy1RHcCRdiK3gfbV8/EVoCehq0Y/V1gbgtCsGBLyHLs+xwH3Ghf9z2QAuSKSMFh9nET8KiIlAN/wZbwHTV7N+YTwDJ7N94J2OqbVopIBbbWsluNMWn2t0QDyw6zy5VAH2wtfU8AFxhjCu3rrsBWdL8ZW/L2IbaWvJbEWQicje06FGLr0jzbGLPvM7oUW+F8EbaC+/mH2d3l2Foht2KrIbutJTEopY6e7F8+oJRS6mDsrVvvG2NOPMT66cA1xpgx7RqYUspp6YB3SinVAsaYLGzDTSilVItod6FSSimlVBvQ7kKllFJKqTagLVlKKaWUUm1AkyyllFJKqTbglIXvoaGhJjY21tFhKKWUUkod0Zo1awqMMWEHLnfKJCs2NpbVq1c7OgyllFJKqSMSkYNOZaXdhUoppZRSbUCTLKWUUkqpNqBJllJKKaVUG9AkSymllFKqDThl4XtHV11bxvLti1iRvZRaax2C8FDc+biIhf8VbqDaw5vxfS8gyK+Ho0NVSimlVBvRJKu1NNRCYSr/3fIuT+3+gmrTgK+44ePiDoAJSAMR1uev49+lKVhS3mSYTxSnRZ7MhITziAjp6+ATUEoppVRrcsppdZKTk01HGcKhrq6Kfy1/hIn1bvRy9WFdYwWfNeRzWtxkkuMn4+rqvt/2xmplc9ZSvktdzPd7V7Gzroh+bkG8P3AW9D4NvAIdcyJKKaWUOiYissYYk3zgcm3JOg7r0r/h4V8eZ2ddEW5Rp9Nr6PUMCYhiiMgh3yMWC0kxY0mKGcssIGPvekpy10JxOpUrX+FD13ouGXk37u7e7XciSimllGp1mmQdg8rqIv655H4W5C6lm6svr4x8kJP7XXRM+4rtNhi6DYaaUr5b+Xee3fkxH+z+hvuG3c6Jiee3cuRKKaWUai96d+HRKs1i/nd3siB3KZd0H8Oi8z4/5gRrP54BTBn3KK+NfAiA61c+zAOfT6eurur4962UUkqpdqc1WUehoWAHrpsXUeXqwY6IfgyOO71NjlNXV8VrS//CG5lfcVHwEB6c+Dpo96FSSinllA5Vk6UtWS309fq3uPDrGRS4eeA9/Ko2S7AA3N29mTXhWZ4bcgfXesfDb/OhsrDNjqeUUkqp1qdJVgt8vPqf3L3uefzcfHEfdAl4+LbLcU8fPIPuydfQ2FDN/f+7hl93LG6X4yqllFLq+B0xyRKRuSKSJyKbDrF+vIiUisg6++MvzdZNEpFtIpIqIve2ZuDt5e1lj/GXlDcY7RfHa+e8h79PWPsGEBBFSdJUNtUVcv3yB/hk9Uvte3yllFJKHZOWtGTNAyYdYZufjTFD7I9HAUTEBXgZOBPoD1wiIv2PJ9j29t7yJ3k29X1OD+zPi2cvxNszwCFxhAT14p0pH5Hs25MHU17n099edUgcSimllGq5IyZZxpglQNEx7HskkGqMSTPG1AELganHsB/H2LuZ06pquLnHBJ4569+4uXs5NBx/nzBePPtdRvj25MGNr/LdxnccGo9SSimlDq+1arJGi8h6EflSRJLsyyKBzGbbZNmXHZSIXCciq0VkdX5+fiuFdWzSs36hfsunhAT35oYJf8fF1c2h8ezj6eHHi5P/zWjfWEJyNkBRmqNDUkoppdQhtEaS9RvQ0xgzGHgRWHQsOzHGzDHGJBtjksPC2rnuqZnMvI1c+cNMnij5DQacDy7ONV6rt1cgr055jyHBibDpIwpy1zk6JKWUUkodxHEnWcaYMmNMhf35F4CbiIQC2UB0s02j7MucVmnlXm767iasGGaMvt95x6Zy84LB0/iwOpNzvr6KlF0/OToipZRSSh3guJMsEekuYpusT0RG2vdZCKwC+ohInIi4A9MApx2DoL6+htu/vIqsujL+MfpRenYb5OiQDs/dhzEjZhHg4skNS+4kMz/F0REppZRSqpmWDOGwAFgB9BWRLBG5WkRuEJEb7JtcAGwSkfXAP4FpxqYBuAX4CtgCvG+McdpM4OnvZrGqcjePDryB5N6THR1Oi3QP7s3rp72GFcPMb2+ivEoHLFVKKaWchU6rA5C7ka3r32GVlyeXj320/Y7bSn7dsZjrlz/AKL9evDL1QyxOVkemlFJKdWaHmlany38bV5bsxmf7/0gMH0Ti4EsdHc4xGdlnCg8Up2LZuxlL+o/Q+zRHh6SUUkp1eV16Wp2qmlIu+9/l/KN4PfSfCpaO+3GcP/IOzk28GDJXUbZrmaPDUUoppbq8jptVtIInv7uVnbVFjOx7Lnj4OTqc4xd/KqvcLEz8aSardnzq6GiUUkqpLq3LJlmfrH6JRQVruDZmEicmnu/ocFqHxULi0KsJd/Pl9l8eIbtgi6MjUkoppbqsLplkpeb8yuOb32SETww3nfxXR4fTqvx8Qnnx1JewYrjju5nU1lU6OiSllFKq/TXWQ02pQ0PoekmW1UrOlkWEu/rw9GkvOc2UOa0pJnwQTwy7g801e3ny25mODkcppZRqd9s3/Ju05c9BfbXDYuh6dxdaLIwdcjUncjWugXGOjqbNnJL0Z67d+xvVJbuwZv+GJXKYo0NSSiml2kfBDhJKcsntNtA2S4qDdL0kCyAkvkuc+Mxxf0M2vg+p34FfBPhHODokpZRSqk0VlOwibe0bjAzsS/fEPzk0lq7XXdiFiIsL9J9CirWCGf+bTmlFrqNDUkoppdqMsVp54PtbuWXPNxTHjwcHD86tSVZn5+6DNW4c66tzuefrG7BaGx0dkVJKKdUm3l35N5aV7+T2hGkEBcc7OhxNsrqCgbETuDfxcpaV72TOzw86OhyllFKq1aXm/Mpz2xdwsn9vpo2829HhAJpkdRkXjriDs0OG8ErGp6zY9rGjw1FKKaVaTV1dFfcsuQdfF3cenfAC4iQzuDhHFKrNicXCg6e9RLxHMB9vmgc1ZY4OSSmllGoVrruWcZ53Tx4bdhehATGODqdJV7jJTtl5ewbwxulvELRpEWz+BIZcChYXR4ellFJKHTNr4U4sWav5c+IlkDDR0eHs54gtWSIyV0TyRGTTIdb/WUQ2iMhGEVkuIoObrcuwL18nIqtbM3B1bEJDEnBJPIv8oh18uOJJR4ejlFJKHbPSilzO//oqlljLIH6Co8P5g5Z0F84DJh1mfTowzhgzEHgMmHPA+lOMMUOMMcnHFqJqdd2S+Lcp4ZHU9/h+078dHY1SSil11IzVyqPf30ZGXTEhfc4EF+ebweWISZYxZglQdJj1y40xxfaXvwBRrRSbakM3j3uKJM9uPLD2eTLzNjo6HKWUUuqofLbuNb4uTuHmuKkkxYx1dDgH1dqF71cDXzZ7bYCvRWSNiFx3uDeKyHUislpEVufn57dyWOpA7u7ePDvhBQS444dbqaktd3RISimlVItkF2zhiU1vMsw7ihkn/sXR4RxSqyVZInIKtiTrnmaLxxhjhgFnAjeLyCFTTWPMHGNMsjEmOSwsrLXCUocRFZbEk8P/j201+bz602wwxtEhKaWUUodntfK/NS8D8NdTnsPF1fm6CfdplbsLRWQQ8CZwpjGmcN9yY0y2/d88EfkYGAksaY1jqtYxtv/FPF2ezYkV5bBnHfQY6uiQlFJKqUPL/IWr3SOZfPLfiQjt5+hoDuu4W7JEJAb4L3C5MWZ7s+U+IuK37zlwBnDQOxSVY5054jYCQhOp2/4/duescnQ4Siml1EFt3vUjO7Z9CuGJRMSOd3Q4R9SSIRwWACuAviKSJSJXi8gNInKDfZO/ACHAKwcM1dANWCoi64Ffgc+NMf9rg3NQx8tigX7ncG/hL1zzwyyKy3McHZFSSim1n/LKAu5Ydj93Fi6lsfcZIOLokI5IjBPW4SQnJ5vVq3VYrfaWsusnLv9xFiP8YnllyodO3c+tlFKq6zBWK/d8fhlfF21i3snPMqTXGY4OaT8isuZgQ1XptDqqSVLPcdzX70qWl6fx4k//5+hwlFJKKQA++e1lvizayE2x5zhdgnU4mmSp/ZyffBsXhI/iX1nf8uW6NxwdjlJKqS5u9971/HXzXEb4xHD1SQ87OpyjokmW2o9YLNx32ktMDRpAYsEuKNvj6JCUUkp1VY0NROxayWUBSTw54Z8droxFkyz1B25unjw+6U3ifHpgNn5IVcVeR4ek2kNjPQVFqaxP/5a0Pb9RW1fp6IiUUl1czY6vcassZNZJD9EtON7R4Ry1VhknS3VC7j4w4Hye+OZmtnzxKW/9aRHu7t6Ojkq1kqz8FH7YsYilub+SU1vEfyOn4NbYwOtFq1hYsaNpu3BXH3p6hPBG/+txCYzGhCQgHj4OjFwp1VV8s2Eez2x4lTcH3UpMaB9Hh3NMNMlSh+bXjVG9z+a9tX/n0W9u4rEz5yIWbfzssMr3snzHJzy3fQHbagsAiHcPJsEnkpqwvrh5h3JBZBIn11dRWltMVtlusipzqKyrwKU4A/amcGfBA9S6enBmzzOY0G8a3l6BDj0lpVTnlJ67lgfX/ZN4z1AiEs91dDjHTJMsdVinD5rOjYVbeHX3F8Qvf4wZYx5ydEjqKK3a8RmhhenEVVfgU1eIj4snd8VfyCkJfyImfNB+2/a1P/7AGKjYS9yqAhbvWc6SjS/juek1JoYM4YaRdxMVltQep6KU6gKqqku4/YfbcBcX/n7aS7i5ezk6pGOm42SpI7JaG/m/zy7jq+JNPD1oJpOHHnaub+UEjNXKyh2LeW3jHNZUZnK+f18eTv4/6JZk6wo+DlZrI+vSv+Hz7R/xSf4qrvTvz8z+06HnaPDwa50TUEp1SfvGw/qqaBOvn/AoJ/T9k6NDapFDjZOlLVnqiCwWF56Y9CY1n/2ZwL2boTgDgmIdHZY6hA3p3/HM6r+xriqHcBdv7k34M+cPu7nVEiCLxYVh8ZMYFj+J64p24rNnI+SsZUna56xxs3DVqHsI8O3eKsdSHURDHY1lmfxr41wyyndT01hHjbWOWms9o31iuCZsFHgFMb9oLRH+PYkL7U9M6ACt81R/UJO5guKqfGbGTe0wCdbhaEuWarn6alj7b6gto2rA+XhrouVc6msg/Sf+tulNvqrazbW9z+fcYTfjcZwtVy1SVcTLyx7m9Zwf8Ld4cE/S1Zw95Hqt4euk6htqWLrtI37e/SO+jfXc4ZsIxjAp+xMaRfCxuONhccPT4sbJAX24JvwEqirzOCH1X+z7xnHFwon+8VyRcBGjEv4Ebp6OPCXlDEoyYd27NAbHIQPOx2JxcXRELXaolixNstTRqSnl4x/u5+Wi1cyf9DY9Qg5awaPakbFa+XrjPMIKdjLMxY+q7gOx9jwBX6+Qdo9lW/YKHlv+MOurchjj35uHxj1N9+CEdo9DtY303LV8vGkei3NXUNhYjZ/FnfEBffnrwBvBvwe1PiF4eAYe8v1VNaVk5G0gvXAzKQUb+TZvDbf4D2CKfx/y/cL4hRpOT7oMT+127nL2Fu3kbz/cwb3dxhI26uYOl3RrkqVazY7slVz5/U2Eufow/5z3tWvIgfYUbuOxJffyc1kqZ/r35W+nvgj+EQ6NqbGhnoWrnuWFHe9zT8hIzh9yHfQY1iEmc1V/1NhQj0vBNsj5jb9lLObd8u2MDUjgvD7nMabvBbi6uh/zvo3VSmNpFq6F23lv+0c8nr+UUBcvpseezYXDZ+ndq11EVXUJ0xefz67aIt459VUSIk9wdEhHTZMs1apW7fiU65c/QD+vbrx+zgKHtJp0ZcZq5bN1r/HXTW/SiGFW7wuZNvKu4/rCa225hdvotnsNUrKLpS4N9Op/IT1CEx0dlmohq7WRrze8xStb5vNA4DBGBvenILgnhCUSGtizTY63KvUz3tj4JisrMgi0eHBFz0lcc8L9SAe+u0wdXmNDPbd9dglLSrfz4oj7Gdv/YkeHdEw0yVKt7ruN73DXb8+Q5B3BW1P/i1t71P4oqK/mu5XPc9vOBQz1juSv4//uvEMoGENdzhrO/OFmqk0Dfxl0E5MGX+3oqNRhGKuV71Le4eWUt0itLaS3RzD3DZ7FiMTz2q01cl36N8xZ9wqWuipe6jERep6IiUxGXPRerc7m2W9m8XbOD8xOuIxLR9/j6HCO2XElWSIyFzgbyDPGDDjIegFeACYDVcB0Y8xv9nVXAg/YN33cGPP2kY6nSVbH8e3Gt8lO/54ro06DQReBq4ejQ+rUSnM3EJD2E411lXzm5cbZw2d1iLm8MvNTuPeH29lQvYc/hQ1n9in/0K4gJ2RKMrnh2xtZXrmLWPdAbup3BRMHXeWwAuS6kt24717JrtzfuLPoF+4YOpMT+57nkFhU66vYtYyLl97FmNAhzJ74qqPDOS7Hm2SNBSqA+YdIsiYDM7ElWaOAF4wxo0QkGFgNJAMGWAMMN8YUH+54mmR1MHlbYfMnbHNzJXrY1frl2Qbq6qp4/se7+WLvSj6Kv4zQgdPAr2PVwtU31PDakgd5I/N/xLgFsGDiPPxCejs6LAUUlu4mKHsdlr0pfFq7BxPWl8mDr3Wa7uf1qV8w+9cnyKwv4/TA/tw95lEi9Kabjq0oDTZ8QKl/d3wGXeI0/9eO1aGSrBbdX22MWQIUHWaTqdgSMGOM+QUIFJEIYCLwjTGmyJ5YfQNMOvrwlVMLT6S8z2lcnfYuN35+CVXVJY6OqFNJ27OGS/97Fv/es4SJ4cn4Dr+6wyVYAG6unsyc8Az/OvFJJvrF47fxI9i90jaavHKI+oYa3l72GGd98ic+TvsUeo7mnNOeZcrwm53qS29w78l8fMHXzIqbys+l25jy+cXM+/kRsFodHZo6Blszl/HET/dQ7x1IwKBpTvV/rbW11iA2kUBms9dZ9mWHWv4HInKdiKwWkdX5+fmtFJZqL36Rw3lg4I2sq8zmxs8uobQi19EhdXjGauWDX5/j4m+uJq++gpeT7+e+ia91+NvbR/Q5m5mTXoPQ3mzZ8iG3fXIhxeXZjg6ry1m7839c+MFEnk19n6F+PRk+4hboNR6c9AvPw92Ha8c+zuKz3uOkgD7szd8Ia+dDhX5fdCRpe9Zw3Y+38WNVFsV9TjvuEhNjDJlFVXyyLps1uw7XFuQYTlNFaIyZA8wBW3ehg8NRx2DSkGsQsTB73Qtc8elFvHr6HL2b7FjVV8PWz1mR8S1DfWN4YsILhAXGOTqq1uPmBUnnsbMmhyUpX3PBJ+fx1KgHGdHnbEdH1vnV1/Dakvt5Oetrerj68c/kexnf75IOM3BsREhfnj/nPRrzNkPqt/y27GlWe3ow46QHcXPtWGMrdTWZeRu55rubcBHhzdNeJzwo/qj3UVPfSEpOGWt3F7Nml+2RV14LQO9wX769Y1xrh31cWivJygaim72Osi/LBsYfsPzHVjqmckITB19FsHc4t/7yEPOXPsy9p74Aft0cHVaHsmLbx0TsSSFW3HlixL149DypQ4183GIinJ08k97dhnH30nu5Zvl9XJ/1M9ed/Fin7j5wFGO1Ys3fgkvqdwysq+eKHuO5ecxjHbKGUiwWXLsPgOA4fvz+Tt7K+Ipvc3/h8TFPdMgxlrqC3KLtXPPN9dSbRt469RV6dht0xPc0Wg1p+RWsyyxhfVYJ6zNL2bKnjAarrR0mOtiLE+NDGN4ziJ+257Mus7StT+OotXgIBxGJBT47ROH7WcAt/F74/k9jzEh74fsaYJh909+wFb4ftk1PC987vl171tIj/WfcGuqo7z8Ft1Ad9ftIamoreOGne/j3niVM9k/g6VNfcvjAou2lqrqEx7+bxaeFa3mwxxlcNOZB6IBf/s4qp2Arf/35PhJwZ1b0GZBwZqf6v/Xtxrd5bP1LlDXWcUuvPzF99AMd4q7bLqO2gnXLn+Wu7C/559hn6R9z8h82qW+0kpZfycbsUjZll7Ixu5TNOWVU1zcC4OfhyqDoAAZHBTI4OpCh0YGE+//ecvnkF1uYtzyDbY+f2W6n1dxxTRAtIguwtUiFikgW8BDgBmCMeQ34AluClYptCIcZ9nVFIvIYsMq+q0ePlGCpzqFnxFAI7k3Jb/OY8fVVXJlwMX9KnunosJzWtszl3LtsNqm1RUzrdhJ3nPI38PB3dFjtxtsrkL+ePZ8zNrzNSSV5sPpfFPYcTUjMiY4OrUNraKjj3ZXP8NLODwEY3ftCGDYdOkjXYEudNvBKhseezmPf384/0v5LWF0NU0bfA97Bjg6ty6upKsRz038Z4uLDF5MX4B7ci9KqerbmlrFlTxmb7Y/tuRXUNdpuZPB2dyGphz8Xj4hmYGQAg6MD6BXqi8Vy6HHafD1cqW2wUtdgxd3Vef5/62Ckqk1VVBdy+xfT+aUigwvDT+CeU//RPhMWdxRWK79ueJvr1/+DQBcPHht+N2P6XejoqByrupjSje9z3vZ/MTKwL/ed8jx+PqGOjqrD2ZG1ggeWPcjmmr2c7N+bB05+stPXSBqrlZ9T/sNJxXtxAbIiBxEZd1qHqTfrbNJzt3LTt9dwhvTE02sGv5T4sy23nNyymqZtQnzc6d/Dn/4R/vSL8GdApD9xob64HCahOph5y9J5+NPN/Pbg6QT7tH+5wXG1ZCl1rHy9Qnh16ke8+NM9zM36lo0fn8PfT/kHMeFH7o/v7OpKMnFP/ZZBpVlcFJbMDSc/RpBfD0eH5XheQfgMm8EFVRm8vutz1i6awuOjHiC592RHR9YxNNRBxs+YtG8oaqjgmSG3MXHgjC6RaIjFwtiBl0NNKcWbPuSS5feRtP4VHhn/d7oFH32RtWqZ0qp6UvMr2Gl/7NhbQXbBbxQHzqHB0siCzP6U1NXTO7yW0fEh9O3uR9/ufvSP8CfczwNphZkE/Dxt3cMVNQ0OSbIORVuyVLtZkrKQ+357lkEeYbwy/nkI79x/VR9KbV0lry19kG/3rOT9mPPw6jsZwhJ1AuWDWJf+DbNXPExWfRkXdzuRe055DjcPbQk9GGO18vXGeazP+Jb/8x8IPYZQHzsGtw4+5MexslobWbjyWZ7fsQA3cWF20jWcPeT6LpFstoW6BiuZxVWk51eSXlBJWkElafkV7MyvpKCitmk7dxcLSd12kO0/DzexcEOvRxjddyyxIT64urTdZ/9VSi7Xv7OGz2aOYUBkQJsd51C0JUs53NikaXzQfSguO76FlI8pyEvAu/dpeHu2/w+Eo6zZ+QUP//okGXUlTAkdRsOwK8AnzNFhOa0hcafzUcRIXlxyH7tLUnFdMw8SJ0NwJxrOohWk7fmNJ5c/xC8VGSR6hlE15hG8Q/rQlUu/LRYXLh19Dyf1OpP7l9zNfRtf4bvM73n6jNfx8NJarYOpb7SSVVxNRmElGQX2R2EVGYWVZBVX02j9vVEm2MeduFAfJiSG0Tvcl/gw28OzZjNTv7+PEFdv5pw+h+h2mlfVz9OWzlTUNrTL8VpKW7JU+7M2QtoP3LLmGXY0lHP/0Fs77MzrLVVVlsPDP93Fl0UbiXT14y/D7+TExPMdHVaH0liyC5dtX5Fdtou3GvKZNfYJ/Lt4glpVXczryx9lftb3eFlcmdn7Ii4acYfeWXeAxoZ65v/yV7bnruGv3U5B+p7ZZVvSy2vq2V1URWZRFbuLqthVaH8UVZJdXE2zPApfD1diQ73pGeJDXIgPvcJ8iAu1PQK9D9Ilt2c9bP+KxXV7OXHELEIDe7bbeW3MKuWcl5byxhXJnN6//YcNOq65C9ubJlldw287v+SRX58kra6YiUEDuGfsk4QFxjo6rFZlra/BkrkSs3sl1+79hiFhQ7hq9P0dcmwip9DYwKKVz/LQjncJdPFgZsIlnDtsZtdLKqyNsGcdxTu/5ayM9zg1dBC3jXmMEP/oI7+3CzPleci2z0kv2s6rNRncPfavnWuQX2ytUXtKasgsrtovmcosqiKzuJqiyrr9tg/ydiMmxIeewd7Ehnjbnod4ExviQ6ive4vqperqq/nbd7dyuvFiVMQJkHQuuLXvwLAZBZWMf/ZHnrtoMOcNi2rXY4MmWcpJ1dVVMXfF47yR8TkeFldeGHonI/pP6/C3mDc01PHputeYu/193gqfQGiP4Zi4cYgmV61ia+Yynlz5OL9VZpHoGcY9w+/qEoXxxmrl203z+SZ1MU8FJmMJ6klR1FCCw/o7OrSOw9rIl6tf4sGtb+EuLtyVeDnnDp/VYWq1rFZDQUUtmcVVZBZV25Mn+/PiKvaU1uzXredqESKDvIgO8iYmxJuY4N8f0cHeBHgd3x8oe4t2cse3N7Kheg+zep7NtWOfcMjv74KKWpIf/5ZHpyZxxejYdj++1mQpp+Tu7s0N4/7KpMSLeXHF4yTs3QGVb5DbLZGwqBM7XAtFXV0Vn6x9lbk7/0tWfRmDvCIoSzyT0KjRaFl760mMPol5kZ/z1ca3+PumN/lq/Zsk19ZCr1M65SCmxmpl5Y7FvLThVdZX5RDvHkxhwmmERY4gWG+YODoWF84ceSv9e57Cwz/fy0Ob/8Xnu7/loZP/6hR3PRtjKK6qJ7OoiqziansC9fvz7OJqahv2nxg7zM+D6CAvhvcMIjrIm+hgL6LtiVR3f882Kzhfs/ML7lzxMFXWep4dcgcTB89ok+O0xL6arPIarck6Im3J6qKMgYLtWNOXcGHqfOpFuCHxMiYOnOH8yVZDHVWZvzBl+f+xt6GSAV7dubb/lYzvf0nnnBLHiVTXltG4+xd8c9bza3UOn1lLuDb5DqLDBzo6tONnDHsyl3PHLw+zqTqXcBdvbu57CVOG3qRTD7UCq7WRj1e/yN+3vcOFvn24fchNEDMaXNr2901lbcNBW6Ky7AlVZV3jftsHerv9njwFeRMV5EVUsDfRQV5EBnrj5d7Ov2OsVrZt+Yhpqx8jyj2Af4x/nviIPzTitLuE+7/kqjFx3Htm+9fbaXeh6jCs1ka+3TifV7fMI7W2iF7uQVwSdzZnDrySAB/nmgdxW/YK1u78immWANvEu7WZDI47nRP6TO0w3Q+dRk0ZC399jmfSP6YRw+SQIVwz/DZ6RQw78nudTH1DDZkZP9KrKJP6ijyuL1jCmbETmTLkeh3Mtw3klaThk7kan4KdrLJWUBQazxkDpx/zz3Cj1bCntHq/mqjdRbbXWUVVFB5QF+Xt7tKUREUF2brxooNsrVFRQV5NY0A5g6rSTLxTv8OU5vAvaz4Xj77faQYLHv7YN0wa0J0nzm3/P7A0yVIdjtXayNcb5/Gvrf9ha00+T4aO4ey4SdSGJeIW0tthLUSlFbl8vvFtFu3+mi01eXiIC98NuouAuPEQ0P4Fl2p/+SXpzFv1HB/sWUqNaeDS8FHcO3I2BMU5fa3f7rwN/HfjW3yyZxkW4Ms+V+EeezKE9XP62DuFkt3c9cNtfFW2g5E+Mdwz+sFDTjhdU99Ipv3uvIzCyqY79XYXVZFVXEV94+/frS4WITLQy14HZUuk9tVERQd5EezTsgJzR2psqOftFU/wdsbnLIyaQkT/8yG8n1ON7zf+mR8YHB3IC9OGtvuxNclSHdqWzKXEVZTiWbCNfxWt5YOKnZwSNpQTIscwoteZbXq3nrFaaajIxa1kNz9lfM3t6R9Rj5VEzzD+FHMGZw24kkC/zjPZbmdRVJbF/FV/J6ymgj9796LO3Yf5jXmcPeAKugc70YTljfWs2f4JL6e8xarK3bggnByQwIUJF3Jy4oXaItrOGhvq+XDNP3hx+3uUW+s4zX8wo3pcT3FNhH38qCp2FVayp6yG5l+ffh6uxIR40zPEm5hgH2KC9z33JiKg7eqi2kNqzq88tPQBNlTv4dTARB4Y/3dCA2IcHdYfnP3iz4T7eTJ3+oh2P7YmWapzaGxgyZb3eHf7B6yuyKDWNOKKMMK3J68P+z/EvwclLq74+0cdc0tXcXkOqbm/kVqQwqbCFJaXbOWWgIGc79ubXHcP/l2VwdmJF5MYfVIrn5xqE40NULiDVdsXc9XOf2NBGOUXy7iI0Zwcf5ZDip0LSnaxZMfHDDEe9KqpYHlFJo+XrOG8qAlMGTSD8MBe7R5TV2W1GvaU1ZCWX0GafTTznfkVZBVkYnFfSEHgdk7I70ldySi2ewwkPCyU2GbDHPQMsY0jFeTt5vStUUfL1JTzxI938sHeX/CzuHPfgOs4c/A1Tpv4XzLnFxqthvdvGN3ux9YkS3U6tXWVrE3/hhVZP1FZmc8D/gPAGC7a8yXpDWX0dA8izrs7oZ7BJPrFMLXHWHBx56v836hqrKa8tozyujLK6yvo59mNqf59qCrPYVTa203HCLJ4ckJgHy7odQ4j488CT38HnrE6Xln5KXy8cR5f7/2FjLoSAD6MnUbfyFHkevrh7h9JsH/rd/nW15SyYueXbMz7jWX5a9lYnQvAraEjuabPRVhD+0BgT71Jog3VNVjZVVjJjrwKUvN+n2dvZ14l1fW/F5r7uLvQK8y3adDNcO8CRpgsYqpT+aw2nV0eXlw54s52HWizvdXXVuK2Zy3s/oVH8pfh7tudG0580OnnVr12/moyi6r4321j2/3Yx5Vkicgk4AXABXjTGPPUAeufB06xv/QGwo0xgfZ1jcBG+7rdxpgpRzqeJlnqmNRXQ2U+n6YuZmvxNtIrskivzqO4oZoTvbrzXOjJAIzN+ohi6+9zbflZ3DnbP4H7oiaCTxjvl6QQFRhP7+5DCfOPddq/2tTxyczbyIq0/3GhZzRSmskjBcv5sCKVcBdvEn0iSQyIp3/YAE6NngDuPtRaXHB39zvk/4fq2jLySjLYW5ZBblkmeypyCDVwvkcPGqpLGJ31AbWmkSSv7ozvNpLxvc4iIfIE/f/VyuoarKQXVLJ9bznb95azY28FO/LK2VVYRUOz8aMiA72ID/clPsyH3uG+9Aq1PQ871ITFVUU8+/P9vJO7DAvC5JDBXD74+k7Vol1dW8bida8zZ8eH/DP0ZJKiTrSN7+cT4ujQWuSO99exMq2IZfdOaPdjH3OSJSIuwHbgdCALWAVcYozZfIjtZwJDjTFX2V9XGGN8jyZYTbJUqzMGrA3QWEd22S6MMfh7h+PjEej8w0OottdQR0rmT6zOXsHWkh1srdhNem0xEa4+fNnD9nfhtXnf81tNHoGuXoBtPKM+7kG83mMiGCtTd/+XtIay/XY7wTeOFxKvAr8ItpoqYsKH6mj/rcRqNWSXVLM1t5xtuWVsyS1ne2456QWVTcmUi0XoGeJNn3Bf+oT70Tvct2mevWMd9mB33gb+vfYVFu1dSbVpYHroSO4cdS8Ex3fYmxPyS9JZ8NvLfJD9IyXWWgZ79+CBkbNJ7Dne0aEdlYc+2cSidTmsf+iMdj/28QxGOhJINcak2Xe0EJgKHDTJAi4BHjrWQJVqEyK2sW9c3IgM1dGx1QFc3UmKO52kuNObFtXUlpNXtAM8AqGukik+XvQrS6e4rhRBsIiFHh7BEJ4EYuF6DxcaXd3p5hdF94BYwgPi8PTwa9pf15wpr3VU1jawNbecLXvKmh7bcsv3G08qOtiLvt38OCOpGwnd/Ejo5kevMB88XFu3CzYmfBD3TXyNmyv38tFvr9K/rhY2fkiOBRbW7+XsftMOeUeiUzEGynOpz1zJBb89QbG1hlMCErl8wAyG95rUIVtY/TzdqKhtwBjjNPVxLUmyIoHMZq+zgFEH21BEegJxwPfNFnuKyGqgAXjKGLPo2EJVSqn24+nhR0yzMbbO6X74sXcmc1pbh9TpGWPIK69lc04Zm/eUkZJTyuacMnYVVTXdyefn6Uq/CH8uGB5F3+7+JEbYEipfj/adwCTApxtXnfywbR7Jgh2s37KQd7K/563s70jwCOXsqPGc3vcCosKS2jWuI9mR/Sv/2/YBGwtTeD1kDG6u7jyUcCm94051ihHvj4evpyuNVkN1fSPe7s4xoU1rRzEN+NAY03y42p7GmGwR6QV8LyIbjTE7D3yjiFwHXAcQE+N8t4YqpZRqPVarYVdRFSk5paTklLEp25ZQNR+os2eIN/26+3PesCj6RfjTL8KPyEAvp2mlAMDiAuGJnBn+MKOGXsNXKf/hs8zveG7nh/xz50cs7XMtPqF9yfTwIqTbILw9A9o3vsZ6duWs4rPURXyTu5KddUVY7Hdkl8WfTECPEUxo58mc20rzqXU6UpKVDTSf2j3KvuxgpgE3N19gjMm2/5smIj8CQ4E/JFnGmDnAHLDVZLUgLqWUUh1AQ6OVtIJKNmWXsim7jE32FqqKWts8c24uQp9wPyYkhpPUw5/+PQLoF+HnVCOdt0SwfxSXjL6HS0bfw+68DWzOXIqPWyjkrueBnC/ZWFtIknd3+vn3ol9IPwZFnEB8xHBbotYKrNZG9hansjNvA2v3/MpEzwgS6hvYWbGL1wuWMNQnivtiJ3N6/0uccpyr47WvNbO8poFuTnIjeEuSrFVAHxGJw5ZcTQMuPXAjEUkEgoAVzZYFAVXGmFoRCQVOAv7WGoErpZRyPnUNVnbklZNiT6Y2ZZeyeU8ZNfW2SY093Sz0i/Dn3KGRDIj0J6lHAH26+bZ67ZSjxYQP+r37rbGBm3cm8POu79hQsoNFe39hQe5STt75Oa90PxW8g7l3z3d4unnTzSuc7r4RBHuFEeUbQbx/HEZc2FKWjohQUVNCeW0J5TUl9PYKJ8mrG3tK0pi5fT6760qoNrbE1QUhKvIMEmLP5ES/yfzs+xenm5astfnbk/LymnoHR/K7IyZZxpgGEbkF+ArbEA5zjTEpIvIosNoYs9i+6TRgodn/dsV+wOsiYgUs2GqyDlUwr5RSqgOpqW9ka245m7JLScmxtVJtyy2nrtGWUPl6uNK/hz+XjIxhYGQAAyID6BXq06FHPz8mLq6MTJjKyISpgK3FaVfeBuor9gJumKoidtcUkFNWSmFjddPbpvn24f7gEdSbRi7OfO8Pu73avz9JQUMJdPch3COQkcFJxAbEEhucQFLUGHy8ggHwtD86u+bdhc5CByNVSil1RKVV9aTssXXzpeTYitJ35lfSaB8uIdDbjaQetpapAZEBDOjhT2yIDxaLE9VPdQB1dVXkl2VQVJFLoJsv0d7hNDTU8XPeKqxWK36eAfh5BuPrGUSwTzd8PIM77NARrW1rbhmT/vEzr/x5GJMHtu9UZ8czhINSSqkuwhhDTmmN7Q6/nDI277EVpmcV/97C0s3fg6QeAUxM6m5PqvydryC9g3J39yYytP9+Q824AqeEOdF8m07KryN2FyqllOqcqusa2b7XNv7UvnGotuaWU1pt+5ISgbgQHwZHB3LJyJimlqowPw8HR67UHzUvfHcWmmQppVQn19BoZVdRFdtyy5tGSN+WW77f+FM+7i707e7H2YMiSIzwJ6mHP4nd/ZzmVniljkSTLKWUUm2m0WrYXVTFjr3l7MirYFuubf6+tPzKpmJ0i0BsiA/9Ivz509BIErv70z/Cn6ggL62fUh2ai0XwcXdpGhrEGWiSpZRSHUxNfSMZhZXszKskNc82AXJqXgVpBZXUNVibtosM9KJPN1/GJoTRJ9yXxO7+9Onmi6db5xouQal9/DzdtCZLKaXU4e2bYiYtv5K0ggrbv/kV7MyvJLP4924+EYgK8qJPuB/jEsKID/e1TYjsgKlmlHI0X09XbclSSillU1pdT0ZBJekFlaQVVDY9Ty+o3O/LwtPNQmyID4OiAjh3aCTx4b7Eh/nQK9QXL3dtmVIKbGNlaU2WUkp1IaXV9ewqtCVOGQVVtueFtoSquOr3ro19rVJxob4MiwmkV5gvvcJ86BXmS4S/p9ZMKXUEfp5uTXfHOgNNspRS6jgZYyiuqiejsJJdhZXsKqxiV2EVGQdJpAAiAjyJDfFh0oAIYkO8iQ31IT7Mh+hg7043vYxS7cnPw5Xs4ipHh9FEkyyllGoBq9VWI3VgIrWrqJJdBVWUN+vaE4EeAV7Ehnpz5kBbItUzxIeeId70DPbR7j2l2oh2FyqllJNqtBpySqptLVCFVey2/7svqaptdueeq0WIDvYmJtibYTFBxO5LokJ8iA720hYppRzA10ML35VSymEarYbs4mrS7S1S6fZi812FVWQWV1Hf+Pt8rh6ulqbEaVxCWFNrVGyIDxEBnl1vomOlnJyfpxtVdY00NFqd4udTkyylVKfTfPgD2516FaQXVJFeUMHuov0TKS83F2JDfUjo5scZSd2baqRiQ3wI9/PQYnOlOhBfT1taU1nbSIC3JllKKXXMauobSS+oZGd+hW0wzvyDD3/g7mohLsSHPuF+nN6/O3GhttaouFAfwvw8dGJjpToJP3uSVVZTT4C3m4OjaWGSJSKTgBcAF+BNY8xTB6yfDjwDZNsXvWSMedO+7krgAfvyx40xb7dC3EqpLqS0up7UvApS7SOb78irYGd+BVnF1fsNytkjwIteYT5cMDyKuFAfeoXZEqkeATpljFJdgZ+TzV94xCRLRFyAl4HTgSxglYgsNsZsPmDT94wxtxzw3mDgISAZMMAa+3uLWyV6pVSnUl5Tz468CnbsLWdbrm26mG255eSV1zZt4+FqoVeYL0Oigzh/WBTxYb7Eh/kSF6p37SnV1fl52lqvnKX4vSUtWSOBVGNMGoCILASmAgcmWQczEfjGGFNkf+83wCRgwbGFq5TqDBoaraQXVLI1t5ytuWVsyy1na245WcXVTdt4ulnoE+7HmD6hJHTzo0+4L73DfYkK8sZFW6WUUgexrybLWeYvbEmSFQlkNnudBYw6yHbni8hYYDtwuzEm8xDvjTzGWJVSHVBZTT1bcsrYvKeMLXvK2LKnnO17y5uGQ3CxCL1CfRgSHci0EdH07e5PQjdfooO8tYtPKXVU9tVkdaSWrJb4FFhgjKkVkeuBt4EJR7MDEbkOuA4gJiamlcJSSrWnvPIaUrLLSMkpJSWnjJScMnYX/T76coiPO/0i/LlidE8Su/uTGOFH73BfHVNKKaC+vp6srCxqamocHUqH1Wg1vDElgkCK2LKlrNX37+npSVRUFG5uLSuqb0mSlQ1EN3sdxe8F7gAYYwqbvXwT+Fuz944/4L0/Huwgxpg5wByA5ORkc7BtlFLOY29ZDRuyStmUbXtszC7dr3YqNsSbgZEBXDwimv49/EmK8Nc7+ZQ6jKysLPz8/IiNjdWfk2NktRqsOaV0D/Ak3M+zVfdtjKGwsJCsrCzi4uJa9J6WJFmrgD4iEoctaZoGXNp8AxGJMMbssb+cAmyxP/8K+KuIBNlfnwHMblFkSimnkVdWw8bs0qakakN2Kfn2hMoiEB/my5jeoSRFBjCghz/9e/g3FaAqpVqmpqZGE6zjJAKCYLW2fluNiBASEkJ+fn6L33PEJMsY0yAit2BLmFyAucaYFBF5FFhtjFkMzBKRKUADUARMt7+3SEQew5aoATy6rwheKeWciirrbAlVZgkbskvZmFVKbpmt+0IEeof5cnKfUAZFBjAwKoB+Ef54u+uQe0q1Bk2wjo+IYLFAYxv1hx3t9WnRb0ZjzBfAFwcs+0uz57M5RAuVMWYuMPeoolJKtYuymnpby1SWLZlan1Wy3x1+vUJ9OKFXMAOjAhkYGUBSD398PDShUqor8/X1paKiAoC7776bL774gsmTJ/PMM884ODIbF0vbtGQdC/1tqVQXUVHbQIq9dmqjvYUqraCyaX10sBeDowK57ISeDIoKYEBkAP7a5aeUOow5c+ZQVFSEi4vz3LxiEaFRkyylVFspr6knJaesqSB9U7Ytodo3OnpEgCcDIwM4d2gkg6JtrVTBPu6ODVop5RTmz5/Ps88+i4gwaNAgHn30US699FIqKiqYOnVq03ZTpkyhoqKC4cOHM3v2bC6++GIHRv07F4vQaDTJUkq1gsKKWltCZR82YXNOGenNWqi6+3syIDKAcwb3aGqhau27bpRSreuRT1PYnNO6QxD07+HPQ+ckHXablJQUHn/8cZYvX05oaChFRUVMnz6dG2+8kSuuuIKXX365advFixfj6+vLunXrWjXO4+UiQn2j1dFhAJpkKdVhNFoNGYWVbNljS6S27LEN8Lm37PdhE6KCvBjQI4DzhkYyICqAAT0CCPPzcGDUSqmO5Pvvv+fCCy8kNDQUgODgYJYtW8ZHH30EwOWXX84999zjyBCPyGIRGhu0JUspdQhFlXVszS1j657fp53ZtrecmnrbX2euFqF3uC8nxYfSL8KfpEh/kiICnGLWeaXU8TtSi1N760h3PbqIFr4rpbDd3bdjr31C5L226Wa25VZQUPF761SwjzuJ3f24dGRPEiP86B/hT59uOkq6Uqr1TZgwgXPPPZc77riDkJAQioqKOOmkk1i4cCGXXXYZ//nPfxwd4hHtG8LBGOPw5FCTLKXaQWFFLal5FezMr2RHXjmpeRXs2FvRNP4UgJebCwndfDmlbxgJ3fxI6O5Hvwg/wnx1lHSlVPtISkri/vvvZ9y4cbi4uDB06FBeeOEFLr30Up5++un9Ct+dlYtFMMZgjG1sP0cS4yQV+M0lJyeb1atXOzoMpY5KfaOVzKIq0vIrSSuoIC2/0p5YVVBc9fuM8F5uLvTp5kvvcF/6hPvRJ9yXPjohslJd3pYtW+jXr5+jw+jwCitqyS6ppl+EP24ullbf/8Guk4isMcYkH7ittmQpdRSMMeRX1JKWX0l6ge2xL6naXVhFQ7M6gBAfd+LDfZk0IILe4b7Eh/nQO9yXHgFemkwppVQb2ff71Wo1tnlqHEiTLKUOYIyhqLKOjMJK0guqyCioJL2wkowC26OyrrFpW3dXC3EhPvQJ92VSUnd6hfnSK8yH+FBfLUJXSikHcLH3ETrDWFmaZKku6fdEypZEZRRW7ve8vKahaVsXixAd5EVsqA8jYoOJC/WhV5gPcaE+2iqllFJOZr+WLAfTJEt1WsYYCivr7IlTFbsKbd17uwqr/pBIWQQig7yIDfHh3JhIYkN8iA31JjbEh+hg7zbp11dKKdX6XOx/92pLllLH6VBde7sKK8koqKKidv8WqaggL3qG+DA0JnC/RCoqyBt3V02klFKqo3Oxt2Q5w6DvmmSpDqG8pp6MgirSCiqaCs73PQ7s2ouyt0gNjwkiNtTHnkz5EBXkpS1SSinVyVmkg3UXisgk4AVsdfpvGmOeOmD9HcA1QAOQD1xljNllX9cIbLRvutsYM6WVYledTKPVkFVcxc582/AHO/MrScuvIK2gkvzy3wfnFIEeAV70CvPhT0MiiQ31IU679pRSqlNYt24dOTk5TJ48+ajeN378eJ599lmGDR8OHH13oa+vLxUVFQDcfffdfPHFF0yePJlnnnnmqPbT3BGTLBFxAV4GTgeygFUistgYs7nZZmuBZGNMlYjcCPwN2Dcdd7UxZsgxR6g6nZr6RtLsg3LutA/QmZpna6Gqa9a+G+TtRq8wX8YnhNErzLep4Dwm2BtPNx3tXCmlOqN169axevXqo06y9rGIYDnOqXXmzJlDUVERLi7H913TkpaskUCqMSYNQEQWAlOBpiTLGPNDs+1/AS47rqhUp1DXYCWtoIJtubbpYrbvrSA1r4JdhZXs+79vEYgJ9qZ3uC/j+4YRH+ZLfLgPvUJ9CfJxd+wJKKVUFzN//nyeffZZRIRBgwbxzjvvkJGRwVVXXUVBQQFhYWG89dZbxMTEMH36dLy8vFi7di15eXnMnTuX+fPns2LFCkaNGsW8efMAWwvRtddey9dff0337t1ZuHAhYWFhTS1PycnJFBQUkJyczPbt2/nLX/5CdXU1S5cuZfbs2Zx99tnMnDmTTZs2UV9fz8MPP8zUqVOprq5mxowZrF+/nsTERKqrq5vOw2KRppas2NhYLrroIr788ku8vLx499136d27N+np6Vx66aVUVFTsN5L9lClTqKioYPjw4cyePZuLL76YY9WSJCsSyGz2OgsYdZjtrwa+bPbaU0RWY+tKfMoYs+hog1TOzRhDblkNW/aUsWVPOVtzy9mWW0ZafmXT4JwuFiE2xJvE7n6cM7hH0yjnsSE+2iqllFIH2vEtVOxt3X36doM+px1ydUpKCo8//jjLly8nNDSUoqIiAGbOnMmVV17JlVdeydy5c5k1axaLFi0CoLi4mBUrVrB48WKmTJnCsmXLePPNNxkxYgTr1q1jyJAhVFZWkpyczPPPP8+jjz7KI488wksvvXTQGNzd3Xn00UdZvXp10zb33XcfEyZMYO7cuZSUlDBy5EhOO+00Xn/9dby9vdmyZQsbNmxg2LBhTftxEaGxWUtWQEAAGzduZP78+dx222189tln3Hrrrdx4441cccUVvPzyy03bLl68GF9fX9atW3esn3STVi18F5HLgGRgXLPFPY0x2SLSC/heRDYaY3Ye5L3XAdcBxMTEtGZYqhU1Wg1p+RVsyillU3YZm3PK2JJbRkmzaWMiA71I7O7Haf260be7H327+xEX6qMTGiullBP7/vvvufDCCwkNDQUgODgYgBUrVvDf//4XgMsvv5z/+7//a3rPOeecg4gwcOBAunXrxsCBAwHbHIgZGRkMGTIEi8XS1Bp02WWXcd555x1VXF9//TWLFy/m2WefBaCmpobdu3ezZMkSZs2aBcCgQYMYNGhQ03tcLNC8t/CSSy5p+vf2228HYNmyZXz00UdN53XPPfccVVwt0ZIkKxuIbvY6yr5sPyJyGnA/MM4Y01SlbIzJtv+bJiI/AkOBPyRZxpg5wBywzV3Y8lNQbaXRatiZX8H6zBI2ZJWyKaeULXvKqKm31U15uFpI7O7HpKTu9Ivwp1+EP4kRfvh76kjnSil1XA7T4uRMPDw8ALBYLE3P971uaGg46Hv2TXjv6uqK1Wr7PqmpqTnkMYwxfPTRR/Tt27fFcVkOaMmSZjNFH+p5W2jJbVirgD4iEici7sA0YHHzDURkKPA6MMUYk9dseZCIeNifhwIn0ayWSzkPYww5JdV8vmEPT3y+mYteW8HAh7/ijOeXcPeHG/h4bTbuLhb+PKonz100mK9vH0vKIxP55JYxPHX+IK48MZaRccGaYCmlVAc1YcIEPvjgAwoLCwGaugtPPPFEFi5cCMB//vMfTj755KPar9Vq5cMPPwTg3XffZcyYMYCtVmrNmjUATesB/Pz8KC8vb3o9ceJEXnzxRYy9xmrt2rUAjB07lnfffReATZs2sWHDhqb3uFj2L3x/7733mv4dPXo0ACeddNJ+59UWjtiSZYxpEJFbgK+wDeEw1xiTIiKPAquNMYuBZwBf4AN7VrhvqIZ+wOsiYsWW0D11wF2JykFqGxrZlF3K6oxi1u4uYW1mMXvLbA2Q7q4WBvTw56LkaAZFBTAoKpBeoT46fYxSSnViSUlJ3H///YwbNw4XFxeGDh3KvHnzePHFF5kxYwbPPPNMU+H70fDx8eHXX3/l8ccfJzw8vCnhueuuu7jooouYM2cOZ511VtP2p5xyCk899RRDhgxh9uzZPPjgg9x2220MGjQIq9VKXFwcn332GTfeeCMzZsygX79+9OvXj+H2oRvA3pLVbAiH4uJiBg0ahIeHBwsWLADghRde4NJLL+Xpp5/er/C9NYlxgmHnD5ScnGxWr17t6DA6ldKqelbvKmJVRjFrdhWxPquUugZbM23PEG+GRgcyNCaIoTGBJHb319HPlVKqnW3ZsoV+/fo5OoxW13z8qfaSU1JNcWUdSZEBxMbGsnr16qZas+N1sOskImuMMckHbqsjvndShRW1rMoo4pe0IlamF7E1twxjwNUiDIgM4MrRPRneM5jhPYMI8/M48g6VUkqpDmLfEA6ObkjSJKuTKK2u59f0IpbvLGB5aiHb9tr6sz3dLAyLCeK2UxMYGRfMkOhAvNz1Lj+llFLto71bscA2hAOA1RgyMjLa/fj7aJLVQdU2NLImo5ifUwtYnlrAxuxSrMaWVI2IDWbKkB6c0CuYgZGB2vWnlFKqS9k3u1qj9ffnjqBJVgdhjGFrbjlLdxTwc2oBv6YXUlNvxdUiDI0JZOaEPpwYH8KQmEAdj0oppVSXZmnWkuVImmQ5seLKOn5OLWDJ9nx+3pHfdPdf73Bfpo2I4eQ+oYzqFYKvh15GpZRSah8X+93wjccxf2Fr0G9nJ2K1GjZkl/Ljtjx+3JbP+qwSjIEALzfG9AllXJ8wTk4IJSLAy9GhKqWUUk5rX0tWo7ZkdW3FlXUs2ZHPD1vzWLKjgKLKOkRgSHQgt57ah3EJYQyKCmzKypVSSqm2tGjRIs4991y2bNlCYmIiABkZGfTr14/ExERqamrw8/PjpptuYvr06cd8nIcffhhfX1/uuusutm7dyrRp0xARPvzwQ+Lj44/rHPZ9Z1q1JatrMcaQklPGj9vy+H5rHusyS7AaCPZxZ1xCGOP7hnFynzCCfdwdHapSSqkuaMGCBYwZM4YFCxbwyCOPNC2Pj49vGm09LS2N8847D2MMM2bMOO5jLlq0iAsuuIAHHnjguPcFv99dqN2FXUBlbQNLUwv4YWseP2zLa6qtGhQVwC0T+jAhMZxBkQE6orpSSimHqqioYOnSpfzwww+cc845+yVZzfXq1YvnnnuOO++88w9J1rx58/j4448pLS0lOzubyy67jIceegiAJ554grfffpvw8HCio6MZPnw4X3zxBf/4xz9wcXHhu+++44cffjju89j3faqF751UekFlU1K1Mq2IukYrfh6unJwQyil9wxnXN4xwP09Hh6mUUspJzfjfH1uIJsZOZFriNKobqrnp25v+sH5q76n8qfefKK4p5o4f79hv3VuTjjwdzieffMKkSZNISEggJCSENWvW7DddTXPDhg1j69atB13366+/smnTJry9vRkxYgRnnXUWIsLChQtZt24dDQ0NDBs2jOHDhzN58mRuuOGGpq7D1rCvzaLR2iq7O2aaZLWS2oZGVqYV8YO9aD29oBKw3Qk4/aRYTukbTnJsEG6OHLBDKaWUOowFCxZw6623AjBt2jQWLFhwyCTrcKOpn3766YSEhABw3nnnsXTpUgDOPfdcvL29AZgyZUprhr4fEbFNEq0tWR1XZlEVP27P56dteSzfWUhVXSMerhZGx4cw46RYxieEExPi7egwlVJKdUCHa3nycvU67Pogz6AWtVw1V1RUxPfff8/GjRsRERobGxERnnnmmYNuv3bt2kPOtSgif3jd3lPcuIhoTVZHUlPfyKqMIn7als+P2/NJzbNNFRAV5MX5w6I4JTGM0b1CddoapZRSHc6HH37I5Zdfzuuvv960bNy4cfz888/ExMTst21GRgZ33XUXM2fOPOi+vvnmG4qKivDy8mLRokXMnTsXi8XC9OnTmT17Ng0NDXz66adcf/31bXY+FosmWU7NGMPO/Ep+2p7Pku35rLSPsu7uYmFUr2CmjYhmfN9w4sN8/pC1K6WUUh3JggULuOeee/Zbdv755zct37lzJ0OHDm0awmHWrFmHHMJh5MiRnH/++WRlZXHZZZeRnJwMwMUXX8zgwYMJDw9nxIgRbXo+LuL47kJpSfOdiEwCXgBcgDeNMU8dsN4DmA8MBwqBi40xGfZ1s4GrgUZgljHmqyMdLzk52axevfrozqSVFFTUsiy1gKU7CliWWkBOaQ0AvUJ9GJsQxtiEUE7oFYK3u+anSimlWs+WLVsO2f3WkcybN4/Vq1fz0ksvOTSO9IJKGhqt9Onm16r7Pdh1EpE1xpjkA7c9YqYgIi7Ay8DpQBawSkQWG2M2N9vsaqDYGNNbRKYBTwMXi0h/YBqQBPQAvhWRBGNM4zGeW6srq6lnVXoRy3cWsiy1gK255YBtlPUT40O46ZRQxiWEER2stVVKKaVUR+EiQl0HKHwfCaQaY9IARGQhMBVonmRNBR62P/8QeEls/WdTgYXGmFogXURS7ftb0TrhH5sl2/NZtrOAX3YWsjG7FKsBd1cLw2OCuHtiX8b0DmVAZICOsq6UUkodpenTpx/XSPCtxWLpGEM4RAKZzV5nAaMOtY0xpkFESoEQ+/JfDnhv5MEOIiLXAdcBfyiwa21PfbmV7XvLGRIdyC2n9OaE+BCGxQTh6aYF60oppVRn4GIRnbtwH2PMHGAO2Gqy2vJYL106lO4BnlpXpZRSyqkYY/RGqlYS6utBiI97q36mRzsMRUtGxswGopu9jrIvO+g2IuIKBGArgG/Je9tdrzBfTbCUUko5FU9PTwoLC9t9PKnOys3FgrurS6smWIWFhXh6tny2lpZkGquAPiIShy1BmgZcesA2i4ErsdVaXQB8b4wxIrIYeFdEnsNW+N4H+LXF0SmllFJdRFRUFFlZWeTn5zs6FHUInp6eREVFtXj7IyZZ9hqrW4CvsA3hMNcYkyIijwKrjTGLgX8B79gL24uwJWLYt3sfW5F8A3CzM91ZqJRSSjkLNzc34uLiHB2GakUtGiervTlynCyllFJKqaNxqHGydLZipZRSSqk2oEmWUkoppVQbcMruQhHJB3a18WFCgYI2PoY6OnpNnJNeF+ej18Q56XVxPu11TXoaY8IOXOiUSVZ7EJHVB+s/VY6j18Q56XVxPnpNnJNeF+fj6Gui3YVKKaWUUm1AkyyllFJKqTbQlZOsOY4OQP2BXhPnpNfF+eg1cU56XZyPQ69Jl63JUkoppZRqS125JUsppZRSqs10+iRLRCaJyDYRSRWRew+y3kNE3rOvXykisQ4Is0tpwTW5Q0Q2i8gGEflORHo6Is6u5kjXpdl254uIERG9i6qNteSaiMhF9p+XFBF5t71j7Ipa8DssRkR+EJG19t9jkx0RZ1chInNFJE9ENh1ivYjIP+3Xa4OIDGuv2Dp1kiUiLsDLwJlAf+ASEel/wGZXA8XGmN7A88DT7Rtl19LCa7IWSDbGDAI+BP7WvlF2PS28LoiIH3ArsLJ9I+x6WnJNRKQPMBs4yRiTBNzW3nF2NS38WXkAeN8YMxTbXL6vtG+UXc48YNJh1p8J9LE/rgNebYeYgE6eZAEjgVRjTJoxpg5YCEw9YJupwNv25x8Cp4qItGOMXc0Rr4kx5gdjTJX95S9Ay6c8V8eqJT8rAI9h+0Okpj2D66Jack2uBV42xhQDGGPy2jnGrqgl18UA/vbnAUBOO8bX5RhjlgBFh9lkKjDf2PwCBIpIRHvE1tmTrEggs9nrLPuyg25jjGkASoGQdomua2rJNWnuauDLNo1IQQuui72JPdoY83l7BtaFteRnJQFIEJFlIvKLiBzur3nVOlpyXR4GLhORLOALYGb7hKYO4Wi/d1qNa3scRKljISKXAcnAOEfH0tWJiAV4Dpju4FDU/lyxdYGMx9biu0REBhpjShwZlOISYJ4x5u8iMhp4R0QGGGOsjg5Mta/O3pKVDUQ3ex1lX3bQbUTEFVvTbmG7RNc1teSaICKnAfcDU4wxte0UW1d2pOviBwwAfhSRDOAEYLEWv7eplvysZAGLjTH1xph0YDu2pEu1nZZcl6uB9wGMMSsAT2xz6CnHaNH3Tlvo7EnWKqCPiMSJiDu2AsTFB2yzGLjS/vwC4Hujg4e1pSNeExEZCryOLcHSGpP2cdjrYowpNcaEGmNijTGx2GrlphhjVjsm3C6hJb+/FmFrxUJEQrF1H6a1Y4xdUUuuy27gVAAR6Yctycpv1yhVc4uBK+x3GZ4AlBpj9rTHgTt1d6ExpkFEbgG+AlyAucaYFBF5FFhtjFkM/AtbU24qtsK5aY6LuPNr4TV5BvAFPrDfg7DbGDPFYUF3AS28LqodtfCafAWcISKbgUbgbmOMtsS3oRZelzuBN0TkdmxF8NP1j/e2IyILsP2xEWqvg3sIcAMwxryGrS5uMpAKVAEz2i02ve5KKaWUUq2vs3cXKqWUUko5hCZZSimllFJtQJMspZRSSqk2oEmWUkoppVQb0CRLKaWUUqoNaJKllFJKKdUGNMlSSimllGoDmmQppZRSSrWB/wfhkWJytXtDGwAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -332,12 +368,12 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -349,7 +385,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -361,7 +397,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlAAAADSCAYAAACFBf6/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABL90lEQVR4nO3deXxcVd348c+ZfSaTPWmaNkmTrrSl6UJbtgIFZIcioiwKAqI+oI+ICPwU0AcVFZdHRMWFRxEXlkLRUmSRXWiBQktLF9rSJWmTNM2+zz73/P6YSUg6SZplkkk63/frlVdm7jn33m/mTuZ+59xzz1Faa4QQQgghxMCZEh2AEEIIIcR4IwmUEEIIIcQgSQIlhBBCCDFIkkAJIYQQQgySJFBCCCGEEIMkCZQQQgghxCBJAiXEGKWUKldKfSJO21qulKocRP3XlVJfjMe+h0Mpda1Sau0w1r9DKfXHeMYkhBAAlkQHIISIP6WUBmZorfckOpZE0lr/KNExCCGOTtICJYQ4KimlEv4FMVExjIW/XYijnSRQQoxtS5RSHyqlmpRSf1ZKOToLlFJfUkrtUUo1KqXWKKUmRZe/Ea3ygVKqXSl1ebd1vqmUqlVKVSulrjvCvqcppd5VSrUqpZ5WSmV1284KpdR2pVRz9HLf7G5lWik1vdvzh5VS90QfL1dKVfYVh1IqO/q3tCql3gWmdQ9IKXW/UqoiWr5RKXVKt7K7lVKrlFJ/V0q1AtdGl/29W50TlFJvReP+QCm1vFvZtUqpfUqpNqVUmVLqc729KEqppUqpt6PbqFZK/UYpZTvs7/+qUmo3sDu67EKl1OboOm8ppUr72Pbt0WPW+RNUSj0cLUtXSv0pus8qpdQ9Silzt9jXKaXuU0o1AHdH6/9VKVWnlNqvlLpLKSWf+ULEifwzCTG2fQ44h0giMRO4C0ApdQbwY+AyIB/YDzwOoLU+NbrufK21W2u9Mvp8IpAOTAauBx5QSmX2s+/PA1+Ibj8E/Cq675nAY8DNQC7wHPBM9yTiCPqL4wHAF93nF6I/3b0HLACygEeBJ7snlcDFwCogA3ik+4pKqcnAs8A90fVvBZ5SSuUqpVKif995WutU4CRgcx/xh4FvADnAicCZwFcOq/NJ4HhgjlJqIfAQ8F9ANvAHYI1Syn74hrXWP40eMzcwG6gDOo/fw0SOw3RgIXA20L2f2vHAPiAP+CHwayKv81TgNCLH80hJsxBioLTW8iM/8jMGf4By4IZuz88H9kYf/wn4abcyNxAEiqPPNTC9W/lywAtYui2rBU7oY9+vA/d2ez4HCABm4DvAE93KTEAVsLyPfT8M3HOkOKLbDgLHdCv7EbC2n9eoiUiiCHA38MZh5XcDf48+/n/A3w4r/zdwDZACNAOXAs5BHqebgX92e66BM7o9/x3wg8PW2QWc1s82ncBG4P9Fn+cB/u6xAVcCr0UfXwsc6FZmjh6vOd2W/RfweqLf1/IjP0fLj7RACTG2VXR7vB+YFH08KfocAK11O9BApFWnLw1a61C35x4iiddA920l0upy+L6NaN3+9j2QOHKJ3Nhy+H67KKVuVUrtUEq1KKWaibSw5PQR8+GmAJ+JXkZrjq6/DMjXWncAlwM3ANVKqWeVUsf0thGl1Eyl1L+UUoeilwp/dFgMh8cxBfjmYfst5ONj2Zs/Abu01j/ptg1rNLbObfwBmNDHPnOi9bu/fvsZ+DESQhyBJFBCjG2F3R4XAQejjw8SOakCEL0ElU2kJWik9h0E6nvZt4rW7dy3B3B1W3fiAPdXR+QS1eH77dzPKcDtRC5bZmqtM4AWQHWrr/vZfgWRFqiMbj8pWut7AbTW/9Zan0Xk8uFO4P/62M7vouUztNZpwB2HxXB4HBXADw/br0tr/VhvG1dKfYvI5drrD9uGH8jpto00rfXcPvZZT+R4Tem2rIj4vj+ESGqSQAkxtn1VKVUQ7cB9Jx/3h3kMuE4ptSDal+ZHwHqtdXm0vIZI35fhuEopNUcp5QK+D6zSWoeBJ4ALlFJnKqWswDeJnNzfiq63GfisUsqslDqXSP+bI4pu+x9EOkC7lFJziFxe65RKJMGqAyxKqe8CaYP4e/4OXKSUOicamyPaqb1AKZWnlLo4moj6gXbA6GM7qUAr0B5tpbrxCPv9P+AGpdTxKiJFKXWBUir18IpKqfOAm4BLtNbezuVa62rgReB/lVJpSimTUmqaUqrX17bbcfqhUipVKTUFuCX6Gggh4kASKCHGtkeJnDj3AXuJdIBGa/0ykb5ITwHVRDqZX9FtvbuBv0Qv91w2xH3/jUj/pUOAg8iJHa31LuAqIp2U64GLgIu01oHoel+PLmsm0gl+9SD2+d9ELucdiu77z93K/g28AHxE5HKUj/4v2fWgta4g0sn8DiJJWAVwG5HPQRORBOMg0Egk6esrMboV+CzQRiQ5WtlHvc79bgC+BPyGSJ+tPUT6LPXmciKXMnd0uxPv99GyzwM24MPodlYRaS3ry9eADiLvnbVE3ksP9RerEGLglNb9tXgLIYQQQojDSQuUEEIIIcQgSQIlhBBCCDFIkkAJIYQQQgySJFBCCCGEEIN0xARKKVWolHpNRebj2q6U+np0eZZS6iWl1O7o7/6mhBBCCCGEOGoc8S48pVQ+kZF634+OW7KRyDxP1wKNWut7owO/ZWqt/19/28rJydHFxcXxiFsIIYQQYkRt3LixXmud21uZ5UgrRwdwq44+blNK7SAyHcDFROa1AvgLkbmz+k2giouL2bBhw4ADF0IIIYRIFKXU/r7KBtUHSilVTGQW8PVAXjS5gsigd3l9rPNlpdQGpdSGurq6wexOCCGEEGJMGnACpZRyExn1+GatdWv3Mh25DtjrtUCt9YNa68Va68W5ub22ggkhhBBCjCsDSqCi8109BTyitf5HdHFNtH9UZz+p2pEJUQghhBBibDliH6joTOt/AnZorX/RrWgNkYk+743+fnpEIhRCCCHGsWAwSGVlJT6fL9GhiD44HA4KCgqwWq0DXueICRRwMnA1sFUptTm67A4iidMTSqnriUzsOdQJS4UQQohxYV/1+7xf8TqfXnrLgNeprKwkNTWV4uJiIm0SYizRWtPQ0EBlZSUlJSUDXm8gd+GtBfo64mcOeE9CCCHEOHf5y1/EZwS5dPHNKNPAuhH7fD5JnsYwpRTZ2dkM9kY3GYlcCCGEGCCfEQQgEPIOaj1Jnsa2oRwfSaCEEEKIATovqxQAX6AtwZHEn9vt7np82223MXfuXG677bYERjS2DaQPlBBCCCGA6/NOZoG2Yu2zZ8vR4cEHH6SxsRGz2ZzoUMYsaYESQgghBkgZYU5wTMRlGvjdWmPFX//6V0pLS5k/fz5XX301ZWVlnHjiicybN4+77rqrq96KFStob2/nuOOOY+XKlQmMeGyTFighhBBigO7av5qDgWZe9N+Ay5U16PW/98x2PjzYeuSKgzBnUhr/c9Hcfuts376de+65h7feeoucnBwaGxu59tprufHGG/n85z/PAw880FV3zZo1uN1uNm/eHNc4jzbSAiXiKxyCDX+Gpj6nDxJCiHFrh6+WFiPAR827Ex3KoLz66qt85jOfIScnB4CsrCzWrVvHlVdeCcDVV1+dyPDGJWmBEnHV7qnluYNvcrw7mymZUxIdjhBCjAhfoGNI6x2ppWi0yd2BQyctUCKuatsP8YOm97h/76pEhyKEECPGF/IkOoRBOeOMM3jyySdpaGgAoLGxkZNPPpnHH38cgEceeSSR4Y1LkkCJuPIF2wHY03EwwZEIIcTI8QXHVwI1d+5c7rzzTk477TTmz5/PLbfcwv33388DDzzAvHnzqKqqSnSI445cwhNx5Y0mUFobCY5ECCHi71uZi7m3aQO+QQ6kORZcc801XHPNNT2Wvf32212P77nnnq7H7e3toxbXeCUJlIgr7xD7BQghxJhnhLkkZSouZWZh+tRERyMSTBIoEVddzdrSAiWEOMoEAu1s9NdyoiOfifacRIcjEkz6QIm4OilrDhPMTmY4chMdihBCxFWjp4av1L3OAy1bqOyoTnQ4IsGkBUrElUuZeWXyJZBRmOhQhBAirjz+SL+g1R37yDr4H74x+5OJDUgklLRAibja3LiTh1t3EByHHSyFEKI/3m4TCPtCvgRGIsYCSaBEXL3TuI3/bd7EPVUvJzoUIYSIK0+3BMof9icwEjEWSAIl4sobbXla1yFTuQghji7e4Md3GXslgRq0zZs389xzzw16veXLl7Nhw4Yh79ftdnc9vu2225g7dy633XbbkLfXSfpAibjqTKA8RjDBkQghRHzNSyvmD7mnc3fju/jCgUSHM+5s3ryZDRs2cP755ycshgcffJDGxkbMZvOwtyUtUCKufNFvZV4jlOBIhBAivjLNTk5y5vP9vNO4fsIJiQ5nUP76179SWlrK/PnzuyYOLi8v54wzzqC0tJQzzzyTAwcOAHDttddy4403csIJJzB16lRef/11vvCFLzB79myuvfbarm263W6+8Y1vMHfuXM4880zq6uqAni1G9fX1FBcXEwgE+O53v8vKlStZsGABK1eupKOjgy984QssXbqUhQsX8vTTTwPg9Xq54oormD17Npdccgleb+99aouLi7n99tuZN28eS5cuZc+ePQCUlZVx4oknMm/ePO66666u+itWrKC9vZ3jjjuOlStXDvs1lRYoEVfeaMfKEAbBkA+rxZHgiIQQIj72te5nj+cAp+fMx2pzH3mF3ux+Gdpr4huYOw9mfKLP4u3bt3PPPffw1ltvkZOTQ2NjIwBf+9rXukYnf+ihh7jppptYvXo1AE1NTbz99tusWbOGFStWsG7dOv74xz+yZMkSNm/ezIIFC+jo6GDx4sXcd999fP/73+d73/sev/nNb3qNwWaz8f3vf58NGzZ01bnjjjs444wzeOihh2hubmbp0qV84hOf4A9/+AMul4sdO3awZcsWFi1a1Offlp6eztatW/nrX//KzTffzL/+9S++/vWvc+ONN/L5z3+eBx54oKvumjVrcLvdbN68eZAvcO+kBUrE1d2FF3BT+nyKLG4CMiq5EOIo8lrtBr5Zv5ZtwRbea92X6HAG7NVXX+Uzn/kMOTmRwT+zsrKAyDQun/3sZwG4+uqrWbt2bdc6F110EUop5s2bR15eHvPmzcNkMjF37lzKy8sBMJlMXH755QBcddVVPdYfiBdffJF7772XBQsWsHz5cnw+HwcOHOCNN97gqquuAqC0tJTS0tI+t3HllVd2/e6clmbdunVdyztb20aCtECJuEpRJr6UPpcvpc8FkzXR4QghRNx4Q14U8LeG99nrqeZpvjv4jfTTUjSW2O12IJIkdT7ufB4K9d5FQykFgMViwTAis1H4fH0P96C15qmnnmLWrFlDjrNzn/09HinSAiXi6tHa9TzTURZ5EpaO5EKIo4c35MWhLDjNdnzjqJ/nGWecwZNPPklDQwNA1yW8k046iccffxyARx55hFNOOWVQ2zUMg1WrVgHw6KOPsmzZMiDSN2njxo0AXeUAqamptLV9PBTEOeecw69//Wu01gBs2rQJgFNPPZVHH30UgG3btrFly5Y+Y+jsy7Ry5UpOPPFEAE4++eQef9dIkQRKxNWTjR9wX/NmvlDzMvta9iY6HCGEiBtPyIvTZMFhtuPT4+cL4ty5c7nzzjs57bTTmD9/PrfccgsAv/71r/nzn/9MaWkpf/vb37j//vsHtd2UlBTeffddjj32WF599VW++91Ii9ytt97K7373OxYuXEh9fX1X/dNPP50PP/ywqxP5d77zHYLBIKWlpcydO5fvfOc7ANx44420t7cze/Zsvvvd73Lcccf1GUNTUxOlpaXcf//93HfffQDcf//9PPDAA8ybN4+qqqpB/U2DoTozv9GwePFiPZyxHMTYd+6jJ+M3gtSHvTy87CccNy1xt6sKIUQ8feuZq/igrYwzchexqnot6z+/aUDr7dixg9mzZ49wdKPP7XbT3t6esP0XFxezYcOGrr5dw9XbcVJKbdRaL+6tvvSBEnHlM4JkW1KoD3vxSidyIcRR5L/zT6M9Yy4vBRvx6TDaMFAmuZCTrCSBEnHlNYJkWd3gr+8xaq8QQox3BRY3uGykpMzhBH8QjDAkcQKVyNYnoOtuwESRBErEjTYMfDpMli0NAE8gsf9cQggRTy81bSPF4uKkCXModOSBDgFyt3GykgRKxI3SBhsKL6cp7xj2th0gxSwfLEKIo8fva95isiObKZOW8EFHOcv9rbiszkSHJRLkiG2PSqmHlFK1Sqlt3ZbdrZSqUkptjv5IT2EB4QBWZWKCO59V+efziez5iY5ICCHixmsEcJrtvN+yl//X8Bb1njiPKC7GlYFcvH0YOLeX5fdprRdEfwY/vbI46jR76/lh43ts9RyMLJBxoIQQRxGPEcRpceCwuACkn2eSO2ICpbV+A2gchVjEONfoqefx9t1U+Bq5rvYV/nLg34kOSQgh4sZrBHGaHTiil+184+xO49WrV6OUYufOnV3LysvLcTqdLFy4kNmzZ7N06VIefvjhYe3n7rvv5uc//zkAO3fuZMGCBSxcuJC9e4+usQGHc/vAfyultkQv8WXGLSIxbnkDkRFmnbYU9gVbOCDN20KIo4Q2DLw6hNPi7GqB8o2zFqjHHnuMZcuW8dhjj/VYPm3aNDZt2sSOHTt4/PHH+eUvf8mf//znuOxz9erVfPrTn2bTpk1MmzYtLtscK4aaQP0OmAYsAKqB/+2rolLqy0qpDUqpDXV1dUPcnRgPOpuznZYUnMqKN+xPcERCCBEnRohn8i/kc4Vn4bSlAOALehIc1MC1t7ezdu1a/vSnP3VNc9KbqVOn8otf/IJf/epXMWUPP/wwF198McuXL2fGjBl873vf6yr74Q9/yMyZM1m2bBm7du0C4LnnnuOXv/wlv/vd7zj99NPj/0cl2JDuwtNadzUtKKX+D/hXP3UfBB6EyEjkQ9mfGB86v405bCk4zVa84b4nkRRCiPFEGUGmWNPAmY3TPYHH8s5hSsbMIW3ruheui1l2TvE5XHHMFXhDXr7y8ldiyi+efjGfnP5JmnxN3PL6LT3K/nzukVuLnn76ac4991xmzpxJdnY2Gzdu7HOKlEWLFvW4zNfdu+++y7Zt23C5XCxZsoQLLrgApRSPP/44mzdvJhQKsWjRIo477jjOP/98brjhBtxuN7feeusRYxxvhtQCpZTK7/b0EmBbX3VF8giGfFgw4bS5cZns0gIlhDhqtHgbeaj1Q/Z5a3HZUznWnk2qafwM1fLYY49xxRVXAHDFFVfEXMbrrr8p3s466yyys7NxOp186lOfYu3atbz55ptccskluFwu0tLSWLFiRdzjH4uO2AKllHoMWA7kKKUqgf8BliulFgAaKAf+a+RCFOPF6bkL2FR0BTpjJvNSJmOS9kYhxFGirqOa+5o3M8mznMna4F/tezi2ZR+z8ksHva3+WoycFme/5ZmOzAG1OHXX2NjIq6++ytatW1FKEQ6HUUrxs5/9rNf6mzZt6nPuPqVUzPPRnFN3LBnIXXhXaq3ztdZWrXWB1vpPWuurtdbztNalWusVWuvq0QhWjHHRYQuUxca3ii7g9rxlCQ5ICCHiwxudWcFlSSGo4O7Gd3mnfkuCoxqYVatWcfXVV7N//37Ky8upqKigpKSEN998M6ZueXk5t956K1/72td63dZLL71EY2MjXq+X1atXc/LJJ3PqqaeyevVqvF4vbW1tPPPMMyP9J40JyTuJj4i7/9Rs4M6GtwkAmCxghBIdkhBCxIU3GEmgnLYU7NZoJ/Jx0s/zscce45JLLumx7NJLL+26jLd3796uYQwuu+wybrrpJq67LrafFsDSpUu59NJLKS0t5dJLL2Xx4sUsWrSIyy+/nPnz53PeeeexZMmSEf+bxgKZykXEzY62ctZ0lPE9s50Hql/nrYatPHK8XN0VQox/3uiYTy5bKlaLAwumcZNAvfbaazHLbrrppq7HXq93wNsqKChg9erVMcvvvPNO7rzzzpjld99994C3Pd5IC5SIG2/IixUTFouNdiNAWaAp0SEJIURceLpaoFIjv00WfCG5USaZSQuUiBtvyIvTFHlLOS1OPEYIbRgok+TpQojx7cycBbwy6ZNkphcD4FCWpBuq5dprr+Xaa69NdBhjhiRQIm68YR/O6G29TouTMJpgyIfN5kpwZEIIMTw2DRMsLrBEpnF5uOgS3OlTEhyVSCRpGhBxY8NEjiXSudLZOdlmoDWRIQkhRFysb9jKb5u3YERb2Ysc2WSZbQNeP1lv9R8vhnJ8JIEScfOdgvN4fNrnACh2F3CGs6BraAMhhBjP3mncxoOt21HRBOr5tr08X//BgNZ1OBw0NDRIEjVGaa1paGjA4XAMaj25hCfixwhC9BLesrzFLGuo6mruFkKI8cwb8uFUlq4+nU80bUED5w1g3YKCAiorK5H5YMcuh8NBQUHBoNaRBErEzc8qXyTd6ubLXA3m6BQH0gIlhDgKeEMf9/EEcJjtNAXaBrSu1WqlpKRkpEITCSKX8ETcvNVezoe+yDzTm1v2cGrlU7xfuynBUQkhxPB5wz5c3RIop8mGz5AviMlMEigRNz4jiMNkB8BsttNk+Gkf4Dc0IYQYy7xhP85uncYdZjs+LQlUMpNLeCJuvEYQpyXSCc9pc0eWBTsSGZIQQsTFfVMuIRD+eOBMu9mGT6arSmqSQIm46ZlARUbrlQRKCHE0sBghLNE58ABuLlnBTU7p15TMJIES8aE1Ey0uJtgzgY8TKE/Qk8iohBAiLv5Qs478lImsiD5Pt6UDFtAalEpkaCJBJIES8WGEeTr/QphyGgApjgzOd02hyJ6V4MCEEGL4/tm0nUWGvyuB2tRWzptNm7gx7MdqGdz4QeLoIJ3IRXyEA5Hf0U6WdmsKP8ldxrLMWQkMSggh4sNrBHGa7V3Pt7ZX8H+t2/H65UaZZCUJlIiL+o5DXFfzMusaP4wsUApMlo8TKyGEGMc8Ooir28DAjuhjf7A9USGJBJMESsRFq6+ZDf5aWrrNTn5uxT/4we6VCYxKCCGGzwiH8Okwzh4JVOSynS8gCVSykgRKxIU3Ot6T0/bxXSpKKTpC3kSFJIQQceELtmPDhNPq6lrm6JwwXe40TlrSiVzEReeHSOeHCoDTZMXbbdwUIYQYj1zKwsaiK9DFZ3Utc0STKV9AEqhkJQmUiAtfNIHqHEATwGWy45EESggx3kX7cirLx53IT8xbzHsFl2FPn5qoqESCySU8ERd2TBxjzSQtOg4UgNNsw2tIAiWEGN8OtlVxZ8Pb7Gir7FpmtTpxmCwobSQwMpFIkkCJuFiSOZMn889jasbH38bOzJzDJ9zy7UwIMb7Veg6xpqOMhtDHHcbrA238pGkj2xt3JjAykUhyCU/ERzg6qab549nKr5h4ErRWJyggIYSIj95ukvEaAf7etos5bfuZm6jAREJJC5SIi6crX+eKQy/g7dacrU1WvDKVy5gWDPmobzmQ6DCEGNM80Y7iLlta1zJH14TpcqdxspIESsTFQW8d2wONWLuNk/KzA89xetnfExiVOJKfvH47p6++AJ+MpixEn7xdN8mkdi1zWCOPfTJUS9KSBErEhTfkxYoJi8XWtcxpceLRQbQhnSzHqjXV6wDYX78twZEIMYYZIdJMNlzd7jJ22COPJYFKXtIHSsSFL+zDaer5dnJanGjAH+zAYU/tfUWRUBMsKewPBJig5buUEH25MG8pF7a1gXty1zKrxYEVE0FDpqtKVpJAibjwhn04TdYeyzpH7fUG2iSBGqOCRogLXMVkhoKJDkWIseuwydI7bSy5GpW/YPTjEWPCEb92KqUeUkrVKqW2dVuWpZR6SSm1O/o7s79tiKNfkS2TRa7JPZa5ogmUx9+SiJDEkRhhfj9hOWe7ithU836ioxFizPrnwTe5veEtMPU8ZSqzDQz58pGsBtJu/zBw7mHLvgW8orWeAbwSfS6S2JcmnMRPCy/oseyY9Gl8OW0uLmXtYy2RUL4WSiypPNG+mx+XP53oaIQYs3a07Wed92DM8l82bmBl9doERCTGgiMmUFrrN4DGwxZfDPwl+vgvwCfjG5YYd4wgHHYJb3bmLL6WMZ/MbhNwirGjrH47j7TtIsueQbm/EcMIJzokIcYkT8iHy2SLWf6fjv2sb9mTgIjEWDDUnqN5WuvOERIPAXlxikeMU1/f9yR3V73YY1lImWgI+/AH2vtYSyTSxkPvcW/TRvLSCvDqEDVNciIQoje99fEEcJhseKUTedIa9q03WmsN6L7KlVJfVkptUEptqKurG+7uxBh1INBEs+HrsWxn+36WV/2Dt2s2Jigq0Z+qtkosKE4oOA2AsjoZykCI3njDfpy9tEDZTVZ8MmF60hpqAlWjlMoHiP6u7aui1vpBrfVirfXi3NzcIe5OjHVeI4jT7OixrHPQOW9QWqDGosqOavKtqUyfuAiAsqaPEhyREGNThsnOZHtGzHKHyYZPOpEnraEOY7AGuAa4N/pbeqAmud4SKFdXAtWRiJDEEVT56plszyLLPZkH889hVtrMRIckxJj0o8nnQLd58DplWlPwhWUgzWR1xARKKfUYsBzIUUpVAv9DJHF6Qil1PbAfuGwkgxRjn88I4rDYeyxzRueN8spIvWNSlb+ZM3Lmo0wmTswphaBcihCiV+Fgj4nSO/142uXQWpWAgMRYcMQESmt9ZR9FZ8Y5FjFeac3JznxmuQt7LHbaIwmUR1qgxp5QgOcnXURgyokA7NA+3j+4kc8t+GyCAxNi7Lml8lnmZx7DNXMv6VlgtkaSK5GUZP4GMXxGmF/knMLFk07tsdhmcfL1jAUsSZuWoMBEn3zNuExWMlIjg5++5ani3rq3aOuoT3BgQow973qqqArGDgi8pn4zt1e/nICIxFggCZQYvq5pDno2cSuTiS9mLWBBSmEvK4lE2la9gV80baIx+glQkhnp/1RetyWBUQkxNnmMIE6LM2Z5mb+Olzr2JyAiMRZIAiWG7VB7FadUPsXzte/FlhkBar3SqjHWbKrbxJ/bdqAcGQCU5M4FoKxhRwKjEmLsCYX8BDF6TaAcZichDIIhXy9riqOdJFBi2Dz+NpoNP5hiu9RdX/UsP9//TAKiEv2paq/CpSxkpEwEoCD7GCwoylr2Jjgy0Z+H37yb/2x/LNFhJBWvvw2g9wTKErnz2C/9PJOSJFBi2LyB6AeMNfY2X6fJijcs387GmsqOQxTYMlDRyVGtFgdFtgzK2ioSHJnoU6CDtw++xaO7Hk90JEklFPIw25pJnjN2HMPOpMrnl7HuktFQx4ESoosvFPn25bDEznnnNNvwyki9Y06Vv4FCR88TwoOzriNLhjIYu+p341IW9vmbEh1JUsm0unki/zyYtCymLN2WToHFTUi+JCYlSaDEsHkDkQTKaXPHlDnNdjqkf8CYog2DtpCPAtfEHsvzMkqg4l0wwmAyJyg60Zeff/AA632H8Okw4VAQsyV2XCIxArpukomdyuWcycs4p7ke7FmjHJQYC+QSnhi2bIubC13F5LgmxJS5zHY8MtnmmKKCHl6e/EluOebqHsvLtJ8f16+nulGmdBlrOryNPFb7LiE0QQxqW/YlOqSksb1hO5dVP8/2trLYws4JhmU6l6QkCZQYttmpBfw45yQmpxbElF024QRuyD4uAVGJPvki49lYXNk9FrebrTza/hE7a95PRFSiH2s/Wk0Ag2sLzwbgQMPOBEeUPJq8jewINhFUsafLXe0VfLHmFXY0yvFIRnIJTwxf50i8vTRxn5Q1Fwx5m40lb1W+wer6dXxLfZruFx6Kc0sBKGvczemJCU304ZUDr5BpcnDZgi+T3lZDkTm2v6EYGZ1zefbWRcGnw6z311AvQ7UkJWmBEsP2l7JnWVyxko5eLtXVhTvY5qlOQFSiL9vqt/G8Zz9Od16P5akpOeSaXZS1lScmMNGrYNDHm007WJ59LDnpJXwufQ75SB+10dKZQLmssQmUIzrBsC/oGdWYxNggCZQYNk/Ig1+HsffyAfNEzXquPPgshhFOQGSiN1Ud1WSbnV1zFXZX4sylrEMS3rGkqXYrC+25nF18HphMVJgU2+u3JzqspOENRZIjpz09pqxz6BafTJielCSBEsPmC/uwYsJiib2E54wObeALyDgpY0WVt5YCW2avZSUpk+gIekDrUY5K9GVCez2/zT+LZbM+BcC99W/z3bJ/JDiq5JFpdrHInourlwTKEb2sJy1QyUk6p4hh84a8OHsZhRw+HmjOG2jF5Yj9ABKjr9LfyPzUkl7Lvj33i5j3vAJBD9hiB0YVo8sIh6g/tJkJOceAOfI/VpSSz3ttZWjD6BoIVYycs7NLObutFXppsXXZ0phhzSDFFPvlURz95L9PDJs37MNp6n1MGqc10gLl8beOZkiiDzocJl1ZmZ46pddyc0pO5IGnYRSjEn3Zsv8Vzix/lLX64xaOwtQivDpEQ6uMGj8qwoFI8qpUTJHbnsE/8s/n/Alyp3EykgRKDNtSdzGXpM/ptayzj0DndC8isVSglZUTz+VLsy7vtbzD6uTmujd4sez5UY5M9OaVvc9iwcT8knO6lhVlTAXggEz8PCp+Vf4MV1e/0HuhyRxJrMIyDlQykgRKDNtFGXP56sTYaQ4A5mfP4afZJ5FnyxjdoETvvM2R331cTnWmTOAt3yE2128dvZhEr7Rh8ErdRo5PLSG1s2UQKMqeBcCBpt2JCi2pHPI1UtdXJ3Gl+GLNq/yl4sXRDUqMCZJAiWHzhTyEVe+3VU90T+K8lGLSzfZRjkr05oXyf/P5mpdo7uVyBIDJZKbYnkVZe9UoRyYOt7v6XSqCrZxZcGqP5flZM7k/9zROdvd+GVbElzfsw2nue9qc3cEmDnhqRzEiMVZIAiWG7Qt7/s5X9vd+V5DHCLHed4h6T90oRyV681Hzbrb663G78/usU+yaSJlXTgiJ9srup1HA6TMv7bHcanFwRtZccsNGYgJLMt6wH2c/ncQdyopPJkxPSpJAiWHzGkGcvYxCDnDI38wXa19lfd2mUY5K9Kayo5qJ1tReh5zoVJJaxMFgKz6/9FtLpEttE/l50QpyMmJbmj7UPl6seTcBUSUfT9iPs58WdIfJglcSqKQkCZQYtkgC5ei1zGWPjJPSOZqvSKwqbz0FR5g5/pjs2Rxry6a55cAoRSVihPxM8Hs4u+T8Xov/0bKT71X9e5SDSk4LnBM5zl3cZ7nDZMMnE6YnJRkHSgyb1wji6OMbWufovV4ZqXdMqAw0cXp2ab91Tp9yFqfXV4Hqu9+HGFnV9TtZ276HMy1n0lu6W5haQGvNW7S0HyLdPXHU40smt+SeCIdNe9Tdsa58HH0M4yKObtICJYbNZwRxWvpogbJFEygZqTfhQgEP86xZlGbO6r+iMzpKubdp5IMSvdp86F2+3/guDar3EeG7hjKo/3A0w0pO4UCvE6V3+k7Rhdw28dQ+y8XRSxIoMTxac03abE7KnNtrsdXqwILCG5YWqESzBDr4zYTlfKrkwv4rWh38V91/+N+dfxudwESM8uZ9ABTm9D6+WlHmTAAqmvaMWkzJ6tyyR3mg6pW+K5gtYIRGLyAxZkgCJYbHCPOV9Hksy13QZ5VfTfwEF+fISL0J52uO/HZmHLFqG2F2tO0f0XBE3w60V5JvceOwp/ZaPjn7mEi91vJRjCr5aMPgUKiDcO+jfgBwX9UrXF++avSCEmOGJFBiWMJBL/VhL4F+PmBOSZ1KsQykmXCP7n6Ks6tW02bqfcyu7gqdeVT6ZDqXRNnvOUSRI6fPcoc9lVVFn+bq7EWjGFXyCYZ8hNFdc3r2piXso8wvl7uTkSRQYlhqOw5yetU/+VfN+j7rvOerYXPL3lGMSvSmoq2CZiOA25V7xLqF7klUh9oJBOXS66jTmv3+RopT+h6rC2BWxnRSAnJ8RpLX3wKAy9r3xNoOiwOflkt4yUgSKDEs3kBkeAJnPx8wP6t7iz8efH2UIhJ9Ke84SLE9C2U68r99UdoUDDRVjbtGITLRQ9DLc5NWcMOMy/qttinUwoNVr45SUMnJE4hMgt5fC5TDbMcnfaCSkiRQYlg6Jwl2WF191nGabHhkoLmEK/PWUuwa2C3vM3OO5SxnIfhaRzgqEcPbSLrJRk56cb/VNnoP8evGDXR4G0cnriRkRbEipYTi1KI+69jNDoIYhEIyFlSykQRKDEvnAJlOS98tUE6zDa8MNJdQPn8bB4OtlPRzIujumPzF/CL3FErMfSfGYmS8V7mOXzd/gMfW+9AgnYrSSwCoqN8xGmElpRyrmx9mn8iinHl91pnqLmC5czLhsG8UIxNjwbASKKVUuVJqq1Jqs1JqQ7yCEuOHN9gOgNPm7rOO02zHG5YEKpH8HTVc5p7B4gkD7HRsdYHFRshTP7KBiRhv17zLQ60fYnX13YkcoDBrBgAVTbtHI6zkFA5GfvczmfA5+Sfw69zTsEt7RNKJxxE/XWu9QGu9OA7bEuNMsWMCN2csYHJqQZ91XGYHXiM4ilGJw6WHgtyVtYQlhQMc8E8pvljzCl/f/uDIBiZilLdVUmBLx9rH4LSdCnNmA3CgpWw0wkpKb1S/w6IDj7O9tZ8hPTpHIZfPuKQjKbMYlkJnNtenzSHHNaHPOl8sPIv7Jp4xilGJw7W2VhBCg6v/efC6S7OmcsBXN4JRid7s99ZS5DjynZJuZzZZZgfV7QdHIark5Am2E8TAbu27E/kbDVtZXvkP9jXtG8XIxFgw3ARKAy8qpTYqpb7cWwWl1JeVUhuUUhvq6uTD+GjT4muiIthGWPU9tlBJyiTmWNNHMSpxuHt2/IVPVj/X76WIwxW6J1EZaCUckm/Wo8UwwlQEmpninjSg+s/M+hJ3Tlw+skElsa4+nrbeBzQF0MpEg+Hr6s4gksdwE6hlWutFwHnAV5VSMdcHtNYPaq0Xa60X5+Ye+VuVGF9WV77O+dXP4CPcZ53dvnr+0bJLTsQJVO45REE/AzP2pih1CiEMDjXLdCGjpam1EoDitCkDqp/mzkd1jjAv4s4TncPTZe/7C6A9OsRBZ7IlksewEiitdVX0dy3wT2BpPIIS44cnFBnIz2Ht+xva2uad/E/jenzBttEKS3RjGGHK/Y2UuCcPar2izGkAVDTIWFCjJVtr1hd8hkumfXJA9Tf467mj8gX8AWn9GAmdk6D31wLlsEXuQPZJApV0hpxAKaVSlFKpnY+Bs4Ft8QpMjA/ekBcbJsyWvi8NuaJjRHn9kkAlQk3THrw6REn61EGtV5I7j6tSZ5EtXSVHj6cRpRRWd999Crur0QGe8ZRTJUnuiJidks/l7hnY+xkouHMIF39IRoVPNpZhrJsH/FMp1bmdR7XWL8QlKjFueEM+nKb++9U4LdEEKiCDMiZCWV3ke83U6AS0A5WTPoX/l308mPs+eYj4emzfGvY2beUue9qA6hdmTAfgQOMupubLhN3xdnLaDE6e4IF+Ru/PdOVwnmsKOf20wouj05ATKK31PmB+HGMR45DP8OEw9f826pzmxSMtUAlRYHJwU/p8ZkxYMLgVlcJvd9Pcsp+8EYlMHG5d/RYOBhpB9TM7dzdFOXMAONAsd4CNBH/Ig0WZ6W/67QkpE/lpzsmQVjxaYYkxQtrmxbCsyJzP13NP6rdOZwIld6kkRhEWvpS9iPTUgd3Z1d2th17hxt1/HYGoRG/2++oodg7s8h1AekoeqSYbB9oqRjCq5HXn7se4+MCq/it13tkalvnwko0kUGJYlqQUcFHWsf3WWZhTyj8mns8sd+EoRSW621G/nQabY8CtGt0VpkykItCMNowRiEx0FwoFqAy0UDSIzv7KZGKqPRtCMo3ISCjzHKLQ2f/d4wGtOb7iCR4q/9coRSXGCkmgxLDs81RTcYSWpRRHOjNsGTj7GStKjJyv7lvJffXvDmndotQifDpMXWt5fIMSMQ427iSEZkp0jruB+su8m7grYwFoPTKBJalQKEC5v5HpR/jiZ7U48OpQ15AHInlIAiWG5a4Dz3BP9Sv91mk3gjzStovdzXtHKSrRqa2jnrqwh5IBjit0uMLonXsVDTvjGZboRVtbNSWWNEqyBtfZ35xRCEEfeBpGKLLkVNmwgwAG0zJn9FtPmUw4lAWfTCacdCSBEsPiNYI4zbZ+63SEA9zbtJFNjR+OUlSiU3ndFgBKjnAS6EtR9iwADjTJYJojba4tizWTLmRBwcmDWq/FkcZ1NS/z7K4nRyiy5LS3NvK/My1n7hHrOpUFX9g/0iGJMUYSKDEskQSq/0lPndFbsr0haeIebWUNOwAoGcBJoDf5WbO4NXMRpXaZRWDEeZvAYofouGkDlZpexEfBZt479N4IBZacSkxOvpo+j2l5i45Y126y4JUEKukMZxwoIfANKoGSgeZGW1nLXiwoCnJmD2l9i8XGNRNOBFPfk6mK+Lhz58O4lIk7B9nZ32QyU+ou4oNWuUQeT1OVlRvyloEz44h1L0qfTcEgR/oX45+0QIlh8RpBnJb+EyirxY4NEx0y3cSoW5E2i59PPg/rEY5Rf2otFj5o2B7HqERvNrSV08rQOoLPz5rNHn8jrR0yYXu8bKvfRot9YIPIfm3iMi7JLB3hiMRYIwmUGDqt+UH2iVyQd/wRqxbbs9jTdmAUghLdlRgmzsxbMqxtPFj/Hjfu/4cMZTCC/IEOqkNtFKcObaiPBRMj05BuPfCfeIaVtMKhINeUPcEfGzYOqL5WFoLSiTzpSAIlhs4Ic7arkDnp045Y9ddzvsT9OSfLrdajKBTy80zdRqpNgx//qbui1ELajAAtHTVxikwcrqJ+OxooGuQQBp3mFZ3KyY58bL6W+AaWpDrvwJuaOX1A9W/Y/xTX7v7bCEclxhpJoMSQBQLtvO07RF3oyLOQT8qZgy0cAk/jKEQmACobdnJH/Tre9VYPazuFGZGT+oF6uYtypOyPDhNRPMghDDqlOLP4/dTLWGKSeQvjYU/tBwBMz+l/kOBOdpMVnxEcyZDEGCQJlBiyBk8NX659lTcbtx2xrseVxU+bNrJ23/OjEJkAKKuPHJeS7KF1IO9UlNU5lMHuYcckeucMhzjBMZGiId4tCUBaAW3NZRhGOH6BJal9jbsAmJq3YED1HWY7fkmgko4kUGLIvIFIy1PnXHf9sbvzeap9L69XvTHSYYmossZIwlM8YXidWwuyZ6OAitb9cYhK9OYkx0T+r+BCUlNyhryNV3wHObn8UfZWD6zfjujbntYy8i1uUpxZA6rvNNvxapkLL9nIMAZiyFp9kZGPXVb3EeuaLVbmpUxmS4vcaj1aytrKyTE7SUsZ3hhOdlsKv5x0DjPSh3Z5SRyZ4WnANMCTdV+mT1yMBj6oWsuMyUvjE1iS+kLGPOozB3b5DiItUHIJL/lIC5QYso2VawGYM/mEAdWflzmT3b46fP62kQxLRJV1VFPiiM8AmGfkLKRQD68zuujbuTt+y33164e1jaLcY8k0OfggOvq8GCLDYJZh5uSJA09CT8yczWdT5QtGspEESgzZ2pr3mGXPITdjYHcOzZuwiBCaHZXrRjgygdbcl3sq35l+eVw2V0aIZ2qHNiGx6F+7t4HqUDupjuG1QCmTifmpRWyWATWHpaG5jGfb9tBktQ94neW5C/lq+rEgQ30kFUmgxNCE/NybsYTvHXPtgFcpLTiFLJODxpbyEQtLRAU95GrTsDuQd3qlbS931PyHDq/cRRlvr+14AoDS/MXD3tb8rDmUB5ppaT807G0lq81Vb/Gthreo0IEBrxNUiqawDyM88HXE+CcJlBiapnLyzA7mTlk+4FVyMqbw+rRrONOeN3JxCQD21Wzmjy3baTDH51+8c3wiGcog/lbtXUORNZ3F0y4Y9raWTzmLOzIXY2qvjUNkyWlfU+QOvGkDvAMPYFX1Ok6t+geNHnndk4kkUGJIVn74CE97D0B6waDWU+mToXV44xKJI9tYvZ77Wz7Ab4vPuEBzJi1FAS/vfjou2xMRew6+y/ueSj5ddBYmk3nY25s++QSuTDuGVE9THKJLTntaBncHHsCUrBkAbD7w2kiFJcYgSaDEoGnD4I+VL/F6sAEG+aH/ZqCBC/f9nfoWmdZlJJW17MOhzEyMfrAPV0HuXJanz2Jl1Wt4/a1x2aaAiS01fDtrCReXXh+fDVpsHLI7eLtqbXy2l4T2eaqZ6hxcK/nSaReSa3axZu8zIxSVGIskgRKDtq/mfQ6F2jk5f2B333XnTitgf6iNrZVvjkBkAiIJ7pbm3RTbs+LSqtHp2nlfxKdDbPtoTdy2mdTCQdz1u/ns1BVkpQ2uJbc/f2rZwc1lqwiH5Lb6wQqHgpT5G5meWjSo9SwWGxfkHc+bLR/R1HZwhKITY40kUGLQ1u59DoBl0y8c9LqzC07GgmJrzfvxDktErdv1FB94DvLJorPiut2FJWfzyqwbWNLRLncbxcEb2x9jVfN2QhOHN9Dp4eZPWIBHh9hT/V5ct5sMTP5W/pV/EZ+f/qlBr3vRnM8SQvP8NpkTL1lIAiUGbW3Ne0y3ZzExa+ag13XYU5nhyGVL00cjEJnAMNi//z9Mt2Vx2eJvxHXTymQiveQ08DbRdmhzXLedjB7c9Qh/af8Ic2ZxXLc7v/AUADYflOFCBkt5GphocTFhCJe+Z04+gV8VXsQlluENRyHGDxmJXAyKEfThD3ZwSs6CIW+jNH0az9ZuwAiHMJnlLRhXNVv5nH0yl59+AxarI/7bz5nF7U3vUb3udf72mX/Hf/tJ4qOqd/jAc5Bbp1+GMsX3e2xB9myyzU4+qNtKfEYBSx7/OfAqe1s/5DpXNkMZNvb0GZ+EPa+g2+swXDloreMdoujGpBQmU+IG+JWzlxgUU0slf807C6P0siFvY1n+SQTaa/C0VuKO87fvZOb1t7J5+2OcmHkMlrxhTErbH5OJ+flLef6jR9i870UWTD17ZPZzlHty68PYMHFx6Rfjvm1lMrEgdQoftpWhfW0oR2rc93G0ev7gWja27+ULfXz50FpT2eRlR3UrBxo9lDd0sL8h8vtQiw+74WVp1ptUvbebXY2XjnL0yec3n13IhaWTErZ/SaDEoBgNuzGZLZgypgx5G8unX8TyxmrwtcQxMvHI+p9xf9WzrJpxLrPUyH0ru2TBDfx2z5P8ZesfJYEaAo+vhX/VvstZWfPISM2P+/bDhua60ptI++hFPJuexDf3cgxlQWuNEW0Q0XzcMiKNJBEa2NVeRaE1h901bQTDmpBhUN3iY2tlC1uqWtha2UyT5+PO+RkuK1OyXCwszCR/ngOb2cQ7h8Cjt/GNhbfH9SYOEWtWXmK/HEgCJQZMGwaXvn8vZ2fN48bhXHpzZWGYbTQ3fERW/vz4BZjEGlsr+WP5syxPn8WsQQxuOhQuZwaXT17OHyte5EDtFoomxLcT9NGurvIdplrT+Myczw6ovtaa+vYAFU0eKpu8HGrxUtvqp6bNT22rj7o2P62+IL6ggS8YJhTNkmaoAs43v8Ha195mY+sKpMtr/xQh0mc10NKcw1n3vdGjzGxSzMxL5Zy5E5lXkM7cSekUZ7vIcNlitvPC5k9x2wf3c8KUXRw/8+LRCl8kgCRQYsAO1G1jT6CRy9MHd4tvDKX4RuNbVB78F08d+5n4BJfkHnznR3h1iG8c/+24bVNrjT9k0OoL0uoN0eEPETIMQmHNzJzPYa54md+8+SvOm/ujSH00Widvi0Zvf7bWkbaej18TzeR9O/mW4wL2tpSyb0MFYUMTNDTtvlD0tQ7SEv2pbvFR2eTBF+x516PTamZCmp0JqXZm56eR7rLisJixW004LGYcVhMW8xzqDlXxUcc/uXJWJscWfBWForNxsnsb5Qg2WI4bbe27uP+A5hPTFzDvjIVYzQqLyUSW28ac/DQc1oG1Ji2ffTnuLb9lze5/SAJ1lJMESgzY2n3PAnByHKacmJ42lddbduPxteBypA97e8nsQO0WVlav5VMTljI1/7gBr6e1prEjwP5GD/sbOiirj/wur++gqtlLizdIMNx3NrTUvYxMn5evvPcmXkagw/pRxqI8FOWs4ZSOIFu8J7Bp/QcxdaxmRbrTSprDSqrTyrTcFJbPzKUwy0VBppPCLBf56Q7cdgtqAFmPYfwPtc/s4rnmFzg/bTGnzB5638Wj3ds71mM5oLjw2BMoLRl6vxqHPZVzchbwXP0m7pTPt6PasBIopdS5wP2AGfij1vreuEQlxqS11esptmVQmDv4Dsod/s4WDE3Y0ExOORaDF3j1w5c5pkD60fSmt5Yc3b1Ma8ztVezY/QQ5JhdnltzE5opmwobuaj1qj77uHf4QHYEwDe1+DjR6ONDopaLRQ7s/1LVtk4JJGU5KclKYMymdDJeVVIeFVIeVNIcFt92C1WzCbFKYTQq7fwZ5Hz3KseHX2WK3snzGDbidE1AK1JDuYRr/estptGGwoezv/G3/I9QZHaTNPI2fLb4as9WBJfpaWsyKVLsVh9U0oMRooEwmM/ec8yAVT1/C7e/dyyMZ0waVZCeTE12TebfwMkyTTxz2tlbM+gyH2ippqn4fV8npcYhOjEVDTqCUUmbgAeAsoBJ4Tym1Rmsts40ehXz+Nt5rL+fTE0/qt543EGZffTu7a9rZVdPGrkORn6pmb496TrPCMhN+/p8nKK+xQ5KecIfCbTnEhPQ3IKWMCw9OJaSt2IwruWp7BVDR77p2i4nCLBdTslwcX5JFUZaLoiwXxTkpFGY5sVsG0+k1GyZ9iVVv38PjNa/zdMNrfCZ/GZ8/7mbysqYN6288Wmzb/xo/efdePvAc5BhHLj857jssmT78FtzBcDnS+dUnfscVz1/FPW9+m4dKb4aMIpqcaWQO93L8UUAbBlUNOzhw4HVOcmaCzTXsbS6aei6/ry2D1po4RCjGKjXUcSqUUicCd2utz4k+/zaA1vrHfa2zePFivWHDhiHtbyD27S/nxQ9foDnccyJNu7JT6op0dN3l3UWr0XMuL5fJxVxnpFXlQ++HdBgdPcrdplRmO48BYJtnG17dMxlIN6cz0xEZVPIDzwcEdKBHeZY5i2mOyAnl/Y73CRPuUZ5jyaHEHpntfkPHhh53yADkWfIoshcR1mHe98SO4J1vnUSBbTJBHWSzZ3NMeYG1gHxbPj7Dx1bv1pjyItsU8qwT6Ai3s90byX+D2k9boI7mUANnWWZSaJh5yb+V3AkXk5m5HENDWGv8wTAVjR721Xewr66jR6JkNSum5bqZmZfKzDw3mSk2LCaFSUW+cf9u62WEdIjfOs8lYMvkyeBOtCUFtzU70oKhFFnmTGa6Iq/t++2bCOlQj9izrdlMc0wF4L32DTHjrkywTaDYPgVDG2xo3xj72tkmUmgvJKhDbGrfFFM+2T6ZybZJ+A0/H3RsiX3t7EVMtOXhCXvY5tkeU17iKCHXmkNbuJ0dnh1AzzugZjimk2XNojnYxA7vTjQGhjbQGGhtsMgxg2zlZJ93Dy92rKc13MbecC0GMMsykWsnfRVL1kIw26MtQ9GxUZTCbjGRYrdEf8y47RacVnNcWzg67a5az0ObfsPzDR9gQvG57IV8s+AcsLm47+CruG2pOC0uTMqMxWRmZmoRCzJnETIMnq2ODvioPm63mplaxDFpxfjCAV6qWR+zv9lpJUx3F9Ae8vBabexxPTZ9GiUpk2gJtPNGfexxXZAxk0JXHvX+Ft5uiD2uSzLnMNGZzSFfA+82bO96X3Ueu2U5peRYUylrP8i6hi2EjBDekIcabx01vka+m3cK+Ybil3Xv8M+OMr4+63NcvPArmC3WIb7Cw7ejYi279/6bFeZMAkEPJ1WuYoIlhdLUEtJsbpwWJ8uy57Ek+1g6jCDP17yLSSmUMkX6TqGYlzGdqe7JtATbeaOu79e1wd/CW728rsdlHsMkZy61vibWN26LKT8+61gmODI56K1jY9POmPKTc+aTZUujwlPD5ubYwXhPzV1IutXNvvYqtrfuAz7uh4bWnJW3FJfFwc7Wcv5d9Trbm/fwYcdBWgw/FkysX/QdbPM+PfgXtzdlb7Br97P83ltGutVNuj2dDHsGOY5sLio4DYANjTuo9tX3WM1hsnPWxKUAvNOwjTp/z/OZ2+Li9AmRVsR19R/QGOh5Pku3ujk1dyEA/6l9n9ZQz/NZti2Dk3LmAfBKzXt4wr4e5RMd2SzJmgPAC4feIWj0nBJosjOXRZmR8+GzB9dh0LN/3hRXPqUZ0zF0t//tbqamTGZu+lSCRogXDr0dUz4zdQqzUovwhHy8Uhs7mv7ctKlMdU+O/rGF4MyIqRNPSqmNWuvFvZUN5xLeZHp+3a0Eju9l518GvgxQVDSy33a2bfuAZ8of4YC7ucfy1IAdtT+SODw3eRfVrrYe5Vl+J8aBSAK1pnAHdY6eb7g8r5tQZeQN81TRNprtPd9wBR1pnHMwcpJ/ovgDOqw933AlbZmccSiSQD0+dRMBc88EamZLDqfUFgPwyPQN6MPOb3ObJnBCfREhZfDI9NgEakFDPsc1TsZrDvLo1Nh+FYvrJzO/KZ9Wq48ni2M/tE6sLWJOywQabB5WT/m4AVFpcIbs+GvtuNpLaNIn8u72TDQ9k7BUu4WpuSksKc7k8txCpuamMDMvleLsFGyWvu/8OW7y7zlYs4VjHBPBU88PdjzNTk9DjzqfcBbyJXtkZOU7G1bRYvRMTleklPAFa6TJ/Rt1jxM87J/5SvdMrslaTFCHual+ZUwM16fN4SrLAprDfr5R/1RM+U3p8zktfS5VoXa+WR87B9y3Mo/jNPMsdgeaub3+uZjyH2SdwGnuqWz21/Ht+pdiyn+Rs4zTTEWs8x/kkYbXY8qX5y7nBHcRBs20eJpIc7i4PutsPnnsNWPq7rcZk4/nx5OP56t121m5+Q8UWVIgHCDU0sTKg2/SoXv+T1ydOosFmccRMELcVflEzPb+K+1YjskopT3s5Y6qf8aU35KxgOlpc2gMtnFHdewErndlLqEkdQYHA43cceiFmPIfZZ9IYUoJ5b5a7qh9Oab8/pxTmegq4CNvFXfW/Sem/I8TziDHMZGdHeX8pOGtruVZZid51lTaLQ7ImMaXJy/mixPn4HZm9/7CjaLZhcuYXbgMDINQywG+7lC8V7uJja176TACeI0Qae31LGmqoSnUzvcOxr7fv515HFNTZ1ETaOaOQ72/3wvdU6nw13FHTe/v90muInZ7D3JH3esx5X/IPZ0Jzny2ew5wR33shMh/yzuLLHsuG9v38Z3Gd2LKn5p4Pum2DN5u28W9TbGJ9ZKmQ7gsKbzZsp2HW7Yww5HLJ3LmMyd7DnMnLsE8afiX7zq1ZE/lvk07qQk009xWTnPYTwiDVGXlorbIOeix+rW86Ok5sXqe2cVZTbUA/KX2Ndb6qnuUT7WkcfqkyLIHa17ifX9dj/JjbVmcOvFcAH5d/Ry7gs09yo+353FS3pkA/PzgGipD7T3KT3cWsCT3VAB+XPkUjYa/R/mFrmIW5USuRNxdsRKf7nk+u9w9g9KsJWhtcEfF4zGvy3Wps5mbuRCvEeCOylUx5V9Nn8es9Hm0hjq44+DTMeW3ZyxialrkfMzcT454AtWf4bRAfRo4V2v9xejzq4Hjtdb/3dc6I90C1dLWRnldGf7DMmqTMpMXnV27wd9AINzzDWExWcl15AJQ76uLybitJhs5jhwAan21hI2erSA2s51se+QDssZbg3HYG8pudpBljwzvf8h7CK0Pu6PG4iLDlgFAtSd2IkqXJYV0WzqGNqjxHoopd1tTSbWmEjbC1Ppim4w7y0NGiDpfbUx5mi2dFIuboBGgwd8IgNlsJyNlMmZzz9t0TUp19YExKdXV6TVerRrt3gZaOmq7XiOHxUGOIwu0prKjOua1c1lcZDsyAahor4rZXoo1hSx7RmQAvI7Y1zbV6ibDnk5YhznYEfvaptnSSLelEjRCHPLEvrYZ9nRSrW4C4QA13rqY8kx7Bm5rCv6wn1pvt2+aKpJYZtszcFld+EJ+Gv3NmEzmyA+R36nObKxWZz+v2Pjg87fhD3YQNkIYRgi7yUaq1YXR7XX/+EY1gzRbKum2NEJGiOpeXvd0WxppwzguWfZMUqwufGE/dd76mPJsRxYuixNPyEuDrxGUqat1TCkT2fYsHDYXASOE1whgMVmxWV1YLeO7M70Oh1BGiFDIS723ATAwDAONxtAGGbY0Um3dXtfDzh99vt+jsh2ZuCwuvCEf9b6GmPIcRzZOiwNPyEODrymmfIIzB7vZTnuwgyZ/c0x5njMXm9lGW7CdZn+3ceaixy/PNQGryUpboB2bMxO7LWWwL9GQacPA42+mzVPHRNcEAOq9DXjDvh6vo0mZmJwSGR+sztuA77DzmcVkId8VOZ/VeOsIhHt+qbSarF3bP+SpjTmf2c12Jjgj57ODHYcIH3a+cpgd5EYT/qqOaoyY85Uz8pkMVLQf5PD7T4f/mTuw/30AbG6wxA4lEU/9tUAdVZfwhBBCCCHipb8Eajgjq70HzFBKlSilbMAVQGybrxBCCCHEUWbIfaC01iGl1H8D/yYyjMFDWuvYXrRCCCGEEEeZYY0DpbV+DojtSSiEEEIIcRSTyZGEEEIIIQZJEighhBBCiEEa8l14Q9qZUnXA/hHeTQ4Qe/+sSDQ5LmOPHJOxSY7L2CPHZGwajeMyRWud21vBqCZQo0EptaGvWw5F4shxGXvkmIxNclzGHjkmY1Oij4tcwhNCCCGEGCRJoIQQQgghBuloTKAeTHQAoldyXMYeOSZjkxyXsUeOydiU0ONy1PWBEkIIIYQYaUdjC5QQQgghxIgatwmUUupcpdQupdQepdS3eim3K6VWRsvXK6WKExBmUhnAMblFKfWhUmqLUuoVpdSURMSZbI50XLrVu1QppZVScrfRCBvIMVFKXRb9f9mulHp0tGNMRgP4DCtSSr2mlNoU/Rw7PxFxJhOl1ENKqVql1LY+ypVS6lfRY7ZFKbVotGIblwmUUsoMPACcB8wBrlRKzTms2vVAk9Z6OnAf8JPRjTK5DPCYbAIWa61LgVXAT0c3yuQzwOOCUioV+DqwfnQjTD4DOSZKqRnAt4GTtdZzgZtHO85kM8D/lbuAJ7TWC4ErgN+ObpRJ6WHg3H7KzwNmRH++DPxuFGICxmkCBSwF9mit92mtA8DjwMWH1bkY+Ev08SrgTKWUGsUYk80Rj4nW+jWttSf69B2gYJRjTEYD+V8B+AGRLxm+0QwuSQ3kmHwJeEBr3QSgta4d5RiT0UCOiwbSoo/TgYOjGF9S0lq/ATT2U+Vi4K864h0gQymVPxqxjdcEajJQ0e15ZXRZr3W01iGgBcgeleiS00COSXfXA8+PaEQCBnBcok3ehVrrZ0czsCQ2kP+VmcBMpdQ6pdQ7Sqn+voGL+BjIcbkbuEopVQk8B3xtdEIT/RjsuSduLKOxEyG6U0pdBSwGTkt0LMlOKWUCfgFcm+BQRE8WIpcklhNpqX1DKTVPa92cyKAEVwIPa63/Vyl1IvA3pdSxWmsj0YGJ0TdeW6CqgMJuzwuiy3qto5SyEGlubRiV6JLTQI4JSqlPAHcCK7TW/lGKLZkd6bikAscCryulyoETgDXSkXxEDeR/pRJYo7UOaq3LgI+IJFRi5AzkuFwPPAGgtX4bcBCZj00kzoDOPSNhvCZQ7wEzlFIlSikbkc58aw6rswa4Jvr408CrWga9GklHPCZKqYXAH4gkT9KnY3T0e1y01i1a6xytdbHWuphI37QVWusNiQk3KQzk82s1kdYnlFI5RC7p7RvFGJPRQI7LAeBMAKXUbCIJVN2oRikOtwb4fPRuvBOAFq119WjseFxewtNah5RS/w38GzADD2mttyulvg9s0FqvAf5EpHl1D5EOaFckLuKj3wCPyc8AN/BktD//Aa31ioQFnQQGeFzEKBrgMfk3cLZS6kMgDNymtZYW9BE0wOPyTeD/lFLfINKh/Fr5Yj6ylFKPEfkykRPte/Y/gBVAa/17In3Rzgf2AB7gulGLTY69EEIIIcTgjNdLeEIIIYQQCSMJlBBCCCHEIEkCJYQQQggxSJJACSGEEEIMkiRQQgghhBCDJAmUEEIIIcQgSQIlhBBCCDFIkkAJIYQQQgzS/wddwPoTHZijtgAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -398,12 +434,12 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -426,12 +462,12 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -454,12 +490,12 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkkAAADSCAYAAABevlSdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABAk0lEQVR4nO3deXxU1f3/8ddntkz2nTWBsAvIHhBERVEUUUGrVrSoVFt/tXVprdpWq1Vrt29bl6qt1bpUq4JLBbTWrbgCLkEQ2dcQAgnZ90xmO78/ZhKSECBAkpvl83w85pE79965933nBuaTc869I8YYlFJKKaVUUzarAyillFJKdUZaJCmllFJKtUCLJKWUUkqpFmiRpJRSSinVAi2SlFJKKaVaoEWSUkoppVQLtEhSPYqIZIvIWa1c9yIR2SMiVSIyoRXr3yMi/zr+lMdHRDJExIiIw+os7Sl8Xga3cl0jIkOPY18fisj3jvX1bUVEForIp1bnUKqn0CJJqUP7E3CDMSYGKO0JhUd7EZFRIpIlIqXhx/siMup4tmmMiTHG7GyDbFp4tKHwHwu+cBFbdTTFrFKdjRZJSh3aQGCD1SE6UjsWgfuAS4AkIAVYBiw6lg1poXpsOvh9WxwuYmPaqphVygpaJKkeS0RsIvJzEdkhIsUi8rKIJIlIhIhUAXbgaxHZAXwcfllZ+C/jaYfYrFtEFotIpYh8JSLjGu1vZLjbpkxENojI3EbLmnTnNG/dCLdi/UBEtoVf/5iISHiZXUT+JCJFIrITOK/ZcX5XRDaFM+0Ukf/XaNnpIpIrIj8TkXzgGRFZLyIXNFrHGd72EbscD8UYU2aMyTahW/wLEABa3f0VPv4ficg2YFujeUPD08ki8oaIVIjIlyJyfwutQ2c1f/9EZCTwODAtfF7LDhNjiIh8Ed7HUhFJapRvbvicloXP5chm2Yc2ev6siNwfnq5//38qIgUikici3220brKILAvv8wtgSLP35WEJdQlXiMhqETm10bJ7RORVEfmXiFQAPxeRGhFJbrTORBEpFBHnkc+CUj2PFkmqJ7sRuBCYAfQDSoHHjDF14S42gHHGmCHAaeHnCeG/jFcdYpvzgFcItZi8CCwJFxlO4A3gXaBXeN8viMiIo8h7PjAZGAt8GzgnPP/74WUTgExCLTaNFYSXxwHfBR4UkYmNlvcJ5x0IXAc8ByxotHwOkGeMWdM8kIgMCBcGh3pc0Wz9MsADPAL89iiOHULn6iSgpW66x4Dq8LFcHX40d9D7Z4zZBPwAWBU+rwmH2f9VwDVAX8AP/CV8TMOBl4AfA6nAW8AbIuJq5XH1AeKB/sC1wGMiktjouDzhfV4TfjT2JTCeA79vr4iIu9HyecCrQALwZ+DD8LHXuxJYZIzxNQ8lIlcc4dwOOMwxXSAiJeHC8fojvwVKdVLGGH3oo8c8gGzgrPD0JuDMRsv6Aj7AEX5ugKHh6Yzwc8dhtn0P8Fmj5zYgDzg1/MgHbI2WvwTcE57+EPheo2ULgU8bPTfAKY2evwz8PDy9HPhBo2VnHy4rsAS4OTx9OuAF3I2W9wMqgbjw81eB29vwHEQDPwTOO4rXGGBmC/OGEmrx8wEjGi27/yjevybv9SH2/yHw+0bPR4XfNztwF/Bys/O+Fzi9+e9R+PmzwP2N3v/axueKUFE7tdFxndBo2W8Pl5VQoT+u0e/jx82WXwasCE/bw7+TU9r439io8O+QHTg5/G/g8rbchz700VEPbUlSPdlA4PX6v4wJFU0BoPdxbHNP/YQxJgjkEvrA6AfsCc+rt5tQ60Fr5TeargHqW7v6Nd5veLsNRORcEfks/Jd9GaGWoZRGqxQaYzyNcu8DVgAXi0gCcC7wwlHkPCxjTDWhLq7nRKTXUbx0zyHmpwKOZstbWvdQ79+x7H834CT0Pvaj0XsePsd7aP25LTbG+FvI1tJxNT+3t4a7UsvD5zaepue2+fuwFBglIoOAWUC5MeaLVuZsFWPMRmPMPmNMwBizEniYg1s3leoStEhSPdke4FxjTEKjh9sYs7eFdU0rt5lePyEiNiCN0KDlfUB6eF69AYRaHCDUVRTVaFmf1h4Eob/U0xs9b+gGEZEI4DVCV+r1NqHupLcIjQuq19Kx/ZNQl9ulhLqiWnpP6rvbqg7z+M4hMtsIHe/RFImHOgeFhLq/0hrNSz/Eukez3eaav8c+oIjQuR1Yv0BEJLxu/XtWw7Gd2/rjOtS5PRW4nVD3WWL43JZzmHMbLoZfJnRurwSeP9TOReQ7Rzi3h+tua7LbZpmU6jK0SFI92ePAb0RkIICIpIrIvEOsWwgEgSNdyjxJRL4loSuJfgzUAZ8BnxP6sLw9PEbpdOACDlzhtRb4lohEhQf5XnsUx/EycJOIpIXHsvy80TIXEBHO7xeRcwl1xx3JEmAicDOhMUotMsbkmKZXMTV/vAAgIrNEZIKEBpnHAQ8Q6hraFF6+UESyj+KYG2cIAP8G7gm/fycQGj/UWvuBtFaMIVogoVsZRAH3Aa+G9/0ycJ6InBkee/ZTQud9Zfh1a4Erwsc+m9AYuGM5rlE0HWsVS6iIKgQcInI3oXFnR/IcoS7GuRymSDLGvHCEc5vT0utEZJ6IJErIFOAmQi1YSnU5WiSpnuxhQpeivysilYSKmZNaWtEYUwP8BlgR7p6beohtLiU07qOU0F/q3zLG+IwxXkJF0bmEWh/+ClxljNkcft2DhMa47CfUinM03VtPAu8AXwNfEfpgrc9dSehD6uVwpivCx3xYxphaQi1Qgxpv7zgkEBqDVQ7sIHSV1uxG3XzphLr4jtUNhLqa8gl98L9EqFBpjeWEbvWQLyJFh1nveULjifIBN6H3FWPMFkItM48QOrcXABeEzzmECs0LgDLgO4QK0Na6gVDXW3543880WvYO8DawlVA3nIdDd0k2MMasIFTwf2WM2X2k9Y/BfGA7oXFtzwF/MMb8sx32o1S7E2Na29KslOpJwi0Tw40xC4648vHv611Cg8k3tdH2/gD0Mca0dJVbjyciy4EXjTH/sDqLUp2ZFklKqYNI6B5Aa4ArjTEfH2l9q4W72FzAN4Qu83+L0NWCS6zM1RmJyGTgPSA93NKolDoE7W5TSjUhIt8n1G3z365QIIXFEuoWrAYWE7onkI6DaUZE/gm8D/xYCySljkxbkpRSSimlWqAtSUoppZRSLdAiSSmllFKqBe3yrdApKSkmIyOjPTatlFJKKdWmVq9eXWSMSW0+v12KpIyMDLKystpj00oppZRSbUpEWrxnmHa3KaWUUkq1QIskpZRSSqkWaJGklFJKKdWCdhmT1BKfz0dubi4ej+fIK6sO53a7SUtLw+l0Wh1FKaWU6hQ6rEjKzc0lNjaWjIwMRKSjdqtawRhDcXExubm5DBo0yOo4SimlejpjoHALlGbDiNmWxeiwIsnj8WiB1EmJCMnJyRQWFlodRSmlVA+Xm7+GtLwNULYHYlLBVwvOSEuydFiRBGiB1InpuVFKKWWlovIcHllxD68XfslT/eYwedRl0Hc82KwbPq0DtxuJiYlpmL7tttsYPXo0t912m4WJlFJKqe7vrTVPcP7SC1lWmMWCfjMYcfKt0H+ipQUSdHBLUlfyxBNPUFJSgt1utzqKUkop1W1l7/+aX33zV0ZE9ubXp/2BQb3HWx2pQY9qSXruuecYO3Ys48aN48orr2TXrl1MmzaNMWPG8Mtf/rJhvblz51JVVcWkSZNYvHixhYmVUkqpbiwYZPOGxcTaXDww62+dqkACi1qS7n1jAxv3VbTpNkf1i+NXF4w+5PINGzZw//33s3LlSlJSUigpKWHhwoVcf/31XHXVVTz22GMN6y5btoyYmBjWrl3bphmVUkop1Ujul8yWWE4/43HcCYOtTnOQVrUkiUi2iHwjImtFpEt+Kdvy5cu59NJLSUlJASApKYkVK1Zw+eWXA3DllVdaGU8ppZTqUXbmfcU765+DlGG4+02wOk6LjqYl6QxjTFFb7PRwLT4dTa/qUkoppTpWwO/jrk9+zu66EqaeeifxnfSzuMeMSZo5cyavvPIKxcXFAJSUlDB9+nQWLVoEwAsvvGBlPKWUUqrH+Oeq+1lXm8edY/4f8bH9rI5zSK0tkgzwroisFpHr2jNQexk9ejR33nknM2bMYNy4cdxyyy08/PDDPPbYY4wZM4a9e/daHVEppZTq9nbkZfHoziXMShjF7LHXWh3nsMQYc+SVRPobY/aKSC/gPeBGY8zHzda5DrgOYMCAAZN2797dZBubNm1i5MiRbRZctT09R0oppdrb1a+ey67aIl6f92+S49KtjgOAiKw2xmQ2n9+qliRjzN7wzwLgdWBKC+s8YYzJNMZkpqamHm9epZRSSnUzpiyXS93p3Dnqmk5TIB3OEYskEYkWkdj6aeBsYH17B1NKKaVU9yJ7v+T8+BM4Z1zn7mar15qWpN7ApyLyNfAF8B9jzNvtG0sppZRS3cm+os08vf3fVPYaAQ6X1XFa5Yi3ADDG7ATGdUAWpZRSSnVTL6x5jBfLvmZO6q+ItTpMK/WYWwAopZRSyhpVtcW8lreCs5PG0CdpqNVxWk2LJKWUUkq1q39/9TeqjY+rxnatuwhpkdTB1q5dy1tvvXXUrzv99NPJyjr2b4SJiYlpmL7tttsYPXo0t9122zFvTymllGoNv9/LC9lvMSk6ndEDZ1gd56hY8gW3PdnatWvJyspizpw5lmV44oknKCkpwW63W5ZBKaVUz1CWt5oMRzSXnXCF1VGOWo9qSXruuecYO3Ys48aNa/hC2+zsbGbOnMnYsWM588wzycnJAWDhwoVcf/31TJ06lcGDB/Phhx9yzTXXMHLkSBYuXNiwzZiYGH7yk58wevRozjzzTAoLC4GmLT9FRUVkZGTg9Xq5++67Wbx4MePHj2fx4sVUV1dzzTXXMGXKFCZMmMDSpUsBqK2tZf78+YwcOZKLLrqI2traFo8pIyOD22+/nTFjxjBlyhS2b98OwK5du5g2bRpjxozhl7/8ZcP6c+fOpaqqikmTJrF48eK2fYOVUkqpZlIKt/H3gRczc1TXK5KsaUna9j5U7W/bbcb0hmFnHXLxhg0buP/++1m5ciUpKSmUlJQAcOONN3L11Vdz9dVX8/TTT3PTTTexZMkSAEpLS1m1ahXLli1j7ty5rFixgn/84x9MnjyZtWvXMn78eKqrq8nMzOTBBx/kvvvu49577+XRRx9tMYPL5eK+++4jKyurYZ077riDmTNn8vTTT1NWVsaUKVM466yz+Pvf/05UVBSbNm1i3bp1TJw48ZDHFh8fzzfffMNzzz3Hj3/8Y958801uvvlmrr/+eq666ioee+yxhnWXLVtGTEwMa9euPco3WCmllDo6e/Z9gbN4K31GXgS2rtcu0/USH6Ply5dz6aWXkpKSAkBSUhIAq1at4oorQtXtlVdeyaefftrwmgsuuAARYcyYMfTu3ZsxY8Zgs9kYPXo02dnZANhsNi677DIAFixY0OT1rfHuu+/y+9//nvHjx3P66afj8XjIycnh448/ZsGCBQCMHTuWsWPHHnIbl19+ecPPVatWAbBixYqG+fWtZkoppVRHeijrAS7LfwdfrxOsjnJMrGlJOkyLT2cSEREBhAqh+un6536/v8XXiAgADoeDYDAIgMfjOeQ+jDG89tprjBgx4phz1u/zcNNKKaVURyqpyOV/pRu5st/pOF3RVsc5Jj2mJWnmzJm88sorFBcXAzR0t5188sksWrQIgBdeeIFTTz31qLYbDAZ59dVXAXjxxRc55ZRTgNBYodWrVwM0LAeIjY2lsrKy4fk555zDI488Qv0XDa9ZswaA0047jRdffBGA9evXs27dukNmqB9btHjxYqZNmwbA9OnTmxyXUkop1ZHe3vACAQxzRy2wOsox6zFF0ujRo7nzzjuZMWMG48aN45ZbbgHgkUce4ZlnnmHs2LE8//zzPPzww0e13ejoaL744gtOPPFEli9fzt133w3Arbfeyt/+9jcmTJhAUVFRw/pnnHEGGzdubBi4fdddd+Hz+Rg7diyjR4/mrrvuAuD666+nqqqKkSNHcvfddzNp0qRDZigtLWXs2LE8/PDDPPjggwA8/PDDPPbYY4wZM4a9e/ce1TEppZRSx+s/e/7HiIgUhvWfYnWUYyb1LRhtKTMz0zS/p8+mTZsYOXJkm+/LajExMVRVVVm2/4yMDLKyshrGWh2P7nqOlFJKdayC4q2c/eYl/GTIJVx9yt1WxzkiEVltjMlsPl/vk6SUUkqpNtWrYj/vp12Ea+y1Vkc5LlokHScrW5GAhqvslFJKqU7BGNi/gZTkEyCuv9VpjkuPGZOklFJKqfb3dfb/+F72q+TEJlsd5bhpkaSUUkqpNvPGllf42ltEUr9DX3DUVWiRpJRSSqk24fN5eKdwNWckjiImUluSlFJKKaUAWLH135QF6zh/8Fyro7SJHlckLVmyBBFh8+bNDfOys7OJjIxkwoQJjBw5kilTpvDss88e137uuece/vSnPwGwefNmxo8fz4QJE9ixY8dxbVcppZTqrN7c8QaJNjfTRlxodZQ20eOKpJdeeolTTjmFl156qcn8IUOGsGbNGjZt2sSiRYt46KGHeOaZZ9pkn0uWLOGSSy5hzZo1DBkypE22qZRSSnUqPg+ZEsW16WfjdLitTtMmWl0kiYhdRNaIyJvtGag9VVVV8emnn/LUU081fGVHSwYPHswDDzzAX/7yl4OWPfvss8ybN4/TTz+dYcOGce+99zYs+81vfsPw4cM55ZRT2LJlCwBvvfUWDz30EH/7298444wz2v6glFJKqc6gaAvzY4Zy9YQfWp2kzRzNfZJuBjYBcW2x4+++/d2D5p2TcQ7zT5hPrb+WH75/8Js8b+g8Lhx6IaWeUm758JYmy56ZfeRWn6VLlzJ79myGDx9OcnIyq1evPuTXfUycOLFJl1xjX3zxBevXrycqKorJkydz3nnnISIsWrSItWvX4vf7mThxIpMmTWLOnDn84Ac/ICYmhltvvfWIGZVSSqmuaMW2N5gQEUdUXD+ro7SZVrUkiUgacB7wj/aN075eeukl5s+fD8D8+fMP6nJr7HBf1zJr1iySk5OJjIzkW9/6Fp9++imffPIJF110EVFRUcTFxTF3bvcYtKaUUkodSWHZLq7ftZh/eveBiNVx2kxrW5IeAm4HYg+1gohcB1wHMGDAgCNu8HAtP5GOyMMuT3QntqrlqLGSkhKWL1/ON998g4gQCAQQEf74xz+2uP6aNWsO+T1m0uwXQEQOW1QppZRS3dn/Nr+CAc4ecYnVUdrUEVuSROR8oMAYs/pw6xljnjDGZBpjMlNTU9ssYFt59dVXufLKK9m9ezfZ2dns2bOHQYMG8cknnxy0bnZ2Nrfeeis33nhji9t67733KCkpoba2liVLljB9+nROO+00lixZQm1tLZWVlbzxxhvtfUhKKaVUp/De3o8Z5EpkSN+DviO2S2tNS9J0YK6IzAHcQJyI/MsYs6B9o7Wtl156iZ/97GdN5l188cUN83fs2MGECRPweDzExsZy0003sXDhwha3NWXKFC6++GJyc3NZsGABmZmhX4rLLruMcePG0atXLyZPntzeh6SUUkpZrqQil6yqHL6Xfo7VUdqcHE03kYicDtxqjDn/cOtlZmaarKysJvM2bdp0yO6rruTZZ58lKyuLRx991Oooba67nCOllFId563Vf+Vn6//GKzMf54T06VbHOSYistoYc1Az2NFc3aaUUkop1cQcRzInZFzBoP7TrI7S5o6qSDLGfAh82C5JuoiFCxceshtOKaWU6lF8tVCazeD0qWDrfven7n5HpJRSSqkO8fb65/l54adUJaRZHaVddGh3mzHmoMvnVeegtzBQSil1tN7Mfput3iKiE7vnV251WEuS2+2muLhYP4w7IWMMxcXFuN3d47t2lFJKtb+q2mJWVuzgrF6TkG7Y1QYd2JKUlpZGbm4uhYWFHbVLdRTcbjdpad2zuVQppVTb+2jzq/gIMmvIBVZHaTcdViQ5nU4GDRrUUbtTSimlVDt6P+d/pNqjGJdxltVR2o3eAkAppZRSR8fvZQhORvabgc1mtzpNu9EiSSmllFJHp2QnN8SdCOOvsDpJu+qeI62UUkop1W6253yE3+mG+HSro7QrLZKUUkop1Wp13mq+s/Fx/lS9pVveQLKx7n10SimllGpTK7ctocb4OW3gLKujtDstkpRSSinVau9nv0uszcXkoedZHaXddcmB24HacvZV5uAN1OH1exoefaL7kJ44FFwxYO+Sh6aUUkp1Wj6/hw9L1nNG4micju5/A+IuWUlUff08c7b8/aD5P4ofww/ix7DfX8NF+W+R4ogmzZ3MuKRRTOh3EmPSZxDpjrcgsVJKKdX1Ze34LxVBL2dmnG11lA7RJYukqEEz+Y1TcNkjcNojcDkicNkjGBjVG+yR2Cv3cn6wkCJPKbtq8/kkexlkL+O+5Glc1Gca5TEp5EUncUL6dKsPRSmllOoyJhPBU33OZuyweVZH6RBdskhy9h7F3N6jDrk8pe847hg+p+F5efV+vt79IaNskVBbyX+2vc7vSr7kBHcq89LP4rwxC0mM7dcR0ZVSSqmuyRgcRduZ0n86RMRanaZDSHt84WxmZqbJyspq8+22lfKqfN765p8syXmPjZ79OLBxRsIIfnPaH4lMHGh1PKWUUqrT2bD7A/67+q9cM/kWktKnWR2nTYnIamNMZvP5PfLqtviYPlw+7Wcsvux9XjvrSb7TbwYOfx2Ra1+EjUupLN9jdUSllFKqU/nv1td5sXIrrpThVkfpMF2yu60tDe8/lVv7TwWfB/Z8xr5dH3BR1j3M630S1029g5T4AVZHVEoppSxlgkHeL8xiatxgYiKTrY7TYXpkS1KLnG4YfDquzGs4LzWTl/NXMmfpPBZ//kdMMGh1OqWUUsoym/euZK+vkrPSZlgdpUMdsUgSEbeIfCEiX4vIBhG5tyOCWSUlfiB3n/skS2Y/z4SYAdy/+TluXHoJgdpyq6MppZRSlnh/21JsCKePuMTqKB2qNS1JdcBMY8w4YDwwW0SmtmuqTiCj9zgev/B1fjF8AcPFjf2rZ6Fom9WxlFJKqQ5naoqZETeUpLg0q6N0qCOOSTKhy9+qwk+d4UfbXxLXCYnNxhXTfgbVRbBxKau//CtvUsltZ/yZKL0ppVJKqZ6gupiboofBsJ5xA8nGWjUmSUTsIrIWKADeM8Z83sI614lIlohkFRYWtnFMi0WnwKSFrI+O4bWCz7lm6cUUledYnUoppZRqd5X5a0MTKcMszWGFVhVJxpiAMWY8kAZMEZETW1jnCWNMpjEmMzU1tY1jdgI2O1ef9mseybyDnXXFLHhzPjvzvrI6lVJKKdWuvp/1O24v/wrccVZH6XBHdXWbMaYM+ACY3S5puoAZoy/nmRkPUWt8XPn+99mdu8rqSEoppVS7yCvewgbPfk5IHm11FEu05uq2VBFJCE9HArOAze2cq1MbPXAGL5zzLN9KGE369o9h/0arIymllFJt7t3NLwNw5vBvWZzEGq1pSeoLfCAi64AvCY1JerN9Y3V+aamj+ensv2OL70/euhd57fM/Wx1JKaWUalPv7v2Eke5eDOw91uoolmjN1W3rgAkdkKXrcUbC2Pm88N4P+efmpRgRLplyi9WplFJKqeO2r2gz62rzuHnQRVZHsYzecft42R3cfOZfOCVuKPdteoY3v3rc6kRKKaXUcUusLOAPySdz3qjLrY5iGS2S2oDT6ebBOc8xOWYgv/zmr/zvm+esjqSUUkodl8iSnczpM5W+KSOtjmIZLZLaiDsilkfm/IsTo/ryj/VPE9S7cyullOqi8oq28Ezu/yhN6Fl32G5Oi6Q2FBWZwF/n/IvHB38b24YlULrb6khKKaXUUXt78yIeKFtLdXw/q6NYSoukNhYXnUr8hIXURERz1/KfkL3/a6sjKaWUUkflnb2fcGJkH9JSe+b9keppkdQeXFGUDT2Dj2r2cOPyG6io7mZf06KUUqrb2lO4gQ2e/ZzT71Sro1hOi6R20i9lJA9Mu5dcbzm3v/M9/H6v1ZGUUkqpI6q/geTZJ3zb4iTW0yKpHWUOncOdI7/LisqdPPCB3j9JKaVU51dQtpPxUf3ol3KC1VEsd8SbSarjc8mUn7C9bBtv5n/GNbs+ImXQDKsjKaWUUi2rKeEXMaPwj7ne6iSdgrYkdYBbZz7EyydcR0rO51CWY3UcpZRSqkW+/RsAcPQeZXGSzkGLpA7gcLjoM/4qghFxPLfi1xSV6a0BlFJKdT4LvriH31VtgsgEq6N0ClokdRSnm9yMqfyl+EvuWH4jwWDA6kRKKaVUg93717HRU0D/pOFWR+k0tEjqQAP6jOfnJ1zFqspdPP3pPVbHUUoppRr8d/MiAM4eqVe11dMiqYNdnPljZieeyKO7lrJmx9tWx1FKKaUwwSBv7P2YKTED6aMtSQ20SOpgYrPxq1mP0s8Zyy8+vw9fXaXVkZRSSvVwa3e9S46vnLkDZ1sdpVPRIskCMZHJ/OmU3/G75JNxbn0HjLE6klJKqR5sYG0ltyZNYtboBVZH6VT0PkkWGTXgNJBI2P4++Tveo8/Qs62OpJRSqicK+EgqzeHqoRfrVW3NaEuSldIyWSY1nL/ydrbv+8LqNEoppXqgL7cs4Y3yLfhS9Q7bzR2xSBKRdBH5QEQ2isgGEbm5I4L1CCJMn3gd0TYnd3zyC3x+j9WJlFJK9TBPb3mRv5R/gz1psNVROp3WtCT5gZ8aY0YBU4EfiYjeirONJMelc/e4G9nkKeDJT35ldRyllFI9SGHZLlZW7OCCvidjs9mtjtPpHLFIMsbkGWO+Ck9XApuA/u0drCc5c8xVXJA8gSdy/suG3R9ZHUcppVQP8Z/1zxPEcMEoHbDdkqMakyQiGcAE4PN2SdOD/fyMP5PujGP31jcg4LM6jlJKqW7OBIMszV3O2Mi+DOozweo4nVKriyQRiQFeA35sjKloYfl1IpIlIlmFhYVtmbFHiItO5d9nP80cRzLs+tjqOEoppbq5itLt2IIB5g2cZXWUTqtVRZKIOAkVSC8YY/7d0jrGmCeMMZnGmMzU1NS2zNhjOFOGY/pN4M3NL/PVjv9aHUcppVQ3Fl+Sw2v9L+Di8ddbHaXTas3VbQI8BWwyxjzQ/pF6trqBJ/PXivXc8fn91NSWWR1HKaVUN+T311GTvxaSh2KPiLE6TqfVmpak6cCVwEwRWRt+zGnnXD2W2x3Hr0/6JXt9FTzyyZ1Wx1FKKdUNfbLlVU7f9QKbI7VAOpwj3nHbGPMpIB2QRYVNGnIu87ct5YW8jzln57uMH6x341ZKKdV2Xt36GlE2J0MGnmZ1lE5N77jdSf14xm/p44jh7s/vx+ertTqOUkqpbmL3/nV8XLGNb/c/A6fDbXWcTk2LpE4qOjKJX2fezk1xJ+Lco19ZopRSqm0s+vrvOBAunfADq6N0evoFt53YSSMugqATcj4jmDIcW1xfqyMppZTqwjyeCpbkr+LspDGkJgyyOk6npy1Jnd3QM1lcs4ur3r4an7/O6jRKKaW6MHfxNp7tfRbXT7zJ6ihdghZJnZ0zkqS0aXxdm8c/V/7G6jRKKaW6KmMgdzUjUkaR0W+K1Wm6BC2SuoBZY69mVsIo/rZrKbvy11gdRymlVBf02dYl/CxnGcUpw0D0ovXW0CKpi7hjxv/htjm455M7CAYDVsdRSinVxfxr4/N8Vref2L76PW2tpUVSF5GSMJDbRi5kbc1evt70itVxlFJKdSE5BQcu+3e5oqyO02Xo1W1dyLyJP+JEPwwtzgVPObjjrY6klFKqC3hp7d+x62X/R01bkroQsdkYOm4BYNiy9p+YYNDqSEoppTq5mtoyluSvYlbSGHolDLY6TpeiRVJXE5nI5/G9uWTLk7z19ZNWp1FKKdXJ+fZ/zaUxQ7lyzLVWR+lytEjqgjJHX87YyL78Yf0/KKnItTqOUkqpzioYID5vA7cMnMOYgWdYnabL0SKpC7I7nNx7yv1UBr384aOfWR1HKaVUJ/W/r59iZelmzMBT9LL/Y6BFUhc1tN8Urht4Lm+VrOPDDS9aHUcppVQn46mr5LcbnuLx6q2QpGORjoUWSV3Y96bfw7jIvpTtWQm+WqvjKKWU6kQWZz1EQaCGG8ffgNj04/5Y6LvWhTmdbp6b/SwXutNh23tWx1FKKdVJ1NSW8dTOZUyNGcTkYedbHafL0iKpi7PF9cMMmMYbO9/ko/Xa7aaUUgpe+PJPlAY93DjxZqujdGlaJHUDgQEn8Vz1du5e+yCllfusjqOUUspKPg8plUVcnDyBsYPOtDpNl6ZFUjfgcERw//TfUBHw8rsPb7U6jlJKKSvt+ZyLogZyz4w/Wp2kyztikSQiT4tIgYis74hA6tiMSJvGDzLO578l3/Du189YHUcppZQFSipyeW3TC/hShkFsb6vjdHmtaUl6FpjdzjlUG7hm+t2McvfmN+v+SlV1gdVxlFJKdbCnPv8D9xV9Rm7qEKujdAtHLJKMMR8DJR2QRR0npyOC+0/5LXcnn0TMjo/AGKsjKaWU6iBb9qzkxX0fMS91EoP6TLA6TrfgsDqAalvD+k9hmLHDtncp2/UBCYNnWh1JKaVUO/P7vdy18i7i7W5+eupvrY7TbbTZwG0RuU5EskQkq7CwsK02q45F/4l85DSc/elPWb/7A6vTKKWUamfPrryfTZ4C7hz7Q+Jj+1odp9UCQcOanFIefn8bi77IsTrOQdqsJckY8wTwBEBmZqb281hJhPETriVh9xvcuuKXvJKylNjoFKtTKaWUag/VxYyrreaqXtOYNXah1WmOaH+Fh4+3FvLR1kI+3V5EWY2vYdmglGhOGpxsYbqmxLRi3IqIZABvGmNObM1GMzMzTVZW1nFGU8dr7c53WfjJrZyVOJo/nv+C3pZeKaW6m2AQ1v4Laoph8vchIsbqRAcpq/Hy2c5iVu4oZsX2InYUVgOQGhvBacNSmTEilUkDE7n8ic8QgbdvPo1Il71DM4rIamNMZvP5R2xJEpGXgNOBFBHJBX5ljHmq7SOqtjZ+8NnckHshD+96nalZD3HJlFusjqSUUqoNvfT5H9mXt5qbpv4CZycpkAoqPHyZXcqX2SV8mV3CxrwKjIFIp50pg5K4bHI604emMKpvHCLS8Lo/XDyWy5/8jD+9u4W7zh9l4REccMQiyRhzeUcEUe3jmlN+xeqidZTkrYGqQohJtTqSUkqpNpBbuIEHty1iUsxAHH3GWZLB4wuwMa+Cb3LL+Tq3jKzsUnJKagBwO21MSE/k5jOHMX1oCuPSEnA5Dt2jMW1IMgumDuDpFbuYM6YPkwYmddRhHFKrutuOlna3dS6B2nLsX/0TbA6YeFWnbI5VSinVen6/l+uWXMTGmjyWnL+IPknD232fJdVeNudXsDW/ks35lazLLWfr/kr8wVAdkRITwaSBCUzOSCIzI4nR/eJw2o9umEdVnZ9zHvyYCKeNt246FbezY7rdjrm7TXV99sh4GHMJqz97gCffnM8D571AlDve6lhKKaWOgQkG+c17P+TL6hx+Pfq6Ni2QvP4gOSU17C6uZldRNdnhn1vyqyiqqmtYLyHKyZj+8Vw3YjBj0xIYlx5Pnzh3k+6zYxET4eD3F4/hyqe+4MH3t/KLc0ce7yEdFy2Seoq4flT2n8iqrHf52dvX8ND5i7A7nFanUkopdZRytr7Bm4VZXJt2Fhdm3tiq1xhjKK/1UVRVR2Gll+LqOgoq6sgrr2VfmYd95bXklXkoqPQQbNTBFOt2MCglmtNHpDKidywj+oQevWIjjrsgOpRTh6Uyf3I6T368kzkn9mVcekK77Kc1tLuth3lp1R/47dZ/Mb/3dO44+696xZtSSnUiwaDBFwziCxi8/iC+QBCvP0idP0idPwAFm4nd8SabIpPw9ruUWr+hps5PtTdAVZ2fmjo/FR4/5bW+hkdZjY/yWi++wMGf9xEOG/0SIumX4KZvfCT9EiLJSI4iIyWajORoEqOc7VYMHU6Fx8c5D35MrNvBGzeeQoSjfbvdtLtNAXD5tJ+xr2ovz+77gLSV93P1KXdbHUkp1Q3Vf9gHgqbh4W803dLzQNAQMIZAMEggCP5gkGCQJvMarxdsPt1kHg3zAsFmy40hEAy1rhz0+vrXhZ8bQ5N1guHXBuu3a8yB6YasB+Y1ng6a0DEFAgdy+YMGf8DgCwQb3o9D6RW5jvHuVcRXjODfgSEE+LrJcodNiI5wEOt2EB/pJCHKSe+4mPC0i5SYCFJi6n9GkBobYVkRdCRxbie//dYY3t2w/7DvSXvTlqQeKBgMcNub38FWV8n/nfoHpE+rbn+llOpAwaDBGwiGHuEWBZ/f4A0E8PpDy0LzguHp0Aetr2H9A8/rp/2BIN6AwR/+QPaG5/kD9dMGf7gVo+FnIFTo+AKhD/D6wqd+3cbL6p/7g6ZTf3Wk3SbYRRA5MG2zCXabYBPBFp5vk/p5hJaHn4sIdhvhbUijbTR9XcN267djE5zh/TjsB9Zx2G047ILTFvrpsAkuhw2X3YYz/NPj2crjO35GtM3F3ZnPExOTjNtpI9rlIDrCQXSEvd1bW7ozbUlSDWw2O7+b/TSO9a8hm9+k0lNCbMZpVsdSXYgJBqmsLaaipoCK2mKqPKVMSRgBfg8rC9awsWIntX4PdYE6PAEPNoQ7MuaCCfJi/kq+qsxGAJvYsImNeEcUP8+YC2Lj34VZZHuKcNpcuOwu3PYIktyJXNB/BthdrK/MpjboI8oVR6QrlqiIWKIjEoiNTALbsX1IBIIm3KURaOjaqC9OvI2nG3V9NCzzB0JdI4Fm8wOBg15f16j7xNtQ9LS8rL3+enbZbTjtgtNhw2ELTTf9gK6fZ8NhE6JcDuw2Cc2z2bDb6z/oQ+vZbaEPdYfddmA6vNzRaHn9T1ujwsBuI7ReuLCoX89Wv259sWE7UFAceE6jIubAfFsripauZk/BN/zg/V9hs8GTZz/OwN5DrI7UY2iR1EO5XFEwbj7l6xbxnRU/Z8a2Sfz0zIewHeOHjOomjKG6tpjc0m3sL88hvzKX/dX5FHgKubPfLNx+L4/lfcg/StbiJ9jkpV+lz8cpNpaXfMniqm0IECkO3DYH0TYXxI8FsbG3cg9bqnMxBoIYAiZIvC2CctdW/P4Ay0s+Y1XdXnwEqC8T+ks0w7btIxA03OtfxWZKmuw7PRjLTz1T8Adt/M39FUW2GhzGgcM4sBsHSb4kTqyciCdoY33UBjziwwTsBIJOAgEHUpeIuzqDADaqo3cTFCFoHBjjwATtGH8s+JIJYiPgKiFobASxgXFgEIJBN8FgJAZwOAx2uxOH3YnL4Qq1CDRqFYiw24hyOUgIz6tf7rTbiHCECo/Q+nacDmlYx2lv2rLgcshB85zhFon66fpiqHELRWfsWlGH9vnWpdzy+X0IwqOn/I6BvcdaHalH0SKpJ7M7iRkzn+kFK3lu34fkv/kdfjv7KSJc0VYnU+0kGDRUVJeyq3A9e0p3sLd8N3nV+8jzFHBD7Emk+gK8XL2ep+o2NLxGgAQiOaVyMBG2JLyBdKY6XbgkDjsxYKIxwVju3TeMmqCTqsBJjA/Y8fgceINQ5wvgCQSZnlM/+HRwQ4tLYwduhVd/yW8QGwEctjpyxMu3Ay6cBLBF9CLaUYnd5sEudTjsXkScvOQZSJQ9iC2ukARnBcbmIyA+guLHYfczKLKGCFuAzyJ3UGyrwU8AE64XJppe3Eio++SHvE8VvibZZjrSuS1yEnabcF75UoKNCkQB5kcN5Y6kTIISZNKelzGAD/ADPmx8O2EMNyRPoiLo59u5rxMhDiJsTiJsDgI2F+emTOLcXpOoMAGeyvuIaEcU8e4E4iISiHcnMTRxBL3i+mMcUYgzoq1+HVRnt3c1u7csI9URwyNnPkp6rzFWJ+pxdEySwgSDPLfyfv604xUmRqXxl3OfIT6mj9WxLNN4MOdBg0rD8/2BA4Mum4/FqB+v0eL84IHxIKF1Doz/qJ/nDwTxhddrWBYwjcaJNB5jcmBcSf08r9+PzRRglz3YbPsI2goJOEoYUZJG/zob+bF5fNB3Z8PxOgN2In2RDM/LJOjtS7HTS3lENR5vMrX+VKr9yRgOvl2E3SZEOEKtHy6HjQiHPfzT1uinHZfdhtsZWh7hDLV4RDhsRDjtDa9vaRv1065G60Q47Q0tKxHh1pNj7T4xwSA+vwePrxqCPuIcUWCCbC/bTp2vFq+/Fn/Qhy/oI8UVz/DYARAM8Pa+FfiDPgImQNAE8AV8DI3px8T4YfgDPp7f8y6BoB9f0I8/6McX9DE5fginxo+g0lfF73YtoS7opS7gxRP04Ql6+XbCicyNGUKOp4gLc17D16yV7peJk7ksdhhbvKVcuf89kuyRJDtjSHLF0SsikYvTZjIqZRRVNjv5gRr6JA4hJrLzfEmoOjo+n4et655ndEURJA+lbsQ5RETEWR2rWzvUmCQtknowY0zDWAqvP8j73zzF77c8zqyoIfy/0XdQEzcUb7MBmv6gOejKjGCjn42v7PAHGl3h0XDVCYe4EqXpVScN2zzo9QfmNV5+qKtKGr+2aUbCV8scuOIkWH81TScYcFo//sNhD3WpOGzS0JXitNtwSh1Rzn04bXmILZ+AvYgR/j6c4I+ixL6XJ6K/bNiWGEggiotsJzM4YjSlThu7pZjEqEHERw8mJrJXs+4eW5MuoiZFSqPCxd4Fx3Z0FV5vDRW1RVTUFFJeU0i/iAR626PYW5HDiznvUOwppdhbTrGvkkJfFfcnT2VGZH8+rt3Ljwo/AiBGnPRxxdEnIpGfZMxleNIICoyf3EAN/RKHkho3UO+V1gntyl/DvZ/eycaaPN6afA8pIy4AvVVLu9OB292IMYaKWj8lNV5Kqr1U1Pqo8ITuhxGa9lPp8VNdF3pU1fmp9vqp8Qao8wWp9QXw+ALU+gLNrkAZQKr7crzsYtnXj7HFHsNnZhil3rYfJNj86pHmV5fYbeCw2UIDL5tfIdLCYE6bDZw2W5PtNQzkrB8o2mjabm8+CLSlgaGNBptKaHBr48GloUGptvAg1APzD7zO1mS+w2ZrGABrDxc9jQe9OhrN89RVkle6nbyyneyr2M2+qn2Mc/dihrsv+6v2ctauF5q8n26xc/GAJC7rN40KxxSSy0aQnjCI9KQR9E8agdPpbvNzqNqPyxVFimsAKfEDmszv33cst404/+AXBPzgrWRkeQ5/zB9PftU+8qrzyKstJL+uFFtpNpTl82HlNn5dGiqgHQi9nbH0cyXw26GX0yd+INmBavYH6+iXMJjeCUNCYxdVhygqz+HxVffz6v7PiBA7d514HSkj51kdq8fTIqkTqfMHwndA9ZBf4aGgwkNhZR2FlXUUhH+W1HgprfY2fFdOS9xOGzERTmIi7OFLQx30inUT6bLjdtiJdNlwO+y4nXbczsYtBnZcjnE4bYaUio1szn0Y4/+Iy+Kmcs6I24iLSm646uSgAqK+oDlEgdL8ctoeO3jUGPDXsbNoI3sqdlNYtY+C6v3sr9nPMFci344bTsBTzrQdz+DnwDm2I1ydOI4Z6f1JSRnFD4PnkxY3gLT4QaQljyAlbmDDjUHjgCu4wKIDVJawOyAykdTIRGYf6otO/V5mlmfTr+Br9lXkkFe1l701+8nzFBFZuR/KcllWupYnKw6MR0uxR9LXFc8/RlxLVHQKaz0F7A946BM3gN7xGaTEDcDhcHXQQXZTfi/lO5dzwWd34DF+Lu19Mj84+U6S49KtTqbQ7rYOVV3nZ09pDbklteSW1pBbWsue0hr2lXnIK/c0+V6cei6HjV6xoZt+1d8ILDHKRVJ06JEY5SI+ykl8pJM4t5O4SEeb3SujpGIvf1lxN/8u+IIocTIjcSTfGnoRJw2fB3Ztpq/n9dZQWpWHt66C9IgE8NXy5p7/kV25h2JPCcV1ZRR7KxjqjOfe5CkQ8DNr7xLyAzUN24izuZgTfwJ3ZsyDiFieL/yChKhU+sYNpF/CEHolDMLh0AG7qh0FAxSV7WJH0QbyK/aEBvRX51NUV8qjfWcj3gruLPiEZdW7Gl4iQJozjreGXwuuWF4v30Sev5qUqFSSo3qRHNOXXrFp9EsYAlpMNQgGA3yz+wPW7fmIK+2p4K1mMeWcNOpyMnofoshV7UrHJHWQSo+PXUXVDY+c4hp2h78ssKjK22Rdt9NGWmJU6Jbw8aFbwvdNcNM3PvRIjXUT53ZY3uqyYfdHLN7wLB8Uf8P8mGH8KHkidQkDeMdXREbSCaSnjCQhuk+X+4qTYDCAp66SGm8Ftd5KvN5qhkT3hYCXNUXryK7cQ2VdBZXeCqp81TiBW/qeAf46fpXzBiuqsqkI1FFr/AAMdybwWt85AHwn/x2+8RaTaHeT7Igm2RnL2NgMbhx8IUTEsrJiB66IeFJj00iNH6hfOKw6P2OorCkir2wH+eW72V+1l8Lq/fj9tdzU+xSoq+Qnu5fwv+psGn+qDHLEsazf+WB3cFvRSvb4Kkl0xZLojCXeFcvQ2HQuHjALHJGsq9qN3RFJbGQScZGpxEQmd5uWKp/Pw/qcD3l3xxu8V7ia/f5qnNhYPuYWEoacCfFpVkfs0bRIakPBoGFvWS3bC6vYUVDFjsIqdhSGiqLCygOtQSLQN87NgOQoMpKjGZAcxYCkKNISo0hLjCQ52mV5AXQ0/H4v3pLtRJXt4ePs9/hR3jsNy6LFSZornl8MPJ9J8cPY4ilkSdFXRDrcRNjd2MWO3WbnvN5T6eVOYmdNHp+VbAJCf41CqAvu3N4nEe+MYXPlbrJKN2MwBIMBAiZI0ASY328GMfYIvijdzIrSjfjDVxD5g378JsAvBpyHW2y8XpDFO6Xr8Qb91AV9eII+vMbPsoGXIUE/9xd8yuLKLU2OL1IcfJH+bQBuL1rBf2t2NyyLESfprnheHvIdcLh5qiiLbF8Z8c444lyxJLiT6BvTj1P7TwdnFFUEcUckdJv/4JVqLb/fS2nVXooq91JUtQ/jq+G0+BHgq+bhnUvYVJVLia+Scn8t5QEPJ7qS+EfvMwGYs28Ze/xVTbY3K2ogD/Q/B+wR3LD3P3gxRNvdRDkiibJHMiFhKHP6TAO7i9fzV+CwRxDljMbtiMLtiqJPVF/6x6ZhxEahtwyXIwqXIxKn043D5mqzP+5MMEiVp5Ty6nzKa4rIr8hhe8lmzo0ZzIBAkDcKsrijeCUubJwcP4yzB8xkxohLiYtObZP9q+OjA7ePQSBoyC2tYev+Krbur2R7QejnzsJqan2BhvWSol0MTonmjBGpDEqJYVBKNENSo0lPisLt7D43Z3Q4XDh6jYJeo5g+eCZLCuezp2QrueXZ7Kncw56afGL8XqjYS275VpbsX0Wt8Te6JSBMqqqgV0QKa6t28LuSzw/aR2Z5MfGuBL6s2Mz/lX110PLz6gwxjmjWVWzg+bJvcIgNh9hwig0HNurix+B2RFPjraDCX4PT5iDGEUmSLQ63zYk/Ph2n0810p5BUMwS3I5JIRySRzihiXHGQdirYXdzqvZAfixATmUy0OxG7vek/lWtZcNj3KuYY32OlujqHw0VqwiBSEwYdtOzmoWcdNC/g90LAC75afl+QSUltIZV1ZVTUlVNRV0GaKx6ShkCgDofNSam3goK6cmqDPmqCXoI1hcyp9WGM4Z49iwjS9A//K2KG84ukTLwmwJl7FjdZJsB18WO5IXkiZUEf39rzesP/KQ6xYxcbVyVN4KLEE8n3V/HjnDcaboAaMEH8JsD1KZM5LzqD9VW5XJH/9kHHN7DvLAb0PZkpQ+bw5/SpnDx8rt6eoQvRliRCV4sVVNaxOb+SrfmVoZ/7K9lWUInHd+B+JX3j3QzrHcvQ1BiG9jrwSIrW1oLD8fk9BAI+gsEAEXYXdhHq/B5q/LUYE3p/DQZjDAkR8ThszvDXWdSBCHabA5s4sNscuOwRiM0eaqZTSimAYADjr6OgKg+PrxqPt4paXxW1vmp6uxIYHN0Hn9/DktwP8Abq8Aa8DY9JcYM4OX4Ylb5q/py9DJ8JNLRMB02Q85PGcGbCSAq8Ffwq5w3sSKhlXGw4bHYuTM3k5MRRlOJnWeFXxLsTSYhMJiWmL4N7TSAqMsHqd0e1gna3hdV4/WzdX8XmvAo251eyOT/0s6zmwB12e8VGMKJPLMN6xTKiTwzDescyrFcMsW4drKyUUkp1N8fV3SYis4GHATvwD2PM79s4X5szxpBbWsumvAo25R0ohrKLqxvuDRTlsjOiTyznntiXE/rEMqJPLMN7x2rLkFJKKaWOXCSJiB14DJgF5AJfisgyY8zG9g7XWjVeP1vyK9mUVxkuikIFUVVd6KojERiYFMXIvnFcOL4/I/rEMqpvHGmJkV3yG6GVUkop1f5a05I0BdhujNkJICKLgHmAZUXSR1sL+Sa3rKEo2tWodSgmwsEJfWK5aEJ/RvaN44S+sYzoHUt0hI5RV0oppVTrtaZy6A/safQ8Fzip+Uoich1wHcCAAQOaL25T//f2Zjbsq2BAUhQj+8Zywbh+jOwbp61DSimllGozbda8Yox5AngCQgO322q7LXnsiokkx7h0ILVSSiml2k1riqS9QOMvkUkLz7NMRkq0lbtXSimlVA/QmluNfgkME5FBIuIC5gPL2jeWUkoppZS1jtiSZIzxi8gNwDuEbgHwtDFmwxFeppRSSinVpbVqTJIx5i3grXbOopRSSinVaXStr21XSimllOogWiQppZRSSrWgXb67TUQKgd1tvuGmUoCidt6HOjp6TjonPS+dj56TzknPS+fTUedkoDEmtfnMdimSOoKIZLX0ZXTKOnpOOic9L52PnpPOSc9L52P1OdHuNqWUUkqpFmiRpJRSSinVgq5cJD1hdQB1ED0nnZOel85Hz0nnpOel87H0nHTZMUlKKaWUUu2pK7ckKaWUUkq1m05fJInIbBHZIiLbReTnLSyPEJHF4eWfi0iGBTF7lFack1tEZKOIrBOR/4nIQCty9jRHOi+N1rtYRIyI6FU87aw150REvh3+97JBRF7s6Iw9USv+DxsgIh+IyJrw/2NzrMjZU4jI0yJSICLrD7FcROQv4fO1TkQmdlg4Y0ynfRD6rrgdwGDABXwNjGq2zg+Bx8PT84HFVufuzo9WnpMzgKjw9PV6TjrHeQmvFwt8DHwGZFqduzs/WvlvZRiwBkgMP+9lde7u/mjleXkCuD48PQrItjp3d34ApwETgfWHWD4H+C8gwFTg847K1tlbkqYA240xO40xXmARMK/ZOvOAf4anXwXOFBHpwIw9zRHPiTHmA2NMTfjpZ0BaB2fsiVrzbwXg18AfAE9HhuuhWnNOvg88ZowpBTDGFHRwxp6oNefFAHHh6XhgXwfm63GMMR8DJYdZZR7wnAn5DEgQkb4dka2zF0n9gT2NnueG57W4jjHGD5QDyR2SrmdqzTlp7FpCfwGo9nXE8xJuok43xvynI4P1YK35tzIcGC4iK0TkMxGZ3WHpeq7WnJd7gAUikkvoy91v7Jho6hCO9nOnzTg6YieqZxKRBUAmMMPqLD2diNiAB4CFFkdRTTkIdbmdTqjF9WMRGWOMKbMylOJy4FljzJ9FZBrwvIicaIwJWh1MdazO3pK0F0hv9DwtPK/FdUTEQahptLhD0vVMrTkniMhZwJ3AXGNMXQdl68mOdF5igROBD0Ukm1C//jIdvN2uWvNvJRdYZozxGWN2AVsJFU2q/bTmvFwLvAxgjFkFuAl9h5iyRqs+d9pDZy+SvgSGicggEXERGpi9rNk6y4Crw9OXAMtNeKSXahdHPCciMgH4O6ECScdYdIzDnhdjTLkxJsUYk2GMySA0VmyuMSbLmrg9Qmv+/1pCqBUJEUkh1P22swMz9kStOS85wJkAIjKSUJFU2KEpVWPLgKvCV7lNBcqNMXkdseNO3d1mjPGLyA3AO4SuSHjaGLNBRO4Dsowxy4CnCDWFbic08Gu+dYm7v1aekz8CMcAr4TH0OcaYuZaF7gFaeV5UB2rlOXkHOFtENgIB4DZjjLaEt6NWnpefAk+KyE8IDeJeqH98tx8ReYnQHwsp4XFgvwKcAMaYxwmNC5sDbAdqgO92WDY970oppZRSB+vs3W1KKaWUUpbQIkkppZRSqgVaJCmllFJKtUCLJKWUUkqpFmiRpJRSSinVAi2SlFJKKaVaoEWSUkoppVQLtEhSSimllGrB/wd9l4wP012KewAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -491,7 +527,7 @@ }, { "cell_type": "code", - "execution_count": 102, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -502,12 +538,12 @@ }, { "cell_type": "code", - "execution_count": 103, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -520,14 +556,32 @@ ], "source": [ "plot_transformer_density(\n", - " partial(flow._blocks[3].transformer.cpu(), inverse=True),\n", + " partial(flow._blocks[5].transformer.cpu(), inverse=False),\n", " label=\"wurst\"\n", ")" ] }, { "cell_type": "code", - "execution_count": 104, + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "flow = flow.cuda()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "train(flow, cuda=True, train_with_inverse=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -536,24 +590,180 @@ }, { "cell_type": "code", - "execution_count": 106, + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot_evaluation(flow, cuda=True, n_samples=10_000, use_log_norm=False, train_with_inverse=False, eps=0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 529, + "metadata": {}, + "outputs": [], + "source": [ + "def make_transformer(\n", + " d_in,\n", + " d_out,\n", + " d_hidden,\n", + " n_components,\n", + " periodic=False,\n", + " zero_boundary_left=False,\n", + " zero_boundary_right=False,\n", + " activation=torch.nn.SiLU(),\n", + " smoothness_type=\"type1\",\n", + " init_weight=1.,\n", + " min_density=1e-8,\n", + " verbose=False\n", + "):\n", + " return WrapCDFTransformerWithInverse(\n", + " transformer=(\n", + " t:=MixtureCDFTransformer(\n", + " compute_weights=make_net(d_in, d_hidden, d_out * n_components, activation, periodic=periodic),\n", + "# compute_components=MoebiusComponents(\n", + "# compute_params=make_net(d_in, d_hidden, d_out * n_components * 2, activation, periodic=periodic)\n", + "# )\n", + " compute_components=AffineSigmoidComponents(\n", + "# conditional_ramp=SmoothRampWithTrainableExponent(\n", + "# compute_params=make_net(d_in, d_hidden, d_out * n_components * 2, activation, periodic=periodic)\n", + "# ),\n", + " conditional_ramp=SmoothRamp(\n", + " compute_alpha=make_net(d_in, d_hidden, d_out * n_components, activation, periodic=periodic),\n", + " unimodal=False,\n", + " ramp_type=smoothness_type\n", + " ),\n", + " log_sigma_bound=torch.tensor(3.),\n", + " compute_params=make_net(d_in, d_hidden, d_out * (3 * n_components), activation, periodic=periodic),\n", + " min_density=torch.tensor(min_density),\n", + " periodic=periodic,\n", + " zero_boundary_left=zero_boundary_left,\n", + " zero_boundary_right=zero_boundary_right\n", + "\n", + " ),\n", + " )\n", + " ),\n", + " oracle=GridInversion(\n", + " transformer=t,\n", + " compute_init_grid=lambda x,y: torch.linspace(0, 1, 100).view(-1, 1, 1).repeat(1, *y.shape).to(y),\n", + "# compute_init_grid=AffineSigmoidComponentInitGrid(\n", + "# t._compute_components\n", + "# ),\n", + " verbose=verbose\n", + " )\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 530, + "metadata": {}, + "outputs": [], + "source": [ + "from functools import partial\n", + "\n", + "flow = make_coupling_flow(partial(make_transformer, d_in=1, d_out=1, d_hidden=64, n_components=3, periodic=True, verbose=False))# .cuda()\n", + "\n", + "# flow = flow.cuda()" + ] + }, + { + "cell_type": "code", + "execution_count": 549, + "metadata": {}, + "outputs": [], + "source": [ + "from bgflow import Flow\n", + "\n", + "class AutoregressiveModel(Flow):\n", + " \n", + " def __init__(self, n_components=9):\n", + " super().__init__()\n", + " self.t0 = make_transformer(1, 1, 64, n_components, periodic=True, activation=torch.nn.SiLU())\n", + " self.t0._transformer._compute_components.compute_params = self._compute_t0_params\n", + " self.t1 = make_transformer(1, 1, 64, n_components, periodic=True, activation=torch.nn.SiLU())\n", + " \n", + " self.mu0 = torch.nn.Parameter(\n", + " torch.randn(n_components)\n", + " )\n", + " self.log_sigma0 = torch.nn.Parameter(\n", + " torch.randn(n_components)\n", + " )\n", + " self.min_density0 = torch.nn.Parameter(\n", + " torch.randn(n_components)\n", + " )\n", + " \n", + " def _compute_t0_params(self, x, y):\n", + " ones = np.ones(len(y.shape), dtype=int)\n", + " m = self.mu0.view(*ones, -1).expand(y, self.mu0.shape[-1])\n", + " s = self.log_sigma0.view(*ones, 1).expand(y, self.log_sigma0.shape[-1])\n", + " d = self.min_density0.view(*ones, 1).expand(y, self.min_density0.shape[-1])\n", + " return m, s, d\n", + " \n", + " \n", + " def _forward(self, x):\n", + " x0 = x[:, [0]]\n", + " x1 = x[:, [1]]\n", + " z0, dlogp0 = self.t0(torch.zeros_like(x0), x0, inverse=False)\n", + " z1, dlogp1 = self.t1(z0, x1, inverse=False)\n", + " z = torch.cat([z0, z1], dim=-1)\n", + " dlogp = dlogp0 + dlogp1\n", + " return z, dlogp\n", + " \n", + " def _inverse(self, z):\n", + " z0 = z[:, [0]]\n", + " z1 = z[:, [1]]\n", + " x1, dlogp1 = self.t1(z0, z1, inverse=True)\n", + " x0, dlogp0 = self.t0(torch.zeros_like(z0), z0, inverse=True)\n", + " x = torch.cat([x0, x1], dim=-1)\n", + " dlogp = dlogp0 + dlogp1\n", + " return x, dlogp" + ] + }, + { + "cell_type": "code", + "execution_count": 550, + "metadata": {}, + "outputs": [], + "source": [ + "flow = AutoregressiveModel(n_components=3).cuda()" + ] + }, + { + "cell_type": "code", + "execution_count": 551, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "it: 900/1000, nll: -1.833\r" - ] + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "train(flow, cuda=True, train_with_inverse=False)" + "plot_transformer_density(\n", + " partial(flow.t0.cpu(), inverse=False),\n", + " label=\"wurst\"\n", + ")" ] }, { "cell_type": "code", - "execution_count": 109, + "execution_count": 552, "metadata": {}, "outputs": [], "source": [ @@ -562,35 +772,175 @@ }, { "cell_type": "code", - "execution_count": 110, + "execution_count": 553, + "metadata": {}, + "outputs": [], + "source": [ + "def train_with_energy(flow, energy, train_with_inverse=False, batch_size=256, learning_rate=2e-4, n_iters=1_000, print_interval=100, cuda=False):\n", + " optim = torch.optim.Adam(flow.parameters(), lr=learning_rate)\n", + " for it in range(n_iters):\n", + " x = torch.rand(batch_size, 2) \n", + " if cuda:\n", + " x = x.cuda()\n", + " y, dlogp = flow(x, inverse=False) \n", + " kll = (energy(y) - dlogp).mean()\n", + " \n", + "# print(energy(y))\n", + " optim.zero_grad()\n", + " kll.backward()\n", + " optim.step()\n", + " if not it % print_interval: \n", + " print(f\"it: {it}/{n_iters}, kll: {kll.item():.4}\", end=\"\\r\")" + ] + }, + { + "cell_type": "code", + "execution_count": 554, + "metadata": {}, + "outputs": [], + "source": [ + "beta=7\n", + "\n", + "from scipy.special import i0\n", + "\n", + "phi1 = torch.tensor((4.18, 5.96))\n", + "phi2 = torch.tensor([(0.21, 2.85),(1.89, 6.18),(3.77, 1.56)])\n", + "phi3 = torch.tensor((1.94,))\n", + "\n", + "def uni_modal_density(theta, phi, beta):\n", + " theta = theta * 2 * np.pi\n", + " return torch.exp(\n", + " beta * torch.cos(theta - phi).sum(dim=-1)\n", + " ) #/ ((2 * np.pi * i0(beta)) ** 2)\n", + " \n", + "def multi_modal_density(theta, phis, beta):\n", + " return uni_modal_density(theta.unsqueeze(-2), phis, beta=beta).mean(dim=1)\n", + "\n", + "def correlated_density(theta, phi, beta):\n", + " theta = theta * 2 * np.pi\n", + " return torch.exp(\n", + " beta * torch.cos(theta.sum(dim=-1)) - phi\n", + " ) #/ ((2 * np.pi * i0(beta)) ** 2)\n", + "\n", + "\n", + "def energy(x):\n", + " density = -uni_modal_density(x, phi1.unsqueeze(0).to(x), beta=beta).log()\n", + " density = -multi_modal_density(x, phi2.unsqueeze(0).to(x), beta=beta).log()\n", + "# density = -correlated_density(x, phi3.unsqueeze(0).to(x), beta=beta).log()\n", + " return density\n", + "# energy = lambda x: -uni_modal_density(x, phi1.unsqueeze(0).to(x).log(), beta=beta)\n", + "# energy = lambda x: -multi_modal_density(x, phi2.unsqueeze(0).to(x).log(), beta=beta)\n", + "# energy = lambda x: -correlated_density(x, phi3.unsqueeze(0).to(x).log(), beta=beta)" + ] + }, + { + "cell_type": "code", + "execution_count": 555, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Computing energy plot...\n", - "Sampling ground truth...\n", - "Sampling model...\n" + "it: 19900/20000, kll: -9.964\r" ] - }, + } + ], + "source": [ + "train_with_energy(flow, energy, cuda=True, n_iters=20_000)" + ] + }, + { + "cell_type": "code", + "execution_count": 556, + "metadata": {}, + "outputs": [], + "source": [ + "def ess(flow, n_samples, energy, cuda=False):\n", + " with torch.no_grad():\n", + " x = torch.rand(n_samples, 2)\n", + " if cuda:\n", + " x = x.cuda()\n", + " y, dlogp = flow(x, inverse=False) \n", + " u = energy(y)\n", + " u = u - u.min()\n", + " weights = (-u.unsqueeze(-1) + dlogp).exp()\n", + " return (weights.sum()).pow(2) / weights.pow(2).sum() / n_samples" + ] + }, + { + "cell_type": "code", + "execution_count": 557, + "metadata": {}, + "outputs": [], + "source": [ + "with torch.no_grad():\n", + " x = torch.rand(20_000, 2).cuda()\n", + " y, dlogp = flow(x, inverse=False) \n", + " u = energy(y)\n", + " weights = (-u.unsqueeze(-1) + dlogp).exp().view(-1) # .softmax(dim=0).view(-1)" + ] + }, + { + "cell_type": "code", + "execution_count": 558, + "metadata": {}, + "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdQAAAHiCAYAAABRBD3cAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABAd0lEQVR4nO3de5CkWXnf+d+TWZl1667q20xPz4VhhhluK0BjjxAyCsyC1oElrXGEZa1kW0YOvPxjr5Fsh4X8j7QRqw1rQzJS7GoVwQrbrFcWyAgZ5JC8Fiw4JO0uywCSYWYYGM19pq/TXV1d98rMs39UIfp5zqHz7exTl6z6fiImek7We8v3fbNOvvU85zmWUhIAALg1rb0+AAAADgI6VAAAKqBDBQCgAjpUAAAqoEMFAKACOlQAACqgQwUAoAI6VGAPmdkzZrZqZkvX/fe/7PVxAbh5E3t9AAD0X6eUPr1TGzeziZRSb6e2D2ALT6jAPmRmP25mf2hmv2BmV8zsaTP7y9f9fN7MPmxmZ83sRTP7H8ysfd26f2RmHzSzlyX9rJmdNLPfMbNFM/vC9vJ/uL38r5jZL4b9f8rMfnJX3zQw5uhQgf3ruyU9IemUpP9J0ofNzLZ/9q8k9SQ9IOkhSX9J0t8N6z4l6bSkn5P0K5KWJd0h6T3b/33TRyT9qJm1JMnMTkn6Pkn/ZifeFHBQ0aECe+/fmdnCdf/9t9uvP5tS+t9SSn1tdXpnJJ02s9OSvl/ST6SUllNKFyR9UNKPXLfNl1JK//P2n3o3JP01ST+TUlpJKT22vT1JUkrp/5N0VdI7t1/6EUmfSymd38H3DBw4xFCBvfdXYwzVzH5c0rlvtlNKK9sPp0cknZDUkXT2Ww+sakl6/rpNXP//t2nrs/7tfi5tdbB/S9Lvb//7y6O9FeDwokMFxs/zktYlnbpBstH100hd1Nafh++W9PXt1+4Jy/8fkr5qZm+S9DpJ/67a0QKHBH/yBcZMSumspP8o6RfNbM7MWmb2KjP7i99m+b6kT2grOWnGzF4r6W+HZV6Q9AVJ/1rSb6WUVnf2XQAHDx0qsPd+J4xD/e0G6/xtSV1Jj0m6Iunj2oqxfjt/X9K8tv6M/K8l/Ya2nnKv9xFJb9j+OYCbZEwwDhw+Zvbzku5IKb3nutfepq0//d6b+MUA3DSeUIFDwMxea2ZvtC1vlvReSb993c87kt4v6dfoTIHR0KECh8NRbcVRlyV9TNIvSvqkJJnZ6yQtaOtPxr+0N4cHjD/+5AsAQAW39IRqZu8ysyfM7Ekz+0CtgwIAYNyM/IS6XTf065L+K0nfTLn/0e0qLAAAHCq3UtjhzZKeTCk9JUlm9lFJ79ZWGn9R1ybTlGZvYZfADdjwRTJEPADcpGu6cimldFt8/VY61Lvky5e9oK2C3N/WlGb13fbOGy0CNNdqu6a1br5HTYMRetQ0uPl1ituhNwfG0afTx58tvb7jpQfN7H2S3idJU5rZ6d0BALAnbiUp6UX5eqB3b7/mpJQ+lFJ6OKX0cEeTt7A7AAD2r1vpUL8g6UEzu8/Mutqa8ulTdQ4LaCAN/H+7xVr5fwAOvZH/5JtS6pnZ35f0f0pqS/oXKaVHqx0ZAABj5JZiqCml35X0u5WOBQCAscXfqgAAqIAOFQCACnZ82AywY8I4ztTvZ4tYu5295n5eGLs60tjUUVjYN+NSgbHGEyoAABXQoQIAUAEdKgAAFRBDxcFRiEHGuOqwmKqUx1UbxVRjcYdRCk0QUwXGGk+oAABUQIcKAEAFdKgAAFRADBUHWxyr2uvtzXG08thtq9tx7RRjpqXYbYjNZvHdJrFbYrPAjuAJFQCACuhQAQCogA4VAIAK6FABAKiApCRgNwzywv2Dtfy1sRIKUTQpmlFDlohVOLfAXuAJFQCACuhQAQCogA4VAIAKiKFifFFMfm8Nm+A9ThiwQ2wi/zU2dEKDUgEM7h/cIp5QAQCogA4VAIAK6FABAKiAGCrGR4yZNvk5cbEDr9EE8FExvhviqtw7uEk8oQIAUAEdKgAAFdChAgBQAR0qAAAVkJSE/ak1QqH10mB97JxhSWLAIcMTKgAAFdChAgBQAR0qAAAVEEPF7ivE3kaZnDob0M9A/J3TJF66S8Xwgf2KTwAAABXQoQIAUAEdKgAAFRBDxc4L8TfrdvNlYjy0lcfs0mYvrNPPlsHhY4V7ZZiRCuoDQ/CECgBABXSoAABUQIcKAEAFdKgAAFRAUhLqC4XtreNvMysUCUjhq12WgCSRhLTf7FIhh1GSjursuNJ+KThyaPCECgBABXSoAABUQIcKAEAFxFBxawpxpla3E14I39tKhfBXV32bycL31h5NHt4oXlohdmut/P5KgxjI5x7EzeEJFQCACuhQAQCogA4VAIAK6FABAKiApCTcnJCs0pqczJcJSUgWlknr69kq2ewfDIbfX0ZIBKpWkCHuu8F2Y/GQFO+nJjVCmrznJolLMcGLe/vA4gkVAIAK6FABAKiADhUAgAqIoeLGQvzHJoYUbZBkM9P+hY1N10z9QgCLQfRjZ2iMdJS4a7uwTrzHYkyycA9m290M92ChuIjZkNhm4R7NikE0Wa9J0QzirGOJJ1QAACqgQwUAoAI6VAAAKiCGihuy9pDJwmdn85VCzCiLmRZjqMSM9lSM64X4Z7wPipqMD43biffXROFXUnjN4uQLg0JssxfusRDXLx5pvC97fpL74qT3YRnF8dSSlMKY2GzMdSF/gLGrY4knVAAAKqBDBQCgAjpUAAAqoEMFAKACkpLwLa3CYPdQ2N6mp3w7JoioUPw+JHsUCztg9xQKCwxNFioVI4gFFeI6k918P7Mzrj046pPaNm7zP5ekftfvp73hk3gGnfy5oDftX0vtMKnDZp7kM7Hs78vOor+PW1dXsnVaS/61tLqaLZMlMzVIZMo/IyFxiSSlfYknVAAAKqBDBQCgAjpUAAAqIIZ6mMXJwqfyycKzQg7TofB9qZj5io8jpT7xnz0VJzgoFYaPBRU6PjZeipXbjI93bt5z0rUXXp3HQ1dvD/dcCLe3N/J7ozfj1+n5ML7avu69JKmz6LczseZ/3uoV9hPirr0Zf54m5vLPx8TKEb/dpY1smdZyiKuu+oNJa+HgJKU4ocSG3255ggk+V3uNJ1QAACqgQwUAoAI6VAAAKiCGepgMi6WVxice8TGiwXyIGcX4kMS4071UuoZhUngrxcrjpPAnj7nmtdccz9ZZfIW/fwYhzNoPsU5J6s36ON/miTAmc6IwPvSi3/DMOf8eJxfydbpLPm7fXfD76V7J45atRX8v26oP8KbNQrC2wb2dsokGQjt8xiTJ4mcojG8dLC3n+4nH0iSmShH+qnhCBQCgAjpUAAAqoEMFAKACOlQAACogKekQywrfz+QD8QcnjvoXYkH0Xp6UEQehKw2yZVBJmNAgFuKQpNbcnGunMyezZZbu98tshiIHS3fn372X7/bX1U76JJ7bTy5m67TNJ728+Mwp1z7ytbyAxMx5v87MBZ8cNHk+L1rfvuz3nZZDEfv1vABDTDoaZAVJdug+LhXa6PqJBVphUoFWoaD+YCW8x7CMtQoTHAQjJTbhz/CECgBABUM7VDO7x8w+a2aPmdmjZvb+7ddPmNnvm9k3tv/N8+oBADgkmjyh9iT9o5TS6yW9RdLfM7PXS/qApM+klB6U9JntNgAAh9LQGGpK6ayks9v/f83MHpd0l6R3S3r79mIfkfQ5ST+1I0eJm9dkEukYD53PB5j3Z32ctb0cqpnHyZIlpfgacZh6Qsw0TmjQuuP2bJXV+33MdNDNv0cv3eG3u/A9/jqfvv1qts4b5i679rGuLz7w2WcezNbRV31M/tRz/t44+mIe25x6wcdD7bI/lsFyHkPtxzh+LJRQiEFWiZGOUkyhVBwivDYIbZvOq2a0jvjJ2rNJKQb5+8s+qxRhuSU3FUM1s1dKekjS5yWd3u5sJemcpNN1Dw0AgPHRuEM1syOSfkvST6SU3FfGlFKSVPxqZmbvM7NHzOyRTa2XFgEAYOw16lDNrKOtzvTXU0qf2H75vJmd2f75GUkXSuumlD6UUno4pfRwR3kNUQAADoKhMVQzM0kflvR4SumfX/ejT0l6j6R/tv3vJ3fkCFFNHNsWC6IPjvkYjCSlEG+zhRCLKo1DJQ5TRysfn9iOcbJX3OnaG8fy2Nr6cf8xv/Bw/j36Vd/1nGt/1xEfH713yrcl6bGlM679e194o2vPPZH/epl/1sfsZp8K8dHz+X5SKAQ/iJNvFyfbHhIP3cu4foN9x/eU1vxf92wzz12IRfdjfLQUN87GLVu8NwrnkZyIb6tJYYe3SvoxSV8xsz/efu2faqsj/U0ze6+kZyX98I4cIQAAY6BJlu8fSvp2JTbeWfdwAAAYT1RKAgCgAjpUAAAqoDj+QZUlFygfUD7nCzn0jvikJUlqbYYC6OshIWQzH4iPEYUkpJiAJEk67YvJ9+d9EtKlN+YTHCy8wSenvPVNj2fLvP7IWdeeavnr/Hvn/4tsnWe+eLdrn/yG//nxr/tCD5LUfeaSaw8uL/j2Wj60Li/YHovWH8AkmfieUkhSKiRdpc0RzkPf/06IBfRTKb8w/h45iOd/RDyhAgBQAR0qAAAV0KECAFABMdSDwm4cC5Hywg6DOV/YoTedFxKYWvaxtKzIeCHmhYZioftQ8NzmwuTukjbumHftc2/x13Dlzjy29l1v+FPX/u75p7Nlrvb9dv7t8w+59qU/yYvuH/+ab594dMm1W8+dz9bpL/jC9ikWKCgVZCBGl6t0TmJ8OptAo5SLEa8RMdU/wxMqAAAV0KECAFABHSoAABUQQz2oYixEks36MYr9mTDutFRgshcnKfbxkWyCYpQVCt3HwuRx0uiNV96WrXPxO32sc2POX4+Tr345W+cdJ3yw84WNE9kyn37pNa596VG/77CJrde+es21W8/4sayDhXxS8nxM6eGNt+0L4fxn16c4nj28NiymWtjPQcUTKgAAFdChAgBQAR0qAAAV0KECAFABSUkHVDZAW9LgmC8UsHnEX/5UKgaRFek+HMkFt2yUQhv33OHai/f7BCRJCvUXtHGXL7zx1+/9UrbOn675ogz/6ewD2TIvP3HSted9LQgde2IlW6f1/AXXjklIWYKLxP2z3w0pyi+pnHQ0zCEp/sATKgAAFdChAgBQAR0qAAAVEEM9KMJga5vIL+1gyr/Wnxr+fSq1R4iXHEbD4kqFmHbr5HHXXrrbTyg+KHw610752NN3v+Yp1z637ovnS9IfnHuVa196Oi/scOQFfy8ce8pPHN85t5Ct0w+Tg1O04ZAYdl2bxFgPaEyVJ1QAACqgQwUAoAI6VAAAKiCGelCFQuuS1A8x1N5UGCtZCGMMun6d9ihj0A6jENNuzcxki/TuOObaKYRZ107l53riPl+Q/kTXjw/9vy/cl61z8Xkfqz3ybB7PPfq8j39Onl927cGFS9k6qRcmnz8gcTDcolHugya/V8bg/uIJFQCACuhQAQCogA4VAIAK6FABAKiApKQDIiu+fnQ2W6Y/5ZNRetN+nVTKC4jbbYfvYFb6TlYoqH3IWMd/tGz+aLbMYMKfu40jvr18T34e7z226NqPXfEF9c89nxdtmH7eH8v0xTy5Y+acL+TQuuqTkvrr69k6QDVjkHDUBE+oAABUQIcKAEAFdKgAAFRADHVcxYHQsfh6t5OtMpj03582j/htlIqxp4kQZw3btRhTlZT6rfhCvuGDJhZymJx07dTJT26Maa/c7rcxccrHMSXp6qov2HF10ReM6F7M9zNz3senpl/Or8fE4po/3lj4flCIcR2QuBdQC0+oAABUQIcKAEAFdKgAAFRADPWAiBOKp4n8u1I/xlDDUNX+dB4T60377XZizLSTx2qt1/PHMsgWGW+FQt7ZOOAYw57IC9JvzPtzu37Cn//BIL+GMWbaesnHVKcu5sfWveYvwOSlfEyprfpxqIM47vTAXUSgPp5QAQCogA4VAIAK6FABAKiADhUAgApIShpXoZBALMY+iIUeJPUmfcLK5lGfBLN5LB/wvzHntzPV8W0rFJBIa4ewkHo836GduvlHLRbDT2GR/tVSwpe/ht0rvj11OU8s6y7669peLlyfq9fCzg9BMQ6gMp5QAQCogA4VAIAK6FABAKiAGOo4KBQSyMQYXuGrUr/rtxMLOczekRdjX7lt3rWPPOPjehPT09k6trzi2inE/Q5iUXUL59/CNRt08ph2nIxgYjmcp0G+Tlyms+R/3lnJCzB0F3zRBlvvZcuklVXfLhXDB3BDPKECAFABHSoAABXQoQIAUAEdKgAAFZCUNKay2U3iz/t5Uskg1AkYTPkElleeuJyt88Qr5lz7+BNd124vH8l3fnUxHIvfT9r0STJjxwrfQ2Pi2LC2pPamb3f8aVNrI19n8oq/rp3lFH6eJxy1r4VCDqWiDcMKOexUIlmThLthDmCSG8YTT6gAAFRAhwoAQAV0qAAAVEAMdT8aJa4UB+L38gH+iqGmCf/CkU5eNH36NQuuvfIVX+hh8lJefCArmB/ic6kXgofS+MfBWq0btwvXY2ItxEOzIg35brrXYgzVb7ezmMenbT0UdlhezZZJg8L94lYq3JOjXLMaMdOd2ua434PYczyhAgBQAR0qAAAV0KECAFABMdT9YFgMqDTuMUo+BmaFcYXtGF5r+ZjRSq+r6HvufMa1/9ODD7n2kRemsnW6qyf8Cy+d98c2UZiUfJzGpqZCvHFIDNI2C9dj3a/TnvTx6M7q8Dh494o/b62FfIID2/Ax69IE8CmMFc7e427FSwv3ejbmOi5Tuh6KizQ4/ni4Dbab74g47GHGEyoAABXQoQIAUAEdKgAAFdChAgBQAUlJte3EwPUGYlKJbeZF0rMklw3/feraxmS2zkPHfMX26e/0BfSvPXk8W+f4Vb+dViz0UJAVexiz5I7Uy8/39UrXY2LZJyr1u/7e6S7k61g4LZ0rvkiDreYJR/FcpvVSUtKQ4vhNNLn3hyTYFSd9aPtkLQvt+POtQ/HbSfF+Kr3fkFiWrVNKbAqJS8XkpxoJXhgLPKECAFABHSoAABXQoQIAUAEx1NpifGS3YqohJlSMoS6FQupX/eVf3sgLO0Q/cO+jrv2x7/jebJnZ89OuPbV20h/bi77QgyS1Jn3cdbC2NvRY9pUhMchYXEGSOkuh4MKE/34bCz9IUisUiLBFX8ghbRYmHggx05HipSPcx1msU8pjqCFmGmOfkqSOj8HbhL9vbbJw32brhGMpxTFjcYsQFy+e21g0oxBLj+c7xc9mqYAEcdaxxBMqAAAV0KECAFABHSoAABUQQ91pTWIhNeKssTh7KWYXJp+evOzjTAvXfOxTkp5e8fHP1876+OfpN+Xx0CvP3eHat12bCcdxJFtH1/zs2hbjWdrfBfTj+MMUYsCl2GB70S8TI4GpnX/fbS2FcxDjeoVxkFnMrlGh+Jv/rp2NIS2ND41jSkM8VJ38V5J1w5mZ8vH2NJ2Pnx5M+3t7MDV8LHScwCCO+S1NEt9a9+e/tZLH/tNqeC20B6VxwcPirMRY9yWeUAEAqIAOFQCACuhQAQCogA4VAIAKSEraDyoUg4iFvNNGnsDTXvTJD1OXfLLQ8oU8Kekb87e59onuimu/88wT2Tr/+0MnXHv6kt/u/OqxbB0LA+JbhYSW/tVQkGBQoaD7Dklr/lxniTWSLCSwtEMi1uDoVL5OLCQwpBjB1kLDE1iKRemHr+SbIaHIpvPjVyzKEAowpKn8PA1m/XZ6R30S0sbxfJ21Y/7+2Qx5cBP+NpYkdUPhk5iU1NrIz2Or519rr+UJdxPX/L3Quup33rrmi3NIUlrxkx7E+6lYnGMffx4OC55QAQCooHGHamZtM/uymf377fZ9ZvZ5M3vSzD5mZsPr1gEAcEDdzBPq+yU9fl375yV9MKX0gKQrkt5b88AAABgnjWKoZna3pB+Q9HOS/qFtjVJ/h6S/sb3IRyT9rKRf3YFjPHyymFehyMEgxK8UCnAXCju0ln1cZubinGsvX8xvh3OzfgLxS/Mvu3bH8rjNQ69+1rUfPf+AX2c5jzPNroaY78Jitkx73h9v/2pYZqeKjI9SeCPGuErHEeOsPb9O6dtuFkONBdxLMdR4/IV4qdmNfxWUYsDZdmLRhnC9JClN+phpP8RM+0fy/WzM+3XWTvj9bBzJ308Kb2dz1rfDfA3b/HYnF/xPrV8omtH2+26v5eexe82/p+lLPibcfTnPXWhdueb3sxQmQYjFIpTnTWRxVopB7LimT6i/JOmf6Fu/2U9KWkgpffPT+4Kku+oeGgAA42Noh2pmPyjpQkrpi6PswMzeZ2aPmNkjm8pLbAEAcBA0+ZPvWyX9FTP7fklTkuYk/bKkY2Y2sf2UerekF0srp5Q+JOlDkjRnJ/ibAwDgQBraoaaUflrST0uSmb1d0j9OKf1NM/u3kn5I0kclvUfSJ3fuMJEJ8cIYU1VhHGosyj11MbQvhUCTpH6Ief3x8fCXfV8HX5L04NGLrv3MG/y41JcX8wCWDXysdubreWzWlvz4vRhTHVzzcScpL1pfjLPerELh+FHGcab1cI1CjMvWCn9AiuvEONkok4dLUmvIH6uaFK0P405LY0pT129nMOXb/cn8OPqTFtrh53kIUmsn/bnsz/j2oFu4D8Jrq/FQNgvXuJ1u3JZki/4zNHPWv4Gjz+WF+4+86JfpnPPt1tX8Xh8sh8G1cexqrzBBOnHVqm5lHOpPaStB6UltxVQ/XOeQAAAYPzdVKSml9DlJn9v+/6ckvbn+IQEAMH6olAQAQAV0qAAAVEBx/IMiJtsUklNi0kL75SXXnrmYZ3f0J/1g9+Wnjrr2xfm8SEP0vXc+5dq/+8aZbJmF1bjvU9kys1/zyU4WCha0ColBg0X/HpX8MlnSUgPFBKRCopLbTyn5I16jXji2lcI6oQB6NilC4brH86TCe06hMIiFIvbFdQahmHyWIFUoSBIKIQzC/dWfLkyKEJKSelPhPOWrqHck7PuYT8iZmc2H8N1zfMG1z8z4wiGnuuFeknQ8VNmfaefbXR/4pKOvXPOJff/v0/dl6yx+1X8eTjzhE7xmnw2ZWZLaF666dgqFTwa+rsvWMvGaUWD/lvCECgBABXSoAABUQIcKAEAFxFDHQSn+NqRgezE2GIo92IIfHD7zko+PStLmtI93plAA4OvH88oOdt9Z117c9AP+33Lf09k6f3Tt1a7d2izcmuYnO5/5ui/Ub6t5MK0VYoHpWoiDbRaKyY8ixlVjoYTS9YjrxGMpFAkYpXBDNgl5sTh+eC3GZgtF97OtxLhrKaY9GQo7dP15GnTydfrhtVjIYb1UgC3Gylf8flfW83vl68s+Lvni0XnXftUJf79J0ltPPuna33/k0WyZV3d8wZSrx/+zaz9yOs9D+OgDb3HtTz/2Wtc+9gV/bJJ06lEfZ+0+689t6/JCts4gFHvJziQx1ZvCEyoAABXQoQIAUAEdKgAAFRBDPUxC/C2t+DF0nZeuZKtMz/u4jIVBf/3JvAD6M0d9Mfy5WR+neXGQTzx9z31+jOlLS6ezZWJc1fq+yP70c34cniRZmFQ9xjKtEBuMEzU3KiAeYpAWJtsuxqIGQ8aQlvY7uHFx/ywWKimN8rU57qfJJOsWx4cWYtrr/ny3un6Z9lq+nzjicmLdLzP7Un4ogzDeNbXaoZ2vk0IMeNDxsf8/nT6WrfP4/P2u/b+efke2zAP3n3PtH7vr/3Htt04/k63zE6c/7bcxc8G1f+fMG7J1nr/Df2bO/NHtrj3zRLaK7OXwmY8F9UuTSVBQ/9viCRUAgAroUAEAqIAOFQCACuhQAQCogKSkcRUTA7KB+YXC5IPw/WnDFwxPV32hB0maft4XdrDBkdDOb6HLM36ZhQfC4P2UJ55c2fBJIxN35ZW8l6/5AfJZklIvL0wxeS4Mbo8LFAq4ZwUJYlGGUqLGMKVkoXgNY3uEIg4qJAJlRetj0QlpaLJTcZ1YyGHC77u14pPRJCmFazZ52Rfa6Hby+ylN+eLyqRPeY+HYYhH+lCVMFa7HROuGy/S7+X4GoXD/5kx+/l/+0t2u/T/e8cN+uw/65EBJ+uuv+5Jr/8D8H/sFfH19SdJ//As+4euZI3e69r19XxhFkqZDMZFBvA9Kv0eaJM8dUjyhAgBQAR0qAAAV0KECAFABMdTDJMRDUgyFrOZxS7t42bWnQlxpYsUPfpckG/ih+C+3fBy2f6pQkL4fJp6+1MkW6Z3wxz+x4r8PTqzn67Q3fSX1iXD8tpzH+bLoWij+kBWbl/JYU5xwfDMUi5DyuOWwOGYTnfwcZDHGJrHZsE424biUxZpTKLRe3E8suh9+bIXjt5Uhv6ZGeD/FQhUhBpxCW6X4bnfihm1J6s/41+ae8+3VJ0O1f0mf/Or3uvZvP/Qm1/7pN/xets677vCF+X9rwxddeWE9j6Hef9UXR2mFvIrSuc0n3ohx18MbU+UJFQCACuhQAQCogA4VAIAKiKEeFMPGpRbXCTHVQqF4hQm5W2G7nbV87Ofcio8Xttf9uNTLr8vjZBtzIbY2kcdhpi7673/9UDV95bb8+2F73ceRpjf8e85HDSovdL8R4om9QswuTjwQ466licyHxJqycaoFWWyzFE8sjE3NxBhjk3XWQyH18B6zCQJUGMMYNYiHZudyhEkEioacA2vn91c8/61CDLg95W/UzrRvT76c5yFMX/LLLF3wn6GfPffXsnV+7G1/6Np/8Yyf/PxTy3ms9tJ3+u3eftVPXGGF2H+cUCLmYhR/9xySuCpPqAAAVECHCgBABXSoAABUQIcKAEAFJCUdVKUkgCGJSvmAbUkbPilhsOgL6McEBUlqr/jkh6NLPnmluzifrXP5tT4JY2MuP9berD++yct+mVYvP/7Vk/47Y3vNJylN9fLkFVsLg9tjck0hKSlL6IrtUnH5YQk4pesRiymUEsmG7MdK90FMwInF5Ev7icc/iIVDCucp3JfZfhokGGWFNYoTQdx6EozFc11eyLfjxArKE5csFIiYuJwnJbUv+WIo3QWfLNRdyhOM/s3y21z77f/lf3bt0/P55BfP/nm/nfmnjrn2VGGCA1sLyWhNJo/IJu84mElKPKECAFABHSoAABXQoQIAUAEx1MNklEnJYxgsxFSLA+hjvC2sMxViMJJ028oJ1778+plsmfXjYcLnUNhh5nwel5lcvPEA/8FE/p2yFYuir4f3XIqHhlhaVnygQTyxUZH3OKFBiF/FuF9JKk1CPmylwnUeWqShQRwzxVNZ2mYsmlFjwvcGsnu/KCwUY6oqFLxYD2c7TiogyUJBlYmrvn1s4Vi2TmfpuGv/wcYbXfuuv/Bito66/txdfp3/UN3xcp7vYDGPon/jSTe2XtyZa7Tf8IQKAEAFdKgAAFRAhwoAQAXEUA+zEQrqZ/Gr0vjEGBKK4wYL63Se98ucsFPZMitn/Hg9C4fSWcqDN+0Vv6+JBX9waTKPJ/Zn/VjVdhh3aksr2TppLWw3TtS8Q2Mlm2wzi6uW9hvjlNmGC9sdNoa0SdxsMPw7fZWY6a6Nexx+bFmMscn1CJ+ZVqFo/ZG1MCnFhp9Q/Ozm3dk6E6/z9/LiA75LOPbkbLbOzEVfUD8bi1681+N1bnANx3CsKk+oAABUQIcKAEAFdKgAAFRAhwoAQAUkJeHmhISDPNlAedJRTEraDAk7klIY3D6xmBfynn/aF3tIx+eyZTJxUH08luXhxdhjMfyYgCRJKRa8aJA4M6wIQ6MEo0piwflsL51Ofiyh6Hu87sWkq3hedmrA/14ltIy03wYFVcK5HAxWs3XivT0d7tsz/dPZOi+1/Wdq41gs9JBf9+lnfaKSrfhjKRb8GDSYxCEaw4L6PKECAFABHSoAABXQoQIAUAExVHxLkxjFKAX1QwWGUowlm8w5FpeXpHVfVN+uLvp2N4/3xImzs7hek6L1MaZajBGFdWIB+ibxxKBavLRQsD0T91WaAGDIOllMtVhQP74Qlikea6Mq9eOr9Lkb8jkrFqAPk04MFq669tTX81VOT51x7Zfe6q/hxtF8nc1TvrBD90r4HK7m8d14r2S5FwekeD5PqAAAVECHCgBABXSoAABUQIcKAEAFJCXh5lQauJ5tNkuyKGRdhISVmLhksbhCYR1rN5jdJEtKuvn3nM3EUtitmf/4Zfst2YEZakrbTeH8F9OjYuJMSAqzmJgl5cUf4jVrUMyimJBz0AybCapJMmBMUrp8JVtn9jF/jU7O+SSla/fmV37xPj/r06nnJ/0CTRLaDqjD+84BAKiIDhUAgAroUAEAqIAY6s2IcYzdMgZFoW9olOMvneshg7/LsbVQ2L4fYqpNiifEYgMNBqHHYynGbkPBeWtQQCKLxdaKqcYiDfH8l65HPHfxOhfes4U3YJM+/laMI4fJFLLiHAekKMANDYupSsOLP6zn52lw6bJrH3vMF8sfdI5l6/RD/ZTBfCiWf3khP7SsUMsIgfAmv3/3+HclT6gAAFRAhwoAQAV0qAAAVDB+MdS9imPupWK8ZMzjqsPUirtm221QZDzbrj+WUtw1xvWsMAQz22ws5h/iTKV4YhZnbVf6PMSxg2EMaVb4XpJNhfGH8f3EydxVmJw9Tmxeioda1x9q+PFgI5+wPhv7fNA/LyXxXo8F6aVsrGrrxQuuffTEdLbKyu3+eqyd8cXyp8/5caqS8okt0pBi+Vsv5q8Ns1P9Q8P7hydUAAAqoEMFAKACOlQAACqgQwUAoILdT0o6jElFt+owJlSMYqcSmZpspkmBiLhOKOwQj76Y/BQHyGeF/AuJQGGZrGhDab0GxdhjIlOKSUqlYhZTPqHFllb8NnqxAIDyxKXujZOUpEKi0kGrqF9pkop4WtLSsmt3X1gobOeYay3d6a/HzKwvDiFJFrabJfG1CsdWSlTKFxq+TA3Z56G8GE+oAABUQIcKAEAFdKgAAFSwBzHUQ9aHH4bC3eOsFIsaGj9sULUhKk26HIolZJOS9wpxv1gsoVBAPyrGTG9W6XMb31OI+Q6mQ6EHSQqvtWIBiRBTlZS9x1gcIsZUJcnCdU0bFHoov+dQ/CHEsO3K1WyNzoyPlbdO+/PfP+6L5UtSK24nXtPCbVyKq0aN4qy7aH8dDQAAY4oOFQCACuhQAQCoYHdjqDbaeL1b3+8I3xuaHGdpcudhBamJqY6feP8U44lDJuhuF+KuE+0btq1VGJO5ueGaKcaiKsUGYwyyGKsNY1fTZIiZFmK3vSNhDOmUX2cinhNJtrzq25N+G6kQ52uFicsH4bOaeoWC+sRVs/GhaTVMZiCpdTWMVb3mi+P3jobxyJK6ceKEDX8fl37bNhk63CTOuiO+zbHxhAoAQAV0qAAAVECHCgBABXSoAABUsPuFHW7WDiUUZUkjcZB6aTB8XKZUiDwOjA7R65Fmpi8dy2FMoNgJpXMb7jmLxQc6wz82Foo2KCZlSEoxCSkmuU3mBQu0spq/dv02dnHyiexe3/T3ekxAkqQUPptrp/wy3W7++ehcjol9/jy1YrELFYo/ZIUESlklFH/IkioLkxWka0uu3b1y3LV7M/nnIytaEn+Xlq5H/D1eSgId1j/schIoT6gAAFTQqEM1s2Nm9nEz+5qZPW5m32NmJ8zs983sG9v/Hh++JQAADqamT6i/LOk/pJReK+lNkh6X9AFJn0kpPSjpM9ttAAAOpaHBIDObl/Q2ST8uSSmlDUkbZvZuSW/fXuwjkj4n6adu+Yh2oHh+Ma40JGYa42aSpBg7axUGoceB92vrfoFSTGKUuY+zAu6HMN7TxLCYYuF+y2KmYeJsK8RDs/3E7Z6Yz1ZJ8X6Kk4eXJuiOBSRCrHawHu43KY89leJK8Xjj/VQ4j604wXgo5p/FhCX1J1s3bK+czuOuUx2/THvd72eiMPFA60qM0YVJykufw1BsACrGNuPvtPaSbw8mR5g8opY9LpzTpPe6T9JFSf/SzL5sZr9mZrOSTqeUzm4vc07S6Z06SAAA9rsmHeqEpD8n6VdTSg9JWlb4827aqndWfEQys/eZ2SNm9shmKnx7BgDgAGjSob4g6YWU0ue32x/XVgd73szOSNL2vxdKK6eUPpRSejil9HDH8hqPAAAcBENjqCmlc2b2vJm9JqX0hKR3Snps+7/3SPpn2/9+cvju7NZjpKOMMS0vFLYbjqsUQw0x02IsbWbKtyf8hMlxDJek8vgqt1KDuMBhjKmOMuYyjjEtjCmNhdVtfs6101RhQusQ/4zx0d4pX0BckloroUB7O8RHe4XrHu7B1A9/9SncS+Uxl1GIf6YwbrCwRpYfcNyfp9ZGadbosNdwKjeO5te0Hz5nE2v+3E4XfifET2YrxndL8dJhY1UPw2cqiMXyJWV5IO2lUED/5MwOHtEQTfqXUeKsDfutpoUd/jtJv25mXUlPSfo72nq6/U0ze6+kZyX98M0fJQAAB0OjDjWl9MeSHi786J1VjwYAgDFFpSQAACqgQwUAoIJdLo6fbn3gbam4fNxLVrOhTnF5iwPtCwkt2WD9KV+RsXT0g5ioFJMjGrzn7LyOkrCzU0kXO1WwvUGiwLDC9jYzna902wnX3AgJRVYoxh6LGGwe6YSfFw4unO+4jfZiSPaQZKGg/iAkiDRKQGpQ2CEmo8RJHqS8EIJthCSryTxpr73u992b8tcjFs+XpLWT4YVBTMDL9zMIxSCmlkOx/OXlbJ0Uj9/i56Fw3g5aolJW0KOwTPz9tOwTL63XoAptmFgklc7jsGRNafcKOTTcD0+oAABUQIcKAEAFdKgAAFSwuzHU9G0GCt+U4TGiJoPSswH+8W/6hcnDs8LkncKk0WFS5dSJhdZvzzf7YthGnES6FBfLCp6H9zxK/GG3JqcesbiHxfhagyINFos0zPl4aO/0sWyd5Vf4gemb0zEoXzi4cLq7y/7cTqwUJsFu+eNtr/nr3C5dj1hwZNSY6U0uU4zjh/hta9nftzYbipxIaoViFTG23M9XyYo/9GZCrHkjP7bBhD93k+f8RuJ9IUkWClU0ikc3+cyMc5y1cF9k98Kqj09PXMtLzKb1MGlInJygwbm+9b5j5/GECgBABXSoAABUQIcKAEAFuzwOVbsybqjJuE1rhZhpLEReinvkwwIzrTBWtX/KFwzvzeVBovbEHb59fsEfymqIqUqFQt4hNlWaGDi+NkpMolGh/iHnvzDWMBsrXJg0Ok6mrRgfnc3HlA6O+ZjpyplZ1166M/8IrJ2y0PbnqVUI90yftbCMbw8Kk4V3wvDj7pUwVnLJj++TpLR4zbebTB6+U8K+83Gp+STetumPr73ut9GbKhTHnw7LzPr22onhn/f+rL9XOvFekpTimOVWGONb+r2yxxNa7wcxHtpazO/bQZyMIBtrX/hdNIbnlidUAAAqoEMFAKACOlQAACqgQwUAoII9SEoakghTo7hAg2D2sMSlYjHw+MLq8ILO7VhI/dR8tsraGV9IoDvpL0trvZDcEQfIhwQQWwtJAJIUin83Glwdr1eTRKasAENox+IEKiQcdQtFM2Z8QldM8No4ESoASFq+3W83Szg6mb+f3mk/MH3uuE+yWDzvE50kaWLJH+/6ht9PdzFbRZP9kOy0FAoLLBeSO9bzQfO7oviZunGRidI92Nr016y9Mfx+GoTLmrohSelovo3NcP57s/4+6JSKgIT7slHKXkzAG8NEmpsW3mOW7LhayN4cloRU67ztcRENnlABAKiADhUAgAroUAEAqGD3Y6jD1PgbeKOC1TdfDDzGVYtHGmNcYT+tOMBZ0syGn5B3+X4fZ7VYHVxSavv32J+Mky7nhzaxFgbVr8Zjy2OoFuJ8cXLtbA5mZXX6lSbC5NWd/Nz2pnz8qjeTx1nX5/x668f9jtZP5AezMR+KD8z58z8zl8d73nDbBde+sHLUtVeO5oXV+yHuncI9GM+9JE1eCBMzXw1FG+KE11Ie525U+H6Ez9QIn6GsuMhmHvvXkOL47ULof20q7Kfj2/1uoRhEN8ZQQ3x0Ir+/8th/vE8bFMs/jGJ8tPA7Lt4bIxmDSQZ4QgUAoAI6VAAAKqBDBQCggv0XQ62hyd/ah8WIGkysWxyrGsdXxYnKC3ElC+NBZ0PsbP0VPsYqSctn/LjH1VP+2Hp+aOv2wfm40UQY5hgLlUt5jHQQYrepcAfFkG8cR9ibzvfTD5NG94/m57Y77ycJmD/i28c7ecyxHSZB6ITK9nPdPIbaC9f5woIfdzo4l09wMHXNn5epK36/0+fz8aO25I8/jgseFMbzDZ30ulacKW6n8HmJ97rFe71wrNkycU6EQtg4hRiqQgw1dfPnghSGMfcnwzKFcaijTnyPoBQ7j79Pdyr2v8e4gwAAqIAOFQCACuhQAQCogA4VAIAKDmZSUhOjFOmPA9lLxR9CEkzqxUSNQjA+FhUPQf2p1TyhpXtpzrUn7/HFBxZelV/apfvCvk+G7Rbe8mDVb8fWh38HS5N+P5PzPrnmlSevZOv8+RPPufYbZ57PljnWDkXqBz456NmNU9k6T67c7tpnV33RjJeW8skKXjrnk8C6z/msqiNns1U0c8Ffw+kLfnB754pPQJIkXV1yzbS07NvDEpD2m/CZSjEBqbBMvzO8IIlN+fPQaodtbOb7GYTiIf2QpJS6heL4sbADGonJaSPdt2OYgFTCEyoAABXQoQIAUAEdKgAAFRzeGOowjf6mXyj+EMMHDQpsx5hDVoC+NEB+3cfojiz6+OL0eR9jlaSlF3y1h6v3T/ufP5iPqr/n3kuu/YqjPv453c7XGYTq+BOhmMIdk/ls26+eOufad3byOOvawAfCLvd8wYVz63k89KlrPq763CUfH90878+BJE2f9QUwZs/6e2HmYj5wvXPVn4fOBV/oXqHwvSSlFX/NBrEY/rgNfo8x0waT0cci9qlQs74z6c+3hWojg0Jhh0H4zRYnk0idwiT3DY43kxUs2EfXY68Ufl9lBW8OKJ5QAQCogA4VAIAK6FABAKiAGOqtGDHOOnSzcexqKZYW4xRhYvN2obD63FUfc5w+78euLj+fF32/9MAZ137+/pOuffxUHht89cmLrn3v5GXX7lgeY/n62h2u/UeLD2bLPLN0wrXPXfPHv7SST/y9ueTHkE687OOwsxfzsYez5/z5njnnY5uT5/x4UUlqLYTJwUOMOy3n6wzWbjwZ/b6Kx5WOZdiwzdJ9G8Z398Mli21Jmpjw90u77bfb28x/jaX4qBAneSjEUFtNYtaHTfG63/jCpyb37X66tyviCRUAgAroUAEAqIAOFQCACuhQAQCogKSknVYh+F4qNh0HSmfFIHp58QFb84lK3WVfsL3z8my2zuxZn8i0+KxPXFq62ycpSdKfdP1rX5oMA/En83MSB/Rbfvhqr4eCEcu+PZ3n/Wj+mt/X1II/T1Mv++QhSZoIhexboWiG1vN10qpfZxDObbFg+H5OQhpBTEYppq5kSUm+vXk0PwdHuz4pbKrjb461tVD5XnkqYKsXjq1wrlOcuCK7PsOL/R8K2XtuUNDjkCR88YQKAEAFdKgAAFRAhwoAQAXEUMdBKU4TqvCnBvGeFCYut1CM3QrFB7qhYMHJl3yB/WMnfYxVktZu83HWjaPhe1vh7WQxrkLIpRViXK0Nv057LV+pvdoL7fCe1/Pi/nYtFK2/6ov5p1iQQYUY6QGLj9aSJvy9MPB1N7R5PI813zbr78uptr+ml6/lsf84B8XEuj//rZU8Dh6LpRyWgu7VHZJ4aQlPqAAAVECHCgBABXSoAABUQIcKAEAFJCUdFCHppVhIIGRqxGVss1QMIiTgLPkEkfblhWydI8+GTJNJ306dwm0XXkut4d/1LB7/WiHRJMy6k9ZiO08wGoSiGFlyCgP8m7H8Gg66voLHINRkmL4tFNGQdM/swg138/jgdPZae8UXjIgJa1mxDkl9EsuqKCZzHZJzxxMqAAAV0KECAFABHSoAABUQQz2oGsUsfIwo9QrFIPrhO1csBrEWqtpLsnZYJ8ZDrVA2vUHMVINwvOE9Dkpx4yHxz3K8h9jZKCxcV5vI743+1ERo+5/fdjQvLnKi61+71vMr9Xv5fqYXfDvGUNNSYSaFYt4BbhqFHQAAwK2gQwUAoAI6VAAAKiCGepg1iQ2GIvwx/lmMu8bhrGE8orWKU0/ftEbFy4fFc4iPNlOKe0cxDt7NJ/7emJ8IbX99Zjr5WOJ2iPUvbEy7dn81j6HOXPDrdK6G8ccrfgJ4qTTBAfcGbg5PqAAAVECHCgBABXSoAABUQIcKAEAFJCXh5oySqBESm1Kqk5Q0EhJNqsmSy9o+OSjN+uQhSVo96b/DD+Y2s2Wihd6Maz+9eMK1Oxfy5KeZc37Sg/a5K67d3yhMpIDRxM9UkwS2A4onVAAAKqBDBQCgAjpUAAAqIIaK3VcrjhljNcRHd1cs2BEmkt88OZutsnpbKKDfCUUb1vK4659s3Ona55456dq3fy0/tO5FX/x+cGXBtbMiDhL3Ty2H+DzyhAoAQAV0qAAAVECHCgBABcRQMb4Ocaxmx8X4tOXfva3jf33Y3FHXXrp7MlunN+uvWVr3Y1cvXJjPj+Wa38/RZ/w6898oTBZ+yY87TYw7xS7gCRUAgAroUAEAqIAOFQCACuhQAQCogKQkAENZKHwvSTY95dobdx137fVjeZF083UcNHElJDb18n1PX/TbmX/aL9R56XK2zuDqomunAQls2Hk8oQIAUEGjDtXMftLMHjWzr5rZb5jZlJndZ2afN7MnzexjZtYdviUAAA6moR2qmd0l6R9Iejil9B2S2pJ+RNLPS/pgSukBSVckvXcnDxQAgP2saQx1QtK0mW1KmpF0VtI7JP2N7Z9/RNLPSvrV2gcIYBeEQg4xZmrdfBJv3e6L1C/f6Qs59CfzGGorzCfeCvUWOoUaDTPnfOD1yBOhaEOIl0pS6oVgbArBW4qCYAcMfUJNKb0o6RckPaetjvSqpC9KWkgpffOufUHSXTt1kAAA7HdN/uR7XNK7Jd0n6U5Js5Le1XQHZvY+M3vEzB7Z1PrIBwoAwH7WJCnp+yQ9nVK6mFLalPQJSW+VdMzMvvkn47slvVhaOaX0oZTSwymlhzvKa3sCAHAQNImhPifpLWY2I2lV0jslPSLps5J+SNJHJb1H0id36iABVBQL36sUM/VJ+60TfoypJC3ff8y147jTXj5XuCzM6x1jqlMv57HNuT8NgdWLftxpWsv/8sW4U+yFJjHUz0v6uKQvSfrK9jofkvRTkv6hmT0p6aSkD+/gcQIAsK81yvJNKf2MpJ8JLz8l6c3VjwgAgDFEpSQAACqgQwUAoAKK4wMHSSHhKFukVOg+JiHNz7n22qtPZ+ss3el/fayd8PseFGpBDEtCmntqNVtn4rkLfrura66dFXGQKOSAPcETKgAAFdChAgBQAR0qAAAVEEMFxtkIMdMYL5XymOnGA2dc+9rd+TqbR/y+WyGUWSx0f97HNue+fs2122cvZesMri25dlr3hRxSP1SLkIiZYk/whAoAQAV0qAAAVECHCgBABcRQgXESY6bWCs1C4fs4xnTuaLZM/+7bXHv9hB9EamFYpyR1r/o4ZWfFt2fOhdnDJU0++7Jrp0UfQ41jTCUpbfjtZDFT4qXYJ3hCBQCgAjpUAAAqoEMFAKACOlQAACogKQnYLxoUaRiWhFQq2mAz066dTh7Lltmc8+v1u367E+t54s/Ui77S/eQ5n2CklxeydVJIOhrEIg2bFLrH+OIJFQCACuhQAQCogA4VAIAKiKECe2VYzNTy77tZofuO/wjb0SPZOunMKddeu2M2W6Y/5Y8lFmXovJxXurdF/1paXvHtEB+V8hhpXqShUEGCmCnGBE+oAABUQIcKAEAFdKgAAFRADBXYCTXGlE7kH0+bnfEvnDzumpu354Xvo8nzK9lr7ashRhrGi6ZNP+ZUkgbrofh9WCb18jGlFLbHQcYTKgAAFdChAgBQAR0qAAAV0KECAFABSUnAzRol4SgUZJAKRRmmp3x7JiQgSUozU+EFn9TTfeFyfiwheShtbGSLxGSh1A8FFgpJSSkmFGXbCAlIWyvlrwEHBE+oAABUQIcKAEAFdKgAAFRADBWHW4UCDJKkWLQ+xkxLMdRYuKHllynFOrW66tsh1jkoFFPQoMEE3WGZYfFRSUqDFF8Yvh/gAOMJFQCACuhQAQCogA4VAIAKiKFifDWJf2brDP8OWYyR3uQ2srhl4Viz4vGxHbch5XHJ0jLZKnGdQmwzxD+HxkdLxwIccjyhAgBQAR0qAAAV0KECAFABHSoAABWQlISdFxNySsksO5RgNIosISfuNq/RMFypUHwsJj9Kkk+T5CHFRYYnJZFwBNw8nlABAKiADhUAgAroUAEAqIAYKuobFg8dJV5a0iBeOJJhxfCHFX5Qw2IKoxhWgKHBOsRHgZ3BEyoAABXQoQIAUAEdKgAAFdChAgBQAUlJuDW1EoyiURJnKhWHyJKQ4jKjJAKNgIQjYLzwhAoAQAV0qAAAVECHCgBABcRQcXOaFLrfz4YVbSjZoQISQ2OkTfY7bucfOMB4QgUAoAI6VAAAKqBDBQCgAmKoGF9Nxp2OEjMdotH40GYbGmEdYqbAfsUTKgAAFdChAgBQAR0qAAAV0KECAFABSUm4Ofs5KaZJofsGqiUd+Y2OsM4+PtcAMjyhAgBQAR0qAAAV0KECAFABMVTc2BgVw9838dKtDY+wzv49twCG4wkVAIAK6FABAKiADhUAgAqIoeLG9lNcL8ZzC+NO98wOTUIOYHzso99IAACMLzpUAAAqoEMFAKACOlQAACogKQnjIyZI3XwdhzpqJSDtp4QvALeMJ1QAACqgQwUAoAI6VAAAKrC0i3EcM7so6VlJpyRd2rUdHy6c253Dud05nNudw7mt796U0m3xxV3tUP9sp2aPpJQe3vUdHwKc253Dud05nNudw7ndPfzJFwCACuhQAQCoYK861A/t0X4PA87tzuHc7hzO7c7h3O6SPYmhAgBw0PAnXwAAKtjVDtXM3mVmT5jZk2b2gd3c90FjZveY2WfN7DEze9TM3r/9+gkz+30z+8b2v8f3+ljHlZm1zezLZvbvt9v3mdnnt+/fj5lZd6+PcRyZ2TEz+7iZfc3MHjez7+G+rcPMfnL798FXzew3zGyK+3b37FqHamZtSb8i6S9Ler2kHzWz1+/W/g+gnqR/lFJ6vaS3SPp72+fzA5I+k1J6UNJnttsYzfslPX5d++clfTCl9ICkK5LeuydHNf5+WdJ/SCm9VtKbtHWOuW9vkZndJekfSHo4pfQdktqSfkTct7tmN59Q3yzpyZTSUymlDUkflfTuXdz/gZJSOptS+tL2/1/T1i+lu7R1Tj+yvdhHJP3VPTnAMWdmd0v6AUm/tt02Se+Q9PHtRTi3IzCzeUlvk/RhSUopbaSUFsR9W8uEpGkzm5A0I+msuG93zW52qHdJev669gvbr+EWmdkrJT0k6fOSTqeUzm7/6Jyk03t1XGPulyT9E0nfnFrmpKSFlFJvu839O5r7JF2U9C+3/5z+a2Y2K+7bW5ZSelHSL0h6Tlsd6VVJXxT37a4hKWnMmdkRSb8l6SdSSovX/yxtpXCTxn2TzOwHJV1IKX1xr4/lAJqQ9Ock/WpK6SFJywp/3uW+Hc123Pnd2vrScqekWUnv2tODOmR2s0N9UdI917Xv3n4NIzKzjrY6019PKX1i++XzZnZm++dnJF3Yq+MbY2+V9FfM7BlthSbeoa2437HtP6VJ3L+jekHSCymlz2+3P66tDpb79tZ9n6SnU0oXU0qbkj6hrXuZ+3aX7GaH+gVJD25nnHW1FSz/1C7u/0DZjul9WNLjKaV/ft2PPiXpPdv//x5Jn9ztYxt3KaWfTindnVJ6pbbu0/8rpfQ3JX1W0g9tL8a5HUFK6Zyk583sNdsvvVPSY+K+reE5SW8xs5nt3w/fPLfct7tkt2eb+X5txabakv5FSunndm3nB4yZfa+kP5D0FX0rzvdPtRVH/U1Jr9DWzD4/nFK6vCcHeQCY2dsl/eOU0g+a2f3aemI9IenLkv5WSml9Dw9vLJnZd2or2asr6SlJf0dbX+65b2+Rmf33kv4bbY0C+LKkv6utmCn37S6gUhIAABWQlAQAQAV0qAAAVECHCgBABXSoAABUQIcKAEAFdKgAAFRAhwoAQAV0qAAAVPD/AyqNqT3iYrqIAAAAAElFTkSuQmCC\n", "text/plain": [ - "
" + "tensor(0.7762, device='cuda:0')" ] }, - "metadata": { - "needs_background": "light" + "execution_count": 558, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ess(flow, 20_000, energy, cuda=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 559, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(0.7732, device='cuda:0')" + ] }, - "output_type": "display_data" + "execution_count": 559, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ess(flow, 20_000, energy, cuda=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 561, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 561, + "metadata": {}, + "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -600,9 +950,9 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -612,8 +962,39 @@ } ], "source": [ - "plot_evaluation(flow, cuda=True, n_samples=10_000, use_log_norm=False, train_with_inverse=False, eps=0.0)" + "from matplotlib.colors import LogNorm\n", + "\n", + "norm = LogNorm()\n", + "# norm = None\n", + "\n", + "plt.figure(figsize=(5, 5))\n", + "w = weights.detach().cpu()\n", + "w = None\n", + "plt.hist2d(\n", + " y[:, 0].detach().cpu().numpy(),\n", + " y[:, 1].detach().cpu().numpy()\n", + " , bins=100, norm=norm, weights=w\n", + ")#, range=((0, 1), (0, 1)));\n", + "\n", + "plt.figure(figsize=(5, 5))\n", + "theta = torch.meshgrid(torch.linspace(0, 1, 100), torch.linspace(0, 1, 100))\n", + "theta = torch.stack(theta, dim=-1).view(-1, 2)\n", + "plt.imshow((-energy(theta)).exp().view(100, 100).numpy().T, origin=\"lower\", norm=None)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From fd67ead384a69ebf8e1c97607ffea4449ac6ff23 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jonas=20K=C3=B6hler?= Date: Wed, 19 May 2021 11:54:33 +0200 Subject: [PATCH 35/68] added moebius transformation --- bgflow/nn/flow/transformer/compact/moebius.py | 111 ++++++++++++++++++ 1 file changed, 111 insertions(+) create mode 100644 bgflow/nn/flow/transformer/compact/moebius.py diff --git a/bgflow/nn/flow/transformer/compact/moebius.py b/bgflow/nn/flow/transformer/compact/moebius.py new file mode 100644 index 00000000..d5c6ea1f --- /dev/null +++ b/bgflow/nn/flow/transformer/compact/moebius.py @@ -0,0 +1,111 @@ +import numpy as np +import torch + +__all__ = ["MoebiusComponents"] + + +def moebius_transform(z, w): + """compute moebius transform of z along w + returns value together with corresponding jacobian""" + wnorm = 1 - w.pow(2).sum(dim=-1, keepdim=True) + diffnorm = (z - w).norm(dim=-1, keepdim=True) + trafo = wnorm / diffnorm.pow(2) * (z - w) - w + outer = torch.einsum("...i, ...j -> ...ij", z - w, z - w) + jac = (-2 * wnorm / diffnorm.pow(4)).unsqueeze(-1) * outer + jac += ( wnorm / diffnorm.pow(2) ).unsqueeze(-1) * torch.eye(2).expand_as(jac).to(z) + return trafo, jac + + +def uniform_to_complex(x): + """map number in [0,1) to complex number / S^1 + returns value together with corresponding jacobian""" + assert torch.all((x >= 0.) & (x <= 1.)) + x = (2 * x - 1) * np.pi + jac = 2 * np.pi * torch.stack([-x.sin(), x.cos()], dim=-1) + return torch.stack([x.cos(), x.sin()], dim=-1), jac + + +def complex_to_uniform(z): + """map complex number / S^1 to number in [0, 1) + returns value together with corresponding jacobian""" + assert torch.allclose(z.norm(dim=-1), torch.ones_like(z.norm(dim=-1)), rtol=1e-4, atol=1e-4) + jac = torch.stack([ + -z[..., 1], + z[..., 0] + ], dim=-1) + jac = 1 / (z[..., 0].pow(2) + z[..., 1].pow(2)).unsqueeze(-1) * jac + jac = 1 / (2 * np.pi) * jac + + x = torch.atan2(z[..., 1], z[..., 0]) % (2 * np.pi) + x = x / (2 * np.pi ) # - 0.5 + return x, jac + + +def complex_multiply(a, b): + """multiplies complex number a with complex number b (rotation) + returns value together with corresponding jacobian""" + prod = torch.stack([ + a[..., 0] * b[..., 0] - a[..., 1] * b[..., 1], + a[..., 0] * b[..., 1] + a[..., 1] * b[..., 0], + ], dim=-1) + jac = torch.stack([ + torch.stack([ + b[..., 0], b[..., 1] + ], dim=-1), + torch.stack([ + -b[..., 1], b[..., 0] + ], dim=-1), + ], dim=-1) + return prod, jac.transpose(-1, -2) + + +def complex_conjugate(a): + """computes complex conjugate (complex inverse on circle)""" + return torch.stack([ + a[..., 0], + -a[..., 1] + ], dim=-1) + + +def full_moebius(x, w): + """applies moebius trafo along w onto x and computes corresponding log det jac""" + z, jac_in = uniform_to_complex(x) + z_, jac_moeb = moebius_transform(z, w) + z0, _ = uniform_to_complex(torch.zeros_like(x)) + z0_, _ = moebius_transform(z0, w) + z0_ = complex_conjugate(z0_) + z_, jac_rot = complex_multiply(z_, z0_) + x_, jac_out = complex_to_uniform(z_) + x_ = torch.where(x == 1, x, x_) + + # TODO: inline computation of jacobian? + return x_, torch.einsum("...i, ...ij, ...jk, ...k", jac_in, jac_moeb, jac_rot, jac_out).log() + + + +class MoebiusComponents(torch.nn.Module): + + def __init__( + self, + compute_params: torch.nn.Module, + w_bound=torch.tensor(0.99), + ): + """ + compute_params: predicts directional and radial components of w, output should be [*shape, 3] dimensional + w_bound: bound avoiding singular projections + """ + super().__init__() + self._param_net = compute_params + self.register_buffer("_w_bound", w_bound) + + def _compute_params(self, cond, out): + w = self._param_net(cond).view(*out.shape, -1, 2) + + w = w * self._w_bound / ( 1 + w.norm(dim=-1, keepdim=True)) + + return w + + def forward(self, cond, out, *args, **kwargs): + w = self._compute_params(cond=cond, out=out) + out = out.unsqueeze(-1).expand_as(w[..., 0]) + return full_moebius(out, w) \ No newline at end of file From 95b82fd61c4a4288524aba34b35aa0c226dde17f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Wed, 19 May 2021 12:28:59 +0200 Subject: [PATCH 36/68] fix siren bug --- bgflow/nn/dense.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bgflow/nn/dense.py b/bgflow/nn/dense.py index 83ac945a..63b4cba0 100644 --- a/bgflow/nn/dense.py +++ b/bgflow/nn/dense.py @@ -74,5 +74,5 @@ def _init_siren_weights(layers): linear_layers = [layer for layer in layers if isinstance(layer, torch.nn.Linear)] for layer in linear_layers: n = layer.weight.shape[-1] - layer.weight.data = -np.sqrt(6./n) + 2.0*np.sqrt(6./n) * torch.rand_like(layer.weight.data) + layer.weight.data = -np.sqrt(6./n) + 2.0*np.sqrt(6./n) * torch.randn_like(layer.weight.data) linear_layers[0].weight.data *= 30. From 9c122ac07741041ddcebb4710d1d26989d82aa8c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Wed, 19 May 2021 12:29:25 +0200 Subject: [PATCH 37/68] argh --- bgflow/nn/dense.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bgflow/nn/dense.py b/bgflow/nn/dense.py index 63b4cba0..83ac945a 100644 --- a/bgflow/nn/dense.py +++ b/bgflow/nn/dense.py @@ -74,5 +74,5 @@ def _init_siren_weights(layers): linear_layers = [layer for layer in layers if isinstance(layer, torch.nn.Linear)] for layer in linear_layers: n = layer.weight.shape[-1] - layer.weight.data = -np.sqrt(6./n) + 2.0*np.sqrt(6./n) * torch.randn_like(layer.weight.data) + layer.weight.data = -np.sqrt(6./n) + 2.0*np.sqrt(6./n) * torch.rand_like(layer.weight.data) linear_layers[0].weight.data *= 30. From 8f7ac0a4320a807ad6975537ff1e4066560d8919 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Wed, 19 May 2021 12:32:38 +0200 Subject: [PATCH 38/68] optional siren init --- bgflow/nn/dense.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/bgflow/nn/dense.py b/bgflow/nn/dense.py index 83ac945a..78ec651f 100644 --- a/bgflow/nn/dense.py +++ b/bgflow/nn/dense.py @@ -64,15 +64,17 @@ def forward(self, x): class SirenDenseNet(DenseNet): - def __init__(self, *args, **kwargs): + def __init__(self, scale_first_weights=True, initialize=True, *args, **kwargs): super().__init__(*args, **kwargs, activation=Sin()) - self._init_siren_weights(self._layers) + if initialize: + self._init_siren_weights(self._layers, scale_first_weights) @staticmethod - def _init_siren_weights(layers): + def _init_siren_weights(layers, scale_first_weights=True): with torch.no_grad(): linear_layers = [layer for layer in layers if isinstance(layer, torch.nn.Linear)] for layer in linear_layers: n = layer.weight.shape[-1] layer.weight.data = -np.sqrt(6./n) + 2.0*np.sqrt(6./n) * torch.rand_like(layer.weight.data) - linear_layers[0].weight.data *= 30. + if scale_first_weights: + linear_layers[0].weight.data *= 30. From dd43fe386a7ac773d9568bdfb613de36a675528b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Wed, 19 May 2021 12:58:25 +0200 Subject: [PATCH 39/68] ... --- bgflow/nn/dense.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bgflow/nn/dense.py b/bgflow/nn/dense.py index 78ec651f..3c9c6bce 100644 --- a/bgflow/nn/dense.py +++ b/bgflow/nn/dense.py @@ -64,7 +64,7 @@ def forward(self, x): class SirenDenseNet(DenseNet): - def __init__(self, scale_first_weights=True, initialize=True, *args, **kwargs): + def __init__(self, *args, scale_first_weights=True, initialize=True, **kwargs): super().__init__(*args, **kwargs, activation=Sin()) if initialize: self._init_siren_weights(self._layers, scale_first_weights) From 39269b40dc4f61976f2215eb780c7416bf25fbe5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jonas=20K=C3=B6hler?= Date: Wed, 19 May 2021 13:21:52 +0200 Subject: [PATCH 40/68] Andreas's shape fixes for multi-dim inputs --- bgflow/nn/flow/root_finding/approx_inverse.py | 9 +- bgflow/nn/flow/root_finding/bisection.py | 4 +- bgflow/nn/flow/transformer/compact/compact.py | 4 +- notebooks/compact/compact.ipynb | 201 ++++++------------ 4 files changed, 78 insertions(+), 140 deletions(-) diff --git a/bgflow/nn/flow/root_finding/approx_inverse.py b/bgflow/nn/flow/root_finding/approx_inverse.py index 11761676..61b27b7b 100644 --- a/bgflow/nn/flow/root_finding/approx_inverse.py +++ b/bgflow/nn/flow/root_finding/approx_inverse.py @@ -108,7 +108,7 @@ def __init__(self, transformer, root_finder): self._root_finder = root_finder def _forward(self, cond, out, *args, **kwargs): - return self._transformer(cond, out, *args, **kwargs) + return (self._transformer(cond, out, *args, **kwargs)) def _inverse(self, cond, out, *args, **kwargs): flow = TransformerToFlowAdapter(self._transformer, cond=cond) @@ -163,7 +163,7 @@ def backward(ctx, grad_out_x, grad_out_dlogp): create_graph=True ) - return None, None, None, grad_in_y, *grad_in_params + return (None, None, None, grad_in_y, *grad_in_params) class WrapCDFTransformerWithInverse(Transformer): @@ -210,9 +210,10 @@ def __init__( def forward(self, cond, out, *args, **kwargs): def _residual(inp): - extra_dims = len(out.shape) - len(cond.shape) + n_extra_dims = len(inp.shape) - len(cond.shape) + extra_dims = inp.shape[:n_extra_dims] out_pred, dlogp = self._transformer( - cond.view(*np.ones(extra_dims, dtype=int), *cond.shape).expand_as(inp), + cond.view(*np.ones(n_extra_dims, dtype=int), *cond.shape).expand(*extra_dims, *cond.shape), inp, *args, **kwargs diff --git a/bgflow/nn/flow/root_finding/bisection.py b/bgflow/nn/flow/root_finding/bisection.py index 77dca6d9..244c112a 100644 --- a/bgflow/nn/flow/root_finding/bisection.py +++ b/bgflow/nn/flow/root_finding/bisection.py @@ -53,7 +53,7 @@ def filter_grid(f, grid): left = grid.gather(0, lidx) right = grid.gather(0, ridx) fleft = fgrid.gather(0, lidx) - dfleft = dfgrid.gather(0, lidx) + dfleft = dfgrid.expand_as(fgrid).gather(0, lidx) return ( torch.linspace(0, 1, len(grid), dtype=grid.dtype, device=grid.device).view(-1, 1, 1) * (right - left) + left, (left[0], right[0], fleft[0], dfleft[0]), @@ -77,7 +77,7 @@ def find_interval(f, grid, threshold=1e-4, max_iters=100, verbose=False, raise_e raise ValueError(msg) else: warnings.warn(msg) - return left, right, fleft, dfleft + return left, right, fleft, dfleft.sum(-1, keepdim=True) class BisectionRootFinder(torch.nn.Module): diff --git a/bgflow/nn/flow/transformer/compact/compact.py b/bgflow/nn/flow/transformer/compact/compact.py index 335e1e57..d07d883c 100644 --- a/bgflow/nn/flow/transformer/compact/compact.py +++ b/bgflow/nn/flow/transformer/compact/compact.py @@ -355,7 +355,7 @@ def __init__( self._compute_components = compute_components self._compute_weights = compute_weights - def _forward(self, cond, out, log_weights=None): + def _forward(self, cond, out, log_weights=None, *args, **kwargs): cdfs, log_pdfs = self._compute_components(cond, out) if log_weights is None and self._compute_weights is not None: log_weights = self._compute_weights(cond).view(*cdfs.shape).log_softmax(dim=-1) @@ -364,7 +364,7 @@ def _forward(self, cond, out, log_weights=None): out, dlogp = mixture_cdf_transform(cdfs, log_pdfs, log_weights) return out, dlogp.sum(dim=-1, keepdim=True) - def _inverse(self, x, y): + def _inverse(self, x, y, *args, **kwargs): raise NotImplementedError("No analytic inverse") diff --git a/notebooks/compact/compact.ipynb b/notebooks/compact/compact.ipynb index 28b0542c..2ef02c73 100644 --- a/notebooks/compact/compact.ipynb +++ b/notebooks/compact/compact.ipynb @@ -10,13 +10,6 @@ "%autoreload 2" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "code", "execution_count": 2, @@ -324,7 +317,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -336,7 +329,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -373,7 +366,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -385,7 +378,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlAAAADSCAYAAACFBf6/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABCiUlEQVR4nO3dd3xb1fn48c/RlvdOHMeJnUAGCdmDJEAWe/OFslog0JaWFmi/LRRKCqVQ+uMLLavQFsoMhSQUCoS90hBIgOyETLJjx3vbsrbO7w8pxo73khz5eb9eekm659x7H+na0qNzzz1Haa0RQgghhBAdZ4h0AEIIIYQQxxpJoIQQQgghOkkSKCGEEEKITpIESgghhBCikySBEkIIIYToJEmghBBCCCE6SRIoIaKQUmqbUmpOB+seUEqd1o19vaCU+mNX1+8pSqk5Sqn8MO3r+0qpj8KxLyFE3yQJlBBRSGs9Rmu9orvbCWdScizRWr+stT4j0nEIISJHEighoohSyhTpGI5Fx9L7dizFKkQ0kwRKiGNc6BTc7UqpLYBDKWVqfFpOKWVXSr2olKpUSu1QSv2mhValCUqpLUqpaqXUUqWUTSkVC7wPDFJK1YVug1oJI00p9bFSqlYp9ZlSamij+GYqpdaGtr1WKTXzqNhPa/T8HqXUv0KPc5RSWil1rVLqkFKqTCm1sFFde+j0YaVSajsw9aj35Q6l1N5QTNuVUhc3KluglFqllHpEKVUB3KeUqlBKndioToZSyqmUSm/hPV+glPoi9FiFtlMSeo1blFJjW1hnRqP3sU4p5VJKHQiVGRrFW66UelUplXLU+/BDpdQhYHmo/u+UUgdD+12klEps5dgIIXqBJFBCRIcrgXOBJK2176iy3wM5wDDgdOAHLax/GXAWkAuMAxZorR3A2UCB1joudCtoZf/fB+4D0oBNwMsAoSTgXeBxIBV4GHhXKZXaidd2MjASmA/crZQa3eh1DQ/dzgSuPWq9vcApQCLwB+BfSqnMRuXTgX1ABnAvsISm782VwCda69J24jsDOBUYASQBlwPlR1fSWn955H0EkoGvgMWh4luAi4DZwCCgEnjyqE3MBkaHXuuC0G0uweMaBzzRTpxCiB4kCZQQ0eFxrXWe1trZQtllwJ+01pVa63yCyUxL6xdorSuAt4EJndz/u1rrlVprN7AQmKGUyiaY1O3WWr+ktfZprRcDO4HzO7HtP2itnVrrzcBmYHyj13W/1rpCa5139OvSWv879JoCWuulwG5gWqMqBVrrv4bicgIvAlcppY58Ll4NvNSB+LxAPDAKUFrrHVrrwnbWeRxwEHyvAH4CLNRa54few3uAS486XXeP1toRivX7wMNa631a6zrgt8AVcnpPiPCRBEqI6JDXRtmgo8pbqlvU6HE9wRaNLu0/9IVeEdrvIODgUXUPAlmd2HZrsR39uprsRyl1jVJqk1KqSilVBYwl2ELWLOZQ3F8TTGpmK6VGAccBy9oLTmu9nGDrz5NAsVLqaaVUQmv1lVI/AeYAV2mtA6HFQ4E3GsW6A/ADA1qJ9+j39SBgOqq+EKIXSQIlRHTQbZQVAoMbPc/uoe021rBNpVQckAIUhG5Dj6o7BDgceuwAYhqVDexEbIU0fS1DGsUwFPgncBOQqrVOArYCqlH9ll7biwRP410NvKa1dnUkEK3141rrycAYgqfybmupnlLqFIKnOi/UWlc3KsoDztZaJzW62bTWhxvVaRzv0e/rEMAHFHckXiFE90kCJUT0exX4rVIqWSmVRTCp6KhiILUDHZTPUUqdrJSyEEwQvg6dVnsPGKGUuirUuf1y4ATgndB6mwieejIrpaYAl3bxdQ0Gbm5UFksw4SgFUEpdR7AFqj0vARcTTKIWdSQIpdRUpdR0pZSZYELoIth6dHS9bGApcI3W+tujiv8B3H+k871SKl0pdWEbu10M/K9SKjeUsP4JWNpC/zchRC+RBEqI6HcvkA/sBz4BXgPcHVlRa72T4Jf1vtDppdauwnuFYKfuCmAywT46aK3LgfOAXxPsWP0b4DytdVlovbsIdgKvJNjR+5VOvK4/EDx1tR/4iEb9lbTW24G/AF8STAJPBFa1t8FQH7ENBJOvzzsYRwLB1q7KUDzlwJ9bqDefYAvba42uxNsWKnuM4OnCj5RStQQ7mE9vY5/PEXy9Kwm+fhdNE0ghRC9TWne0hV4IEQ2UUjcCV2itZ0c6lr5IKfUcwQ7mv4t0LEKIvkuu2BAiyoUu3R9GsDXmeIKtQXLJewuUUjnA/wATIxyKEKKPk1N4QkQ/C/AUUAssB94C/hbRiPogpdR9BDuaP6S13h/peIQQfZucwhNCCCGE6CRpgRJCCCGE6CRJoIQQQgghOimsncjT0tJ0Tk5OOHcphBBCCNEl69evL9NaN5tQHMKcQOXk5LBu3bpw7lIIIYQQokuUUkdPRdVATuEJIYQQQnSSJFBCCCGEEJ0kCZQQQgghRCfJSORCCCFEL/J6veTn5+NyuSIdimiFzWZj8ODBmM3mDq8jCZQQQgjRDWXVh1i25Tmum3U3ytD8xE5+fj7x8fHk5OSglIpAhKItWmvKy8vJz88nNze3w+vJKTwhhBCiG+5c+Rse2fc6O4rWtljucrlITU2V5KmPUkqRmpra6RZCSaCEEEKIbqjxOgDw+dyt1pHkqW/ryvGRBEoIIYTohnMzpgCgAv4IR9I9cXFxDY9vu+02xowZw2233RbBiPo26QMlhBBCdMOpyaOpTRhLujUx0qH0mKeeeorS0lKsVmukQ+mzpAVKCCGE6AaX18VEWwYDLX07gVq0aBHjxo1j/PjxXH311ezfv58ZM2YwdepU7rrrroZ6F1xwAQ6Hg+nTp7N06dIIRty3SQuUEEII0Q0vF6zgjdK1fO25nph26v7h7W1sL6jp0f2fMCiB358/ps0627Zt4/7772fVqlWkpaVRUVHBggULuPHGG7nmmmt48sknG+ouW7aMuLg4Nm3a1KNxRhtpgRJCCCG6YW99EQCfFq6OcCStW758OZdeeilpaWkApKSksGrVKq688koArr766kiGd0ySFighhBCiWzQALp+z3ZrttRT1Fq11i1eaydWBXSctUEIIIUQ3HElBnN76iMbRlvnz5/Pqq69SXl4OQEVFBbNmzWLJkiUAvPzyy5EM75gkCZQQQgjRHbrjLVCRMmbMGBYuXMjs2bMZP348v/rVr3jsscd48sknmTp1KtXV1ZEO8Zgjp/CEEEKIbrgrcx6X7n0Jl79vz3V37bXXcu211zZZ9uWXXzY8vuOOOxoe19XVhS2uY5UkUEIIIUQ3jLQk85ukSZyQOCLSoYgwkgRKCCGE6IZPqncxwZrGiXFDIh2KCCPpAyWEEEJ0w5+KP+eJ6i0U1ZdGOhQRRu0mUEqpbKXUf5VSO5RS25RSvwgtT1FKfayU2h26T+79cIUQQoi+xaV9rHYV8cChtyMdigijjrRA+YBfa61HAycBP1dKnQDcAXyqtT4e+DT0XAghhOhXnAEfAC6/J8KRiHBqN4HSWhdqrTeEHtcCO4As4ELgxVC1F4GLeilGIYQQok/y+Tz4CADglASqX+lUHyilVA4wEfgaGKC1LoRgkgVk9Hh0QgghRB/m9n53ub8zIAlUWzZt2sR7773X6fXmzJnDunXrurzfuLi4hse33XYbY8aM4bbbbuvy9o7o8FV4Sqk44HXgl1rrmo4O/66UugG4AWDIELlCQQghRPSwYuDfA8/m/1WuozLgjXQ4fdqmTZtYt24d55xzTsRieOqppygtLcVqtXZ7Wx1qgVJKmQkmTy9rrf8TWlyslMoMlWcCJS2tq7V+Wms9RWs9JT09vdsBCyGEEH2FCRhlSebGxHHclDol0uG0atGiRYwbN47x48c3TBx88OBB5s+fz7hx45g/fz6HDh0CYMGCBdx4443MnTuXYcOG8dlnn3H99dczevRoFixY0LDNuLg4fv3rXzNp0iTmz59PaWnwKsTGLUZlZWXk5OTg8Xi4++67Wbp0KRMmTGDp0qU4HA6uv/56pk6dysSJE3nrrbcAcDqdXHHFFYwbN47LL78cp7PlEd5zcnK4/fbbmTZtGtOmTWPPnj0A7N+/nxkzZjB16lTuuuuuhvoXXHABDoeD6dOns3Tp0m6/p+22QKlgU9OzwA6t9cONipYB1wIPhO7f6nY0QgghxDGk0lnOR7W7mRWfy2BzfPsr7P4E6op7Noi4AXD8aa0Wb9u2jfvvv59Vq1aRlpZGRUUFADfddBPXXHMN1157Lc899xy33HILb775JgCVlZUsX76cZcuWcf7557Nq1SqeeeYZpk6dyqZNm5gwYQIOh4NJkybxl7/8hXvvvZc//OEPPPHEEy3GYLFYuPfee1m3bl1DnTvvvJN58+bx3HPPUVVVxbRp0zjttNN46qmniImJYcuWLWzZsoVJkya1+toSEhJYs2YNixYt4pe//CXvvPMOv/jFL7jxxhu55pprePLJJxvqLlu2jLi4ODZt2tTJN7hlHWmBmgVcDcxTSm0K3c4hmDidrpTaDZweei6EEEL0GwW1+fyxci2r3SVsri+IdDgtWr58OZdeeilpaWkApKSkAMFpXK666ioArr76ar744ouGdc4//3yUUpx44okMGDCAE088EYPBwJgxYzhw4AAABoOByy+/HIAf/OAHTdbviI8++ogHHniACRMmMGfOHFwuF4cOHWLlypX84Ac/AGDcuHGMGzeu1W1ceeWVDfdHpqVZtWpVw/IjrW29od0WKK31F3w32fTR5vdsOEIIIcSxw+VzAPBO7W7uqz/MlsADKEMbbRNttBT1Fq01Hem33LjOkT5CBoOhSX8hg8GAz+drc32TyUQgELwy0eVqfX5ArTWvv/46I0eObDOWjsbc2uPeIiORCyGEEF3k8tQDkGQOXunl8va9SXjnz5/Pq6++Snl5OUDDKbyZM2eyZMkSAF5++WVOPvnkTm03EAjw2muvAfDKK680rJ+Tk8P69esBGsoB4uPjqa2tbXh+5pln8te//hWtNQAbN24E4NRTT+Xll18GYOvWrWzZsqXVGI70ZVq6dCkzZswAYNasWU1eV2+RBEoIIYToIpcv2ME5yRLs/+Ty9L0EasyYMSxcuJDZs2czfvx4fvWrXwHw+OOP8/zzzzNu3DheeuklHnvssU5tNzY2lm3btjF58mSWL1/O3XffDcCtt97K3//+d2bOnElZWVlD/blz57J9+/aGTuR33XUXXq+XcePGMXbs2IYO3zfeeCN1dXWMGzeOBx98kGnTprUag9vtZvr06Tz22GM88sgjADz22GM8+eSTTJ06lerq6k69ps5QRzK/cJgyZYruzlgOQgghRF/y7sanuGPLE1yXNZ/nD3/KR+e+RmZa01NSO3bsYPTo0RGKsPfExcVRVxe5hDEnJ4d169Y19O3qrpaOk1Jqvda6xcsrpQVKCCGE6KK5qeN5J/M8jk8YCoDT64hwRCJcOjyQphBCCCGaijGYGGpOwJo+nr+Unky6JSHSIYVNJFufgIarASNFWqCEEEKILtpUsZPna7aTFjuIM2KGEG+0RDokESaSQAkhhBBdtLr8Gx6u2oRTwWpnIWX1pZEOSYSJJFBCCCFEF7n8LqzKSIGrgp+U/pdN5VsjHZIIE0mghBBCiC5y+d3YlAmbJTgOlNNbH+GIRLhIAiWEEEJ0kcvvxmYwYbeGBtL0tTzxbV/wxhtvoJRi586dDcsOHDiA3W5n4sSJjB49mmnTpvHiiy92az/33HMPf/7znwHYuXMnEyZMYOLEiezdu7db2+1rJIESQgghuqihBSo0kXBfboFavHgxJ598csMo3UcMHz6cjRs3smPHDpYsWcIjjzzC888/3yP7fPPNN7nwwgvZuHEjw4cP75Ft9hWSQAkhhBBd9Pvsc1mUezn2IyOR99EWqLq6OlatWsWzzz7bLIFqbNiwYTz88MM8/vjjzcpeeOEFLrzwQs466yxGjhzJH/7wh4ay+++/n5EjR3Laaaexa9cuAN577z0effRRnnnmGebOndvzLyrCZBwoIYQQootilZFYSwLaaOHJjLnkpk1sd53rPriu2bIzc87kilFX4PQ5+dknP2tWfuFxF3LRcRdR6arkVyt+1aTs+bPaby168803OeussxgxYgQpKSls2LCBSZMmtVh30qRJTU7zNbZmzRq2bt1KTEwMU6dO5dxzz0UpxZIlS9i4cSM+n49JkyYxefJkzjnnHH76058SFxfHrbfe2m6MxxpJoIQQQoguWlqyBrvRygUGA6fGDQVLUqRDatHixYv55S9/CcAVV1zB4sWLW02g2pri7fTTTyc1NRWA//mf/+GLL74A4OKLLyYmJgaACy64oAcj77skgRJCCCG66PWKzWRYErkA+MJZRGJNHCdyWpvrtNViZDfZ2yxPtiV3qMWpsfLycpYvX87WrVtRSuH3+1FK8eCDD7ZYf+PGja3O3aeUavZca91seX8gfaCEEEKILnIFvFhDo4/fX7aaVwq/iHBEzb322mtcc801HDx4kAMHDpCXl0dubm5D61FjBw4c4NZbb+Xmm29ucVsff/wxFRUVOJ1O3nzzTWbNmsWpp57KG2+8gdPppLa2lrfffru3X1KfIC1QQgghRBe5Al5sRisANoMZp98V4YiaW7x4MXfccUeTZZdccgmvvPIKt99+O3v37mXixIm4XC7i4+O5+eabue665v20AE4++WSuvvpq9uzZw1VXXcWUKVMAuPzyy5kwYQJDhw7llFNO6fXX1BdIAiWEEEJ0kVv7sBmCLVB2gxmX3xPhiJpbsWJFs2W33HJLw2Ons+NXDmZkZPDEE080W75w4UIWLlzYbPk999zT4W0fa+QUnhBCCNFFzoAPm8kGgM1gwdkHEyjRO6QFSgghhOgKrVmVfSk6ezoAdqOVUk91hIPqPQsWLGDBggWRDqPPkARKCCGE6IqAHzMGMAcv3/9V9pkE6isiHJQIFzmFJ4QQQnRBvaeWP1asZX3NfgCGx2ZxvDmhxbptja0kIq8rx0cSKCGEEKIL6tyVLK3bzb76IgC2OgtZVrW9WT2bzUZ5ebkkUX2U1pry8nJsNlun1pNTeEIIIUQXuDx1ANjMdgA+LP+GpaWrOXoc7sGDB5Ofn09paWmYIxQdZbPZGDx4cKfWaTeBUko9B5wHlGitx4aW3QP8GDjy13Cn1vq9Tu1ZCCGEOIa5vPUA2EwxoXsbTu1DBwIow3cneMxmM7m5uRGJUfSejpzCewE4q4Xlj2itJ4RukjwJIYToV1weBwC2UCdyeyiRcnnrIhaTCJ92Eyit9UpALisQQgghGvH6XZgxYDMFT+EduT9yak9Et+50Ir9JKbVFKfWcUiq5tUpKqRuUUuuUUuvk/K8QQohoMTl5FBuGXMGUjEkA2EN9oVzu2kiGJcKkqwnU34HhwASgEPhLaxW11k9rradoraekp6d3cXdCCCFEH+P3AqCMZgDmDTiJtzLPJc2aGMmoRJh0KYHSWhdrrf1a6wDwT2Baz4YlhBBC9G3ryrawsPxLKkN9nhLtyQwzJ2KW4Qr6hS4lUEqpzEZPLwa29kw4QgghxLFhX20eyxz78SkFQLG7mkU1OymsOxzhyEQ4dGQYg8XAHCBNKZUP/B6Yo5SaAGjgAPCT3gtRCCGE6HtcPicAVnMcAIWeSh6q2sCw6v1kDpoSydBEGLSbQGmtr2xh8bO9EIsQQghxzHD7XQDYLfHBe1MsAC5ffcRiEuEjU7kIIYQQXeD0uTCgMBktANgswZYop1cSqP5AEighhBCiC8xAhjGmYdRxuzWYQB05tSeim8yFJ4QQQnTBjVmncaM1u+G5zRw8lSctUP2DJFBCCCFEVwS8YDA3PI2zJfHxoAtJGDgzgkGJcJFTeEIIIUQXPHN4Of9X9mXDc4PBxEBzPDFKvlr7AznKQgghRBdsrD3I+vqC7xYoxQu1O1lZujlyQYmwkQRKCCGE6AJXwIPdYGmy7IXqbfy34psIRSTCSRIoIYQQogtcfg9Wo7nJMrvBjMvvjlBEIpwkgRJCCCG6wBXwYjuqBcpmMOMMDbApopskUEIIIUQXpBrtDLQmN1kWbIHyRCgiEU4yjIEQQgjRBU9nnQMpuU2W2QwWnJJA9QuSQAkhhBBdcdQ4UAB/HX4lJhlIs1+QU3hCCCFEF/z48Pv8p3Rtk2WxllisOkIBibCSBEoIIYTopEDAz1euQoo8NU2Wf1S1kydLVkcoKhFOkkAJIYQQneT2OgCwmexNlq+pPcDSqm2RCEmEmSRQQgghRCe5PHVA8wTKbrTi1N5IhCTCTBIoIYQQopPc3iMJlLXJcpvJhkv7CQT8kQhLhJEkUEIIIUQnab+P0eZk0mypTZbbTTHAd6f4RPSSYQyEEEKITsq0pfBq5tkwcHqT5TaTHQW4PLXYrQmRCU6EhSRQQgghRGf5Q/2cjE2/Rq8YegZXOv0oU2wEghLhJKfwhBBCiE7aVLaVy4s+YFdtfpPlBqMVpRQEfBGKTISLJFBCCCFEJ1W6K9juqcBH01Ezv3UUcHf5V+TVHIpQZCJcJIESQogosyPvCz795qVIhxHVXKHpWuyWuCbLy721vOHYR0l9USTCEmEkfaCEECLKXLb8RgA2j7kKg8EY4Wiik8vnBMBqjmmy/EhC5fTIVXjRrt0WKKXUc0qpEqXU1kbLUpRSHyuldofuk3s3TCGEEJ11oHhTpEOIWi5vMIGyHdUCZQ91Hnf5ZELhaNeRU3gvAGcdtewO4FOt9fHAp6HnQgghIkwHAg2PXbWHIxhJdEsxxzHJmo7d0nSogiMJldMrCVS0a/cUntZ6pVIq56jFFwJzQo9fBFYAt/dkYEIIIbrA4+DTQRehlCIdW6SjiVpnpo3nzNoasMQ3WW63xhGrTGi5Ci/qdbUP1ACtdSGA1rpQKZXRWkWl1A3ADQBDhgzp4u6EEEJ0hHJXk2GKAWXAW5OPOdIBRSu/FwxGMDQ9kZMRO4ivsi+DAdNbWVFEi16/Ck9r/bTWeorWekp6enpv704IIfq1TYVr+Gf1Nv7uzuPk7X/F63VFOqSo9PeD73JV4fvNC4yhlNUvEwpHu64mUMVKqUyA0H1Jz4UkhBCiq74sWsNfqzeTlTaaeu1jd+HaSIcUlYpdFRS11FFcGfht+Ze8XbQ6/EGJsOpqArUMuDb0+FrgrZ4JRwghRHfk1RUwwBTHxCFzANhWuCayAUUpl9+DzdBCLxilWFGfz/aaA2GPSYRXR4YxWAx8CYxUSuUrpX4IPACcrpTaDZweei6EECLC8pzFDLYmMzh1NIkGK9vKt0U6pKjkCrixGVruYWYzmHD53WGOSIRbR67Cu7KVovk9HIsQQohuynNXcmrKGJTBwJjYLLbW7I90SFEp2ALVWgJllgSqH5CRyIUQIkq4XDVU+91kx2UBcHHWHMqKtwQ7NBvleryeNMY+AK8OtFhmM5hx+qXzfrSTBEoIIaKEzedibfZl+I47F4Czhp0L9S6oK4bEwRGOLrrcnD4DLLEtlmWaE4gzWMIckQg3SaCEECJaOKswKQOmuNDQfAmZlPjq8RRvYbAkUD0r4IOWOpEDfxt+BQT8YQ5IhFuvjwMlhBAiPD459An3VazBaw2Njm2N58rij3hi1yuRDSwKXb5vMf+X/2HLhQYzBGQcqGgnCZQQQkSJr0o38379IczW76YXGROXzba6gxGMKjoV++pw6ZZbmZ4r+ZKFeS0MsimiiiRQQggRJfLri8i2JDdZNjZ5JAc8VdQ4SiMUVXRyB3zYjNYWy/a5K1hbnx/miES4SQIlhBBRIs9VTra96ZRZYwdMAmB7/qpIhBS1XNqH3dTyZM02oxWXTCYc9SSBEkKIKODzeSjw1pAdl9lk+ZjBswDYWrwhEmFFJa/PhQ+N1dhyAmU3WnFpSaCinVyFJ4QQUaCqNo8MYwxDE3KaLE+MG8jDg85ibNzQyAQWhQJ+D+fH5DAyoeX31Gay4dQ+dCCAMkg7RbSSBEoIIaJAmjbwYdaFMPyCZmWnD5oFNYcjEFV0smLgT2kzIWNyi+UD7GmMMCfh9TmxtDJWlDj2SWoshOgxOhDgoY9vZu3udyIdSv/jrAze25ObFZVZYvh32QaqJInqGUeGKGhlKpdLB8/n9cxzkKE0o5skUEKIHrM973MWFazg+tW/RQdanuZC9I5Fe9/gf8u+AEt8s7KDBh/3Vqxhc97KCEQWffZU7mbyoSV8Wrqx5QrG0Mkdv4wFFc0kgRJC9BhT1XfjDX2+49UIRtL/bKr8lj2+Gmihz83oQTMxoNhWsin8gUUhl7ceDwFMxpbbmL6u3MX3iz4kr+ZQmCMT4SQJlBCiZwQCjHRUs2HCnQwyxfPP7c9LK1QY5blKGWxLa7Esxp7EMGsyW6u+DXNU0cnlrQfAZo5psbxee9niKafGVRnOsESYSQIlhOgR+QVryasrxDxwPD89/jKmmpLxVR2IdFj9gg4EyHNXkR0zsNU6Y+Jz2ebIl6S2B7i8DgCsrSRQNlNwucvnCFtMIvwkgRJC9Ihnv/knlxS9jzspm4sn/5xbMmZgzlsb6bD6hSpHIQ7tJTu+9QmDRyWPoMLvoqJOOpJ3l8sXbIGym1q+ws5uiQPA6ZEEKppJAiWE6Dav18XHZZuYmzwGqzUejGYCWZP5b/5K9hz+KtLhRb262kImWtM5LmVkq3UuHHYeX2RdQmpAhzGy6DTImsJlcceREpPeYvmRxOpIoiWik4wDJYTottXfvkF1wM25w85rWOZIH8Wd5V8ya30Ff846KYLRRb9so51FA06H7Dmt1olPHAJGK9SXQ9KQ8AUXhU6IG8wJKdMgdkCL5Qn2ZMZb0ohRLQ9zIKKDtEAJIbrt3X3vkGiwMmPERQ3L4mPTuCxrNh9XbuNg8ZbIBdcfHBkDypbYeh1bIs/U7mDZgQ/CE1MU8/rc+HUAjC0nSJnxg/nXwDOYmTI6zJGJcJIESgjRLV63gy+qdnJG2kTM5qZzg109+ZeYUDy//tHIBNdP3L/jRX5atrLVL3QAlOIj52HeK/o6fIFFqRcPvMeEvCWtTxh8ZIBNGQcqqkkCJYToFnPVAd7LPJ+fTLixWVla0lAuHjCdt0rXU1yxNwLR9Q/f1uXjUqrdejkxAzngLAlDRNHN7XcBYDW33IncpxQXF77LkkMfhzMsEWaSQAkhuqd4O0kxaQwYOLHF4gWTf0GmKYbDB5aHObD+I89dwWB7Rrv1cuOHUOCrxemuCUNU0cvlc2FXplYnCjYZLRzw1lDirghzZCKcJIESQnRZVW0h129/ik12O7TSAjI4fQzvjLmFSa2c7RDd43TXUOqvJzsuq926ucnHoYFDJVt7P7Ao5vS7sSpj6xWUwqZMOH2u8AUlwq5bCZRS6oBS6hul1Cal1LqeCkoIcWz4ePsrrHUXY01r/fJ5AENKLr66Erz1MjJzT8sv2wlAdsLQduvmpp2AXRkprT7Qy1FFN3fAja2ViYSPsBlMuPzuMEUkIqEnhjGYq7Uu64HtCCGOMe/lfUquJZlRWTPbrHfIZOKy/Ne4e1cG50z8cZii6x+MXgdnxwxlRPrYduseP2ASX2VfjiE2OwyRRa+T448jh5bnwTvCZjBLAhXl5BSeEKJLSqv2s96Rx9mZs1rtC3JEVsZ4DMrAmsIvwxRd/zHMGMuDabM4LmNCu3UNJisGe1JwLCjRZWcmjeKH6dPbrDM9NpvhttQwRSQiobsJlAY+UkqtV0rd0BMBCSGODV/ufQ8NzB1+Xrt1jSYzU+Jz+bpqV+8H1s94HGVgsoLZ3qH6/6rbw8Ldr/RyVNGt2l1DPW2P6H7P4LP5UfqMMEUkIqG7CdQsrfUk4Gzg50qpU4+uoJS6QSm1Tim1rrS0tJu7E0L0FYluB/NjhzKig6OMTx8wmXxvDYfLdvRyZP3LLduf5rqij1vtxH+0Qu3ho5pvCQT8vRxZ9Lpp/1JuOfRW25WMZvB7whOQiIhuJVBa64LQfQnwBjCthTpPa62naK2npKe3PG+QEOIYozWztZVHT/gxBkMbVyM1Mn3ofADWHJCxcXqKDgTYWV/AoJj2hzA4IjcxF5f2U1Sxuxcji26ugBe7se0+UHfnvc8N+5aEKSIRCV1OoJRSsUqp+COPgTMAuTZWiH6gumIv1a4qSM7t8DrDB07hppTJjKVjp5pE+4oqd1Pud3Ji6pgOr5ObOgqA/aXycd1VroAXm6HtBMqhvRR5a8MUkYiE7rRADQC+UEptBtYA72qtZZIlIfqB/+x4mdn5r1MRk9ThdZTBwE+GXcTxHhfotvuPiI75Jn81AGMzmzX+tyo3fRwA+yqlP1pXuQI+rEZrm3XsRhuugEzlEs26PIyB1nofML4HYxH9nMtdyxMrF1Lvq+fOeY9issZFOiTRitXF68i1JpOSOKRT67kTMtlw6L8cV76b9LQRvRRd/7G1dBNmDIwY1PYVYY0lxw1irDUNs1cuse8qV8CLrZ0Eyma0tj5XnogKMoyB6BP2Fa7nqjfO58WC/1JeW4Bpw4tQeTDSYYkWuNy1bKg7xIzUEzu9bok1hhtKlvPpnjd7PrB+aKYlg18MPAVLB6/Ag2BL4OIR13FFQtuDn4rW/TjpROaljmuzjt1oxaUlgYpmkkCJiNKBAK+veZTLP/4h5T4Hf5t2F4+e8TQYTOxa+zce+eSXeDz1kQ5TNLJh/0d4CDBjcLOLbts1OG0MmaY41hSv74XI+plAgJOwcm3uBZ1fNyZVxoLqKq25Jn4kM9Pa/gExOiGHufYsdCAQpsBEuEkCJSLH66Lmm6U8vutfjI/N5rXzXuWU0ZehkgbD5Ov43KR57vCnXPWfc9l9eE2koxUhq/M+w4yBycPO6vS6ymBgWtJI1tTslcvou6mych/bnMV44zp/dfMHdfs4ff/LVDuKeyGy6Bbwe8nz1OBo5+/3nMyZ/F/aLJSWv/NoJQmUiAjt88Kml0msPMRLU37H0xe/SXpSoyu6TBZ+NO9BnphyJ6W+Oq5dfiMlVfsiF7BocFnMEB4YeiEx1oQurT89cxrVATe7Dsuo5N2xYv97XFH0AXmq8x3ybfZUivz1HCj5phcii261rgrOKXybN4rb+fs9MleejAUVtSSBEhHxt88Xct+hd/CfcAFDRl/U6lhCs8dcyaLTn8Wr/dy34jZpDo80dy1DPF7OyD27y5uYlnMmAGsP/benouqXtpZ+Q5wykzOg89fy5KYF583bXy6DmnaW01MHgM1ka7PeuyVrmJ73KgU1eeEIS0SAJFAi7HbmfcEzhz7AaY3HmDG63fpDB4zj5uGXkuDz4i3aHIYIRWs27vuQdxz78SZ1fTLaASnD+XfOFVwVd3wPRtb/fFOzjzGxWR0eyLSxrNRRmDCwv1padTvL7Q32ybSZYtqsZzCYqNc+XF5HOMISESAJlAgrr8/FXavvJtFo4/Y5D3Z4vatP+i33D7sUy74V4K7rvQBFm/69dxkPVW3EGJ/Zre2MypyCqTofpB9Ul7jctex2lXJicteSUJPJwlBLEvtrpXWks44kRLZ2rny0mYMJ1pEWKxF9JIESYfX8qvvY6SrlrvE3kRg3sMPrKaMRRp7LLmcpj8mpvIjQgQCrq3YyPXFEl1o9GiuxxfOn0i/ZmfdFD0XXv+ws+AofmrHpE7u8jTNTxzHGnNyDUfUPDQlUOy1QqTHBz7fD0nczakkCJcLGUXmQRYc+4Mzkscw/8ZrObyA2lVU2M88UfcGHW57r+QBFm74t/Jpyv5OZmR2bPLgtluRcFtd9y8oDH/VAZP3PCGXnnxnzmJIzr8vbuPG4S/hJ7HHSCthJg2wp3Jk8heMS257GaHT2LOzKxJrCr8IUmQg3SaBEeAQCxO77L0sGX8Sdcx7q8maumbGQsfaB/Ombp6ioye/BAEV7vtwfnAR4xrBzur2tpPhMRtnSWVmyrtvb6o9i6ss5KfF4EuOzurGRVHwBH15HSc8F1g+kmxO4Mn4EA+MGtVnPbLLxo4EnM8UYH6bIRLhJAiXCYt+ut9DVBQw+4RJSEgZ3eTsmk4X7Tr6fuoCH+1fc2oMRivbsqdzFcEsKA1KG98j2zhs8l831BWw9KFfjdda/Dn7IdlP35hP81lvD1LxXWXng4x6Kqn+oclWwy1OJpwPzOd4w6gecZUoFV00YIhPhJgmU6HW78lbzvTX38Ky/GDpw1V17jhs0jRtzz+ejym18ullO5YWF38cfEybw0oSeS1ovmfQz4pSZFzc/3WPb7A+q64r4v5LPWe0q7dZ2BqWNwkeA/ZW7eyiy/uGz4rVcWvQ+JZ6q9isnD6XIV09egQwEHI26PJmwEB1R76rm1i9uJ9Fo4+Lpt4JSPbLd62f+njh3PadWlUJ9BcSk9Mh2Rcu8JdswB3zEZ5zQY9uMs6dyTfZ86ioPoOsrUTHSobkjtuWvAuDEgZO7tZ04eyoZplj218ick53h9jkBsJnbn+w8EJvO94reZ44nj/uGndbboYkwkxYo0av+9OkvOOip4v9Nu5PUhK6PHXQ0o8nMlafcg9loofqbJTJfXi/y+lxcuuJmnnMdhJRhPbrtG2fcxW0pU1CHZW68jvqmeAMAJ2TN6va2cm3p7K8v7PZ2+hPnkQTKEttuXYPByNSE4XxdtUuuHI5CkkCJXvP2hr/zVtl6bhhyNtNHXNjzO7AlUDtsDt/b/SKPfvabnt++AOCN9U+wz1PJ8CGze6wFsYEtAZ0xmjX73pd52Tpoa+VOci3JxMemdXtbubFZ7HeVy5d7J7h9LgCslvZboACmD5xCoa+O/LJtvRmWiABJoETvqK8gteRbTksYwU9P+WOv7SZ+0ETmpE/kpYLPWLl9aa/tp79yumv4x+5/MzEmi1NHX94r+9ifOJAfFn3Ev9c/2Svbjypas8dRyInxOT2yuXmDZvLDhBPwyZV4HVZYX4xVGTG3M5XLEdOGBk/dfSWd9aOOJFCi5/l9sP1NZsYN4ZGzn8NksvTq7n499y+MtKbxu/V/lgmHe9jiNQ9T6q/nF5NuQRl65+NiWNY0ZsTn8sqhD+VUbHvcNbydeS6/GfOjHtncjJEX86OU8ZgPyVhFHeJ1cb0li3tyL+nwKjkZ48kwxbKmaG0vBiYiQRIo0eMe+vSXPJX/KXrkuWBL7PX9WS2xPDj7L7i0jzs/vQVvqIlddI/XVcuig+9xcsJxTB7e/bGf2rLghGsp9dfz3pZne3U/x7yaQkzKQGLqcT2zPWs83kGTWLz3LXYc+rxnthnNCjeTbbBx3oQbOryKMhh46Pjv8+vEE6EDQx+IY4ckUKLHBAJ+Hvn0f1lU+BmVMYmo9BFh2/ewzEncecL1+L1O9Devg88dtn1HK3PBBl4acDp3nLSw1/c1Y8TFHG9N5cU9r0l/nDYs+XYpD1ZthNiMHtumK3M8f6v+hkfWdX2A2/7A5/Pwu/UPsc1ihvgBnVp3UvZsBgYUOLo39IToWySBEj3C7XHwm3d+wHP5n3BZxkncOu/RsMdw0ZSbefrkB7BU51O97llKq/aHPYZo4XNWQf4asgdNZWjmlF7fnzIYWHD896j01nP4sJxOas0HRV+zyVsJxp4bgSY+No0bhl/Ml7X7Wb3rPz223WjzybaXeKtmFyWJnZ9IO5CUzZLab1m5e1kvRCYiRcaBEt0WcNfx07cvY50jj18Nv5QFM+/qtf4y7TEPngr2FO749Ofs3fsSf5/3V4aHIQGINg+t/C0F1Qd4bPJ1YfuVdfb4H3Km04O1ZDcMmgpGc5j2fGx4Y93jrHfk8dMhZ/f4ti+f8r/8a/+7PLrpSU46/sJuTxYdjV7atZRscwKnjrqsxXJ/QHOoop6dhTXsLKplV1Et+8scePwBAlrjS95GTEE+te+3PYee6Lg/XjSW007oXGtgT5IESnRPfQWGLa9ygS2bK47/HmeOvy7SEUHqcG4+aSE/X/lrrv7kJzx20j1MPf78SEd1zNh1+EteLVrNRRlTMfTApfIdZTbZ4LjT8O5YxsPv/4gfnnwvaUlDw7b/vuzLXW9w77ZnmBGfyw2n3Nvt7WmtcfsC1Ll9OD1+/AHNlUMu4y/7nmXRqr8xdfg1oXrd3tUxT2vYW7iCLc5Crh94CZsO1+Jw+zlYUc+hcgcHy+s5VFHPgXIHLm/w9LNSkJsay7D0OOwWI0YFxfW57LbtYu5xiRgMvXthTX+RHm+N6P6VDuN/yJQpU/S6dTJ5aDSoc5bz7/VPMNRRybzYHDjxUkjs+hx3veFw2Q5+9vFPyPNUc1nmLG6a8Tvi4tueALQ/04EAS75+iL/sXkyswcyr5yzpsXnvOmPbnve5bvWdJBltPDHnEUZknRT2GPoSf20R//P2pRgMJhad/1qb4z9prams91Jc46Kw2kl+pZPDlU7yq4L3JTUu6tw+HKGkqTGFj1FZTzCseiDv111GQHp4NMjN+ivVsUXU7r4Tr/5uAE2rycCQlBiGpsYwNDWWkQPjGTUwnuMz4rFbmrbifbD5WW7b9Cj/OvURxufKqOTHCqXUeq11i6cxJIESnVJWdZB/rX+UVwtWUhvwMDvhOB4742mMsemRDq1F1Y5iHlpxO+urdrFs0PmYB46jftB4YhJ7blT0qOCu5eHlv+b5ki+ZFT+c++Y9QnpSz51qcPv8VDu9ONx+6lw+6tzBm9Prx+cP4PUH8Pg1Xl8Af0BTVbuWZWV/xoWP8xJ+RHLCGQ2tIZrWP7OO1RaTFsPWGpO/nrFFb1Kpa9meciYmyxA8/gAubwC314/bF8Dl9VPl9FJU7aK01o3H37QTvsVkICvJTlaSnYwEK/FWE7GhW5zVhN1ixGRQGA2KeMdBsvPfoSxzDjWp4wBQgOrpAVSPISZPLeu2L8QVk8kpo+9EKYXdbGRISgwZ8VYMho69NxU1+cx+42xuyb2QH5/ae2PjiZ7VVgLVrVN4SqmzgMcAI/CM1vqB7mxP9FFeJ9QU8PLW53n4wNt4CXBa0gn8cMLPGDN0dqSja1Ni7AD+eO4LeBylmAs24SlYzwXr7+PE+KGcPuQ0Jg2dw8CU8F0t2Bd5i7dh3v0xl5gHMGjk1Vw+7dY2+7B5fAHqPcFWDIfbR4XDQ3mdhwqHm7I6DxUOD2V17tAt+LjW5etkVHHEmX5KYvYzvK7/QcbOreRXn46LyDbZh5NZ1TM5ZSme6iTe0HMo3RdAcQCL0YDVbMRmNmAzG7GaDCTazUzPTSEjwcaABCsDE2wMSLQxOMlOWlzHv+TRg6het513CxYxe/A1TMg5LWL9GfuMvduYO2giTP8p2JO6vJmUhMGMsqVTWHOo52ITEdXlFiillBH4FjgdyAfWAldqrbe3to60QPVtXq+T4qp9lNTkcbDyWzaXbGJT9V7+X8o0RltSWO0u4WNdy4JJtzB0wLge338goKn3Br+Ua10+HO7grTbUT8Pp9VPv8ePy+nGG7oMtFwE8Po031JLhD+jgTQfvA1oTCEBAa4yBaryGJRywbMZlCH6px/ttTKifSoxvCpUGG9VGL/7AAAKq9akajoWGjpb+tQPaj03tQxm24THuo8pcSLrXyqnVJ7HKPIsqlYDWwffKF9D4/BpfIIDPr/H4Azg9fnyB1l+9UpBkN5MaZyUtzkJanDV0s5AYY2lo/Yizmoi3mbCZDViMRkxGhdlowGI0YDCA0aAwKIXTXcWfPv05P7RmM8KawgaDn6/8NczKmc/YIXMwGZv3JTmWW0sCAT8HijexteAr3jrwPmvrDvKvmQ8w7vhzwxbDtoOfcd1nv8SpfWSbEzgv82TOPeH7vfI/39fVO6tYueIuTsuejWnspd3ennfXB5iLvoGT/7dHr6QUvadXTuEppWYA92itzww9/y2A1vr/tbZObydQ+w4e4KPtH1Dlr2yy3KqsjIsJ/vPvcu6iJlDTpDzGEMMY+xgAtju34wg4mpTHGeIZbR8FwNb6rTi1s0l5ojGREbZgK8bm+s14tKdJeYoxheG2YF+SDY4N+PE3KU8zpZFrDZ4uWetY2+iLL/hgoHkAQ6xD8Gs/6xzfTbqq0aA1gy2DyLYMxhNws8axDk0ArTUB7SOgfRxnzWGYeRB1/jo+ql2JO+DCo924tRt3wMM55hOYTBJ7vIf5vf/Lhu3HYmaYKZMzEs8hNX4STmsGPmVGownoYH+LQEDj14TuQwlLQH93SsYfwOMLJjYubzAJcnoDuEIJkcMTTJLqXMEWjY4yKLCZjVhMhoYvXovJ0HAqovHNoBRGpUAF11MoFF7M7MDPVmoN+5jhHMBIr5095goWJXwDgDVgIk7bsWkrs1xTSNEZFBmr2WXeh0GbMSgjShtRGBnqH4uNeKpUOaWGfFTwxAdHRgrJCozCjI1qVUqlobBZBpYVGI0JC9WqmGrVfFqNwYETMGCkUhVQYzgyloxuyJKG+U9EoSkx7KNKFaPxE8CNX7lQ+DjNNRmz9vCW/TP2mMsAsAVMDAxkkKxHYjVficFgRqEwGILvkcmoMBkMmI3fPY61GomxmIixGIm1mIixGkmJsZASZyE11kpyjBmTsYdbLLSGmgKo2Mdz3y7hsaLPCaCxKxNpphiSTbG8OOpHmCxxrKjZw476AswGM2aDGZPRQqzJzkVZpwKKryu2UeAqD/0NBBOtGJON0wdOB+DL8m8oc1c12X2cKYa5GZMB+KJ0M5Xepp8fSeZ4TkmfAMCKkvXU+r4bTV1rTZo1iZmpJwKaD4q+wuF14vG78QQ8ePxuhtjSODN5LO7aAuZue4zaQPDzI0aZ+PXIH3DZ9F/37PvZAbWOMj7Z8QrvHvyINXUH0cBrw69mZMpIVtTsZaMjjzhzLLHmeMxGMwq4JGsuymBgc9UeDtYXNdmeyWDinMyZAKyv3EmBs+l4SFaDhTNCx+Dr8m2UuCualMea7MzLCH6HrS7bQrmnukl5ojmOU9MnArCydCPV3rom5amWRGamBb8DPi1eS72/6WC7GdYUpqeOgYCfVw99TI2nhnqfk701B1levZN/nfow43NP7+S72IKy3VRvepk7ajaSbEkk2ZpIsjWJJFsyk1PHkBs7iGpPHSvLNjZbdULSCLJjBlDurmZ1+ZZm5VOSR5NpT6PYVcGaiubz7p2UOpZ0azKHnaVsqNzZrPzktPEkWxI45Chic/XuZuWz0yeRYI5lX91httU0n/FhfsZUYkw2dtUe4tvag83Kzxo4A7PBxPaa/eyty29Wfm7mLAzKwJaqPRw8aoJrAwbOHRScPHtD5U4OO0sZGpPJuKFzu9Uq2BG9dQovC8hr9DwfmN7Czm8AbgAYMmRIN3bXvq1bN/P2gZc5FFfVZHm8x4o6GPxSfC9rF4UxtU3KU9x2AoeCCdSy7B2U2pomUAOccfjygwnU60O2UmVt+s832JHAmQXBBOrVnM04zN4m5bm1ycwrCiZQS4ZtxGNsmiiMqE7jlJIcAF45bh36qB/QYyozOKlsCD7lZ/FxLfxjlWcyuSILp9HLv4dtblY+ZX8WVZWZVJs8fDZ0K6aACVPAiCFgwhgw8WFlJZ/XpVCjhpISb8XjS8LpGUCRZwhFGFkNQEXo1nEWUzCxMYdaF2xmI3azEbsleJ8WZ2GINYY4y5FWCWND34x4m4lYi4k4W7C1IsYS/OK2m43YLMHtdr+l4ZTvHmoNrmpKq/YxqvBrShxFFNcXU+Iqp9rr4Hsj0hhlSeTDqgI+LdmFM+DDx3d9Te4cGM8JlhRerd3NfZXNp2z4Q6aRHHMCL9Ts4C9VzY/hn7MspBvt/K1qC3+v2dqs/G+DbcQYzDxUuYFFtc0//F7ITkIpxT3lm/jMsRcAI4oEg5VUcww/njgITHayHHbqzDbGDz6FnAHjj43L1ZWCxCxIzOL63FO4pK6Ir/a+x6bi9ZS7q3B46zG5a6CumA8LPuEdR9PxvxINFi6qCyY1S0o/5xNnXpPyQcZYTq8MfqG/ULKc1a6mX/7HmROZmxn8QP9H0Uds9pQ1KR9nSeWUgWcC8Fjhu+zxNv1yn2EbyMyMeQA8cvgtCvxNP1/m2QdzpsuLNSaNqwfNITMxhxOzZpCTPh6jKTJDOcTHpnHxlFu4eMotFFfs5b+7/s0IywCoKWRzyQZeqvwGL037Wl3qCA5e+0b517we+hs8IkaZOKcq+PmxtGwV79c3/YJNN9o5I3QMXipZwWeugiblOaZ45g0KHpd/Fn/COnfTHxmjzcmcmhkc3uGJwvfZ4W36I3qKNYOZA4Idtx8peJuDvqbfAbNtg5ieMQeAfxx+g1K/EwXYlYl5iaN6JnkCSM7BmZpDRfkX7HOWUul34tTBlvCFyVPIjR9BoaeSO4veb7bqn1JnkB2by0FXCXeWfNKs/NG0U8iMyeZbZwF3lq5oVv50xjzSbQP5xnGQO8tXNSt/ecAZJFvTWFe3l99XfN2s/M3Mc0kwJ7KqZicPVm1oVv7xoAJiTLGsqN7KE9XNE7zZlaWYDRY+qNzI87U7mpWfXVWJQRlYVrGWpXVNEzirMnJudfCY/rtsNe/UH+DyuOMZlzKq1xOotnSnBep7wJla6x+Fnl8NTNNa39zaOr3dAlVdW8uB0v24j/p1YVBGBtiDY0WUu8vx+JuOUm0ymEm3BTtBl7lK8QaaJkBmg4U0W/DKlxJXCf5A0/4cFqOVVGsqAMXOYgK6aYJkNdpIsaYAUOQsQuumHzx2UwxJliRAUVhfADRNDGJMMSRaEgnoACWuElDf/XoGA7GmWGItcfh1gBpPDQaDMdSSYMZotGI2WjEazMEvImi07ndaykWOLFOq0d6UCrbiNLo3KtXktIvRoDAZ1DF9KqUjdCCAP+DD53djVkaMgMvnos5bh9Z+AoEAOtTamGpNwWwwUeupo/qoX88AA2MyMBlMVLtrqPGGPty1BhVqwYodiEEZqHJXU+d1oJQh2IaigrcBMQNRBhMuv4eAUpiNVkxGS7/svxII+PH53Hj9Lrw+N76AhzRrMgAVrgpcPleT/1GjMpIZOwC0psRZhvuozwezwczAmODI30X1JS18PrRdbjPZSLenAYri+lICBLCYY7CaY7CaYo/Z4+Tx1FPrKscf8BIIBBgYkw5aU+GqxOFrOqehAgbHBgegLHNV4PQ1bcU3KANZofJSZzmuoz7DTQYTmTHBz/BiZykef9NW/vaOgcVoYYA9+BlfWF+M76jPcJvRRro9FQxGanwurJY4LCZ7WI6L011DtaOIWKOdeEscHr+HYmdps3PwKdZkYs0xuPxuSp1lzbaTakshxmTH6XNR5ipvVp5mS8VuslHvq6fcVdmsPMOehtVopc7roPKoVlgIfkaZDWZqPLVUe2qalWfGDAh+hnlqqWmhfFDsQIzKSJW7mtqjWggBBscOQilFhbsKh9dxVKkiOy54BfWRv59Ycywp8YOhl+da7Ten8IQQQgghekpbCVR30uu1wPFKqVyllAW4ApBx6oUQQggR9brcB0pr7VNK3QR8SHAYg+e01s17rgkhhBBCRJluXUeptX4PeK+HYhFCCCGEOCYcez0XhRBCCCEiTBIoIYQQQohOCutceEqpUqD5CFs9Kw1ofo2niDQ5Ln2PHJO+SY5L3yPHpG8Kx3EZqrVucbLXsCZQ4aCUWtfaJYcicuS49D1yTPomOS59jxyTvinSx0VO4QkhhBBCdJIkUEIIIYQQnRSNCdTTkQ5AtEiOS98jx6RvkuPS98gx6Zsielyirg+UEEIIIURvi8YWKCGEEEKIXnXMJlBKqbOUUruUUnuUUne0UK6UUo+HyrcopSZFIs7+pAPH5PuhY7FFKbVaKTU+EnH2N+0dl0b1piql/EqpS8MZX3/UkWOilJqjlNqklNqmlPos3DH2Rx34DEtUSr2tlNocOi7XRSLO/kQp9ZxSqkQptbWV8sh912utj7kbwbn39gLDAAuwGTjhqDrnAO8DCjgJ+DrScUfzrYPHZCaQHHp8thyTvnFcGtVbTnBqpksjHXc03zr4v5IEbAeGhJ5nRDruaL918LjcCfxf6HE6UAFYIh17NN+AU4FJwNZWyiP2XX+stkBNA/ZorfdprT3AEuDCo+pcCCzSQV8BSUqpzHAH2o+0e0y01qu11pWhp18Bg8McY3/Ukf8VgJuB14GScAbXT3XkmFwF/EdrfQhAay3Hpfd15LhoIF4ppYA4ggmUL7xh9i9a65UE3+fWROy7/lhNoLKAvEbP80PLOltH9JzOvt8/JPirQfSudo+LUioLuBj4Rxjj6s868r8yAkhWSq1QSq1XSl0Ttuj6r44clyeA0UAB8A3wC611IDzhiVZE7LveFI6d9ALVwrKjLyfsSB3Rczr8fiul5hJMoE7u1YgEdOy4PArcrrX2B39Yi17WkWNiAiYD8wE78KVS6iut9be9HVw/1pHjciawCZgHDAc+Vkp9rrWu6eXYROsi9l1/rCZQ+UB2o+eDCf4i6Gwd0XM69H4rpcYBzwBna63LwxRbf9aR4zIFWBJKntKAc5RSPq31m2GJsP/p6OdXmdbaATiUUiuB8YAkUL2nI8flOuABHex8s0cptR8YBawJT4iiBRH7rj9WT+GtBY5XSuUqpSzAFcCyo+osA64J9dA/CajWWheGO9B+pN1jopQaAvwHuFp+SYdNu8dFa52rtc7RWucArwE/k+SpV3Xk8+st4BSllEkpFQNMB3aEOc7+piPH5RDBVkGUUgOAkcC+sEYpjhax7/pjsgVKa+1TSt0EfEjwyonntNbblFI/DZX/g+DVROcAe4B6gr8cRC/p4DG5G0gF/hZq7fBpmaCzV3XwuIgw6sgx0VrvUEp9AGwBAsAzWusWL+MWPaOD/yv3AS8opb4heOrodq11WcSC7geUUouBOUCaUiof+D1ghsh/18tI5EIIIYQQnXSsnsITQgghhIgYSaCEEEIIITpJEighhBBCiE6SBEoIIYQQopMkgRJCCCGE6CRJoIQQQgghOkkSKCGEEEKITpIESgghhBCik/4/BpB7GzrN92oAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -397,7 +390,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -439,7 +432,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -467,7 +460,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -495,7 +488,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -518,6 +511,41 @@ ")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## test multi-dimensional inputs" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "t = make_transformer(11, 13, 100, 20)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "x = torch.zeros(100, 11)\n", + "y = torch.linspace(0, 1, 100).view(-1, 1).repeat(1, 13)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "y__, _ = t(x, y_, inverse=True)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -533,27 +561,14 @@ "source": [ "from functools import partial\n", "\n", - "flow = make_coupling_flow(partial(make_transformer, d_in=1, d_out=1, d_hidden=100, n_components=20, periodic=True, verbose=False)).cuda()" + "flow = make_coupling_flow(partial(make_transformer, d_in=1, d_out=1, d_hidden=100, n_components=20, periodic=True, verbose=False))" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plot_transformer_density(\n", " partial(flow._blocks[5].transformer.cpu(), inverse=False),\n", @@ -567,7 +582,7 @@ "metadata": {}, "outputs": [], "source": [ - "flow = flow.cuda()" + "# flow = flow.cuda()" ] }, { @@ -576,7 +591,7 @@ "metadata": {}, "outputs": [], "source": [ - "train(flow, cuda=True, train_with_inverse=False)" + "train(flow, cuda=False, train_with_inverse=False)" ] }, { @@ -585,7 +600,7 @@ "metadata": {}, "outputs": [], "source": [ - "flow = flow.cuda()" + "# flow = flow.cuda()" ] }, { @@ -594,7 +609,7 @@ "metadata": {}, "outputs": [], "source": [ - "plot_evaluation(flow, cuda=True, n_samples=10_000, use_log_norm=False, train_with_inverse=False, eps=0)" + "plot_evaluation(flow, cuda=False, n_samples=10_000, use_log_norm=False, train_with_inverse=False, eps=0)" ] }, { @@ -606,7 +621,7 @@ }, { "cell_type": "code", - "execution_count": 529, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -663,7 +678,7 @@ }, { "cell_type": "code", - "execution_count": 530, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -676,7 +691,7 @@ }, { "cell_type": "code", - "execution_count": 549, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -729,7 +744,7 @@ }, { "cell_type": "code", - "execution_count": 550, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -738,22 +753,9 @@ }, { "cell_type": "code", - "execution_count": 551, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plot_transformer_density(\n", " partial(flow.t0.cpu(), inverse=False),\n", @@ -763,7 +765,7 @@ }, { "cell_type": "code", - "execution_count": 552, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -772,7 +774,7 @@ }, { "cell_type": "code", - "execution_count": 553, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -795,7 +797,7 @@ }, { "cell_type": "code", - "execution_count": 554, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -835,24 +837,16 @@ }, { "cell_type": "code", - "execution_count": 555, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "it: 19900/20000, kll: -9.964\r" - ] - } - ], + "outputs": [], "source": [ "train_with_energy(flow, energy, cuda=True, n_iters=20_000)" ] }, { "cell_type": "code", - "execution_count": 556, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -870,7 +864,7 @@ }, { "cell_type": "code", - "execution_count": 557, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -883,84 +877,27 @@ }, { "cell_type": "code", - "execution_count": 558, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor(0.7762, device='cuda:0')" - ] - }, - "execution_count": 558, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "ess(flow, 20_000, energy, cuda=True)" ] }, { "cell_type": "code", - "execution_count": 559, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor(0.7732, device='cuda:0')" - ] - }, - "execution_count": 559, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "ess(flow, 20_000, energy, cuda=True)" ] }, { "cell_type": "code", - "execution_count": 561, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 561, - "metadata": {}, - "output_type": "execute_result" - }, - { - "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" - } - ], + "outputs": [], "source": [ "from matplotlib.colors import LogNorm\n", "\n", From 73104e84b5e119ffa7896decf6e3e087cf5391b1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Wed, 19 May 2021 13:36:57 +0200 Subject: [PATCH 41/68] import moebius stuff --- bgflow/nn/flow/transformer/compact/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bgflow/nn/flow/transformer/compact/__init__.py b/bgflow/nn/flow/transformer/compact/__init__.py index cf41bf98..5a102f06 100644 --- a/bgflow/nn/flow/transformer/compact/__init__.py +++ b/bgflow/nn/flow/transformer/compact/__init__.py @@ -1,2 +1,2 @@ from .compact import * -#from .moebius import * \ No newline at end of file +from .moebius import * \ No newline at end of file From b5778c2a90409db9f669411c681a1a9a98e58ac0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jonas=20K=C3=B6hler?= Date: Thu, 20 May 2021 16:55:51 +0200 Subject: [PATCH 42/68] added non-compact sigmoid transformers --- bgflow/nn/flow/transformer/__init__.py | 3 +- bgflow/nn/flow/transformer/sigmoid.py | 100 +++++++++++ notebooks/compact/compact.ipynb | 220 ++++++++++++++++++------- 3 files changed, 258 insertions(+), 65 deletions(-) create mode 100644 bgflow/nn/flow/transformer/sigmoid.py diff --git a/bgflow/nn/flow/transformer/__init__.py b/bgflow/nn/flow/transformer/__init__.py index 6d75e919..9336b621 100644 --- a/bgflow/nn/flow/transformer/__init__.py +++ b/bgflow/nn/flow/transformer/__init__.py @@ -2,4 +2,5 @@ from .affine import * from .entropy_scaling import * from .spline import * -from .compact import * \ No newline at end of file +from .compact import * +from .sigmoid import * \ No newline at end of file diff --git a/bgflow/nn/flow/transformer/sigmoid.py b/bgflow/nn/flow/transformer/sigmoid.py new file mode 100644 index 00000000..84297dab --- /dev/null +++ b/bgflow/nn/flow/transformer/sigmoid.py @@ -0,0 +1,100 @@ +import torch +import numpy as np + + +__all__ = [ + "NonCompactAffineSigmoidComponents" +] + + +_logsigmoid = torch.nn.functional.logsigmoid + + +def _logit_deriv(x): + return 1. / x + 1. / (1. - x) + + +def _log_logit_deriv(x): + return torch.log(1. / x + 1. / (1. - x)) + + +def non_compact_affine_sigmoid_transform( + x, + mu, + log_sigma, + min_density=torch.tensor(1e-5), +): + sigma = log_sigma.exp() + z = x.logit() * sigma + mu + y = z.sigmoid() * (1. - min_density) + min_density * x + + log_j = (1. - min_density).log() + _logsigmoid(z) + _logsigmoid(-z) + log_sigma + _log_logit_deriv(x) + log_j_ = torch.where(torch.isnan(log_j), min_density.log(), log_j) + log_pdf = torch.logsumexp(torch.stack([log_j_, min_density.expand_as(log_j).log()], dim=0), dim=0) + + return y, log_pdf + + +def rescaled_non_compact_affine_sigmoid_transform( + x, + mu, + log_sigma, + min_density=torch.tensor(1e-5), + domain=torch.tensor([0., 1.]), +): + + a_in, b_in = domain.chunk(2, dim=-1) + + x = (x - a_in) / (b_in - a_in) + x0 = (torch.zeros_like(x) - a_in) / (b_in - a_in) + x1 = (torch.ones_like(x) - a_in) / (b_in - a_in) + + x_ = torch.stack([x, x0, x1], dim=0) + (y, y0, y1), (log_pdf, _, _) = non_compact_affine_sigmoid_transform(x_, mu, log_sigma, min_density) + + y = (y - y0) / (y1 - y0) + + log_pdf = log_pdf - (y1 - y0).log() - (b_in - a_in).log() + + return y, log_pdf + + +class NonCompactAffineSigmoidComponents(torch.nn.Module): + + def __init__( + self, + compute_params: torch.nn.Module, + min_density=torch.tensor(1e-4), + log_sigma_bound=torch.tensor(4.), + domain=torch.tensor([0., 1.]), + ): + super().__init__() + self._param_net = compute_params + self.register_buffer("_log_sigma_bound", log_sigma_bound) + self.register_buffer("_min_density_lower_bound", min_density) + self.register_buffer("_domain", domain) + + + def _compute_params(self, cond, out): + params = self._param_net(cond) + mu, log_sigma, min_density = params.chunk(3, dim=-1) + + mu = mu.view(*out.shape, -1)#.softmax(dim=-1).cumsum(dim=-1) + + log_sigma = log_sigma.view(*out.shape, -1) +# log_sigma = log_sigma.tanh() * self._log_sigma_bound + + # min density in [lb, 1] + lower_bound = self._min_density_lower_bound.expand_as(min_density) + lower_bound = lower_bound + min_density.sigmoid() * (1. - self._min_density_lower_bound) + + lower_bound = lower_bound.view(*out.shape, -1) + + return mu, log_sigma, lower_bound + + def forward(self, cond, out, *args, **kwargs): + mu, log_sigma, min_density = self._compute_params(cond=cond, out=out) + out = out.unsqueeze(-1) + return rescaled_non_compact_affine_sigmoid_transform( + out, mu, log_sigma, min_density, self._domain + ) \ No newline at end of file diff --git a/notebooks/compact/compact.ipynb b/notebooks/compact/compact.ipynb index 2ef02c73..7b6c3e00 100644 --- a/notebooks/compact/compact.ipynb +++ b/notebooks/compact/compact.ipynb @@ -58,7 +58,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -70,8 +70,10 @@ " AffineSigmoidComponentInitGrid,\n", " \n", " MixtureCDFTransformer,\n", + " \n", " AffineSigmoidComponents, \n", " MoebiusComponents,\n", + " NonCompactAffineSigmoidComponents,\n", " \n", " SmoothRamp,\n", " SmoothRampWithTrainableExponent,\n", @@ -131,34 +133,38 @@ " transformer=(\n", " t:=MixtureCDFTransformer(\n", " compute_weights=make_net(d_in, d_hidden, d_out * n_components, activation, periodic=periodic),\n", + " compute_components=NonCompactAffineSigmoidComponents(\n", + " compute_params=make_net(d_in, d_hidden, d_out * n_components * 3, activation, periodic=periodic),\n", + " domain=torch.tensor([0. - 1e-1, 1. + 1e-1])\n", + " )\n", "# compute_components=MoebiusComponents(\n", - "# compute_params=make_net(d_in, d_hidden, d_out * n_components * 3, activation, periodic=periodic)\n", + "# compute_params=make_net(d_in, d_hidden, d_out * n_components * 2, activation, periodic=periodic)\n", "# )\n", - " compute_components=AffineSigmoidComponents(\n", - "# conditional_ramp=SmoothRampWithTrainableExponent(\n", - "# compute_params=make_net(d_in, d_hidden, d_out * n_components * 2, activation, periodic=periodic)\n", + "# compute_components=AffineSigmoidComponents(\n", + "# # conditional_ramp=SmoothRampWithTrainableExponent(\n", + "# # compute_params=make_net(d_in, d_hidden, d_out * n_components * 2, activation, periodic=periodic)\n", + "# # ),\n", + "# conditional_ramp=SmoothRamp(\n", + "# compute_alpha=make_net(d_in, d_hidden, d_out * n_components, activation, periodic=periodic),\n", + "# unimodal=True,\n", + "# ramp_type=smoothness_type\n", "# ),\n", - " conditional_ramp=SmoothRamp(\n", - " compute_alpha=make_net(d_in, d_hidden, d_out * n_components, activation, periodic=periodic),\n", - " unimodal=True,\n", - " ramp_type=smoothness_type\n", - " ),\n", - " log_sigma_bound=torch.tensor(1.),\n", - " compute_params=make_net(d_in, d_hidden, d_out * (3 * n_components), activation, periodic=periodic),\n", - " min_density=torch.tensor(min_density),\n", - " periodic=periodic,\n", - " zero_boundary_left=zero_boundary_left,\n", - " zero_boundary_right=zero_boundary_right\n", + "# log_sigma_bound=torch.tensor(1.),\n", + "# compute_params=make_net(d_in, d_hidden, d_out * (3 * n_components), activation, periodic=periodic),\n", + "# min_density=torch.tensor(min_density),\n", + "# periodic=periodic,\n", + "# zero_boundary_left=zero_boundary_left,\n", + "# zero_boundary_right=zero_boundary_right\n", "\n", - " ),\n", + "# ),\n", " )\n", " ),\n", " oracle=GridInversion(\n", " transformer=t,\n", - "# compute_init_grid=lambda x,y: torch.linspace(0, 1, 100).view(-1, 1, 1).repeat(1, *y.shape).to(y),\n", - " compute_init_grid=AffineSigmoidComponentInitGrid(\n", - " t._compute_components\n", - " ),\n", + " compute_init_grid=lambda x,y: torch.linspace(0, 1, 100).view(-1, 1, 1).repeat(1, *y.shape).to(y),\n", + "# compute_init_grid=AffineSigmoidComponentInitGrid(\n", + "# t._compute_components\n", + "# ),\n", " verbose=verbose\n", " )\n", " )\n", @@ -276,7 +282,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -294,7 +300,7 @@ " 'cos']" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -312,12 +318,12 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -329,7 +335,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -361,12 +367,12 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -378,7 +384,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -390,7 +396,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -427,12 +433,12 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -455,12 +461,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -483,12 +489,12 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -520,7 +526,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -529,7 +535,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -539,13 +545,46 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ + "y_, _ = t(x, y, inverse=True)\n", "y__, _ = t(x, y_, inverse=True)" ] }, + { + "cell_type": "code", + "execution_count": 205, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[ 0.0000e+00, 0.0000e+00, 0.0000e+00, ..., 0.0000e+00,\n", + " 0.0000e+00, 0.0000e+00],\n", + " [-7.7321e-03, -7.1790e-03, -5.8637e-03, ..., -7.4780e-03,\n", + " -7.6361e-03, -6.1297e-03],\n", + " [-1.4187e-02, -1.3120e-02, -1.0713e-02, ..., -1.3576e-02,\n", + " -1.3778e-02, -1.0838e-02],\n", + " ...,\n", + " [-3.6102e-03, -6.5573e-03, -9.0616e-03, ..., -7.5957e-03,\n", + " -5.7418e-03, -1.1301e-02],\n", + " [-8.9812e-04, -2.7115e-03, -4.0700e-03, ..., -3.0189e-03,\n", + " -2.0247e-03, -5.1659e-03],\n", + " [ 0.0000e+00, 0.0000e+00, 0.0000e+00, ..., 0.0000e+00,\n", + " -5.9605e-08, 0.0000e+00]], grad_fn=)" + ] + }, + "execution_count": 205, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y__ - y" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -555,30 +594,43 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "from functools import partial\n", "\n", - "flow = make_coupling_flow(partial(make_transformer, d_in=1, d_out=1, d_hidden=100, n_components=20, periodic=True, verbose=False))" + "flow = make_coupling_flow(partial(make_transformer, d_in=1, d_out=1, d_hidden=100, n_components=10, periodic=True, verbose=False))" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "plot_transformer_density(\n", - " partial(flow._blocks[5].transformer.cpu(), inverse=False),\n", + " partial(flow._blocks[3].transformer.cpu(), inverse=False),\n", " label=\"wurst\"\n", ")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -587,16 +639,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "it: 900/1000, nll: -1.3465\r" + ] + } + ], "source": [ "train(flow, cuda=False, train_with_inverse=False)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -605,9 +665,55 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computing energy plot...\n", + "Sampling ground truth...\n", + "Sampling model...\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" + } + ], "source": [ "plot_evaluation(flow, cuda=False, n_samples=10_000, use_log_norm=False, train_with_inverse=False, eps=0)" ] @@ -918,20 +1024,6 @@ "theta = torch.stack(theta, dim=-1).view(-1, 2)\n", "plt.imshow((-energy(theta)).exp().view(100, 100).numpy().T, origin=\"lower\", norm=None)" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 0e2fc455d8429a165aa00486457f23d6de762ab7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Thu, 20 May 2021 17:11:24 +0200 Subject: [PATCH 43/68] sloppy uniform --- bgflow/distribution/distribution.py | 25 +++++++++++++++---------- 1 file changed, 15 insertions(+), 10 deletions(-) diff --git a/bgflow/distribution/distribution.py b/bgflow/distribution/distribution.py index 13c1a880..25d1adf7 100644 --- a/bgflow/distribution/distribution.py +++ b/bgflow/distribution/distribution.py @@ -2,10 +2,10 @@ import torch from .energy import Energy from .sampling import Sampler -import warnings +from torch.distributions import constraints -__all__ = ["TorchDistribution", "CustomDistribution", "UniformDistribution"] +__all__ = ["TorchDistribution", "CustomDistribution", "UniformDistribution", "SloppyUniform"] class CustomDistribution(Energy, Sampler): @@ -68,11 +68,22 @@ def __getattr__(self, name): raise AttributeError(msg) +class SloppyUniform(torch.distributions.Uniform): + def __init__(self, *args, tol=1e-5, **kwargs): + super().__init__(*args, **kwargs) + self.tol = tol + + @constraints.dependent_property(is_discrete=False, event_dim=0) + def support(self): + return constraints.interval(self.low-self.tol, self.high+self.tol) + + class UniformDistribution(TorchDistribution): """Shortcut""" - def __init__(self, low, high, validate_args=None, n_event_dims=1): - uniform = torch.distributions.Uniform(low, high, validate_args) + def __init__(self, low, high, tol=1e-5, validate_args=None, n_event_dims=1): + uniform = SloppyUniform(low, high, validate_args, tol=1e-5) independent = torch.distributions.Independent(uniform, n_event_dims) + self.tol = tol super().__init__(independent) def _energy(self, x): @@ -81,10 +92,4 @@ def _energy(self, x): assert torch.all(torch.isfinite(y)) return y except (ValueError, AssertionError): - if torch.any(x < self._delegate.base_dist.low): - indices = torch.where(x < self._delegate.base_dist.low)[0] - print("too low", x[indices], "at indices", indices) - if torch.any(x > self._delegate.base_dist.high): - indices = torch.where(x > self._delegate.base_dist.high)[0] - print("too high", x[indices], "at indices", indices) return -self._delegate.log_prob(self._delegate.sample(sample_shape=x.shape[:-1]))[:,None] From 529762c4ed6ef7371917674e1e1a3b68f75807fb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jonas=20K=C3=B6hler?= Date: Thu, 20 May 2021 17:46:25 +0200 Subject: [PATCH 44/68] add log sigma bound to non compact affine trafos --- bgflow/nn/flow/transformer/sigmoid.py | 2 +- notebooks/compact/compact.ipynb | 101 ++++++++++++-------------- 2 files changed, 47 insertions(+), 56 deletions(-) diff --git a/bgflow/nn/flow/transformer/sigmoid.py b/bgflow/nn/flow/transformer/sigmoid.py index 84297dab..219dc48c 100644 --- a/bgflow/nn/flow/transformer/sigmoid.py +++ b/bgflow/nn/flow/transformer/sigmoid.py @@ -82,7 +82,7 @@ def _compute_params(self, cond, out): mu = mu.view(*out.shape, -1)#.softmax(dim=-1).cumsum(dim=-1) log_sigma = log_sigma.view(*out.shape, -1) -# log_sigma = log_sigma.tanh() * self._log_sigma_bound + log_sigma = log_sigma.tanh() * self._log_sigma_bound # min density in [lb, 1] lower_bound = self._min_density_lower_bound.expand_as(min_density) diff --git a/notebooks/compact/compact.ipynb b/notebooks/compact/compact.ipynb index 7b6c3e00..4613d055 100644 --- a/notebooks/compact/compact.ipynb +++ b/notebooks/compact/compact.ipynb @@ -43,7 +43,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 47, "metadata": {}, "outputs": [], "source": [ @@ -58,7 +58,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 48, "metadata": {}, "outputs": [], "source": [ @@ -282,7 +282,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 49, "metadata": {}, "outputs": [ { @@ -300,7 +300,7 @@ " 'cos']" ] }, - "execution_count": 7, + "execution_count": 49, "metadata": {}, "output_type": "execute_result" } @@ -318,12 +318,12 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 50, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -335,7 +335,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -367,12 +367,12 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 51, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -384,7 +384,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -396,7 +396,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlMAAADSCAYAAABuMkW8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABCsElEQVR4nO3deXzcVb34/9d7Jnsm60ymafY9KaWlpem+F5BFoSIChQtY0IviRRBlEUVFRH8qXq9c4XrlIiJeLSBcsXr5igpd6AKlpRUobbM0XdItk5lsk2SSzMz5/THT3LR0Sdskk+X95DEPZuZz5vN5Tz5p5j3nnM/7iDEGpZRSSil1diyRDkAppZRSaiTTZEoppZRS6hxoMqWUUkopdQ40mVJKKaWUOgeaTCmllFJKnQNNppRSSimlzoEmU0qNACKyR0QuHqB9LRKR+jNov1pEPjcQxz4XIrJcRNadw+u/LiJPD2RMSikFEBXpAJRSg0tEDFBqjKmJdCyRZIz5fqRjUEqNTtozpZQa9UQk4l8cIxXDcHjvSo12mkwpNXJMF5EPRaRJRH4lInFHN4jIP4tIjYh4RGSliGSFn18bbvIPEfGKyPV9XvNVEWkQkUMicutpjl0sIptEpFVE/igi6X32c5WIbBeR5vCQ4IQ+24yIlPR5/KyIPBq+v0hE6k8Wh4jYw++lVUQ2AcV9AxKRx0Vkf3j7FhGZ32fbwyLykoj8t4i0AsvDz/13nzazRGRDOO5/iMiiPtuWi8huEWkTkToR+acT/VBEZIaIbAzv45CIPCEiMce9/38RkWqgOvzcJ0RkW/g1G0Rk8kn2fX/4nB299YjIs+FtKSLyy/AxD4jIoyJi7RP7ehH5NxFxAw+H2z8nIi4R2SsiD4mI/v1XaoDoPyalRo5/Ai4llFSUAQ8BiMgS4P8DrgPGA3uB5wGMMQvCr73AGGMzxrwQfpwJpADZwGeBJ0Uk7RTHvgW4Lbx/P/Dv4WOXASuALwMZwKvAn/omFKdxqjieBHzhY94WvvX1DjAFSAd+B/y+b4IJLAVeAlKB3/Z9oYhkA/8LPBp+/b3AyyKSISKJ4fd3uTEmCZgDbDtJ/AHgHsABzAYuAr54XJtPAjOB80RkKvAM8HnADvwCWCkiscfv2Bjzo/A5swETABdw9Pw9S+g8lABTgY8Bfee1zQR2A+OA7wE/I/RzLgIWEjqfp0uglVL9ZYzRm970NsxvwB7gC30eXwHUhu//EvhRn202oAcoCD82QEmf7YuATiCqz3MNwKyTHHs18IM+j88DugEr8E3gxT7bLMABYNFJjv0s8Ojp4gjvuweo6LPt+8C6U/yMmggljQAPA2uP2/4w8N/h+w8Avzlu+2vAZ4BEoBm4Bog/w/P0ZeAPfR4bYEmfxz8Hvnvca3YBC0+xz3hgC/BA+PE4oKtvbMANwKrw/eXAvj7brOHzdV6f5z4PrI7077Xe9DZabtozpdTIsb/P/b1AVvh+VvgxAMYYL+Am1NtzMm5jjL/P4w5CSVh/jx1NqDfm+GMHw21Pdez+xJFB6AKZ44/bS0TuFZEdItIiIs2Eel4cJ4n5ePnAteGhtubw6+cB440x7cD1wBeAQyLyvyJScaKdiEiZiPxZRA6HhxO/f1wMx8eRD3z1uOPm8n/n8kR+Cewyxvywzz6iw7Ed3ccvAOdJjukIt+/789tL/8+RUuo0NJlSauTI7XM/DzgYvn+Q0AcsAOFhKjuhHqLBOnYP0HiCY0u47dFjdwAJfV6b2c/juQgNYx1/3KPHmQ/cT2hoM80Ykwq0ANKnvTnF/vcT6plK7XNLNMb8AMAY85ox5hJCQ4w7gf86yX5+Ht5eaoxJBr5+XAzHx7Ef+N5xx00wxqw40c5F5GuEhnQ/e9w+ugBHn30kG2MmnuSYjYTOV36f5/IY2N8PpcY0TaaUGjn+RURywpO/v8H/zZ9ZAdwqIlPCc2++D7xtjNkT3n6E0FyZc3GTiJwnIgnAI8BLxpgA8CLwcRG5SESiga8S+qDfEH7dNuBGEbGKyGWE5uucVnjf/0No8nSCiJxHaAjuqCRCyZYLiBKRbwHJZ/B+/hu4UkQuDccWF54QnyMi40RkaTgp7QK8QPAk+0kCWgFvuPfqjtMc97+AL4jITAlJFJGPi0jS8Q1F5HLgLuBqY0zn0eeNMYeAvwL/KiLJImIRkWIROeHPts95+p6IJIlIPvCV8M9AKTUANJlSauT4HaEP0d1ALaHJ0xhj/k5o7tLLwCFCE9SX9Xndw8Cvw0NC153lsX9DaL7TYSCO0Ic8xphdwE2EJjg3AlcCVxpjusOvuzv8XDOhCfSvnMEx7yQ05Hc4fOxf9dn2GvAXoIrQkJWPUw/rHcMYs5/QBPWvE0rI9gP3EfqbaCGUbBwEPIQSwJMlSfcCNwJthBKlF07S7uhxNwP/DDxBaI5XDaE5TidyPaHhzh19ruj7z/C2W4AY4MPwfl4i1It2Ml8C2gn97qwj9Lv0zKliVUr1nxhzqp5wpZRSSil1KtozpZRSSil1DjSZUkoppZQ6B5pMKaWUUkqdA02mlFJKKaXOgSZTSimllFLnIGKriTscDlNQUBCpwyullFJK9duWLVsajTEZJ9oWsWSqoKCAzZs3R+rwSimllFL9JiJ7T7ZNh/mUUkoppc6BJlNKKaWUUudAkymllFJKqXOgyZRSSiml1DmI2AR0pdS5McEg/kA3Xf52JBgg0RoHQT97Wvfi6+mgJ9BFT6Cbbr+P9JgkypLyIBjgLwfX0R3owh/swR8MEAj6KUnMYnpqGYGgn6f3vkrQBAiYIEETwB8MUJlczIL0CXT6u/np3j8RNAZDMPx/w+LUCSxIm0CLv51/3fcqhmPX/Lw8/QLmpJbR0N3Kk/V/QwBEsGBBgE9kTGNqchGHupt57uAarGLFIoJFLFjEymXOSspsORzsauIvDVuwWqxEWaKIskRhFStzHRcwPmEcDd0tvN9SS5QlmmhrTPgWS0lKEbbYZNr9XTT1tBITHU+MNZ6YqHiio+OIssQgFv1uqZQ6O5pMKTUIgsEAvq42Orpa6OhuIeDvpjBhHAS62dSwlcMdR+joaafT34nP30mqNZ4bxs2GYA8/2ftn6jpddAW76Qr04Av2UBFr5zuZiyDo57q9L1PX00yXCfSmLIvjc/j3jAUAfKb+ZTzBrmPi+XhCAT9wzAHgW/tfoNMEjtl+na2E6ekzwAR5Yv/K3uejECwIUd4GFvi68Bs/f27YhAXBIkLoPygMCgtMDF3+DjY07QAIbwmZIokQjKaju5l1TR9iwkmYAQyGKcQy1deJx+fiD4c3EsQQxBAwof+XdXgpS8xnr+8w/9bwxkd+3v+RsYjx8Vm837GfLze++ZHtv3ZezIVxTt5or+Pr7o0f2f7i+MuZEJfBK946fubZQowliliJItYSTZwlmh8VXM24uHTWtNbyestO4qyxxFnjiI+KIy4qnutzLyEhxkZtxxEOdHmIj04gISaZ+JgkEmKTcNqysETFgcV6ul8dpdQIpMmUUn0ZQ4evmeb2I7R1evB2N+P1tdDZ4+Uyx4UQ6OJ/D65na0sN7f4OvP5O2v2dxIiF/8z5BAS6+cqB1/h7x95j+mbyomz8b9ZVAPziyOts6jpyzGEnxti5QZLBEk19+yEOdbeEPsitMdij4rDHOyA5GyxRXOSbgTfYRYwlhlhrDDHWWPITs2DcNLBE8bAjmyAQbY3t7ZlxxKdDUj5YrLw44fJQz441hihrDFZLNHHRCRCdiAXhXb6K1RKN5QQf/EnAer520h+fE/g7D5x0ewHwOg+ddPtE4C2+/9ENxoAxzAj08HbAR9D48fu78Qd7CAR6SIm2gTWaGd2tvNR2Ez3BLnr8od63nkA3xSnFEBXPFG89j7on0xXooifYTXegm+5AF85xcyAqnvFNCczDhy/QRXcwlMh2BbqxBv3ga+ZA2z42NO3AF/TjM366wknpp7oASwx/bNrKr9p2fCT8d3OvxyJWftS8lZXe3SRaYkiwxpBgiSElOoH/KL0FrDG82rSdGp8LW7QNW0wStpgkUuPtzMmcAVGxNAd8WKMSSIxPO+H5UUpFhhhjTt9qEFRWVhqtM6UGgwkG6exqpbn9MC2djbR0NNLi87Ao7TxiTZC1RzbzeuM2Wnu8tPo7aPV30Ob3sTL3amKCAb7vfocV3qpj9mlB2Ja7DBHhu02b+Vv7PhKtMdissSRYY7FHJ/GTkhvBGsOfPP9gX1cTidE2EqITiI9OJC0unXmZ08EawwGfh6AI8THJxMcmERedhDUqOkI/LXUuAv4eunraiRcrYvw0eA9z2HuQzh4vnT3tdHR78fk7+FTmXAh08dqRt3mnqYoOfycdgU7a/T6MCfJ03ifB38XXD/2dP3trj0nEndZ4Xs++GoB/aVjNWt9BBLBZYkiyxFIWl8HPiq6DqFiecb2Ny99BckwSybEpJMemMD4xi8px0yA6npZgNwlx6URHx0Xix6XUiCYiW4wxlSfcpsmUGu46u1ppajtIujWOuGCAuuYa3jz8Ds1dTTR1tdDS3UpTj5fvZi4hR2L4jXsrP2r66O/Wa1lLyYpK5Ndtu/h16w6SrXEkR8WTHJVAcrSNh0quIyE2ma3e/dT5XCTFpmKLTSEpLhVbXDr5KUVIdDxYtUNXDZ6jXwa8XR68nc309LRTbssGfzdrDm1kT9t+2nq8eHu8tHV7SbHGcn/mQvD7+OLeP/BuxyHaTU/v/i6MzeDX4y4BYOnBP7Pb30q8RJFijSPFGsec5GK+kv9xiIrn2SPrsVhjSY1LIzXeQWq8g8zkXJzJeRAVCyInC1upUe9UydRpPxVE5BngE0CDMeb8E2wX4HHgCqADWG6MeffcQlajWTAYoMl7EHfbAdzeQ7jbj+DudLEwpYyCKBvbPLv4Uf3/w9PTjifQSafxA/BL50XMiBvHrva9POZejxUhxRpLmjWBlOgEeuKSwJbLhbYU7knLJzUulZQ4OynxdlLiHWSklUBsMp+xRvGZU8Q3NXxTKhLEYiEhPpWE+FScqcduW+isYOEpXvsf0z8HgN/fTVtnI22djRh/F8Smg7+L22wJHOlooKW7lebuVlp7vMSIBbwu8Hfy9N5XaQl2H7PPqxIL+Z59NkYsXH7gj8RbY0iPtpEWnURaTApzHZNYNH4WJiqeza27sdvGk27LIjnRqUORaszoz1fsZ4EngOdOsv1yoDR8mwn8PPx/NcYE/V1Yutvp6Ghk7YE3aWw/QmOni0ZfE41dzSxLnciiuEw+aNvHPx3+y0den+6YS0Ha+cQFukmOSqAgYTxpsSmkxaaRHp9OfuZMSM5lkcXKOouFpHjHCf9YTwzflBqroqJiSEvKIi0p65jnl44775SvWzv7TrydHprbD9Hc7qK5w0W6NRYSsgh0tzGrYxdN3W009bSxq70eT0sVts4mFrW10hro4rYDL/fuy4qQZo3j9oyZ3JA5l1YRfnFkHfY4O/Z4B47ETBy2LLLTirElZIBeTalGsNMmU8aYtSJScIomS4HnTGi88C0RSRWR8caYQwMVpIqsHr8Pd+s+pLuTcZZYfJ0efl7ze1ydbhq6mnB1t+Dyt7M8qYLbU86nzd/BfQdfAUJXg9mjEnBE2eiyxkB6Mfn2Yh5MdmBPyMCemEl6Yib25GyS40N/UCuA/zxFPHHhm1JqYFksVpITM0hOzCDvuG1RwMMlF3/kNSbgB7+PeF8zT+dNwdPhwtPhwu3z4PF5yE7MAn8Xbm89vz+0rren+ahvpc/g2qRSqoOdfK1hLRkxydhjU3HEpZMRn8GirLnkpBbSbY3BHx1PQlzK4P0AlDpLAzH5IxvY3+dxffg5TaZGgJ4eH0eaazncspfYQA+T4sdBVxv37vglB3xujnS30hjowADX2kr4VvoMok2QFQdWkWZNICMmieKE8cyKS2ei80LInIkjJp6XzruCjKRcUm3jP9J7lALcyBUReb9KqYEl1iiw2oiJtTEzJeek7QqBTebrdPhaaGzbh7vtIO72I1QkjANrAjTXktX6AY3drdR2NtDo78BPkLzmg+TEZ7Oho54vNa7FJtFkRNtwxiSTEZvG5ws+TkFqCQ3Bbg76vTiT88hIKdBJ9qOct8vPlr1NvFPnYVOdh3+alcfSKdkRi2dIZ9KKyO3A7QB5ecd/71EDzQSDNLcf5qCnmsOte7H0+FicXAS+Vu6qeo73Ow7iDnT2Xjk0Py6L/3AugqhYWrpbSYlKoMyWizPewbjETCrs54FzKtZYG29HPXjSIodWoJzSoXqbSqmRQoSE+FTy4lPJc04+ZlMpC/jZ1Ft7Hx/9+xUfDEKgmwJPNXcn2XF1unD5PLi6m9naUov/0HvgquONtiq+1+fCk3RrHOOik/lp8Q1kJeWwvdtDdZebcUk5ZKYUMC61SHu5RhBPezfv7AklTpvqPGw/2ELQgNUinJ+VjNUS2YsjBiKZOgDk9nmcE37uI4wxTwFPQehqvgE49phmgkGavAc52FTNgeY6OnxNXJ12PvhaeKD2RVa11R7TpV4WncrinKsgNoXsODupcWlkxjvJtI0nMymX3LRSsFdAVAz/xVdOeWy9pkcpNZjEYjlmzldBehGfK7n0ow2NgZ4OljTvIdu9nYa2gzR0HOZIp4sGn4ckfxe4dvJ310aebv3wmJcmWWL4e+ltJCRk8Hr7Xmq7m8m0ZZGZnMv4lELGpRYTE5Mw2G9VncCRVh9v13nYVOdmU52HqiNeAGKiLEzNTeVfFpcwozCdqXlp2GIjf4X1QESwErhTRJ4nNPG8RedLDZzOrlbqG3dS31zNkdZ6ljkuBF8Lj+1Zye+b3j8mWUqSaK4uuhniUjgvKZ/0xHFk2bLISsolMzmfrPRSsI0HER4IdRAqpdTIJgIxiTidE3E6T37pyRe6P8fVzbs50rKPw237OeI9hLuzkfgEJ3S3seHwJl5s3XnMaxIlio1Fy5H4FH7XsoP6QDvjE8eTlRRKtrLSSki1ZWrJiAGw39PBpjoPb4eTpz3uDgBssVFMy09j6ZRsZhSmMzknhdio4XeVaH9KI6wAFgEOEakHvg1EAxhj/hN4lVBZhBpCpRFuPfGe1ImYYJCW9iPsc+9gf1M1F6eUEdvl5bf7X+fphg00BjqPaX9lV5DExAwqkvK5JjaJnKQcspLzyEotIiutDBLsAKe89F8ppcaa2Bgbec7JHxlePOqblbdxf7eXI827OdRcx6HWfXR2tSD2Uuhq5YOWWv7WVoOvz1JMhVHJrMy9GuJS+KlnM14gK3E8Wcm5ZKcUkmMvJ82WpcnWcYwx7HV38Hadm7d3e3i7zsOB5tBnXUp8NDMK07lpVj4zCtM5b3wyUdbhf6WnFu0cIq3tLva63qcwyoatp4u1hzbyH/V/ZV9XE2196rq8Mv7jFNtyeKPbxeqOfeTYsslNzicntZgcewWpiZm6IKtSSkVAaGrFIQ411XCodQ90d3Jxcgn4mvlS9W94t72e1j5/z2fHZfLU+I9BXCoPN7xJTHQC2bZscpLzyU4tJsdeji3BEbk3NESMMexubOet3UeTJzdHWkPrh9oTY5hZlM7MQjszi9IpcyZhifD8p5M5p6Kdqv96/D6CHR5iu7zsdn3As3v+xJ72Q+ztcuMJ+AD4z4xFzE3IJjbQSnJUAlckF5GXlEduaiF56eXkOc6D6ASWAEsi+3aUUkr1IRYL6cnZpCdnM/G48qk/m/RpALydbg54qjjYvJv4QAASsjCdzVS1H2RPdxNth9f3vubqxCIeyVyEiU3ha4dfZ3yCk5ykXHJSisi1l5OZWjIil5oyxlDr8vLWbk8ogarz4GoLJU8ZSbHMLExnVpGdWUXpFGfYkFHQc6c9U2fD30V78z7+tucv7G6upc5bz57OI9R3t/DN9Bl8ylbMzu4m7nCtJj/OQUHieAqS8slPK2bK+FmkpeTrkiRKKTUGtbQfod69iwNNtTgtMUyJddDSdpB/2vVLDvS04SfY2/YLKZP5l/ELaImK5QnXW+Ql55KXUkRuejk59ophMzn+aPK08WjytNtNozfUQzcuOTacONmZWZhOoSNxxCZPujbfWWprb6S2YSu1rg+oaa6h1rufBbHjuSmhgKaAjwUH/ocoLOTHpFKUkElBUi4XZc9n4vjpEJ8OWudEKaVUPwX8PRxurqHeU8X+5lomxNqZGJVMdVM1t+x+Hm+fNRcF+H7mEj4xbhaHLPDX1mpyU4vIt1eQY59AbEzioMUZSp5Cw3Ybj0ueMpPjmF1s7+19yrcnjNjk6Xg6zHcaXd3t7D6ylRrXe8T3dHFxXBZBbwMX1f6SzvBkw3iJojDWjjXdDoWLSEuw8+dJ15BtryAqKiayb0AppdSIZ42KJtsxgWzHhGPWZCsFNsy5l+b2w+xv3MG+pmr2tdQxIbkUAt18eGQrPz78em97AbKikvhx0ac5334+9RJgj99LgeM8xqeVnfHQoTGGPe4ONtaGkqe3drt7h+0yk+OYV+IIJ1CjK3k6E2OqZ8oEg7S1Hya5uxO8Dfxox7Osb9rB3u5mAuHSldNinTxbfCMkZvCH1irSk7Ipdk4my16hi3YqpZQallq8h9nv3sEe9y72tdSx11vPPY6ZZPp7eM7zHo81vwtADBbyYlPJj3fyzbKbsacW4LFasSY6SEkc17u//Z4ONtQ2srHWzVu7PRxuDc37dSbFMrs4NGw3e5T1PJ3O2OyZMoYDru28d3AjO90fsrNlNzs7DhKPlb9kLwXA52smLz6Di8fNpMw+gVLnBeRlTIJwT9PVkYxfKaWU6qcUWyYptkzOz1987AZjWOo9xMSGbexxV7G3tY467wHqOo6QeOh9OLydp5u28Ju2XSQTS2owBdORQmd7OoGmWVgSHFQW5TK7xMGsIjtFI3jO02AavT1TR7bz3XUP8aK3higslMY5qEjKoyKtnBsqbkBs43ROk1JKqTHJ1dbFW7UNbKvay9b6DTQFdiAxjQTjWuiIaSPaYmGl/UrSE2P4tucddvnbKE7Moig5n6L0ckqdF5DrmAhjqFTP2OyZSs3jpgtu59rYZIozp+mil0oppcaslo4e3qpzs7HWzYbaxt7lWZJio5hZtJgrij7N7GI7EzKTEQzeDldoKZ72RgqrvRz2fMCmlir+5N4KdTAhOo0Xs6+EhHR+3vweUbFJFKdXUOqcQrZjwpibFjN6e6aUUkqpMaqj28+mOk84eXLzwcEWjIG4aAvTC9KZXWxnTrGD87POrMK4t9PN7sPb6O5opDLWAe2NfHrHz9nV5e5tEy9RfDr9Au4vuRYSM9jsO0JBxmTsybkjuui0lkZQSimlRrEuf4Bt+5pZX+tmY20j2/Y30xMwRFuFqblpzCkJJU8X5A7O2nZHk6yaxvepbqqmzJrE1XFZtPuamVX/ewDSrXGUxo+jNCmfj+UsYmrufEhwjJi6i2NzmE8ppZQapQJBw4cHW1lf28j6mkbe2ePB1xPEInB+dgqfnVfEnGI70wvSiY8Z/CE3W7ydyYUXMbnwomOej+ls5pf1U6hyfUB1cw3V3v28dHg9ub52ph6pYZ+/nbsa36TclktFWikVGZOpyJpJWlLWoMc8kLRnSimllBrmjq5vt6GmkfU1oXpPLZ2hIp6lThtzw7WeZhXaSUkY3kvQBPw9+DtcxPpaqDnyD35a8yI7Ow5yxN/e2+Zn4y9lUeZMDkRHURXsYML4mYxLLYroMKH2TCmllFIjzJFWH+trGllX08iGGndvrafs1HgunTiuN4FyJo2sC6ysUdFYk7MgOYsS5wSemLQMgKa2g+w6uImdrvc4z1YEvmZW71nPD5q2AKFhwgkJ2UxMLeWW8mWkOMogNimSb6WX9kwppZRSw0BLZw9v7XazIZxA1bpCPTVpCdHMKXYwt8TB3BI7eeljp1Bmh6+FqoNv8+GRrexo2sH21j3s6WpiXc41JFiiebajlkNieHDGg+AoGdRYtGdKKaWUGma6/AHe3dvc2/v0Xn0zQQPx0VZmFKZz/fRc5pY4mJCZjMUyNpKn4yXEpTCl6GNMKfpY73Nd3V5iO5uh7TBml4fEzkbo9kYuSDSZUkoppYZEMGjYcbg1nDy52VTnxtcTxGoRLshJ4c7FJcwtcTAlL3VQrrgbLWJjbBBjg5Qcbs0JdxRFaJTtKE2mlFJKqUFS39TB+ppG3qxuZEOtG097NxCaNL5seh7zShzMLEonKW54Txof9iI87KnJlFJKKTVAWjp72FjrZl2Ni/U1buoaQ/OenEmxLCrLYG6Jg3mlDsYlj6xJ4+rUNJlSSimlzlK3P8i7+5pYV33svKfEGCuziuzcMjufeSUOSpy2MTNpfCzSZEoppZTqJ2MM1Q1e3qxuZF21i7frPHR0B/5v3tOSUuaXOpiSm0r0GSzToka2fiVTInIZ8DhgBZ42xvzguO15wK+B1HCbrxljXh3YUJVSSqmh19Dm6533tL6mkSOtXQAUORK55sIc5pWG6j0l67ynMeu0yZSIWIEngUuAeuAdEVlpjPmwT7OHgBeNMT8XkfOAV4GCQYhXKaWUGlS+ngCb6jysq2lkbZWLnYfbgHC9pxIH88PznnLSEiIcqRou+tMzNQOoMcbsBhCR54GlQN9kygDJ4fspwMGBDFIppZQaLMGgYefhNt6sdrGuppG36zx0+4PEWC1My0/j/svKmV+SwcSssVvvSZ1af5KpbGB/n8f1wMzj2jwM/FVEvgQkAhefaEcicjtwO0BeXt6ZxqqUUkoNiIZWH29WN4YTKDeN3tDQXfm4JG6elc+8UgczC9NJiNGpxer0Buq35AbgWWPMv4rIbOA3InK+MSbYt5Ex5ingKQgtJzNAx1ZKKaVOydcT4J09Ht6sPnbozp4Yw7xSB/NLM5ivJQvUWepPMnUAyO3zOCf8XF+fBS4DMMZsFJE4wAE0DESQSiml1JkwxlB1xMvaKhdrq11sqvPQFR66m16Yxtcur2B+6dheqkUNnP4kU+8ApSJSSCiJWgbceFybfcBFwLMiMgGIA1wDGahSSil1Km5vV3jSeGj4rqEtNHRX6rTxTzPzmV+mQ3dqcJz2N8oY4xeRO4HXCJU9eMYYs11EHgE2G2NWAl8F/ktE7iE0GX25MRFeKEcppdSodrRg5toqF29WN/LBwRaMgdSEaOaWOFhYmsH8MgfjU+IjHaoa5SRSOU9lZaXZvHlzRI6tlFJqZNrT2M7aahdrq1xsrHXTHi6YOS0vjfmlDhaUZXB+dgpWHbpTA0xEthhjKk+0Tfs6lVJKDVveLj8bahrDCVQj+zwdAOSmx/PJqdksKMtgTrFdFwpWEaXJlFJKqWEjGDR8eKiVNVUu1lS5eHdvE/6gISHGypxiO5+bX8iC0gwKHImRDlWpXppMKaWUiqhGbxdvhnue3qx20ejtBuC88cl8bn4RC8symJafRkyUrnWnhidNppRSSg2pnkCQrfuaWVPVwJoqFx8caAUgPTGG+aUOFpZlMK/UgTNJaz6pkUGTKaWUUoOuvqmDtVWNrKlqYEONm7Yuf+/E8Xs/VhaaOJ6VojWf1IikyZRSSqkB5+sJ8NZuN2uqQlfe1braAchOjecTF2SxsCyDOSV2knXiuBoFNJlSSil1zowx7G5sZ80uF6urXLy9202XP0hslIWZRXZunJnPwrIMijMSEdHeJzW6aDKllFLqrHi7/GysdbN6V2juU31TJwBFGYncODOPhWUZzCy0Ex9jjXCkSg0uTaaUUkr1izGGnYfbQmULdrnYvNdDT8CQGGNlTomDzy8sZlFZBrnpCZEOVakhpcmUUkqpk2rp7GF9TWNv79OR1tB6dxWZSdw2r5BFZU4tW6DGPE2mlFJK9TpaNHP1rgZW73KxdX8zgaAhOS6K+aUZLCzPYGFZBuOStWyBUkdpMqWUUmNcc0c3a6tDvU9rqxpp9IZ6nyZlp3DHwmIWlWcwJTeVKKv2Pil1IppMKaXUGBMMGj442MLqXS5W72pg2/5mggZSE6KZX5rBorIMFpRlkJEUG+lQlRoRNJlSSqkxoKm9m7XVoYnja8NLtojA5OwU7lxSyqLyDC7IScWqRTOVOmOaTCml1CgUDBrePxDufapq4B/h3qe0hGgWlGWwqDyDBaUZ2G3a+6TUudJkSimlRomjvU+rd4Wqjrvbw71POal8aUkpiyucTMpO0d4npQaYJlNKKTVCHZ37tGrnsb1P6YkxLCh1sKjcyfxSh/Y+KTXINJlSSqkR5Ngr7/rMfQr3Pi0qz2Cyzn1SakhpMqWUUsNY37pPq3a52LqvqffKuwWlGSyu0LlPSkVav5IpEbkMeBywAk8bY35wgjbXAQ8DBviHMebGAYxTKaXGjJbOHtaFe59WV7lwtYXqPk3OSeHOxSUsqnDqlXdKDSOnTaZExAo8CVwC1APviMhKY8yHfdqUAg8Cc40xTSLiHKyAlVJqtDm65t2qcNXxLXubequOh668c7JQ6z4pNWz1p2dqBlBjjNkNICLPA0uBD/u0+WfgSWNME4AxpmGgA1VKqdHE2+XvXfNu1U4Xh1t9AJw3PpkvLCxicblTq44rNUL0J5nKBvb3eVwPzDyuTRmAiKwnNBT4sDHmL8fvSERuB24HyMvLO5t4lVJqRDLGUOvysmqni1W7Gnhnj4eegMEWG8X8UgeLy50sLNc175QaiQZqAnoUUAosAnKAtSIyyRjT3LeRMeYp4CmAyspKM0DHVkqpYamzO8Bbu92s2tXAGzsbqG/qBKB8XBK3zStkUZmTyoI0orX3SakRrT/J1AEgt8/jnPBzfdUDbxtjeoA6EakilFy9MyBRKqXUCLHP3cGqXQ2s2tXAxlo3Xf4g8dFW5pbYuWNRMYvKnWSnxkc6TKXUAOpPMvUOUCoihYSSqGXA8VfqvQLcAPxKRByEhv12D2CcSik1LHX5A2ze08QbO0MJ1G5XOwCFjkRunJnH4nInMwrTiYu2RjhSpdRgOW0yZYzxi8idwGuE5kM9Y4zZLiKPAJuNMSvD2z4mIh8CAeA+Y4x7MANXSqlIOdziC/U+7WxgfU0j7d0BYqIszCqyc/OsfBaVOyl0JEY6TKXUEBFjIjN1qbKy0mzevDkix1ZKqTPhDwTZtr853PvkYsehVgCyUuJYVOFkSbmTOSV2EmK0DrJSo5WIbDHGVJ5om/7LV0qpE3B7u1hb7eKNnaFFg1s6e7BahGn5aXzt8goWlzspG2dDRAtnKjXWaTKllFKElm3ZfrC1d/L4tv3NGAMOWwwXTxjHkgon80odpMRHRzpUpdQwo8mUUmrMavWFlm1ZtfP/lm05umjw3ReVsqTCyflZKVh02Ral1CloMqWUGjOMMdQ0eHvrPm3e04S/z7ItRwtnOnTRYKXUGdBkSik1qvl6Amys/WjhzIrMJD43v4glFU4uzNNlW5RSZ0+TKaXUqFPf1MGqXS5W7WxgQ20jvh4tnKmUGjyaTCmlRryeQJAte5tYFS6cWXXEC0C+PYFl0/NYXOFkphbOVEoNEk2mlFIjUqO3i9Xh3qe11S7afH6ircKMwnSuq8xlcYWTIkeili5QSg06TaaUUiNCMGj44GBLqHDmzgbeO9CCMeBMiuXy8zNZUuFkbomDpDgtXaCUGlqaTCmlhq2jpQve2NnA6l0uGr2h0gVTclO55+IyllQ4OW98spYuUEpFlCZTSqlhwxhDrcsb7n1y8c4ezzGlC5ZUOFlYloFdSxcopYYRTaaUUhHl6wnw1m43q3Y28MauBvZ7QqULysdp6QKl1MigyZRSasgdbO4MLduys4H1NW46ewLERVuYW+zg8wuKWVyhpQuUUiOHJlNKqUHnDwTZur+5d/L4zsNtAOSmx3NdZQ6LK5zMKrJr6QKl1IikyZRSalB42rtZU9XAGztdrK1y0dLZQ5RFmF6QztevqGBJhZPiDJuWLlBKjXiaTCmlBoQxhu0HW3sLZ27d34wx4LDFcMl541hS4WReqYNkLV2glBplNJlSSp219i4/62oaexOoI61dAFyQk8JdS0pZUuFkUnaKli5QSo1qmkwppc5IXWN779ynTXUeugNBkmKjmF/mYHG5k0XlTjKStHSBUmrs0GRKKXVKXf4Am+o8vYUz6xrbAShx2lg+t4DF5U4qC9KI1tIFSqkxql/JlIhcBjwOWIGnjTE/OEm7a4CXgOnGmM0DFqVSakgdbvH1KV3QSHt3gJgoC3OK7dwaTqBy0xMiHaZSSg0Lp02mRMQKPAlcAtQD74jISmPMh8e1SwLuBt4ejECVUoMnEDRs298cKpy5s4EPD7UCkJUSxyenZrOkwsmcYgfxMVq6QCmljtefnqkZQI0xZjeAiDwPLAU+PK7dd4EfAvcNaIRKqUHR3NHNmioXq3Y2sKbKRVNHD1aLMC0vjQcuq2BxRQbl45K0dIFSSp1Gf5KpbGB/n8f1wMy+DUTkQiDXGPO/InLSZEpEbgduB8jLyzvzaJVSZ80Yw87Dbb2Tx9/d10TQQHpiTGjieIWThaUZpCRo6QKllDoT5zwBXUQswE+A5adra4x5CngKoLKy0pzrsZVSp9be5WdDrTs8ebyBQy0+AM7PTuZfFpewuMLJBTmpWLV0gVJKnbX+JFMHgNw+j3PCzx2VBJwPrA4PB2QCK0XkKp2ErtTQ23O0dMGuBt7eHSpdYIuNYl6Jg3sudrKwPINxyXGRDlMppUaN/iRT7wClIlJIKIlaBtx4dKMxpgVwHH0sIquBezWRUmpodPkDvFPX1Nv7tDtcuqA4I5FbZuezpMJJZUE6MVFaukAppQbDaZMpY4xfRO4EXiNUGuEZY8x2EXkE2GyMWTnYQSqljnWy0gWzi+zhBGoceXYtXaCUUkOhX3OmjDGvAq8e99y3TtJ20bmHpZTqyx8Ism1/c3j4zsWOE5QumF1sJyFG6/AqpdRQ07+8Sg1TnvZu1lQ1sGqnizVVLlo6w6UL8tP42uUVLC53UjbOpqULlFIqwjSZUmqYMMaw/WBrqHDmrga27W/GGHDYYrhogpMlFU7ml2aQEq+lC5RSajjRZEqpCGr19bC+upFVu0Lr3jW0dSECk3NSufuiUhaXO5mUnYJFSxcopdSwpcmUUkPIGEN1g5dV4dIFm/c04Q8akuOiWFCWweLyUOkChy020qEqpZTqJ02mlBpkHd1+Nta6w1ffuTjQ3AlARWYSn5tfxJIKJxfmpRJl1dIFSik1EmkypdQg2Otu773y7q3dbrr9QRJirMwtcYQrj2cwPiU+0mEqpSKgp6eH+vp6fD5fpENRJxAXF0dOTg7R0f2fn6rJlFIDwNcTYFOdh1W7Glizy9VbOLMoI5GbZ+WzuNzJ9MI0YqOsEY5UKRVp9fX1JCUlUVBQoFfjDjPGGNxuN/X19RQWFvb7dZpMKXWW6ps6WLXLxZpdDayvcdPZEyA2ysLs4lDhzMUVTvLtiZEOUyk1zPh8Pk2khikRwW6343K5zuh1mkwp1U/d/iCb93pYvcvFqp0NVDd4AchJi+fayhwWlzuZVWQnPkZ7n5RSp6aJ1PB1NudGkymlTuFwi4/Vu0JX3q2rDi3bEm0VZhbauX56LosrnBQ5EvUPo1JqVLHZbHi9oS+M9913H6+++ipXXHEFjz32WIQjG540mVKqj55AkHf3NrG6ysXq45ZtWTo1m0VlGcwtcZAYq/90lFJjw1NPPYXH48Fq1V73k9FPBDXmNbT6wslTA29WN9Lm8xOly7YopUax5557jh//+MeICJMnT+aRRx7hxhtvxOv1snTp0t52V111FV6vl2nTpvHggw9y/fXXRzDq4UuTKTXm+ANBtu5vDg3f7XTxYbj3aVxyLFecP57FFRnMKXGQHKfLtiilBtd3/rSdDw+2Dug+z8tK5ttXTjzp9u3bt/Poo4+yYcMGHA4HHo+H5cuXc8cdd3DLLbfw5JNP9rZduXIlNpuNbdu2DWiMo40mU2pMaGjzsWaXi9VVLt6sctHq8/cuGnz/ZeUsKnMyYXyS9j4ppUa9N954g2uvvRaHwwFAeno669ev5+WXXwbg5ptv5oEHHohkiCOOJlNqVPIHgmzb3xy68m5XA9vD3/ycSbFcdn4mi8qdzC1x6KLBSqmIOlUP0lDTL5NnT5MpNWo0tPpYU3WC3qe8NO67tJxF5RmcNz5Z/2Aopca0JUuWcPXVV/OVr3wFu92Ox+Nh7ty5PP/889x000389re/jXSII44mU2rE8geCvLuvmTVVDaze5Tqm9+nSiaHep3ml2vuklFJ9TZw4kW984xssXLgQq9XK1KlTefzxx7nxxhv54Q9/eMwEdNU/YoyJyIErKyvN5s2bI3JsNXIdbvH1Jk/rakJX3h3tfVpYnqG9T0qpYW/Hjh1MmDAh0mGoUzjRORKRLcaYyhO1154pNawdrTq+psrFml0udh5uAyAzOY4rzh/PovIM5pbqlXdKKaUip1/JlIhcBjwOWIGnjTE/OG77V4DPAX7ABdxmjNk7wLGqMaK+qaM3eVpfE6o6HmURKgtCdZ8WlmVQkalX3imllBoeTptMiYgVeBK4BKgH3hGRlcaYD/s02wpUGmM6ROQO4EeAVvZS/eLrCfDOntCad2uqXNSE17zLTo3nqinZod6nEgc2rTqulFJqGOrPp9MMoMYYsxtARJ4HlgK9yZQxZlWf9m8BNw1kkGp0Mcawx93Bml0NrKlysXG3G19PkJgoCzML01k2PZdF5U6KM3TNO6WUUsNff5KpbGB/n8f1wMxTtP8s8P9OtEFEbgduB8jLy+tniGo08Hb52VjrZm1VqPdpn6cDgEJHIsum57GwPINZhXbiY3TtJ6WUUiPLgI6biMhNQCWw8ETbjTFPAU9B6Gq+gTy2Gl6MMew41Mba6tDcp817PfQEDAkxVuYU2/nc/EIWlmWQb0+MdKhKKaXUOelPMnUAyO3zOCf83DFE5GLgG8BCY0zXwISnRpKm9m7erGlkbZWLtVUuGtpCvwYVmUncNjeUPE0rSCM2SnuflFJqrNu2bRsHDx7kiiuuOKPXLVq0iB//+MdUVp6wSsFp2Ww2vN7Q3Nz77ruPV199lSuuuILHHnvsrPYH/Uum3gFKRaSQUBK1DLixbwMRmQr8ArjMGNNw1tGoEcUfCPKP+mbWVDWypsrFe/XNGAMp8dHML3WwoCyDBaUZZKbERTpUpZRSw8y2bdvYvHnzGSdTA+mpp57C4/FgtZ7bl3zL6RoYY/zAncBrwA7gRWPMdhF5RESuCjd7DLABvxeRbSKy8pyiUsPWweZOnt+0jy/+dgsXfvdvXPPzjTzxRjUWgbuWlPI/X5zDu9+8hCduvJDrKnM1kVJKqWHoueeeY/LkyVxwwQXcfPPNAOzZs4clS5YwefJkLrroIvbt2wfA8uXLueOOO5g1axZFRUWsXr2a2267jQkTJrB8+fLefdpsNu655x4mTpzIRRddhMvlAkI9SUeLdDc2NlJQUEB3dzff+ta3eOGFF5gyZQovvPAC7e3t3HbbbcyYMYOpU6fyxz/+EYDOzk6WLVvGhAkTuPrqq+ns7DzheyooKOD+++9n0qRJzJgxg5qaGgDq6uqYPXs2kyZN4qGHHuptf9VVV+H1epk2bRovvPDCOf08+zVnyhjzKvDqcc99q8/9i88pCjVs+XoCvLXbzdqqRtZW/1/ZgszkOC47P5OFZU7mlthJTYiJcKRKKTUCVf8dvEcGdp+2cVB68o/l7du38+ijj7JhwwYcDgcejweAL33pS3zmM5/hM5/5DM888wx33XUXr7zyCgBNTU1s3LiRlStXctVVV7F+/Xqefvpppk+fzrZt25gyZQrt7e1UVlbyb//2bzzyyCN85zvf4YknnjhhDDExMTzyyCNs3ry5t83Xv/51lixZwjPPPENzczMzZszg4osv5he/+AUJCQns2LGD9957jwsvvPCk7y0lJYX333+f5557ji9/+cv8+c9/5u677+aOO+7glltu4cknn+xtu3LlSmw2G9u2bTvDH/BHaeEedQxjDFVHvKF5T9Uu3q7z0O0/tmzBgrIMSp02LVuglFIj0BtvvMG1116Lw+EAID09HYCNGzfyP//zPwDcfPPN3H///b2vufLKKxERJk2axLhx45g0aRIQWudvz549TJkyBYvFwvXXh0pM3nTTTXzqU586o7j++te/snLlSn784x8D4PP52LdvH2vXruWuu+4CYPLkyUyePPmk+7jhhht6/3/PPfcAsH79el5++eXe9/XAAw+cUVz9ocmUwtPezbrwxPE3q10caQ1NHC912rh5Vj7zSx3M1LIFSik18E7RgzScxMbGAmCxWHrvH33s9/tP+JqjX7ijoqIIBoNAKEE6GWMML7/8MuXl5WcdZ98v+Se7PxhOO2dKjT49gSCb6jz8+LVdXPXEOqY9+jfuWrGVv314hMr8dH54zSQ2fG0Jf/vKQr75ifNYVO7UREoppUaJJUuW8Pvf/x632w3QO8w3Z84cnn/+eQB++9vfMn/+/DPabzAY5KWXXgLgd7/7HfPmzQNCc5m2bNkC0LsdICkpiba2tt7Hl156KT/72c8wJlQ5aevWrQAsWLCA3/3udwB88MEHvPfeeyeN4ejcpxdeeIHZs2cDMHfu3GPe12DQnqkxwBjDXncHa6tdrK1q5K3dbrxdfqwWYWpuKvdcXMb8UgeTc1KxWnToTimlRrOJEyfyjW98g4ULF2K1Wpk6dSrPPvssP/vZz7j11lt57LHHyMjI4Fe/+tUZ7TcxMZFNmzbx6KOP4nQ6exObe++9l+uuu46nnnqKj3/8473tFy9ezA9+8AOmTJnCgw8+yDe/+U2+/OUvM3nyZILBIIWFhfz5z3/mjjvu4NZbb2XChAlMmDCBadOmnTSGpqYmJk+eTGxsLCtWrADg8ccf58Ybb+SHP/whS5cuPYuf2OnJ0QxwqFVWVpqjs/vVwGvp7GFjbSNrqxt5s9rFfk/o6ofc9HgWlGYwvzSD2cV2UuKjIxypUkqNLTt27GDChAmRDmPA9a3fFAkFBQVs3ry5dy7YuTjRORKRLcaYExa30p6pUaInEOQf+5tZW93IumoX2/Y3EzRgi41idrGdf55fxILSDAocWnFcKaWUGkiaTI1QRxcLXlftYm11I2/Vumnr8mMRmJyTyp1LSplf6mBKbirRVp0ap5RSanBFslcKQnWyIkWTqRGkqb2bDbVu3qx28WZ1IweaQ0N3OWnxXDkli/klDuYUO0hJ0KE7pZRSaqhoMjWMdfkDbNnbxLrqRtbVNPL+gRaMgaTw0N0XFhYxvzSDfHuC1nxSSimlIkSTqWHEGMOuI22sq27kzepGNtV56OwJ9F51d/dFpcwvzeCCnBSidOhOKaWUGhY0mYqwwy0+1tWEJo2vq3HT6A0VzCzKSOS6yhzmlWYwqyidpDgdulNKKaWGI02mhlibr4e3dntYXxMauju61p09MYa5JQ7mlTqYW+IgOzU+wpEqpZQazV555RWuvvpqduzYQUVFBRCaxD1hwgQqKirw+XwkJSXxxS9+8ZgFjc/Uww8/jM1m495772Xnzp0sW7YMEeGll16iuLh4gN5NZGkyNci6/UG27W9mXU0j62sa2ba/mUDQEBdtYWahPdT7VJJBRWYSFi2YqZRSaoisWLGCefPmsWLFCr7zne/0Pl9cXNxbfXz37t186lOfwhjDrbfees7HfOWVV/j0pz/NQw89dM77Gk40mRpgwaBh5+E2NtSGep421Xno6A5gEZiUk8odC4uZW+LgwvxUYqN0iRallFJDz+v1sm7dOlatWsWVV155TDLVV1FRET/5yU/46le/+pFk6tlnn+UPf/gDLS0tHDhwgJtuuolvf/vbAHzve9/j17/+NU6nk9zcXKZNm8arr77KT3/6U6xWK6+//jqrVq0a9Pc5VDSZGgD7PR29w3Yba92427sBKM5I5NPTcphb4mBWkVYbV0op9VG3/uWjPT6XFlzKsopldPo7+eLfv/iR7UtLlvLJkk/S5GviK6u/csy2X112+mVg/vjHP3LZZZdRVlaG3W5ny5YtJ12m5cILL2Tnzp0n3LZp0yY++OADEhISmD59Oh//+McREZ5//nm2bduG3+/nwgsvZNq0aVxxxRV84Qtf6B3yG000mToLjd4uNtS62VjbyPoaN/s8HQA4k2JZWJbBnBIHc0vsjE/ReU9KKaWGnxUrVnD33XcDsGzZMlasWHHSZOpUy85dcskl2O12AD71qU+xbt06AK6++moSEhIAuOqqqwYy9GFJk6l+aPP1sKnOw/oaNxtqG9l5OLTKdVJcFLOK7Nw2t4B5pQ6KM2xa70kppdQZOVVPUnxU/Cm3p8Wl9asnqi+Px8Mbb7zB+++/j4gQCAQQER577LETtt+6detJ1xI8/jNPRE6ZfI1WmkydgK8nwLt7m9hQ62Z9bSPv1bcQCBpioixU5qdx36XlzC1xcH5WstZ7UkopNaK89NJL3HzzzfziF7/ofW7hwoW8+eab5OXlHdN2z5493HvvvXzpS1864b7+9re/4fF4iI+P55VXXuGZZ57BYrGwfPlyHnzwQfx+P3/605/4/Oc/P6jvKdI0mSK0SPB79S1srG1kQ62bzXub6PYHsVqEyTkp3LGwmDnFdi7MTyMuWieNK6WUGrlWrFjBAw88cMxz11xzTe/ztbW1TJ06tbc0wl133XXS0ggzZszgmmuuob6+nptuuonKykoArr/+ei644AKcTifTp08f7LcUcdKf7jgRuQx4HLACTxtjfnDc9ljgOWAa4AauN8bsOdU+KysrzebNm88y7HMTDBo+PNTKxtrQsN2mOg/t3QEAJoxPZk6xnTnFdmYUarFMpZRSA2vHjh0nHTYbSZ599lk2b97ME088EelQBtyJzpGIbDHGVJ6o/Wl7pkTECjwJXALUA++IyEpjzId9mn0WaDLGlIjIMuCHwPVn+R4GnDGGqiNeNtY2snG3m7d2e2jp7AFClcY/OTW794q79MSYCEerlFJKqZGkP8N8M4AaY8xuABF5HlgK9E2mlgIPh++/BDwhImIiOAvtSKuPv314hI21bt7a/X/lCnLS4rl04jjmFDuYXWxnXHJcpEJUSimlRqzly5efU2X00aQ/yVQ2sL/P43pg5snaGGP8ItIC2IHGvo1E5HbgduAjk9wG2j/2N/PQKx+QmRzHgrIMZhfZmV1sJzc9YVCPq5RSSqmxZUgnoBtjngKegtCcqcE81rxSB6vuXUSBPUHLFSillBpWjDH62TRMnc2gWn+u6z8A5PZ5nBN+7oRtRCQKSCE0ET1iEmKiKHQk6i+rUkqpYSUuLg632z0m6zENd8YY3G43cXFnNgWoPz1T7wClIlJIKGlaBtx4XJuVwGeAjcCngTciOV9KKaWUGq5ycnKor6/H5XJFOhR1AnFxceTk5JzRa06bTIXnQN0JvEaoNMIzxpjtIvIIsNkYsxL4JfAbEakBPIQSLqWUUkodJzo6msLCwkiHoQZQv+ZMGWNeBV497rlv9bnvA64d2NCUUkoppYY/XQtFKaWUUuocaDKllFJKKXUO+rWczKAcWMQF7B3kwzg4rtaVGhb0vAw/ek6GJz0vw4+ek+FpKM5LvjEm40QbIpZMDQUR2XyydXRU5Oh5GX70nAxPel6GHz0nw1Okz4sO8ymllFJKnQNNppRSSimlzsFoT6aeinQA6oT0vAw/ek6GJz0vw4+ek+EpoudlVM+ZUkoppZQabKO9Z0oppZRSalCNimRKRC4TkV0iUiMiXzvB9lgReSG8/W0RKYhAmGNOP87LV0TkQxF5T0ReF5H8SMQ5lpzunPRpd42IGBHRq5YGWX/OiYhcF/63sl1EfjfUMY5F/fj7lSciq0Rka/hv2BWRiHMsEZFnRKRBRD44yXYRkX8Pn7P3ROTCoYptxCdTImIFngQuB84DbhCR845r9lmgyRhTAvwb8MOhjXLs6ed52QpUGmMmAy8BPxraKMeWfp4TRCQJuBt4e2gjHHv6c05EpBR4EJhrjJkIfHmo4xxr+vlv5SHgRWPMVELr0f7H0EY5Jj0LXHaK7ZcDpeHb7cDPhyAmYBQkU8AMoMYYs9sY0w08Dyw9rs1S4Nfh+y8BF4mIDGGMY9Fpz4sxZpUxpiP88C3gzJbpVmeqP/9WAL5L6AuHbyiDG6P6c07+GXjSGNMEYIxpGOIYx6L+nBcDJIfvpwAHhzC+MckYsxbwnKLJUuA5E/IWkCoi44cittGQTGUD+/s8rg8/d8I2xhg/0ALYhyS6sas/56WvzwL/b1AjUqc9J+Fu8VxjzP8OZWBjWH/+nZQBZSKyXkTeEpFTfTNXA6M/5+Vh4CYRqQdeBb40NKGpUzjTz50BEzUUB1HqVETkJqASWBjpWMYyEbEAPwGWRzgUdawoQsMWiwj13q4VkUnGmOZIBqW4AXjWGPOvIjIb+I2InG+MCUY6MDX0RkPP1AEgt8/jnPBzJ2wjIlGEumTdQxLd2NWf84KIXAx8A7jKGNM1RLGNVac7J0nA+cBqEdkDzAJW6iT0QdWffyf1wEpjTI8xpg6oIpRcqcHTn/PyWeBFAGPMRiCO0PpwKnL69bkzGEZDMvUOUCoihSISQ2gi4Mrj2qwEPhO+/2ngDaMFtgbbac+LiEwFfkEokdJ5IIPvlOfEGNNijHEYYwqMMQWE5rFdZYzZHJlwx4T+/P16hVCvFCLiIDTst3sIYxyL+nNe9gEXAYjIBELJlGtIo1THWwncEr6qbxbQYow5NBQHHvHDfMYYv4jcCbwGWIFnjDHbReQRYLMxZiXwS0JdsDWEJq8ti1zEY0M/z8tjgA34ffh6gH3GmKsiFvQo189zooZQP8/Ja8DHRORDIADcZ4zRnvVB1M/z8lXgv0TkHkKT0Zfrl/TBJSIrCH2xcITnqn0biAYwxvwnoblrVwA1QAdw65DFpudeKaWUUursjYZhPqWUUkqpiNFkSimllFLqHGgypZRSSil1DjSZUkoppZQ6B5pMKaWUUkqdA02mlFJKKaXOgSZTSimllFLnQJMppZRSSqlz8P8D25sqLBN0wEoAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -433,12 +433,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 52, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkkAAADSCAYAAABevlSdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAxIUlEQVR4nO3deXhU5d3/8fd3ZrInhCUB2cMmIoY1UhHcsHXBCirWraJo1UpbtfXRLtpa9aeP9mmrUkttbV3qBrgVsbVWW6AK4hIEFzbZIptANgiB7HP//phJzDKQQZKcLJ/Xdc2VmXOf5TM5CXxz3/c5Y845RERERKQun9cBRERERFojFUkiIiIiEahIEhEREYlARZKIiIhIBCqSRERERCJQkSQiIiISgYokkXbMzHLM7OtRrnu+mW01s2IzGx3F+nea2TNHnvLImFmGmTkzC3idRUTaFxVJIlLtN8APnHPJQKEKj6ZjZqeaWTBcgFY/rvQ6l4gcmv4BFJFq/YFVXodoSWYWcM5VttDhdjjn+rTQsUSkCagnSaSDMDOfmf3UzDaaWb6ZPW9mXc0szsyKAT/wkZltBN4Kb7Yn3Osx/iC7jTezeWa2z8w+NLORtY43zMwWm9keM1tlZlNqtS02s2tqvZ5hZktqvXZmdr2ZrQ9vP9vMLNzmN7PfmFmemW0Czqn3Pq8yszXhTJvM7Lu12k41s21m9hMz2wk8YWafmtm5tdaJCe+70SFHEWnfVCSJdBw3AOcBpwC9gEJgtnOuLDzEBjDSOTcIODn8urNzLtk5t+wg+5wKvAB0BZ4D5oeLjBjgVeANoHv42M+a2dDDyPtN4HhgBHARcGZ4+bXhttFAFnBhve12h9s7AVcBD5rZmFrtR4Xz9geuA54CLq/VPhn4wjm3on4gM+sXLtoO9rjsEO+nu5ntMrPNZvagmSVF9V0QEc+oSBLpOK4HbnfObXPOlQF3Ahce4byj5c65F51zFcADQDxwQviRDNzvnCt3zi0E/g5cehj7vt85t8c5twVYBIwKL78IeMg5t9U5VwDcV3sj59w/nHMbXch/CRVqJ9VaJQj8MlwclgDPAJPNrFO4fTrwdKRAzrktzrnOh3g8d5D3sjacvycwCRhL6PslIq2YiiSRjqM/8LfqXg9gDVAF9DiCfW6tfuKcCwLbCPVS9QK2hpdV+xzofRj73lnr+QFCRRfV+6633xpmdraZvWtmBeH3ORlIq7VKrnOutFbuHcBSYJqZdQbOBp49jJyNcs7tdM6tds4FnXObgR8D05ryGCLS9DRxW6Tj2Apc7ZxbGsW6Lsp99q1+YmY+oA+wo7rNzHy1CqV+wGfh5/uBxFr7OSrK4wF8Ufu44f1WZ4gDXgKuAF5xzlWY2XzAaq0f6b39FbiG0L+Jy5xz2yMd2Mz6AasPke27zrloCiyH/kgVafX0SyrScfwRuNfM+gOYWbqZTT3IurmEhqUGNrLPsWZ2QXjI7odAGfAu8B6h3p8fh+conQqcC8wNb7cSuMDMEs1sMPCdw3gfzwM3mlkfM+sC/LRWWywQF85faWZnA2dEsc/5wBjgJkJzlCIKD7clH+IRsUAys9PMrL+F9AXuB16J5s2KiHdUJIl0HLOABcAbZraPUDHztUgrOucOAPcCS8PDcyccZJ+vABcTmgQ+HbjAOVfhnCsnVBSdDeQBfwCucM6tDW/3IFAO7CLUi3M4w1t/Bv4FfAR8CLxcK/c+4EZChVQhcFn4PR9SeG7SS8CA2vtrQqOBdwj1oL0DfBLOKSKtmDkXba+6iEj7ZWZ3AEc75y5vdGUR6RA0J0lEOjwz60poyG+611lEpPXQcJuIdGhmdi2hSe3/dM691dj6ItJxaLhNREREJAL1JImIiIhEoCJJREREJIJmmbidlpbmMjIymmPXIiIiIk1q+fLlec659PrLm6VIysjIIDs7uzl2LSIiItKkzOzzSMs13CYiIiISgYokERERkQhUJImIiIhEoDtui4iINIGKigq2bdtGaWmp11HkIOLj4+nTpw8xMTFRrd8mi6TgpsXM2jSfjM4DGdD1GAb0GElqUg+vY4mISAe2bds2UlJSyMjIwMy8jiP1OOfIz89n27ZtDBgwIKpt2mSRlFewgae3L6Ji+39qlnXzJ3Btr1P49ujvQ+f+oB9QERFpQaWlpSqQWjEzo1u3buTm5ka9TZsskrpnXcMHo65kR8FaNuV+yubC9Wws2sSoYCysnMOmGD8rYmM5Z+R3iI9L8TquiIh0ECqQWrfDPT9tskgC8Adi6Ns9k77dMzmlemFVBexezT8//B1/zHufh9Y9w2V9v841E+4kJibey7giIiKtQnJyMsXFxQDceuutvPbaa0yePJlf//rXHidrfdpskRSRPwZ6juR7Z/+ZcRv/wdOr/sofPv8Hi3Z9wP0n/x8De471OqGIiEir8eijj1JQUIDf7/c6SqvULm8BYD4fxw85l9+d9yKzxv6EneVFPP/u/bB9OTjndTwREZFm89RTTzFixAhGjhzJ9OnT2bx5M+PHjyczM5Of//znNetNmTKF4uJixo4dy7x58zxM3Hq1r56kCCYddzmZfSaQvHkpfPYGG7a9S5dhU+jWqa/X0UREpJ2669VVrN5R1KT7PLZXJ3557vBDrrNq1Sruuece3nnnHdLS0igoKGDGjBnMnDmTK664gtmzZ9esu2DBApKTk1m5cmWT5mxP2mVPUn3pnQeQMOrbBAefzo83zuXCBdNYv/19r2OJiIg0qYULF/Ktb32LtLQ0ALp27crSpUu59NJLAZg+fbqX8dqcdt+TVMMMX99x3H/Kr5m56Ca+s/D7/PnUWQzte6LXyUREpJ1prMenpemqu6+mQ/Qk1XZ07xN44ow/E+vz853FN7J6y9teRxIREWkSkyZN4oUXXiA/Px+AgoICJkyYwNy5cwF49tlnvYzX5nS4IgmgX/cRPHHGYyT6Ypj93v9C0Q6vI4mIiByx4cOHc/vtt3PKKacwcuRIbr75ZmbNmsXs2bPJzMxk+/btXkdsU8w1w9VeWVlZLjs7u8n329S+yFtHyrrXSQ5WwohLILW315FERKSNWrNmDcOGDfM6hjQi0nkys+XOuaz660bVk2RmOWb2iZmtNLPWX/1EqWfaUJLHzuCAP5Yb3riWz7a/63UkERERaSUOZ7jtNOfcqEiVVpsWn0rxsMmsKsvnpv/+D3uLd3qdSERERFqBDjknqb7uXQbxwIR72FlRzE/e+C5VlRVeRxIRERGPRVskOeANM1tuZtdFWsHMrjOzbDPLPpxP2G0tRg34BrcPu5Kl+zbx+7d+4nUcERER8Vi0RdJE59wY4Gzg+2Z2cv0VnHOPOueynHNZ6enpTRqypVw47mYu7P41FuxYQtH25V7HEREREQ9FVSQ557aHv+4G/gaMa85QXvrZ6b9j3pCr6LRxERS3vR4xERERaRqNFklmlmRmKdXPgTOAT5s7mFdiYxNJG3U5lb4Af/nvbRTtV6EkIiISrZUrV/Laa68d9nannnoqR3L7oOTk5Jrnt956K8OHD+fWW2/9yvuD6D6WpAfwt/AtzQPAc86514/oqK1dXAob+43h94seJ2fxrdxzzpNeJxIREWkTVq5cSXZ2NpMnT/Ysw6OPPkpBQQF+v/+I9tNoT5JzbpNzbmT4Mdw5d+8RHbGNGNrvZK7uewav5C3n7TXPex1HRESkUU899RQjRoxg5MiRNR9mm5OTw6RJkxgxYgSnn346W7ZsAWDGjBnMnDmTE044gYEDB7J48WKuvvpqhg0bxowZM2r2mZyczI9+9COGDx/O6aefTvXFWbV7fvLy8sjIyKC8vJw77riDefPmMWrUKObNm8f+/fu5+uqrGTduHKNHj+aVV14BoKSkhEsuuYRhw4Zx/vnnU1JSEvE9ZWRk8OMf/5jMzEzGjRvHhg0bANi8eTPjx48nMzOTn//85zXrT5kyheLiYsaOHcu8efOO6PvZcT7g9iu4fuLdLHr5A+768AH+1m8SKUlpXkcSEZG2YP2/oXhX0+4zuQcM+fpBm1etWsU999zDO++8Q1paGgUFBQDccMMNXHnllVx55ZU8/vjj3HjjjcyfPx+AwsJCli1bxoIFC5gyZQpLly7lL3/5C8cffzwrV65k1KhR7N+/n6ysLB588EHuvvtu7rrrLn7/+99HzBAbG8vdd99NdnZ2zTq33XYbkyZN4vHHH2fPnj2MGzeOr3/96/zpT38iMTGRNWvW8PHHHzNmzJiDvrfU1FQ++eQTnnrqKX74wx/y97//nZtuuomZM2dyxRVXMHv27Jp1FyxYQHJyMitXrjzMb3BDuk/SIcTGJvL/xt9JbuUBHnjrp17HEREROaiFCxfyrW99i7S00B/0Xbt2BWDZsmVcdtllAEyfPp0lS5bUbHPuuediZmRmZtKjRw8yMzPx+XwMHz6cnJwcAHw+HxdffDEAl19+eZ3to/HGG29w//33M2rUKE499VRKS0vZsmULb731FpdffjkAI0aMYMSIEQfdx6WXXlrzddmyZQAsXbq0Znl1r1lTU09SI47rfxo/HTiNkQeKoWAzdB3gdSQREWntDtHj05rExcUBoUKo+nn168rKyojbhOcoEwgECAaDAJSWlh70GM45XnrpJYYOHfqVc1Yf81DPm4N6kqJw6Ym3c2znIbDunwQrIo+ZioiIeGnSpEm88MIL5OfnA9QMt5144onMnTsXgGeffZaTTjrpsPYbDAZ58cUXAXjuueeYOHEiEJortHx56J6C1e0AKSkp7Nu3r+b1mWeeycMPP4xzDoAVK1YAcPLJJ/Pcc88B8Omnn/Lxxx8fNEP13KJ58+Yxfvx4ACZMmFDnfTUHFUnR8AdwQ8/mzh1v8r//+aHXaURERBoYPnw4t99+O6eccgojR47k5ptvBuDhhx/miSeeYMSIETz99NPMmjXrsPablJTE+++/z3HHHcfChQu54447ALjlllt45JFHGD16NHl5eTXrn3baaaxevbpm4vYvfvELKioqGDFiBMOHD+cXv/gFADNnzqS4uJhhw4Zxxx13MHbs2INmKCwsZMSIEcyaNYsHH3wQgFmzZjF79mwyMzPZvn37Yb2naFl1ZdeUsrKy3JHc66C1+tUb3+eZL97iiQm/Imuwd5c2iohI67NmzRqGDRvmdYwml5ycTHFxsWfHz8jIIDs7u2au1ZGKdJ7MbLlzLqv+uupJOgw3nnIfvQIp3J/9a30IroiISDunIukwJMR14ubjrmFdWR7zP5zd+AYiIiJtnJe9SBC6z1NT9SIdLhVJh+mMzBmMSezDn9c/T1X5Aa/jiIiISDNRkXSYzOfjrhPv5q/dT8e/9T2v44iIiEgzUZH0FWT0Pp4efcbhtr7PgX07vI4jIiIizUBF0lfkMk7m+7sX8fOFP/I6ioiIiDQDFUlfkSWkMqLHGN7cs5rsDa95HUdERASA+fPnY2asXbu2ZllOTg4JCQmMHj2aYcOGMW7cOJ588skjOs6dd97Jb37zGwDWrl3LqFGjGD16NBs3bjyi/bYmKpKOwJUn/JQegST+b/lvdUsAERFpFebMmcPEiROZM2dOneWDBg1ixYoVrFmzhrlz5/LQQw/xxBNPNMkx58+fz4UXXsiKFSsYNGhQk+yzNVCRdAQS4jrxo2OvYk3pbhasfMTrOCIi0sEVFxezZMkSHnvssZqP7Ihk4MCBPPDAA/zud79r0Pbkk08ydepUTj31VIYMGcJdd91V03bvvfdy9NFHM3HiRNatWwfAa6+9xkMPPcQjjzzCaaed1vRvykP6gNsjNHnktTyz/kVe3LiA88d8H3x+ryOJiEgrcNXrVzVYdmbGmVxyzCWUVJbwvX9/r0H71MFTOW/weRSWFnLz4pvrtD1xVuO9Pq+88gpnnXUWRx99NN26dWP58uUH/biPMWPG1BmSq+3999/n008/JTExkeOPP55zzjkHM2Pu3LmsXLmSyspKxowZw9ixY5k8eTLXX389ycnJ3HLLLY1mbEtUJB0h8/n4vxN+Sdr6RfDFR9B7jNeRRESkg5ozZw433XQTAJdccglz5sw5aJF0qI8l+8Y3vkG3bt0AuOCCC1iyZAkA559/PomJiQBMmTKlKaO3SlEXSWbmB7KB7c65bzZfpLanb98JkLeJipy3ofswYmISvI4kIiIeO1TPT0Ig4ZDtXeK7RNVzVFtBQQELFy7kk08+wcyoqqrCzPj1r38dcf0VK1Yc9LPmzKzB6+b4rNfW7nDmJN0ErGmuIG2aGfk9M5mSM5eXlj/sdRoREemAXnzxRaZPn87nn39OTk4OW7duZcCAAbz99tsN1s3JyeGWW27hhhtuiLivN998k4KCAkpKSpg/fz4TJkzg5JNPZv78+ZSUlLBv3z5effXV5n5LnouqSDKzPsA5wF+aN07b1bXHSLrHdebPG16irNzbz7kREZGOZ86cOZx//vl1lk2bNq3mKreNGzfW3ALgoosu4sYbb+SqqxrOmwIYN24c06ZNY8SIEUybNo2srCzGjBnDxRdfzMiRIzn77LM5/vjjm/09ec2i6T4zsxeB+4AU4JbGhtuysrJcdnZ20yRsQz5Y/ypXv3MbPx1yKd8+8Tav44iISAtas2bNQYev2pInn3yS7Oxsfv/733sdpVlEOk9mttw5l1V/3UZ7kszsm8Bu59zyRta7zsyyzSw7Nzf3cDO3C8cPOZdxyf35y6b5lJQVeR1HREREjkA0w20TgClmlgPMBSaZ2TP1V3LOPeqcy3LOZaWnpzdxzLbje6O+R15VCa+t+JPXUURERA7bjBkz2m0v0uFqtEhyzv3MOdfHOZcBXAIsdM5d3uzJ2qixgybz2KBvc35lDFSWex1HREREviLdcbsZjMu8HF9FCcFtH3gdRUREWlBHvEy+LTnc83NYRZJzbrHukRSF1D78ww5w/js/pbRsn9dpRESkBcTHx5Ofn69CqZVyzpGfn098fHzU2+iO282ke+9xbPp8Pq+s/CMXf+1Wr+OIiEgz69OnD9u2baOjXrzUFsTHx9OnT5+o11eR1EyyBp3DiBUP8+TG+UwbexOBQKzXkUREpBnFxMQwYMAAr2NIE9KcpGZiPh9XD7ucbRVFvPnpX72OIyIiIodJRVIzOm34t8mI7czj6+bggkGv44iIiMhh0HBbM/L5/NyeeT3x25ZjhZuh2yCvI4mIiEiUVCQ1sxOGXQxFhbD1PRVJIiIibYiG25qbP0BB92O4c8PzfJKz0Os0IiIiEiUVSS0grvcY3ijZyuMf/dHrKCIiIhIlFUktICmhK5f0Po3/7FnD5p0rvI4jIiIiUVCR1EK+nXUTsebnyQ8f9jqKiIiIREFFUgvp1qkv53Ufx6u5y8nbu8XrOCIiItIIFUkt6PLR3+f85IG4Lz7yOoqIiIg0QrcAaEEZPUbyiyGXQf4mqKoEv779IiIirZV6klqY65PFh0U5vLt6ntdRRERE5BBUJLW0zv25r+gjfrXqUX1UiYiISCumIqmFmc/H9MHT2FBWwLLP/uZ1HBERETkIFUkeODvzatL8CTy1+mmvo4iIiMhBqEjyQExsApf0/QZL921k4xfZXscRERGRCBotksws3szeN7OPzGyVmd3VEsHau4vGfJ+j/Il8nrPY6ygiIiISQTQ9SWXAJOfcSGAUcJaZndCsqTqALim9eD3rDiaVOyjf73UcERERqafRIsmFFIdfxoQfrllTdRD+vl+jqqqcnA2vex1FRERE6olqTpKZ+c1sJbAbeNM5916zpuooktK4+8BaZnz4K8rLD3idRkRERGqJqkhyzlU550YBfYBxZnZc/XXM7Dozyzaz7Nzc3CaO2X6dOfg88qtKeP2TJ7yOIiIiIrUc1tVtzrk9wCLgrAhtjzrnspxzWenp6U0Ur/0bf/T5DIztwjMbXtbNJUVERFqRaK5uSzezzuHnCcA3gLXNnKvDMJ+Pbw+cyprS3Xy4+V9exxEREZGwaHqSegKLzOxj4ANCc5L+3ryxOpZzR11LJ18s/1j7vNdRREREJKzRj6F3zn0MjG6BLB1WQlwnnhr1P2Tk5UDJHkjo7HEiERER0R23W4lBQ87Bb37c9uVeRxERERFUJLUe8am84a9gyvu/5EDpXq/TiIiIdHgqklqR9N7Hk1Oxl1c/etTrKCIiIh2eiqRWZFTGNzg2vgfPbnqVYLDK6zgiIiIdmoqkVsR8Pi4fMo3N5YUsW/c3r+OIiIh0aCqSWpmzMq8izZ/A02ue8TqKiIhIh9boLQCkZcXExPOzoZfTJW8T7M+DpDSvI4mIiHRI6klqhc4Y+R2OT+wN27K9jiIiItJhqUhqjWKT2Nm5N/etfozCfTu8TiMiItIhqUhqpYrTB/Nc0VpeWPEHr6OIiIh0SCqSWqnBvcZxYspA5m55k4qKUq/jiIiIdDgqklqxK4ZNJ7fqAK9/8rjXUURERDocFUmt2IlDL2BQbFeeXv8SLhj0Oo6IiEiHoiKpFTOfj6uHXMgwfwql+eu9jiMiItKh6D5JrdyU0dczpbQKdn4C6UO9jiMiItJhqCeptfPHQK/RfLLjXb7IW+N1GhERkQ5DRVIbUJg2kCt2vskTy2d5HUVERKTDUJHUBnTp1JfJ3UYyf9d77N2/y+s4IiIiHUKjRZKZ9TWzRWa22sxWmdlNLRFM6rpi5PWUuErmZf/O6ygiIiIdQjQ9SZXA/zjnjgVOAL5vZsc2byypb2jfE5nYaTDPbHmDkrIir+OIiIi0e40WSc65L5xzH4af7wPWAL2bO5g0dM2Ia6l0VXy24Z9eRxEREWn3DusWAGaWAYwG3muWNHJIYwacxb8Ld5BYlA/BKvD5vY4kIiLSbkU9cdvMkoGXgB865xqM95jZdWaWbWbZubm5TZlRwsznIzHjFIIle9i9ZanXcURERNq1qIokM4shVCA965x7OdI6zrlHnXNZzrms9PT0pswotXUbzC173ue77/6CYLDK6zQiIiLtVjRXtxnwGLDGOfdA80eSQzLjtIwz2VBWwNtrnvc6jYiISLsVTU/SBGA6MMnMVoYfk5s5lxzCWSOuolcghcdW/xWc8zqOiIhIuxTN1W1LnHPmnBvhnBsVfrzWEuEksphAPFcOnMqKA9tZvklXuomIiDQH3XG7jTp/zEy6+OL52+rnvI4iIiLSLh3WLQCk9UiI68TjY35Mxq7PYN8uSOnhdSQREZF2RT1Jbdjgo88lEJNA+aZFXkcRERFpd1QktWUx8azqfBRnfPxbVm56w+s0IiIi7YqKpDZuwJBzwIxZHz6ECwa9jiMiItJuqEhq4xLjU7lu0AVk79/KsvXzvY4jIiLSbqhIagcuHHsjvQIp/G7lH9SbJCIi0kRUJLUDsbGJzBx6KatKd/H+uoifGiMiIiKHSbcAaCe+Oeq79C7KJauoAIJB8Kn+FRERORL6n7SdCARiOf64y7AD+VTu/NjrOCIiIm2eiqT2JH0oc8p3Mu2/N1JRUep1GhERkTZNRVJ7Yka/fiexqbyQOe//xus0IiIibZqKpHbmxKEXMLHTYGZvfImdBRu8jiMiItJmqUhqZ8zn4/aJ9xDEcf/bP/M6joiISJulIqkd6pM+nJkDprJ4zzo25ehz3URERL4K3QKgnZo+/mecTAIDv1gNfSZAINbrSCIiIm2KepLaqZhAPINHXA6lRWxdoxtMioiIHC4VSe1Zah/mByo598P/Zc3WJV6nERERaVMaLZLM7HEz221mn7ZEIGlap425jlR/HHcvu4uqygqv44iIiLQZ0fQkPQmc1cw5pJmkJvXgJ8Ov5dOSnTzz7n1exxEREWkzGp247Zx7y8wyWiCLNJOzR17Dvz5/kwc3vsixPUZz/JBzvY4kIiKCc47yqiDlleFHredllUGCzjGiT2fP8unqtg7AfD7uPfOPfGfBRRRt/A/0OQkSOnsdS0REWohzjsqgo6JeEVJR9WVhUlEVWla7YKm/fu11v1zPfbl+/UKn5nlV3WKoZv/ukLnjY3ys/X9nt9B3qaEmK5LM7DrgOoB+/fo11W6liSQndGPON+fh+/CvsOplGD0d/DFexxIRaVecc1RU1e0dqVN81C486q1TZ1kjxUh5ZVW43dUUIxURCpva+wkeuh45LH6fEev3ERsIP/z1voafp8bGEOv3EVd/vYCPmPDzuAjbVT+PC3h7fVmTFUnOuUeBRwGysrKa8FRIU/ElpcGwqby47H5W7FzMPZOfxHy6wFFE2p5gMFSIlNUrJCrqL4s0lFO/AKkuPupvF6FQqSl4quov/7KAaUrVxUiM34gN+OsUGzGBLwuVUDFiX7b5vyxE6m7TsAiJ8Tdsi6tXyNReHuP34fdZk77P1krDbR1N2mAKU49iweZXGPLOPcyYeIfXiUSklXLOURUuRioqHWVVdXsvQkVBVbgoaVho1O7dqLM8iiKmfgFSf5uqpuwWgZoiICZcaNQuDuJqvU6KC9Tt8agpVvx1Co9Yf90iI8ZvdQuPekVMTL0elo5WjLRWjRZJZjYHOBVIM7NtwC+dc481dzBpPtdMvJs1het5cOOLDO42jInDvuV1JJEOrXq+SP1CIvKQy6Hni1RUOsprFTNl9QqX6u0iLY90DNeEtYgZNYVFTaERoaBIjgsctHcjxm91CopIwzw1wzj19lt//ep9x/gNMxUj0lA0V7dd2hJBpOWYz8c9Z/yJz185nxvev4e7S/I4d8xMr2OJtIjKqmCDYZfGnkcalqnuRalfjFTPF6nb23LweSZl4f03ZTESaYimuoekdk9GSnygwVyQ6sLhYMMtB1u/YaFiDbbz+1SMSNui4bYOKjGhM4+fO5cf/fNqCrYug66Z0H9C6E89kSZQFb6SpqwycoFwsOV1r4j5cnntuSCRelcO1jNSv9ekOSavNjZfJCUmUHdIpV5PSly9OSSR5ovUH4rRfBGR5qciqQNLTerBo+e9jP+zN2Dz26zNW8WgkVcSExPvdTQ5DM65WkMtdXtBDnsCa50raKrqre9qeknqbutqFT1VNVf2NOWcEZ9RqxjwfzlBNVC3uIjUMxJp8uqhhmAaXHVTf15JrbknKkZE2jcVSR1cIBAHw77JnpgYrl52G8fkLODBsx8nNamH19FandqX9lZEKDQiFR+RLsOt34NSf6JrY5cEN5xf0sQTWCPM5ajuKaluS4wN0DnCcEudnpQG806qh1/8dYZ+DtbDEuf31/TGBPy6ClNEWp6KJAEzOg85i9v25XDHJ49wwd+mcO3gaVww5gfExiZ6Eqmyqvb9P+r2aFRPTD3oTc/qzRupfbO0Q01WrX8lTqQCpSnF+C3iJbn1ezWSD9E7cqi5IlE/r7UsoDkjIiI1zDXlbMGwrKwsl52d3eT7leZT3UuyfOO/+f3K3/Jx6Q6O8ifz4LC7Kes6irIqoyxcZJTVG245ZC/KYQ3xfHlH1uacN1J7qKZukVCrrU4xEerRiGtQYHzZI3KoS3vrDwtVX93j01CNiEirYGbLnXNZ9ZerJ6kdcM5xoLyKgv3l5O8vp2B/GXtLKigqqQx/raCotILiskqKy6rYX1YZepRXUlJeRUl5FaWVteeQ/ICeSdl0SvyYf699jiL3Cm8nxpBXnkFh2QDAHzGHGaHCoN4wS/2Jp8lxAWITG84nOdRQzaEu5a1/jxFNYhURkaagIqmVq6gKsnNvKVsLD7C9sITd+8rYVVQafpSRu6+MvOIyyg4xFJQY66dTfAwp8QES4wIkx/npmpRIUqyfxLgACTH+0CPWT3xM6Aqd+JjRxPmNLmXbKd/1L14ofB6AnhbD8IS+HNdlOKf3PZO+XQZhsXEE4hNIjEvSUI2IiDTKBYNUBsupqqqo+UqwitTYFHBVbC/ewYHy/fRN7kl8al/PcqpIagVKK6r4PP8Am/OK2ZwX+pqTHyqKvthb0mDoKTUhhh6d4ujRKZ6B6UmkJ8fRJSmWrkmxdAt/7ZwYS6f4AJ0SYog5okmvvXHBLF7LO48Pt/yXFbs/5MO9G3hs+6tklOSSmTyQlWW5TN/1JgkWoJM/jgA+fGb8/KjTODG5P8sP7OB/dy5usOdf9jydEYk9WVqcw4O7ljRov6/3WQyJT+PfRRv4Y+67Ddof7PtN+sam8uqeNTyZ/2GD9j/1P4+0QBLPF37CvIKPG7Q/lfEtkvyxPJX/IfP3rG7Q/sLAy/Cbjz/lvs+/ij6r0xZnAeYMvASAh3Yt5a3izXXaU/3xPJFxYeh97FzMB/u31Wk/KiaFP/SbGvo+7Pg3n5TsrNOeEduFB/qeA8CPt/2TDWX5ddqHxXfn3t5nAHDDllfZXrG3TvuYxF78vOckAK75/GUKKg9gfFnATkjuz809JgIwffPzHAhW1Nn+650GMzP9BAAu2vQswXrD8uekHsNVaVmUBiuZnjOvTpthXNDlOC7pOpI9lSVc9/nL1PftbqOY2vk4dlbs46YtC2ptG3J12vGckXo0m8sKuG37P2u1hHyv+4mclDKANSW7uGfHfxrs/0dHnUxWUl9WHtjBbyP87P2019cZnnAU7xZ/ziO7ltY9OPDL3mcyMD6Nt4o28kTuew3e3z19z6FXbCpv7F3H8w1+9oz/6z+VroEkXi38lFcLPqmzb8N4MGMaif44Xs5fwRt71n7ZFv4jY/bAS/CZjzm5H7CkaENNPDMjxgI8MDB0A9indi0ju/jzOvtO8cdzz4DzAPjLzrdZtX9HTRtAWkwyt/U7B8x4ZMciNpbk1nn7veK68KM+oZ+th7f/h61lBXXaBySkc32v0M/WA1tfJ7diX539D008iit7ngTArz7/B0VVJXV+9jKT+3Jxj9DP1r05r1AW/tmz8FqjUwYwNX0sAHdtfil0/yj78v19LXUwZ3UbSUWwivtyXqn3nYeJnY/htK7DKa4s5aGtr1HfpK6ZnNj5aAoqinlk6xv1toaz0kYxttNAdpYV8tj2RQ22n5KeRWZKP7aU5PH0F28B4Pjy9+NbPU5gaFIv1h/4gnk732mw/bePmsiAhO6sKt7KS7vfr9m2+us1vSbRJ64Ly4s2syBveYP2G3qfQffYTizds45/5H+Ew1E9bcbh+Fm/c+gcSOTNwlX8q+DTOu1BgtyXcQEJvhj+lr+C/xSuIRjes3NBgjj+OOASfAZ/3f0ei4rW45wjSJCgc8SanycGXAQ4Zu1cwn+LNxF0jiCOoAuS6o/n2X4XgAty+85FLDmwhaBzVOEIOkevQBIv9z4XXJCrd75JdtnuOt+bYTFdeL5n6MNsb975OqvLC5jTazLHfeNXDb6PLUVFUgsqq6xi4+79fLZrX61HMVsLD9S5kVx6ShwZ3RL52oCu9OmSQJ8uifTukkDvzgn06BRPQmzk4a7mYj4ffbtn0rd7JlPDywqKtuErKQCLoXvRVm5ISGBP+V72VRRTFQxS5apITT4KErsR70roE59WZ58OR1x8Z4hPJaGyC73iuzU4bky4PbG888HbY1NJie/aYP8A/vguEEik00HaLb4z+GNJje9K3/j0hreISugC5qNLQjf6VaTXPbb5Q+1At4Ru9KsqrtOe7I+vaU9PSKNfsKxOe1pMck1794Q0+lFVp71nbJea9qMS0iiv9xl7PeLTatp7JqThD8TWaU9P+LK9T0I6SRUH6rR3je8K8Z0B6BWfRmmtIsnhSI3rAvGpofa4bgSpWySlxofafcFKjorrWqsltF5SbCrEdcL8MXSPTaW+xNhUiE3GZ4602E41x60WH5sMsUkEXBmdY1IabB8bSIBAAv5AIimBhFpHDgkE4iEQh88fS7wvrk6rA3wWAF8An89PjM9f993V/K/csFfU1eQMPYKuiopgVa328H9WwUoIVlBZVc6BWue+Zg5oZRk4R0llCUWV+2vlD7eX7wcz9pfvI698b518MeaH0lBRXFhayI7S/DrvP9UfDyWFAOQeyCOnZPeXe3dwICYZDoS22Vb8BZ+V7qrzvS+r2A/FuwDYtG8L68vy6xzfVZRA8g7AsbZoM1srir5sdw5fxQFIyADg473rya2s+7MXX1EKMaGrZ98vXMP+YEVo+/D3JrmiDPydAXgr/9OafVdn7FZRDi6RymAlC/M/avC971lVxWnBAGWVJbyZt4L6BlQ5TiyvYn9FEa/nLm/QfmzQx9jSUvaWFfB6bsO5tVnEkVlSTEHprjrt1YXgKZbM0KS95B3YHvH4Zwe6MSChkJ3Fn9fkt1r7uDiuD8SnsWvfBpYUrm7Qfk3SEIjtzK69OXy4dwOY1flprSjeCYEk8op3sG7/tpri0whdlBEsKQR/HMWle9hdvhfD8JnhC+/BBcvB/IDDh+Hz+YAAfvMRawGITQKMLvFd6FeVjg8fPgv9YZziT4DOfcF8HFe+k7iErvjMR8Dnx2c+usakQJ/jwXycH+9nfNke/L4AAfMT8MfQLTYVeo4H83Njej/2VZXSJ310g+9hS9LE7Wayv6ySNV8U8en2vazaUcSnO4pYv2sfleFuoYDPGJiexNE9UhjcPZmB6ckMTEuif7dEUuJjPE4vIiLScWjidjOqCjo+27WPj7buYWX48dmufTXDZN2SYhneO5VTh6YzrGcnjjkqhYxuScQGdO8XERGR1kpF0lewv6ySlVv38EFOAdk5hazYUsj+8lCXe2pCDCP7duaM4Ucxoncqx/VOpUenOE1oFhERaWNUJEVhb0kF2TkFvLspn3c3FbD6iyKqgg4zOOaoTlwwpg9j+ndmVN8uZHRLVEEkIiLSDqhIimB/WSXvby5g6YY83t2cz6odRTgHsX4fo/p15nunDmJs/y6M6d+FTpo/JCIi0i6pSALKK4Os3LqHJRvyeGdDHiu37qEy6IgN+BjdtzM3ThrCCQO7MbpfZ+JjWvbKMhEREfFGhyySnHPk5B/g7fW5vPVZLss25rO/vAqfQWbvVK49eSATBqWRldFFRZGIiEgH1WGKpOKySpZtzGfxut28tT6XrQUlAPTtmsB5o3tz0pA0xg9MIzVRw2ciIiLSjosk5xyf7Spm8brdLF6XS/bnBVRUOZJi/YwflMZ1Jw3kpCHpZKQleR1VREREWqGoiiQzOwuYReiTTf/inLu/WVN9RfvLKnlnYz6L1u1m8drd7NhbCsAxR6Vw9cQBnHJ0Oln9u+r+RCIiItKoRoskM/MDs4FvANuAD8xsgXOu4YddeWBz3n4Wrt3N4nW7eW9TAeVVQZJi/UwcksaNpw/hlKHp9ExN8DqmiIiItDHR9CSNAzY45zYBmNlcYCrgWZG0ZH0e/1m7i8XrctmcF/rco8Hdk7lifH8mHdOdrAz1FomIiMiRiaZI6g1srfV6G/C1+iuZ2XXAdQD9+vVrknAHc+9ra9iUW8z4Qd2YcWIGpw3tTr9uic16TBEREelYmmzitnPuUeBRCH3AbVPtN5LZl42mZ2oCCbG6PF9ERESaRzRF0nagb63XfcLLPDMwPdnLw4uIiEgHEM3EnQ+AIWY2wMxigUuABc0bS0RERMRbjfYkOecqzewHwL8I3QLgcefcqmZPJiIiIuKhqOYkOedeA15r5iwiIiIirYaukxcRERGJQEWSiIiISATmXNNfrW9mucDnTb7jutKAvGY+hhwenZPWSeel9dE5aZ10Xlqfljon/Z1z6fUXNkuR1BLMLNs5l+V1DvmSzknrpPPS+uictE46L62P1+dEw20iIiIiEahIEhEREYmgLRdJj3odQBrQOWmddF5aH52T1knnpfXx9Jy02TlJIiIiIs2pLfckiYiIiDSbVl8kmdlZZrbOzDaY2U8jtMeZ2bxw+3tmluFBzA4linNys5mtNrOPzew/Ztbfi5wdTWPnpdZ608zMmZmu4mlm0ZwTM7so/Puyysyea+mMHVEU/4b1M7NFZrYi/O/YZC9ydhRm9riZ7TazTw/Sbmb2u/D5+tjMxrRYOOdcq30Q+qy4jcBAIBb4CDi23jrfA/4Yfn4JMM/r3O35EeU5OQ1IDD+fqXPSOs5LeL0U4C3gXSDL69zt+RHl78oQYAXQJfy6u9e52/sjyvPyKDAz/PxYIMfr3O35AZwMjAE+PUj7ZOCfgAEnAO+1VLbW3pM0DtjgnNvknCsH5gJT660zFfhr+PmLwOlmZi2YsaNp9Jw45xY55w6EX74L9GnhjB1RNL8rAP8P+BVQ2pLhOqhozsm1wGznXCGAc253C2fsiKI5Lw7oFH6eCuxowXwdjnPuLaDgEKtMBZ5yIe8Cnc2sZ0tka+1FUm9ga63X28LLIq7jnKsE9gLdWiRdxxTNOantO4T+ApDm1eh5CXdR93XO/aMlg3Vg0fyuHA0cbWZLzexdMzurxdJ1XNGclzuBy81sG6EPd7+hZaLJQRzu/ztNJtASB5GOycwuB7KAU7zO0tGZmQ94AJjhcRSpK0BoyO1UQj2ub5lZpnNuj5ehhEuBJ51zvzWz8cDTZnaccy7odTBpWa29J2k70LfW6z7hZRHXMbMAoa7R/BZJ1zFFc04ws68DtwNTnHNlLZStI2vsvKQAxwGLzSyH0Lj+Ak3eblbR/K5sAxY45yqcc5uBzwgVTdJ8ojkv3wGeB3DOLQPiCX2GmHgjqv93mkNrL5I+AIaY2QAziyU0MXtBvXUWAFeGn18ILHThmV7SLBo9J2Y2GvgToQJJcyxaxiHPi3Nur3MuzTmX4ZzLIDRXbIpzLtubuB1CNP9+zSfUi4SZpREaftvUghk7omjOyxbgdAAzG0aoSMpt0ZRS2wLgivBVbicAe51zX7TEgVv1cJtzrtLMfgD8i9AVCY8751aZ2d1AtnNuAfAYoa7QDYQmfl3iXeL2L8pz8msgGXghPId+i3NuimehO4Aoz4u0oCjPyb+AM8xsNVAF3OqcU094M4ryvPwP8Gcz+xGhSdwz9Md38zGzOYT+WEgLzwP7JRAD4Jz7I6F5YZOBDcAB4KoWy6bzLiIiItJQax9uExEREfGEiiQRERGRCFQkiYiIiESgIklEREQkAhVJIiIiIhGoSBIRERGJQEWSiIiISAQqkkREREQi+P/Zy1UCiLDb+AAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -461,12 +461,12 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 53, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -489,12 +489,12 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 54, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -526,7 +526,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 55, "metadata": {}, "outputs": [], "source": [ @@ -535,7 +535,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 56, "metadata": {}, "outputs": [], "source": [ @@ -545,7 +545,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 57, "metadata": {}, "outputs": [], "source": [ @@ -555,7 +555,7 @@ }, { "cell_type": "code", - "execution_count": 205, + "execution_count": 58, "metadata": {}, "outputs": [ { @@ -563,20 +563,20 @@ "text/plain": [ "tensor([[ 0.0000e+00, 0.0000e+00, 0.0000e+00, ..., 0.0000e+00,\n", " 0.0000e+00, 0.0000e+00],\n", - " [-7.7321e-03, -7.1790e-03, -5.8637e-03, ..., -7.4780e-03,\n", - " -7.6361e-03, -6.1297e-03],\n", - " [-1.4187e-02, -1.3120e-02, -1.0713e-02, ..., -1.3576e-02,\n", - " -1.3778e-02, -1.0838e-02],\n", + " [ 3.2816e-04, 1.8552e-03, -2.1804e-04, ..., 7.3786e-04,\n", + " -9.7713e-04, 3.1228e-04],\n", + " [ 7.0167e-04, 3.6128e-03, -3.5956e-04, ..., 1.4626e-03,\n", + " -1.8273e-03, 6.6710e-04],\n", " ...,\n", - " [-3.6102e-03, -6.5573e-03, -9.0616e-03, ..., -7.5957e-03,\n", - " -5.7418e-03, -1.1301e-02],\n", - " [-8.9812e-04, -2.7115e-03, -4.0700e-03, ..., -3.0189e-03,\n", - " -2.0247e-03, -5.1659e-03],\n", - " [ 0.0000e+00, 0.0000e+00, 0.0000e+00, ..., 0.0000e+00,\n", - " -5.9605e-08, 0.0000e+00]], grad_fn=)" + " [-1.7625e-04, -3.7745e-03, 6.2877e-04, ..., -1.1397e-03,\n", + " 2.6466e-03, 5.7441e-04],\n", + " [-7.1645e-05, -1.9399e-03, 3.5667e-04, ..., -5.7197e-04,\n", + " 1.3840e-03, 3.1435e-04],\n", + " [ 0.0000e+00, -2.9802e-07, 0.0000e+00, ..., -1.7881e-07,\n", + " 0.0000e+00, 0.0000e+00]], grad_fn=)" ] }, - "execution_count": 205, + "execution_count": 58, "metadata": {}, "output_type": "execute_result" } @@ -594,23 +594,23 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 59, "metadata": {}, "outputs": [], "source": [ "from functools import partial\n", "\n", - "flow = make_coupling_flow(partial(make_transformer, d_in=1, d_out=1, d_hidden=100, n_components=10, periodic=True, verbose=False))" + "flow = make_coupling_flow(partial(make_transformer, d_in=1, d_out=1, d_hidden=100, n_components=20, periodic=True, verbose=False))" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 60, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -630,42 +630,33 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 61, "metadata": {}, "outputs": [], "source": [ - "# flow = flow.cuda()" + "flow = flow.cuda()" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 69, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "it: 900/1000, nll: -1.3465\r" + "it: 900/1000, nll: -0.6222\r" ] } ], "source": [ - "train(flow, cuda=False, train_with_inverse=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "# flow = flow.cuda()" + "train(flow, dataset=\"checkerboard\", cuda=True, train_with_inverse=False)" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 71, "metadata": {}, "outputs": [ { @@ -679,7 +670,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -691,7 +682,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -703,7 +694,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -715,7 +706,7 @@ } ], "source": [ - "plot_evaluation(flow, cuda=False, n_samples=10_000, use_log_norm=False, train_with_inverse=False, eps=0)" + "plot_evaluation(flow, dataset=\"checkerboard\", cuda=True, n_samples=10_000, use_log_norm=False, train_with_inverse=False, eps=0.1)" ] }, { From e1b03bcbebeda9966cb6365a6d246456cec43802 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 25 May 2021 18:42:23 +0200 Subject: [PATCH 45/68] elementwise_jacobian --- bgflow/nn/flow/root_finding/approx_inverse.py | 2 +- bgflow/nn/flow/root_finding/bisection.py | 3 ++- bgflow/nn/flow/transformer/compact/compact.py | 6 ++++-- bgflow/nn/flow/transformer/spline.py | 12 ++++++++---- 4 files changed, 15 insertions(+), 8 deletions(-) diff --git a/bgflow/nn/flow/root_finding/approx_inverse.py b/bgflow/nn/flow/root_finding/approx_inverse.py index d322ef30..b5972945 100644 --- a/bgflow/nn/flow/root_finding/approx_inverse.py +++ b/bgflow/nn/flow/root_finding/approx_inverse.py @@ -85,7 +85,7 @@ def backward(ctx, grad_out_x, grad_out_dlogp): with torch.enable_grad(): x = x.detach().requires_grad_(True) - y, dlogp = ctx.bijection(x) + y, dlogp = ctx.bijection(x, diagonal_jacobian=True) force = torch.autograd.grad(-dlogp.sum(), x, create_graph=True)[0] diff --git a/bgflow/nn/flow/root_finding/bisection.py b/bgflow/nn/flow/root_finding/bisection.py index 6c51dd55..553e92cf 100644 --- a/bgflow/nn/flow/root_finding/bisection.py +++ b/bgflow/nn/flow/root_finding/bisection.py @@ -77,7 +77,8 @@ def find_interval(f, grid, threshold=1e-4, max_iters=100, verbose=False, raise_e raise ValueError(msg) else: warnings.warn(msg) - return left, right, fleft, dfleft.sum(-1, keepdim=True) + dfleft = f(left)[-1] + return left, right, fleft, dfleft class BisectionRootFinder(torch.nn.Module): diff --git a/bgflow/nn/flow/transformer/compact/compact.py b/bgflow/nn/flow/transformer/compact/compact.py index b70e810f..eb690e61 100644 --- a/bgflow/nn/flow/transformer/compact/compact.py +++ b/bgflow/nn/flow/transformer/compact/compact.py @@ -357,14 +357,16 @@ def __init__( self._compute_components = compute_components self._compute_weights = compute_weights - def _forward(self, cond, out, log_weights=None, *args, **kwargs): + def _forward(self, cond, out, log_weights=None, *args, elementwise_jacobian=False, **kwargs): cdfs, log_pdfs = self._compute_components(cond, out) if log_weights is None and self._compute_weights is not None: log_weights = self._compute_weights(cond).view(*cdfs.shape).log_softmax(dim=-1) else: log_weights = torch.zeros(*cdfs.shape).log_softmax(dim=-1) out, dlogp = mixture_cdf_transform(cdfs, log_pdfs, log_weights) - return out, dlogp.sum(dim=-1, keepdim=True) + if not elementwise_jacobian: + dlogp = dlogp.sum(dim=-1, keepdim=True) + return out, dlogp def _inverse(self, x, y, *args, **kwargs): raise NotImplementedError("No analytic inverse") diff --git a/bgflow/nn/flow/transformer/spline.py b/bgflow/nn/flow/transformer/spline.py index c5606ee0..1cb7114c 100644 --- a/bgflow/nn/flow/transformer/spline.py +++ b/bgflow/nn/flow/transformer/spline.py @@ -103,7 +103,7 @@ def _compute_params(self, x, y_dim): slopes[..., self._noncircular_indices(y_dim), -1] = noncircular_slopes return widths, heights, slopes - def _forward(self, x, y, *args, **kwargs): + def _forward(self, x, y, *args, elementwise_jacobian=False, **kwargs): from nflows.transforms.splines import rational_quadratic_spline widths, heights, slopes = self._compute_params(x, y.shape[-1]) @@ -118,9 +118,11 @@ def _forward(self, x, y, *args, **kwargs): top=self._top, bottom=self._bottom, ) - return z, dlogp.sum(dim=-1, keepdim=True) + if elementwise_jacobian: + dlogp = dlogp.sum(dim=-1, keepdim=True) + return z, dlogp - def _inverse(self, x, y, *args, **kwargs): + def _inverse(self, x, y, *args, elementwise_jacobian=False, **kwargs): from nflows.transforms.splines import rational_quadratic_spline widths, heights, slopes = self._compute_params(x, y.shape[-1]) @@ -135,7 +137,9 @@ def _inverse(self, x, y, *args, **kwargs): top=self._top, bottom=self._bottom, ) - return z, dlogp.sum(dim=-1, keepdim=True) + if elementwise_jacobian: + dlogp = dlogp.sum(dim=-1, keepdim=True) + return z, dlogp def _n_noncircular(self, y_dim): if self._is_circular.all(): From 6550bbc8a9c832434ca1a0ca9a0eb9dfe9421e5b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 25 May 2021 18:54:18 +0200 Subject: [PATCH 46/68] ... --- bgflow/nn/flow/root_finding/approx_inverse.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/bgflow/nn/flow/root_finding/approx_inverse.py b/bgflow/nn/flow/root_finding/approx_inverse.py index b5972945..5db6db9a 100644 --- a/bgflow/nn/flow/root_finding/approx_inverse.py +++ b/bgflow/nn/flow/root_finding/approx_inverse.py @@ -124,13 +124,17 @@ def __init__(self, flow, root_finder): def _forward(self, x, *args, **kwargs): return self._flow(x, *args, **kwargs) - def _inverse(self, y, *args, **kwargs): - return DifferentiableApproximateInverse.apply( + def _inverse(self, y, *args, elementwise_jacobian=False, **kwargs): + x, dlogp = DifferentiableApproximateInverse.apply( self._root_finder, self, y, *self.parameters() ) + if not elementwise_jacobian: + dlogp = dlogp.sum(-1, keepdim=True) + return x, dlogp + class TransformerToFlowAdapter(Flow): From 4ff80c4e3b019a05b1b248aea24c5f55195eacbe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 25 May 2021 18:56:43 +0200 Subject: [PATCH 47/68] ... --- bgflow/nn/flow/root_finding/approx_inverse.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/bgflow/nn/flow/root_finding/approx_inverse.py b/bgflow/nn/flow/root_finding/approx_inverse.py index 5db6db9a..e205ee15 100644 --- a/bgflow/nn/flow/root_finding/approx_inverse.py +++ b/bgflow/nn/flow/root_finding/approx_inverse.py @@ -165,14 +165,17 @@ def __init__(self, transformer, root_finder): def _forward(self, cond, out, *args, **kwargs): return (self._transformer(cond, out, *args, **kwargs)) - def _inverse(self, cond, out, *args, **kwargs): + def _inverse(self, cond, out, *args, elementwise_jacobian=False, **kwargs): flow = TransformerToFlowAdapter(self._transformer, cond=cond) - return DifferentiableApproximateInverse.apply( + x, dlogp = DifferentiableApproximateInverse.apply( self._root_finder, flow, out, *flow.parameters() ) + if not elementwise_jacobian: + dlogp = dlogp.sum(-1, keepdim=True) + return x, dlogp class TransformerApproximateInverse(torch.autograd.Function): From 5f8288ca2893186562a259d32fc474ba9b64b4c8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 25 May 2021 18:59:48 +0200 Subject: [PATCH 48/68] ... --- bgflow/nn/flow/root_finding/approx_inverse.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/bgflow/nn/flow/root_finding/approx_inverse.py b/bgflow/nn/flow/root_finding/approx_inverse.py index e205ee15..f7cc273b 100644 --- a/bgflow/nn/flow/root_finding/approx_inverse.py +++ b/bgflow/nn/flow/root_finding/approx_inverse.py @@ -197,7 +197,7 @@ def backward(ctx, grad_out_x, grad_out_dlogp): with torch.enable_grad(): x = x.detach().requires_grad_(True) - y, dlogp = ctx.bijection(cond, x) + y, dlogp = ctx.bijection(cond, x, elementwise_jacobian=True) force = torch.autograd.grad(-dlogp.sum(), x, create_graph=True)[0] @@ -234,14 +234,17 @@ def __init__(self, transformer, oracle): def _forward(self, *args, **kwargs): return self._transformer(*args, **kwargs) - def _inverse(self, cond, out, *args, **kwargs): - return TransformerApproximateInverse.apply( + def _inverse(self, cond, out, *args, elementwise_jacobian=False, **kwargs): + x, dlogp= TransformerApproximateInverse.apply( self._oracle, self._transformer, cond, out, *self._transformer.parameters() ) + if not elementwise_jacobian: + dlogp = dlogp.sum(-1, keepdim=True) + return x, dlogp class GridInversion(Transformer): From faaca3032b2c2c6b166526f63d6b5dde5df43ca1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 25 May 2021 19:09:39 +0200 Subject: [PATCH 49/68] ... --- bgflow/nn/flow/root_finding/approx_inverse.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/bgflow/nn/flow/root_finding/approx_inverse.py b/bgflow/nn/flow/root_finding/approx_inverse.py index f7cc273b..23c83fe0 100644 --- a/bgflow/nn/flow/root_finding/approx_inverse.py +++ b/bgflow/nn/flow/root_finding/approx_inverse.py @@ -235,7 +235,7 @@ def _forward(self, *args, **kwargs): return self._transformer(*args, **kwargs) def _inverse(self, cond, out, *args, elementwise_jacobian=False, **kwargs): - x, dlogp= TransformerApproximateInverse.apply( + x, dlogp = TransformerApproximateInverse.apply( self._oracle, self._transformer, cond, @@ -243,7 +243,7 @@ def _inverse(self, cond, out, *args, elementwise_jacobian=False, **kwargs): *self._transformer.parameters() ) if not elementwise_jacobian: - dlogp = dlogp.sum(-1, keepdim=True) + dlogp = dlogp.sum(dim=-1, keepdim=True) return x, dlogp From 5984dde5acbd3673f7520cd374ffa135e38d862a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 25 May 2021 19:12:08 +0200 Subject: [PATCH 50/68] ... --- bgflow/nn/flow/transformer/spline.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/bgflow/nn/flow/transformer/spline.py b/bgflow/nn/flow/transformer/spline.py index 1cb7114c..fb484056 100644 --- a/bgflow/nn/flow/transformer/spline.py +++ b/bgflow/nn/flow/transformer/spline.py @@ -118,7 +118,7 @@ def _forward(self, x, y, *args, elementwise_jacobian=False, **kwargs): top=self._top, bottom=self._bottom, ) - if elementwise_jacobian: + if not elementwise_jacobian: dlogp = dlogp.sum(dim=-1, keepdim=True) return z, dlogp @@ -137,7 +137,7 @@ def _inverse(self, x, y, *args, elementwise_jacobian=False, **kwargs): top=self._top, bottom=self._bottom, ) - if elementwise_jacobian: + if not elementwise_jacobian: dlogp = dlogp.sum(dim=-1, keepdim=True) return z, dlogp From 02d8ccd804090728e0ec8350334e5ac89f6d3dd2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 25 May 2021 22:29:40 +0200 Subject: [PATCH 51/68] modulify distributions --- bgflow/distribution/distribution.py | 2 + bgflow/distribution/modulify.py | 60 +++++++++++++++++++++++++++++ 2 files changed, 62 insertions(+) create mode 100644 bgflow/distribution/modulify.py diff --git a/bgflow/distribution/distribution.py b/bgflow/distribution/distribution.py index 25d1adf7..974f1dc8 100644 --- a/bgflow/distribution/distribution.py +++ b/bgflow/distribution/distribution.py @@ -2,6 +2,7 @@ import torch from .energy import Energy from .sampling import Sampler +from .modulify import distribution_module from torch.distributions import constraints @@ -68,6 +69,7 @@ def __getattr__(self, name): raise AttributeError(msg) +@distribution_module class SloppyUniform(torch.distributions.Uniform): def __init__(self, *args, tol=1e-5, **kwargs): super().__init__(*args, **kwargs) diff --git a/bgflow/distribution/modulify.py b/bgflow/distribution/modulify.py new file mode 100644 index 00000000..249cc3dd --- /dev/null +++ b/bgflow/distribution/modulify.py @@ -0,0 +1,60 @@ +import torch +from torch import nn +from torch.distributions.utils import lazy_property + + +__all__ = ["distribution_module"] + + +def distribution_module(cls): + """A class decorator to "modulify" torch distributions.""" + # get the actual distribution class from the mro() + cls_distribution = [] + for parent in cls.mro()[1:]: + if ( + issubclass(parent, torch.distributions.Distribution) + and parent != torch.distributions.Distribution + ): + cls_distribution.append(parent) + assert len(cls_distribution) == 1 + cls_distribution = cls_distribution[0] + + class DistributionModule: + def __init__(self, *args, **kwargs): + """Initialize distribution and register plain tensors as buffers.""" + super().__init__(*args, **kwargs) + + # after initializing re-register distribution parameters as buffers + k_tensors = [] + for k in self.__dict__: + + # check if it's a lazy_property + # in this case we should simply move on instead of evaluating it. + if self._is_lazy_property(k): + continue + + # check if it's a "plain" tensor + if isinstance(getattr(self, k), torch.Tensor): + k_tensors.append(k) + + for k in k_tensors: + # for a "plain "tensor we will now register it as buffer. + val = getattr(self, k) + delattr(self, k) + self.register_buffer(k, val) + + def __getattribute__(self, name): + """Return attribute with lazy_property special check.""" + if type(self)._is_lazy_property(name): + # deleting the attribute from the instance will simply "reset" + # the lazy_property + delattr(self, name) + return super().__getattribute__(name) + + @classmethod + def _is_lazy_property(cls, name): + return isinstance(getattr(cls, name, object), lazy_property) + + return type( + cls.__name__, (DistributionModule, cls_distribution, nn.Module), {} + ) \ No newline at end of file From 75666dc4c6b90e499a0311be3f1a8305fdcad5df Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 25 May 2021 22:33:58 +0200 Subject: [PATCH 52/68] ... --- bgflow/distribution/distribution.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/bgflow/distribution/distribution.py b/bgflow/distribution/distribution.py index 974f1dc8..ee5c77d3 100644 --- a/bgflow/distribution/distribution.py +++ b/bgflow/distribution/distribution.py @@ -69,8 +69,7 @@ def __getattr__(self, name): raise AttributeError(msg) -@distribution_module -class SloppyUniform(torch.distributions.Uniform): +class SloppyUniform(distribution_module(torch.distributions.Uniform)): def __init__(self, *args, tol=1e-5, **kwargs): super().__init__(*args, **kwargs) self.tol = tol From 5f510a44f29af9a041452c65d4bad42145b0009e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 25 May 2021 23:00:14 +0200 Subject: [PATCH 53/68] ... --- bgflow/distribution/distribution.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/bgflow/distribution/distribution.py b/bgflow/distribution/distribution.py index ee5c77d3..357872f6 100644 --- a/bgflow/distribution/distribution.py +++ b/bgflow/distribution/distribution.py @@ -68,10 +68,10 @@ def __getattr__(self, name): msg = msg.replace(self._delegate.__class__.__name__, "Distribution") raise AttributeError(msg) - -class SloppyUniform(distribution_module(torch.distributions.Uniform)): +@distribution_module +class SloppyUniform(torch.distributions.Uniform, torch.nn.Module): def __init__(self, *args, tol=1e-5, **kwargs): - super().__init__(*args, **kwargs) + super().__init__(self._low, self._high, *args, **kwargs) self.tol = tol @constraints.dependent_property(is_discrete=False, event_dim=0) From 28b3749e6e7d30f4df484d212798f3b17793462b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 25 May 2021 23:01:31 +0200 Subject: [PATCH 54/68] ... --- bgflow/distribution/distribution.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/bgflow/distribution/distribution.py b/bgflow/distribution/distribution.py index 357872f6..6ef476b5 100644 --- a/bgflow/distribution/distribution.py +++ b/bgflow/distribution/distribution.py @@ -68,10 +68,11 @@ def __getattr__(self, name): msg = msg.replace(self._delegate.__class__.__name__, "Distribution") raise AttributeError(msg) + @distribution_module class SloppyUniform(torch.distributions.Uniform, torch.nn.Module): def __init__(self, *args, tol=1e-5, **kwargs): - super().__init__(self._low, self._high, *args, **kwargs) + super().__init__(*args, **kwargs) self.tol = tol @constraints.dependent_property(is_discrete=False, event_dim=0) From 269eb6d7e9fc67b1943c37e8283b6a84801db561 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 25 May 2021 23:05:39 +0200 Subject: [PATCH 55/68] ... --- bgflow/distribution/distribution.py | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/bgflow/distribution/distribution.py b/bgflow/distribution/distribution.py index 6ef476b5..40295a48 100644 --- a/bgflow/distribution/distribution.py +++ b/bgflow/distribution/distribution.py @@ -69,12 +69,21 @@ def __getattr__(self, name): raise AttributeError(msg) -@distribution_module class SloppyUniform(torch.distributions.Uniform, torch.nn.Module): - def __init__(self, *args, tol=1e-5, **kwargs): - super().__init__(*args, **kwargs) + def __init__(self, low, high, tol=1e-5, **kwargs): + super().__init__(low=low, high=high, **kwargs) + self.register_buffer("_low", low) + self.register_buffer("_high", high) self.tol = tol + @property + def low(self): + return self._low + + @property + def high(self): + return self._high + @constraints.dependent_property(is_discrete=False, event_dim=0) def support(self): return constraints.interval(self.low-self.tol, self.high+self.tol) From a13c6cd9e7311eb51c7d33eb0baf9034f749eee3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 25 May 2021 23:06:47 +0200 Subject: [PATCH 56/68] ... --- bgflow/distribution/distribution.py | 1 - 1 file changed, 1 deletion(-) diff --git a/bgflow/distribution/distribution.py b/bgflow/distribution/distribution.py index 40295a48..34f82a95 100644 --- a/bgflow/distribution/distribution.py +++ b/bgflow/distribution/distribution.py @@ -2,7 +2,6 @@ import torch from .energy import Energy from .sampling import Sampler -from .modulify import distribution_module from torch.distributions import constraints From 3959b9aff6f38e23396120b001dc947a21ab2986 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 25 May 2021 23:09:31 +0200 Subject: [PATCH 57/68] ... --- bgflow/distribution/distribution.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/bgflow/distribution/distribution.py b/bgflow/distribution/distribution.py index 34f82a95..f25a0716 100644 --- a/bgflow/distribution/distribution.py +++ b/bgflow/distribution/distribution.py @@ -69,8 +69,8 @@ def __getattr__(self, name): class SloppyUniform(torch.distributions.Uniform, torch.nn.Module): - def __init__(self, low, high, tol=1e-5, **kwargs): - super().__init__(low=low, high=high, **kwargs) + def __init__(self, low, high, *args, tol=1e-5, **kwargs): + super().__init__(*args, low=low, high=high, **kwargs) self.register_buffer("_low", low) self.register_buffer("_high", high) self.tol = tol From 748ad995d87a41102488823317290dd3a1b7f7ee Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 25 May 2021 23:10:33 +0200 Subject: [PATCH 58/68] ... --- bgflow/distribution/distribution.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bgflow/distribution/distribution.py b/bgflow/distribution/distribution.py index f25a0716..94ff01da 100644 --- a/bgflow/distribution/distribution.py +++ b/bgflow/distribution/distribution.py @@ -70,7 +70,7 @@ def __getattr__(self, name): class SloppyUniform(torch.distributions.Uniform, torch.nn.Module): def __init__(self, low, high, *args, tol=1e-5, **kwargs): - super().__init__(*args, low=low, high=high, **kwargs) + super().__init__(low, high, *args, **kwargs) self.register_buffer("_low", low) self.register_buffer("_high", high) self.tol = tol From 8a4fa8f5aaef309545732ff048f791f71cd75da1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 25 May 2021 23:24:54 +0200 Subject: [PATCH 59/68] ... --- bgflow/distribution/distribution.py | 29 ++++++++++++++++------------- 1 file changed, 16 insertions(+), 13 deletions(-) diff --git a/bgflow/distribution/distribution.py b/bgflow/distribution/distribution.py index 94ff01da..95991bbb 100644 --- a/bgflow/distribution/distribution.py +++ b/bgflow/distribution/distribution.py @@ -46,6 +46,9 @@ def __init__(self, distribution: torch.distributions.Distribution): self._delegate = distribution super().__init__(dim=distribution.event_shape) + def _apply(self, fn): + pass + def _sample(self, n_samples): if isinstance(n_samples, int): return self._delegate.sample(torch.Size([n_samples])) @@ -68,25 +71,25 @@ def __getattr__(self, name): raise AttributeError(msg) -class SloppyUniform(torch.distributions.Uniform, torch.nn.Module): - def __init__(self, low, high, *args, tol=1e-5, **kwargs): - super().__init__(low, high, *args, **kwargs) - self.register_buffer("_low", low) - self.register_buffer("_high", high) +class SloppyUniform(torch.nn.Module): + def __init__(self, low, high, tol=1e-5): + super().__init__() + self.register_buffer("low", low) + self.register_buffer("high", high) self.tol = tol - @property - def low(self): - return self._low - - @property - def high(self): - return self._high - @constraints.dependent_property(is_discrete=False, event_dim=0) def support(self): return constraints.interval(self.low-self.tol, self.high+self.tol) + def __getattr__(self, item): + uniform = torch.distributions.Uniform(self.low, self.high) + uniform.support = self.support + if hasattr(uniform, item): + return getattr(uniform, item) + else: + raise AttributeError(f"SloppyUniform has no attribute {item}") + class UniformDistribution(TorchDistribution): """Shortcut""" From 202101ee2f69b2c5875273544a259f778debef45 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 25 May 2021 23:26:30 +0200 Subject: [PATCH 60/68] ... --- bgflow/distribution/distribution.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/bgflow/distribution/distribution.py b/bgflow/distribution/distribution.py index 95991bbb..c19c4889 100644 --- a/bgflow/distribution/distribution.py +++ b/bgflow/distribution/distribution.py @@ -72,18 +72,19 @@ def __getattr__(self, name): class SloppyUniform(torch.nn.Module): - def __init__(self, low, high, tol=1e-5): + def __init__(self, low, high, validate_args=None, tol=1e-5, **kwargs): super().__init__() self.register_buffer("low", low) self.register_buffer("high", high) self.tol = tol + self.validate_args = validate_args @constraints.dependent_property(is_discrete=False, event_dim=0) def support(self): return constraints.interval(self.low-self.tol, self.high+self.tol) def __getattr__(self, item): - uniform = torch.distributions.Uniform(self.low, self.high) + uniform = torch.distributions.Uniform(self.low, self.high, self.validate_args) uniform.support = self.support if hasattr(uniform, item): return getattr(uniform, item) From 8705b60297d936ae57c0c54a6b09bed5fc28ad4b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 25 May 2021 23:28:40 +0200 Subject: [PATCH 61/68] ... --- bgflow/distribution/distribution.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/bgflow/distribution/distribution.py b/bgflow/distribution/distribution.py index c19c4889..7ba55e4a 100644 --- a/bgflow/distribution/distribution.py +++ b/bgflow/distribution/distribution.py @@ -83,13 +83,13 @@ def __init__(self, low, high, validate_args=None, tol=1e-5, **kwargs): def support(self): return constraints.interval(self.low-self.tol, self.high+self.tol) - def __getattr__(self, item): + def __getattr__(self, name): uniform = torch.distributions.Uniform(self.low, self.high, self.validate_args) uniform.support = self.support - if hasattr(uniform, item): - return getattr(uniform, item) + if hasattr(uniform, name): + return getattr(uniform, name) else: - raise AttributeError(f"SloppyUniform has no attribute {item}") + return super().__getattr__(name=name) class UniformDistribution(TorchDistribution): From 47afe2272c2b9fb12341ec0860f5aac2bf8f5b79 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 25 May 2021 23:31:32 +0200 Subject: [PATCH 62/68] ... --- bgflow/distribution/distribution.py | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/bgflow/distribution/distribution.py b/bgflow/distribution/distribution.py index 7ba55e4a..03d5b170 100644 --- a/bgflow/distribution/distribution.py +++ b/bgflow/distribution/distribution.py @@ -84,12 +84,16 @@ def support(self): return constraints.interval(self.low-self.tol, self.high+self.tol) def __getattr__(self, name): - uniform = torch.distributions.Uniform(self.low, self.high, self.validate_args) - uniform.support = self.support - if hasattr(uniform, name): - return getattr(uniform, name) - else: + try: return super().__getattr__(name=name) + except AttributeError: + uniform = torch.distributions.Uniform(self.low, self.high, self.validate_args) + uniform.support = self.support + if hasattr(uniform, name): + return getattr(uniform, name) + except: + raise AttributeError(f"SloppyUniform has no attribute {name}") + class UniformDistribution(TorchDistribution): From 0c457a59bb2ef0cd7837581d3bab8a0e177e7c7c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 25 May 2021 23:40:12 +0200 Subject: [PATCH 63/68] ... --- bgflow/distribution/distribution.py | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/bgflow/distribution/distribution.py b/bgflow/distribution/distribution.py index 03d5b170..ab4bbb0e 100644 --- a/bgflow/distribution/distribution.py +++ b/bgflow/distribution/distribution.py @@ -71,24 +71,29 @@ def __getattr__(self, name): raise AttributeError(msg) +class _SloppyUniform(torch.distributions.Uniform): + def __init__(self, *args, tol=1e-5, **kwargs): + super().__init__(*args, **kwargs) + self.tol = tol + + @constraints.dependent_property(is_discrete=False, event_dim=0) + def support(self): + return constraints.interval(self.low-self.tol, self.high+self.tol) + + class SloppyUniform(torch.nn.Module): - def __init__(self, low, high, validate_args=None, tol=1e-5, **kwargs): + def __init__(self, low, high, validate_args=None, tol=1e-5): super().__init__() self.register_buffer("low", low) self.register_buffer("high", high) self.tol = tol self.validate_args = validate_args - @constraints.dependent_property(is_discrete=False, event_dim=0) - def support(self): - return constraints.interval(self.low-self.tol, self.high+self.tol) - def __getattr__(self, name): try: return super().__getattr__(name=name) except AttributeError: - uniform = torch.distributions.Uniform(self.low, self.high, self.validate_args) - uniform.support = self.support + uniform = _SloppyUniform(self.low, self.high, self.validate_args, tol) if hasattr(uniform, name): return getattr(uniform, name) except: From bb5b5627fe8ec4ec29059c07d9c1d60be606a87c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 25 May 2021 23:40:38 +0200 Subject: [PATCH 64/68] ... --- bgflow/distribution/distribution.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/bgflow/distribution/distribution.py b/bgflow/distribution/distribution.py index ab4bbb0e..dc38bf44 100644 --- a/bgflow/distribution/distribution.py +++ b/bgflow/distribution/distribution.py @@ -93,14 +93,13 @@ def __getattr__(self, name): try: return super().__getattr__(name=name) except AttributeError: - uniform = _SloppyUniform(self.low, self.high, self.validate_args, tol) + uniform = _SloppyUniform(self.low, self.high, self.validate_args, self.tol) if hasattr(uniform, name): return getattr(uniform, name) except: raise AttributeError(f"SloppyUniform has no attribute {name}") - class UniformDistribution(TorchDistribution): """Shortcut""" def __init__(self, low, high, tol=1e-5, validate_args=None, n_event_dims=1): From e9230c2c78b31e004f8c923a9fa9dcb1c40c2a42 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Tue, 25 May 2021 23:41:03 +0200 Subject: [PATCH 65/68] ... --- bgflow/distribution/distribution.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bgflow/distribution/distribution.py b/bgflow/distribution/distribution.py index dc38bf44..a2bd8bc9 100644 --- a/bgflow/distribution/distribution.py +++ b/bgflow/distribution/distribution.py @@ -93,7 +93,7 @@ def __getattr__(self, name): try: return super().__getattr__(name=name) except AttributeError: - uniform = _SloppyUniform(self.low, self.high, self.validate_args, self.tol) + uniform = _SloppyUniform(self.low, self.high, self.validate_args, tol=self.tol) if hasattr(uniform, name): return getattr(uniform, name) except: From ce4ca327fdff44763183d681df13bcb399a7e473 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Wed, 26 May 2021 00:01:07 +0200 Subject: [PATCH 66/68] ... --- bgflow/distribution/distribution.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/bgflow/distribution/distribution.py b/bgflow/distribution/distribution.py index a2bd8bc9..b9a2d6d3 100644 --- a/bgflow/distribution/distribution.py +++ b/bgflow/distribution/distribution.py @@ -103,8 +103,8 @@ def __getattr__(self, name): class UniformDistribution(TorchDistribution): """Shortcut""" def __init__(self, low, high, tol=1e-5, validate_args=None, n_event_dims=1): - uniform = SloppyUniform(low, high, validate_args, tol=1e-5) - independent = torch.distributions.Independent(uniform, n_event_dims) + self.uniform = SloppyUniform(low, high, validate_args, tol=1e-5) + independent = torch.distributions.Independent(self.uniform, n_event_dims) self.tol = tol super().__init__(independent) From 33b0ba94dfdb64a072c7d902e215efe350d68ef7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Wed, 26 May 2021 00:11:27 +0200 Subject: [PATCH 67/68] ... --- bgflow/distribution/distribution.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/bgflow/distribution/distribution.py b/bgflow/distribution/distribution.py index b9a2d6d3..f81dd8e2 100644 --- a/bgflow/distribution/distribution.py +++ b/bgflow/distribution/distribution.py @@ -46,9 +46,6 @@ def __init__(self, distribution: torch.distributions.Distribution): self._delegate = distribution super().__init__(dim=distribution.event_shape) - def _apply(self, fn): - pass - def _sample(self, n_samples): if isinstance(n_samples, int): return self._delegate.sample(torch.Size([n_samples])) From df24ac281b565bb4a08d5ce2899877a8b4690d69 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20Kr=C3=A4mer?= Date: Wed, 26 May 2021 00:13:34 +0200 Subject: [PATCH 68/68] ... --- bgflow/distribution/distribution.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/bgflow/distribution/distribution.py b/bgflow/distribution/distribution.py index f81dd8e2..01e9ebc5 100644 --- a/bgflow/distribution/distribution.py +++ b/bgflow/distribution/distribution.py @@ -100,10 +100,10 @@ def __getattr__(self, name): class UniformDistribution(TorchDistribution): """Shortcut""" def __init__(self, low, high, tol=1e-5, validate_args=None, n_event_dims=1): - self.uniform = SloppyUniform(low, high, validate_args, tol=1e-5) - independent = torch.distributions.Independent(self.uniform, n_event_dims) - self.tol = tol + uniform = SloppyUniform(low, high, validate_args, tol=tol) + independent = torch.distributions.Independent(uniform, n_event_dims) super().__init__(independent) + self.uniform = uniform def _energy(self, x): try: