From c3725e2e1a3d66390e80e3e08d95eab36e9420cf Mon Sep 17 00:00:00 2001 From: Ben Thompson Date: Wed, 19 Oct 2022 21:16:02 -0400 Subject: [PATCH] EH-Bound aka: Exponential holder bound, q-holder bound. (#73) * Add study of exponential holder bound * Add Mike changes to study no-noise Taylor, optimal centered Holder * Add slightly different line types to distinguish them * Update with fresh restart * Rename gaussian and start binom * Fix holder bounds for binom and gaussian * Update tight bounds * Add qcp solver to optimize q * Add qcp solver to optimize q * Add jaxified version of qcp solver * Integrate qcp solver and update binomial bound study with new method * Update saved qcp solver notebook * Finish study of q-holder * Refactor binomial more and clean-up comments * Amend some comments * Add tutorial and simplify interface for binomial for validation Co-authored-by: James Yang --- .vscode/settings.json | 3 +- .../confirm/mini_imprint/bound/binomial.py | 780 ++++++++++++++++++ docs/tutorial/q-holder-bound.md | 195 +++++ imprint/.vscode/build.sh | 2 +- research/q-holder-bound/qcp-solver.ipynb | 587 +++++++++++++ research/q-holder-bound/qcp-solver.md | 242 ++++++ .../q-holder-bound/tight_holder_binom.ipynb | 353 ++++++++ research/q-holder-bound/tight_holder_binom.md | 198 +++++ .../tight_holder_gaussian.ipynb | 636 ++++++++++++++ .../q-holder-bound/tight_holder_gaussian.md | 400 +++++++++ 10 files changed, 3394 insertions(+), 2 deletions(-) create mode 100644 confirm/confirm/mini_imprint/bound/binomial.py create mode 100644 docs/tutorial/q-holder-bound.md mode change 100755 => 100644 imprint/.vscode/build.sh create mode 100644 research/q-holder-bound/qcp-solver.ipynb create mode 100644 research/q-holder-bound/qcp-solver.md create mode 100644 research/q-holder-bound/tight_holder_binom.ipynb create mode 100644 research/q-holder-bound/tight_holder_binom.md create mode 100644 research/q-holder-bound/tight_holder_gaussian.ipynb create mode 100644 research/q-holder-bound/tight_holder_gaussian.md diff --git a/.vscode/settings.json b/.vscode/settings.json index 8c914ab4..18fdd8bf 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -122,5 +122,6 @@ "autoDocstring.docstringFormat": "google-notypes", "r.bracketedPaste": true, "r.plot.useHttpgd": true, - "python.analysis.extraPaths": ["./outlaw", "./imprint/python"] + "python.analysis.extraPaths": ["./outlaw", "./imprint/python"], + "cmake.sourceDirectory": "${workspaceFolder}/imprint/imprint" } diff --git a/confirm/confirm/mini_imprint/bound/binomial.py b/confirm/confirm/mini_imprint/bound/binomial.py new file mode 100644 index 00000000..f1061d45 --- /dev/null +++ b/confirm/confirm/mini_imprint/bound/binomial.py @@ -0,0 +1,780 @@ +import jax +import jax.numpy as jnp + + +def logistic(t): + """ + Numerically stable implementation of log(1 + e^t). + """ + return jnp.maximum(t, 0) + jnp.log(1 + jnp.exp(-jnp.abs(t))) + + +def A(n, t): + """ + Log-partition function of a Bernoulli family with d-arms + where arm i has n Bernoullis with logit t_i. + """ + return n * jnp.sum(logistic(t)) + + +def dA(n, t): + """ + Gradient of the log-partition function A. + """ + return n * jax.nn.sigmoid(t) + + +def _bm_minimize( + df_func, + t, + q0, + tol, + gamma_tol, + max_iters, + q_lower, + q_upper, +): + """ + Implements the Newton algorithm to optimize: + minimize_q [t * f(q) + B(q)] + where f(q) is the objective to minimize + and B(q) is the barrier function for the constraint q >= 1, + that is, B(q) = -log(q-1). + + We assume that f is convex and has Lipschitz derivative. + The implementation is based on the Barzilai-Borwein method, + since the objective is convex with Lipschitz derivative. + + Parameters: + ----------- + df_func: function that returns the derivative of f. + t: barrier method regularization parameter. + q0: initial starting point for Newton step. + tol: convergence tolerance. + gamma_tol: largest gamma tolerance. + max_iters: max number of Newton iterations. + q_lower: lower bound of q. + q_higher: upper bound of q. + + Returns: + -------- + (q_prev, dL_prev, q, dL, iters) + + q_prev: previous solution. + dL_prev: previous derivative of objective. + q: current solution. + dL: current derivative of objective. + iters: number of iterations. + """ + + def _bm_df(q, t): + return t * df_func(q) - 1.0 / (q - 1) + + # set previous state + # make the previous sufficiently far from current while still feasible. + q_prev = q0 + jnp.maximum(1, 2 * tol) + df_prev = _bm_df(q_prev, t) + + # set current state + q = q0 + df = _bm_df(q, t) + + iter = 0 + + # returns True if it should continue descending. + def _cond_func(args): + ( + q_prev, + _, + q, + _, + iter, + ) = args + return ( + # no convergence yet + (jnp.abs(q - q_prev) > tol) + & + # not reached max iterations yet + (iter < max_iters) + & + # strictly feasible + (q_lower < q) + & + # not divergent + (q < q_upper) + ) + + # routine for gradient descent + def _body_func(args): + ( + q_prev, + df_prev, + q, + df, + iter, + ) = args + + # compute descent quantities + abs_delta_df = jnp.abs(df - df_prev) + abs_delta_u = jnp.abs(q - q_prev) + + # early exit if gamma is too large (hessian is close to 0) + # TODO: is this the right behavior? + early_exit = abs_delta_u > gamma_tol * abs_delta_df + gamma = jnp.where(early_exit, 0, abs_delta_u / abs_delta_df) + + # update previous states + q_prev = q + df_prev = df + + # update current states + # either q is still strictly feasible or forced to the boundary + q = jnp.maximum(q - gamma * df, q_lower) + df = jnp.where( + q == q_lower, + -jnp.inf, + _bm_df(q, t), + ) + + iter = iter + 1 + + return (q_prev, df_prev, q, df, iter) + + args = ( + q_prev, + df_prev, + q, + df, + iter, + ) + + args = jax.lax.while_loop( + _cond_func, + _body_func, + args, + ) + + return args + + +def _bm_check_feasible( + constraint_f, + bm_minimize, + t0, + q0, + mu, + tol, + q_lower, + q_upper, +): + """ + Checks if constraint_f is feasible, that is, + there exists a q >= 1 such that constraint_f(q) <= 0. + + It implements the barrier method to solve the problem: + find q + such that constraint_f(q) <= 0 + subject to q >= 1 + + Parameters: + ----------- + constraint_f: function to check if feasible. + bm_minimize: function that minimizes constraint_f + barrier function + and returns the optimal value. + t0: initial regularization value. + q0: initial starting point for barrier method. + Assumes that q0 is strictly feasible (q0 > 1). + mu: factor to increase regularization value. + tol: convergence tolerance. + q_lower: lower bound on q (usually == 1). + q_upper: upper bound on q. + + Returns: + -------- + (t, q, f_q, is_feasible) + t: current regularization parameter. + q: current solution. + f_q: constraint_f at q. + is_feasible: True if constraint_f is feasible. + """ + + def _cond_func(args): + (t, q, f_q) = args + return ( + # current function value is above bound + (f_q > 0.0) + & + # barrier method has not converged yet + (1.0 / t >= tol) + & + # q is strictly feasible + (q_lower < q) + & + # q is not divergent + (q < q_upper) + ) + + def _body_func(args): + (t, q, _) = args + q = bm_minimize(q, t) + t = t * mu + f_q = constraint_f(q) + return (t, q, f_q) + + f_q = constraint_f(q0) + args = (t0, q0, f_q) + args = jax.lax.while_loop( + _cond_func, + _body_func, + args, + ) + is_feasible = args[-1] <= 0.0 + return args + (is_feasible,) + + +def _qcp_bisect( + lower, + upper, + q_init, + q_hint, + is_feasible_f, + tol, +): + """ + This function uses the golden bisection method + to solve the quasiconvex minimization problem: + minimize_q f(q) + subject to q >= 1 + + Parameters: + ----------- + lower: initial lower value for bisection method. + The minimum value of f must be >= lower. + upper: initial upper value for bisection method. + The minimum value of f must be <= upper. + q_init: initial starting point. + f(q_init) must lie in the range [lower, upper]. + q_hint: initial hint to start is_feasible_f. + is_feasible_f: function that takes in (t, q_hint) + and returns (q_new, is_feasible) + where q_new is a new point that achieves a value + below the given level, t, if is_feasible is True. + If is_feasible is False, q_new is undefined. + tol: convergence tolerance. + + Returns: + -------- + (lower, upper, q, q_hint) + + lower: last lower function value below the minimum value. + upper: last upper function value above the minimum value. + q: optimal solution. + q_hint: last hint used in convex optimization. + """ + # returns True if bisection should continue + def _cond_func(args): + ( + lower, + upper, + _, + _, + ) = args + return (upper - lower) >= tol + + # routine for bisection + def _body_func(args): + ( + lower, + upper, + q, + q_hint, + ) = args + mid = (upper + lower) / 2 + ( + q_new, + is_feasible, + ) = is_feasible_f(mid, q_hint) + lower, upper, q, q_hint = jax.lax.cond( + is_feasible, + lambda: (lower, mid, q_new, q_new), + lambda: (mid, upper, q, q_hint), + ) + return (lower, upper, q, q_hint) + + args = (lower, upper, q_init, q_hint) + + args = jax.lax.while_loop( + _cond_func, + _body_func, + args, + ) + + return args + + +class BaseQCPSolver: + def __init__( + self, + n: int, + bm_t0: float = 1.0, + bm_mu: float = 10.0, + bm_tol: float = 1e-4, + cp_convg_tol: float = 1e-6, + cp_gamma_tol: float = 1e7, + cp_max_iters: int = int(1e2), + qcp_q0: float = 2.0, + qcp_convg_tol: float = 1e-3, + q_lower: float = 1.0, + q_upper: float = 1e7, + ): + if n < 0: + raise ValueError("n must be >= 0.") + if bm_t0 <= 0: + raise ValueError("bm_t0 must be positive.") + if bm_mu <= 1: + raise ValueError("bm_mu must be > 1.") + if bm_tol <= 0: + raise ValueError("bm_tol must be positive.") + if cp_convg_tol <= 0: + raise ValueError("cp_convg_tol must be positive.") + if cp_gamma_tol <= 0: + raise ValueError("cp_gamma_tol must be positive.") + if cp_max_iters < 0: + raise ValueError("cp_max_iters must be non-negative.") + if qcp_q0 < 1: + raise ValueError("qcp_q0 must be >= 1.") + if qcp_convg_tol <= 0: + raise ValueError("qcp_convg_tol must be positive.") + if q_lower < 1: + raise ValueError("q_lower must be >= 1.") + if q_upper <= q_lower: + raise ValueError("q_upper must be greater than q_lower.") + + self.n = n + self.bm_t0 = bm_t0 + self.bm_mu = bm_mu + self.bm_tol = bm_tol + self.cp_convg_tol = cp_convg_tol + self.cp_gamma_tol = cp_gamma_tol + self.cp_max_iters = cp_max_iters + self.qcp_q0 = qcp_q0 + self.qcp_convg_tol = qcp_convg_tol + self.q_lower = q_lower + self.q_upper = q_upper + + +class ForwardQCPSolver(BaseQCPSolver): + """ + This class optimizes the quasiconvex program: + For a fixed value of n, theta_0, v, a, + minimize_q L(q) + subject to q >= 1 + where + L(q) = (A(theta_0 + q * v) - A(theta_0) - np.log(a)) / q + A(theta) = n * log(1 + e^theta) (elementwise) + """ + + # ============================================================ + # Members for non-optimization routine. + # ============================================================ + + def objective(self, q, theta_0, v, a): + """ + Computes the objective function. + + Parameters: + ----------- + q: q-parameter. + theta_0: pivot point. + v: displacement from pivot point. + a: constant shift. + """ + return (self.A(theta_0 + q * v) - self.A(theta_0) - jnp.log(a)) / q + + # ============================================================ + # Members for optimization routine. + # ============================================================ + + def A(self, t): + return A(self.n, t) + + def dA(self, t): + return dA(self.n, t) + + def phi_t(self, q, t, theta_0, v): + """ + Computes phi_t(q) defined by + A(theta_0 + q * v) - t * q + This is the convex function that induces the level sets of L(q). + Specifically, for any level t, + {x : L(x) <= t} = {x : phi_t(x) <= bound} + for some appropriate bound (see self._bm_check_feasible). + """ + return self.A(theta_0 + q * v) - t * q + + def dphi_t(self, q, t, theta_0, v): + """ + Computes dphi_t(q)/dq given by + A'(theta_0 + q * v)^T v - t + """ + return jnp.sum(self.dA(theta_0 + q * v) * v) - t + + def _bm_minimize(self, q0, t_bm, t_bs, theta_0, v): + """ + Solves: + minimize_q f_t(q) + where f_t(q) is the barrier objective. + + Parameters: + ----------- + q0: initial starting point for Newton step. + t_bm: t value on the central path of barrier method. + t_bs: t value for the current level of bisection method. + theta_0: pivot point. + v: displacement from theta_0. + + Returns: + -------- + See _bm_minimize. + """ + + def _df_func(q): + return self.dphi_t(q, t_bs, theta_0, v) + + return _bm_minimize( + df_func=_df_func, + t=t_bm, + q0=q0, + tol=self.cp_convg_tol, + gamma_tol=self.cp_gamma_tol, + max_iters=self.cp_max_iters, + q_lower=self.q_lower, + q_upper=self.q_upper, + ) + + def _bm_check_feasible( + self, + t_bs, + theta_0, + v, + bound, + q_hint, + ): + """ + Checks if there exists a feasible q such that L(q) <= t_bs =: t. + """ + + def _constraint_f(q): + return self.phi_t(q, t_bs, theta_0, v) - bound + + def _bm_minimize(q, t): + out = self._bm_minimize(q, t, t_bs, theta_0, v) + return out[2] + + return _bm_check_feasible( + constraint_f=_constraint_f, + bm_minimize=_bm_minimize, + t0=self.bm_t0, + q0=q_hint, + mu=self.bm_mu, + tol=self.bm_tol, + q_lower=self.q_lower, + q_upper=self.q_upper, + ) + + def _solve(self, theta_0, v, a): + """ + Finds the minimum point for the optimization problem + for fixed theta_0, v, a. + + This function uses the golden bisection method. + + Returns: + -------- + (lower, upper, q, q_hint) + + lower: last lower function value below the minimum value. + upper: last upper function value above the minimum value. + q: optimal solution. + q_hint: last hint used in convex optimization. + """ + + # pre-compute some auxiliary quantities for reuse + A0 = self.A(theta_0) + bound = A0 + jnp.log(a) + + # theoretical bounds that contain the minimum value + lower = self.A(theta_0 + v) - A0 + upper = self.n * jnp.sum(jnp.maximum(v, 0)) + + # initial optimal value + # invariance: q achieves a value in [lower, upper]. + q = jnp.inf + + # hint for initial starting point of self._convex_feasible + q_hint = self.qcp_q0 + + def _is_feasible_f(t, q_hint): + out = self._bm_check_feasible(t, theta_0, v, bound, q_hint) + return out[1], out[3] + + return _qcp_bisect( + lower=lower, + upper=upper, + q_init=q, + q_hint=q_hint, + is_feasible_f=_is_feasible_f, + tol=self.qcp_convg_tol, + ) + + def solve(self, theta_0, v, a): + """ + Returns the optimal solution. + """ + return self._solve(theta_0, v, a)[2] + + +class BackwardQCPSolver(BaseQCPSolver): + """ + This class optimizes the quasiconvex program: + For a fixed value of n, theta_0, v, a, + minimize_q L(q) + subject to q >= 1 + where + L(q) = (q / (q-1)) * [ + (A(theta_0 + q * v) - A(theta_0)) / q + - (A(theta_0 + v) - A(theta_0)) + - np.log(a) + ] + A(theta) = n * log(1 + e^theta) (elementwise) + """ + + # ============================================================ + # Members for non-optimization routine. + # ============================================================ + + def objective(self, q, theta_0, v, a): + """ + Computes the objective function. + + Parameters: + ----------- + q: q-parameter. + theta_0: pivot point. + v: displacement from pivot point. + a: constant shift. + """ + + def _eval(q): + p = 1 / (1 - 1 / q) + A0 = self.A(theta_0) + slope_diff = (self.A(theta_0 + q * v) - A0) / q - (self.A(theta_0 + v) - A0) + return p * (slope_diff - jnp.log(a)) + + return jax.lax.cond( + q <= 1, + lambda _: jnp.where(a >= 1, 0, jnp.inf), + _eval, + q, + ) + + # ============================================================ + # Members for optimization routine. + # ============================================================ + + def A(self, t): + return A(self.n, t) + + def dA(self, t): + return dA(self.n, t) + + def phi_t(self, q, t, theta_0, v, a): + A0 = self.A(theta_0) + return ( + self.A(theta_0 + q * v) + - A0 + - q * (self.A(theta_0 + v) - A0 + jnp.log(a)) + - t * (q - 1) + ) + + def dphi_t(self, q, t, theta_0, v, a): + return ( + jnp.sum(self.dA(theta_0 + q * v) * v) + - (self.A(theta_0 + v) - self.A(theta_0) + jnp.log(a)) + - t + ) + + def _bm_minimize(self, q0, t_bm, t_bs, theta_0, v, a): + """ + Solves: + minimize_q f_t(q) + where f_t(q) is the barrier objective. + + Parameters: + ----------- + q0: initial starting point for Newton step. + t_bm: t value on the central path of barrier method. + t_bs: t value for the current level of bisection method. + theta_0: pivot point. + v: displacement from theta_0. + + Returns: + -------- + See _bm_minimize. + """ + + def _df_func(q): + return self.dphi_t(q, t_bs, theta_0, v, a) + + return _bm_minimize( + df_func=_df_func, + t=t_bm, + q0=q0, + tol=self.cp_convg_tol, + gamma_tol=self.cp_gamma_tol, + max_iters=self.cp_max_iters, + q_lower=self.q_lower, + q_upper=self.q_upper, + ) + + def _bm_check_feasible( + self, + t_bs, + theta_0, + v, + a, + q_hint, + ): + """ + Checks if there exists a feasible q such that L(q) <= t_bs =: t. + """ + + def _constraint_f(q): + return self.phi_t(q, t_bs, theta_0, v, a) + + def _bm_minimize(q, t): + out = self._bm_minimize(q, t, t_bs, theta_0, v, a) + return out[2] + + return _bm_check_feasible( + constraint_f=_constraint_f, + bm_minimize=_bm_minimize, + t0=self.bm_t0, + q0=q_hint, + mu=self.bm_mu, + tol=self.bm_tol, + q_lower=self.q_lower, + q_upper=self.q_upper, + ) + + def _solve(self, theta_0, v, a): + """ + Finds the minimum point for the optimization problem + for fixed theta_0, v, a. + + This function uses the golden bisection method. + + Returns: + -------- + (lower, upper, q, q_hint) + + lower: last lower function value below the minimum value. + upper: last upper function value above the minimum value. + q: optimal solution. + q_hint: last hint used in convex optimization. + """ + # pre-compute some auxiliary quantities for reuse + A0 = self.A(theta_0) + + # theoretical bounds that contain the minimum value + lower = -jnp.log(a) + upper = self.n * jnp.sum(jnp.maximum(v, 0)) - (self.A(theta_0 + v) - A0) + lower + + # initial optimal value + # invariance: q achieves a value in [lower, upper]. + q = jnp.inf + + # hint for initial starting point of self._convex_feasible + q_hint = self.qcp_q0 + + def _is_feasible_f(t, q_hint): + out = self._bm_check_feasible(t, theta_0, v, a, q_hint) + return out[1], out[3] + + return _qcp_bisect( + lower=lower, + upper=upper, + q_init=q, + q_hint=q_hint, + is_feasible_f=_is_feasible_f, + tol=self.qcp_convg_tol, + ) + + def solve(self, theta_0, v, a): + """ + Returns the optimal solution. + """ + return self._solve(theta_0, v, a)[2] + + +def q_holder_bound_fwd( + q, + n, + theta_0, + v, + f0, +): + """ + Computes the forward q-Holder bound given by: + f0 * exp[L(q) - (A(theta_0 + v) - A(theta_0))] + for fixed f0, n, theta_0, v, + where L, A are as given in ForwardQCPSolver. + + Parameters: + ----------- + q: q parameter. + n: scalar Binomial size parameter. + theta_0: d-array pivot point. + v: d-array displacement vector. + f0: probability value at theta_0. + """ + A0 = A(n, theta_0) + expo = (A(n, theta_0 + q * v) - A0) / q - (A(n, theta_0 + v) - A0) + return f0 ** (1 - 1 / q) * jnp.exp(expo) + + +def q_holder_bound_bwd( + q, + n, + theta_0, + v, + alpha, +): + """ + Computes the backward q-Holder bound given by: + exp(-L(q)) + where L(q) is as given in BackwardQCPSolver. + The resulting value is alpha' such that + q_holder_bound_fwd(q, n, theta_0, v, alpha') = alpha + + Parameters: + ----------- + q: q parameter. + n: scalar Binomial size parameter. + theta_0: d-array pivot point. + v: d-array displacement from pivot point. + alpha: target level. + """ + + def _bound(q): + p = q / (q - 1) + A0 = A(n, theta_0) + slope_diff = (A(n, theta_0 + q * v) - A0) / q - (A(n, theta_0 + v) - A0) + return (alpha * jnp.exp(-slope_diff)) ** p + + return jax.lax.cond( + q <= 1, + lambda _: float(alpha >= 1), + _bound, + q, + ) diff --git a/docs/tutorial/q-holder-bound.md b/docs/tutorial/q-holder-bound.md new file mode 100644 index 00000000..48c7b403 --- /dev/null +++ b/docs/tutorial/q-holder-bound.md @@ -0,0 +1,195 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.13.8 + kernelspec: + display_name: Python 3.10.6 ('confirm') + language: python + name: python3 +--- + +```python +%load_ext autoreload +%autoreload 2 +``` + +# Tutorial on q-Holder Bound + + +The q-Holder bound is the newest tight bound on Type I Error. +This notebook aims to provide the simplest example on using the q-Holder bound in `confirm`. +The q-Holder bound comes in two variations: forward and backward. +The forward mode is used as part of the "validation" step where it computes the q-Holder bound directly +given the Type I Error at the simulation point. +The backward mode is used as part of the "tuning" step where it computes the inverted forward q-Holder bound +given the desired Type I Error in the tile. + +For this tutorial, we will focus on Binomial family since it is one of the most useful applications +and requires non-trivial implementation to compute these bounds. + +```python +import jax +import jax.numpy as jnp +import numpy as np +import matplotlib.pyplot as plt +import pyimprint.grid as pygrid +import confirm.mini_imprint.grid as grid +from confirm.mini_imprint.bound import binomial as binomial +``` + +## Validation Step + + +Consider $n$ (size parameter of Binomial family), +$\theta_0$ (logit parameter of Binomial family) simulation point, $v \in H-\theta_0$ any displacement vector, +where $H$ is the tile associated with $\theta_0$. +As an example, suppose that the test has a Type I Error of $f(\theta_0)$. + +```python +n = 350 # size +theta_0 = np.array([-1., 0., 0.5]) # sim point +v = 0.1 * np.ones(theta_0.shape[0]) # displacement +f0 = 0.01 # Type I Error at theta_0 +``` + +We can compute the forward q-Holder bound by calling `q_holder_bound_fwd` with the above information and the hyperparameter $q$. + +```python +binomial.q_holder_bound_fwd( + q=2.5, n=n, theta_0=theta_0, v=v, f0=f0, +) +``` + +However, note that the bound is incredibly sensitive to the $q$-value. +In the above, we manually found a $q$ that provides decent performance, +but if we changed $q$ to a different value, the bound could potentially explode. + +```python +binomial.q_holder_bound_fwd( + q=10, n=n, theta_0=theta_0, v=v, f0=f0, +) +``` + +For this reason, we provide a JAX-based class `ForwardQCPSolver` that optimizes for $q$ +based on the other inputs. + +```python +fwd_solver = binomial.ForwardQCPSolver(n=n) +q_opt = fwd_solver.solve(theta_0=theta_0, v=v, a=f0) # optimal q +q_opt +``` + +As a sanity check, we can plot the bound as a function of $q$ and check that the optimal $q$ +indeed achieves the minimum value. + +```python +def _sanity_check_fwd_solver(): + q_grid = np.linspace(1+1e-6, 4, 1000) + bound_vmap = jax.vmap(binomial.q_holder_bound_fwd, in_axes=(0, None, None, None, None)) + bounds = bound_vmap(q_grid, n, theta_0, v, f0) + opt_bound = binomial.q_holder_bound_fwd(q_opt, n, theta_0, v, f0) + plt.plot(q_grid, bounds, '--') + plt.plot(q_opt, opt_bound, 'r.') +_sanity_check_fwd_solver() +``` + +So far, we are able to tightly bound $f(\theta_0 + v)$ for a fixed $v$ based on $\theta_0, f(\theta_0)$ and an optimal choice of $q$. +However, we would like to find a tight bound on for all $v \in H-\theta_0$. +Luckily, we can prove that the q-Holder bound takes its maximum on one of the corners of $H-\theta_0$ so long as the objective +is separable and the tile is rectangular (if not, we can embed the tile in a rectangle and find a further upper bound by maximizing on the rectangle). + +The following shows an example for computing the maximum on a tile. + +```python +# Create corners of the tile with a given max radius. +radius = 0.1 +v_coords = [[-1., 1.]] * theta_0.shape[0] +mgrid = np.meshgrid(*v_coords, indexing='ij') +vs = radius * np.concatenate([coord.reshape(-1,1) for coord in mgrid], axis=1) +vs +``` + +```python +def q_holder_bound_fwd_tile(n, theta_0, vs, f0, fwd_solver): + # vectorize fwd_solver over v + fwd_solver_vmap_v = jax.vmap( + fwd_solver.solve, + in_axes=(None, 0, None), + ) + q_opts = fwd_solver_vmap_v(theta_0, vs, f0) + + # compute bounds over q_opt, v + bound_vmap = jax.vmap( + binomial.q_holder_bound_fwd, + in_axes=(0, None, None, 0, None), + ) + bounds = bound_vmap( + q_opts, n, theta_0, vs, f0, + ) + + # find the maximin of the bounds at corners + i_max = jnp.argmax(bounds) + return vs[i_max], q_opts[i_max], bounds[i_max] +``` + +```python +v_opt, q_opt, bound_opt = q_holder_bound_fwd_tile( + n=n, theta_0=theta_0, vs=vs, f0=f0, fwd_solver=fwd_solver, +) +v_opt, q_opt, bound_opt +``` + +### Main Workflow + + +The main workflow is to apply this technique in parallel on many tiles. +For each tile (and its corresponding simulation point), +we would like to optimize for $q$ based on the worse corner. + +The following is an example of a workflow. +We start with an array of simulation points `thetas` and the radius that defines the boundaries of the rectangular tile `radii`. +For this example, we are using the helper function `make_cartesian_grid_range`, but any `thetas, radii` will do. +The vertices for each tile are explicitly computed using `radii`. +Assume that we have access to the Type I Error values at each of the `thetas`. + +```python +gr = pygrid.make_cartesian_grid_range( + size=100, + lower=-np.ones(theta_0.shape[0]), + upper=np.ones(theta_0.shape[0]), + grid_sim_size=0, # dummy for now +) +thetas = gr.thetas().T +radii = gr.radii().T +f0s = np.full(thetas.shape[0], 0.025) # dummy values +``` + +```python +hypercube = grid.hypercube_vertices( + theta_0.shape[0], +) +make_vertices = jax.vmap( + lambda r: r * hypercube, + in_axes=(0,), +) +vertices = make_vertices(radii) +``` + +Finally, we vectorize the routine from before to get the best bound for the worse corner for each tile. + +```python +q_holder_bound_fwd_tile_jvmap = jax.jit(jax.vmap( + lambda n, t, v, f0: q_holder_bound_fwd_tile(n, t, v, f0, fwd_solver)[-1], + in_axes=(None, 0, 0, 0), +)) +``` + +```python +bounds = q_holder_bound_fwd_tile_jvmap( + n, thetas, vertices, f0s, +) +``` diff --git a/imprint/.vscode/build.sh b/imprint/.vscode/build.sh old mode 100755 new mode 100644 index 43dadd87..70f3c4af --- a/imprint/.vscode/build.sh +++ b/imprint/.vscode/build.sh @@ -2,4 +2,4 @@ eval "$(conda shell.bash hook)" conda activate imprint bazel build -c opt --config gcc //python:pyimprint/core.so -cp -f ./bazel-bin/python/pyimprint/core.so python/pyimprint/ +cp -f ./bazel-bin/python/pyimprint/core.so python/pyimprint/ \ No newline at end of file diff --git a/research/q-holder-bound/qcp-solver.ipynb b/research/q-holder-bound/qcp-solver.ipynb new file mode 100644 index 00000000..f2405bf9 --- /dev/null +++ b/research/q-holder-bound/qcp-solver.ipynb @@ -0,0 +1,587 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "import cvxpy as cp\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import jax\n", + "import jax.numpy as jnp\n", + "\n", + "import confirm.mini_imprint.bound.binomial as binomial\n", + "from pyimprint.grid import make_cartesian_grid_range" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Optimizing q for Exponential Holder Bound" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "def A_cp(n, t):\n", + " return n * cp.sum(cp.logistic(t))\n", + "\n", + "def opt_q_cp(n, theta_0, v, a):\n", + " '''\n", + " CVXPY implementation of finding optimal q\n", + " ''' \n", + " A0 = binomial.A(n, theta_0)\n", + " q = cp.Variable(pos=True)\n", + " objective_fn = (\n", + " (A_cp(n, theta_0 + (q+1) * v) - A0)\n", + " - np.log(a)\n", + " ) / (q + 1)\n", + " objective = cp.Minimize(objective_fn)\n", + " problem = cp.Problem(objective)\n", + " problem.solve(qcp=True)\n", + " return q.value + 1 " + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "theta_0 = jnp.array([-2., -1., 0.3])\n", + "n = 350\n", + "f0 = 0.025\n", + "v = 0.1 * jnp.array([0.4, 1, -1.32])" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "solver = binomial.ForwardQCPSolver(n)\n", + "solve_jit = jax.jit(solver.solve)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 509 ms, sys: 0 ns, total: 509 ms\n", + "Wall time: 200 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "q_opt = solve_jit(theta_0, v, f0)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 172 ms, sys: 0 ns, total: 172 ms\n", + "Wall time: 171 ms\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jhyang/mambaforge/envs/confirm/lib/python3.10/site-packages/cvxpy/problems/problem.py:1337: UserWarning: Solution may be inaccurate. Try another solver, adjusting the solver settings, or solve with verbose=True for more information.\n", + " warnings.warn(\n", + "/home/jhyang/mambaforge/envs/confirm/lib/python3.10/site-packages/cvxpy/problems/problem.py:1337: UserWarning: Solution may be inaccurate. Try another solver, adjusting the solver settings, or solve with verbose=True for more information.\n", + " warnings.warn(\n", + "/home/jhyang/mambaforge/envs/confirm/lib/python3.10/site-packages/cvxpy/problems/problem.py:1337: UserWarning: Solution may be inaccurate. Try another solver, adjusting the solver settings, or solve with verbose=True for more information.\n", + " warnings.warn(\n", + "/home/jhyang/mambaforge/envs/confirm/lib/python3.10/site-packages/cvxpy/problems/problem.py:1337: UserWarning: Solution may be inaccurate. Try another solver, adjusting the solver settings, or solve with verbose=True for more information.\n", + " warnings.warn(\n", + "/home/jhyang/mambaforge/envs/confirm/lib/python3.10/site-packages/cvxpy/problems/problem.py:1337: UserWarning: Solution may be inaccurate. Try another solver, adjusting the solver settings, or solve with verbose=True for more information.\n", + " warnings.warn(\n", + "/home/jhyang/mambaforge/envs/confirm/lib/python3.10/site-packages/cvxpy/problems/problem.py:1337: UserWarning: Solution may be inaccurate. Try another solver, adjusting the solver settings, or solve with verbose=True for more information.\n", + " warnings.warn(\n", + "/home/jhyang/mambaforge/envs/confirm/lib/python3.10/site-packages/cvxpy/problems/problem.py:1337: UserWarning: Solution may be inaccurate. Try another solver, adjusting the solver settings, or solve with verbose=True for more information.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "%%time\n", + "q_opt_qcp_cvxpy = opt_q_cp(n, theta_0, v, f0)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "qs = jnp.linspace(1.0001, 10, 100)\n", + "phis = np.array([\n", + " solver.objective(q, theta_0, v, f0) for q in qs\n", + "]) \n", + "plt.plot(qs, phis)\n", + "plt.plot(q_opt, solver.objective(q_opt, theta_0, v, f0), 'bo')\n", + "plt.plot(q_opt_qcp_cvxpy, solver.objective(q_opt_qcp_cvxpy, theta_0, v, f0), 'r^')" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [], + "source": [ + "solver = binomial.ForwardQCPSolver(n)\n", + "solve_vmap_jit = jax.jit(jax.vmap(solver.solve, in_axes=(0, 0, None)))\n", + "\n", + "def vectorize_run(key, m, d, a=0.025, n=350):\n", + " theta_0 = jax.random.normal(key, (m, d))\n", + " _, key = jax.random.split(key)\n", + " v = 0.001 * jax.random.normal(key, (m, d))\n", + " return solve_vmap_jit(theta_0, v, a)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 1.84 s, sys: 0 ns, total: 1.84 s\n", + "Wall time: 1.24 s\n" + ] + } + ], + "source": [ + "%%time\n", + "qs = vectorize_run(\n", + " jax.random.PRNGKey(10),\n", + " 10000,\n", + " 3,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(qs[~np.isinf(qs)], bins=30)\n", + "print(np.sum(np.isinf(qs)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Optimizing q for Implicit Exponential Holder Bound" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "def qcp_solve_bwd(n, theta_0, v, alpha):\n", + " A0 = binomial.A(n, theta_0)\n", + " shift = (binomial.A(n, theta_0 + v) - A0) + np.log(alpha)\n", + " q = cp.Variable(pos=True)\n", + " objective_fn = (\n", + " (A_cp(n, theta_0 + (q+1) * v) - A0)\n", + " - (q+1) * shift\n", + " ) / q\n", + " objective = cp.Minimize(objective_fn)\n", + " problem = cp.Problem(objective)\n", + " problem.solve(qcp=True)\n", + " return q.value + 1, problem.value" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "n = 350\n", + "theta_0 = -0.1\n", + "v = 0.005\n", + "alpha = 0.025" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [], + "source": [ + "solver_bwd = binomial.BackwardQCPSolver(n)\n", + "solve_bwd_jit = jax.jit(solver_bwd.solve)" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "solve_bwd_vmap_jit = jax.jit(jax.vmap(solver_bwd.solve, in_axes=(0, 0, None)))\n", + "\n", + "def vectorize_run_bwd(key, m, d, a=0.025, n=350):\n", + " theta_0 = jax.random.normal(key, (m, d))\n", + " _, key = jax.random.split(key)\n", + " v = 0.001 * jax.random.normal(key, (m, d))\n", + " return solve_bwd_vmap_jit(theta_0, v, a)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 2.29 s, sys: 0 ns, total: 2.29 s\n", + "Wall time: 1.37 s\n" + ] + } + ], + "source": [ + "%%time\n", + "qs = vectorize_run_bwd(\n", + " jax.random.PRNGKey(69),\n", + " 10000,\n", + " 3\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(qs, bins=50)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 763 ms, sys: 0 ns, total: 763 ms\n", + "Wall time: 492 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "opt_q = solve_bwd_jit(theta_0, v, alpha)" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.021995207 0.021994945\n" + ] + } + ], + "source": [ + "opt_bound = binomial.q_holder_bound_bwd(opt_q, n, theta_0, v, alpha)\n", + "\n", + "# brute force search method\n", + "qs = np.linspace(1.01, 1000, 1000)\n", + "bound_bwd_f = jax.vmap(binomial.q_holder_bound_bwd, in_axes=(0, None, None, None, None))\n", + "bounds = bound_bwd_f(qs, n, theta_0, v, alpha)\n", + "i_max = np.argmax(bounds)\n", + "\n", + "# plot\n", + "plt.plot(qs, bounds)\n", + "plt.plot(qs[i_max], bounds[i_max], 'r^')\n", + "plt.plot(opt_q, opt_bound, 'b.')\n", + "plt.show()\n", + "\n", + "print(bounds[i_max], opt_bound)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Combine Both Forward and Backward" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [], + "source": [ + "n = 350\n", + "theta_0 = -0.1\n", + "v = 0.01\n", + "alpha = 0.005" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(DeviceArray(0.005, dtype=float32),\n", + " 0.005,\n", + " DeviceArray(0.00367232, dtype=float32))" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Backward solve the implicit bound at theta_0\n", + "solver_bwd = binomial.BackwardQCPSolver(n)\n", + "opt_q_bwd = solver_bwd.solve(theta_0, v, alpha)\n", + "alpha_prime = binomial.q_holder_bound_bwd(\n", + " opt_q_bwd, n, theta_0, v, alpha\n", + ")\n", + "\n", + "# Forward evaluate to get bound on f(theta_0 + v)\n", + "bound = binomial.q_holder_bound_fwd(\n", + " opt_q_bwd, n, theta_0, v, alpha_prime\n", + ")\n", + "bound, alpha, alpha_prime" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Optimize for v" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "n = 350\n", + "theta_0 = -1.0\n", + "vs = np.linspace(-1, 1, 100)\n", + "bound_vs_f = jax.vmap(binomial.q_holder_bound_fwd, in_axes=(None, None, None, 0, None))\n", + "bound_vs = bound_vs_f(2, n, theta_0, vs, f0)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(vs, bound_vs)" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "q = 20\n", + "def g(v, theta_0, q):\n", + " return jnp.sum(binomial.logistic(theta_0 + q * v) / q - binomial.logistic(theta_0 + v))\n", + "theta_0 = jnp.array([-0.2, -0.1])\n", + "d = theta_0.shape[0]\n", + "v_1d_len = 100\n", + "vs = make_cartesian_grid_range(v_1d_len, -10*np.ones(d), 10*np.ones(d), 0).thetas().T\n", + "g_vmap = jax.vmap(g, in_axes=(0, None, None))\n", + "gs = g_vmap(vs, theta_0, q)\n", + "\n", + "# find max\n", + "i_max = jnp.argmax(gs)\n", + "\n", + "sc = plt.scatter(vs[:,0], vs[:,1], c=gs)\n", + "plt.scatter(vs[i_max, 0], vs[i_max, 1], c='r')\n", + "plt.colorbar(sc)\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 ('confirm')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.6" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "5d574717a19d12573763700bcd6833eaae2108879723021a1c549979ef70be90" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/research/q-holder-bound/qcp-solver.md b/research/q-holder-bound/qcp-solver.md new file mode 100644 index 00000000..c9437a73 --- /dev/null +++ b/research/q-holder-bound/qcp-solver.md @@ -0,0 +1,242 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.13.8 + kernelspec: + display_name: Python 3.10.6 ('confirm') + language: python + name: python3 +--- + +```python +%load_ext autoreload +%autoreload 2 +``` + +```python +import cvxpy as cp +import numpy as np +import matplotlib.pyplot as plt +import jax +import jax.numpy as jnp + +import confirm.mini_imprint.bound.binomial as binomial +from pyimprint.grid import make_cartesian_grid_range +``` + +## Optimizing q for Exponential Holder Bound + +```python +def A_cp(n, t): + return n * cp.sum(cp.logistic(t)) + +def opt_q_cp(n, theta_0, v, a): + ''' + CVXPY implementation of finding optimal q + ''' + A0 = binomial.A(n, theta_0) + q = cp.Variable(pos=True) + objective_fn = ( + (A_cp(n, theta_0 + (q+1) * v) - A0) + - np.log(a) + ) / (q + 1) + objective = cp.Minimize(objective_fn) + problem = cp.Problem(objective) + problem.solve(qcp=True) + return q.value + 1 +``` + +```python +theta_0 = jnp.array([-2., -1., 0.3]) +n = 350 +f0 = 0.025 +v = 0.1 * jnp.array([0.4, 1, -1.32]) +``` + +```python +solver = binomial.ForwardQCPSolver(n) +solve_jit = jax.jit(solver.solve) +``` + +```python +%%time +q_opt = solve_jit(theta_0, v, f0) +``` + +```python +%%time +q_opt_qcp_cvxpy = opt_q_cp(n, theta_0, v, f0) +``` + +```python +qs = jnp.linspace(1.0001, 10, 100) +phis = np.array([ + solver.objective(q, theta_0, v, f0) for q in qs +]) +plt.plot(qs, phis) +plt.plot(q_opt, solver.objective(q_opt, theta_0, v, f0), 'bo') +plt.plot(q_opt_qcp_cvxpy, solver.objective(q_opt_qcp_cvxpy, theta_0, v, f0), 'r^') +``` + +```python +solver = binomial.ForwardQCPSolver(n) +solve_vmap_jit = jax.jit(jax.vmap(solver.solve, in_axes=(0, 0, None))) + +def vectorize_run(key, m, d, a=0.025, n=350): + theta_0 = jax.random.normal(key, (m, d)) + _, key = jax.random.split(key) + v = 0.001 * jax.random.normal(key, (m, d)) + return solve_vmap_jit(theta_0, v, a) +``` + +```python +%%time +qs = vectorize_run( + jax.random.PRNGKey(10), + 10000, + 3, +) +``` + +```python +plt.hist(qs[~np.isinf(qs)], bins=30) +print(np.sum(np.isinf(qs))) +``` + +## Optimizing q for Implicit Exponential Holder Bound + +```python +def qcp_solve_bwd(n, theta_0, v, alpha): + A0 = binomial.A(n, theta_0) + shift = (binomial.A(n, theta_0 + v) - A0) + np.log(alpha) + q = cp.Variable(pos=True) + objective_fn = ( + (A_cp(n, theta_0 + (q+1) * v) - A0) + - (q+1) * shift + ) / q + objective = cp.Minimize(objective_fn) + problem = cp.Problem(objective) + problem.solve(qcp=True) + return q.value + 1, problem.value +``` + +```python +n = 350 +theta_0 = -0.1 +v = 0.005 +alpha = 0.025 +``` + +```python +solver_bwd = binomial.BackwardQCPSolver(n) +solve_bwd_jit = jax.jit(solver_bwd.solve) +``` + +```python +solve_bwd_vmap_jit = jax.jit(jax.vmap(solver_bwd.solve, in_axes=(0, 0, None))) + +def vectorize_run_bwd(key, m, d, a=0.025, n=350): + theta_0 = jax.random.normal(key, (m, d)) + _, key = jax.random.split(key) + v = 0.001 * jax.random.normal(key, (m, d)) + return solve_bwd_vmap_jit(theta_0, v, a) +``` + +```python +%%time +qs = vectorize_run_bwd( + jax.random.PRNGKey(69), + 10000, + 3 +) +``` + +```python +plt.hist(qs, bins=50) +plt.show() +``` + +```python +%%time +opt_q = solve_bwd_jit(theta_0, v, alpha) +``` + +```python +opt_bound = binomial.q_holder_bound_bwd(opt_q, n, theta_0, v, alpha) + +# brute force search method +qs = np.linspace(1.01, 1000, 1000) +bound_bwd_f = jax.vmap(binomial.q_holder_bound_bwd, in_axes=(0, None, None, None, None)) +bounds = bound_bwd_f(qs, n, theta_0, v, alpha) +i_max = np.argmax(bounds) + +# plot +plt.plot(qs, bounds) +plt.plot(qs[i_max], bounds[i_max], 'r^') +plt.plot(opt_q, opt_bound, 'b.') +plt.show() + +print(bounds[i_max], opt_bound) +``` + +## Combine Both Forward and Backward + +```python +n = 350 +theta_0 = -0.1 +v = 0.01 +alpha = 0.005 +``` + +```python +# Backward solve the implicit bound at theta_0 +solver_bwd = binomial.BackwardQCPSolver(n) +opt_q_bwd = solver_bwd.solve(theta_0, v, alpha) +alpha_prime = binomial.q_holder_bound_bwd( + opt_q_bwd, n, theta_0, v, alpha +) + +# Forward evaluate to get bound on f(theta_0 + v) +bound = binomial.q_holder_bound_fwd( + opt_q_bwd, n, theta_0, v, alpha_prime +) +bound, alpha, alpha_prime +``` + +## Optimize for v + +```python +n = 350 +theta_0 = -1.0 +vs = np.linspace(-1, 1, 100) +bound_vs_f = jax.vmap(binomial.q_holder_bound_fwd, in_axes=(None, None, None, 0, None)) +bound_vs = bound_vs_f(2, n, theta_0, vs, f0) +``` + +```python +plt.plot(vs, bound_vs) +``` + +```python +q = 20 +def g(v, theta_0, q): + return jnp.sum(binomial.logistic(theta_0 + q * v) / q - binomial.logistic(theta_0 + v)) +theta_0 = jnp.array([-0.2, -0.1]) +d = theta_0.shape[0] +v_1d_len = 100 +vs = make_cartesian_grid_range(v_1d_len, -10*np.ones(d), 10*np.ones(d), 0).thetas().T +g_vmap = jax.vmap(g, in_axes=(0, None, None)) +gs = g_vmap(vs, theta_0, q) + +# find max +i_max = jnp.argmax(gs) + +sc = plt.scatter(vs[:,0], vs[:,1], c=gs) +plt.scatter(vs[i_max, 0], vs[i_max, 1], c='r') +plt.colorbar(sc) +plt.show() +``` diff --git a/research/q-holder-bound/tight_holder_binom.ipynb b/research/q-holder-bound/tight_holder_binom.ipynb new file mode 100644 index 00000000..fa6c4903 --- /dev/null +++ b/research/q-holder-bound/tight_holder_binom.ipynb @@ -0,0 +1,353 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Tight Bounds for Binomial" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import jax\n", + "import jax.numpy as jnp\n", + "import numpy as np\n", + "import scipy\n", + "from scipy.stats import norm, beta\n", + "import matplotlib.pyplot as plt\n", + "import cvxpy as cp\n", + "import confirm.mini_imprint.bound.binomial as binomial" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook studies the behavior of a collection of bounds in a simple binomial test setting.\n", + "Consider $X \\sim Binom(n, p(\\theta))$ where $n$ is fixed, $\\theta \\in \\mathbb{R}$ is the natural parameter,\n", + "and $p(\\theta)$ is the sigmoid function.\n", + "For a fixed critical threshold $t^*$, we reject if $X > t^*$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Taylor Bound" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def f(theta, n, t):\n", + " return scipy.stats.binom.sf(t, n, scipy.special.expit(theta))\n", + " \n", + "def df(theta, n, t):\n", + " p = scipy.special.expit(theta)\n", + " return scipy.stats.binom.expect(\n", + " lambda x: (x > t) * (x - n*p),\n", + " args=(n, p),\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def taylor_bound(f0, df0, vs, theta_0, n):\n", + " p = scipy.special.expit(theta_0)\n", + " return f0 + df0 * vs + 0.5 * vs**2 * n * p * (1-p)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Centered Holder Bound" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def copt(a, p):\n", + " return 1 / (1 + ((1-a)/a)**(1/(p-1)))\n", + "\n", + "def C_numerical(n_arm_samples, t, hp, hq):\n", + " p = scipy.special.expit(t)\n", + " xs = np.arange(n_arm_samples + 1).astype(np.float64)\n", + " eggq = np.abs(xs - n_arm_samples * p[:, None]) ** hq\n", + " return np.sum(eggq * scipy.stats.binom.pmf(xs, n_arm_samples, p[:, None]), axis=-1) ** (1 / hq)\n", + " \n", + "def holder_bound(f0, n_arm_samples, theta_0, vs, hp, hc='opt'):\n", + " if isinstance(hp, np.ndarray):\n", + " bounds = np.array([holder_bound(f0, n_arm_samples, theta_0, vs, hpi, hc) for hpi in hp])\n", + " return np.min(bounds, axis=0)\n", + " if hc == 'opt':\n", + " hc = copt(f0, hp)\n", + " hq = 1 / (1 - 1 / hp)\n", + " B = hc ** hp\n", + " A = (1 - hc) ** hp - B\n", + " Cs = [\n", + " scipy.integrate.quadrature(\n", + " lambda h: np.abs(v) * C_numerical(n_arm_samples, theta_0 + h * v, hp, hq),\n", + " 0.0,\n", + " 1.0,\n", + " )[0]\n", + " for v in vs\n", + " ]\n", + " Cs = np.maximum.accumulate(Cs)\n", + " return 1/A * (A*Cs / hq + (A*f0 + B)**(1/hq))**hq - B/A" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exponential Holder Improved" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def log_partition(t, n):\n", + " return n * jnp.log(1 + jnp.exp(t))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def exp_holder_impr_bound_(f0, n, theta_0, vs, q):\n", + " A0 = log_partition(theta_0, n)\n", + " bounds = f0**(1-1/q) * np.exp(\n", + " (log_partition(theta_0 + q * vs, n) - A0) / q\n", + " - (log_partition(theta_0 + vs, n) - A0)\n", + " )\n", + " return bounds\n", + "\n", + "def exp_holder_impr_bound(f0, n, theta_0, vs, q = 'inf'):\n", + " if isinstance(q, np.ndarray):\n", + " bounds = np.array([exp_holder_impr_bound_(f0, n, theta_0, vs, qi)[1] for qi in q])\n", + " order = np.argmin(bounds, axis=0)\n", + " return q[order], bounds[order, np.arange(0, len(order))]\n", + " elif q == 'inf' or (isinstance(q, float) and np.isinf(q)): \n", + " return None, f0 * np.exp(n*vs - log_partition(theta_0 + vs, n) + log_partition(theta_0, n))\n", + " elif q == 'opt':\n", + " solver = binomial.ForwardQCPSolver(n, qcp_convg_tol=1e-4)\n", + " q_solver = jax.jit(jax.vmap(solver.solve, in_axes=(None, 0, None)))\n", + " qs = q_solver(theta_0, vs, f0)\n", + " bounds_f = jax.vmap(binomial.q_holder_bound_fwd, in_axes=(0, None, None, 0, None))\n", + " bounds = bounds_f(qs, n, theta_0, vs, f0)\n", + " return qs, bounds\n", + " bounds = exp_holder_impr_bound_(f0, n, theta_0, vs, q)\n", + " return None, bounds" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Performance Comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "n = 350\n", + "theta_0 = -0.5\n", + "theta_boundary = 0\n", + "v_max = theta_boundary - theta_0\n", + "n_steps = 100\n", + "alpha = 0.025\n", + "p_boundary = scipy.special.expit(theta_boundary)\n", + "thresh = np.sqrt(n*p_boundary*(1-p_boundary)) * scipy.stats.norm.isf(alpha) + n*p_boundary" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "f0 = f(theta_0, n, thresh)\n", + "df0 = df(theta_0, n, thresh)\n", + "vs = np.linspace(1e-8, v_max, n_steps)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "def run(theta_0, n, f0, df0, vs, thresh, hp, hc, q='inf'):\n", + " # compute true Type I Error\n", + " thetas = theta_0 + vs\n", + " fs = f(thetas, n, thresh)\n", + "\n", + " # compute taylor bound\n", + " taylor_bounds = taylor_bound(f0, df0, vs, theta_0, n)\n", + "\n", + " # compute holder centered bound\n", + " holder_bounds = [holder_bound(f0, n, theta_0, vs, hp, c) for c in hc]\n", + " \n", + " # compute exp holder impr bound\n", + " qs, exp_holder_impr_bounds = exp_holder_impr_bound(f0, n, theta_0, vs, q)\n", + "\n", + " # plot everything\n", + " plt.plot(thetas, fs, ls='--', color='black', label='True TIE')\n", + " plt.plot(thetas, taylor_bounds, ls='-', label='taylor')\n", + " for i, c in enumerate(hc):\n", + " plt.plot(thetas, holder_bounds[i], ls='--', label=f'centered-holder({c}), p={hp}')\n", + " plt.plot(thetas, exp_holder_impr_bounds, ls=':', label='exp-holder-impr')\n", + " plt.ylim(np.maximum(np.min(fs)-1e-7, 0), np.max(exp_holder_impr_bounds)+1e-7)\n", + " plt.legend()\n", + " plt.show()\n", + " \n", + " return qs" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "qs = run(\n", + " theta_0=theta_0,\n", + " n=n,\n", + " f0=f0,\n", + " df0=df0,\n", + " vs=vs,\n", + " thresh=thresh,\n", + " hp=1.1,\n", + " hc=['opt'],\n", + " q='opt',\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "solver = binomial.ForwardQCPSolver(n)\n", + "q_opt = solver.solve(theta_0, vs[-1], f0)\n", + "qs_plt = np.linspace(1.00001, 100, 1000)\n", + "objs = [solver.objective(q, theta_0, vs[-1], f0) for q in qs_plt]\n", + "plt.plot(qs_plt, objs)\n", + "plt.plot(q_opt, solver.objective(q_opt, theta_0, vs[-1], f0), 'r.')" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(19.950722, DeviceArray(19.95071, dtype=float32))" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.min(objs), solver.objective(q_opt, theta_0, vs[-1], f0)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 ('confirm')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.6" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "5d574717a19d12573763700bcd6833eaae2108879723021a1c549979ef70be90" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/research/q-holder-bound/tight_holder_binom.md b/research/q-holder-bound/tight_holder_binom.md new file mode 100644 index 00000000..f2ce76b2 --- /dev/null +++ b/research/q-holder-bound/tight_holder_binom.md @@ -0,0 +1,198 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.13.8 + kernelspec: + display_name: Python 3.10.6 ('confirm') + language: python + name: python3 +--- + +# Tight Bounds for Binomial + +```python +%load_ext autoreload +%autoreload 2 +``` + +```python +import jax +import jax.numpy as jnp +import numpy as np +import scipy +from scipy.stats import norm, beta +import matplotlib.pyplot as plt +import cvxpy as cp +import confirm.mini_imprint.bound.binomial as binomial +``` + +This notebook studies the behavior of a collection of bounds in a simple binomial test setting. +Consider $X \sim Binom(n, p(\theta))$ where $n$ is fixed, $\theta \in \mathbb{R}$ is the natural parameter, +and $p(\theta)$ is the sigmoid function. +For a fixed critical threshold $t^*$, we reject if $X > t^*$. + + +## Taylor Bound + +```python +def f(theta, n, t): + return scipy.stats.binom.sf(t, n, scipy.special.expit(theta)) + +def df(theta, n, t): + p = scipy.special.expit(theta) + return scipy.stats.binom.expect( + lambda x: (x > t) * (x - n*p), + args=(n, p), + ) +``` + +```python +def taylor_bound(f0, df0, vs, theta_0, n): + p = scipy.special.expit(theta_0) + return f0 + df0 * vs + 0.5 * vs**2 * n * p * (1-p) +``` + +## Centered Holder Bound + +```python +def copt(a, p): + return 1 / (1 + ((1-a)/a)**(1/(p-1))) + +def C_numerical(n_arm_samples, t, hp, hq): + p = scipy.special.expit(t) + xs = np.arange(n_arm_samples + 1).astype(np.float64) + eggq = np.abs(xs - n_arm_samples * p[:, None]) ** hq + return np.sum(eggq * scipy.stats.binom.pmf(xs, n_arm_samples, p[:, None]), axis=-1) ** (1 / hq) + +def holder_bound(f0, n_arm_samples, theta_0, vs, hp, hc='opt'): + if isinstance(hp, np.ndarray): + bounds = np.array([holder_bound(f0, n_arm_samples, theta_0, vs, hpi, hc) for hpi in hp]) + return np.min(bounds, axis=0) + if hc == 'opt': + hc = copt(f0, hp) + hq = 1 / (1 - 1 / hp) + B = hc ** hp + A = (1 - hc) ** hp - B + Cs = [ + scipy.integrate.quadrature( + lambda h: np.abs(v) * C_numerical(n_arm_samples, theta_0 + h * v, hp, hq), + 0.0, + 1.0, + )[0] + for v in vs + ] + Cs = np.maximum.accumulate(Cs) + return 1/A * (A*Cs / hq + (A*f0 + B)**(1/hq))**hq - B/A +``` + +## Exponential Holder Improved + +```python +def log_partition(t, n): + return n * jnp.log(1 + jnp.exp(t)) +``` + +```python +def exp_holder_impr_bound_(f0, n, theta_0, vs, q): + A0 = log_partition(theta_0, n) + bounds = f0**(1-1/q) * np.exp( + (log_partition(theta_0 + q * vs, n) - A0) / q + - (log_partition(theta_0 + vs, n) - A0) + ) + return bounds + +def exp_holder_impr_bound(f0, n, theta_0, vs, q = 'inf'): + if isinstance(q, np.ndarray): + bounds = np.array([exp_holder_impr_bound_(f0, n, theta_0, vs, qi)[1] for qi in q]) + order = np.argmin(bounds, axis=0) + return q[order], bounds[order, np.arange(0, len(order))] + elif q == 'inf' or (isinstance(q, float) and np.isinf(q)): + return None, f0 * np.exp(n*vs - log_partition(theta_0 + vs, n) + log_partition(theta_0, n)) + elif q == 'opt': + solver = binomial.ForwardQCPSolver(n, qcp_convg_tol=1e-4) + q_solver = jax.jit(jax.vmap(solver.solve, in_axes=(None, 0, None))) + qs = q_solver(theta_0, vs, f0) + bounds_f = jax.vmap(binomial.q_holder_bound_fwd, in_axes=(0, None, None, 0, None)) + bounds = bounds_f(qs, n, theta_0, vs, f0) + return qs, bounds + bounds = exp_holder_impr_bound_(f0, n, theta_0, vs, q) + return None, bounds +``` + +## Performance Comparison + +```python +n = 350 +theta_0 = -0.5 +theta_boundary = 0 +v_max = theta_boundary - theta_0 +n_steps = 100 +alpha = 0.025 +p_boundary = scipy.special.expit(theta_boundary) +thresh = np.sqrt(n*p_boundary*(1-p_boundary)) * scipy.stats.norm.isf(alpha) + n*p_boundary +``` + +```python +f0 = f(theta_0, n, thresh) +df0 = df(theta_0, n, thresh) +vs = np.linspace(1e-8, v_max, n_steps) +``` + +```python +def run(theta_0, n, f0, df0, vs, thresh, hp, hc, q='inf'): + # compute true Type I Error + thetas = theta_0 + vs + fs = f(thetas, n, thresh) + + # compute taylor bound + taylor_bounds = taylor_bound(f0, df0, vs, theta_0, n) + + # compute holder centered bound + holder_bounds = [holder_bound(f0, n, theta_0, vs, hp, c) for c in hc] + + # compute exp holder impr bound + qs, exp_holder_impr_bounds = exp_holder_impr_bound(f0, n, theta_0, vs, q) + + # plot everything + plt.plot(thetas, fs, ls='--', color='black', label='True TIE') + plt.plot(thetas, taylor_bounds, ls='-', label='taylor') + for i, c in enumerate(hc): + plt.plot(thetas, holder_bounds[i], ls='--', label=f'centered-holder({c}), p={hp}') + plt.plot(thetas, exp_holder_impr_bounds, ls=':', label='exp-holder-impr') + plt.ylim(np.maximum(np.min(fs)-1e-7, 0), np.max(exp_holder_impr_bounds)+1e-7) + plt.legend() + plt.show() + + return qs +``` + +```python +qs = run( + theta_0=theta_0, + n=n, + f0=f0, + df0=df0, + vs=vs, + thresh=thresh, + hp=1.1, + hc=['opt'], + q='opt', +) +``` + +```python +solver = binomial.ForwardQCPSolver(n) +q_opt = solver.solve(theta_0, vs[-1], f0) +qs_plt = np.linspace(1.00001, 100, 1000) +objs = [solver.objective(q, theta_0, vs[-1], f0) for q in qs_plt] +plt.plot(qs_plt, objs) +plt.plot(q_opt, solver.objective(q_opt, theta_0, vs[-1], f0), 'r.') +``` + +```python +np.min(objs), solver.objective(q_opt, theta_0, vs[-1], f0) +``` diff --git a/research/q-holder-bound/tight_holder_gaussian.ipynb b/research/q-holder-bound/tight_holder_gaussian.ipynb new file mode 100644 index 00000000..74438d32 --- /dev/null +++ b/research/q-holder-bound/tight_holder_gaussian.ipynb @@ -0,0 +1,636 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exponential Holder Bound" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import jax\n", + "import numpy as np\n", + "import scipy\n", + "from scipy.stats import norm, beta\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook studies the behavior of the \"exponential Hölder bound\".\n", + "Let us consider the simple z-test:\n", + "\\begin{align*}\n", + " X &\\sim N(\\theta, 1) \\\\\n", + " H_0: \\theta \\leq 0 &\\quad H_1: \\theta > 0\n", + "\\end{align*}\n", + "with $\\sigma$ known.\n", + "\n", + "The most powerful test is the usual one given by $\\phi(x) = 1$ if $x > z_{1-\\alpha}$,\n", + "where $z_{1-\\alpha}$ is the $1-\\alpha$ quantile of the standard normal distribution.\n", + "Then, the Type I Error function is\n", + "\\begin{align*}\n", + " f(\\theta) &:= 1-\\Phi\\left(z_{1-\\alpha}-\\theta\\right) \\\\\n", + " \\nabla f(\\theta) &= \\phi\\left(z_{1-\\alpha}-\\theta\\right)\n", + "\\end{align*}\n", + "where $\\theta$ is the natural parameter\n", + "and $\\Phi(\\theta), \\phi(\\theta)$ are the CDF, PDF of thise standard normal distribution, respectively.\n", + "\n", + "We will compare this new bound with the other bounds developed previously." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following are general helper functions that will be used throughout the notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def simulate(theta_0, n_sims, alpha):\n", + " '''\n", + " Simulates the model described above n_sims times under theta_0\n", + " and computes the Type I sum and score with optimal threshold\n", + " at level alpha.\n", + " '''\n", + " xs = np.random.normal(theta_0, 1, n_sims)\n", + " z_crit = norm.ppf(1 - alpha)\n", + " rejs = xs > z_crit\n", + " typeI_sum = np.sum(rejs)\n", + " typeI_score = np.sum((xs - theta_0) * rejs)\n", + " return typeI_sum, typeI_score" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Taylor Bound" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The first upper bound we revisit is the Taylor bound.\n", + "The Taylor bound is given by\n", + "\\begin{align*}\n", + " f(\\theta_0 + v)\n", + " &\\leq\n", + " f(\\theta_0) + \\nabla f(\\theta_0) v + U_R(v)\n", + "\\end{align*}\n", + "where\n", + "\\begin{align*}\n", + " \\int_0^1 (1-\\alpha) \\frac{d^2}{d\\theta^2} f(\\theta_0+\\alpha v) v^2 d\\alpha \\leq U_R(v)\n", + "\\end{align*}\n", + "for some convex function $U_R$.\n", + "By Lemma 9 in the draft of paper, we may take\n", + "\\begin{align*}\n", + " U_R(v) = \\frac{1}{2} v^2\n", + "\\end{align*}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The empirical upper bound estimate must take into account the randomness of our zeroth and first order terms.\n", + "The empirical upper bound is given by:\n", + "\\begin{align*}\n", + " \\hat{U}(\\theta_0+v)\n", + " &=\n", + " \\hat{U}_0 + \\hat{\\Delta}(v) + U_R(v)\n", + " \\\\\n", + " \\hat{\\Delta}(v) \n", + " &= \n", + " \\frac{1}{N} \\sum\\limits_{i=1}^N (X_i-\\theta_0) F(X_i)v + \n", + " \\frac{1}{2} \\sqrt{\\frac{v^2}{N} \\left(\\frac{1}{\\delta_2} - 1 \\right)}\n", + "\\end{align*}\n", + "where $\\hat{U}_0$ is the Clopper-Pearson estimate at $\\theta_0$ with confidence $1-\\delta_1$,\n", + "$F(x)$ is the indicator that the test falsely rejects with data $x$ generated from $\\theta_0$,\n", + "and $N$ is the number of simulations." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def taylor_bound(f0, df0, vs):\n", + " '''\n", + " Computes the Taylor upper bound with true Type I Error and its gradient.\n", + " '''\n", + " return f0 + df0 * vs + (1 / 2) * vs**2\n", + "\n", + "def taylor_bound_est(typeI_sum, typeI_score, nsims, vs, delta=0.025, delta_prop_0to1=0.5):\n", + " '''\n", + " Computes the Taylor upper bound with estimates and accounting for their error.\n", + " '''\n", + " f0 = beta.ppf(1 - (delta * delta_prop_0to1), typeI_sum + 1, nsims - typeI_sum)\n", + "\n", + " grad_est = typeI_score / nsims * vs\n", + " covars = vs**2\n", + " grad_bound = 0.5 * np.sqrt(covars / nsims * (1 / ((1 - delta_prop_0to1) * delta) - 1))\n", + "\n", + " hess_bound = covars / 2\n", + "\n", + " return f0 + (grad_est + grad_bound) + hess_bound" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Hölder Bound (Centered)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The centered Hölder bound centered by $c$ with conjugates $p, q \\geq 1$ is given by\n", + "\\begin{align*}\n", + " f(\\theta_0 + v)\n", + " &\\leq\n", + " \\frac{1}{A} \\left(\\frac{A C_q}{q} + (A f(\\theta_0) + B)^{\\frac{1}{q}}\\right)^q - \\frac{B}{A}\n", + " \\\\\n", + " C_q \n", + " &:= \n", + " \\sup\\limits_{v \\in H-\\theta_0} \\int_0^1 || \\frac{d}{dh} \\log p_{\\theta_0+hv}(X)||_{L^q(P_{\\theta_0+hv})} dh\n", + " \\\\\n", + " p &:= \\frac{q}{q-1} \\\\\n", + " A &:= (1-c)^p - c^p \\\\\n", + " B &:= c^p \n", + "\\end{align*}\n", + "\n", + "We simplify $C_q$.\n", + "\\begin{align*}\n", + " \\log p_{\\theta}(x) &= - \\frac{(x-\\theta)^2}{2} + C\n", + " \\\\ \\implies\n", + " \\frac{d}{dh} \\log p_{\\theta_0+hv}(x) \n", + " &=\n", + " (x-(\\theta_0+hv))v\n", + " \\\\ \\implies\n", + " ||\\frac{d}{dh} \\log p_{\\theta_0+hv}(X)||_{L^q}\n", + " &=\n", + " |v| \\cdot \\mathbb{E}\\left[|Z|^q \\right]^\\frac{1}{q}\n", + "\\end{align*}\n", + "By simple calculus, one can show\n", + "\\begin{align*}\n", + " ||Z||_{L^q}\n", + " &=\n", + " \\sqrt{2} \\left(\\frac{\\Gamma\\left(\\frac{q+1}{2}\\right)}{\\sqrt{\\pi}}\\right)^{\\frac{1}{q}}\n", + "\\end{align*}\n", + "Hence,\n", + "\\begin{align*}\n", + " C_q = ||Z||_{L^q} \\sup\\limits_{v \\in H-\\theta_0} |v|\n", + "\\end{align*}\n", + "\n", + "Finally, we have the following as the optimal choice for the centering\n", + "\\begin{align*}\n", + " c^* := \\frac{1}{1 + \\left(\\frac{1-f(\\theta_0)}{f(\\theta_0)}\\right)^{\\frac{1}{p-1}}}\n", + "\\end{align*}" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "def z_lq(q):\n", + " frac = scipy.special.gamma((q+1)/2) / np.sqrt(np.pi)\n", + " return np.sqrt(2) * frac**(1/q)\n", + "\n", + "def C_q(vs, q):\n", + " return z_lq(q) * vs\n", + " \n", + "def copt(f0, p):\n", + " return 1/(1 + ((1-f0) / f0)**(1/(p-1)))\n", + "\n", + "def holder_bound(f0, vs, hp, hc='opt'):\n", + " if isinstance(hp, list) or isinstance(hp, np.ndarray):\n", + " bounds = np.array([holder_bound(f0, vs, hpp, hc) for hpp in hp])\n", + " return np.min(bounds, axis=0)\n", + " if hc == 'opt':\n", + " hc = copt(f0, hp)\n", + " hq = 1 / (1 - 1 / hp)\n", + " B = hc**hp\n", + " A = (1-hc)**hp - B\n", + " C = C_q(vs, hq)\n", + " return 1/A * (A*C/hq + (A*f0 + B)**(1/hq))**hq - B/A" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exponential Hölder Bound" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The exponential Hölder bound is given by\n", + "\\begin{align*}\n", + "f(\\theta_0 + v)\n", + "&\\leq\n", + "1 - (1-f(\\theta_0)) \\exp\\left[-\\frac{\\nabla f(\\theta_0)^\\top v}{1-f(\\theta_0)} - S(v)\\right]\n", + "\\end{align*}\n", + "where\n", + "\\begin{align*}\n", + "S(v) := A(\\theta_0+v) - A(\\theta_0) - \\nabla A(\\theta_0)^\\top v\n", + "\\end{align*}\n", + "and $A$ is the log-partition function.\n", + "In the Gaussian data case,\n", + "\\begin{align*}\n", + "A(\\theta) := \\frac{\\theta^2}{2}\n", + "\\end{align*}\n", + "This gives us\n", + "\\begin{align*}\n", + "S(v) \n", + "&= \\frac{1}{2} \\left((\\theta_0+v)^2 - \\theta_0^2\\right) - \\theta_0 v\n", + "= \\frac{v (2\\theta_0+v)}{2} - \\theta_0 v\n", + "= \\frac{v^2}{2}\n", + "\\end{align*}" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "def exp_holder_bound(f0, df0, vs):\n", + " f0c = 1 - f0\n", + " Svs = vs**2 / 2\n", + " expos = df0 * vs / f0c + Svs\n", + " return 1 - f0c * np.exp(-expos)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exponential Holder Improved?" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "def exp_holder_impr_bound(f0, vs):\n", + " return np.exp(-0.5 * (vs - np.sqrt(-2*np.log(f0)))**2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Performance Comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [], + "source": [ + "theta_0 = -1\n", + "v_max = 1\n", + "n_steps = 20\n", + "alpha = 0.1" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [], + "source": [ + "z_crit = norm.ppf(1-alpha)\n", + "f0 = 1-norm.cdf(z_crit - theta_0)\n", + "df0 = norm.pdf(z_crit - theta_0) \n", + "vs = np.linspace(0, v_max, n_steps)" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [], + "source": [ + "def run(theta_0, f0, df0, vs, alpha, z_crit, hp, hc):\n", + " # compute true Type I Error\n", + " thetas = theta_0 + vs\n", + " fs = 1-norm.cdf(z_crit - thetas)\n", + "\n", + " # compute taylor bound\n", + " taylor_bounds = taylor_bound(f0, df0, vs)\n", + "\n", + " # compute holder centered bound\n", + " holder_bounds = [holder_bound(f0, vs, hp, c) for c in hc]\n", + "\n", + " # compute exp holder bound\n", + " exp_holder_bounds = exp_holder_bound(f0, df0, vs)\n", + " \n", + " # compute exp holder impr bound\n", + " exp_holder_impr_bounds = exp_holder_impr_bound(f0, vs)\n", + "\n", + " # plot everything\n", + " plt.plot(thetas, fs, ls='--', color='black', label='True TIE')\n", + " plt.plot(thetas, taylor_bounds, ls='-', label='taylor')\n", + " for i, c in enumerate(hc):\n", + " plt.plot(thetas, holder_bounds[i], ls='--', label=f'centered-holder({c})')\n", + " plt.plot(thetas, exp_holder_bounds, ls='-.', label='exp-holder')\n", + " plt.plot(thetas, exp_holder_impr_bounds, ls=':', label='exp-holder-impr')\n", + " plt.legend()\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We first compare the performance of all the methods with various centering for centered-Holder method.\n", + "Since exponential Holder bound is inherently a Cauchy-Schwarz bound,\n", + "we first compare with $p = 2$ for centered-Holder." + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "run(\n", + " theta_0=theta_0,\n", + " f0=f0,\n", + " df0=df0,\n", + " vs=vs,\n", + " alpha=alpha,\n", + " z_crit=z_crit,\n", + " hp=[1.1, 1.15, 1.2, 1.25, 1.3, 1.35],\n", + " hc=['opt'],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that from $\\theta_0$ (leftmost point), if we increase the tile size all the way until it hits the origin\n", + "(boundary of the null hypothesis), the exponential Holder bound does far worse than the centered Holder bound.\n", + "However, it is still uniformly better than the classical Taylor bound.\n", + "\n", + "Zooming in on a smaller region around $\\theta_0$, we get the following:" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "v_max = 0.01\n", + "vs = np.linspace(0, v_max, n_steps)\n", + "run(\n", + " theta_0=theta_0,\n", + " f0=f0,\n", + " df0=df0,\n", + " vs=vs,\n", + " alpha=alpha,\n", + " z_crit=z_crit,\n", + " hp=np.arange(1.01, 10, 0.01),\n", + " hc=['opt'],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we see that the exponential Holder is actually performing better than the optimally centered Holder method with $p=2$\n", + "in a smaller region around $\\theta_0$.\n", + "Moreover, the Taylor expansion is nearly identical to the exponential Holder.\n", + "\n", + "From a previous study, $p=1.2$ gave a good estimate for an improved bound for the centered Holder method.\n", + "The following shows the bound with $p=1.2$." + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "run(\n", + " theta_0=theta_0,\n", + " f0=f0,\n", + " df0=df0,\n", + " vs=vs,\n", + " alpha=alpha,\n", + " z_crit=z_crit,\n", + " hp=np.arange(1.01, 10, 0.01),\n", + " hc=['opt'],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The centered Holder bound is asymptotically performing better than the exponential Holder bound and Taylor bound.\n", + "However, for tile size of about $0.003$ (the usual gridding radius we consider in practice),\n", + "the two are nearly indistinguishable." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we consider what happens when $\\theta_0$ is closer to the boundary (when Type I Error at the simulation point is larger)." + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj4AAAGdCAYAAAASUnlxAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAACuuklEQVR4nOzdd3xN9//A8de9N3uKhBBkoBV7RO0UpVYHVa3x/Rltjegg9qqtqFG11R5tbYqq2YpRW62iqFErMSIyZN3c+/n9cblcGXIjMd/Px+M+mnPO53PO+9y6ue98zmdolFIKIYQQQohXgPZZByCEEEII8bRI4iOEEEKIV4YkPkIIIYR4ZUjiI4QQQohXhiQ+QgghhHhlSOIjhBBCiFeGJD5CCCGEeGVI4iOEEEKIV4bNsw7geWI0Grl27Rqurq5oNJpnHY4QQgghMkEpRWxsLD4+Pmi1GbfpSOLzkGvXrlGoUKFnHYYQQgghsuDy5csULFgwwzKS+DzE1dUVML1xbm5uzzgaIYQQQmRGTEwMhQoVMn+PZ0QSn4fcf7zl5uYmiY8QQgjxgslMNxXp3CyEEEKIV4YkPkIIIYR4ZUjiI4QQQohXhvTxsZJSipSUFAwGw7MORYinTqfTYWNjI9M9CCFeWJL4WCE5OZnw8HDi4+OfdShCPDNOTk7kz58fOzu7Zx2KEEJYTRKfTDIajVy4cAGdToePjw92dnbyV694pSilSE5O5ubNm1y4cIHXXnvtsROFCSHE80YSn0xKTk7GaDRSqFAhnJycnnU4QjwTjo6O2Nra8t9//5GcnIyDg8OzDkkIIawif65ZSf7CFa86+QwIIV5k8htMCCGEEK8MSXyEEEII8cqQxEcIIYQQrwxJfF5yGo0mw1e7du2eqzg0Gg2//PLLY+stWbLkqcQthBDi5SKjul5y4eHh5p+XLl3KoEGDOH36tHmfo6OjRXm9Xo+tre0zj+Nh8+bNo0GDBhb7cuXKle0xCiGEePlJi082uHv3brqvxMTETJdNSEjIVFlr5MuXz/xyd3dHo9GYtxMTE8mVKxfLli2jVq1aODg48OOPPzJkyBDKlStncZ7vv/8ef39/i33z5s2jePHiODg4EBgYyLRp07IUx/196cmVK5dF2Xz58skwaiGEEFkiLT7ZwMXFJd1jjRo1Yv369ebtvHnzpjvzc82aNQkLCzNv+/v7c+vWrVTllFJZDzYNffr0Yfz48cybNw97e3tmzpz52DqzZs1i8ODBTJkyhfLly3P48GE6dOiAs7Mzbdu2zdb4hBBCvMDOb4fwo1C9y7OOBJDERwChoaE0bdrUqjrDhw9n/Pjx5noBAQGcPHmSH374IdsTn5YtW6LT6Sz2HTt2jMKFC2frdYQQQmQjowF2jIWw0aZtn/IQEPxsY0ISn2wRFxeX7rFHv7Bv3LiRbtlHJ4a7ePHiE8WVWRUrVrSq/M2bN7l8+TKfffYZHTp0MO9PSUnJ8JFVVk2YMIG6deta7CtUqFC2X0cIIUQ2ibsBqzrA+TDTdvnWUCDomYZ0nyQ+2cDZ2fmZl30Sj15Hq9Wmepym1+vNPxuNRsD0uKty5coW5R5N9LJDvnz5KFq0aLafVwghRA64uAtWfAZxEWDrBO98B+VaPuuozCTxEankyZOHiIgIlFLmhViPHDliPu7t7U2BAgU4f/48//vf/55RlEIIIZ47u6fAloGgjJAnED5aAHkDn3VUFiTxEanUqlWLmzdvMmbMGJo1a8bGjRvZsGEDbm5u5jJDhgyhS5cuuLm50bBhQ5KSkjh48CBRUVF07949W+O5c+cOERERFvtcXV2fWouYEEKITHLKbUp6yraEd8aD3fP3e1qGs4tUihcvzrRp05g6dSply5Zl//799OzZ06JM+/btmT17NvPnz6d06dLUrFmT+fPnExAQkO3xfPLJJ+TPn9/iNXny5Gy/jhBCiCzQPzQVS7lW0O43aDL9uUx6AFBZMHXqVOXv76/s7e1VhQoV1I4dOzIsHxYWpipUqKDs7e1VQECAmj59usXxmTNnqho1aqhcuXKpXLlyqTp16qh9+/ZZlBk8eLACLF7e3t4WZVauXKnq1aunPD09FaAOHz5s1X1FR0crQEVHR6c6lpCQoE6ePKkSEhKsOqcQLxv5LAghlFJKGQxK7Zyg1ITSSsXdeqahZPT9/SirW3yWLl1KaGgoAwYM4PDhwwQHB9OwYUMuXbqUZvkLFy7QqFEjgoODOXz4MP3796dLly6sXLnSXCYsLIyWLVuybds29uzZg6+vL/Xq1ePq1asW5ypZsiTh4eHm1/Hjxy2O3717l+rVqzN69Ghrb0sIIYQQmRV/Gxa3gK2D4c5/cHTxs44o0zRKWTcbXuXKlalQoQLTp0837ytevDhNmjRh1KhRqcr36dOHtWvXcurUKfO+kJAQjh49yp49e9K8hsFgwMPDgylTptCmTRvA1Kfkl19+sehkm56LFy8SEBDA4cOHU81AnJGYmBjc3d2Jjo626M8CkJiYyIULFwgICJBZg8UrTT4LQrziLh+A5e0g5gro7KHhtxDUDu4NhnkWMvr+fpRVLT7JyckcOnSIevXqWeyvV68eu3fvTrPOnj17UpWvX78+Bw8etBgi/bD4+Hj0ej25c+e22H/27Fl8fHwICAigRYsWnD9/3prwU0lKSiImJsbiJYQQQog0KGUatTWvgSnpyV0Y2m+Fip8806THWlYlPrdu3cJgMODt7W2x39vbO9Wom/siIiLSLJ+SkpLmcgwAffv2pUCBAhaT1lWuXJmFCxeyadMmZs2aRUREBNWqVSMyMtKaW7AwatQo3N3dzS+ZFE8IIYRIx54psHkAGFOg5AfQcTvkL/Oso7JalkZ1aR7J7NRD871ktnxa+wHGjBnD4sWLWbVqlUUzesOGDfnwww8pXbo0devWNa9/tWDBgqzcAgD9+vUjOjra/Lp8+XKWzyWEEEK81Cq0Mc3N02gcNJsHDhk/UnpeWTWPj5eXFzqdLlXrzo0bN1K16tyXL1++NMvb2Njg6elpsX/cuHGMHDmSrVu3UqZMxlmks7MzpUuX5uzZs9bcggV7e3vs7e2zXF8IIYR4aSkFZ7fAa2+bHmU5uEPILtDZZul0sdu2kXD4CHm7d8vmQK1jVYuPnZ0dQUFBbNmyxWL/li1bqFatWpp1qlatmqr85s2bqVixIra2D968sWPHMnz4cDZu3JiptaOSkpI4deoU+fPnt+YWhBBCCPE4CXdgWWv4+SM4OOfB/iwmPcpo5Nb0GUTOnEnczl3ZE2MWWT1zc/fu3WndujUVK1akatWqzJw5k0uXLhESEgKYHh9dvXqVhQsXAqYRXFOmTKF79+506NCBPXv2MGfOHBYvfjD0bcyYMQwcOJCff/4Zf39/cwuRi4sLLi4uAPTs2ZP33nsPX19fbty4wYgRI4iJibFYCfz27dtcunSJa9euAXD69GnA1OqUL1++rLw/QgghxKvl2hFY3haiLoI2a4nOozRaLQXGjeXOsmU4Va6ULefMsqxMFDR16lTl5+en7OzsVIUKFdT27dvNx9q2batq1qxpUT4sLEyVL19e2dnZKX9//1QTGPr5+aWanBBQgwcPNpdp3ry5yp8/v7K1tVU+Pj6qadOm6sSJExbnmTdv3mPPkxGZwDDz5s2bp9zd3Z91GOIZkM+CEC8po1GpfTOVGual1GA3pSaUUurKwSyeyqhu//yzilqxIpuDTJs1ExhaPY/Py+xlncenVq1alCtXju+//z7bzjl//nxCQ0O5c+dOtp1TvBhe5M+CECIdiTGwrgucWG3aLvYONJkKjh5ZOl3Mli1c/aoLGgcHCv+6DruCBbMx2DSuZ8U8PrJIqXhm9Hq9RT8vIYQQz8iNk3ByDWhtoO5QqPrFE83N41qnDi61a+NUuRK2Pj7ZGOiTk0VKX3Lt2rVj+/btTJw4EY1Gg0aj4dy5c3z22WcEBATg6OhIsWLFmDhxornOjh07sLW1TTUar0ePHrz55pvpXmv69OkUKVIEOzs7ihUrxqJFiyyOazQaZsyYQePGjXF2dmbEiBHZe7NCCCGyxreKaZj6Jxuh2pdWJz1KrydqyVKUwQCY+vQUnDYVz3bt0Gifr1RDWnyegFKKBL3hmVzb0VaX4dxJ902cOJEzZ85QqlQphg0bBoCHhwcFCxZk2bJleHl5sXv3bjp27Ej+/Pn5+OOPefPNNylcuDCLFi2iV69eAKSkpPDjjz+muw7a6tWr6dq1K99//z1169bl119/5ZNPPqFgwYLUrl3bXG7w4MGMGjWKCRMmoNPpsuGdEEIIYbWkWNjQF6p3gTzFTPve+CxLp1JKcaljR+L37MVwJwqve4OdMvMd9SxI4vMEEvQGSgza9EyufXJYfZzsHv+/z93dHTs7O5ycnCxGtg0dOtT8c0BAALt372bZsmV8/PHHAHz22WfMmzfPnPisX7+e+Ph48/FHjRs3jnbt2vH5558DptF/e/fuZdy4cRaJT6tWrfj000+tv2EhhBDZI+Jv06ityH8h4ih03AFP0Cqj0Whwf78xiSdPYVe4cDYGmjOer/Yn8dTMmDGDihUrkidPHlxcXJg1axaXLl0yH2/Xrh3//vsve/fuBWDu3Ll8/PHHODs7p3m+U6dOUb16dYt91atXt1icFsjUHE1CCCFygFJwaAHMrmNKelx9TI+3spD0GOLiSL5y1bzt3qQxRTZuwO2RtTmfR9Li8wQcbXWcHFb/mV07q5YtW0a3bt0YP348VatWxdXVlbFjx7Jv3z5zmbx58/Lee+8xb948ChcuzG+//UZYWFiG583MUibpJU5CCCFyUFIcrO8Ox5aatovWhQ9mgrNnxvXSkHj6NFe++BKtiwv+y5aitbNDo9Fg45G1EWBPmyQ+T0Cj0WTqcdOzZmdnh8HwoC/Szp07qVatmvmxFMC5c+dS1Wvfvj0tWrSgYMGCFClSJFWLzsOKFy/Orl27aNOmjXnf7t27KV68eDbdhRBCiCyJuQYLG8OtM6DRwVtfQ/XQLD/e0nl4YLx7F5QiJTwcOz+/7I03hz3/39riifn7+7Nv3z4uXryIi4sLRYsWNa90HxAQwKJFizhw4AABAQEW9erXr4+7uzsjRowwd4xOT69evfj444+pUKECderUYd26daxatYqtW7fm5K0JIYR4HOc84JgbXPNDs7ngl/YSUxkxJiaivTdvl23evBSa+QN2/v7oXF2zO9ocJ318XgE9e/ZEp9NRokQJ8uTJQ4MGDWjatCnNmzencuXKREZGWrT+3KfVamnXrh0Gg8GiJSctTZo0YeLEiYwdO5aSJUvyww8/MG/ePGrVqpVDdyWEECJdyXchJdn0s84WPpoPnXZmKemJ2bKFf+vUJeHoUfM+x9KlX8ikB0Bmbn7Iyzpz85Po0KED169fZ+3atc86FPGceFU/C0K8MG78Yxq1VaQONBj5xKe72r0HMb/9hmvDBhScMCEbAsx+MnOzeGLR0dEcOHCAn376iTVr1jzrcIQQQmTG0SXwazfQx5tWWK/ZK8vLTtyXb8hg7F9/Hc9PP8meGJ8xSXxEmho3bsz+/fvp1KkTb7/99rMORwghREaS42FDLzj8o2m7cC1oOsvqpEcpRdSiH0m5dYu83bsBoHNzwyukUzYH/OxI4iPS9Lih60IIIZ4TN8+YHm3dOAlooFY/eLMnaK2f9iTh8BGujzQ9HnN9uy6OpUtnc7DPniQ+QgghxIsqJQkWvg+x4eCcFz6cDYVrZvl0ThXKk/uTT7AtWACHUqWyMdDnhyQ+QgghxIvKxh4ajIKDc6HpbHD1tqq6MTmZ23Pn4vF/rdG5mCaY9e7TOycifW5I4iOEEEK8SG79C3dvgl9V03bJD6BEE6tXVAe42q07cb//TvKFi/h8m/Yi1C8bmcdHCCGEeFH8vRJm1oRlrSE24sH+LK6E7vnpJ+i8vHCt/2yWX3oWpMVHCCGEeN7pE2FTP9MjLYD8ZbN0GsOdOyRfuYpjqZIAOAUFUXTLZrSOjtkV6XNPEh8hhBDieRZ5zjRqK+I4oIHgHqaRWzrrvsKTzp3j0mftUSkpFF7zCzaepgVKn2bScyMmkZhEPUXzPrtZn+VRl3hp+Pv78/3336d7/OLFi2g0Go4cOZKj1wHTAra//PLLE13nvtOnT5MvXz5iY2Oz5XwZmTJlCu+//36OX0cIkUl/r4IfapqSHidP+L8VUGeg1UkPgK2PD1oXZ7TOThiionIg2IxtOhFBvYmb6bToEAnJhsdXyCGS+IhskZlkQGTNgAED+OKLL3DN5nVx0krOOnTowIEDB9i1a1e2XksIkUVnNkFyLPhWg5BdULSuVdVTbt82/6x1dKTQ9OkUXrUK+6JFszvSdMUnp9Bz5T66/t6b5LxTsbNR3I5PfmrXf5QkPuK5kpz87D4Mz5P778OVK1dYu3Ytn3zydKaKt7e3p1WrVkyePPmpXE8I8RjvjIe3h0PbdeDmY1XV6F/Xc+7tekSvX2/eZ1eoEFpn5+yOMl3Hrtyh/rQFbLjdE1v3w9g4hNO3qQ0Fcj27PkWS+LwijEYj3377LUWLFsXe3h5fX1+++eYbAK5evUrz5s3x8PDA09OTxo0bc/HiRXPddu3a0aRJE8aNG0f+/Pnx9PTkiy++QK/XA1CrVi3+++8/unXrhkajQfPQ6ILdu3fz5ptv4ujoSKFChejSpQt37941H/f392fEiBG0a9cOd3d3OnTokKl6N27c4L333sPR0ZGAgAB++umnTL8X58+fp3bt2jg5OVG2bFn27NljcXzlypWULFkSe3t7/P39GT9+fIbnO3v2LG+++SYODg6UKFGCLVu2pCqT2fd41KhR+Pj48PrrrwOwbNkyypYtS8GCBa2K0d/fn+HDh9OqVStcXFzw8fGxSGb8/f0B+OCDD9BoNOZtgPfff59ffvmFhISEDO9bCJEDTvwCK9uD0WjatneB6l2y9Ggr+fw5jHfvEr12LU97PXKDUTF52z98vGwwUbkmorW7g5d9fhY2XEjNQsFPNZZUlDCLjo5WgIqOjk51LCEhQZ08eVIlJCSkrpgUl/4rOcGKsvGZK5sFvXv3Vh4eHmr+/Pnq33//VTt37lSzZs1Sd+/eVa+99pr69NNP1bFjx9TJkydVq1atVLFixVRSUpJSSqm2bdsqNzc3FRISok6dOqXWrVunnJyc1MyZM5VSSkVGRqqCBQuqYcOGqfDwcBUeHq6UUurYsWPKxcVFTZgwQZ05c0b9+eefqnz58qpdu3bmuPz8/JSbm5saO3asOnv2rDp79mym6jVs2FCVKlVK7d69Wx08eFBVq1ZNOTo6qgkTJqT7Hly4cEEBKjAwUP3666/q9OnTqlmzZsrPz0/p9XqllFIHDx5UWq1WDRs2TJ0+fVrNmzdPOTo6qnnz5lnEfP86BoNBlSpVStWqVUsdPnxYbd++XZUvX14BavXq1Uoplen32MXFRbVu3Vr9/fff6vjx40oppRo3bqxCQkIs7iOzMbq6uqpRo0ap06dPq0mTJimdTqc2b96slFLqxo0bClDz5s1T4eHh6saNG+a6cXFxSqPRqLCwsDTfxww/C0KIrNEnKrW+p1KD3UyvI4uzdBqj0fjgZ71e3V6yVBnv/X57Wq5ExavGP6xWxac3UKXml1Kl5pdSPbf1UbFJsTl2zYy+vx8lic9Dspz43P+Hmtbrx2aWZUfkS7/s3EaWZb8NSLuclWJiYpS9vb2aNWtWqmNz5sxRxYoVs/iwJCUlKUdHR7Vp0yallOlL2c/PT6WkpJjLfPTRR6p58+bm7YeTgftat26tOnbsaLFv586dSqvVmt9HPz8/1aRJE6vqnT59WgFq79695uOnTp1SQKYSn9mzZ5v3nThxQgHq1KlTSimlWrVqpd5++22Ler169VIlSpRI8143bdqkdDqdunz5svn4hg0bLBKfzL7H3t7e5kTovrJly6phw4ZZ7MtsjA0aNLAo07x5c9WwYUPz9sMxPup+kpwWSXyEyGaR55Wa8eaD3/FbBiuVYl2yYkxJUTdn/KAuf/mVxe+ap23N4Suq1NihquTc8qrU/FKq4sIqasP5DTl+XWsSH3nU9Qo4deoUSUlJ1KlTJ9WxQ4cO8e+//+Lq6oqLiwsuLi7kzp2bxMREzp07Zy5XsmRJdLoHC97lz5+fGzduZHjdQ4cOMX/+fPN5XVxcqF+/PkajkQsXLpjLVaxY0ap6p06dwsbGxqJeYGAguXLlMm+HhIRY1H9YmTJlLO4DMN/LqVOnqF69ukX56tWrc/bsWQyG1KMQTp06ha+vr8WjqKpVq6a6n8y8x6VLl8bOzs6ibkJCAg4ODqmumZkYH42jatWqnDp1KtU9pMXR0ZH4+PhMlRVCPIGTa02jtsKPgGNuaLUc6g6x+tFW8qVL3Jo6ldgtW7i7Y0eOhJqR2EQ93ZcdoefvoyDPcjRaPWU8g1jXdDUNAho89XgyIvP4ZIf+19I/pnlkddxe/2ZQ9pE8NPR41mN6iGMGczQYjUaCgoLS7COTJ08e88+2trYWxzQaDcb7z6AzOHenTp3o0qVLqmO+vr7mn50f6Wj3uHqnT582x5CeYcOG0bNnzzSPPXwv989x/16UUqnOqzJ4Np7WsUfrZ/Y9fvR9APDy8iLqkWGn1saYUWzpuX37tkVsQogcsHM8/D7M9HOhytBsLrgXzLhOOuwDAvDu3w+NrR3Ob76ZjUE+3qH/bhO69AiXbyegs6+AbZ4DfF6uE5+Wbof20e+154AkPtnBzooe8jlVNgOvvfYajo6O/P7777Rv397iWIUKFVi6dCl58+bFzc0ty9ews7NL1SJSoUIFTpw4QVErh00+rl7x4sVJSUnh4MGDVKpUCTDNdXPnzh1zmbx585I3b17rbgIoUaJEqqHcu3fv5vXXX7do8Xq4/KVLl7h27Ro+PqYRF492ln6S97h8+fKcPHkySzHu3bvXoszevXsJDAw0b9va2qbZinXu3DkSExMpX768VbEKIaxUuBaEjYbKIVBnEOhsH1vlPmNCAje/n0juNq2xLVAAAI8WLXIo0LSlGIxM+P0kM/dvRh9XjAK5HPm+RROK+TTDzS7r3yc57flLxUS2c3BwoE+fPvTu3ZuFCxdy7tw59u7dy5w5c/jf//6Hl5cXjRs3ZufOnVy4cIHt27fTtWtXrly5kulr+Pv7s2PHDq5evcqtW7cA6NOnD3v27OGLL77gyJEjnD17lrVr1/LVV19leK7H1StWrBgNGjSgQ4cO7Nu3j0OHDtG+ffsMW7Yyq0ePHvz+++8MHz6cM2fOsGDBAqZMmZJu61HdunUpVqwYbdq04ejRo+zcuZMBAwZYlHmS97h+/frs2bPHIkHJbIx//vknY8aM4cyZM0ydOpXly5fTtWtX83F/f39+//13IiIiLFqVdu7cSeHChSlSpEim3zchRCZFP/SZLxAEX/0F9YZblfQARAwdxu0FC7jap89TH7EFcCkyng9/+IN5F0KxL7iA2mXi2RAazBv+uZ/rpAck8XllDBw4kB49ejBo0CCKFy9O8+bNuXHjBk5OTuzYsQNfX1+aNm1K8eLF+fTTT0lISLCqdWLYsGFcvHiRIkWKmB+RlClThu3bt3P27FmCg4MpX748AwcONPerSU9m6s2bN49ChQpRs2ZNmjZtSseOHbPUwvOoChUqsGzZMpYsWUKpUqUYNGgQw4YNo127dmmW12q1rF69mqSkJCpVqkT79u3N0wTc9yTvcaNGjbC1tWXr1q1Wx9ijRw8OHTpE+fLlGT58OOPHj6f+QwsRjh8/ni1btlCoUCGL1p3FixebpxUQQmSTlGTY2B8mB0H4sQf7cxXK0um8vvgcu4AAvDp3zvQj7OyglGLloSs0nLiDo5eS0Ol9cLF1o1PtQrg5WJe8PSsa9SxSxedUTEwM7u7uREdHp/pCSkxM5MKFCwQEBKTqbCpETpo2bRpr1qxh06ZNma7j7+9PaGgooaGhVl3r77//pk6dOpw5cwZ3d/c0y8hnQQgrRf0HKz6Bq4dM2/VGQLWMW74flRIZScLx47jWqmXepwwGNGk8gs8p0fF6eqzewe8nI1EGZyr552Z40yJ4uerwdPR8anGkJaPv70dJHx8hnnMdO3YkKiqK2NjYbF+24lHXrl1j4cKF6SY9Qggr/fMb/BICidHgkAs+mAHFGlp1iuQrV7nYogXG2Fj8ly/D4d4Ep08z6dlzLpIuaxeQ4LYUx/z+fF5iBJ1rFUWnfXqtTdlFEh8hnnM2Njap+g3llHr16j2V6wjx0ktJht+Hwp4ppu0CQfDRfMjlm2G1tNgW8MGhRHFSwsOf6mMtgOQUI99uOspP/07CNvdBNEARnxRaV8/7QiY9IImPEC+lh5fDEEI8A0cXP0h6qn4JdQaDjV3GdR6SfOkStj4+aGxs0Gg0FBgzBo2DA9qn+Hj53M04Qpav4prtXGxzRQIa2hb/hK5BX2JrZWfs54kkPkIIIUR2K/9/cH4blP4IAt+xquqd1b8QMXQonh07kOfzzwHQPTRBa05TSvHTvouM3D0Zbe7f0WqM5LLLy4Ta31IxX8XHn+A5J4mPEEII8aQMetg3A95oD7aOoNWZHm1lgUanRSUmkvDXYZTRiEb79AZg376bTNcVWzkUPxWd5yUA3ipYn+HBg577YeqZJYmPEEII8STuXIYVn8KV/XDrLLw/yepTqORkNPeWrHF//320rq641Kz5VJOebf9cp/uGOejdV6JzSsZO48SQagN5r+i7Ty2GpyFL7+i0adPMQ1mDgoLYuXNnhuW3b99OUFAQDg4OFC5cmBkzZlgcnzVrFsHBwXh4eODh4UHdunXZv3+/RZkhQ4ag0WgsXvny5bMoo5RiyJAh+Pj44OjoSK1atThx4kRWblEIIYR4vNMb4YdgU9Jj7w6vvW1VdaXXc+P777nQvAXGpCTzftfatZ9a0pOoN9B39R46b+lKSu7FaHTJBOYqy9qmq166pAeykPgsXbqU0NBQBgwYwOHDhwkODqZhw4ZcunQpzfIXLlygUaNGBAcHc/jwYfr370+XLl1YuXKluUxYWBgtW7Zk27Zt7NmzB19fX+rVq8fVq1ctzlWyZEnCw8PNr+PHLdeyGjNmDN999x1TpkzhwIED5MuXj7fffpvY2Fhrb1MIIYRIn0EPmwfC4uaQEAU+5SFkBxR/z7rTxMRwZ9lykk6dInbL1sdXyGYnrkXz7uRdrL40E1u3E2jQ8XnZL1ny3gIKuBR46vE8DVZPYFi5cmUqVKjA9OnTzfuKFy9OkyZNGDVqVKryffr0Ye3atRarQoeEhHD06NFUaxrdZzAY8PDwYMqUKbRp0wYwtfj88ssvHDlyJM06Sil8fHwIDQ2lT58+ACQlJeHt7c23335Lp06dHntvMoGhEI8nnwXxyou+apqQ8PI+03blzvD2ULCxz9Lp4nbuxBgXh1tD6+b3eRIGo2L2zvOM23wavUHh5a6nUOAKRrzZj5KeJZ9aHNnFmgkMrWrxSU5O5tChQ6nm+qhXrx67d+9Os86ePXtSla9fvz4HDx5Er9enWSc+Ph69Xk/u3Lkt9p89exYfHx8CAgJo0aIF58+fNx+7cOECERERFteyt7enZs2a6caWlJRETEyMxUtknyFDhlCuXLknOkdYWBgajcZiAdJHzZ8/n1xPccSDEOIVp4xw64zp0dbHi6Dh6EwnPYa4OK716UP84cPmfS7BwU816bl6J4Gmc5Yz/uBE9AbF2yW82fRVQ1Z/8OMLmfRYy6rE59atWxgMBry9vS32e3t7ExERkWadiIiINMunpKSYF7N8VN++fSlQoAB169Y176tcuTILFy5k06ZNzJo1i4iICKpVq0ZkZKT5OvfPndnYRo0ahbu7u/lVqFDW1kwRQgjxkjMaH/ycqxA0/xE6bYcS71t1mluTpxC9Zi3X+vZFpaRkc5CPt/boNRpM+o1zNqOx99pGm7pRzGwdhKdL1lqrMuP27dssWbIkx85vrSz1nHp05kilVIazSaZVPq39YOqns3jxYlatWmXRjN6wYUM+/PBDSpcuTd26dVm/fj0ACxYsyHJs/fr1Izo62vy6fPlyuvcgXm7ptT4KIQTRV2BeQzi94cE+/xqQO8DqU3l9+QVOlSvjM2o0GpunN7A6OkFP6JLDdFl8mNh4BzxS6lHFuybdaryTY7NBK6VYtGgRgYGBtGrVKtWgpWfFqsTHy8sLnU6XqgXlxo0bqVpa7suXL1+a5W1sbPD0tFzUbNy4cYwcOZLNmzdTpkyZDGNxdnamdOnSnD171nwdwKrY7O3tcXNzs3i9rJRSjBkzhsKFC+Po6EjZsmVZsWIFSinq1q1LgwYNzAnpnTt38PX1NS+TcP9x0/r16ylbtiwODg5Urlw5Vefy9CxatAh/f3/c3d1p0aKFRWfzpKQkunTpQt68eXFwcKBGjRocOHAgw/PNnz8fX19fnJyc+OCDD8ytfg9bt26dxUjCoUOHkvLQX1cajYYZM2bQuHFjnJ2dGTFiRKbuRQjxijmzGWbUgMt7YUMfU6dmK+jDw4l6qLVD5+qK34L5OFUon92RpmvPuVvUnfkda08eRquBrnVeY+snI5hZfzIeDh45cs3Tp09Tp04d2rRpw82bNylevPhTX24jXcpKlSpVUp07d7bYV7x4cdW3b980y/fu3VsVL17cYl9ISIiqUqWKxb4xY8YoNzc3tWfPnkzFkZiYqAoUKKCGDh2qlFLKaDSqfPnyqW+//dZcJikpSbm7u6sZM2Zk6pzR0dEKUNHR0amOJSQkqJMnT6qEhIRUx+4m37X6pTfozfX1Br26m3xXJegTMnXerOjfv78KDAxUGzduVOfOnVPz5s1T9vb2KiwsTF25ckV5eHio77//XimlVPPmzVXFihVVcnKyUkqpbdu2KUAVL15cbd68WR07dky9++67yt/f31wmLYMHD1YuLi6qadOm6vjx42rHjh0qX758qn///uYyXbp0UT4+Puq3335TJ06cUG3btlUeHh4qMjLS4tpRUVFKKaX27t2rNBqNGjVqlDp9+rSaOHGiypUrl3J3dzefc+PGjcrNzU3Nnz9fnTt3Tm3evFn5+/urIUOGmMsAKm/evGrOnDnq3Llz6uLFi1l6X19FGX0WhHhppCQrtXmQUoPdTK8ZbyoVec6qU+gjI9U/lSqrk8UCVez27TkUaPqS9AY1dP0BVWxSK1VqfilVdlZ9ted8RI5eMz4+Xg0cOFDZ2dkpQDk6OqpRo0appKSkHL1uRt/fj7I68VmyZImytbVVc+bMUSdPnlShoaHK2dnZ/MXRt29f1bp1a3P58+fPKycnJ9WtWzd18uRJNWfOHGVra6tWrFhhLvPtt98qOzs7tWLFChUeHm5+xcbGmsv06NFDhYWFqfPnz6u9e/eqd999V7m6ulp8YY0ePVq5u7urVatWqePHj6uWLVuq/Pnzq5iYmEzdW1YTn1LzS1n92nhho7n+xgsbVan5pVS7De0szhu8ODjNutaKi4tTDg4Oavfu3Rb7P/vsM9WyZUullFLLli1T9vb2ql+/fsrJyUmdPn3aXO5+8rFkyRLzvsjISOXo6KiWLl2a7nUHDx6snJycLN7/Xr16qcqVK5vjsrW1VT/99JP5eHJysvLx8VFjxoyxuPb9xKdly5aqQYMGFtdp3ry5ReITHBysRo4caVFm0aJFKn/+/OZtQIWGhqYbu0ifJD7ipXfnilKz6z1Ietb3VEqfmKVThQ8foc43+0glPeU/rs5ej1FvTZmpSsyqpkrNL6VKzy+jvj84xeKP7uxmNBpVpUqVFKAA1ahRI3X+/Pkcu97DrEl8rH7A2Lx5cyIjIxk2bBjh4eGUKlWK3377DT8/PwDCw8Mt5vQJCAjgt99+o1u3bkydOhUfHx8mTZrEhx9+aC4zbdo0kpOTadasmcW1Bg8ezJAhQwC4cuUKLVu25NatW+TJk4cqVaqwd+9e83UBevfuTUJCAp9//jlRUVFUrlyZzZs34+rqau1tvlROnjxJYmIib79tObFWcnIy5cubmls/+ugjVq9ezahRo5g+fTqvv/56qvNUrVrV/HPu3LkpVqyYeZoCFxcX87H/+7//M09S6e/vb/H+58+fnxs3bgBw7tw59Ho91atXNx+3tbWlUqVKFtMfPOzUqVN88MEHqeLauHGjefvQoUMcOHCAb775xrzPYDCQmJhIfHw8Tk5OAFSs+OKvOSOEyGZxN0yPthJug50rNJ4MJT94fL17Ek+dwrZQIXT3fifm7d3LNOmu7dNZ1FMpxbzdZxl34Ht0HjvRAl72BZhUZyyl85TO0WtrNBo6dOjAlStXmDRpEk2bNn1+Hm89JEs9qz7//HM+v7dw2qPmz5+fal/NmjX566+/0j1fZlaSzkyPcI1Gw5AhQ8zJ0tOyr9U+q+vY6R6s0lvHtw77Wu1Dq7HscrXxw42PVssS473RCOvXr6dAAcsJqeztTT354+PjOXToEDqdztxvKjPu/6N+eH6lh/tK2T7yYddoNOZ4VDqd3FUGHdJVJqadMhqNDB06lKZNm6Y69nCHeWdn58eeSwjxinHJCyWbwJWDprW2PItkuuqdlasIHzIEt4YNKDBmDABau8yvyP6kbsQm8tWK3ziePB2dh6m/67v+TRlYrQ9Otk7Zfj2DwcAPP/yAn58f77xjWoj1008/pXnz5s91g4Os1ZUNnvQflI3WBhtt6v8V2fUPtUSJEtjb23Pp0iVq1qyZZpkePXqg1WrZsGEDjRo14p133uGtt96yKLN37158fX0BiIqK4syZMwQGBgJQtGhRq+MqWrQodnZ27Nq1i1atWgGm0VUHDx4kNDQ03XvZu3dvqrgeVqFCBU6fPp2lmIQQr6CYa6C1MSU9APXvTcZra90EnXYBAWA0YoyPx5ic/FSTnk0nwum9ZQoG9/XoHAw4at0Z/eZw3vKrnSPXO3z4MCEhIezfv59ChQpx8uRJXFxc0Gq1z3XSA5L4vBJcXV3p2bMn3bp1w2g0UqNGDWJiYti9ezcuLi54eXkxd+5c9uzZQ4UKFejbty9t27bl2LFjeHg86PE/bNgwPD098fb2ZsCAAXh5edGkSZMsx+Xs7Eznzp3p1asXuXPnxtfXlzFjxhAfH89nn32WZp0uXbpQrVo1xowZQ5MmTdi8ebPFYy6AQYMG8e6771KoUCE++ugjtFotx44d4/jx4zJ6Swhh6exWWN0RvEtB69WmVdWtSHgMd+6guzeBqlOF8vgvW4pDiRJP7RFPfHIK/dfuYtON77HxOIcGCMpTnXG1R+Dl6JXt14uNjWXQoEFMmjQJo9GIm5sbffv2xdHRMduvlWNyuL/RCyWrnZtfBEajUU2cOFEVK1ZM2draqjx58qj69eursLAw5e3tbdEZWK/Xq0qVKqmPP/5YKfWgg/G6detUyZIllZ2dnXrjjTfUkSNHMrzm4MGDVdmyZS32TZgwQfn5+Zm3ExIS1FdffaW8vLyUvb29ql69utq/f7/5+KOdm5VSas6cOapgwYLK0dFRvffee2rcuHEWnZuVMo3sqlatmnJ0dFRubm6qUqVKaubMmebjgFq9enXm3jxh4UX/LAihlFIqRa/U1qEPOjBPr6FU3M1MVzckJqrwYcPV6eo1lP5m5utlpyOXolTVSeNUyTkVTaO25gepn04uUUajMduvZTQa1cqVK1WBAgXMnZdbtGihrl27lu3XygprOjdbvVbXy0zW6kpbWFgYtWvXJioqSpaGEK/0Z0G8JGKuwYrP4NK95YzeaA/1vrGqpceYlMTFZh+RdPYs+b8ZQa6HBuzktBSDkelh5/j+97PYeK3HznMH/i6BTK47Fn93/xy55oEDB6hUqRIARYoUYerUqdSvXz9HrpUV1qzVJY+6hBBCvDr+3QqrOkJ8pGnU1vsToVTmkhb10MALrb09Bb4bjz4iApfg4JyM2MKlyHi6LTvEof9Ma0vW825DUKlKtC3dClttzo0ce+ONN/jf//5H4cKF6dev34v1aOsRkvgIIYR4NRhSYGN/U9KTrzR8tCDTo7ZSbt8mvP8A3N5phPt77wFg/9pr2L/2Wk5GbKaUYvGBC4zcPQGj/QVc7D9nWOMyfFC+ABpN5Wy/3q5du+jbty/Lly8nf/78gGkW/udxeLq1srRWl3i11KpVC6WUPOYSQrzYdDbQbC5U6gSfbbVqqHr0qlXEhYVxfdRojAkJORhkarfvJhPy4yEGrN0DbnvROf3H4OZamlYomO2JSGRkJO3btyc4OJg///yTQYMGmY+9DEkPSIuPEEKIl9m/W+HOZaj4iWk7XyloNMbq0+Ru146kCxfI3aYN2qf4mOePU9fpvfI4t+KSsNV5UN/7KxqULMDb/nWy9TpKKRYsWECvXr24desWAB06dGD06NHZep3ngSQ+QgghXj6GFAgbCTvHm+bo8SkHPplfGDTp/HnuLF/xYOZlGxt8HpoNPqclJBsY8OsONkR8T7KqSdG8QXzfvBylCrhn+7VOnjxJ586d2bFjBwClSpVixowZFrPqv0wk8RFCCPFyeXTUVoW2kKd4pqsb797lv5atMERHY1uoILnvTbD6tBy5FMXna2YT47wMG+dE3F3jWfPxlzjb58yEiHPnzmXHjh04OTkxZMgQQkNDU826/zKRxEcIIcTLI9WorUlQKvXyNRnROjvj9dVXxP6+Fdc6dXMo0NRSDEa+++MI8/4Zj43bMTRAgEsJprw9NtuTnofXLRw8eDBRUVEMGjTIYv3Ll5UkPkIIIV4O20bB9nt9UqwctXV3/35sfXywK1gQAI//tcKjVUs02qczBui/yLt0XPEzV3TzsXGLQYOOz0p25IsKHdNc0iirrl69SmhoKBEREWzfvt28xMScOXOy7RrPO0l8hBBCvBwc7k1cV/EzqD8y0xMS3lmxgvCBg3AsWxa/HxehsbExjWB6CqOYlFL8uO8so/d/h9b9z3urqRdkcp2xlMpTKtuuk5KSwrRp0/j666+JjY1Fp9Nx8OBB86SErxIZzi5yzJAhQyhXrtwTnSMsLAyNRsOdO3fSLTN//vwcGWqfmWsLIZ4x/UNDy6t8Du3Ww7vfWTULs1OVqmidnbErWgSVkpIDQabtVlwSrRauZNSxELTufwLwXsBH/NZsVbYmPQcOHKBy5cp07dqV2NhYqlSpwqFDh17JpAekxUeIdFWrVo3w8HDc3bN/FIUQ4gndH7V1ah10+APsXU0tNP41HltVKUXyxYvYBwQAYFewAIXX/4qtt3dOR222+eQ1em/9nhS3TejsjTjpPBhXayTBBR8ff2bFx8fTu3dvpk2bZp6LbfTo0XTo0AHtU3qE9zx6de9ciIfo9fpU++zs7MiXL98zmbQrrXiEEPfEXIMF75mGqt86Y0p+MsmYlMS1Xr250LgJiafPmPc/raQnPjmFviuP0XXblxjcN6DRGKni/Rabmq3N1qQHTL/Ddu3ahVKK//u//+Off/6hU6dOr3TSA5L4vDKUUowZM4bChQvj6OhI2bJlWbFiBUop6tatS4MGDbi/Xu2dO3fw9fVlwIABwINHPuvXr6ds2bI4ODhQuXJljh8/nqlrL1q0CH9/f9zd3WnRogWxsbHmY0lJSXTp0oW8efPi4OBAjRo1OHDgQIbnmz9/Pr6+vjg5OfHBBx8QGRmZqsy6desICgrCwcGBwoULM3ToUFIeasLWaDTMmDGDxo0b4+zszIgRI1Kd49FHXfcfqf36668UK1YMJycnmjVrxt27d1mwYAH+/v54eHjw1VdfYTAYzOfx9/dn+PDhtGrVChcXF3x8fJg8ebLFtTITjxACOLsVZtQwDVW3c4Vm86Bc5oeba+zsMMTGoAwGEo4dzcFAUzt8KYpGE3ey5MBlUmJLYatxZGjVb5hZ/3tyOeTKlmucO3eOpKQkAGxsbJg9eza///47ixYtwvsptmg913JmgfgXU0bL2ickJKiTJ0+qhISEVMcMd+8qw927ymg0mvcZk5JM+5OS0i5rMDwom5xs2p+YmKmyWdG/f38VGBioNm7cqM6dO6fmzZun7O3tVVhYmLpy5Yry8PBQ33//vVJKqebNm6uKFSuq5HvX2rZtmwJU8eLF1ebNm9WxY8fUu+++q/z9/c1l0jJ48GDl4uKimjZtqo4fP6527Nih8uXLp/r3728u06VLF+Xj46N+++03deLECdW2bVvl4eGhIiMjLa4dFRWllFJq7969SqPRqFGjRqnTp0+riRMnqly5cil3d3fzOTdu3Kjc3NzU/Pnz1blz59TmzZuVv7+/GjJkiLkMoPLmzavmzJmjzp07py5evJgq/kevPW/ePGVra6vefvtt9ddff6nt27crT09PVa9ePfXxxx+rEydOqHXr1ik7Ozu1ZMkS83n8/PyUq6urOeZJkyYpnU6nNm/ebFU8z4uMPgtC5JgUvVJbhyo12M30ml5dqVv/ZqqqUa9XRr3evK2/dUvd/euvnIo0leQUg/pmwz5VZMhM5dfnV1Vl5Fa168wNdTP+ZrZdIzExUQ0bNkzZ29urYcOGZdt5XxQZfX8/ShKfh2Q18TlZLFCdLBao9Pe+rJVS6ub06epksUB17euvLcqeKldenSwWqJIuXzHvi5w/X50sFqiu9OhpUfZ0larqZLFAlXjmjHnf7aVLrb6vuLg45eDgoHbv3m2x/7PPPlMtW7ZUSim1bNkyZW9vr/r166ecnJzU6dOnzeXuJwAPf5lHRkYqR0dHtTSDeAYPHqycnJxUTEyMeV+vXr1U5cqVzXHZ2tqqn376yXw8OTlZ+fj4qDFjxlhc+37y0bJlS9WgQQOL6zRv3twi8QkODlYjR460KLNo0SKVP39+8zagQkND0409rWvPmzdPAerffx/8su3UqZNycnJSsbGx5n3169dXnTp1Mm/7+fmlGXPDhg2tiud5IYmPeCY2ff0g6VnXTankzP37S7p8RV1o2UrdmDQ5hwNM2/mbcar+tJ9UidmVVYlZNVTnn3apO3ez9gdsen7//XdVrFgxBShAvffeexZ/iL8KrEl85FHXK+DkyZMkJiby9ttv4+LiYn4tXLiQc+fOAfDRRx/RtGlTRo0axfjx43n99ddTnadq1armn3Pnzk2xYsU4deoUgMV5Q0JCzOX8/f1xdXU1b+fPn58bN24ApiZZvV5vMS26ra0tlSpVMp/3UadOnbKI49G4AA4dOsSwYcMsYurQoQPh4eHEx8eby1WsWNH8c8OGDc1lS5Ysmc47CU5OThQp8mBeEG9vb/z9/XFxcbHYd/8e04uxatWqqe7x4XiEEI+o+iV4FjU92rJi1FbC0SMk/PUXt3/8EUN0dA4H+YBSip/2/UejiTv557IDWuWAj6sH/d7zxd0pe2ZFvnHjBq1bt6ZOnTqcPn0ab29vFi9ezJo1a16aBUVzgozqygbF/joEgOahhes8P/2U3G3agI3lW/z6n7tMZR0efGg9WrUi10cfgU5nUbbo71tTlc31wQdWx2c0GgFYv349BQoUsDhmb28PmHr/Hzp0CJ1Ox9mzZzN97vsfriNHjpj3ubm5mX9+dNpzjUZjjkfd61P06AdUKZXuh/Z+nYwYjUaGDh1K06apZ2t1eOi9dHZ2Nv88e/ZsEu6tuJzRVO1p3U9G95iRR+/x4XiEeOUZUuDsJgh8x7Tt6g2f7zOtsG4F93feQX/1Gm4NG6B7SiM0b8Ym0WXlevb8YwdoqFbEh24NZlI2vz92uuyZgXnDhg20atWKO3fuoNFo6Ny5M998802OTO3xspHEJxto7037/TCNnR0au9T/wNMsa2uLJo0v2/TKWqtEiRLY29tz6dIlatasmWaZHj16oNVq2bBhA40aNeKdd97hrbfesiizd+9efH19AYiKiuLMmTMEBgYCULRoUavjKlq0qHnUQat7a+Ho9XoOHjxIaGhouveyd+/eVHE9rEKFCpw+fdqqmB5NCLNbWjHff++EEI94eK2tD+dA6Wam/ZlIehKOHePWDzMpMH4c2nt/6Hh17JCT0Vr47fhl+m0bj8HtDxw836dnlU/5tHoAWm32tsC8/vrrJCYmUq5cOX744YdXdk6erJDE5xXg6upKz5496datG0ajkRo1ahATE8Pu3btxcXHBy8uLuXPnsmfPHipUqEDfvn1p27Ytx44dw8PDw3yeYcOG4enpibe3NwMGDMDLy4smTZpkOS5nZ2c6d+5Mr169yJ07N76+vowZM4b4+Hg+++yzNOt06dKFatWqMWbMGJo0acLmzZvZuHGjRZlBgwbx7rvvUqhQIT766CO0Wi3Hjh3j+PHjz2y01J9//mmOecuWLSxfvpz169c/k1iEeK49utaWFcs1GJOTudKlKykREdyaMYO86fwBlRNiE/X0XruJ7VGT0LmHowHeCdLSPrhwtpw/Li6OjRs30qyZKQksUqQI27dvp0KFCtjYyFe5NaSPzyti+PDhDBo0iFGjRlG8eHHq16/PunXr8Pf357PPPmPIkCFUqFABMC1Y5+PjY9FXB2D06NF07dqVoKAgwsPDWbt2LXZptGpZY/To0Xz44Ye0bt2aChUq8O+//7Jp0yaLhOthVapUYfbs2UyePJly5cqxefNmvv76a4sy9evX59dff2XLli288cYbVKlShe++++6ZLr7Xo0cPDh06RPny5Rk+fDjjx4+nfv36zyweIZ47hhT4fRj8+KEp6clXGjpth5JNMn0KrZ0d+YcPw61RQzw/+STnYn3E3vO3eGvWUHbeHYjOIRx7jSvfBo9j/FvDsuX8a9asoUSJEnz00Uf8+eef5v2VKlWSpCcLNCoznSZeETExMbi7uxMdHW3RTwUgMTGRCxcuEBAQYNFP5FUQFhZG7dq1iYqKkufHWeDv709oaGi6j+9eNK/yZ0HkkIcfbYFVa23FbNqMTZ48OFUon8NBppaUYmDYxl2svjwendMFAErnrsKkuqPwcvR64vP/999/dOnShbVr1wKm3yXz5s2jVq1aT3zul01G39+PklRRCCHEsxV+7MGEhO9PhFIfZqranVWrCe/fH1sfHwLW/ILuoRGkOe3ktWg6/TKDKIfl6JyS0GFPz4q9+F+Jj594RJVer+f7779nyJAhxMfHY2trS69evRgwYABOafT9FNaRxEcIIcSzVawBNBwDReuCZ5HHl7/Htd7b3PphBm716qO9N0I1pxmMiklhfzHr1Fh0LifQAP7OJZhWbxyF3Ao98fmVUjRo0IA//vgDgODgYGbMmEGJEiWe+NzCRBIf8Vi1atXK1DBykbaLFy8+6xCEeL5EX4XfepqSnVz3koXKnR5bTRmNxO/bh/O9ebF0Li4U/uUXtA9NJZKTLt+Op+PKBVzSLkTnEocGHZ+V7MyXFdqj0+oef4JM0Gg0tGnThqNHjzJu3Djatm0rc/JkM0l8hBBCPD1nt5hGbSXchpQkaL0qU9VUSgqXO4Vw988/KThjOq73+rk8jaRHKcWKQ1cY+utRVMGf0NrEkcfej6lvj6W4Z/EnPveCBQvInTs377//PgBt2rTh/fffT3eQh3gykvgIIYTIeQY9/DEC/vzetJ2vDDQam+nqGhsb7IsWJf7QIYxPcQbmyLgk+q06zuaT1wENxQ2fUKnYTfpX64a97sker506dYqQkBB27NiBj48PtWrVws3NDY1GI0lPDpLEx0ryyEe86uQzIKwWfcU0auvyvYk83+gA9UY8dtSWMTERlWJA52Ka1TxPj+7katEc+4CAnI4YgE0nLtPnj7HExXliq3uDbm+/Tqc3G6F7wskI4+Pj+eabbxg7dix6vR4nJydCQ0NxfEqP7F51kvhk0v1lCeLj4+Ufp3il3V/vLKOlPYQwCz8GCxubHm3Zu8H7kzM1N0/imTNc69ED+9dex2f8ODQaDVo7u6eS9NxNSmHE+pOsOLMSh/zbcHK154da7ajq/+RzgW3YsIEvvviCCxdMw9/fe+89Jk+e/EznGXvVSOKTSTqdjly5cpkXn3RycpIOZ+KVopQiPj6eGzdukCtXLnS67OnMKV5yXq+Ba35TJ+aP5kPuzM1krOLjSTp/gZSoO6TcvIlt3rw5G+c9By/epvuyo1y6HY9GU5GCflcJrdIiW5KeY8eO0ahRIwAKFizI5MmTady4sXyXPGUygeFDHjcBklKKiIgI7ty58/SDE+I5kStXLvLlyye/rEX6YiPAOS9o7y0OEHMNnDzBJuM+McpoRKN9sKBAzMaNOL3xBjaenjkZLQDJKUaGb9zB8vPzSAz/gALuboz7qCxVi2Tvtdu2bUuePHkYMmQILi4u2XruV5k1ExhK4vOQzL5xBoMBvV7/FCMT4vlga2srLT0iY2c2wepOUPULeLNXpqvF7dzJjbHj8J0zG5s8eXIwwNROR8TQYfVUbjusQKNNxs+mET9/OAI3hyd7nLt//3569erFjz/+SKFCpmH7Sin5oyEHyMzNOUyn08kvfyGEeJhBb1pra/ck0/bpDVA9FHSPTx6UwcCN7yaQdOYMt6bPIN+ggTkb6z1Go2Ly9r/44dRodM7/oAEKu5RhWv0uT5T03LlzhwEDBjB9+nSUUgwYMICFCxcCSNLzHJDERwghxJOJvgLLP4Er+03blTpBveGZSnoANDodBcaO4c7y5eTp1i0HA33g6p0EOqyYy3+aheic49EoGzqV/pLOFT5Bq8na+t1KKZYsWUK3bt24fv06AK1bt2bcuHHZGbp4Qln6vztt2jTzAoVBQUHs3Lkzw/Lbt28nKCgIBwcHChcuzIwZMyyOz5o1i+DgYDw8PPDw8KBu3brs378/3fONGjUKjUaTatHH69ev065dO3x8fHBycqJBgwacPXs2K7cohBAiM05vhBk1TEmPvRt8vBAajcmwP49Sits//0z0ul/N++yLFsW7Xz+0ObzwrVKKnw78Q4MfO3PZdgZam3jy2hdmxftL+SLosywnPWfPnqVevXq0atWK69evU6xYMf744w8WLlxI3qfUMVtkjtX/h5cuXUpoaCgDBgzg8OHDBAcH07BhQy5dupRm+QsXLtCoUSOCg4M5fPgw/fv3p0uXLqxcudJcJiwsjJYtW7Jt2zb27NmDr68v9erV4+rVq6nOd+DAAWbOnEmZMmUs9iulaNKkCefPn2fNmjUcPnwYPz8/6taty927d629TSGEEI8TdwOWt4WEKPApD512QInGj60W89tvXB82nIjBg9FHRDyFQE0i45JouehHRh5tD66HQGn4qEhbNn60gtdzv/5E5547dy5bt27F3t6e4cOHc/ToUWrXrp1NkYtspaxUqVIlFRISYrEvMDBQ9e3bN83yvXv3VoGBgRb7OnXqpKpUqZLuNVJSUpSrq6tasGCBxf7Y2Fj12muvqS1btqiaNWuqrl27mo+dPn1aAervv/+2OE/u3LnVrFmzMnVv0dHRClDR0dGZKi+EEK+8A3OU+q23UvrETFcxpqSo/z75VEXOn6+MBkMOBvfA+mMXVdnJnVWp+aVUqfmlVLVFddWB8ENPdM67d++af46Li1Pt2rVTZ8+efdJQRRZY8/1tVYtPcnIyhw4dol69ehb769Wrx+7du9Oss2fPnlTl69evz8GDB9MdGRUfH49eryd37twW+7/44gveeecd6tatm6pOUlISAA4PNZPqdDrs7OzYtWtXmtdJSkoiJibG4iWEECIDpzfAlUMPtit+Cg2/zfDRljE5maily1BGI2Dq01Nozmxyt21rMXw9J8Qm6umy7Hd67WmHwdXULaNuwSZsab6GivkqZOmcERERtGrVijp16mC8d0/Ozs7MmzePokWLZlvsImdY9S/u1q1bGAwGvL29LfZ7e3sTkU5zZURERJrlU1JSuHXrVpp1+vbtS4ECBSwSnCVLlvDXX38xatSoNOsEBgbi5+dHv379iIqKIjk5mdGjRxMREUF4eHiadUaNGoW7u7v5dX+4oRBCiEekJMOmAbC4BaxoZ3q8lQnKaORSu0+IGDyYqEWLzPufxuimvecjaThxJ2v/uosyOuCo9WBSrWlMqDMcJ1snq89nMBiYNm0agYGBLF68mP3797Nnz54ciFzkpCyN6nr0H6x6zLwEaZVPaz/AmDFjWLx4MWFhYebWm8uXL9O1a1c2b95s0aLzMFtbW1auXMlnn31G7ty50el01K1bl4YNG6YbV79+/ejevbt5OyYmRpIfIYR41J1LplFbVw+atgPfBVvnTFXVaLW4v/cuyefPY1vINweDfCBRb2DQb7+zfF8CymhDQQ8X+r05lhpFCuFu756lc/7111+EhIRw4MABACpWrMiMGTMICgrKztDFU2BV4uPl5YVOp0vVunPjxo1UrTr35cuXL83yNjY2eD4yG+e4ceMYOXIkW7dutei8fOjQIW7cuGHxD8xgMLBjxw6mTJlCUlISOp2OoKAgjhw5QnR0NMnJyeTJk4fKlStTsWLFNGOzt7fH3v7JVtcVQoiX2j/r4ZfOkBgNDu7QeBoUfzfDKilRUaiEBGx9fADI1aIFrg0aYPMUVhz/+2o0nX6ZTLTTCmw9g2nq34Gv3y2Bi33WZm9JSEigX79+TJ48GaPRiJubGyNHjiQkJETmc3tBWfWoy87OjqCgILZs2WKxf8uWLVSrVi3NOlWrVk1VfvPmzVSsWNFikcOxY8cyfPhwNm7cmCpRqVOnDsePH+fIkSPmV8WKFfnf//7HkSNHUv3jc3d3J0+ePJw9e5aDBw/SuPHjRxkIIYR4iCEFNvaHJa1MSU+BIOi087FJT8KxY1xo8gFXunVD3evHqdFocjzpSTEYmfz7WZpM/ZPrd2zRaA1UfE3PyKalspz0AOZ+okajkRYtWvDPP//wxRdfSNLzArP6X0P37t1p3bo1FStWpGrVqsycOZNLly4REhICmB4fXb161TxLZUhICFOmTKF79+506NCBPXv2MGfOHBYvXmw+55gxYxg4cCA///wz/v7+5hYiFxcXXFxccHV1pVSpUhZxODs74+npabF/+fLl5MmTB19fX44fP07Xrl1p0qRJqs7VQgghHkOjhdvnTD9X/RLqDAYbu8dWs/HywhgfjzE6xrS46L1Wn5z0741Yuq74nROXTH9MN/SrS7PqwbzlXzVLfYnOnz9P/vz5cXR0RKfTMXv2bG7cuCHfJS+LrAwbmzp1qvLz81N2dnaqQoUKavv27eZjbdu2VTVr1rQoHxYWpsqXL6/s7OyUv7+/mj59usVxPz8/BaR6DR48ON0YHh3OrpRSEydOVAULFlS2trbK19dXff311yopKSnT9yXD2YUQr7yHh5ffjVTq9MbHV4mLs9iOP3pUGR4a6p1TDAajmrz9oCox9UNVYnYlVWrYMrX6ryvKaDRm6XyJiYlqxIgRysHBQX399dfZHK3ISdZ8f8sipQ+xZpEzIYR4qaQkw9bBptFaTaZDJlpKlFJEr1rFjTFj8Z0/D4fixZ9CoCZXo+LpuGo2/2l+RKNLQKNsGVJlNE0Ds9YqExYWRufOnfnnn38AaNiwIb/++ivaHB5uL7KHNd/f8n9UCCFedVEXYW592DsNji6Ga39lumrs739giI4m6ufFjy+cDZRS/HzgFA1+7sglm1lodAl42xdlVePlWUp6bty4Qdu2balduzb//PMPefPm5aeffmL9+vWS9LykZJFSIYR4lZ1aB798AUnR4JALPphh6sicCRqNhvzfjCB6zRpyt26ds3ECt+8m03nVIv5OnoPWJRaUlpavf0qvKp9jq7V+NfXNmzfTokULoqKi0Gg0hISE8M033+DxFEafiWdHEh8hhHgVpSTBlkGw796i0QXfgGbzIFf6c5kpvZ6bU6ei0erI0+UrAGw8PPBs1y7Hw13/9wX6bx+J0WUvWhvIZVOQqW+PpUzeUo+vnI5ixYqRlJREuXLlmDFjBpUrV87GiMXzShIfIYR4FS1tDWc3mX6u1gXqDAJdxq0md/fuJXLGD6DR4Pbuu9gXDsjxMOOSUui2ZiW7o6eidYkCpaGR38cMDe6Jg411K7nHxcXx66+/0qJFCwD8/PzYvn075cqVw8ZGvg5fFfJ/WgghXkVVOsPVQ9BkGrxeP1NVXIKDyd22DY7lyj2VpGfXv9founkUSU7b0dopnLV5GF97FNULWtcyo5Til19+oUuXLly5coX8+fNTs2ZNgHQnuBUvL0l8hBDiVaBPhBsnocC9hTmL1IauR8HeJd0qhpgYbv3wA3m+/BKtoyMA3v365XioiXoD4zefZt6RdTgWDEMDBOd7h7FvDcQ5k0tl3Hfx4kW++uorfv31VwACAgKQwcyvNkl8hBDiZRd5Dpa3g9sXoNN28Cxi2p9B0qOU4nKHjiQcPYpKSCDfoEFPJdS/r0bTfdkRzlyPA0ria1OXr6q+S4PCdaw6T3JyMhMmTGDo0KEkJCRga2tLr169GDBgAE5O1i9QKl4ekvgIIcTL7O9VsLYLJMeCY26IDX+Q+GRAo9Hg1eUrIoYNw/0pLPujNxj5ZnMYy85PJ/7WR3i5eDC6aRnqlsh4iYz0NGrUiN9//x2AmjVrMn36dIo/xXmGxPNLEh8hhHgZ6RNhU384OMe0XagKNJsL7gXSrZJ8+TKGO3dwLF0aAJfq1Sny669obK0fKm6Ns9dj6b78COdsxqBzuUrRYmEs+/B7cjs/fomM9Hz66accO3aMcePG0bp16ywtXSFeTjJz80Nk5mYhxEsh8hwsbwsRx03bNbpD7QGgS/9v3fi//uJyh45o3dwo/MtqdO7uOR6mwaiYu+sCYzefJjnFiJt7BMUC9zKl3gi8nb0zfR6j0ci8efPIlSsXH374IWB6VHf/d7p4+Vnz/S0tPkII8bL5a4Ep6XHyhA9mwmt1H1vF/vVi6Dw9TYuMJibmeOLz3627tF89iYu3Y9Cn1KBWsTx8+2EdvN0+s+o8x48fp3Pnzvz555/kzZuXt956Cw8PDzQajSQ9Ik2S+AghxMum9teQHA/B3cEt/dXRk69cwa5gQQB0Ls74zZ+HTd68aHJwThulFDP+PMTU4yPROJ3F3ltH12rv80WNN6x6HHX37l2GDh3KhAkTSElJwdnZmT59+uDq6ppjsYuXgyxEIoQQL7pbZ00dmA1607aNHbwzLsOk5+bUqZyr34DYP/4w77P18cnRpCf8TgLvzZ/A1DMhaJzOolG2hJTqyuc1KluV9Kxdu5YSJUowduxYUlJSaNq0KadOnaJ79+4yEaF4LPkXIoQQL7Jjy2BdKOjvglsBqNUnU9WMcXfBYODu7j24vvVWjoaolOLHA38z5uA34HwCDZDPvhg/NBhL4VzWTYT4999/0/jeKDM/Pz+mTJnCu+9mbeSXeDVJ4iOEEC+i5HjY2Af+Wmja9g+GCm0yrKL0evMIrTzdQnGqGIRrHevmx7FWZFwSIavncjJ5PlrneFA6/q9YB3pU7oSNNnNfQUopc4tQqVKl6NixI7lz52bgwIEyJ4+wmozqeoiM6hJCvBBunjZNSHjjJKCBmr2hZh/Q6tIsboiL4/rw4RiTkynw3XdPbWj36qNnGPLnCIzOhwHwtA1ger2xFPcqlulz/Pnnn/To0YMlS5bg7+8PWCZCQoCM6hJCiJfXP7/Bys9AHw/OeeHDWVC4VoZVki9cJHr9b2A0knT6NA6BgTkaYnSCni9/+ZG/4mehdY4FpaVp4TZ8Xb0Lto9ZCPW+yMhI+vTpw5w5pnmIBg4cyKJFiwAk6RFPRBIfIYR4kXgWBTQQ8CY0nQ2uj5/vxrF0KfJ9/TX2r7+W40nPrrO36LJpNHrXTWhtwE1XgMlvf0sF77KZqm80GlmwYAG9evUiMjISgPbt2zN69OicDFu8QiTxEUKI511CFDh6mH7O8zp8tgnylkj30Zb+6lUiRo0i38BB2HrnBcCjRfMcDTE+OYXRG/5h4Z7/0DkG4OSipUGhjxhesycONg6ZOsfff/9N586d2bVrF2DqzzNjxgyqV6+ek6GLV4wkPkII8bxSCo78BBv6Qqul4H8vAchXOsNq1wZ8TfzevVzXaCg4eXKOh7n7/FV6rV3P1QjTchitytakXc33KOLha9V5li1bxq5du3BycmLIkCGEhoZim8PLZYhXjyQ+QgjxPEqKg/U94NgS0/bhHx8kPo+Rb9BAIoYNJ2+vXjkYICSlGPhm4z5WhvdH4x6Nd3Ivxn3wNsGv5cn0OWJiYsydUfv168fNmzfp168fvr7WJU1CZJaM6nqIjOoSQjwXrp8wjdq6dQY0WtM6WzW6gzbtOWcTjh5FH3Edt/r1nlqIf1+Npseyo5y+HoNjobk4u9xiwlvjCS70RqbqX7p0ia5du3L58mX27duHTpf2YzshMkNGdQkhxItIKdO8PBt6Q0oiuOaHD+dk2NIT/9dh/mvdGo29PQ7FXsfu3pDvnKI3GBm+eQs//3mXlBR7vFzs6VN9BPVLFMTN7vF/MOr1eiZOnMjgwYOJj4/HxsaGffv2Ua1atRyNW4j7JPERQojnxfltsK6L6eeideGDH8DZK8MqjmXL4FShAjZ58qDLnTtHwzsRfptO677ljt1GdF4Vqev5Od98UApPF/tM1f/zzz8JCQnh77//BqBGjRpMnz6dUqVK5WTYQliQxEcIIZ4XhWtD6Y/AuyRU65ruo627e/bgVLkyGq0WjU5HoR9moHF0zLH5bQxGxajf/2Dx+TFoHa6hASr4OzD5vTKZmpcnPj6erl27Mnv2bAA8PT0ZO3Ysbdu2RZvOPQqRUyTxEUKIZ0UpOLoEijUEx1yg0UDTWab/piNi2DCifl5M3t698fz0EwC0Obhsw9nrd+iwdiy3bNejdTBgo1zoW6k/zUu8l+lzODg4mFt57s/J4+npmVMhC5EhSXyEEOJZSIyBX0Ph75VQ/H34eKEp4XlMq43968VAq8WYEJ+j4RmNivFhO5l/djRah8togNddqzCjwUjyOD1+1NaJEyfw9/fH2dkZrVbLrFmziI6Oljl5xDMniY8QQjxt4UdNo7ZunweNDgpWTLeoMhgwREdjc6//Tq7mH+NYvjwOxV7PsfAuRsby2ervuK77Ba1DCjrlRPegPrQu9cFjH6fdvXuXYcOG8d1339G9e3e+/fZbAOnHI54bkvgIIcTTohQcmA2b+oMhGdwKQrO54Fs5zeL6iAiu9eyFMSkJ/59/QmNri0ajybGkRynFlF17+OHESDSO/6EBCjsH8UPD0eRzzvfY+mvXruWrr77i0qVLAJw/f14WFBXPHUl8hBDiaUiMhrVfwck1pu3XG0KTaeCUwUgspUg8exb0ehJPn8GxVMkcC+9K1F3ar/6eK5qVaBz1aJUDX5btTvtyLR6buFy6dIkuXbqwZo3p3nx9fZk8eTLvv/9+jsUrRFZJ4iOEEE+DIQUuHwCtDbw9DKp8nmZ/HmU0ork30sk2f34KTvgO2wIFsPPzy5GwlFKsOHSFYev+JiXfXmyc9BRyLMushmMo4Orz2Prr1q2jRYsW5jl5evTowcCBA3F2ds6ReIV4UpL4CCFETlHqQXLj7AkfLzDNxJxOn56EY8e41r8/Pt9+i2NJU+uOcw5O7Hc9OoF+vxzhj1O3ASipPqNRyRg+D2qd6cdT5cuXR6vVypw84oUhiY8QQuSEhChY8yUEvgPlWpn2FaqUYZXIufNI/vccN8d/h+/cOTkWmlKKRQePMvbQMJIT8mCra0y3t1+nY3BhbHQZz6sTGRnJqlWr6NChAwAFCxZk3759BAYGypw84oUgiY8QQmS3K4dgRTu4cwku7oLi74G962Or5Rs8CJ1HLvKGhuZYaJFxSQxc8zebzu/Ayfcs9g7/8UPTvlT1C8iwntFoZMGCBfTq1YvIyEj8/f15++23AShRokSOxStEdpPERwghsotSsGcqbB0MxhTw8IeP5qeb9MRs3Ejyxf/wCukEgI2HB/kHD86x8NYfv8LgNae4FZeMjbYYldza0a/WBxT1yDjp+fvvv+ncuTO7du0CTEPTZSFn8aKSxEcIIbJD/G345XM4s8G0XaIJvD8JHNzTLJ5w/G+uhnYDjQbnKpVxLFcux0K7czeZkDUzOX53KfGJIbzuXZDvPi5HqQKNMqz38Jw8KSkpODk5MXToULp27Yqt7eOXqhDieZSlB7LTpk0jICAABwcHgoKC2LlzZ4blt2/fTlBQEA4ODhQuXJgZM2ZYHJ81axbBwcF4eHjg4eFB3bp12b9/f7rnGzVqFBqNhtBHmoPj4uL48ssvKViwII6OjhQvXpzp06dn5RaFECLzkuJgZk1T0qOzh3fGm1p60kl6ABxLlyLXxx/j2akjDiVzbpj6muP/UGtRW07of0Brd4eKZY+x7qsalCqQfmxg6gdUv359xowZQ0pKCk2aNOHUqVP07NlTkh7xQrM68Vm6dCmhoaEMGDCAw4cPExwcTMOGDc0TVj3qwoULNGrUiODgYA4fPkz//v3p0qULK1euNJcJCwujZcuWbNu2jT179uDr60u9evW4evVqqvMdOHCAmTNnUqZMmVTHunXrxsaNG/nxxx85deoU3bp146uvvjLPLSGEEDnC3sW0uGjuItB+K7zRPtVQdWUwcPvnnzHGP1hqIt/QIeQNDUWTA4lEbKKeNktm0n9/WwyOf4PS8WFAexZ/+A32NrrH1r//x6Wfnx/r1q1j9erV+Pr6ZnucQjx1ykqVKlVSISEhFvsCAwNV37590yzfu3dvFRgYaLGvU6dOqkqVKuleIyUlRbm6uqoFCxZY7I+NjVWvvfaa2rJli6pZs6bq2rWrxfGSJUuqYcOGWeyrUKGC+vrrrx93W0oppaKjoxWgoqOjM1VeCPEKi7ulVNSlB9speqUSY9ItfqVHT3WyWKC6NnBQjoe24cS/qtz01qrU/FKq1PxSqsaid9XRiJMZ1klOTlbffvut+vHHH837jEajSkhIyOlwhXhi1nx/W9Xik5yczKFDh6hXr57F/nr16rF79+406+zZsydV+fr163Pw4EH0en2adeLj49Hr9eTObTmj6RdffME777xD3bp106xXo0YN1q5dy9WrV1FKsW3bNs6cOUP9+vUze4tCCPF4/+2GGTVg6f9BSpJpn84mw5FbuT5sitbZOUf78sQlpfDJsjn02PM/UhwPg9Lynm9b/mi5ijLexdOtt3PnTsqXL0+fPn3o2rUrUVFRgKnVx8HBIcfiFeJZsKpz861btzAYDHh7e1vs9/b2JiIiIs06ERERaZZPSUnh1q1b5M+fP1Wdvn37UqBAAYsEZ8mSJfz1118cOHAg3fgmTZpEhw4dKFiwIDY2Nmi1WmbPnk2NGjXSLJ+UlERSUpJ5OyYmJt1zCyEERiPs+g62jQRlADtniLsOuVI/AjLE3UV/7SoOr5vW1XKuWpWif/yOzj3jvjVZtfmfc/QNG4be8S+0NuCmLcSkuqMJyp+6W8B9t27donfv3sybNw8ALy8vxo0bR65cuXIkRiGeB1ka1fXojJ7qMYvQpVU+rf0AY8aMYfHixYSFhZn/0rh8+TJdu3Zl8+bNGf71MWnSJPbu3cvatWvx8/Njx44dfP755+TPnz/NVqJRo0YxdOjQ9G9UCCHui7sJqzvCuT9M22VamDox27ukKpp04QKXO4WgkpMp/MtqdPcSiZxIeuKTU+iyZhF7YmaidYwDpaVhoVaMqNUNO51dmnWMRiPz5s2jd+/e3L5tmrW5Q4cOjBo1Ck9Pz2yPUYjniVWJj5eXFzqdLlXrzo0bN1K16tyXL1++NMvb2Nik+oCNGzeOkSNHsnXrVovOy4cOHeLGjRsEBQWZ9xkMBnbs2MGUKVNISkoiOTmZ/v37s3r1at555x0AypQpw5EjRxg3blyaiU+/fv3o3r27eTsmJoZChQpl8t0QQrwyLuyEle0hLgJsHOGdcVDuf2mutQVgmzcvGo0GpdGgv37dnPhkt33nI+n2y6/Een6H1gZctAWYVPdb3shfNsN6x44do3379oDp9+T06dOploNLYwjxPLEq8bGzsyMoKIgtW7bwwQcfmPdv2bKFxo0bp1mnatWqrFu3zmLf5s2bqVixosWQyLFjxzJixAg2bdpExYqW69jUqVOH48ePW+z75JNPCAwMpE+fPuh0OvR6PXq9PtWU6TqdDqPRmGZs9vb22NvbP/7GhRCvLqVg6xBT0pMn0DRMPW/q/jKG6Ghzi47W2ZmC06dh4+mZI608CckGxmz6h/m7L6KUFx6OlXjrtaKMqt0jw1ae+78fy5UrR7du3ShYsCBdunTBxkamdBOvEGt7Ti9ZskTZ2tqqOXPmqJMnT6rQ0FDl7OysLl68qJRSqm/fvqp169bm8ufPn1dOTk6qW7du6uTJk2rOnDnK1tZWrVixwlzm22+/VXZ2dmrFihUqPDzc/IqNjU03jrRGddWsWVOVLFlSbdu2TZ0/f17NmzdPOTg4qGnTpmXq3mRUlxAiTZHnlfq1u1JJcWkejt6wQf3zRiUVvXlzjoey7cwFFTS9k/If8LPy6/Or6rPiqLoTn5RueaPRqFavXq1ee+01dfbs2RyPT4hnwZrvb6sTH6WUmjp1qvLz81N2dnaqQoUKavv27eZjbdu2VTVr1rQoHxYWpsqXL6/s7OyUv7+/mj59usVxPz8/BaR6DR48ON0Y0kp8wsPDVbt27ZSPj49ycHBQxYoVU+PHj1dGozFT9yWJjxBCKaXUv38otev7TBe/PnasOlksUP3XsWOOhZSQnKKGrzuhAqc0U6Xml1Jlp7dUf/xzPcM6Fy5cUO+++675d+onn3ySY/EJ8SxZ8/2tUepeT2NBTEwM7u7uREdHyzo0QryKDCmwfTTsGGfabrsOAoLTLKoeGtShkpOJWrYcj+Yf58hkhH9diqLnsqOcv3UXrX0E+YqsYtxbw6lWsEKa5ZOTk/nuu+8YNmwYCQkJ2Nra0qtXLwYMGICTk1O2xyfEs2bN97c82BVCCICYa6YOzP/9adqu0BYKVkxVTBkMRM6aRdKZM/iMH49Go0FjZ0fu//tftoeUqDfQc/0SNp85TvLtYPK62jP6w3epXezTdEfS7tixg86dO3Py5EkAatasyfTp0ylePP15fIR4lUjiI4QQZ7eahqrHR4KdC7w3EUo3S7No8vnz3Jw6DfR6cjVrhnMOjYb68/xlQrcMJdFhH3Z5tbxZqArjG9fD3SnjFqXt27dz8uRJ8uTJw7hx42jdunWG040I8aqRxEcI8WoL+xbCRpp+zlcams0Hr6LpFrd/7TW8e/dG6+qCU9Wq2R5OUoqB3uuXsfXmFLQOMaA01MrXlHF1G+BgkzrpMRqN3Lhxg3z58gHQu3dvkpOT6datW6rZ74UQkvgIIV51ue7N3fVGe6j3DdhaTpJqiLvLze++w7NjB2zvJRe5W/9fjoSy7+JVvto8hAT7vWhtwVHjzbhaI3nTr1Ka5Y8cOULnzp2Jj4/n0KFD2NjYYG9vz/Dhw3MkPiFeBpL4CCFePYnR4HBvfp1yrcCrGBQMSrNo+IABxG7aRPLFixSaMztHHhslpxjpt2E5G69PRmsfDUpDsPcHjH+7L442jqnKx8bGMnjwYCZOnIjRaMTV1ZVjx45RoULanZ2FEA9I4iOEeHWkJMPvQ+HEaui0E5zvzR6fTtIDkKdrV5LO/YvX551zJOk58N9Vvtw0jHj73WhtwQFvxtT6htr+lVOVVUqxcuVKQkNDuXr1KgAff/wx3333HQUKFMj22IR4GUniI4R4NUT9Bys+hasHTdun10OFNqmK6a9eJfHMGVxr1wbAvnAAhdeuRfPIrPBPSm8w0m/DCjZETDK38lTP24QJ9fql2coTExNDixYt2LBhAwBFihRh6tSp1K9fP1vjEuJlJ4mPEOLld+pXWPP5g0dcjadB8XdTFUs6d46LLVqiUlIIWLUS+4AAgGxPek5ei6Hj2jFEO66518qTh9E1v6FOQPqdpV1dXYmLi8POzo6+ffvSt29fHB1TJ0hCiIxJ4iOEeHmlJMGWQbBvhmm7QEVoNhc8/NIsbhcQgEPJkhgT4nNkIkK9wcjUbf8y5Y9/Mdr54uyvo2qed5nwdj+c7ZxTld+2bRtBQUG4ubmh0WiYPXs2AK+//nq2xybEq0Jmbn6IzNwsxEtm61DY9Z3p52pfQZ3BoLNMaBJPn8b+tdfMrTqGO3fQOjtne+Jz4L+r9P51DRcum5KueiW8+aq+F6W9/VOVjYiIoEePHvz888+EhoYyYcKEbI1FiJeNNd/f2dt+K4QQz5MaoeBTAVotg3ojUiU9kXPmcqHph9yeO9e8T5crV7YmPckpRr7ZuI92W5pz03kmudxvMqlleX5oHZQq6TEYDEydOpXAwEB+/vlnNBoNyrSmYrbFI8SrTh51CSFeHvpEOLbU1GlZozH15+nwh+nnNGjdXMFgIOnceYu1t7LLiWvR9Fx+jFPh0TgULICr6y3GtyrNm34+qcoeOnSIkJAQDh40db4OCgpixowZVKyYetkMIUTWSeIjhHg53PoXlreD68fBqDdNSAipkh5D3F10Lqb+NLmaNcOukC/OVVIPHX8SySlG+m5Yxtr9OlL0Tng42dG36lDeK+OLk23qRUIXLVpEu3btMBqNuLm5MXLkSEJCQtDpdNkalxBCEh8hxMvg2HL4NRSS48DJCzz8UxUxxMYSMWw4yefO4b9kMRo7OzQaTbYnPXsvXqbr5qHE2+/DJk856nqEMrxJKfK42qdb5+2338bV1ZV33nmH8ePHm5efEEJkP0l8hBAvruR42NgH/lpo2vYPhqazwC1/qqLG+Hju7tiBITaW+IMHs31x0eQUI71/W8zWm1PR2MeC0lC7aGEm1y+Ljc7yV+2ZM2dYsWIF/fv3ByBfvnz8888/kvAI8RRI4iOEeDHdPG16tHXjJKCBmr2hZh/QPng89HC/HVtvb3zGjkHr4opThfLZGsrei5fpsnkICfb70diAI/kYU/sbaj2yxlZiYiKjRo1i9OjRJCcnU758eRo2bAggSY8QT4kkPkKIF1N8JNz8B5zzwoezoHAti8PJV64Q3q8/eXv3xrF0KQBc3nwzW0NITjHS67ef+f3mNHMrz5vezRj/dm8cbCwXO920aRNffPEF586dA6B+/foyH48Qz4AkPkKIF4dSDzor+1UzPdbyDwZX71RFb02ZSvyBA0QMG4b/sqXZPmJr94VLhG4ZQoL9gXutPPkZV3skb/pZjsK6evUq3bp1Y/ny5QD4+Pjw/fff06xZsxxZ+0sIkTFJfIQQL4aIv2HNF9B0JuQpZtpXulm6xb379sGYmEjenj2zNcFISjHQc/1PbLs1HY19HCgNNb0/Zny9XtjrLDswK6Vo0KABf//9N1qtli5dujB06FCZIFWIZ0hmbn6IzNwsxHNIKTg0Hzb2hZREKFIHWq9KVSz+0CESjhzF87NPcyyUg/9d5/NNfUiwPwSAEz6Mrz2SGr7pr+6+Zs0aRo8ezfTp0ylXrlyOxSbEq8ya729p8RFCPL8SY0zD1P9eadou+jZ8MCNVsaTzF/ivdRtQCofSpXCuVClVmSeRlGJg0u9nmbH9HHYFYrGx01I738eMfbunRStPVFQU/fr1o2LFirRvb5pHqHHjxrz33ntos3mhUyFE1kjiI4R4Pl07Ais+gdvnQaODuoOh6leQRgJhXziAXM2aoZKTcShRIlvD2HX+AkPWnubfCAMANXJ1pt2bnlQv9GBkmFKKRYsW0bNnT27evMny5ctp0aIFLi4uAJL0CPEckcRHCPH8ubwf5r8DhmRwL2RaUb3Qg1YcpRSxGzfi8uabaJ1NszDnGzwITTbOdJyUYqD3+qX8fmsSek1xPJ1bMaJJKRqWtpwj6OTJk3z++eds374dgBIlSjB9+nRz0iOEeL5I4iOEeP74VIACQeDoAY2nglNui8M3Ro/m9oKFuDf7EJ8RIwCyNek5cvkOvZYf5XzsbRz94vHwuM7KdpUo4O5uLhMfH8/w4cMZN24cKSkpODo6MnjwYLp164adnV22xSKEyF6S+Aghng/hxyBPINjYgc7GtKK6vWuaC4y6vFWHqJ8XY1ewULYuLpqQnMKwjdtZuicRowIvl2L832vD+aJKI2wfWdn91KlTfPvttyileP/995k0aRJ+fn7ZEocQIufIqK6HyKguIZ4BpWDvNNgyGCp1hAYjUxfR60m+cgX7gADzPv31G9h65822MLaeOU2fsCEk2f7D3fOhNC5ZhsHvlcTD+UHrzd27d3G+92gNYPjw4ZQpU4bGjRtnWxxCCOvJqC4hxIsh/jb88jmc2WDajrkKRoPFshP669e58uVXpFy/TsCaX7Dx8ADItqTnbpKeL9fN5EDMfDT2iWiUjk71bOkb/KDzsl6vZ8KECYwePZo9e/ZQrJhpHqGBAwdmSwxCiKdHhhoIIZ6NS/tgRrAp6dHZwzvj4aP5FkkPgM7NDWNcHMakJJLPn8/WENafPEnwglYcvDsDjS4RN21hFtZfQt/gVuYyO3fupHz58vTp04eoqChmz56drTEIIZ4uafERQjxdRiPsngi/DwdlgNxFTAlP/jIPiiQkoHV0BEDr6EjBSRPRurpim00LecYmJtN5zTSO3P0RjX0SKBsa+33KkJqdsdGafi3evHmT3r17M3/+fAC8vLwYN24cbdq0yZYYhBDPhrT4CCGerthw2PmdKekp/RF02m6R9Nzdu49zDRoSs2mzeZ/9a69lW9Kz+vgxghe24GjiHDS6JDx0r/Nzo2WMqP2VOelZsGABxYoVMyc9HTt25PTp07Rt21bW1xLiBSctPkKIp8u9ADSeAgl3oEKbVKO27u7ZQ8r169yeOxfXem9nW6JxJyGJkDUT+TthCRp7PRjt+KhIRwbUaI/ukcdr4eHhREVFUaZMGWbMmEHVqlWzJQYhxLMniY8QImcZDbBzPBSsCEXeMu0rkf4oqDxffoHW0ZHcbVpnW9Kz7Mghvtk/FKP9BTRa8LIpwfT6own0Mo0Si42N5dq1a+ZOy927dydPnjy0bdsWGxv5NSnEy0SGsz9EhrMLkc1ir8OqDnBhOzjngS8PgmMu82GlFHeWLSf+wAF8xo7J9sdI0fF6hq8/yepTYTj5zQajPf97/XN6V2uHVqNFKcWKFSsIDQ3F3d2dI0eOyOSDQryAZDi7EOLZO7cNVnWEuzfA1gnqjbBIegD0ly4RMWIE6PW4NWqI61tvZdvl1x+/yNC1/3IjNgmNpijlnT5lcN0PKeLhC8C///7Ll19+yaZNmwBwcHDg0qVLFC1aNNtiEEI8fyTxEUJkL0MKbB8NO8YBCvKWNI3ayvN6qqJ2fn549+qJSjHgUqtWtlz+Zmw87deM5VzSb9xN/JLCXoUY06wMFf3fASApKYlvv/2WkSNHkpSUhJ2dHX379qVv37443htJJoR4eUniI4TIPsnx8OOHcGm3aTuoHTQYDbamhMKYnMytKVPxaNkC2/ymxT5zZ+Pw8A3Hw/l6zTHiPQ9i4xRP1TIXmNukFQ62ps7LERERvPnmm5w9exaAunXrMnXqVF5/PXVSJoR4OUniI4TIPnZO4OEHEcfhve+hdDOLwxFDhhK9ahUJR47gu2B+tvXpCY+JY+jav9n4dyQAAS5t+DDIyBdvfGxxDW9vbwoVKkRcXBwTJkzg448/luHpQrxisjSPz7Rp0wgICMDBwYGgoCB27tyZYfnt27cTFBSEg4MDhQsXZsaMGRbHZ82aRXBwMB4eHnh4eFC3bl3279+f7vlGjRqFRqMhNDTUYr9Go0nzNXbs2KzcphAiMwx6SIx+sN1onGlunkeSHgCvjh2wLViQ3O3aZUvCoZRi2p4w6i39gG0356PTaviidhE2ftmULys1x2g0MmPGDO7cuQOYfkcsWLCAU6dO0bx5c0l6hHgFWZ34LF26lNDQUAYMGMDhw4cJDg6mYcOGXLp0Kc3yFy5coFGjRgQHB3P48GH69+9Ply5dWLlypblMWFgYLVu2ZNu2bezZswdfX1/q1avH1atXU53vwIEDzJw5kzJlyqQ6Fh4ebvGaO3cuGo2GDz/80NrbFEJkRtR/MK8hrOxgWmwUwN4FPIsAkBIZSdxDfxjZ+ftTZOMGXN+q/cSXvhIVTcOFfZl2ugvYReCQ6xiLO5WlV/1A7G10HDhwgEqVKtG5c2e+/vprc72CBQvi7u7+xNcXQryglJUqVaqkQkJCLPYFBgaqvn37plm+d+/eKjAw0GJfp06dVJUqVdK9RkpKinJ1dVULFiyw2B8bG6tee+01tWXLFlWzZk3VtWvXDGNt3LixeuuttzIs87Do6GgFqOjo6EzXEeKVdXKdUqMKKTXYzfTfm2ctDidduqROV6+hTpUtpxL//TfbLms0GtX47RtVqZm1Van5pVSp+aXU+0tDVETsTaWUUrdv31adO3dWGo1GASpXrlzqhx9+yLbrCyGeP9Z8f1vV4pOcnMyhQ4eoV6+exf569eqxe/fuNOvs2bMnVfn69etz8OBB9Hp9mnXi4+PR6/Xkzp3bYv8XX3zBO++8Q926dR8b6/Xr11m/fj2fffZZumWSkpKIiYmxeAkhHiMlCTb0gaX/Mz3iKlAROu0EL8th4LYFCuDw+mvYFSr4oDXoCf17K5I687sx93wvsLuJzuhGz7KjWPPxdPI6e/Ljjz8SGBjI9OnTUUrRunVr/vnnHzp27Jgt1xdCvPis6tx869YtDAYD3t7eFvu9vb2JiIhIs05ERESa5VNSUrh16xb5743seFjfvn0pUKCARYKzZMkS/vrrLw4cOJCpWBcsWICrqytNmzZNt8yoUaMYOnRops4nhAAiz8GKTyD8qGm72ldQZzDobAFIOn8BOz9fNDodGq0Wn/Hj0To6onVweKLLGo2Kb7atZemF8Whso9AAgc5v8UOjoeR2ygXAmDFj6Nu3LwDFixdn2rRp1MqmIfJCiJdHljo3P9ohUCmVYSfBtMqntR9Mv7wWL17MqlWrcLj3y/Ly5ct07dqVH3/80bzvcebOncv//ve/DMv369eP6Oho8+vy5cuZOrcQrySlYHlbU9LjmBtaLTNNSngv6YlasoQLTZoQOXuOuYqNh8cTJz1/h0dQc97nLLvyNRrbKGyMngyu+D3Lm000Jz0An3zyCQUKFGDkyJEcOXJEkh4hRJqsavHx8vJCp9Olat25ceNGqlad+/Lly5dmeRsbGzw9PS32jxs3jpEjR7J161aLzsuHDh3ixo0bBAUFmfcZDAZ27NjBlClTSEpKQqd7sMjgzp07OX36NEuXLs3wfuzt7bG3t8/4poUQJhoNvDcRtg6FJtNNi40+fNjOHpWcTMLxY4/9YygzDEbFwM1LWHt1Chob02Posu6NmNZwIG72Lvz6669s2LCBqVOnApA3b17OnTsnn2khRIasSnzs7OwICgpiy5YtfPDBB+b9W7ZsoXHjtBcdrFq1KuvWrbPYt3nzZipWrIitra1539ixYxkxYgSbNm2iYsWKFuXr1KnD8ePHLfZ98sknBAYG0qdPH4ukB2DOnDkEBQVRtmxZa25PCPGom2fgxgkoee/zXiAI2qwxr6huTEhAe2+2Y/cPmmDj5YlzcPATJz1nrsfSa8URzuoWoXOMwU7lZXi1YTR6vTqXLl2ibdfW/PLLLwA0bNiQd999F0CSHiHEY1k9gWH37t1p3bo1FStWpGrVqsycOZNLly4REhICmB4fXb16lYULFwIQEhLClClT6N69Ox06dGDPnj3MmTOHxYsXm885ZswYBg4cyM8//4y/v7+5hcjFxQUXFxdcXV0pVaqURRzOzs54enqm2h8TE8Py5csZP368tbcmhHjYkcWwvrtpdXXPopCvtGm/RoMxIYHr335LwrFj+C9ZgtbODo1Gg8ubbz7RJZNTDEwPO8vUbRdINhhxdWlO1XIXmVi/NzbYMGbMGIYOHUp8fDw2NjZ0795dHmkJIaxideLTvHlzIiMjGTZsGOHh4ZQqVYrffvsNPz8/wDSXzsNz+gQEBPDbb7/RrVs3pk6dio+PD5MmTbKYW2fatGkkJyfTrJnlhGeDBw9myJAhVsW3ZMkSlFK0bNnS2lsTQgAk34XfesGRn0zbAW+Cc16LIobYWGI3bsJw5w53//wT19pPPi/PjnP/0mPbIGJiPEg2NKJOYF5GfPAW+d0d2blzJ507d+bEiRMABAcHM23atFR/+AghxONolMqmcaYvAWuWtRfipXT9BCxvB7fOgEYLtfpBcA/Q6lIVjduxA42NDc7Vqj3RJRP1Bib/cZZZB3/FvuACMNrSp9Qi/lexBBqNhpSUFAIDAzl37hxeXl6MGzeONm3ayKzLQggza76/Za0uIYTJXwtNLT0pieCaHz6cDf41ANBfv074gK/J0+UrHO8NPHjSx1oA+y7coP+qk5y7eRcozuvapgyq8zEVfYpjNBrR6XTY2NgwadIk1qxZw6hRo1LN7yWEENbI0nB2IcRLKPa6KekpWhdCdpmTHoBbU6Zwd9cuwgcNJjsaieOSkmm9fDyf/t6U81HheLnYM+P/gvi19VBsbyZTrVo1pk+fbi7fqFEjfvjhB0l6hBBPTFp8hHiVGQ0PHmMFdwcPfyj1IWgt/ybK27MnKVFR5O3R44kfMa069hfD9g3FYHcerS2UKX6KBR98iDYlkdDQUCZPnozRaOTq1at07NgROzu7J7qeEEI8TFp8hHgVKQX7ZsLsuqBPMO3T6qDMR6DVknD8OJFz5pqL69zdKTRlCvYBAVm+5O34BD5a/A2DDn2Gwe48GO35OCCUVS0Hs2ndagIDA5k4cSJGo5GPP/6Yffv2SdIjhMh20uIjxKsmIQrWfAn//GraPvITvNHefDj58mUutmwFKSk4lCiOc9WqT3zJHw/tYexfwzDaXUGjhbw2ZZnRYCS66BQaNWzE5s2bAShatChTp05Ntb6fEEJkF0l8hHiVXDloWmvrziXQ2pqWnKhouZCvXaFC5Gr2IYboaBxKlHiiy12PiaPD2tGcT1mHxs6IxuhEu2Jd6Va1JRqNhiOXj7B161bs7e3p168fffr0yfSyNEIIkRWS+AjxKjAaYc8U+H0oGFNMfXmazYMCFQCI2bIF56rV0Lk4A5Dv669Bp8tyfx6lFDP2bWP63yNRttfRaKCgXWVmNvqGpJux5vOWK1eOH374gZo1a/Laa69ly60KIURGJPER4lWwbQTsvDebeckPTGtuObgDcGPcOCJnz8G9aVN8Rn4DgMYm678a/rt9mw7rRnBNbUVjq9AaXfm8dC/ezV+J0PZf8ssvv3D48GHz5IPt27d/zBmFECL7SOdmIV4FFT8FVx94d4Kppede0gPgUrMm2Npimy/fEw1VV0qx7MBl3p09j3C2oNEoijjWZEPTX4jfeZHAwEBWrFiBUopdu3Zlx10JIYTVpMVHiJeR0QAXtkORt0zb7gWhy2GwdUClpJB8+bJ5hJbTG29QdMtmbPPly/Ll/rt1lwG//M2uf28BgRTwqMWXVd7HP86FRjXrcfToUcC0aPH06dNlAWEhxDMjLT5CvGxir8OPTWHRB/DPbw/22zqgv3GD//6vNf+1aUNKVNSDQ1lMegxGRd+NP/HOqib8eeEi9jZa+jcKZPunE9k/9zeqVavG0aNHyZ07N7NmzWLXrl2S9Aghnilp8RHiZXJuG6zqCHdvgK0T6OMtDutcXTHExqISEkk6cxabypWyfKmz12PptfIwZ3Tz0TlE4Fd4P/MbD8Pfy9RBulChQgB88sknfPvtt+TJkyfr9yWEENlEFil9iCxSKl5YhhTYPhp2jAMU5C0BH82HPMUwJiSgdXQ0F03691+0jo7YFiiQpUsl6Q1M336WqdvOozcoXF3DqVY2gvYFG2BMMlC5cmUAUlJSOHTokHlbCCFyijXf3/KoS4gXXfRVWPAe7BgLKAhqBx3+gDzFuLtvP+cavUPMbw8eedkXLZrlpGfLmZNUX9CCaUdmojco6gTmZVW7JriG3aFqxSq0adOGpKQkAGxsbCTpEUI8d+RRlxAvuisH4NJusHOF976H0s3Mh+L37SUlPJzIefNxbdgwy/PyxCUm8/mvk/gr9mc0tnrsPf9jRO0QtBeOU7vyB1y9ehWAUqVKERcXh729fXbcmRBCZDtJfIR40ZVsAneGQeC74FnE4pBX585o7OzI3bp1lpOelccOMnz/EAy2/6HRQi5NcfqX+ZzJA0PZsGEDAAEBAUyZMoVGjRo96d0IIUSOkj4+D5E+PuKFEHURNvQ1TULo6m3erZTizvLlxO/dh8/4cU+8inrk3Xg6rh3D6aRf0GgMYHSgeeHONPOuRvny5UlMTMTOzo4+ffrQr18/HB/qRySEEE+TNd/f0uIjxIvk5BpY8xUkRcNvNtD8R/Mh/ZUrXB8+AqXX49qwAW5vv53ly8zZH8bEYyNRtuFoNJDPJogfGn5D4dwFUEpRs2ZNUlJSmDp1KsWKFcuOOxNCiKdCEh8hXgT6RNj8NRyYZdouUBHqfWNRxK5QIfL26YNKSsK1Tp0sXebKnTt0WDeCy4bNaGwVGqMLLQt15Pyy3eRqaGrR0Wg0LF++HBcXlyduVRJCiKdNEh8hnne3/oUV7SDiuGm7WheoMwhjipFb48fj0aKFeZRW7v/7X5YuoZRiwq71zDs9Fmxvo9GAv30wVW4EMKppV2JjY9FqtPzwww8AuLq6ZsedCSHEUyeJjxDPs0t74ccPITkOnDzhgx/gNdMjrIhBA4heuYqEw0fwXbQwy60v1+4kMOCXY+xLnoDO/jY6owcf5m7F6qEz+frwdAAqVapEp06dsu22hBDiWZHER4jnmXcpcM0HLt7w4Wxw8zEf8goJIf7AQXJ/9mmWkh6jUfHTvv/4duNp4pJSsHduRonXz+K+PZbBMz5HKUWuXLkYPXo07du3R6fTZeedCSHEMyETGArxvIm6CPcHW9q7QNt10GYtKcl2xIaFmYvZFSpEkd/W41q7ttWXOHD5IjXmt2X4rqnEJaVQwTcX6zv9H4X2KuZOn41SirZt23L69Gk6deokSY8Q4qUhiY8Qzwul4K+FMLUK7Jn6YL+bD8nXwjn/fmOudg0l6dw58yGNjXWNtnqDkanb/qX1zz8SqzuMndc2+jT0ZXlINYrmdeXrr7+mZs2abN++nfnz55M3b97sujshhHguyKMuIZ4HSbHwazc4vty0fXEnVP0C7j3Csi1QAIcSJUi5eTPLl/jr0i36rzrJPxGxQDny57mF7wUjG1YPIOTNNQB4enoS9lCrkhBCvGwk8RHiWQs/Csvbwe3zoNHBW19D9VCSzp/Hzs8PjY0NGq0Wn7Fj0Do5obVyOYiYxEQ+XzeBw3c2cffGV3g4ufJO/gQWDllF2OXLAPz555/UqFEjB25OCCGeL/KoS4hnRSnYNxNm1zUlPW4F4ZMNENyd24sXc77JB0TOmmUubuPhYXXS8/Ph3bz54wccjf8ZrV0kJYv+jfehmXzTsQmXL1/G39+fdevWSdIjhHhlSIuPEM9K5L+wqR8YU6BYI2g8FZxyA6BzcQG9nsR/TqOUsnrUVkRMNB3WjeKCfgMaWyMYnSga+QYbB44mMTERW1tbevfuTf/+/XFycsqJuxNCiOeSJD5CPCter92bfVlB5RCM8fHmJli3999H5+WFc7VqViU9Sikm7d7A7FNjwDYSjQYK2lZlUt2veadGXRITE3nrrbeYNm2aLDUhhHglySKlD5FFSkWOMhph71QoXAvylTbvNsTd5frIkSSeOIH/8mVo7eyydPqzN2/Q6bch3GQnAFpDLr4o3ZOObzQGICwsjGvXrtGyZUtZakII8VKRRUqFeN7cjYRfQuDsZvB8DUJ2gq1p7SuVEE9cWBiGqCji9+zBpWZNq05tMBgZ/Mdi1lyaCjaxAOSOK8/R4b9xt895eMNUrlatWtl5R0II8UKSxEeInHZxF6xsD7HhYOMAVb9A6ey53+ZikycPPmPGoLGzxblSJatOvf/yebpuGUSc7ijYgC4lL4aNRnasWATA+vXrCQ0NlRYeIYS4R0Z1CZFTjAbYPgYWvGdKerxehw5/kJyvHpfatiPhyBFzUZca1a1Keu5PRNhm8ULidEdRSovrtdIc/3wHf68II1euXEyfPp1NmzZJ0iOEEA+RFh8hckJiNCz9P7iww7Rd7n/QaCzYORM5cCDxBw4QPmwYAStXWp2YWE5EGISHazj/zd/Bif2LAWjbti1jxoyRWZeFECINkvgIkRPsXAAN2DrDu99B2RbmQ3l79cJ49y55une3KumJSUwgZN13HI3aem8iQhcGvVeCojb+VOgylxIlSjB9+nTefPPNHLghIYR4OciorofIqC7xRAx60+MtWwfTdux1SIoh/sId4g/9hVdIpyyfetfZW/RdfYAoj1Fo7aLIG/s+y9oNwtPFNKFhWFgY1atXx9bWNjvuRAghXigyqkuIp+3OZVj5GXiXhHcnmPa5epN8O5H/2rYDoxHHMqVxrlbNqtNGxEQzbuN5Vvx1DQB3w4fEnVxF2M+juVzjIzzLlQNkxJYQQmRWljo3T5s2jYCAABwcHAgKCmLnzp0Zlt++fTtBQUE4ODhQuHBhZsyYYXF81qxZBAcH4+HhgYeHB3Xr1mX//v3pnm/UqFFoNBpCQ0NTHTt16hTvv/8+7u7uuLq6UqVKFS5dupSV2xQic/75DWbUgMv74PgKiAk3H7Lz88OjZUvcmzbFoUzZTJ9SKcV3O9fx9vL3WXNhJRog961jHB/Sj/M/7sDX15fY2NgcuBkhhHi5WZ34LF26lNDQUAYMGMDhw4cJDg6mYcOG6SYXFy5coFGjRgQHB3P48GH69+9Ply5dWLlypblMWFgYLVu2ZNu2bezZswdfX1/q1avH1atXU53vwIEDzJw5kzJlyqQ6du7cOWrUqEFgYCBhYWEcPXqUgQMH4uDgYO1tCvF4KUmwsR8saQmJd8CnAqrjdqK37ccQF2cu5j2gPz4jv0Hn4pyp0564fo3aCzox73x/sLmNg8duIpf35/Cc/tioFAb8f3t3HhdltT9w/DPMsG8iyCKaYC5opAnkUlct9aKWZaldtaK08kbpzaVromUumRhZeg33/JnWdbkued0SMZdUsBSXcK9cQAURVMAFhpk5vz/IuU6gAgnD8n2/XvN69Zz5nuc535M2357lPO+/z5EjR2jfvn05JSaEENVXqe/xadOmDSEhIcyePdvc1qxZM5577jmio6OLxI8aNYq1a9dy7Ngxc1tkZCSHDh0iMTGx2GMYjUY8PDyIjY3llVdeMbdfu3aNkJAQZs2axaRJk3jkkUeYPn26+ft+/fpha2vL119/XZqUzOQeH1Fil0/BioGQdrBwu+1g6DKe9CmfcuWbb3Dv2ZO6n0wp1S4NRhOjNy/ku7R5aLQ3UEoDZx7g2NR4TNf18qoJIYS4g9L8fpfqjI9erycpKYnw8HCL9vDwcBISEortk5iYWCS+a9eu7Nu3j4KCgmL73Lhxg4KCAmrXrm3RPnjwYJ5++mm6dOlSpI/JZGLDhg00adKErl274u3tTZs2bVizZs0d88nPzycnJ8fiI8Q9GQ2wuGdh0ePoAf2XQ7fJoLPD7anuaOztsW/SmNL8P8WOU8d47Kt+bMqYjkZ7AzuTPzGPzSPSqxverrVZsmQJW7ZskaJHCCH+pFLd3JyZmYnRaMTHx8ei3cfHh/T09GL7pKenFxtvMBjIzMzEz8+vSJ+oqCj8/f0tCpxly5axf/9+9u7dW+xxMjIyuHbtGlOmTGHSpEl88sknbNq0iV69erFt2zY6FvMagOjoaCZMmHDPvIWwoNVBt08g4QtMPWahv1rArYupTiEhNNr6PTpPzxLt6lp+PkM2/It92cvQ6ApQJh3N6MI3ER9jr7PD+OCjRERE4O7uXn75CCFEDVKmp7r+uPaIUuqu65EUF19cO0BMTAxLly5l+/bt5ntzUlNTGTp0KJs3b77j/TomkwmAnj17Mnz4cAAeeeQREhISmDNnTrGFz+jRoxkxYoR5Oycnh/r1698xD1GDZRyHa+mFLxgFCHqKAteWpA4ajCEri4b/XWMudkpa9Cz/OZEpP03EYHsOjQ0Yr/hyesbP3NSsxtRvYuErKLRaKXqEEOI+KlXh4+XlhVarLXJ2JyMjo8hZnVt8fX2LjdfpdHj+4Qdi6tSpTJ48mS1btljcvJyUlERGRgahoaHmNqPRyA8//EBsbCz5+fl4eXmh0+lo3ry5xT6bNWvGrl27ih2bvb099vb2905c1FxKwcF/w8aRoLOHyF3gXg8Aradn4bo9JhP6lJQSFzwXc3P4+7rJ/KbfiMZWoQwOXNoEGSu34OHhwagpo+TPpRBClJNSFT52dnaEhoYSHx/P888/b26Pj4+nZ8+exfZp164d69ats2jbvHkzYWFhFoutffrpp0yaNIm4uDjCwsIs4jt37kxycrJF28CBAwkKCmLUqFFotVq0Wi2PPvooJ06csIg7efIkDRo0KE2aQhTKz4X1IyD5P4Xb9VtjvJGP9vcTMDYODvj/awZaVxd0dercc3dKKb47nM6H65K46b0LG1tFfqovp//1I4bMXAYMGEBMTAx1SrAvIYQQZVPqS10jRowgIiKCsLAw2rVrx7x580hJSSEyMhIovHx0/vx5Fi9eDBQ+wRUbG8uIESMYNGgQiYmJLFiwgKVLl5r3GRMTw9ixY1myZAkBAQHmM0QuLi64uLjg6upKcHCwxTicnZ3x9PS0aB85ciR9+/alQ4cOPPnkk2zatIl169axffv2Uk+MqOHSfoYVA+Dyb6DRwpNjyC1oRVqvCHzGjMH9mR4A2DcMLNHuTl66SMzGs2w5dgnQUMe2D79t+pIrW7cQHBzMrNWz5PF0IYSoCKoMZs6cqRo0aKDs7OxUSEiI2rFjh/m7V199VXXs2NEifvv27apVq1bKzs5OBQQEqNmzZ1t836BBAwUU+YwbN+6OY+jYsaMaOnRokfYFCxaoRo0aKQcHB9WyZUu1Zs2aEueVnZ2tAJWdnV3iPqIa+nGeUhO9lBrnptRnzZQ6k6CUUipjxhfqaNMgdeblCGUymUq0K6PRpEbHLVYPLWijGkV/qBqN2aA+izuubuoNqn///mrq1KlKr9eXZzZCCFHtleb3W97VdRtZx0cAsG4YJC2EJt1RPWeicS68d0cZDFxZsoRa/fphY2d3z938cjGXqNXJ/Jz7Xxx8NmLMrsuXXebyWPOA8h2/EELUMOW2jo8Q1dbvTwUC0C0a9cwXZF7rxLlR4/73FKJOR+1XXrln0XNdn89H3+3iqRk7STp7BeOlR8n63pNj725hzVezyjMLIYQQ9yAvKRU1m8kEiV/A6Z3w4n/AxgZsHSnw7EBmbE+UXs+1HTtwLeFLQFcm7+HjnyaiN96kwDSUvN8Okhk3E21+Dh+O+YCoqKjyzUcIIcRdSeEjaq7rmfBtJPwaX7h9fB00L3w60S4gAJ8xY9DY2uJSzBpQf5RxLYe/r4vm1/yNaHQmNDiQnTiFqzt+JDw8nNjYWBo3blye2QghhCgBKXxEzXR6J6weBLlpoHPA2GECGcuS8Px7KHb1Ctfp8ejXt0S7+iJxI/OPxqB0WWg0YHu1EYc/3kodWxfm/ec/9OnT564LfAohhKg4UviImsVkhB8+hR2fgDKBVxN44SvSYxaSs2ED+lOneeDrxSUqVI5npPH2d+O5RALowMbowdsPj6Rv4/Z8mvEpo0aNkpvkhRCikpHCR9Qs64fB/sI1pnjkZXgqBuycqTN8GPm//kqdEcPvWfQYjSbGbPmKDefnmt+ibnMukO+HL8bLuXB1w48//ricExFCCFEWUviImqX13+H4BvQt/0meehA3O2cA7OrVI3DNt/cserb/doz3dnzITe1xNFow5Hpw/v/OYZeym9yXLuMVKO/VEkKIykwKH1G9GQvg3F5o8Fjhtu/D5D+7ltMvvgoGA3YNA3Fo0gQo/qW5t+QVGHlr3efszV6CRmtAmXRcSXDhwle7eWPAa0RvjsbLy6siMhJCCPEnSOEjqq8rZ2HV63DhILweB/6FL7m1a/oQTo+GoW7cROvics/dJPyayZhvk7nARey9DeRn1CF11hGauvux8oddtGvXrpwTEUIIcb9I4SOqp6NrYe0QyMsGe3duJO3D0aclGp0OjUaD/2efYePoiEarveMuUq9mMTnuJ747ULi4YR3XLuRuO0z66gSmfPQRgwcPRqeTv0JCCFGVyH+1RfVSkAebP4C98wu3/cO4lN2JzPem45VqoM7gwQB3PdOjlGJmwlbmHv8Qo8ERjeYfRLR9kJFdm3LqhB91Jtehbt26FZGNEEKI+0wKH1F9ZP4KKwdAenLh9uNDodNY7DbGAd9gzLqMUuqu9/KkZN3g/TXJ7DyVhXNDI6ibdK11mIk9Cxc2bNmyZfnnIYQQotxI4SOqj1/iID0Z5eiJsfNUdGG9AHB/pgd2AQE4Phx8x655BQV8GP8f1iZ4kGdQKIMtF7/15saubbw+tldFZSCEEKKcSeEjqo82b2HISOfCmhQMu74iYOXT2NjbA9y16Fl7dB/jE8dToDuLwfFFbiYrLm+eSdfHWvHFgZ8JDAysqAyEEEKUM3k7u6i60g/D0hch/1rhto0N/GUYeSd/Q3/2LHk//3zX7pnXc+m9bAxjfnqdAt1ZlNGe3EPrcUicy8qFs1i3bp0UPUIIUc1I4SOqHqVg3//Bl53hxAbU95PMX+k8PfH//HMCV63E6dFH77iL2MQNdFr2DCfz16HRmPAwteLcpDRee7ADR48epWfPnvJ+LSGEqIbkUpeoWvKyYe07cHQNADdd2nMh9hB+vvtxCgkBwLlN6zt2P37pQuH7tVQi6EBjrMWbD73L4DbPcbnnZWrXrl0RWQghhLASOeMjqo5zSTCnfWHRY6OD8ElcyWqB/tQZMj77/K5djUYT78V9SZ91z3NJJaKUhtwj3kwL+pjBbZ4DkKJHCCFqADnjI6qGo/+Fla+ByQC1HoA+C6FeGD4trmHj5ESdfwy5Y9ftp47w3vZx3NSe+P39WrU5v/A8EW2DCGn2cAUmIYQQwtqk8BFVQ/024FCL7Jwg8gva410vDChciNB37AfFdskrMPLexiVsvfy5+f1aVxNc8fn5BlvnLiMsLKwiMxBCCFEJyKUuUXll/fa/f3b1Ja/TQi6sPEXWgkXc2Lv3rl13/ZJJ1+k/sO4nO1C25Gd4c/HzXD4IfZGfEvZI0SOEEDWUnPERlY/JCD9MhR1ToM//wUPPA+AQ1oHaAwZg4+yMY6tWxXY9dTmD975bxL7k5gD4unnRKvdlriXvZeqWJfj4+FRYGkIIISofjVJKWXsQlUVOTg7u7u5kZ2fj5uZm7eHUTLnpsOoNOLMTZYKs653xGL8IrasrwB1fOaGUYslPvzLl8ADQ5XAzNYKXWzzNu+FNcHWwreAkhBBCVKTS/H7LpS5Refy6BWY/Dmd2gq0zF1L/yqUNx0ifMNEcUlzR82tGLn1m7+b9b0+SfzUEw/Va2CZtYtwzzaXoEUIIYUEudQnrMxbA1kmwe3rhts/D8MJCPFKvcf3EEFy7dC62W25eHkM2fM7uZC8Mef6Y9Hmkr0yls783M2ZMlwUIhRBCFCGFj7C+lD2wezqGfBsK6vfC8Y2ZYOuAkxc0+n4LNo6ORbos3r+Nz/Z/jMn2Ina+9cnZEobLiY0sj/mI7t27WyEJIYQQVYEUPsL6AtuT3/jvnP1iB9gcp+HfrqHzcgAoUvScuXKJyA0TOW/cDrZgKnDiypbLRD6kYfTXO3EspkgSQgghbpHCR1S8gjzY9jG0eRPc6wFg22cSuuV/QxmNGHNy0Hl5WXQxmUxM2PZvVp+dBdrCl5I2sO1EiwueDIzuT+PGjSs8DSGEEFWPFD6iYmX+CisHQHoyBUf2oBsah8bGBht7e+rPnoW2du0iZ3l2nTnOiO/HclN3HLSgNfgS9egH9GvR0To5CCGEqLKk8BEV59AyWD8CCq5z+UwdMval4ffgetyffRYAW39/i/Br+XkM2TCNfdn/QaMzoExasvd5MOmxV6XoEUIIUSZS+Ijyl38NNo6EQ0sKtwPaY3LvgNqzkGs/7DQXPrf75sB2Pt03CZPdRTQ2oM/0xn2nlqUffcbDD8v7tYQQQpSNFD6ifF05C9/0hqxfUCYbNJ1HQ/t38TQp7Jq1wLVrV8vw63o+3LCLbTeGo7EzYSpw5Np2J8Z1fpkBq1/FxkaWnhJCCFF2UviI8uXijcloS/r+uhjcgqk/YSQajQaNDbh162YOU0qx5uB5Plp/jMvX9dh7P0bBlV9pf/VBps2YTO3ata2YhBBCiOpCCh9x/+Vlg50L2GjB1pGCDtHkLByK0h/h5oGDOIVYvmdrT8pJhsZ9yKXUcEx6H5r6uDImfAyO19No3bq1lZIQQghRHUnhI+6vc/tg5UAIeQU6jATAPuQJ/CZOROfnZ1H05BuMTN90hK9ORaNzP4K9Tx7/aD6VQR0aYqu1AepbKQkhhBDVlRQ+4v4wmSDxC/h+IvocRfqGr/Cd+xx2DQvX13Hv2dMifPevFxm6+Ecy9Vo0uqexzcui6Sl3Xh3g93vRI4QQQtx/8gsj/rzrmbDkbxD/IZgMXDzZlOupJtInxxQJPZV1kSf/bxCvb3iPTL0W47Ur2O7ZwJywKNbNWYSzs7MVEhBCCFFTlKnwmTVrFoGBgTg4OBAaGsrOnTvvGr9jxw5CQ0NxcHCgYcOGzJkzx+L7+fPn0759ezw8PPDw8KBLly789NNPd9xfdHQ0Go2GYcOGWbQPGDCg8MbZ2z5t27YtS4qipE7vLHyj+q/xoHOAHtPxnbUClyeewHf8eHOY0WhiTPwCnv3vs2Rq96BzP4D+1LcM8k/j8MZFdOrUyXo5CCGEqDFKfalr+fLlDBs2jFmzZvH4448zd+5cunfvztGjR3nggQeKxJ8+fZqnnnqKQYMG8c0337B7927efvtt6tSpQ+/evQHYvn07/fv357HHHsPBwYGYmBjCw8M5cuQI/n9Y1G7v3r3MmzePFi1aFDu+bt26sXDhQvO2nZ1daVMUJXU9C5b8jevnDBRoGlJr3Dfg8xC2QP05s81hW39LJmrHeG5qT6LRgumGJ3WS/dg49cNi/8wIIYQQ5UWjlFKl6dCmTRtCQkKYPft/P2zNmjXjueeeIzo6ukj8qFGjWLt2LceOHTO3RUZGcujQIRITE4s9htFoxMPDg9jYWF555RVz+7Vr1wgJCWHWrFlMmjSJRx55hOnTp5u/HzBgAFevXmXNmjWlScksJycHd3d3srOzcXNzK9M+apqbSyZw5qNlaHS2BKxciUPTJubvrty4zuurPuKkcRMajRFlsuUvXi8y4bEB+Hh63WWvQgghRMmV5ve7VJe69Ho9SUlJhIeHW7SHh4eTkJBQbJ/ExMQi8V27dmXfvn0UFBQU2+fGjRsUFBQUWbtl8ODBPP3003Tp0uWOY9y+fTve3t40adKEQYMGkZGRccfY/Px8cnJyLD7iHk7Gwfkk86ZDv7G4PPEk7r16YVe/nrk9dvc62v+7O7+YNqDRGLG9/iCLuq5gzjP/lKJHCCGE1ZTqUldmZiZGoxEfHx+Ldh8fH9LT04vtk56eXmy8wWAgMzMTPz+/In2ioqLw9/e3KHCWLVvG/v372bt37x3H1717d1544QUaNGjA6dOnGTt2LJ06dSIpKQl7e/si8dHR0UyYMOGuOYvfGfTw/QRUQiw5mfVxm7IDjasnGhsb6s34FxpbWwCOZ5zjtW+jyHU4hMYOTHpnnJLr8+8hH9Ok7oNWTkIIIURNV6bH2TUajcW2UqpI273ii2sHiImJYenSpWzfvh0HBwcAUlNTGTp0KJs3bza3Fadv377mfw4ODiYsLIwGDRqwYcMGevXqVSR+9OjRjBgxwrydk5ND/fqydkwRl0/Dytfgwn4uJNYiJ8WIfsFi6gwbDoDG1haD0cSQNdPYlb0MjUMeSmnQ/1qPUQ+9yGv/eumufz6EEEKIilKqwsfLywutVlvk7E5GRkaRszq3+Pr6Fhuv0+nw9PS0aJ86dSqTJ09my5YtFjcvJyUlkZGRQWhoqLnNaDTyww8/EBsbS35+Plqttsix/fz8aNCgAb/88kuxY7O3ty/2TJC4zeHVsG4o5OeAQy1cXhhEbuxKtN7/+/d9+Hw2Y779mV80u9G55GHI8eKRiy2YN2oSrq6uVhy8EEIIYalUhY+dnR2hoaHEx8fz/PPPm9vj4+Pp+YcF6m5p164d69ats2jbvHkzYWFh2P5+eQTg008/ZdKkScTFxREWFmYR37lzZ5KTky3aBg4cSFBQEKNGjSq26AHIysoiNTW12Mtp4h4MevhuJKYfF2HIs8GuWRvovQD3WvVxeuYNbH19ybiWw4ytJ1iSmIFJgZNjL3Qpa1jU/wNCHnnE2hkIIYQQRZT6UteIESOIiIggLCyMdu3aMW/ePFJSUoiMjAQKLx+dP3+exYsXA4VPcMXGxjJixAgGDRpEYmIiCxYsYOnSpeZ9xsTEMHbsWJYsWUJAQID5DJGLiwsuLi64uroSHBxsMQ5nZ2c8PT3N7deuXWP8+PH07t0bPz8/zpw5w5gxY/Dy8rIo0kQJ2ejI/+0U5+LqgHNtAiesxsbZBQCdjw9T4lfwzZnpFFwPwqR60aOFHx/26Iy328tWHrgQQghxZ6UufPr27UtWVhYTJ04kLS2N4OBgNm7cSIMGDQBIS0sjJSXFHB8YGMjGjRsZPnw4M2fOpG7dusyYMcO8hg8ULoio1+vp06ePxbHGjRvH+NsWwbsbrVZLcnIyixcv5urVq/j5+fHkk0+yfPlyudxSUkqByQBaW7CxQdtnOsblL6JRjhSkpWPfqBEpmdcYOPM7zpCOU0AOWtMJPu7uw0sdQ6w9eiGEEOKeSr2OT3VWo9fxycuB9cMxFmjQ9v/S3Hzz8BHs6vmjd3Zi5PJlrD/kClo7lLEAZ/0qYvv+nU6PtbfiwIUQQtR0pfn9lpeUCrhwAFYMJPtAOulJ7tT3WoXTXwvPyDkGP8SiH+OZeuATlP1lNA7DKTibwd9D3Xh/yFd3vL9KCCGEqIyk8KnJlII9s39/uWgB1y/7YypQXPkuAae/9ib1aiZvbZzEGf1WNI4KZXDggfzdLI8Zj6+vr7VHL4QQQpSaFD411Y3LsOYt1IlNaDRAUA98hnyCw4bvce/fn2HffsH3V5aA9hoaDbjnhTD4gd70f/1Za49cCCGEKDMpfGoipTAtfI5L8adRJg98P3gfHn0DrUbDj2HNGTX/eZRLCmhBZ/BlRMgYIlo9ae1RCyGEEH+aFD41kUZDXr2XuXx8GgC13Dtw48Z1+n0dxQX7XWhcjCiTDveLLdk8fC7OssijEEKIakIKn5oiNx0unYCGHQFw6vl3vFLycWjWjCm/JLJixwJsHK+iAQyX/BkSGMHggS9Zd8xCCCHEfSaFT03wyxYM/36TjH0afGJXow0ofB2I4ZU3+Ouid7juvgcbezDlu9DkcluWDJ2Mo6OjlQcthBBC3H821h6AKEfGAoj/EPVNb85tgexfbbk4fS4Go4kvd56iy2c7uHT1IZSywSa1KYsen8u3UdOk6BFCCFFtyRmf6urK2cI3qp/fh0YDPi8+QfqWK2xu3ZKZ0yZzKbMVAGF+renq3ZA3Xn1G3qAuhBCi2pPCpzo6+l9uLhiK8foNXALc4dlYcut25rXL08ks+AJV2w7Xm434oNtjvBBaHxsbKXiEEELUDFL4VEPXt6wlZaMDWgdnAv/5NVMSM1kwfz3Yt8DpRiI2OVpmPtuIDi0fsPZQhRBCiAol9/hUF7e9cs3xjenY16/DlYdb0n7FRBYcvQb2LpiupNFP24/k99bQoWWYFQcrhBBCWIec8anqlEIdXMKNDYtxilqPRmdLNhrGv9iW/abNaLQmbHXxNEprzOLJA6jjWdvaIxZCCCGsRgqfqiw/F7V+BGnzN5N9xgk/l9F83aY9849+jtJdRqMFU1Z9JoQ+w4udnrL2aIUQQgirk8KnqrpwEFYORHP5FHZurigbDZ8e+pG1HnGgA42hFi83GsK7L/eRN6gLIYQQv5PCp6pRCtOumZjiJqLT5aN38+fdx1txKeQIqX5XUcqGZk49mPXUKOq4uFl7tEIIIUSlIoVPFZP/zTDOz9yAzt6ZI30eYpStCeX4M9QCY44vbwa8xtBn+lt7mEIIIUSlJIVPVdPsWfJz47icZ8dnhksoNw0mgyONc9uz7K3JOMgLRYUQQog7ksKnsjMZUWcS0TT8C0aTYoWhEVs6tebXoP1ku2jQZTRl7jPjaR0UbO2RCiGEEJWeFD6VWU4auVNe5GLcOW6MHcPY8004lHoVnF/AWa+nr1MXPhz5hrVHKYQQQlQZUvhUVr9sQa1+k0u7FAXX7Un4ZhqHGk/E1d6Rd8Ob8HLbJei0sv6kEEIIURpS+FQ2Bj1s/QgSZqABrjzqz6YsO1a2N/BgTjJLXx+Jt5uDtUcphBBCVElS+FQi6tJvZEX1IzsvjcDG8LXhr0y2fQmD336es/Pks+HDrD1EIYQQokqTwqcSSV86k6u7r1GgdeX1gL+wNf9vhNhf5KuoKNxdna09PCGEEKLKk8Knkvh812q+ctrL28Eafg7UsNddz9ddgugQ0svaQxNCCCGqDSl8rMj4615OTBzC2+0bkGV3DGxhVncv2tGN5NdGo9ForD1EIYQQolqRwscalCJ791xOvjcNl8s2dNEdZlkHOx52fpbYp0fi6eRq7REKIYQQ1ZIUPhUtL4eV859nkcN5fDvo6PeDif3+XnzebjrhTUOsPTohhBCiWpPCpwLtWz6DdcdmsTrQFrAlvZGOvHrdWPHWJHmDuhBCCFEBpPCpAAajiUVjXubR9Qf4Sy0NGweYqJ0byLQXYmleP8DawxNCCCFqDFn6twKcvHiNrwyPc90Bctw0vOE6mLgR66XoEUIIISqYnPGpAM3ruvFseGf2NlO88dLrODk6WntIQgghRI0khU8FGdk1CAiy9jCEEEKIGk0udQkhhBCixpDCRwghhBA1hhQ+QgghhKgxylT4zJo1i8DAQBwcHAgNDWXnzp13jd+xYwehoaE4ODjQsGFD5syZY/H9/Pnzad++PR4eHnh4eNClSxd++umnO+4vOjoajUbDsGHD7hjz5ptvotFomD59emlSE0IIIUQ1VurCZ/ny5QwbNoz333+fAwcO0L59e7p3705KSkqx8adPn+app56iffv2HDhwgDFjxvDOO++watUqc8z27dvp378/27ZtIzExkQceeIDw8HDOnz9fZH979+5l3rx5tGjR4o5jXLNmDT/++CN169YtbXpCCCGEqM5UKbVu3VpFRkZatAUFBamoqKhi49977z0VFBRk0fbmm2+qtm3b3vEYBoNBubq6qkWLFlm05+bmqsaNG6v4+HjVsWNHNXTo0CJ9z507p/z9/dXhw4dVgwYN1LRp00qWmFIqOztbASo7O7vEfYQQQghhXaX5/S7VGR+9Xk9SUhLh4eEW7eHh4SQkJBTbJzExsUh8165d2bdvHwUFBcX2uXHjBgUFBdSuXduiffDgwTz99NN06dKl2H4mk4mIiAhGjhzJQw89VNK0hBBCCFFDlGodn8zMTIxGIz4+PhbtPj4+pKenF9snPT292HiDwUBmZiZ+fn5F+kRFReHv729R4Cxbtoz9+/ezd+/eO47vk08+QafT8c4775Qon/z8fPLz883bOTk5JeonhBBCiKqpTAsYajQai22lVJG2e8UX1w4QExPD0qVL2b59Ow4ODgCkpqYydOhQNm/ebG77o6SkJP71r3+xf//+u47ldtHR0UyYMKFEsUIIIYSo+kp1qcvLywutVlvk7E5GRkaRszq3+Pr6Fhuv0+nw9PS0aJ86dSqTJ09m8+bNFjcvJyUlkZGRQWhoKDqdDp1Ox44dO5gxYwY6nQ6j0cjOnTvJyMjggQceMMecPXuWd999l4CAgGLHNnr0aLKzs82f1NTU0kyHEEIIIaqYUp3xsbOzIzQ0lPj4eJ5//nlze3x8PD179iy2T7t27Vi3bp1F2+bNmwkLC8PW1tbc9umnnzJp0iTi4uIICwuziO/cuTPJyckWbQMHDiQoKIhRo0ah1WqJiIgocu9P165diYiIYODAgcWOzd7eHnt7+3snLoQQQohqodSXukaMGEFERARhYWG0a9eOefPmkZKSQmRkJFB4FuX8+fMsXrwYgMjISGJjYxkxYgSDBg0iMTGRBQsWsHTpUvM+Y2JiGDt2LEuWLCEgIMB8hsjFxQUXFxdcXV0JDg62GIezszOenp7mdk9PzyJnkGxtbfH19aVp06alTVMIIYQQ1VCpC5++ffuSlZXFxIkTSUtLIzg4mI0bN9KgQQMA0tLSLNb0CQwMZOPGjQwfPpyZM2dSt25dZsyYQe/evc0xs2bNQq/X06dPH4tjjRs3jvHjx5cxNSGEEEIISxp1605jQXZ2NrVq1SI1NRU3NzdrD0cIIYQQJZCTk0P9+vW5evUq7u7ud40t01Nd1VVubi4A9evXt/JIhBBCCFFaubm59yx85IzPbUwmExcuXMDV1bXEj8SX1K1qVM4mlS+Z54oh81xxZK4rhsxzxSiveVZKkZubS926dbGxufsD63LG5zY2NjbUq1evXI/h5uYmf6kqgMxzxZB5rjgy1xVD5rlilMc83+tMzy1leju7EEIIIURVJIWPEEIIIWoMKXwqiL29PePGjZMFE8uZzHPFkHmuODLXFUPmuWJUhnmWm5uFEEIIUWPIGR8hhBBC1BhS+AghhBCixpDCRwghhBA1hhQ+QgghhKgxpPApoytXrhAREYG7uzvu7u5ERERw9erVu/ZRSjF+/Hjq1q2Lo6MjTzzxBEeOHLGImTdvHk888QRubm5oNJpi91mWY1dV5TXP+fn5/OMf/8DLywtnZ2eeffZZzp07ZxFz8uRJevbsiZeXF25ubjz++ONs27btfqdYKVhzngE2bNhAmzZtcHR0xMvLi169et3P9CoNa8/zrdhHHnkEjUbDwYMH71NmlYu15vnMmTO8/vrrBAYG4ujoyIMPPsi4cePQ6/XlkaZVzJo1i8DAQBwcHAgNDWXnzp13jd+xYwehoaE4ODjQsGFD5syZUyRm1apVNG/eHHt7e5o3b8633377p497V0qUSbdu3VRwcLBKSEhQCQkJKjg4WPXo0eOufaZMmaJcXV3VqlWrVHJysurbt6/y8/NTOTk55php06ap6OhoFR0drQB15cqV+3Lsqqq85jkyMlL5+/ur+Ph4tX//fvXkk0+qli1bKoPBYI5p1KiReuqpp9ShQ4fUyZMn1dtvv62cnJxUWlpaueVrLdac55UrVyoPDw81e/ZsdeLECXX8+HG1YsWKcsvVmqw5z7e88847qnv37gpQBw4cuN8pVgrWmufvvvtODRgwQMXFxanffvtN/fe//1Xe3t7q3XffLdd8K8qyZcuUra2tmj9/vjp69KgaOnSocnZ2VmfPni02/tSpU8rJyUkNHTpUHT16VM2fP1/Z2tqqlStXmmMSEhKUVqtVkydPVseOHVOTJ09WOp1O7dmzp8zHvRcpfMrg6NGjCrD4F5OYmKgAdfz48WL7mEwm5evrq6ZMmWJuy8vLU+7u7mrOnDlF4rdt21Zs4VOWY1dV5TXPV69eVba2tmrZsmXmmPPnzysbGxu1adMmpZRSly5dUoD64YcfzDE5OTkKUFu2bLmveVqbNee5oKBA+fv7qy+//LI8UqtUrDnPt2zcuFEFBQWpI0eOVNvCpzLM8+1iYmJUYGDgn02rUmjdurWKjIy0aAsKClJRUVHFxr/33nsqKCjIou3NN99Ubdu2NW//7W9/U926dbOI6dq1q+rXr1+Zj3svcqmrDBITE3F3d6dNmzbmtrZt2+Lu7k5CQkKxfU6fPk16ejrh4eHmNnt7ezp27HjHPvfr2FVVec1zUlISBQUFFjF169YlODjYHOPp6UmzZs1YvHgx169fx2AwMHfuXHx8fAgNDS2PdK3GmvO8f/9+zp8/j42NDa1atcLPz4/u3bsXucRQHVhzngEuXrzIoEGD+Prrr3Fycrrf6VUa1p7nP8rOzqZ27dp/Ni2r0+v1JCUlWeQPEB4efsf8ExMTi8R37dqVffv2UVBQcNeYW/ssy3HvRQqfMkhPT8fb27tIu7e3N+np6XfsA+Dj42PR7uPjc8c+9+vYVVV5zXN6ejp2dnZ4eHjcMUaj0RAfH8+BAwdwdXXFwcGBadOmsWnTJmrVqvVnU6tUrDnPp06dAmD8+PF88MEHrF+/Hg8PDzp27Mjly5f/XGKVjDXnWSnFgAEDiIyMJCws7E/nUplZc57/6LfffuOLL74gMjKy1HlUNpmZmRiNxlL9hqWnpxcbbzAYyMzMvGvMrX2W5bj3IoXPbcaPH49Go7nrZ9++fUDhD+MfKaWKbb/dH78vSZ977aOs+7GWyjrPt8copXj77bfx9vZm586d/PTTT/Ts2ZMePXqQlpZWmnStpirMs8lkAuD999+nd+/ehIaGsnDhQjQaDStWrChxrtZUFeb5iy++ICcnh9GjR5cmtUqlKszz7S5cuEC3bt144YUXeOONN+6VXpVR2jkqLv6P7SXZ5/347bxFV6Ze1dSQIUPo16/fXWMCAgL4+eefuXjxYpHvLl26VKQqvcXX1xcorG79/PzM7RkZGXfsc6f9lPbYlY2159nX1xe9Xs+VK1cs/u8tIyODxx57DICtW7eyfv16rly5gpubG1D4VEF8fDyLFi0iKiqqFBlbR1WY51t9mzdvbv7e3t6ehg0bkpKSUpI0ra4qzPPWrVvZs2dPkfcjhYWF8dJLL7Fo0aISZGpdVWGeb7lw4QJPPvkk7dq1Y968eSVLsJLz8vJCq9UWOctyt98wX1/fYuN1Oh2enp53jbm1z7Ic957KdGdQDXfr5rkff/zR3LZnz54S3Tz3ySefmNvy8/PLfHNzaY5dVZXXPN+6SXH58uXmmAsXLljcpLh27VplY2OjcnNzLfbfpEkT9fHHH9+3HCsDa85zdna2sre3t7i5Wa/XK29vbzV37tz7mqe1WXOez549q5KTk82fuLg4BaiVK1eq1NTU8kjXaqw5z0opde7cOdW4cWPVr1+/Yp+qq8pat26t3nrrLYu2Zs2a3fXm5mbNmlm0RUZGFrm5uXv37hYx3bp1K3Jzc2mOey9S+JRRt27dVIsWLVRiYqJKTExUDz/8cJHHJZs2bapWr15t3p4yZYpyd3dXq1evVsnJyap///5FHpdMS0tTBw4cUPPnzzc/VXTgwAGVlZVVqmNXF+U1z5GRkapevXpqy5Ytav/+/apTp04Wj6VeunRJeXp6ql69eqmDBw+qEydOqH/+85/K1tZWHTx4sGKSr0DWmmellBo6dKjy9/dXcXFx6vjx4+r1119X3t7e6vLly+WfeAWz5jzf7vTp09X2qS6lrDfP58+fV40aNVKdOnVS586dU2lpaeZPdXDrsfIFCxaoo0ePqmHDhilnZ2d15swZpZRSUVFRKiIiwhx/63H24cOHq6NHj6oFCxYUeZx99+7dSqvVqilTpqhjx46pKVOm3PFx9jsdt7Sk8CmjrKws9dJLLylXV1fl6uqqXnrppSJnZwC1cOFC87bJZFLjxo1Tvr6+yt7eXnXo0EElJydb9Bk3bpwCinxu309Jjl1dlNc837x5Uw0ZMkTVrl1bOTo6qh49eqiUlBSLmL1796rw8HBVu3Zt5erqqtq2bas2btxYXqlalTXnWa/Xq3fffVd5e3srV1dX1aVLF3X48OHyStWqrDnPt6vuhY+15nnhwoXF/ve7Ol1cmTlzpmrQoIGys7NTISEhaseOHebvXn31VdWxY0eL+O3bt6tWrVopOzs7FRAQoGbPnl1knytWrFBNmzZVtra2KigoSK1atapUxy0tjVK/32kkhBBCCFHNyVNdQgghhKgxpPARQgghRI0hhY8QQgghagwpfIQQQghRY0jhI4QQQogaQwofIYQQQtQYUvgIIYQQosaQwkcIIYQQNYYUPkIIIYSoMaTwEUIIIUSNIYWPEEIIIWoMKXyEEEIIUWP8P41CP/SBb3wpAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "theta_0 = -0.01\n", + "v_max = -theta_0\n", + "f0 = 1-norm.cdf(z_crit - theta_0)\n", + "df0 = norm.pdf(z_crit - theta_0) \n", + "vs = np.linspace(0, v_max, n_steps)\n", + "run(\n", + " theta_0=theta_0,\n", + " f0=f0,\n", + " df0=df0,\n", + " vs=vs,\n", + " alpha=alpha,\n", + " z_crit=z_crit,\n", + " hp=np.arange(1.01, 10, 0.01),\n", + " hc=['opt'],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As before, clearly the best centered Holder occurs when the centering is small (close to 0).\n", + "Removing the others shows:" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "alpha = 0.3\n", + "z_crit = norm.ppf(1-alpha)\n", + "f0 = 1-norm.cdf(z_crit - theta_0)\n", + "df0 = norm.pdf(z_crit - theta_0) \n", + "run(\n", + " theta_0=theta_0,\n", + " f0=f0,\n", + " df0=df0,\n", + " vs=vs,\n", + " alpha=alpha,\n", + " z_crit=z_crit,\n", + " hp=np.arange(1.01, 10, 0.01),\n", + " hc=['opt'],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Amazing! Exponential Holder and Taylor are literally right on the true Type I Error whereas the centered Holder performs much worse." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Final Remarks\n", + "\n", + "- Taylor bound is surprisingly accurate for this example. This is largely due to the fact that the Taylor bound simplifies very nicely to a simple formula with few boundings necessary. It is partly a consequence that estimating $\\theta$ is independent of $\\sigma$, i.e. $\\sigma$ is really a nuisance parameter. Things may look different with curved Gaussian when $\\theta$ also governs the variance parameter. This is a good approximation of a test with Binomial data since with large enough sample size, Binomial is approximately Gaussian with mean $np$ and variannce $np(1-p)$ where $p = expit(\\theta)$.\n", + "\n", + "- Exponential Holder bound is also surprisingly accurate.\n", + "Especially when the Type I Error is large, it's surprising that it is robust.\n", + "Moreover, it beats Taylor with large enough tile size!\n", + "So, in some sense, it has more potential of being tighter to the true Type I Error.\n", + "\n", + "- Centered Holder bound is very accurate in some regions, but I want to argue that it's not doing so well in cases that we care about.\n", + "When Type I Error is large, that's when we would like to be tightest, if possible.\n", + "When Type I Error is small, we have more budget to be wrong.\n", + "The above shows that centered Holder does extremely well with _large_ tile-size when Type I Error is low at $\\theta_0$.\n", + "But within small regions around $\\theta_0$,\n", + "which is the typical use-case when we construct grid-points,\n", + "it's doing worse than exponential Holder/Taylor.\n", + "And at large Type I Error at $\\theta_0$, it does worse than exponential Holder/Taylor." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 ('confirm')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.6" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "5d574717a19d12573763700bcd6833eaae2108879723021a1c549979ef70be90" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/research/q-holder-bound/tight_holder_gaussian.md b/research/q-holder-bound/tight_holder_gaussian.md new file mode 100644 index 00000000..8779ffe9 --- /dev/null +++ b/research/q-holder-bound/tight_holder_gaussian.md @@ -0,0 +1,400 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.13.8 + kernelspec: + display_name: Python 3.10.6 ('confirm') + language: python + name: python3 +--- + +# Exponential Holder Bound + +```python +import jax +import numpy as np +import scipy +from scipy.stats import norm, beta +import matplotlib.pyplot as plt +``` + +This notebook studies the behavior of the "exponential Hölder bound". +Let us consider the simple z-test: +\begin{align*} + X &\sim N(\theta, 1) \\ + H_0: \theta \leq 0 &\quad H_1: \theta > 0 +\end{align*} +with $\sigma$ known. + +The most powerful test is the usual one given by $\phi(x) = 1$ if $x > z_{1-\alpha}$, +where $z_{1-\alpha}$ is the $1-\alpha$ quantile of the standard normal distribution. +Then, the Type I Error function is +\begin{align*} + f(\theta) &:= 1-\Phi\left(z_{1-\alpha}-\theta\right) \\ + \nabla f(\theta) &= \phi\left(z_{1-\alpha}-\theta\right) +\end{align*} +where $\theta$ is the natural parameter +and $\Phi(\theta), \phi(\theta)$ are the CDF, PDF of thise standard normal distribution, respectively. + +We will compare this new bound with the other bounds developed previously. + + +The following are general helper functions that will be used throughout the notebook. + +```python +def simulate(theta_0, n_sims, alpha): + ''' + Simulates the model described above n_sims times under theta_0 + and computes the Type I sum and score with optimal threshold + at level alpha. + ''' + xs = np.random.normal(theta_0, 1, n_sims) + z_crit = norm.ppf(1 - alpha) + rejs = xs > z_crit + typeI_sum = np.sum(rejs) + typeI_score = np.sum((xs - theta_0) * rejs) + return typeI_sum, typeI_score +``` + +## Taylor Bound + + +The first upper bound we revisit is the Taylor bound. +The Taylor bound is given by +\begin{align*} + f(\theta_0 + v) + &\leq + f(\theta_0) + \nabla f(\theta_0) v + U_R(v) +\end{align*} +where +\begin{align*} + \int_0^1 (1-\alpha) \frac{d^2}{d\theta^2} f(\theta_0+\alpha v) v^2 d\alpha \leq U_R(v) +\end{align*} +for some convex function $U_R$. +By Lemma 9 in the draft of paper, we may take +\begin{align*} + U_R(v) = \frac{1}{2} v^2 +\end{align*} + + +The empirical upper bound estimate must take into account the randomness of our zeroth and first order terms. +The empirical upper bound is given by: +\begin{align*} + \hat{U}(\theta_0+v) + &= + \hat{U}_0 + \hat{\Delta}(v) + U_R(v) + \\ + \hat{\Delta}(v) + &= + \frac{1}{N} \sum\limits_{i=1}^N (X_i-\theta_0) F(X_i)v + + \frac{1}{2} \sqrt{\frac{v^2}{N} \left(\frac{1}{\delta_2} - 1 \right)} +\end{align*} +where $\hat{U}_0$ is the Clopper-Pearson estimate at $\theta_0$ with confidence $1-\delta_1$, +$F(x)$ is the indicator that the test falsely rejects with data $x$ generated from $\theta_0$, +and $N$ is the number of simulations. + +```python +def taylor_bound(f0, df0, vs): + ''' + Computes the Taylor upper bound with true Type I Error and its gradient. + ''' + return f0 + df0 * vs + (1 / 2) * vs**2 + +def taylor_bound_est(typeI_sum, typeI_score, nsims, vs, delta=0.025, delta_prop_0to1=0.5): + ''' + Computes the Taylor upper bound with estimates and accounting for their error. + ''' + f0 = beta.ppf(1 - (delta * delta_prop_0to1), typeI_sum + 1, nsims - typeI_sum) + + grad_est = typeI_score / nsims * vs + covars = vs**2 + grad_bound = 0.5 * np.sqrt(covars / nsims * (1 / ((1 - delta_prop_0to1) * delta) - 1)) + + hess_bound = covars / 2 + + return f0 + (grad_est + grad_bound) + hess_bound +``` + +## Hölder Bound (Centered) + + +The centered Hölder bound centered by $c$ with conjugates $p, q \geq 1$ is given by +\begin{align*} + f(\theta_0 + v) + &\leq + \frac{1}{A} \left(\frac{A C_q}{q} + (A f(\theta_0) + B)^{\frac{1}{q}}\right)^q - \frac{B}{A} + \\ + C_q + &:= + \sup\limits_{v \in H-\theta_0} \int_0^1 || \frac{d}{dh} \log p_{\theta_0+hv}(X)||_{L^q(P_{\theta_0+hv})} dh + \\ + p &:= \frac{q}{q-1} \\ + A &:= (1-c)^p - c^p \\ + B &:= c^p +\end{align*} + +We simplify $C_q$. +\begin{align*} + \log p_{\theta}(x) &= - \frac{(x-\theta)^2}{2} + C + \\ \implies + \frac{d}{dh} \log p_{\theta_0+hv}(x) + &= + (x-(\theta_0+hv))v + \\ \implies + ||\frac{d}{dh} \log p_{\theta_0+hv}(X)||_{L^q} + &= + |v| \cdot \mathbb{E}\left[|Z|^q \right]^\frac{1}{q} +\end{align*} +By simple calculus, one can show +\begin{align*} + ||Z||_{L^q} + &= + \sqrt{2} \left(\frac{\Gamma\left(\frac{q+1}{2}\right)}{\sqrt{\pi}}\right)^{\frac{1}{q}} +\end{align*} +Hence, +\begin{align*} + C_q = ||Z||_{L^q} \sup\limits_{v \in H-\theta_0} |v| +\end{align*} + +Finally, we have the following as the optimal choice for the centering +\begin{align*} + c^* := \frac{1}{1 + \left(\frac{1-f(\theta_0)}{f(\theta_0)}\right)^{\frac{1}{p-1}}} +\end{align*} + +```python +def z_lq(q): + frac = scipy.special.gamma((q+1)/2) / np.sqrt(np.pi) + return np.sqrt(2) * frac**(1/q) + +def C_q(vs, q): + return z_lq(q) * vs + +def copt(f0, p): + return 1/(1 + ((1-f0) / f0)**(1/(p-1))) + +def holder_bound(f0, vs, hp, hc='opt'): + if isinstance(hp, list) or isinstance(hp, np.ndarray): + bounds = np.array([holder_bound(f0, vs, hpp, hc) for hpp in hp]) + return np.min(bounds, axis=0) + if hc == 'opt': + hc = copt(f0, hp) + hq = 1 / (1 - 1 / hp) + B = hc**hp + A = (1-hc)**hp - B + C = C_q(vs, hq) + return 1/A * (A*C/hq + (A*f0 + B)**(1/hq))**hq - B/A +``` + +## Exponential Hölder Bound + + +The exponential Hölder bound is given by +\begin{align*} +f(\theta_0 + v) +&\leq +1 - (1-f(\theta_0)) \exp\left[-\frac{\nabla f(\theta_0)^\top v}{1-f(\theta_0)} - S(v)\right] +\end{align*} +where +\begin{align*} +S(v) := A(\theta_0+v) - A(\theta_0) - \nabla A(\theta_0)^\top v +\end{align*} +and $A$ is the log-partition function. +In the Gaussian data case, +\begin{align*} +A(\theta) := \frac{\theta^2}{2} +\end{align*} +This gives us +\begin{align*} +S(v) +&= \frac{1}{2} \left((\theta_0+v)^2 - \theta_0^2\right) - \theta_0 v += \frac{v (2\theta_0+v)}{2} - \theta_0 v += \frac{v^2}{2} +\end{align*} + +```python +def exp_holder_bound(f0, df0, vs): + f0c = 1 - f0 + Svs = vs**2 / 2 + expos = df0 * vs / f0c + Svs + return 1 - f0c * np.exp(-expos) +``` + +## Exponential Holder Improved? + +```python +def exp_holder_impr_bound(f0, vs): + return np.exp(-0.5 * (vs - np.sqrt(-2*np.log(f0)))**2) +``` + +## Performance Comparison + +```python +theta_0 = -1 +v_max = 1 +n_steps = 20 +alpha = 0.1 +``` + +```python +z_crit = norm.ppf(1-alpha) +f0 = 1-norm.cdf(z_crit - theta_0) +df0 = norm.pdf(z_crit - theta_0) +vs = np.linspace(0, v_max, n_steps) +``` + +```python +def run(theta_0, f0, df0, vs, alpha, z_crit, hp, hc): + # compute true Type I Error + thetas = theta_0 + vs + fs = 1-norm.cdf(z_crit - thetas) + + # compute taylor bound + taylor_bounds = taylor_bound(f0, df0, vs) + + # compute holder centered bound + holder_bounds = [holder_bound(f0, vs, hp, c) for c in hc] + + # compute exp holder bound + exp_holder_bounds = exp_holder_bound(f0, df0, vs) + + # compute exp holder impr bound + exp_holder_impr_bounds = exp_holder_impr_bound(f0, vs) + + # plot everything + plt.plot(thetas, fs, ls='--', color='black', label='True TIE') + plt.plot(thetas, taylor_bounds, ls='-', label='taylor') + for i, c in enumerate(hc): + plt.plot(thetas, holder_bounds[i], ls='--', label=f'centered-holder({c})') + plt.plot(thetas, exp_holder_bounds, ls='-.', label='exp-holder') + plt.plot(thetas, exp_holder_impr_bounds, ls=':', label='exp-holder-impr') + plt.legend() + plt.show() +``` + +We first compare the performance of all the methods with various centering for centered-Holder method. +Since exponential Holder bound is inherently a Cauchy-Schwarz bound, +we first compare with $p = 2$ for centered-Holder. + +```python +run( + theta_0=theta_0, + f0=f0, + df0=df0, + vs=vs, + alpha=alpha, + z_crit=z_crit, + hp=[1.1, 1.15, 1.2, 1.25, 1.3, 1.35], + hc=['opt'], +) +``` + +We see that from $\theta_0$ (leftmost point), if we increase the tile size all the way until it hits the origin +(boundary of the null hypothesis), the exponential Holder bound does far worse than the centered Holder bound. +However, it is still uniformly better than the classical Taylor bound. + +Zooming in on a smaller region around $\theta_0$, we get the following: + +```python +v_max = 0.01 +vs = np.linspace(0, v_max, n_steps) +run( + theta_0=theta_0, + f0=f0, + df0=df0, + vs=vs, + alpha=alpha, + z_crit=z_crit, + hp=np.arange(1.01, 10, 0.01), + hc=['opt'], +) +``` + +Now we see that the exponential Holder is actually performing better than the optimally centered Holder method with $p=2$ +in a smaller region around $\theta_0$. +Moreover, the Taylor expansion is nearly identical to the exponential Holder. + +From a previous study, $p=1.2$ gave a good estimate for an improved bound for the centered Holder method. +The following shows the bound with $p=1.2$. + +```python +run( + theta_0=theta_0, + f0=f0, + df0=df0, + vs=vs, + alpha=alpha, + z_crit=z_crit, + hp=np.arange(1.01, 10, 0.01), + hc=['opt'], +) +``` + +The centered Holder bound is asymptotically performing better than the exponential Holder bound and Taylor bound. +However, for tile size of about $0.003$ (the usual gridding radius we consider in practice), +the two are nearly indistinguishable. + + +Now, we consider what happens when $\theta_0$ is closer to the boundary (when Type I Error at the simulation point is larger). + +```python +theta_0 = -0.01 +v_max = -theta_0 +f0 = 1-norm.cdf(z_crit - theta_0) +df0 = norm.pdf(z_crit - theta_0) +vs = np.linspace(0, v_max, n_steps) +run( + theta_0=theta_0, + f0=f0, + df0=df0, + vs=vs, + alpha=alpha, + z_crit=z_crit, + hp=np.arange(1.01, 10, 0.01), + hc=['opt'], +) +``` + +As before, clearly the best centered Holder occurs when the centering is small (close to 0). +Removing the others shows: + +```python +alpha = 0.3 +z_crit = norm.ppf(1-alpha) +f0 = 1-norm.cdf(z_crit - theta_0) +df0 = norm.pdf(z_crit - theta_0) +run( + theta_0=theta_0, + f0=f0, + df0=df0, + vs=vs, + alpha=alpha, + z_crit=z_crit, + hp=np.arange(1.01, 10, 0.01), + hc=['opt'], +) +``` + +Amazing! Exponential Holder and Taylor are literally right on the true Type I Error whereas the centered Holder performs much worse. + + +### Final Remarks + +- Taylor bound is surprisingly accurate for this example. This is largely due to the fact that the Taylor bound simplifies very nicely to a simple formula with few boundings necessary. It is partly a consequence that estimating $\theta$ is independent of $\sigma$, i.e. $\sigma$ is really a nuisance parameter. Things may look different with curved Gaussian when $\theta$ also governs the variance parameter. This is a good approximation of a test with Binomial data since with large enough sample size, Binomial is approximately Gaussian with mean $np$ and variannce $np(1-p)$ where $p = expit(\theta)$. + +- Exponential Holder bound is also surprisingly accurate. +Especially when the Type I Error is large, it's surprising that it is robust. +Moreover, it beats Taylor with large enough tile size! +So, in some sense, it has more potential of being tighter to the true Type I Error. + +- Centered Holder bound is very accurate in some regions, but I want to argue that it's not doing so well in cases that we care about. +When Type I Error is large, that's when we would like to be tightest, if possible. +When Type I Error is small, we have more budget to be wrong. +The above shows that centered Holder does extremely well with _large_ tile-size when Type I Error is low at $\theta_0$. +But within small regions around $\theta_0$, +which is the typical use-case when we construct grid-points, +it's doing worse than exponential Holder/Taylor. +And at large Type I Error at $\theta_0$, it does worse than exponential Holder/Taylor.